/*
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
 *			Copyright (c) Telecom ParisTech 2000-2012
 *					All rights reserved
 *
 *  This file is part of GPAC / MPEG-4 ObjectDescriptor sub-project
 *
 *  GPAC is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  GPAC is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <gpac/internal/odf_dev.h>

/************************************************************
		Object GF_Descriptor Codec Functions
************************************************************/

GF_EXPORT
GF_ODCodec *gf_odf_codec_new()
{
	GF_ODCodec *codec;
	GF_List *comList;

	comList = gf_list_new();
	if (!comList) return NULL;

	codec = (GF_ODCodec *) gf_malloc(sizeof(GF_ODCodec));
	if (!codec) {
		gf_list_del(comList);
		return NULL;
	}
	//the bitstream is always NULL. It is created on the fly for access unit processing only
	codec->bs = NULL;
	codec->CommandList = comList;
	return codec;
}

GF_EXPORT
void gf_odf_codec_del(GF_ODCodec *codec)
{
	if (!codec) return;

	while (gf_list_count(codec->CommandList)) {
		GF_ODCom *com = (GF_ODCom *)gf_list_get(codec->CommandList, 0);
		gf_odf_delete_command(com);
		gf_list_rem(codec->CommandList, 0);
	}
	gf_list_del(codec->CommandList);
	if (codec->bs) gf_bs_del(codec->bs);
	gf_free(codec);
}


/************************************************************
		Codec Encoder Functions
************************************************************/

GF_EXPORT
GF_Err gf_odf_codec_add_com(GF_ODCodec *codec, GF_ODCom *command)
{
	if (!codec || !command) return GF_BAD_PARAM;
	return gf_list_add(codec->CommandList, command);
}

GF_EXPORT
GF_Err gf_odf_codec_encode(GF_ODCodec *codec, u32 cleanup_type)
{
	GF_ODCom *com;
	GF_Err e = GF_OK;
	u32 i;

	if (!codec) return GF_BAD_PARAM;

	//check our bitstream: if existing, this means the previous encoded AU was not retrieved
	//we DON'T allow that
	if (codec->bs) return GF_BAD_PARAM;
	codec->bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
	if (!codec->bs) return GF_OUT_OF_MEM;

	/*encode each command*/
	i = 0;
	while ((com = (GF_ODCom *)gf_list_enum(codec->CommandList, &i))) {
		e = gf_odf_write_command(codec->bs, com);
		if (e) goto err_exit;
		//don't forget OD Commands are aligned...
		gf_bs_align(codec->bs);
	}

//if an error occurs, delete the GF_BitStream and empty the codec
err_exit:
	if (e) {
		gf_bs_del(codec->bs);
		codec->bs = NULL;
	}
	if (cleanup_type==1) {
		while (gf_list_count(codec->CommandList)) {
			com = (GF_ODCom *)gf_list_get(codec->CommandList, 0);
			gf_odf_delete_command(com);
			gf_list_rem(codec->CommandList, 0);
		}
	}
	if (cleanup_type==0) {
		gf_list_reset(codec->CommandList);
	}
	return e;
}

GF_EXPORT
GF_Err gf_odf_codec_get_au(GF_ODCodec *codec, u8 **outAU, u32 *au_length)
{
	if (!codec || !codec->bs || !outAU || *outAU) return GF_BAD_PARAM;
	gf_bs_get_content(codec->bs, outAU, au_length);
	gf_bs_del(codec->bs);
	codec->bs = NULL;
	return GF_OK;
}



/************************************************************
		Codec Decoder Functions
************************************************************/

GF_EXPORT
GF_Err gf_odf_codec_set_au(GF_ODCodec *codec, const u8 *au, u32 au_length)
{
	if (!codec ) return GF_BAD_PARAM;
	if (!au || !au_length) return GF_OK;

	//if the command list is not empty, this is an error
	if (gf_list_count(codec->CommandList)) return GF_BAD_PARAM;

	//the bitStream should not be here
	if (codec->bs) return GF_BAD_PARAM;

	codec->bs = gf_bs_new(au, (u64) au_length, (unsigned char)GF_BITSTREAM_READ);
	if (!codec->bs) return GF_OUT_OF_MEM;
	return GF_OK;
}


