static void gf_sm_au_del(GF_StreamContext *sc, GF_AUContext *au)
{
while (gf_list_count(au->commands)) {
void *comptr = gf_list_last(au->commands);
gf_list_rem_last(au->commands);
switch (sc->streamType) {
case GF_STREAM_OD:
gf_odf_com_del((GF_ODCom**) & comptr);
break;
case GF_STREAM_SCENE:
gf_sg_command_del((GF_Command *)comptr);
break;
}
}
gf_list_del(au->commands);
gf_free(au);
}
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 count, j, k;
GF_ODRemove *odR = (GF_ODRemove *)command;
odU = (GF_ODUpdate *)com;
count = gf_list_count(odU->objectDescriptors);
/*remove all descs*/
for (k = 0; k<count; 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--;
count--;
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;
}
}
}
}
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;
}
return GF_NOT_SUPPORTED;
}
// Rewrite the good dependancies when an OD AU is extracted from the file
static u32 Media_FindOD_ID(GF_MediaBox *mdia, GF_ISOSample *sample, u32 track_id)
{
GF_Err e;
GF_ODCodec *ODdecode;
GF_ODCom *com;
u32 the_od_id;
GF_ODUpdate *odU;
GF_ESD *esd;
GF_Descriptor *desc;
GF_TrackReferenceTypeBox *mpod;
u32 i, j;
if (!mdia || !sample || !sample->data || !sample->dataLength) return 0;
mpod = NULL;
e = Track_FindRef(mdia->mediaTrack, GF_ISOM_BOX_TYPE_MPOD, &mpod);
if (e) return 0;
//no references, nothing to do...
if (!mpod) return 0;
the_od_id = 0;
ODdecode = gf_odf_codec_new();
if (!ODdecode) return 0;
e = gf_odf_codec_set_au(ODdecode, sample->data, sample->dataLength);
if (e) goto err_exit;
e = gf_odf_codec_decode(ODdecode);
if (e) goto err_exit;
while (1) {
GF_List *esd_list = NULL;
com = gf_odf_codec_get_com(ODdecode);
if (!com) break;
if (com->tag != GF_ODF_OD_UPDATE_TAG) continue;
odU = (GF_ODUpdate *) com;
i=0;
while ((desc = (GF_Descriptor*)gf_list_enum(odU->objectDescriptors, &i))) {
switch (desc->tag) {
case GF_ODF_OD_TAG:
case GF_ODF_IOD_TAG:
esd_list = ((GF_ObjectDescriptor *)desc)->ESDescriptors; break;
default:
continue;
}
j=0;
while ((esd = (GF_ESD*)gf_list_enum( esd_list, &j))){
if (esd->ESID==track_id) {
the_od_id = ((GF_IsomObjectDescriptor*)desc)->objectDescriptorID;
break;
}
}
if (the_od_id) break;
}
gf_odf_com_del((GF_ODCom **)&odU);
if (the_od_id) break;
}
err_exit:
gf_odf_codec_del(ODdecode);
if (e) return 0;
return the_od_id;
}
// Rewrite the good dependancies when an OD AU is extracted from the file
GF_Err Media_RewriteODFrame(GF_MediaBox *mdia, GF_ISOSample *sample)
{
GF_Err e;
GF_ODCodec *ODdecode;
GF_ODCodec *ODencode;
GF_ODCom *com;
//the commands we proceed
GF_ESDUpdate *esdU, *esdU2;
GF_ESDRemove *esdR, *esdR2;
GF_ODUpdate *odU, *odU2;
//the desc they contain
GF_ObjectDescriptor *od;
GF_IsomObjectDescriptor *isom_od;
GF_ESD *esd;
GF_ES_ID_Ref *ref;
GF_Descriptor *desc;
GF_TrackReferenceTypeBox *mpod;
u32 i, j, skipped;
if (!mdia || !sample || !sample->data || !sample->dataLength) return GF_BAD_PARAM;
mpod = NULL;
e = Track_FindRef(mdia->mediaTrack, GF_ISOM_BOX_TYPE_MPOD, &mpod);
if (e) return e;
//no references, nothing to do...
if (!mpod) return GF_OK;
ODdecode = gf_odf_codec_new();
if (!ODdecode) return GF_OUT_OF_MEM;
ODencode = gf_odf_codec_new();
if (!ODencode) {
gf_odf_codec_del(ODdecode);
return GF_OUT_OF_MEM;
}
e = gf_odf_codec_set_au(ODdecode, sample->data, sample->dataLength);
if (e) goto err_exit;
e = gf_odf_codec_decode(ODdecode);
if (e) goto err_exit;
while (1) {
com = gf_odf_codec_get_com(ODdecode);
if (!com) break;
//we only need to rewrite commands with ESDs inside: ESDUpdate and ODUpdate
switch (com->tag) {
case GF_ODF_OD_UPDATE_TAG:
odU = (GF_ODUpdate *) com;
odU2 = (GF_ODUpdate *) gf_odf_com_new(GF_ODF_OD_UPDATE_TAG);
i=0;
while ((desc = (GF_Descriptor*)gf_list_enum(odU->objectDescriptors, &i))) {
switch (desc->tag) {
case GF_ODF_OD_TAG:
case GF_ODF_ISOM_OD_TAG:
//IOD can be used in OD streams
case GF_ODF_ISOM_IOD_TAG:
break;
default:
return GF_ISOM_INVALID_FILE;
}
e = gf_odf_desc_copy(desc, (GF_Descriptor **)&isom_od);
if (e) goto err_exit;
//create our OD...
if (desc->tag == GF_ODF_ISOM_IOD_TAG) {
od = (GF_ObjectDescriptor *) gf_malloc(sizeof(GF_InitialObjectDescriptor));
} else {
od = (GF_ObjectDescriptor *) gf_malloc(sizeof(GF_ObjectDescriptor));
}
if (!od) {
e = GF_OUT_OF_MEM;
goto err_exit;
}
od->ESDescriptors = gf_list_new();
//and duplicate...
od->objectDescriptorID = isom_od->objectDescriptorID;
od->tag = GF_ODF_OD_TAG;
od->URLString = isom_od->URLString;
isom_od->URLString = NULL;
od->extensionDescriptors = isom_od->extensionDescriptors;
isom_od->extensionDescriptors = NULL;
od->IPMP_Descriptors = isom_od->IPMP_Descriptors;
isom_od->IPMP_Descriptors = NULL;
od->OCIDescriptors = isom_od->OCIDescriptors;
isom_od->OCIDescriptors = NULL;
//init as IOD
if (isom_od->tag == GF_ODF_ISOM_IOD_TAG) {
((GF_InitialObjectDescriptor *)od)->audio_profileAndLevel = ((GF_IsomInitialObjectDescriptor *)isom_od)->audio_profileAndLevel;
((GF_InitialObjectDescriptor *)od)->inlineProfileFlag = ((GF_IsomInitialObjectDescriptor *)isom_od)->inlineProfileFlag;
((GF_InitialObjectDescriptor *)od)->graphics_profileAndLevel = ((GF_IsomInitialObjectDescriptor *)isom_od)->graphics_profileAndLevel;
((GF_InitialObjectDescriptor *)od)->OD_profileAndLevel = ((GF_IsomInitialObjectDescriptor *)isom_od)->OD_profileAndLevel;
((GF_InitialObjectDescriptor *)od)->scene_profileAndLevel = ((GF_IsomInitialObjectDescriptor *)isom_od)->scene_profileAndLevel;
((GF_InitialObjectDescriptor *)od)->visual_profileAndLevel = ((GF_IsomInitialObjectDescriptor *)isom_od)->visual_profileAndLevel;
((GF_InitialObjectDescriptor *)od)->IPMPToolList = ((GF_IsomInitialObjectDescriptor *)isom_od)->IPMPToolList;
((GF_IsomInitialObjectDescriptor *)isom_od)->IPMPToolList = NULL;
}
//then rewrite the ESDesc
j=0;
while ((ref = (GF_ES_ID_Ref*)gf_list_enum(isom_od->ES_ID_RefDescriptors, &j))){
//if the ref index is not valid, skip this desc...
if (!mpod->trackIDs || gf_isom_get_track_from_id(mdia->mediaTrack->moov, mpod->trackIDs[ref->trackRef - 1]) == NULL) continue;
//OK, get the esd
e = GetESDForTime(mdia->mediaTrack->moov, mpod->trackIDs[ref->trackRef - 1], sample->DTS, &esd);
if (!e) e = gf_odf_desc_add_desc((GF_Descriptor *) od, (GF_Descriptor *) esd);
if (e) {
gf_odf_desc_del((GF_Descriptor *)od);
gf_odf_com_del((GF_ODCom **)&odU2);
gf_odf_desc_del((GF_Descriptor *)isom_od);
gf_odf_com_del((GF_ODCom **)&odU);
goto err_exit;
}
}
//delete our desc
gf_odf_desc_del((GF_Descriptor *)isom_od);
gf_list_add(odU2->objectDescriptors, od);
}
//clean a bit
gf_odf_com_del((GF_ODCom **)&odU);
gf_odf_codec_add_com(ODencode, (GF_ODCom *)odU2);
break;
case GF_ODF_ESD_UPDATE_TAG:
esdU = (GF_ESDUpdate *) com;
esdU2 = (GF_ESDUpdate *) gf_odf_com_new(GF_ODF_ESD_UPDATE_TAG);
esdU2->ODID = esdU->ODID;
i=0;
while ((ref = (GF_ES_ID_Ref*)gf_list_enum(esdU->ESDescriptors, &i))) {
//if the ref index is not valid, skip this desc...
if (gf_isom_get_track_from_id(mdia->mediaTrack->moov, mpod->trackIDs[ref->trackRef - 1]) == NULL) continue;
//OK, get the esd
e = GetESDForTime(mdia->mediaTrack->moov, mpod->trackIDs[ref->trackRef - 1], sample->DTS, &esd);
if (e) goto err_exit;
gf_list_add(esdU2->ESDescriptors, esd);
}
gf_odf_com_del((GF_ODCom **)&esdU);
gf_odf_codec_add_com(ODencode, (GF_ODCom *)esdU2);
break;
//brand new case: the ESRemove follows the same principle according to the spec...
case GF_ODF_ESD_REMOVE_REF_TAG:
//both commands have the same structure, only the tags change
esdR = (GF_ESDRemove *) com;
esdR2 = (GF_ESDRemove *) gf_odf_com_new(GF_ODF_ESD_REMOVE_TAG);
esdR2->ODID = esdR->ODID;
esdR2->NbESDs = esdR->NbESDs;
//alloc our stuff
esdR2->ES_ID = (unsigned short*)gf_malloc(sizeof(u32) * esdR->NbESDs);
if (!esdR2->ES_ID) {
e = GF_OUT_OF_MEM;
goto err_exit;
}
skipped = 0;
//get the ES_ID in the mpod indicated in the ES_ID[]
for (i = 0; i < esdR->NbESDs; i++) {
//if the ref index is not valid, remove this desc...
if (gf_isom_get_track_from_id(mdia->mediaTrack->moov, mpod->trackIDs[esdR->ES_ID[i] - 1]) == NULL) {
skipped ++;
} else {
//the command in the file has the ref index of the trackID in the mpod
esdR2->ES_ID[i - skipped] = mpod->trackIDs[esdR->ES_ID[i] - 1];
}
}
//gf_realloc...
if (skipped && (skipped != esdR2->NbESDs) ) {
esdR2->NbESDs -= skipped;
esdR2->ES_ID = (unsigned short*)gf_realloc(esdR2->ES_ID, sizeof(u32) * esdR2->NbESDs);
}
gf_odf_com_del((GF_ODCom **)&esdR);
gf_odf_codec_add_com(ODencode, (GF_ODCom *)esdR2);
break;
default:
e = gf_odf_codec_add_com(ODencode, com);
if (e) goto err_exit;
}
}
//encode our new AU
e = gf_odf_codec_encode(ODencode, 1);
if (e) goto err_exit;
//and set the buffer in the sample
gf_free(sample->data);
sample->data = NULL;
sample->dataLength = 0;
e = gf_odf_codec_get_au(ODencode, &sample->data, &sample->dataLength);
err_exit:
gf_odf_codec_del(ODdecode);
gf_odf_codec_del(ODencode);
return e;
}
// Update the dependancies when an OD AU is inserted in the file
GF_Err Media_ParseODFrame(GF_MediaBox *mdia, GF_ISOSample *sample, GF_ISOSample **od_samp)
{
GF_TrackReferenceBox *tref;
GF_TrackReferenceTypeBox *mpod;
GF_Err e;
GF_ODCom *com;
GF_ODCodec *ODencode;
GF_ODCodec *ODdecode;
u32 i, j;
//the commands we proceed
GF_ESDUpdate *esdU, *esdU2;
GF_ESDRemove *esdR, *esdR2;
GF_ODUpdate *odU, *odU2;
//the desc they contain
GF_ObjectDescriptor *od;
GF_IsomObjectDescriptor *isom_od;
GF_ESD *esd;
GF_ES_ID_Ref *ref;
GF_Descriptor *desc;
*od_samp = NULL;
if (!mdia || !sample || !sample->data || !sample->dataLength) return GF_BAD_PARAM;
//First find the references, and create them if none
tref = mdia->mediaTrack->References;
if (!tref) {
tref = (GF_TrackReferenceBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_TREF);
e = trak_AddBox((GF_Box*)mdia->mediaTrack, (GF_Box *) tref);
if (e) return e;
}
//then find the OD reference, and create it if none
e = Track_FindRef(mdia->mediaTrack, GF_ISOM_BOX_TYPE_MPOD, &mpod);
if (e) return e;
if (!mpod) {
mpod = (GF_TrackReferenceTypeBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_REFT);
mpod->reference_type = GF_ISOM_BOX_TYPE_MPOD;
e = tref_AddBox((GF_Box*)tref, (GF_Box *)mpod);
if (e) return e;
}
//OK, create our codecs
ODencode = gf_odf_codec_new();
if (!ODencode) return GF_OUT_OF_MEM;
ODdecode = gf_odf_codec_new();
if (!ODdecode) return GF_OUT_OF_MEM;
e = gf_odf_codec_set_au(ODdecode, sample->data, sample->dataLength);
if (e) goto err_exit;
e = gf_odf_codec_decode(ODdecode);
if (e) goto err_exit;
while (1) {
com = gf_odf_codec_get_com(ODdecode);
if (!com) break;
//check our commands
switch (com->tag) {
//Rewrite OD Update
case GF_ODF_OD_UPDATE_TAG:
//duplicate our command
odU = (GF_ODUpdate *) com;
odU2 = (GF_ODUpdate *) gf_odf_com_new(GF_ODF_OD_UPDATE_TAG);
i=0;
while ((desc = (GF_Descriptor*)gf_list_enum(odU->objectDescriptors, &i))) {
//both OD and IODs are accepted
switch (desc->tag) {
case GF_ODF_OD_TAG:
case GF_ODF_IOD_TAG:
break;
default:
e = GF_ODF_INVALID_DESCRIPTOR;
goto err_exit;
}
//get the esd
e = gf_odf_desc_copy(desc, (GF_Descriptor **)&od);
if (e) goto err_exit;
if (desc->tag == GF_ODF_OD_TAG) {
isom_od = (GF_IsomObjectDescriptor *) gf_malloc(sizeof(GF_IsomObjectDescriptor));
isom_od->tag = GF_ODF_ISOM_OD_TAG;
} else {
isom_od = (GF_IsomObjectDescriptor *) gf_malloc(sizeof(GF_IsomInitialObjectDescriptor));
isom_od->tag = GF_ODF_ISOM_IOD_TAG;
//copy PL
((GF_IsomInitialObjectDescriptor *)isom_od)->inlineProfileFlag = ((GF_InitialObjectDescriptor *)od)->inlineProfileFlag;
((GF_IsomInitialObjectDescriptor *)isom_od)->graphics_profileAndLevel = ((GF_InitialObjectDescriptor *)od)->graphics_profileAndLevel;
((GF_IsomInitialObjectDescriptor *)isom_od)->audio_profileAndLevel = ((GF_InitialObjectDescriptor *)od)->audio_profileAndLevel;
((GF_IsomInitialObjectDescriptor *)isom_od)->OD_profileAndLevel = ((GF_InitialObjectDescriptor *)od)->OD_profileAndLevel;
((GF_IsomInitialObjectDescriptor *)isom_od)->scene_profileAndLevel = ((GF_InitialObjectDescriptor *)od)->scene_profileAndLevel;
((GF_IsomInitialObjectDescriptor *)isom_od)->visual_profileAndLevel = ((GF_InitialObjectDescriptor *)od)->visual_profileAndLevel;
((GF_IsomInitialObjectDescriptor *)isom_od)->IPMPToolList = ((GF_InitialObjectDescriptor *)od)->IPMPToolList;
((GF_InitialObjectDescriptor *)od)->IPMPToolList = NULL;
}
//in OD stream only ref desc are accepted
isom_od->ES_ID_RefDescriptors = gf_list_new();
isom_od->ES_ID_IncDescriptors = NULL;
//TO DO: check that a given sampleDescription exists
isom_od->extensionDescriptors = od->extensionDescriptors;
od->extensionDescriptors = NULL;
isom_od->IPMP_Descriptors = od->IPMP_Descriptors;
od->IPMP_Descriptors = NULL;
isom_od->OCIDescriptors = od->OCIDescriptors;
od->OCIDescriptors = NULL;
isom_od->URLString = od->URLString;
od->URLString = NULL;
isom_od->objectDescriptorID = od->objectDescriptorID;
j=0;
while ((esd = (GF_ESD*)gf_list_enum(od->ESDescriptors, &j))) {
ref = (GF_ES_ID_Ref *) gf_odf_desc_new(GF_ODF_ESD_REF_TAG);
//1 to 1 mapping trackID and ESID. Add this track to MPOD
//if track does not exist, this will be remove while reading the OD stream
e = reftype_AddRefTrack(mpod, esd->ESID, &ref->trackRef);
e = gf_odf_desc_add_desc((GF_Descriptor *)isom_od, (GF_Descriptor *)ref);
if (e) goto err_exit;
}
//delete our desc
gf_odf_desc_del((GF_Descriptor *)od);
//and add the new one to our command
gf_list_add(odU2->objectDescriptors, isom_od);
}
//delete the command
gf_odf_com_del((GF_ODCom **)&odU);
//and add the new one to the codec
gf_odf_codec_add_com(ODencode, (GF_ODCom *)odU2);
break;
//Rewrite ESD Update
case GF_ODF_ESD_UPDATE_TAG:
esdU = (GF_ESDUpdate *) com;
esdU2 = (GF_ESDUpdate *) gf_odf_com_new(GF_ODF_ESD_UPDATE_TAG);
esdU2->ODID = esdU->ODID;
i=0;
while ((esd = (GF_ESD*)gf_list_enum(esdU->ESDescriptors, &i))) {
ref = (GF_ES_ID_Ref *) gf_odf_desc_new(GF_ODF_ESD_REF_TAG);
//1 to 1 mapping trackID and ESID
e = reftype_AddRefTrack(mpod, esd->ESID, &ref->trackRef);
e = gf_list_add(esdU2->ESDescriptors, ref);
if (e) goto err_exit;
}
gf_odf_com_del((GF_ODCom **)&esdU);
gf_odf_codec_add_com(ODencode, (GF_ODCom *)esdU2);
break;
//Brand new case: the ESRemove has to be rewritten too according to the specs...
case GF_ODF_ESD_REMOVE_TAG:
esdR = (GF_ESDRemove *) com;
esdR2 = (GF_ESDRemove *) gf_odf_com_new(GF_ODF_ESD_REMOVE_TAG);
//change the tag for the file format
esdR2->tag = GF_ODF_ESD_REMOVE_REF_TAG;
esdR2->ODID = esdR->ODID;
esdR2->NbESDs = esdR->NbESDs;
if (esdR->NbESDs) {
//alloc our stuff
esdR2->ES_ID = (unsigned short*)gf_malloc(sizeof(u32) * esdR->NbESDs);
if (!esdR2->ES_ID) {
e = GF_OUT_OF_MEM;
goto err_exit;
}
for (i = 0; i < esdR->NbESDs; i++) {
//1 to 1 mapping trackID and ESID
e = reftype_AddRefTrack(mpod, esdR->ES_ID[i], &esdR2->ES_ID[i]);
if (e) goto err_exit;
}
}
gf_odf_com_del(&com);
gf_odf_codec_add_com(ODencode, (GF_ODCom *)esdR2);
break;
//Add the command as is
default:
e = gf_odf_codec_add_com(ODencode, com);
if (e) goto err_exit;
}
}
//encode our new AU
e = gf_odf_codec_encode(ODencode, 1);
if (e) goto err_exit;
//and set the buffer in the sample
*od_samp = gf_isom_sample_new();
(*od_samp)->CTS_Offset = sample->CTS_Offset;
(*od_samp)->DTS = sample->DTS;
(*od_samp)->IsRAP = sample->IsRAP;
e = gf_odf_codec_get_au(ODencode, & (*od_samp)->data, & (*od_samp)->dataLength);
if (e) {
gf_isom_sample_del(od_samp);
*od_samp = NULL;
}
err_exit:
gf_odf_codec_del(ODencode);
gf_odf_codec_del(ODdecode);
return e;
}
static GF_Err CTXLoad_ProcessData(GF_SceneDecoder *plug, const char *inBuffer, u32 inBufferLength,
u16 ES_ID, u32 stream_time, u32 mmlevel)
{
GF_Err e = GF_OK;
u32 i, j, k, nb_updates, last_rap=0;
GF_AUContext *au;
Bool can_delete_com;
GF_StreamContext *sc;
CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack;
/*something failed*/
if (priv->load_flags==3) return GF_EOS;
/*this signals main scene deconnection, destroy the context if needed*/
assert(ES_ID);
if (!priv->ctx) {
e = CTXLoad_Setup((GF_BaseDecoder *)plug);
if (e) return e;
}
if (stream_time==(u32)-1) {
/*seek on root stream: destroy the context manager and reload it. We cannot seek on the main stream
because commands may have changed node attributes/children and we d'ont track the initial value*/
if (priv->load_flags && (priv->base_stream_id == ES_ID)) {
if (priv->src) gf_fclose(priv->src);
priv->src = NULL;
gf_sm_load_done(&priv->load);
priv->file_pos = 0;
/*queue scene for detach*/
gf_term_lock_media_queue(priv->scene->root_od->term, GF_TRUE);
priv->scene->root_od->action_type = GF_ODM_ACTION_SCENE_RECONNECT;
gf_list_add(priv->scene->root_od->term->media_queue, priv->scene->root_od);
gf_term_lock_media_queue(priv->scene->root_od->term, GF_FALSE);
return CTXLoad_Setup((GF_BaseDecoder *)plug);
}
i=0;
while ((sc = (GF_StreamContext *)gf_list_enum(priv->ctx->streams, &i))) {
/*not our stream*/
if (!sc->in_root_od && (sc->ESID != ES_ID)) continue;
/*not the base stream*/
if (sc->in_root_od && (priv->base_stream_id != ES_ID)) continue;
/*handle SWF media extraction*/
if ((sc->streamType == GF_STREAM_OD) && (priv->load_flags==1)) continue;
sc->last_au_time = 0;
}
return GF_OK;
}
if (priv->load_flags != 2) {
if (priv->progressive_support) {
u32 entry_time;
char file_buf[4096+1];
if (!priv->src) {
priv->src = gf_fopen(priv->file_name, "rb");
if (!priv->src) return GF_URL_ERROR;
priv->file_pos = 0;
}
priv->load.type = GF_SM_LOAD_XMTA;
e = GF_OK;
entry_time = gf_sys_clock();
gf_fseek(priv->src, priv->file_pos, SEEK_SET);
while (1) {
u32 diff;
s32 nb_read = (s32) fread(file_buf, 1, 4096, priv->src);
if (nb_read<0) {
return GF_IO_ERR;
}
file_buf[nb_read] = 0;
if (!nb_read) {
if (priv->file_pos==priv->file_size) {
gf_fclose(priv->src);
priv->src = NULL;
priv->load_flags = 2;
gf_sm_load_done(&priv->load);
break;
}
break;
}
e = gf_sm_load_string(&priv->load, file_buf, GF_FALSE);
priv->file_pos += nb_read;
if (e) break;
diff = gf_sys_clock() - entry_time;
if (diff > priv->sax_max_duration) break;
}
if (!priv->scene->graph_attached) {
gf_sg_set_scene_size_info(priv->scene->graph, priv->ctx->scene_width, priv->ctx->scene_height, priv->ctx->is_pixel_metrics);
gf_scene_attach_to_compositor(priv->scene);
CTXLoad_CheckStreams(priv);
}
}
/*load first frame only*/
else if (!priv->load_flags) {
/*we need the whole file*/
if (!CTXLoad_CheckDownload(priv)) return GF_OK;
priv->load_flags = 1;
e = gf_sm_load_init(&priv->load);
if (!e) {
CTXLoad_CheckStreams(priv);
gf_sg_set_scene_size_info(priv->scene->graph, priv->ctx->scene_width, priv->ctx->scene_height, priv->ctx->is_pixel_metrics);
/*VRML, override base clock*/
if ((priv->load.type==GF_SM_LOAD_VRML) || (priv->load.type==GF_SM_LOAD_X3DV) || (priv->load.type==GF_SM_LOAD_X3D)) {
/*override clock callback*/
gf_sg_set_scene_time_callback(priv->scene->graph, CTXLoad_GetVRMLTime);
}
}
}
/*load the rest*/
else {
priv->load_flags = 2;
e = gf_sm_load_run(&priv->load);
gf_sm_load_done(&priv->load);
/*in case this was not set in the first pass (XMT)*/
gf_sg_set_scene_size_info(priv->scene->graph, priv->ctx->scene_width, priv->ctx->scene_height, priv->ctx->is_pixel_metrics);
}
if (e<0) {
gf_sm_load_done(&priv->load);
gf_sm_del(priv->ctx);
priv->ctx = NULL;
priv->load_flags = 3;
return e;
}
/*and figure out duration of root scene, and take care of XMT timing*/
if (priv->load_flags==2) {
CTXLoad_CheckStreams(priv);
if (!gf_list_count(priv->ctx->streams)) {
gf_scene_attach_to_compositor(priv->scene);
}
}
}
nb_updates = 0;
i=0;
while ((sc = (GF_StreamContext *)gf_list_enum(priv->ctx->streams, &i))) {
/*not our stream*/
if (!sc->in_root_od && (sc->ESID != ES_ID)) continue;
/*not the base stream*/
if (sc->in_root_od && (priv->base_stream_id != ES_ID)) continue;
/*handle SWF media extraction*/
if ((sc->streamType == GF_STREAM_OD) && (priv->load_flags==1)) continue;
/*check for seek*/
if (sc->last_au_time > 1 + stream_time) {
sc->last_au_time = 0;
}
can_delete_com = GF_FALSE;
if (sc->in_root_od && (priv->load_flags==2)) can_delete_com = GF_TRUE;
/*we're in the right stream, apply update*/
j=0;
/*seek*/
if (!sc->last_au_time) {
while ((au = (GF_AUContext *)gf_list_enum(sc->AUs, &j))) {
u32 au_time = (u32) (au->timing*1000/sc->timeScale);
if (au_time > stream_time)
break;
if (au->flags & GF_SM_AU_RAP) last_rap = j-1;
}
j = last_rap;
}
while ((au = (GF_AUContext *)gf_list_enum(sc->AUs, &j))) {
u32 au_time = (u32) (au->timing*1000/sc->timeScale);
if (au_time + 1 <= sc->last_au_time) {
/*remove first replace command*/
if (can_delete_com && (sc->streamType==GF_STREAM_SCENE)) {
while (gf_list_count(au->commands)) {
GF_Command *com = (GF_Command *)gf_list_get(au->commands, 0);
gf_list_rem(au->commands, 0);
gf_sg_command_del(com);
}
j--;
gf_list_rem(sc->AUs, j);
gf_list_del(au->commands);
gf_free(au);
}
continue;
}
if (au_time > stream_time) {
nb_updates++;
break;
}
if (sc->streamType == GF_STREAM_SCENE) {
GF_Command *com;
/*apply the commands*/
k=0;
while ((com = (GF_Command *)gf_list_enum(au->commands, &k))) {
e = gf_sg_command_apply(priv->scene->graph, com, 0);
if (e) break;
/*remove commands on base layer*/
if (can_delete_com) {
k--;
gf_list_rem(au->commands, k);
gf_sg_command_del(com);
}
}
}
else if (sc->streamType == GF_STREAM_OD) {
/*apply the commands*/
while (gf_list_count(au->commands)) {
Bool keep_com = GF_FALSE;
GF_ODCom *com = (GF_ODCom *)gf_list_get(au->commands, 0);
gf_list_rem(au->commands, 0);
switch (com->tag) {
case GF_ODF_OD_UPDATE_TAG:
{
GF_ODUpdate *odU = (GF_ODUpdate *)com;
while (gf_list_count(odU->objectDescriptors)) {
GF_ESD *esd;
char *remote;
GF_MuxInfo *mux = NULL;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *)gf_list_get(odU->objectDescriptors, 0);
gf_list_rem(odU->objectDescriptors, 0);
/*we can only work with single-stream ods*/
esd = (GF_ESD*)gf_list_get(od->ESDescriptors, 0);
if (!esd) {
if (od->URLString) {
ODS_SetupOD(priv->scene, od);
} else {
gf_odf_desc_del((GF_Descriptor *) od);
}
continue;
}
/*fix OCR dependencies*/
if (CTXLoad_StreamInRootOD(priv->ctx->root_od, esd->OCRESID)) esd->OCRESID = priv->base_stream_id;
/*forbidden if ESD*/
if (od->URLString) {
gf_odf_desc_del((GF_Descriptor *) od);
continue;
}
/*look for MUX info*/
k=0;
while ((mux = (GF_MuxInfo*)gf_list_enum(esd->extensionDescriptors, &k))) {
if (mux->tag == GF_ODF_MUXINFO_TAG) break;
mux = NULL;
}
/*we need a mux if not animation stream*/
if (!mux || !mux->file_name) {
/*only animation streams are handled*/
if (!esd->decoderConfig) {
gf_odf_desc_del((GF_Descriptor *) od);
} else if (esd->decoderConfig->streamType==GF_STREAM_SCENE) {
/*set ST to private scene to get sure the stream will be redirected to us*/
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_SCENE;
esd->dependsOnESID = priv->base_stream_id;
ODS_SetupOD(priv->scene, od);
} else if (esd->decoderConfig->streamType==GF_STREAM_INTERACT) {
GF_UIConfig *cfg = (GF_UIConfig *) esd->decoderConfig->decoderSpecificInfo;
gf_odf_encode_ui_config(cfg, &esd->decoderConfig->decoderSpecificInfo);
gf_odf_desc_del((GF_Descriptor *) cfg);
ODS_SetupOD(priv->scene, od);
} else {
gf_odf_desc_del((GF_Descriptor *) od);
}
continue;
}
//solve url before import
if (mux->src_url) {
char *res_url = gf_url_concatenate(mux->src_url, mux->file_name);
if (res_url) {
gf_free(mux->file_name);
mux->file_name = res_url;
}
gf_free(mux->src_url);
mux->src_url = NULL;
}
/*text import*/
if (mux->textNode) {
#ifdef GPAC_DISABLE_MEDIA_IMPORT
gf_odf_desc_del((GF_Descriptor *) od);
continue;
#else
e = gf_sm_import_bifs_subtitle(priv->ctx, esd, mux);
if (e) {
e = GF_OK;
gf_odf_desc_del((GF_Descriptor *) od);
continue;
}
/*set ST to private scene and dependency to base to get sure the stream will be redirected to us*/
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_SCENE;
esd->dependsOnESID = priv->base_stream_id;
ODS_SetupOD(priv->scene, od);
continue;
#endif
}
/*soundstreams are a bit of a pain, they may be declared before any data gets written*/
if (mux->delete_file) {
FILE *t = gf_fopen(mux->file_name, "rb");
if (!t) {
keep_com = GF_TRUE;
gf_list_insert(odU->objectDescriptors, od, 0);
break;
}
gf_fclose(t);
}
/*remap to remote URL - warning, the URL has already been resolved according to the parent path*/
remote = (char*)gf_malloc(sizeof(char) * (strlen("gpac://")+strlen(mux->file_name)+1) );
strcpy(remote, "gpac://");
strcat(remote, mux->file_name);
k = od->objectDescriptorID;
/*if files were created we'll have to clean up (swf import)*/
if (mux->delete_file) gf_list_add(priv->files_to_delete, gf_strdup(remote));
gf_odf_desc_del((GF_Descriptor *) od);
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->URLString = remote;
od->objectDescriptorID = k;
ODS_SetupOD(priv->scene, od);
}
if (keep_com) break;
}
break;
case GF_ODF_OD_REMOVE_TAG:
{
GF_ODRemove *odR = (GF_ODRemove*)com;
for (k=0; k<odR->NbODs; k++) {
GF_ObjectManager *odm = gf_scene_find_odm(priv->scene, odR->OD_ID[k]);
if (odm) gf_odm_disconnect(odm, 1);
}
}
break;
default:
break;
}
if (keep_com) {
gf_list_insert(au->commands, com, 0);
break;
} else {
gf_odf_com_del(&com);
}
if (e) break;
}
}
sc->last_au_time = au_time + 1;
/*attach graph to renderer*/
if (!priv->scene->graph_attached)
gf_scene_attach_to_compositor(priv->scene);
if (e) return e;
/*for root streams remove completed AUs (no longer needed)*/
if (sc->in_root_od && !gf_list_count(au->commands) ) {
j--;
gf_list_rem(sc->AUs, j);
gf_list_del(au->commands);
gf_free(au);
}
}
}
if (e) return e;
if ((priv->load_flags==2) && !nb_updates) return GF_EOS;
return GF_OK;
}
static GF_Err ODF_ProcessData(GF_SceneDecoder *plug, const char *inBuffer, u32 inBufferLength,
u16 ES_ID, u32 AU_time, u32 mmlevel)
{
GF_Err e;
GF_ODCom *com;
GF_ODCodec *oddec;
ODPriv *priv = (ODPriv *)plug->privateStack;
oddec = gf_odf_codec_new();
e = gf_odf_codec_set_au(oddec, inBuffer, inBufferLength);
if (!e) e = gf_odf_codec_decode(oddec);
if (e) goto err_exit;
//3- process all the commands in this AU, in order
while (1) {
com = gf_odf_codec_get_com(oddec);
if (!com) break;
//ok, we have a command
switch (com->tag) {
case GF_ODF_OD_UPDATE_TAG:
e = ODS_ODUpdate(priv, (GF_ODUpdate *) com);
break;
case GF_ODF_OD_REMOVE_TAG:
e = ODS_RemoveOD(priv, (GF_ODRemove *) com);
break;
case GF_ODF_ESD_UPDATE_TAG:
e = ODS_UpdateESD(priv, (GF_ESDUpdate *)com);
break;
case GF_ODF_ESD_REMOVE_TAG:
e = ODS_RemoveESD(priv, (GF_ESDRemove *)com);
break;
case GF_ODF_IPMP_UPDATE_TAG:
#if 0
{
GF_IPMPUpdate *ipmpU = (GF_IPMPUpdate *)com;
while (gf_list_count(ipmpU->IPMPDescList)) {
GF_IPMP_Descriptor *ipmp = gf_list_get(ipmpU->IPMPDescList, 0);
gf_list_rem(ipmpU->IPMPDescList, 0);
IS_UpdateIPMP(priv->scene, ipmp);
}
e = GF_OK;
}
#else
e = GF_OK;
#endif
break;
case GF_ODF_IPMP_REMOVE_TAG:
e = GF_NOT_SUPPORTED;
break;
/*should NEVER exist outside the file format*/
case GF_ODF_ESD_REMOVE_REF_TAG:
e = GF_NON_COMPLIANT_BITSTREAM;
break;
default:
if (com->tag >= GF_ODF_COM_ISO_BEGIN_TAG && com->tag <= GF_ODF_COM_ISO_END_TAG) {
e = GF_ODF_FORBIDDEN_DESCRIPTOR;
} else {
/*we don't process user commands*/
e = GF_OK;
}
break;
}
gf_odf_com_del(&com);
if (e) break;
}
err_exit:
gf_odf_codec_del(oddec);
return e;
}
