GF_Err schi_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_SchemeInformationBox *ptr = (GF_SchemeInformationBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
if (ptr->ikms) {
e = gf_isom_box_write((GF_Box *) ptr->ikms, bs);
if (e) return e;
}
if (ptr->isfm) {
e = gf_isom_box_write((GF_Box *) ptr->isfm, bs);
if (e) return e;
}
if (ptr->okms) {
e = gf_isom_box_write((GF_Box *) ptr->okms, bs);
if (e) return e;
}
if (ptr->tenc) {
e = gf_isom_box_write((GF_Box *) ptr->tenc, bs);
if (e) return e;
}
if (ptr->piff_tenc) {
e = gf_isom_box_write((GF_Box *) ptr->piff_tenc, bs);
if (e) return e;
}
return GF_OK;
}
GF_Err avcc_Write(GF_Box *s, GF_BitStream *bs)
{
u32 i, count;
GF_Err e;
GF_AVCConfigurationBox *ptr = (GF_AVCConfigurationBox *) s;
if (!s) return GF_BAD_PARAM;
if (!ptr->config) return GF_OK;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->config->configurationVersion);
gf_bs_write_u8(bs, ptr->config->AVCProfileIndication);
gf_bs_write_u8(bs, ptr->config->profile_compatibility);
gf_bs_write_u8(bs, ptr->config->AVCLevelIndication);
gf_bs_write_int(bs, 0x3F, 6);
gf_bs_write_int(bs, ptr->config->nal_unit_size - 1, 2);
gf_bs_write_int(bs, 0x7, 3);
count = gf_list_count(ptr->config->sequenceParameterSets);
gf_bs_write_int(bs, count, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->sequenceParameterSets, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
count = gf_list_count(ptr->config->pictureParameterSets);
gf_bs_write_u8(bs, count);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->pictureParameterSets, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
return GF_OK;
}
GF_Err gppc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_3GPPConfigBox *ptr = (GF_3GPPConfigBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u32(bs, ptr->cfg.vendor);
gf_bs_write_u8(bs, ptr->cfg.decoder_version);
switch (ptr->cfg.type) {
case GF_ISOM_SUBTYPE_3GP_H263:
gf_bs_write_u8(bs, ptr->cfg.H263_level);
gf_bs_write_u8(bs, ptr->cfg.H263_profile);
break;
case GF_ISOM_SUBTYPE_3GP_AMR:
case GF_ISOM_SUBTYPE_3GP_AMR_WB:
gf_bs_write_u16(bs, ptr->cfg.AMR_mode_set);
gf_bs_write_u8(bs, ptr->cfg.AMR_mode_change_period);
gf_bs_write_u8(bs, ptr->cfg.frames_per_sample);
break;
case GF_ISOM_SUBTYPE_3GP_EVRC:
case GF_ISOM_SUBTYPE_3GP_QCELP:
case GF_ISOM_SUBTYPE_3GP_SMV:
gf_bs_write_u8(bs, ptr->cfg.frames_per_sample);
break;
}
return GF_OK;
}
GF_Err senc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 sample_count;
GF_SampleEncryptionBox *ptr = (GF_SampleEncryptionBox *) s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
//WARNING - PSEC (UUID) IS TYPECASTED TO SENC (FULL BOX) SO WE CANNOT USE USUAL FULL BOX FUNCTIONS
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
sample_count = gf_list_count(ptr->samp_aux_info);
gf_bs_write_u32(bs, sample_count);
if (sample_count) {
u32 i, j;
e = store_senc_info(ptr, bs);
if (e) return e;
for (i = 0; i < sample_count; i++) {
GF_CENCSampleAuxInfo *sai = (GF_CENCSampleAuxInfo *)gf_list_get(ptr->samp_aux_info, i);
//for cbcs scheme, IV_size is 0, constant IV shall be used. It is written in tenc box rather than in sai
if (sai->IV_size)
gf_bs_write_data(bs, (char *)sai->IV, sai->IV_size);
if (ptr->flags & 0x00000002) {
gf_bs_write_u16(bs, sai->subsample_count);
for (j = 0; j < sai->subsample_count; j++) {
gf_bs_write_u16(bs, sai->subsamples[j].bytes_clear_data);
gf_bs_write_u32(bs, sai->subsamples[j].bytes_encrypted_data);
}
}
}
}
return GF_OK;
}
GF_Err mdri_Write(GF_Box *s, GF_BitStream *bs)
{
// GF_OMADRMMutableInformationBox*ptr = (GF_OMADRMMutableInformationBox*)s;
GF_Err e = gf_isom_box_write_header(s, bs);
if (e) return e;
return GF_OK;
}
GF_Err mdri_Write(GF_Box *s, GF_BitStream *bs)
{
GF_OMADRMMutableInformationBox*ptr = (GF_OMADRMMutableInformationBox*)s;
GF_Err e = gf_isom_box_write_header(s, bs);
if (e) return e;
return gf_isom_box_array_write(s, ptr->boxes, bs);
}
GF_Err ilst_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
// GF_ItemListBox *ptr = (GF_ItemListBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
return GF_OK;
}
GF_Err frma_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_OriginalFormatBox *ptr = (GF_OriginalFormatBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u32(bs, ptr->data_format);
return GF_OK;
}
GF_Err gppa_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_3GPPAudioSampleEntryBox *ptr = (GF_3GPPAudioSampleEntryBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_isom_audio_sample_entry_write((GF_AudioSampleEntryBox*)s, bs);
return gf_isom_box_write((GF_Box *)ptr->info, bs);
}
GF_Err hvcc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_HEVCConfigurationBox *ptr = (GF_HEVCConfigurationBox *) s;
if (!s) return GF_BAD_PARAM;
if (!ptr->config) return GF_OK;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
return gf_odf_hevc_cfg_write_bs(ptr->config, bs);
}
GF_Err wvtt_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_WebVTTSampleEntryBox *wvtt = (GF_WebVTTSampleEntryBox *)s;
e = gf_isom_box_write_header(s, bs);
gf_bs_write_data(bs, wvtt->reserved, 6);
gf_bs_write_u16(bs, wvtt->dataReferenceIndex);
if (wvtt->config) gf_isom_box_write((GF_Box *)wvtt->config, bs);
return e;
}
GF_Err boxstring_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_StringBox *box = (GF_StringBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
if (box->string) {
gf_bs_write_data(bs, box->string, (u32)(box->size-8));
}
return e;
}
GF_Err gppv_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_3GPPVisualSampleEntryBox *ptr = (GF_3GPPVisualSampleEntryBox*)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_isom_video_sample_entry_write((GF_VisualSampleEntryBox *)s, bs);
e = gf_isom_box_write((GF_Box *)ptr->info, bs);
if (e) return e;
return GF_OK;
}
GF_Err btrt_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_MPEG4BitRateBox *ptr = (GF_MPEG4BitRateBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u32(bs, ptr->bufferSizeDB);
gf_bs_write_u32(bs, ptr->maxBitrate);
gf_bs_write_u32(bs, ptr->avgBitrate);
return GF_OK;
}
GF_Err flxs_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeFlashAccessParamsBox *ptr = (GF_AdobeFlashAccessParamsBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
if (ptr->metadata) {
gf_bs_write_data(bs, ptr->metadata, (u32) strlen(ptr->metadata));
gf_bs_write_u8(bs, 0); //string end
}
return GF_OK;
}
GF_Err ghnt_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_HintSampleEntryBox *ptr = (GF_HintSampleEntryBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_data(bs, ptr->reserved, 6);
gf_bs_write_u16(bs, ptr->dataReferenceIndex);
gf_bs_write_u16(bs, ptr->HintTrackVersion);
gf_bs_write_u16(bs, ptr->LastCompatibleVersion);
gf_bs_write_u32(bs, ptr->MaxPacketSize);
return GF_OK;
}
GF_Err ListItem_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ListItemBox *ptr = (GF_ListItemBox *) s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
/*iTune way*/
if (ptr->data->type) return gf_isom_box_write((GF_Box* )ptr->data, bs);
/*QT way*/
gf_bs_write_u16(bs, ptr->data->dataSize);
gf_bs_write_u16(bs, 0);
gf_bs_write_data(bs, ptr->data->data, ptr->data->dataSize);
return GF_OK;
}
GF_Err ireftype_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 i;
GF_ItemReferenceTypeBox *ptr = (GF_ItemReferenceTypeBox *)s;
ptr->type = ptr->reference_type;
e = gf_isom_box_write_header(s, bs);
ptr->type = GF_ISOM_BOX_TYPE_REFI;
if (e) return e;
gf_bs_write_u16(bs, ptr->from_item_id);
gf_bs_write_u16(bs, ptr->reference_count);
for (i = 0; i < ptr->reference_count; i++) {
gf_bs_write_u16(bs, ptr->to_item_IDs[i]);
}
return GF_OK;
}
GF_Err piff_pssh_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PIFFProtectionSystemHeaderBox *ptr = (GF_PIFFProtectionSystemHeaderBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
gf_bs_write_data(bs, (char *) ptr->SystemID, 16);
gf_bs_write_u32(bs, ptr->private_data_size);
gf_bs_write_data(bs, (char *) ptr->private_data, ptr->private_data_size);
return GF_OK;
}
GF_Err piff_tenc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PIFFTrackEncryptionBox *ptr = (GF_PIFFTrackEncryptionBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
gf_bs_write_int(bs, ptr->AlgorithmID, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
return GF_OK;
}
GF_Err sinf_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ProtectionSchemeInfoBox *ptr = (GF_ProtectionSchemeInfoBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
//frma
e = gf_isom_box_write((GF_Box *) ptr->original_format, bs);
if (e) return e;
// schm
e = gf_isom_box_write((GF_Box *) ptr->scheme_type, bs);
if (e) return e;
// schi
e = gf_isom_box_write((GF_Box *) ptr->info, bs);
if (e) return e;
return GF_OK;
}
GF_Err m4ds_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
char *enc_ods;
u32 enc_od_size;
GF_MPEG4ExtensionDescriptorsBox *ptr = (GF_MPEG4ExtensionDescriptorsBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
enc_ods = NULL;
enc_od_size = 0;
e = gf_odf_desc_list_write(ptr->descriptors, &enc_ods, &enc_od_size);
if (e) return e;
if (enc_od_size) {
gf_bs_write_data(bs, enc_ods, enc_od_size);
free(enc_ods);
}
return GF_OK;
}
GF_Err vtcu_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_VTTCueBox *cuebox = (GF_VTTCueBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
if (cuebox->id) {
e = gf_isom_box_write((GF_Box *)cuebox->id, bs);
if (e) return e;
}
if (cuebox->settings) {
e = gf_isom_box_write((GF_Box *)cuebox->settings, bs);
if (e) return e;
}
if (cuebox->payload) {
e = gf_isom_box_write((GF_Box *)cuebox->payload, bs);
}
return e;
}
GF_Err ftab_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 i;
GF_FontTableBox *ptr = (GF_FontTableBox *)s;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u16(bs, ptr->entry_count);
for (i=0; i<ptr->entry_count; i++) {
gf_bs_write_u16(bs, ptr->fonts[i].fontID);
if (ptr->fonts[i].fontName) {
u32 len = (u32) strlen(ptr->fonts[i].fontName);
gf_bs_write_u8(bs, len);
gf_bs_write_data(bs, ptr->fonts[i].fontName, len);
} else {
gf_bs_write_u8(bs, 0);
}
}
return GF_OK;
}
GF_Err piff_psec_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PIFFSampleEncryptionBox *ptr = (GF_PIFFSampleEncryptionBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
if (ptr->flags & 1) {
gf_bs_write_int(bs, ptr->AlgorithmID, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
}
gf_bs_write_u32(bs, ptr->sample_count);
if (ptr->cenc_data && ptr->cenc_data_size) {
gf_bs_write_data(bs, ptr->cenc_data, ptr->cenc_data_size);
}
return GF_OK;
}
GF_Err piff_psec_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 sample_count;
GF_SampleEncryptionBox *ptr = (GF_SampleEncryptionBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
if (ptr->flags & 1) {
gf_bs_write_int(bs, ptr->AlgorithmID, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
}
sample_count = gf_list_count(ptr->samp_aux_info);
gf_bs_write_u32(bs, sample_count);
if (sample_count) {
u32 i, j;
e = store_senc_info((GF_SampleEncryptionBox *)ptr, bs);
if (e) return e;
for (i = 0; i < sample_count; i++) {
GF_CENCSampleAuxInfo *sai = (GF_CENCSampleAuxInfo *)gf_list_get(ptr->samp_aux_info, i);
if (! sai->IV_size) continue;
gf_bs_write_data(bs, (char *)sai->IV, sai->IV_size);
gf_bs_write_u16(bs, sai->subsample_count);
for (j = 0; j < sai->subsample_count; j++) {
gf_bs_write_u16(bs, sai->subsamples[j].bytes_clear_data);
gf_bs_write_u32(bs, sai->subsamples[j].bytes_encrypted_data);
}
}
}
return GF_OK;
}
GF_Err avcc_Write(GF_Box *s, GF_BitStream *bs)
{
u32 i, count;
GF_Err e;
GF_AVCConfigurationBox *ptr = (GF_AVCConfigurationBox *) s;
if (!s) return GF_BAD_PARAM;
if (!ptr->config) return GF_OK;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->config->configurationVersion);
gf_bs_write_u8(bs, ptr->config->AVCProfileIndication);
gf_bs_write_u8(bs, ptr->config->profile_compatibility);
gf_bs_write_u8(bs, ptr->config->AVCLevelIndication);
if (ptr->type==GF_ISOM_BOX_TYPE_AVCC) {
gf_bs_write_int(bs, 0x3F, 6);
} else {
gf_bs_write_int(bs, ptr->config->complete_representation, 1);
gf_bs_write_int(bs, 0x1F, 5);
}
gf_bs_write_int(bs, ptr->config->nal_unit_size - 1, 2);
gf_bs_write_int(bs, 0x7, 3);
count = gf_list_count(ptr->config->sequenceParameterSets);
gf_bs_write_int(bs, count, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->sequenceParameterSets, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
count = gf_list_count(ptr->config->pictureParameterSets);
gf_bs_write_u8(bs, count);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->pictureParameterSets, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
if (ptr->type==GF_ISOM_BOX_TYPE_AVCC) {
switch (ptr->config->AVCProfileIndication) {
case 100:
case 110:
case 122:
case 144:
gf_bs_write_int(bs, 0xFF, 6);
gf_bs_write_int(bs, ptr->config->chroma_format, 2);
gf_bs_write_int(bs, 0xFF, 5);
gf_bs_write_int(bs, ptr->config->luma_bit_depth - 8, 3);
gf_bs_write_int(bs, 0xFF, 5);
gf_bs_write_int(bs, ptr->config->chroma_bit_depth - 8, 3);
count = ptr->config->sequenceParameterSetExtensions ? gf_list_count(ptr->config->sequenceParameterSetExtensions) : 0;
gf_bs_write_u8(bs, count);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->sequenceParameterSetExtensions, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
break;
}
}
return GF_OK;
}
GF_Err vtte_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
e = gf_isom_box_write_header(s, bs);
return e;
}