GF_EXPORT
GF_Err gf_odf_codec_decode(GF_ODCodec *codec)
{
	GF_Err e = GF_OK;
	u32 size = 0, comSize, bufSize;
	GF_ODCom *com;

	if (!codec || !codec->bs) return GF_BAD_PARAM;

	bufSize = (u32) gf_bs_available(codec->bs);
	while (size < bufSize) {
		e =	gf_odf_parse_command(codec->bs, &com, &comSize);
		if (e) goto err_exit;
		gf_list_add(codec->CommandList, com);
		size += comSize + gf_odf_size_field_size(comSize);
		//OD Commands are aligned
		gf_bs_align(codec->bs);
	}
	//then delete our bitstream
	gf_bs_del(codec->bs);
	codec->bs = NULL;
	if (size != bufSize) {
		e = GF_ODF_INVALID_COMMAND;
		goto err_exit;
	}
	return e;

err_exit:
	if (codec->bs) {
		gf_bs_del(codec->bs);
		codec->bs = NULL;
	}
	while (gf_list_count(codec->CommandList)) {
		com = (GF_ODCom*)gf_list_get(codec->CommandList, 0);
		gf_odf_delete_command(com);
		gf_list_rem(codec->CommandList, 0);
	}
	return e;
}

//get the first command in the codec and remove the entry
GF_EXPORT
GF_ODCom *gf_odf_codec_get_com(GF_ODCodec *codec)
{
	GF_ODCom *com;
	if (!codec || codec->bs) return NULL;
	com = (GF_ODCom*)gf_list_get(codec->CommandList, 0);
	if (com) gf_list_rem(codec->CommandList, 0);
	return com;
}



/************************************************************
		OD Commands Functions
************************************************************/

//some easy way to get an OD GF_ODCom...
GF_EXPORT
GF_ODCom *gf_odf_com_new(u8 tag)
{
	GF_ODCom *newcom;

	newcom = gf_odf_create_command(tag);
	newcom->tag = tag;
	return (GF_ODCom *)newcom;
}

//	... and to delete it
GF_EXPORT
GF_Err gf_odf_com_del(GF_ODCom **com)
{
	GF_Err e;
	e = gf_odf_delete_command(*com);
	*com = NULL;
	return e;
}


/************************************************************
		Object Descriptors Functions
************************************************************/

//some easy way to get an mpeg4 descriptor ...
GF_EXPORT
GF_Descriptor *gf_odf_desc_new(u8 tag)
{
	GF_Descriptor *newdesc;
	newdesc = gf_odf_create_descriptor(tag);
	newdesc->tag = tag;
	return (GF_Descriptor *)newdesc;
}

//	... and to delete it
GF_EXPORT
void gf_odf_desc_del(GF_Descriptor *desc)
{
	if (desc) gf_odf_delete_descriptor(desc);
}

//this functions will destroy the descriptors in a list but not the list
GF_EXPORT
GF_Err gf_odf_desc_list_del(GF_List *descList)
{
	GF_Err e;

	if (! descList) return GF_BAD_PARAM;

	while (gf_list_count(descList)) {
		GF_Descriptor *tmp = (GF_Descriptor*)gf_list_get(descList, 0);
		gf_list_rem(descList, 0);
		e = gf_odf_delete_descriptor(tmp);
		if (e) return e;
	}
	return GF_OK;
}



GF_EXPORT
GF_ESD *gf_odf_desc_esd_new(u32 sl_predefined)
{
	GF_ESD *esd;
	esd = (GF_ESD *) gf_odf_desc_new(GF_ODF_ESD_TAG);
	esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
	esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
	esd->slConfig = (GF_SLConfig *) gf_odf_new_slc((u8) sl_predefined);
	return esd;
}


//use this function to decode a standalone descriptor
//the desc MUST be formatted with tag and size field!!!
GF_EXPORT
GF_Err gf_odf_desc_read(u8 *raw_desc, u32 descSize, GF_Descriptor **outDesc)
{
	GF_Err e;
	u32 size;
	GF_BitStream *bs;
	if (!raw_desc || !descSize) return GF_BAD_PARAM;

	bs = gf_bs_new(raw_desc, (u64) descSize, GF_BITSTREAM_READ);
	if (!bs) return GF_OUT_OF_MEM;

	size = 0;
	e = gf_odf_parse_descriptor(bs, outDesc, &size);
	//the size dosn't have the header in it
	size += gf_odf_size_field_size(size);
	/*
		if (size != descSize) {
			if (*outDesc) gf_odf_delete_descriptor(*outDesc);
			*outDesc = NULL;
			e = GF_ODF_INVALID_DESCRIPTOR;
		}
	*/

	gf_bs_del(bs);
	return e;
}

