GF_Err gf_isom_remove_meta_item(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_id)
{
GF_ItemInfoEntryBox *iinf;
u32 i, count;
GF_MetaBox *meta = gf_isom_get_meta(file, root_meta, track_num);
u32 item_num;
if (!meta || !meta->item_infos || !meta->item_locations) return GF_BAD_PARAM;
item_num = gf_isom_get_meta_item_by_id(file, root_meta, track_num, item_id);
if (!item_num) return GF_BAD_PARAM;
iinf = (GF_ItemInfoEntryBox *)gf_list_get(meta->item_infos->item_infos, item_num-1);
gf_list_rem(meta->item_infos->item_infos, item_num-1);
count = gf_list_count(meta->item_locations->location_entries);
for (i=0; i<count; i++) {
GF_ItemLocationEntry *iloc = (GF_ItemLocationEntry *)gf_list_get(meta->item_locations->location_entries, i);
if (iloc->item_ID==iinf->item_ID) {
/*FIXME: remove data ref...*/
if (iloc->data_reference_index) { }
gf_list_rem(meta->item_locations->location_entries, i);
gf_isom_box_del((GF_Box *)iloc);
break;
}
}
gf_isom_box_del((GF_Box *)iinf);
return GF_OK;
}
GF_Err tx3g_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_Box *a;
GF_Tx3gSampleEntryBox *ptr = (GF_Tx3gSampleEntryBox*)s;
if (ptr->size < 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->displayFlags = gf_bs_read_u32(bs);
ptr->horizontal_justification = gf_bs_read_u8(bs);
ptr->vertical_justification = gf_bs_read_u8(bs);
ptr->back_color = gpp_read_rgba(bs);
gpp_read_box(bs, &ptr->default_box);
gpp_read_style(bs, &ptr->default_style);
ptr->size -= 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE;
while (ptr->size) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) return GF_ISOM_INVALID_FILE;
ptr->size -= a->size;
if (a->type==GF_ISOM_BOX_TYPE_FTAB) {
if (ptr->font_table) gf_isom_box_del((GF_Box *) ptr->font_table);
ptr->font_table = (GF_FontTableBox *)a;
} else {
gf_isom_box_del(a);
}
}
return GF_OK;
}
void vtcu_del(GF_Box *s)
{
GF_VTTCueBox *box = (GF_VTTCueBox *)s;
if (box->id) gf_isom_box_del((GF_Box *)box->id);
if (box->settings) gf_isom_box_del((GF_Box *)box->settings);
if (box->payload) gf_isom_box_del((GF_Box *)box->payload);
}
void gf_isom_hint_sample_del(GF_HintSample *ptr)
{
GF_HintPacket *pck;
if (ptr->hint_subtype==GF_ISOM_BOX_TYPE_FDP_STSD) {
gf_isom_box_del((GF_Box*)ptr);
return;
}
while (gf_list_count(ptr->packetTable)) {
pck = (GF_HintPacket *)gf_list_get(ptr->packetTable, 0);
gf_isom_hint_pck_del(pck);
gf_list_rem(ptr->packetTable, 0);
}
gf_list_del(ptr->packetTable);
if (ptr->AdditionalData) gf_free(ptr->AdditionalData);
if (ptr->sample_cache) {
while (gf_list_count(ptr->sample_cache)) {
GF_HintDataCache *hdc = (GF_HintDataCache *)gf_list_get(ptr->sample_cache, 0);
gf_list_rem(ptr->sample_cache, 0);
if (hdc->samp) gf_isom_sample_del(&hdc->samp);
gf_free(hdc);
}
gf_list_del(ptr->sample_cache);
}
if (ptr->extra_data)
gf_isom_box_del((GF_Box*)ptr->extra_data);
if (ptr->other_boxes)
gf_isom_box_array_del(ptr->other_boxes);
gf_free(ptr);
}
void odkm_del(GF_Box *s)
{
GF_OMADRMKMSBox *ptr = (GF_OMADRMKMSBox *)s;
if (ptr->hdr) gf_isom_box_del((GF_Box*)ptr->hdr);
if (ptr->fmt) gf_isom_box_del((GF_Box*)ptr->fmt);
gf_free(ptr);
}
void adkm_del(GF_Box *s)
{
GF_AdobeDRMKeyManagementSystemBox *ptr = (GF_AdobeDRMKeyManagementSystemBox *)s;
if (!ptr) return;
if (ptr->header) gf_isom_box_del((GF_Box *)ptr->header);
if (ptr->au_format) gf_isom_box_del((GF_Box *)ptr->au_format);
gf_free(s);
}
void aprm_del(GF_Box *s)
{
GF_AdobeStdEncryptionParamsBox *ptr = (GF_AdobeStdEncryptionParamsBox *)s;
if (!ptr) return;
if (ptr->enc_info) gf_isom_box_del((GF_Box *)ptr->enc_info);
if (ptr->key_info) gf_isom_box_del((GF_Box *)ptr->key_info);
gf_free(s);
}
void schi_del(GF_Box *s)
{
GF_SchemeInformationBox *ptr = (GF_SchemeInformationBox *)s;
if (ptr == NULL) return;
if (ptr->ikms) gf_isom_box_del((GF_Box *)ptr->ikms);
if (ptr->isfm) gf_isom_box_del((GF_Box *)ptr->isfm);
gf_free(ptr);
}
void gppv_del(GF_Box *s)
{
GF_3GPPVisualSampleEntryBox *ptr = (GF_3GPPVisualSampleEntryBox *)s;
if (ptr == NULL) return;
if (ptr->info) gf_isom_box_del((GF_Box *)ptr->info);
if (ptr->protection_info) gf_isom_box_del((GF_Box *)ptr->protection_info);
gf_free(ptr);
}
GF_Err Media_CreateDataRef(GF_DataReferenceBox *dref, char *URLname, char *URNname, u32 *dataRefIndex)
{
GF_Err e;
GF_DataEntryURLBox *entry;
GF_Err dref_AddDataEntry(GF_DataReferenceBox *ptr, GF_Box *entry);
if (!URLname && !URNname) {
//THIS IS SELF CONTAIN, create a regular entry if needed
entry = (GF_DataEntryURLBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_URL);
entry->location = NULL;
entry->flags = 0;
entry->flags |= 1;
e = dref_AddDataEntry(dref, (GF_Box *)entry);
if (e) return e;
*dataRefIndex = gf_list_count(dref->other_boxes);
return GF_OK;
} else if (!URNname && URLname) {
//THIS IS URL
entry = (GF_DataEntryURLBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_URL);
entry->flags = 0;
entry->location = (char*)gf_malloc(strlen(URLname)+1);
if (! entry->location) {
gf_isom_box_del((GF_Box *)entry);
return GF_OUT_OF_MEM;
}
strcpy(entry->location, URLname);
e = dref_AddDataEntry(dref, (GF_Box *)entry);
if (e) return e;
*dataRefIndex = gf_list_count(dref->other_boxes);
return GF_OK;
} else {
//THIS IS URN
entry = (GF_DataEntryURLBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_URN);
((GF_DataEntryURNBox *)entry)->flags = 0;
((GF_DataEntryURNBox *)entry)->nameURN = (char*)gf_malloc(strlen(URNname)+1);
if (! ((GF_DataEntryURNBox *)entry)->nameURN) {
gf_isom_box_del((GF_Box *)entry);
return GF_OUT_OF_MEM;
}
strcpy(((GF_DataEntryURNBox *)entry)->nameURN, URNname);
//check for URL
if (URLname) {
((GF_DataEntryURNBox *)entry)->location = (char*)gf_malloc(strlen(URLname)+1);
if (! ((GF_DataEntryURNBox *)entry)->location) {
gf_isom_box_del((GF_Box *)entry);
return GF_OUT_OF_MEM;
}
strcpy(((GF_DataEntryURNBox *)entry)->location, URLname);
}
e = dref_AddDataEntry(dref, (GF_Box *)entry);
if (e) return e;
*dataRefIndex = gf_list_count(dref->other_boxes);
return GF_OK;
}
return GF_OK;
}
GF_EXPORT
GF_Err gf_isom_set_meta_type(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 metaType)
{
char szName[20];
GF_MetaBox *meta;
GF_Err e = CanAccessMovie(file, GF_ISOM_OPEN_WRITE);
if (e) return e;
meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta) {
if (!metaType) return GF_OK;
meta = (GF_MetaBox *) meta_New();
if (root_meta) {
file->meta = meta;
gf_list_add(file->TopBoxes, meta);
} else {
gf_isom_insert_moov(file);
if (!track_num) {
file->moov->meta = meta;
} else {
GF_TrackBox *tk = (GF_TrackBox *)gf_list_get(file->moov->trackList, track_num-1);
if (!tk) {
gf_isom_box_del((GF_Box *)meta);
return GF_BAD_PARAM;
}
tk->meta = meta;
}
}
} else if (!metaType) {
if (root_meta) {
gf_list_del_item(file->TopBoxes, meta);
gf_isom_box_del((GF_Box *)file->meta);
file->meta = NULL;
} else if (file->moov) {
if (!track_num) {
gf_isom_box_del((GF_Box *)file->moov->meta);
file->moov->meta = NULL;
} else {
GF_TrackBox *tk = (GF_TrackBox *)gf_list_get(file->moov->trackList, track_num-1);
if (!tk) return GF_BAD_PARAM;
gf_isom_box_del((GF_Box *)tk->meta);
tk->meta = NULL;
}
}
return GF_OK;
}
if (!meta->handler)
meta->handler = (GF_HandlerBox *)hdlr_New();
if (meta->handler->nameUTF8) gf_free(meta->handler->nameUTF8);
meta->handler->handlerType = metaType;
sprintf(szName, "GPAC %s Handler", gf_4cc_to_str(metaType));
meta->handler->nameUTF8 = gf_strdup(szName);
return GF_OK;
}
void sinf_del(GF_Box *s)
{
GF_ProtectionSchemeInfoBox *ptr = (GF_ProtectionSchemeInfoBox *)s;
if (ptr == NULL) return;
if (ptr->original_format) gf_isom_box_del((GF_Box *)ptr->original_format);
if (ptr->info) gf_isom_box_del((GF_Box *)ptr->info);
if (ptr->scheme_type) gf_isom_box_del((GF_Box *)ptr->scheme_type);
gf_free(ptr);
}
void meta_reset(GF_Box *s)
{
GF_MetaBox *ptr = (GF_MetaBox *)s;
if (ptr == NULL) return;
gf_isom_box_del((GF_Box *)ptr->handler);
ptr->handler = NULL;
if (ptr->primary_resource) gf_isom_box_del((GF_Box *)ptr->primary_resource);
ptr->primary_resource = NULL;
if (ptr->file_locations) gf_isom_box_del((GF_Box *)ptr->file_locations);
ptr->file_locations = NULL;
if (ptr->item_locations) gf_isom_box_del((GF_Box *)ptr->item_locations);
ptr->item_locations = NULL;
if (ptr->protections) gf_isom_box_del((GF_Box *)ptr->protections);
ptr->protections = NULL;
if (ptr->item_infos) gf_isom_box_del((GF_Box *)ptr->item_infos);
ptr->item_infos = NULL;
if (ptr->IPMP_control) gf_isom_box_del((GF_Box *)ptr->IPMP_control);
ptr->IPMP_control = NULL;
if (ptr->item_refs) gf_isom_box_del((GF_Box *)ptr->item_refs);
ptr->item_refs = NULL;
if (ptr->item_props) gf_isom_box_del((GF_Box *)ptr->item_props);
ptr->item_props = NULL;
if (ptr->other_boxes) gf_isom_box_array_del(ptr->other_boxes);
ptr->other_boxes = NULL;
}
void CleanWriters(GF_List *writers)
{
TrackWriter *writer;
while (gf_list_count(writers)) {
writer = (TrackWriter*)gf_list_get(writers, 0);
gf_isom_box_del(writer->stco);
gf_isom_box_del((GF_Box *)writer->stsc);
gf_free(writer);
gf_list_rem(writers, 0);
}
}
void akey_del(GF_Box *s)
{
GF_AdobeKeyInfoBox *ptr = (GF_AdobeKeyInfoBox *)s;
if (!ptr) return;
if (ptr->params) gf_isom_box_del((GF_Box *)ptr->params);
gf_free(s);
}
GF_Err gf_isom_svc_config_del(GF_ISOFile *the_file, u32 trackNumber, u32 DescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
GF_MPEGVisualSampleEntryBox *entry;
e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(the_file, trackNumber);
if (!trak || !trak->Media || !DescriptionIndex) return GF_BAD_PARAM;
entry = (GF_MPEGVisualSampleEntryBox *)gf_list_get(trak->Media->information->sampleTable->SampleDescription->other_boxes, DescriptionIndex-1);
if (!entry) return GF_BAD_PARAM;
switch (entry->type) {
case GF_ISOM_BOX_TYPE_AVC1:
case GF_ISOM_BOX_TYPE_AVC2:
case GF_ISOM_BOX_TYPE_AVC3:
case GF_ISOM_BOX_TYPE_AVC4:
case GF_ISOM_BOX_TYPE_SVC1:
break;
default:
return GF_BAD_PARAM;
}
if (entry->svc_config) {
gf_isom_box_del((GF_Box*)entry->svc_config);
entry->svc_config = NULL;
}
AVC_RewriteESDescriptor(entry);
return GF_OK;
}
void ahdr_del(GF_Box *s)
{
GF_AdobeDRMHeaderBox *ptr = (GF_AdobeDRMHeaderBox *)s;
if (!ptr) return;
if (ptr->std_enc_params) gf_isom_box_del((GF_Box *)ptr->std_enc_params);
gf_free(s);
}
void tx3g_del(GF_Box *s)
{
GF_Tx3gSampleEntryBox *ptr = (GF_Tx3gSampleEntryBox*)s;
if (ptr->font_table)
gf_isom_box_del((GF_Box *)ptr->font_table);
gf_free(ptr);
}
GF_Err ListItem_Read(GF_Box *s,GF_BitStream *bs)
{
GF_Err e;
u32 sub_type;
GF_Box *a = NULL;
GF_ListItemBox *ptr = (GF_ListItemBox *)s;
/*iTunes way: there's a data atom containing the data*/
sub_type = gf_bs_peek_bits(bs, 32, 4);
if (sub_type == GF_ISOM_BOX_TYPE_DATA ) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) return GF_ISOM_INVALID_FILE;
ptr->size -= a->size;
if (a && ptr->data) gf_isom_box_del((GF_Box *) ptr->data);
ptr->data = (GF_DataBox *)a;
}
/*QT way*/
else {
ptr->data->type = 0;
ptr->data->dataSize = gf_bs_read_u16(bs);
gf_bs_read_u16(bs);
ptr->data->data = (char *) gf_malloc(sizeof(char)*(ptr->data->dataSize + 1));
gf_bs_read_data(bs, ptr->data->data, ptr->data->dataSize);
ptr->data->data[ptr->data->dataSize] = 0;
ptr->size -= ptr->data->dataSize;
}
return GF_OK;
}
GF_List *gf_webvtt_parse_iso_cues(GF_ISOSample *iso_sample, u64 start)
{
GF_List *cues;
GF_WebVTTCue *cue;
GF_VTTCueBox *cuebox;
GF_BitStream *bs;
cues = gf_list_new();
bs = gf_bs_new(iso_sample->data, iso_sample->dataLength, GF_BITSTREAM_READ);
while(gf_bs_available(bs))
{
GF_Err e;
GF_Box *box;
e = gf_isom_parse_box(&box, bs);
if (e) return NULL;
if (box->type == GF_ISOM_BOX_TYPE_VTCU) {
cuebox = (GF_VTTCueBox *)box;
cue = gf_webvtt_cue_new();
gf_list_add(cues, cue);
gf_webvtt_timestamp_set(&cue->start, start);
if (cuebox->id) {
gf_webvtt_cue_add_property(cue, WEBVTT_ID, cuebox->id->string, (u32) strlen(cuebox->id->string));
}
if (cuebox->settings) {
gf_webvtt_cue_add_property(cue, WEBVTT_SETTINGS, cuebox->settings->string, (u32) strlen(cuebox->settings->string));
}
if (cuebox->payload) {
gf_webvtt_cue_add_property(cue, WEBVTT_PAYLOAD, cuebox->payload->string, (u32) strlen(cuebox->payload->string));
}
}
gf_isom_box_del(box);
}
gf_bs_del(bs);
return cues;
}
void ResetWriters(GF_List *writers)
{
u32 i;
TrackWriter *writer;
i=0;
while ((writer = (TrackWriter *)gf_list_enum(writers, &i))) {
writer->isDone = 0;
writer->chunkDur = 0;
writer->DTSprev = 0;
writer->sampleNumber = 1;
gf_isom_box_del((GF_Box *)writer->stsc);
writer->stsc = (GF_SampleToChunkBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_STSC);
if (writer->stco->type == GF_ISOM_BOX_TYPE_STCO) {
gf_free(((GF_ChunkOffsetBox *)writer->stco)->offsets);
((GF_ChunkOffsetBox *)writer->stco)->offsets = NULL;
((GF_ChunkOffsetBox *)writer->stco)->nb_entries = 0;
((GF_ChunkOffsetBox *)writer->stco)->alloc_size = 0;
} else {
gf_free(((GF_ChunkLargeOffsetBox *)writer->stco)->offsets);
((GF_ChunkLargeOffsetBox *)writer->stco)->offsets = NULL;
((GF_ChunkLargeOffsetBox *)writer->stco)->nb_entries = 0;
((GF_ChunkLargeOffsetBox *)writer->stco)->alloc_size = 0;
}
}
}
GF_Err gf_webvtt_dump_iso_sample(FILE *dump, u32 timescale, GF_ISOSample *iso_sample)
{
GF_Err e;
GF_BitStream *bs;
bs = gf_bs_new(iso_sample->data, iso_sample->dataLength, GF_BITSTREAM_READ);
while(gf_bs_available(bs))
{
GF_Box *box;
GF_WebVTTTimestamp ts;
e = gf_isom_parse_box(&box, bs);
if (e) return e;
if (box->type == GF_ISOM_BOX_TYPE_VTCU) {
GF_VTTCueBox *cuebox = (GF_VTTCueBox *)box;
if (cuebox->id) fprintf(dump, "%s", cuebox->id->string);
gf_webvtt_timestamp_set(&ts, (iso_sample->DTS * 1000) / timescale);
gf_webvtt_timestamp_dump(&ts, dump, GF_FALSE);
fprintf(dump, " --> NEXT");
if (cuebox->settings) fprintf(dump, " %s", cuebox->settings->string);
fprintf(dump, "\n");
if (cuebox->payload) fprintf(dump, "%s", cuebox->payload->string);
fprintf(dump, "\n");
} else if (box->type == GF_ISOM_BOX_TYPE_VTTE) {
gf_webvtt_timestamp_set(&ts, (iso_sample->DTS * 1000) / timescale);
gf_webvtt_timestamp_dump(&ts, dump, GF_FALSE);
fprintf(dump, " --> NEXT\n\n");
} else if (box->type == GF_ISOM_BOX_TYPE_VTTA) {
fprintf(dump, "%s\n\n", ((GF_StringBox *)box)->string);
}
gf_isom_box_del(box);
}
gf_bs_del(bs);
return GF_OK;
}
void gppv_del(GF_Box *s)
{
GF_3GPPVisualSampleEntryBox *ptr = (GF_3GPPVisualSampleEntryBox *)s;
if (ptr == NULL) return;
gf_isom_sample_entry_predestroy((GF_SampleEntryBox *)ptr);
if (ptr->info) gf_isom_box_del((GF_Box *)ptr->info);
gf_free(ptr);
}
GF_Err odkm_Add(GF_Box *s, GF_Box *a)
{
GF_OMADRMKMSBox *ptr = (GF_OMADRMKMSBox *)s;
switch (a->type) {
case GF_ISOM_BOX_TYPE_OHDR:
if (ptr->hdr) gf_isom_box_del((GF_Box*)ptr->hdr);
ptr->hdr = (GF_OMADRMCommonHeaderBox *)a;
return GF_OK;
case GF_ISOM_BOX_TYPE_ODAF:
if (ptr->fmt) gf_isom_box_del((GF_Box*)ptr->fmt);
ptr->fmt = (GF_OMADRMAUFormatBox*)a;
return GF_OK;
default:
gf_isom_box_del(a);
return GF_OK;
}
}
void tx3g_del(GF_Box *s)
{
GF_Tx3gSampleEntryBox *ptr = (GF_Tx3gSampleEntryBox*)s;
gf_isom_sample_entry_predestroy((GF_SampleEntryBox *)s);
if (ptr->font_table)
gf_isom_box_del((GF_Box *)ptr->font_table);
gf_free(ptr);
}
GF_Err tx3g_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_Box *a;
GF_Tx3gSampleEntryBox *ptr = (GF_Tx3gSampleEntryBox*)s;
if (ptr->size < 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->displayFlags = gf_bs_read_u32(bs);
ptr->horizontal_justification = gf_bs_read_u8(bs);
ptr->vertical_justification = gf_bs_read_u8(bs);
ptr->back_color = gpp_read_rgba(bs);
gpp_read_box(bs, &ptr->default_box);
gpp_read_style(bs, &ptr->default_style);
ptr->size -= 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE;
while (ptr->size) {
if (ptr->size < 8) {
/* Sometimes there are void atoms at the end of an atom and they are not parsed correctecly */
/* So just skip them if we have less than 8 bytes to parse */
/* "The actual size of an atom cannot be less than 8 bytes" from QTFF specs */
ptr->size = 0;
return GF_OK;
}
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) return GF_ISOM_INVALID_FILE;
ptr->size -= a->size;
if (a->type==GF_ISOM_BOX_TYPE_FTAB) {
if (ptr->font_table) gf_isom_box_del((GF_Box *) ptr->font_table);
ptr->font_table = (GF_FontTableBox *)a;
} else {
gf_isom_box_del(a);
}
}
return GF_OK;
}
GF_Err AVC_UpdateESD(GF_MPEGVisualSampleEntryBox *avc, GF_ESD *esd)
{
if (!avc->bitrate) avc->bitrate = (GF_MPEG4BitRateBox*)gf_isom_box_new(GF_ISOM_BOX_TYPE_BTRT);
if (avc->descr) gf_isom_box_del((GF_Box *) avc->descr);
avc->descr = NULL;
avc->bitrate->avgBitrate = esd->decoderConfig->avgBitrate;
avc->bitrate->maxBitrate = esd->decoderConfig->maxBitrate;
avc->bitrate->bufferSizeDB = esd->decoderConfig->bufferSizeDB;
if (gf_list_count(esd->IPIDataSet)
|| gf_list_count(esd->IPMPDescriptorPointers)
|| esd->langDesc
|| gf_list_count(esd->extensionDescriptors)
|| esd->ipiPtr || esd->qos || esd->RegDescriptor) {
avc->descr = (GF_MPEG4ExtensionDescriptorsBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_M4DS);
if (esd->RegDescriptor) { gf_list_add(avc->descr->descriptors, esd->RegDescriptor); esd->RegDescriptor = NULL; }
if (esd->qos) { gf_list_add(avc->descr->descriptors, esd->qos); esd->qos = NULL; }
if (esd->ipiPtr) { gf_list_add(avc->descr->descriptors, esd->ipiPtr); esd->ipiPtr= NULL; }
while (gf_list_count(esd->IPIDataSet)) {
GF_Descriptor *desc = (GF_Descriptor *)gf_list_get(esd->IPIDataSet, 0);
gf_list_rem(esd->IPIDataSet, 0);
gf_list_add(avc->descr->descriptors, desc);
}
while (gf_list_count(esd->IPMPDescriptorPointers)) {
GF_Descriptor *desc = (GF_Descriptor *)gf_list_get(esd->IPMPDescriptorPointers, 0);
gf_list_rem(esd->IPMPDescriptorPointers, 0);
gf_list_add(avc->descr->descriptors, desc);
}
if (esd->langDesc) {
gf_list_add(avc->descr->descriptors, esd->langDesc);
esd->langDesc = NULL;
}
while (gf_list_count(esd->extensionDescriptors)) {
GF_Descriptor *desc = (GF_Descriptor *)gf_list_get(esd->extensionDescriptors, 0);
gf_list_rem(esd->extensionDescriptors, 0);
gf_list_add(avc->descr->descriptors, desc);
}
}
/*update GF_AVCConfig*/
if (!avc->svc_config) {
if (!avc->avc_config) avc->avc_config = (GF_AVCConfigurationBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_AVCC);
if (esd->decoderConfig->decoderSpecificInfo && esd->decoderConfig->decoderSpecificInfo->data) {
if (avc->avc_config->config) gf_odf_avc_cfg_del(avc->avc_config->config);
avc->avc_config->config = gf_odf_avc_cfg_read(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
}
gf_odf_desc_del((GF_Descriptor *)esd);
}
AVC_RewriteESDescriptor(avc);
return GF_OK;
}
GF_Err gf_isom_set_meta_primary_item(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_id)
{
GF_MetaBox *meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta || !meta->item_infos || !meta->item_locations) return GF_BAD_PARAM;
/*either one or the other*/
if (gf_isom_has_meta_xml(file, root_meta, track_num)) return GF_BAD_PARAM;
if (meta->primary_resource) gf_isom_box_del((GF_Box*)meta->primary_resource);
meta->primary_resource = (GF_PrimaryItemBox*) gf_isom_box_new(GF_ISOM_BOX_TYPE_PITM);
meta->primary_resource->item_ID = item_id;
return GF_OK;
}
GF_Err tx3g_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_Box *a;
GF_Tx3gSampleEntryBox *ptr = (GF_Tx3gSampleEntryBox*)s;
if (ptr->size < 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->displayFlags = gf_bs_read_u32(bs);
ptr->horizontal_justification = gf_bs_read_u8(bs);
ptr->vertical_justification = gf_bs_read_u8(bs);
ptr->back_color = gpp_read_rgba(bs);
gpp_read_box(bs, &ptr->default_box);
gpp_read_style(bs, &ptr->default_style);
ptr->size -= 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE;
while (ptr->size >= 8) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box \"%s\" larger than remaining bytes in tx3g - ignoring box\n", gf_4cc_to_str(a->type)));
ptr->size = 0;
gf_isom_box_del(a);
return GF_OK;
}
ptr->size -= a->size;
if (a->type == GF_ISOM_BOX_TYPE_FTAB) {
if (ptr->font_table) gf_isom_box_del((GF_Box *)ptr->font_table);
ptr->font_table = (GF_FontTableBox *)a;
}
else {
e = gf_isom_box_add_default(s, a);
if (e) return e;
}
}
return GF_OK;
}
void meta_del(GF_Box *s)
{
GF_MetaBox *ptr = (GF_MetaBox *)s;
if (ptr == NULL) return;
gf_isom_box_del((GF_Box *)ptr->handler);
if (ptr->primary_resource) gf_isom_box_del((GF_Box *)ptr->primary_resource);
if (ptr->file_locations) gf_isom_box_del((GF_Box *)ptr->file_locations);
if (ptr->item_locations) gf_isom_box_del((GF_Box *)ptr->item_locations);
if (ptr->protections) gf_isom_box_del((GF_Box *)ptr->protections);
if (ptr->item_infos) gf_isom_box_del((GF_Box *)ptr->item_infos);
if (ptr->IPMP_control) gf_isom_box_del((GF_Box *)ptr->IPMP_control);
if (ptr->item_props) gf_isom_box_del((GF_Box *)ptr->item_props);
gf_free(ptr);
}
