GF_Err sinf_Size(GF_Box *s)
{
GF_Err e;
GF_ProtectionInfoBox *ptr = (GF_ProtectionInfoBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_get_size(s);
if (e) return e;
e = gf_isom_box_size((GF_Box *) ptr->original_format);
if (e) return e;
ptr->size += ptr->original_format->size;
e = gf_isom_box_size((GF_Box *) ptr->scheme_type);
if (e) return e;
ptr->size += ptr->scheme_type->size;
e = gf_isom_box_size((GF_Box *) ptr->info);
if (e) return e;
ptr->size += ptr->info->size;
return GF_OK;
}
GF_Err odkm_Size(GF_Box *s)
{
GF_Err e;
GF_OMADRMKMSBox *ptr = (GF_OMADRMKMSBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_get_size(s);
if (e) return e;
if (ptr->hdr) {
e = gf_isom_box_size((GF_Box*)ptr->hdr);
if (e) return e;
ptr->size += ptr->hdr->size;
}
if (ptr->fmt) {
e = gf_isom_box_size((GF_Box*)ptr->fmt);
if (e) return e;
ptr->size += ptr->fmt->size;
}
return GF_OK;
}
GF_Err ahdr_Size(GF_Box *s)
{
GF_Err e;
GF_AdobeDRMHeaderBox *ptr = (GF_AdobeDRMHeaderBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_size((GF_Box *) ptr->std_enc_params);
if (e) return e;
ptr->size += ptr->std_enc_params->size;
return GF_OK;
}
GF_Err gppv_Size(GF_Box *s)
{
GF_Err e;
GF_3GPPVisualSampleEntryBox *ptr = (GF_3GPPVisualSampleEntryBox*)s;
e = gf_isom_box_get_size(s);
if (e) return e;
gf_isom_video_sample_entry_size((GF_VisualSampleEntryBox *)s);
e = gf_isom_box_size((GF_Box *)ptr->info);
if (e) return e;
ptr->size += ptr->info->size;
return GF_OK;
}
GF_Err gppa_Size(GF_Box *s)
{
GF_Err e;
GF_3GPPAudioSampleEntryBox *ptr = (GF_3GPPAudioSampleEntryBox *)s;
e = gf_isom_box_get_size(s);
if (e) return e;
gf_isom_audio_sample_entry_size((GF_AudioSampleEntryBox*)s);
e = gf_isom_box_size((GF_Box *)ptr->info);
if (e) return e;
ptr->size += ptr->info->size;
return GF_OK;
}
GF_Err wvtt_Size(GF_Box *s)
{
GF_Err e;
GF_WebVTTSampleEntryBox *wvtt = (GF_WebVTTSampleEntryBox *)s;
s->size += 8; // reserved and dataReferenceIndex
if (wvtt->config) {
e = gf_isom_box_size((GF_Box *)wvtt->config);
if (e) return e;
wvtt->size += wvtt->config->size;
}
return GF_OK;
}
GF_Err meta_Size(GF_Box *s)
{
GF_Err e;
GF_MetaBox *ptr = (GF_MetaBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_get_size(s);
if (e) return e;
if (ptr->handler) {
e = gf_isom_box_size((GF_Box *) ptr->handler);
if (e) return e;
ptr->size += ptr->handler->size;
}
if (ptr->primary_resource) {
e = gf_isom_box_size((GF_Box *) ptr->primary_resource);
if (e) return e;
ptr->size += ptr->primary_resource->size;
}
if (ptr->file_locations) {
e = gf_isom_box_size((GF_Box *) ptr->file_locations);
if (e) return e;
ptr->size += ptr->file_locations->size;
}
if (ptr->item_locations) {
e = gf_isom_box_size((GF_Box *) ptr->item_locations);
if (e) return e;
ptr->size += ptr->item_locations->size;
}
if (ptr->protections) {
e = gf_isom_box_size((GF_Box *) ptr->protections);
if (e) return e;
ptr->size += ptr->protections->size;
}
if (ptr->item_infos) {
e = gf_isom_box_size((GF_Box *) ptr->item_infos);
if (e) return e;
ptr->size += ptr->item_infos->size;
}
if (ptr->IPMP_control) {
e = gf_isom_box_size((GF_Box *) ptr->IPMP_control);
if (e) return e;
ptr->size += ptr->IPMP_control->size;
}
if (ptr->item_props) {
e = gf_isom_box_size((GF_Box *) ptr->item_props);
if (e) return e;
ptr->size += ptr->item_props->size;
}
return GF_OK;
}
GF_Err vtcu_Size(GF_Box *s)
{
GF_Err e;
GF_VTTCueBox *cuebox = (GF_VTTCueBox *)s;
e = gf_isom_box_get_size(s);
if (e) return e;
if (cuebox->id) {
e = gf_isom_box_size((GF_Box *)cuebox->id);
if (e) return e;
cuebox->size += cuebox->id->size;
}
if (cuebox->settings) {
e = gf_isom_box_size((GF_Box *)cuebox->settings);
if (e) return e;
cuebox->size += cuebox->settings->size;
}
if (cuebox->payload) {
e = gf_isom_box_size((GF_Box *)cuebox->payload);
if (e) return e;
cuebox->size += cuebox->payload->size;
}
return GF_OK;
}
GF_Err iref_Size(GF_Box *s)
{
GF_Err e = GF_OK;
u32 count, i;
GF_ItemReferenceBox *ptr = (GF_ItemReferenceBox *)s;
if (!s) return GF_BAD_PARAM;
count = gf_list_count(ptr->references);
for (i = 0; i < count; i++) {
GF_Box *a = (GF_Box *)gf_list_get(ptr->references, i);
e = gf_isom_box_size(a);
if (e) return e;
s->size += a->size;
}
return e;
}
GF_Err ipro_Size(GF_Box *s)
{
u32 i, count;
GF_Err e;
GF_ItemProtectionBox *ptr = (GF_ItemProtectionBox *)s;
if (!s) return GF_BAD_PARAM;
ptr->size += 2;
if ((count = gf_list_count(ptr->protection_information))) {
for (i = 0; i < count; i++) {
GF_Box *a = (GF_Box *)gf_list_get(ptr->protection_information, i);
e = gf_isom_box_size(a);
if (e) return e;
ptr->size += a->size;
}
}
return GF_OK;
}
GF_Err iinf_Size(GF_Box *s)
{
u32 i, count;
GF_Err e;
GF_ItemInfoBox *ptr = (GF_ItemInfoBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_get_size(s);
if (e) return e;
ptr->size += 2;
if ((count = gf_list_count(ptr->item_infos))) {
for (i = 0; i < count; i++) {
GF_Box *a = (GF_Box *)gf_list_get(ptr->item_infos, i);
e = gf_isom_box_size(a);
if (e) return e;
ptr->size += a->size;
}
}
return GF_OK;
}
u32 gf_isom_hint_sample_size(GF_HintSample *ptr)
{
u32 size, count, i;
GF_HintPacket *pck;
if (ptr->hint_subtype==GF_ISOM_BOX_TYPE_FDP_STSD) {
gf_isom_box_size((GF_Box*)ptr);
size = (u32) ptr->size;
} else {
size = 4;
count = gf_list_count(ptr->packetTable);
for (i=0; i<count; i++) {
pck = (GF_HintPacket *)gf_list_get(ptr->packetTable, i);
size += gf_isom_hint_pck_size(pck);
}
size += ptr->dataLength;
}
return size;
}
GF_ISOSample *gf_isom_webvtt_to_sample(void *s)
{
GF_Err e = GF_OK;
GF_ISOSample *res;
GF_BitStream *bs;
u32 i;
GF_WebVTTCue *cue;
GF_WebVTTSample *samp = (GF_WebVTTSample *)s;
if (!samp) return NULL;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if (gf_list_count(samp->cues)) {
i=0;
while ((cue = (GF_WebVTTCue *)gf_list_enum(samp->cues, &i))) {
e = webvtt_write_cue(bs, cue);
if (e) break;
}
if (e) {
gf_bs_del(bs);
return NULL;
}
} else {
GF_Box *cuebox = (GF_Box *)vtte_New();
e = gf_isom_box_size((GF_Box *)cuebox);
if (!e) e = gf_isom_box_write((GF_Box *)cuebox, bs);
gf_isom_box_del((GF_Box *)cuebox);
if (e) {
gf_bs_del(bs);
return NULL;
}
}
res = gf_isom_sample_new();
if (!res) {
gf_bs_del(bs);
return NULL;
}
gf_bs_get_content(bs, &res->data, &res->dataLength);
gf_bs_del(bs);
res->IsRAP = RAP;
return res;
}
GF_Err ListItem_Size(GF_Box *s)
{
GF_Err e;
GF_ListItemBox *ptr = (GF_ListItemBox *)s;
e = gf_isom_box_get_size(s);
if (e) return e;
/*iTune way*/
if (ptr->data && ptr->data->type) {
e = gf_isom_box_size((GF_Box *)ptr->data);
if (e) return e;
ptr->size += ptr->data->size;
}
/*QT way*/
else if (ptr->data) {
ptr->size += ptr->data->dataSize + 4;
}
return GF_OK;
}
GF_Err schi_Size(GF_Box *s)
{
GF_Err e;
GF_SchemeInformationBox *ptr = (GF_SchemeInformationBox *)s;
if (!s) return GF_BAD_PARAM;
if (ptr->ikms) {
e = gf_isom_box_size((GF_Box *) ptr->ikms);
if (e) return e;
ptr->size += ptr->ikms->size;
}
if (ptr->isfm) {
e = gf_isom_box_size((GF_Box *) ptr->isfm);
if (e) return e;
ptr->size += ptr->isfm->size;
}
if (ptr->islt) {
e = gf_isom_box_size((GF_Box *) ptr->islt);
if (e) return e;
ptr->size += ptr->isfm->size;
}
if (ptr->odkm) {
e = gf_isom_box_size((GF_Box *) ptr->odkm);
if (e) return e;
ptr->size += ptr->odkm->size;
}
if (ptr->tenc) {
e = gf_isom_box_size((GF_Box *) ptr->tenc);
if (e) return e;
ptr->size += ptr->tenc->size;
}
if (ptr->adkm) {
e = gf_isom_box_size((GF_Box *) ptr->adkm);
if (e) return e;
ptr->size += ptr->adkm->size;
}
if (ptr->piff_tenc) {
e = gf_isom_box_size((GF_Box *) ptr->piff_tenc);
if (e) return e;
ptr->size += ptr->piff_tenc->size;
}
return GF_OK;
}
static GF_Err webvtt_write_cue(GF_BitStream *bs, GF_WebVTTCue *cue)
{
GF_Err e;
GF_VTTCueBox *cuebox;
if (!cue) return GF_OK;
cuebox = (GF_VTTCueBox *)vtcu_New();
if (cue->id) {
cuebox->id = (GF_StringBox *)boxstring_new_with_data(GF_ISOM_BOX_TYPE_IDEN, cue->id);
}
if (cue->settings) {
cuebox->settings = (GF_StringBox *)boxstring_new_with_data(GF_ISOM_BOX_TYPE_STTG, cue->settings);
}
if (cue->text) {
cuebox->payload = (GF_StringBox *)boxstring_new_with_data(GF_ISOM_BOX_TYPE_PAYL, cue->text);
}
/* TODO: check if a time box should be written */
e = gf_isom_box_size((GF_Box *)cuebox);
if (!e) e = gf_isom_box_write((GF_Box *)cuebox, bs);
gf_isom_box_del((GF_Box *)cuebox);
return e;
}
//write the file track by track, with moov box before or after the mdat
GF_Err WriteFlat(MovieWriter *mw, u8 moovFirst, GF_BitStream *bs)
{
GF_Err e;
u32 i;
u64 offset, finalOffset, totSize, begin, firstSize, finalSize;
GF_Box *a;
GF_List *writers = gf_list_new();
GF_ISOFile *movie = mw->movie;
begin = totSize = 0;
//first setup the writers
e = SetupWriters(mw, writers, 0);
if (e) goto exit;
if (!moovFirst) {
if (movie->openMode == GF_ISOM_OPEN_WRITE) {
begin = 0;
totSize = gf_isom_datamap_get_offset(movie->editFileMap);
/*start boxes have not been written yet, do it*/
if (!totSize) {
if (movie->is_jp2) {
gf_bs_write_u32(movie->editFileMap->bs, 12);
gf_bs_write_u32(movie->editFileMap->bs, GF_4CC('j','P',' ',' '));
gf_bs_write_u32(movie->editFileMap->bs, 0x0D0A870A);
totSize += 12;
begin += 12;
}
if (movie->brand) {
e = gf_isom_box_size((GF_Box *)movie->brand); if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->brand, movie->editFileMap->bs); if (e) goto exit;
totSize += movie->brand->size;
begin += movie->brand->size;
}
if (movie->pdin) {
e = gf_isom_box_size((GF_Box *)movie->pdin); if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->pdin, movie->editFileMap->bs); if (e) goto exit;
totSize += movie->pdin->size;
begin += movie->pdin->size;
}
} else {
if (movie->is_jp2) begin += 12;
if (movie->brand) begin += movie->brand->size;
if (movie->pdin) begin += movie->pdin->size;
}
totSize -= begin;
} else {
if (movie->is_jp2) {
gf_bs_write_u32(bs, 12);
gf_bs_write_u32(bs, GF_4CC('j','P',' ',' '));
gf_bs_write_u32(bs, 0x0D0A870A);
}
if (movie->brand) {
e = gf_isom_box_size((GF_Box *)movie->brand);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->brand, bs);
if (e) goto exit;
}
/*then progressive download*/
if (movie->pdin) {
e = gf_isom_box_size((GF_Box *)movie->pdin);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->pdin, bs);
if (e) goto exit;
}
}
//if the moov is at the end, write directly
i=0;
while ((a = (GF_Box*)gf_list_enum(movie->TopBoxes, &i))) {
switch (a->type) {
/*written by hand*/
case GF_ISOM_BOX_TYPE_MOOV:
case GF_ISOM_BOX_TYPE_META:
case GF_ISOM_BOX_TYPE_FTYP:
case GF_ISOM_BOX_TYPE_PDIN:
break;
case GF_ISOM_BOX_TYPE_MDAT:
//in case we're capturing
if (movie->openMode == GF_ISOM_OPEN_WRITE) {
//emulate a write to recreate our tables (media data already written)
e = DoWrite(mw, writers, bs, 1, begin);
if (e) goto exit;
continue;
}
//to avoid computing the size each time write always 4 + 4 + 8 bytes before
begin = gf_bs_get_position(bs);
gf_bs_write_u64(bs, 0);
gf_bs_write_u64(bs, 0);
e = DoWrite(mw, writers, bs, 0, gf_bs_get_position(bs));
if (e) goto exit;
totSize = gf_bs_get_position(bs) - begin;
break;
default:
e = gf_isom_box_size(a);
if (e) goto exit;
e = gf_isom_box_write(a, bs);
if (e) goto exit;
break;
}
}
//OK, write the movie box.
e = WriteMoovAndMeta(movie, writers, bs);
if (e) goto exit;
/*if data has been written, update mdat size*/
if (totSize) {
offset = gf_bs_get_position(bs);
e = gf_bs_seek(bs, begin);
if (e) goto exit;
if (totSize > 0xFFFFFFFF) {
gf_bs_write_u32(bs, 1);
} else {
gf_bs_write_u32(bs, (u32) totSize);
}
gf_bs_write_u32(bs, GF_ISOM_BOX_TYPE_MDAT);
if (totSize > 0xFFFFFFFF) gf_bs_write_u64(bs, totSize);
e = gf_bs_seek(bs, offset);
}
movie->mdat->size = totSize;
goto exit;
}
//nope, we have to write the moov first. The pb is that
//1 - we don't know its size till the mdat is written
//2 - we don't know the ofset at which the mdat will start...
//3 - once the mdat is written, the chunkOffset table can have changed...
if (movie->is_jp2) {
gf_bs_write_u32(bs, 12);
gf_bs_write_u32(bs, GF_4CC('j','P',' ',' '));
gf_bs_write_u32(bs, 0x0D0A870A);
}
if (movie->brand) {
e = gf_isom_box_size((GF_Box *)movie->brand);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->brand, bs);
if (e) goto exit;
}
/*then progressive dnload*/
if (movie->pdin) {
e = gf_isom_box_size((GF_Box *)movie->pdin);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->pdin, bs);
if (e) goto exit;
}
//What we will do is first emulate the write from the begining...
//note: this will set the size of the mdat
e = DoWrite(mw, writers, bs, 1, gf_bs_get_position(bs));
if (e) goto exit;
firstSize = GetMoovAndMetaSize(movie, writers);
//offset = (firstSize > 0xFFFFFFFF ? firstSize + 8 : firstSize) + 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
offset = firstSize + 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
e = ShiftOffset(movie, writers, offset);
if (e) goto exit;
//get the size and see if it has changed (eg, we moved to 64 bit offsets)
finalSize = GetMoovAndMetaSize(movie, writers);
if (firstSize != finalSize) {
//we need to remove our offsets
ResetWriters(writers);
//finalOffset = (finalSize > 0xFFFFFFFF ? finalSize + 8 : finalSize) + 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
finalOffset = finalSize + 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
//OK, now we're sure about the final size.
//we don't need to re-emulate, as the only thing that changed is the offset
//so just shift the offset
e = ShiftOffset(movie, writers, finalOffset - offset);
if (e) goto exit;
}
//now write our stuff
e = WriteMoovAndMeta(movie, writers, bs);
if (e) goto exit;
e = gf_isom_box_size((GF_Box *)movie->mdat);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->mdat, bs);
if (e) goto exit;
//we don't need the offset as the moov is already written...
ResetWriters(writers);
e = DoWrite(mw, writers, bs, 0, 0);
if (e) goto exit;
//then the rest
i=0;
while ((a = (GF_Box*)gf_list_enum(movie->TopBoxes, &i))) {
switch (a->type) {
case GF_ISOM_BOX_TYPE_MOOV:
case GF_ISOM_BOX_TYPE_META:
case GF_ISOM_BOX_TYPE_FTYP:
case GF_ISOM_BOX_TYPE_PDIN:
case GF_ISOM_BOX_TYPE_MDAT:
break;
default:
e = gf_isom_box_size(a);
if (e) goto exit;
e = gf_isom_box_write(a, bs);
if (e) goto exit;
}
}
exit:
CleanWriters(writers);
gf_list_del(writers);
return e;
}
static GF_Err WriteInterleaved(MovieWriter *mw, GF_BitStream *bs, Bool drift_inter)
{
GF_Err e;
u32 i;
GF_Box *a;
u64 firstSize, finalSize, offset, finalOffset;
GF_List *writers = gf_list_new();
GF_ISOFile *movie = mw->movie;
//first setup the writers
e = SetupWriters(mw, writers, 1);
if (e) goto exit;
if (movie->is_jp2) {
gf_bs_write_u32(bs, 12);
gf_bs_write_u32(bs, GF_4CC('j','P',' ',' '));
gf_bs_write_u32(bs, 0x0D0A870A);
}
if (movie->brand) {
e = gf_isom_box_size((GF_Box *)movie->brand);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->brand, bs);
if (e) goto exit;
}
if (movie->pdin) {
e = gf_isom_box_size((GF_Box *)movie->pdin);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->pdin, bs);
if (e) goto exit;
}
e = DoInterleave(mw, writers, bs, 1, gf_bs_get_position(bs), drift_inter);
if (e) goto exit;
firstSize = GetMoovAndMetaSize(movie, writers);
offset = firstSize;
if (movie->mdat && movie->mdat->dataSize) offset += 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
e = ShiftOffset(movie, writers, offset);
if (e) goto exit;
//get the size and see if it has changed (eg, we moved to 64 bit offsets)
finalSize = GetMoovAndMetaSize(movie, writers);
if (firstSize != finalSize) {
//we need to remove our offsets
ResetWriters(writers);
finalOffset = finalSize;
if (movie->mdat->dataSize) finalOffset += 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
//OK, now we're sure about the final size -> shift the offsets
//we don't need to re-emulate, as the only thing that changed is the offset
//so just shift the offset
e = ShiftOffset(movie, writers, finalOffset - offset);
if (e) goto exit;
firstSize = GetMoovAndMetaSize(movie, writers);
}
//now write our stuff
e = WriteMoovAndMeta(movie, writers, bs);
if (e) goto exit;
/*we have 8 extra bytes for large size (not computed in gf_isom_box_size) */
if (movie->mdat && movie->mdat->dataSize) {
if (movie->mdat->dataSize > 0xFFFFFFFF) movie->mdat->dataSize += 8;
e = gf_isom_box_size((GF_Box *)movie->mdat);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->mdat, bs);
if (e) goto exit;
}
//we don't need the offset as we are writing...
ResetWriters(writers);
e = DoInterleave(mw, writers, bs, 0, 0, drift_inter);
if (e) goto exit;
//then the rest
i=0;
while ((a = (GF_Box*)gf_list_enum(movie->TopBoxes, &i))) {
switch (a->type) {
case GF_ISOM_BOX_TYPE_MOOV:
case GF_ISOM_BOX_TYPE_META:
case GF_ISOM_BOX_TYPE_FTYP:
case GF_ISOM_BOX_TYPE_PDIN:
case GF_ISOM_BOX_TYPE_MDAT:
break;
default:
e = gf_isom_box_size(a);
if (e) goto exit;
e = gf_isom_box_write(a, bs);
if (e) goto exit;
}
}
exit:
CleanWriters(writers);
gf_list_del(writers);
return e;
}
static GF_Err WriteInterleaved(MovieWriter *mw, GF_BitStream *bs, Bool drift_inter)
{
GF_Err e;
u8 converted;
u32 i;
GF_Box *a;
u64 offset, shift_offset, prev;
GF_List *writers = gf_list_new();
GF_ISOFile *movie = mw->movie;
//first setup the writers
e = SetupWriters(mw, writers, 1);
if (e) goto exit;
if (movie->is_jp2) {
gf_bs_write_u32(bs, 12);
gf_bs_write_u32(bs, GF_4CC('j','P',' ',' '));
gf_bs_write_u32(bs, 0x0D0A870A);
}
if (movie->brand) {
e = gf_isom_box_size((GF_Box *)movie->brand);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->brand, bs);
if (e) goto exit;
}
if (movie->pdin) {
e = gf_isom_box_size((GF_Box *)movie->pdin);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->pdin, bs);
if (e) goto exit;
}
e = DoInterleave(mw, writers, bs, 1, gf_bs_get_position(bs), drift_inter);
if (e) goto exit;
shift_offset = 0;
prev = 0;
for (;;) {
offset = GetMoovAndMetaSize(movie, writers);
if (offset==prev) break;
prev = offset;
if (movie->mdat && movie->mdat->dataSize)
offset += 8 + (movie->mdat->dataSize > 0xFFFFFFFF ? 8 : 0);
e = ShiftOffset(movie, writers, offset-shift_offset,&converted);
if (e) goto exit;
shift_offset = offset;
}
//now write our stuff
e = WriteMoovAndMeta(movie, writers, bs);
if (e) goto exit;
/*we have 8 extra bytes for large size (not computed in gf_isom_box_size) */
if (movie->mdat && movie->mdat->dataSize) {
if (movie->mdat->dataSize > 0xFFFFFFFF) movie->mdat->dataSize += 8;
e = gf_isom_box_size((GF_Box *)movie->mdat);
if (e) goto exit;
e = gf_isom_box_write((GF_Box *)movie->mdat, bs);
if (e) goto exit;
}
//we don't need the offset as we are writing...
ResetWriters(writers);
e = DoInterleave(mw, writers, bs, 0, 0, drift_inter);
if (e) goto exit;
//then the rest
i=0;
while ((a = (GF_Box*)gf_list_enum(movie->TopBoxes, &i))) {
switch (a->type) {
case GF_ISOM_BOX_TYPE_MOOV:
case GF_ISOM_BOX_TYPE_META:
case GF_ISOM_BOX_TYPE_FTYP:
case GF_ISOM_BOX_TYPE_PDIN:
case GF_ISOM_BOX_TYPE_MDAT:
break;
default:
e = gf_isom_box_size(a);
if (e) goto exit;
e = gf_isom_box_write(a, bs);
if (e) goto exit;
}
}
exit:
CleanWriters(writers);
gf_list_del(writers);
return e;
}