//use this function to encode a standalone descriptor
//the desc will be formatted with tag and size field
GF_EXPORT
GF_Err gf_odf_desc_write_bs(GF_Descriptor *desc, GF_BitStream *bs)
{
	GF_Err e;
	if (!desc || !bs) return GF_BAD_PARAM;

	//then encode our desc...
	e = gf_odf_write_descriptor(bs, desc);
	if (e) return e;
	
	return GF_OK;
}

GF_EXPORT
GF_Err gf_odf_desc_write(GF_Descriptor *desc, u8 **outEncDesc, u32 *outSize)
{
	GF_Err e;
	GF_BitStream *bs;
	if (!desc || !outEncDesc || !outSize) return GF_BAD_PARAM;
	*outEncDesc = NULL;
	*outSize = 0;

	bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
	if (!bs) return GF_OUT_OF_MEM;

	e = gf_odf_desc_write_bs(desc, bs);
	
	//then get the content from our bitstream
	gf_bs_get_content(bs, outEncDesc, outSize);
	gf_bs_del(bs);
	return e;
}


//use this function to get the size of a standalone descriptor
GF_EXPORT
u32 gf_odf_desc_size(GF_Descriptor *desc)
{
	u32 descSize;
	GF_Err e;

	if (!desc) return GF_BAD_PARAM;
	//get the descriptor length
	e = gf_odf_size_descriptor(desc, &descSize);
	if (e) return 0;
	//add the header length
	descSize += gf_odf_size_field_size(descSize);
	return descSize;

}

//this is useful to duplicate on the fly a descriptor (mainly for authoring purposes)
GF_EXPORT
GF_Err gf_odf_desc_copy(GF_Descriptor *inDesc, GF_Descriptor **outDesc)
{
	GF_Err e;
	u8 *desc;
	u32 size, oti=0;

	//patch for esd copy, we now signal codecid (32 bit) in OTI (8 bits)
	if (inDesc->tag == GF_ODF_ESD_TAG) {
		GF_ESD *esd = (GF_ESD *)inDesc;
		if (esd->decoderConfig) {
			oti = esd->decoderConfig->objectTypeIndication;
			esd->decoderConfig->objectTypeIndication = 0;
		}
	}

	//warning: here we get some data allocated
	e = gf_odf_desc_write(inDesc, &desc, &size);
	if (e) return e;
	e = gf_odf_desc_read(desc, size, outDesc);
	gf_free(desc);
	if (oti && !e) {
		GF_ESD *esd = (GF_ESD *)inDesc;
		GF_ESD *out_esd = (GF_ESD *)*outDesc;
		if (esd->decoderConfig) esd->decoderConfig->objectTypeIndication = oti;
		if (out_esd->decoderConfig) out_esd->decoderConfig->objectTypeIndication = oti;
	}
	return e;
}

/************************************************************
		Object Descriptors Edit Functions
************************************************************/

//This functions handles internally what desc can be added to another desc
//and adds it. NO DUPLICATION of the descriptor, so
//once a desc is added to its parent, destroying the parent WILL destroy this desc
GF_EXPORT
GF_Err gf_odf_desc_add_desc(GF_Descriptor *parentDesc, GF_Descriptor *newDesc)
{
	GF_DecoderConfig *dcd;

	//our ADD definition
	GF_Err AddDescriptorToOD(GF_ObjectDescriptor *od, GF_Descriptor *desc);
	GF_Err AddDescriptorToIOD(GF_InitialObjectDescriptor *iod, GF_Descriptor *desc);
	GF_Err AddDescriptorToESD(GF_ESD *esd, GF_Descriptor *desc);
	GF_Err AddDescriptorToIsomIOD(GF_IsomInitialObjectDescriptor *iod, GF_Descriptor *desc);
	GF_Err AddDescriptorToIsomOD(GF_IsomObjectDescriptor *od, GF_Descriptor *desc);

	if (!parentDesc || !newDesc) return GF_BAD_PARAM;

	switch (parentDesc->tag) {
	//these are container descriptors
	case GF_ODF_OD_TAG:
		return AddDescriptorToOD((GF_ObjectDescriptor *)parentDesc, newDesc);
	case GF_ODF_IOD_TAG:
		return AddDescriptorToIOD((GF_InitialObjectDescriptor *)parentDesc, newDesc);
	case GF_ODF_ESD_TAG:
		return AddDescriptorToESD((GF_ESD *)parentDesc, newDesc);
	case GF_ODF_DCD_TAG:
		dcd = (GF_DecoderConfig *)parentDesc;
		if ((newDesc->tag == GF_ODF_DSI_TAG)
		        || (newDesc->tag == GF_ODF_BIFS_CFG_TAG)
		        || (newDesc->tag == GF_ODF_UI_CFG_TAG)
		        || (newDesc->tag == GF_ODF_TEXT_CFG_TAG)
		   ) {
			if (dcd->decoderSpecificInfo) return GF_ODF_FORBIDDEN_DESCRIPTOR;
			dcd->decoderSpecificInfo = (GF_DefaultDescriptor *) newDesc;
			return GF_OK;
		} else if (newDesc->tag == GF_ODF_EXT_PL_TAG) {
			return gf_list_add(dcd->profileLevelIndicationIndexDescriptor, newDesc);
		}
		return GF_ODF_FORBIDDEN_DESCRIPTOR;

	case GF_ODF_TEXT_CFG_TAG:
		if (newDesc->tag != GF_ODF_TX3G_TAG) return GF_ODF_FORBIDDEN_DESCRIPTOR;
		return gf_list_add(((GF_TextConfig *)parentDesc)->sample_descriptions, newDesc);

	case GF_ODF_QOS_TAG:
		return GF_BAD_PARAM;

	//MP4 File Format tags
	case GF_ODF_ISOM_IOD_TAG:
		return AddDescriptorToIsomIOD((GF_IsomInitialObjectDescriptor *)parentDesc, newDesc);
	case GF_ODF_ISOM_OD_TAG:
		return AddDescriptorToIsomOD((GF_IsomObjectDescriptor *)parentDesc, newDesc);

	case GF_ODF_IPMP_TL_TAG:
		if (newDesc->tag!=GF_ODF_IPMP_TOOL_TAG) return GF_BAD_PARAM;
		return gf_list_add(((GF_IPMP_ToolList *)parentDesc)->ipmp_tools, newDesc);

	case GF_ODF_BIFS_CFG_TAG:
	{
		GF_BIFSConfig *cfg = (GF_BIFSConfig *)parentDesc;
		if (newDesc->tag!=GF_ODF_ELEM_MASK_TAG) return GF_BAD_PARAM;
		if (!cfg->elementaryMasks) cfg->elementaryMasks = gf_list_new();
		return gf_list_add(cfg->elementaryMasks, newDesc);
	}
	default:
		return GF_ODF_FORBIDDEN_DESCRIPTOR;
	}
}



/*****************************************************************************************
		Since IPMP V2, we introduce a new set of functions to read / write a list of
	descriptors that have no containers (a bit like an OD command, but for descriptors)
		This is useful for IPMPv2 DecoderSpecificInfo which contains a set of
	IPMP_Declarators.
		As it could be used for other purposes we keep it generic
	You must create the list yourself, the functions just encode/decode from/to the list

	These functions are also used in mp4 for extension descriptor in LASeR and AVC sample descriptions
*****************************************************************************************/

GF_EXPORT
GF_Err gf_odf_desc_list_read(u8 *raw_list, u32 raw_size, GF_List *descList)
{
	GF_BitStream *bs;
	u32 size, desc_size;
	GF_Descriptor *desc;
	GF_Err e = GF_OK;

	if (!descList || !raw_list || !raw_size) return GF_BAD_PARAM;

	bs = gf_bs_new(raw_list, raw_size, GF_BITSTREAM_READ);
	if (!bs) return GF_OUT_OF_MEM;

	size = 0;
	while (size < raw_size) {
		e =	gf_odf_parse_descriptor(bs, &desc, &desc_size);
		if (e) goto exit;
		gf_list_add(descList, desc);
		size += desc_size + gf_odf_size_field_size(desc_size);
	}

exit:
	//then delete our bitstream
	gf_bs_del(bs);
	if (size != raw_size) e = GF_ODF_INVALID_DESCRIPTOR;
	return e;
}


GF_EXPORT
GF_Err gf_odf_desc_list_write(GF_List *descList, u8 **outEncList, u32 *outSize)
{
	GF_BitStream *bs;
	GF_Err e;

	if (!descList || !outEncList || *outEncList || !outSize) return GF_BAD_PARAM;

	*outSize = 0;

	bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
	if (!bs) return GF_OUT_OF_MEM;

	e = gf_odf_write_descriptor_list(bs, descList);
	if (e) {
		gf_bs_del(bs);
		return e;
	}

	gf_bs_get_content(bs, outEncList, outSize);
	gf_bs_del(bs);
	return GF_OK;
}

GF_EXPORT
GF_Err gf_odf_desc_list_size(GF_List *descList, u32 *outSize)
{
	return gf_odf_size_descriptor_list(descList, outSize);
}



GF_Err gf_odf_codec_apply_com(GF_ODCodec *codec, GF_ODCom *command)
{
	GF_ODCom *com;
	GF_ODUpdate *odU, *odU_o;
	u32 i, count;
	count = gf_list_count(codec->CommandList);

	switch (command->tag) {
	case GF_ODF_OD_REMOVE_TAG:
		for (i=0; i<count; i++) {
			com = (GF_ODCom *)gf_list_get(codec->CommandList, i);
			/*process OD updates*/
			if (com->tag==GF_ODF_OD_UPDATE_TAG) {
				u32 count2, j, k;
				GF_ODRemove *odR = (GF_ODRemove *) command;
				odU = (GF_ODUpdate *)com;
				count2 = gf_list_count(odU->objectDescriptors);
				/*remove all descs*/
				for (k=0; k<count2; k++) {
					GF_ObjectDescriptor *od = (GF_ObjectDescriptor *)gf_list_get(odU->objectDescriptors, k);
					for (j=0; j<odR->NbODs; j++) {
						if (od->objectDescriptorID==odR->OD_ID[j]) {
							gf_list_rem(odU->objectDescriptors, k);
							k--;
							count2--;
							gf_odf_desc_del((GF_Descriptor *)od);
							break;
						}
					}
				}
				if (!gf_list_count(odU->objectDescriptors)) {
					gf_list_rem(codec->CommandList, i);
					i--;
					count--;
				}
			}
			/*process ESD updates*/
			else if (com->tag==GF_ODF_ESD_UPDATE_TAG) {
				u32 j;
				GF_ODRemove *odR = (GF_ODRemove *) command;
				GF_ESDUpdate *esdU = (GF_ESDUpdate*)com;
				for (j=0; j<odR->NbODs; j++) {
					if (esdU->ODID==odR->OD_ID[j]) {
						gf_list_rem(codec->CommandList, i);
						i--;
						count--;
						gf_odf_com_del((GF_ODCom**)&esdU);
						break;
					}
				}
			}
			/*process ESD remove*/
			else if (com->tag==GF_ODF_ESD_REMOVE_TAG) {
				u32 j;
				GF_ODRemove *odR = (GF_ODRemove *) command;
				GF_ESDRemove *esdR = (GF_ESDRemove*)com;
				for (j=0; j<odR->NbODs; j++) {
					if (esdR->ODID==odR->OD_ID[j]) {
						gf_list_rem(codec->CommandList, i);
						i--;
						count--;
						gf_odf_com_del((GF_ODCom**)&esdR);
						break;
					}
				}
			}
		}
		return GF_OK;
	case GF_ODF_OD_UPDATE_TAG:
		odU_o = NULL;
		for (i=0; i<count; i++) {
			odU_o = (GF_ODUpdate*)gf_list_get(codec->CommandList, i);
			/*process OD updates*/
			if (odU_o->tag==GF_ODF_OD_UPDATE_TAG) break;
			odU_o = NULL;
		}
		if (!odU_o) {
			odU_o = (GF_ODUpdate *)gf_odf_com_new(GF_ODF_OD_UPDATE_TAG);
			gf_list_add(codec->CommandList, odU_o);
		}
		odU = (GF_ODUpdate*)command;
		count = gf_list_count(odU->objectDescriptors);
		for (i=0; i<count; i++) {
			Bool found = GF_FALSE;
			GF_ObjectDescriptor *od = (GF_ObjectDescriptor *)gf_list_get(odU->objectDescriptors, i);
			u32 j, count2 = gf_list_count(odU_o->objectDescriptors);
			for (j=0; j<count2; j++) {
				GF_ObjectDescriptor *od2 = (GF_ObjectDescriptor *)gf_list_get(odU_o->objectDescriptors, j);
				if (od2->objectDescriptorID==od->objectDescriptorID) {
					found = GF_TRUE;
					break;
				}
			}
			if (!found) {
				GF_ObjectDescriptor *od_new;
				GF_Err e = gf_odf_desc_copy((GF_Descriptor*)od, (GF_Descriptor**)&od_new);
				if (e==GF_OK)
					gf_list_add(odU_o->objectDescriptors, od_new);
			}

		}
		return GF_OK;
	case GF_ODF_ESD_REMOVE_TAG:
		for (i=0; i<count; i++) {
			com = (GF_ODCom *)gf_list_get(codec->CommandList, i);
			/*process OD updates*/
			if (com->tag==GF_ODF_OD_UPDATE_TAG) {
				u32 count2, j, k, l;
				GF_ESDRemove *esdR = (GF_ESDRemove *) command;
				odU = (GF_ODUpdate *)com;
				count2 = gf_list_count(odU->objectDescriptors);
				/*remove all descs*/
				for (k=0; k<count2; k++) {
					GF_ObjectDescriptor *od = (GF_ObjectDescriptor *)gf_list_get(odU->objectDescriptors, k);
					for (j=0; j<gf_list_count(od->ESDescriptors); j++) {
						GF_ESD *esd = gf_list_get(od->ESDescriptors, j);
						for (l=0; l<esdR->NbESDs; l++) {
							if (esdR->ES_ID[l] == esd->ESID) {
								gf_list_rem(od->ESDescriptors, j);
								j--;
								gf_odf_desc_del((GF_Descriptor *)esd);
								break;
							}
						}
					}
				}
			}
			/*process ESD updates*/
			else if (com->tag==GF_ODF_ESD_UPDATE_TAG) {
				u32 j, k;
				GF_ESDRemove *esdR = (GF_ESDRemove *) command;
				GF_ESDUpdate *esdU = (GF_ESDUpdate*)com;
				for (j=0; j<gf_list_count(esdU->ESDescriptors); j++) {
					GF_ESD *esd = gf_list_get(esdU->ESDescriptors, j);
					for (k=0; k<esdR->NbESDs; k++) {
						if (esd->ESID == esdR->ES_ID[k]) {
							gf_list_rem(codec->CommandList, j);
							j--;
							gf_odf_desc_del((GF_Descriptor *)esd);
						}
					}
				}
				if (!gf_list_count(esdU->ESDescriptors)) {
					gf_list_rem(codec->CommandList, i);
					i--;
					count--;
					gf_odf_com_del((GF_ODCom**)&esdU);
				}
			}
		}
		return GF_OK;
	case GF_ODF_ESD_UPDATE_TAG:
		for (i=0; i<count; i++) {
			com = (GF_ODCom *)gf_list_get(codec->CommandList, i);
			/*process OD updates*/
			if (com->tag==GF_ODF_OD_UPDATE_TAG) {
				u32 count2, k, l;
				GF_ESDUpdate *esdU = (GF_ESDUpdate *) command;
				odU = (GF_ODUpdate *)com;
				count2 = gf_list_count(odU->objectDescriptors);
				/*remove all descs*/
				for (k=0; k<count2; k++) {
					GF_ObjectDescriptor *od = (GF_ObjectDescriptor *)gf_list_get(odU->objectDescriptors, k);
					if (od->objectDescriptorID==esdU->ODID) {
						GF_ESD *esd;
						while (gf_list_count(od->ESDescriptors)) {
							esd = gf_list_pop_back(od->ESDescriptors);
							gf_odf_desc_del((GF_Descriptor *)esd);
						}
						gf_list_transfer(od->ESDescriptors, esdU->ESDescriptors);
						l = 0;
						while ((esd = gf_list_enum(esdU->ESDescriptors, &l))) {
							GF_ESD *new_esd;
							GF_Err e = gf_odf_desc_copy((GF_Descriptor*)esd, (GF_Descriptor**)&new_esd);
							if (e==GF_OK)
								gf_list_add(od->ESDescriptors, new_esd);
						}
						break;
					}
				}
			}
			/*process ESD updates*/
			else if (com->tag==GF_ODF_ESD_UPDATE_TAG) {
				return GF_NOT_SUPPORTED;
			}
		}
		return GF_OK;
	}
	return GF_NOT_SUPPORTED;
}
