GF_Err tenc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_TrackEncryptionBox *ptr = (GF_TrackEncryptionBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_u8(bs, 0x0); //reserved
if (!ptr->version) {
gf_bs_write_u8(bs, 0x0); //reserved
}
else {
gf_bs_write_int(bs, ptr->crypt_byte_block, 4);
gf_bs_write_int(bs, ptr->skip_byte_block, 4);
}
gf_bs_write_u8(bs, ptr->isProtected);
gf_bs_write_u8(bs, ptr->Per_Sample_IV_Size);
gf_bs_write_data(bs, (char *)ptr->KID, 16);
if ((ptr->isProtected == 1) && !ptr->Per_Sample_IV_Size) {
gf_bs_write_u8(bs, ptr->constant_IV_size);
gf_bs_write_data(bs, (char *)ptr->constant_IV, ptr->constant_IV_size);
}
return GF_OK;
}
GF_Err infe_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 len;
GF_ItemInfoEntryBox *ptr = (GF_ItemInfoEntryBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_u16(bs, ptr->item_ID);
gf_bs_write_u16(bs, ptr->item_protection_index);
if (ptr->item_name) {
len = (u32) strlen(ptr->item_name)+1;
gf_bs_write_data(bs, ptr->item_name, len);
} else {
gf_bs_write_byte(bs, 0, 1);
}
if (ptr->content_type) {
len = (u32) strlen(ptr->content_type)+1;
gf_bs_write_data(bs, ptr->content_type, len);
} else {
gf_bs_write_byte(bs, 0, 1);
}
if (ptr->content_encoding) {
len = (u32) strlen(ptr->content_encoding)+1;
gf_bs_write_data(bs, ptr->content_encoding, len);
} else {
gf_bs_write_byte(bs, 0, 1);
}
return GF_OK;
}
GF_EXPORT
GF_Err gf_odf_avc_cfg_write(GF_AVCConfig *cfg, char **outData, u32 *outSize)
{
u32 i, count;
GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_int(bs, cfg->configurationVersion, 8);
gf_bs_write_int(bs, cfg->AVCProfileIndication , 8);
gf_bs_write_int(bs, cfg->profile_compatibility, 8);
gf_bs_write_int(bs, cfg->AVCLevelIndication, 8);
gf_bs_write_int(bs, 0x3F, 6);
gf_bs_write_int(bs, cfg->nal_unit_size - 1, 2);
gf_bs_write_int(bs, 0x7, 3);
count = gf_list_count(cfg->sequenceParameterSets);
gf_bs_write_int(bs, count, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_list_get(cfg->sequenceParameterSets, i);
gf_bs_write_int(bs, sl->size, 16);
gf_bs_write_data(bs, sl->data, sl->size);
}
count = gf_list_count(cfg->pictureParameterSets);
gf_bs_write_int(bs, count, 8);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_list_get(cfg->pictureParameterSets, i);
gf_bs_write_int(bs, sl->size, 16);
gf_bs_write_data(bs, sl->data, sl->size);
}
*outSize = 0;
*outData = NULL;
gf_bs_get_content(bs, outData, outSize);
gf_bs_del(bs);
return GF_OK;
}
GF_EXPORT
GF_Err gf_oci_codec_encode(OCICodec *codec, char **outAU, u32 *au_length)
{
GF_BitStream *bs;
u32 i, size, desc_size;
GF_Err e;
OCIEvent *ev;
if (!codec || !codec->Mode || *outAU) return GF_BAD_PARAM;
bs = NULL;
size = 0;
//get the size of each event
i=0;
while ((ev = (OCIEvent *)gf_list_enum(codec->OCIEvents, &i))) {
//fixed size header
size += 10;
e = gf_odf_size_descriptor_list(codec->OCIEvents, &desc_size);
if (e) goto err_exit;
size += desc_size;
}
//encode
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
e = WriteSevenBitLength(bs, size);
if (e) goto err_exit;
//get one event, write it and delete it
while (gf_list_count(codec->OCIEvents)) {
ev = (OCIEvent *)gf_list_get(codec->OCIEvents, 0);
gf_list_rem(codec->OCIEvents, 0);
gf_bs_write_int(bs, ev->EventID, 15);
gf_bs_write_int(bs, ev->AbsoluteTimeFlag, 1);
gf_bs_write_data(bs, ev->StartingTime, 4);
gf_bs_write_data(bs, ev->duration, 4);
e = gf_odf_write_descriptor_list(bs, ev->OCIDescriptors);
gf_oci_event_del(ev);
if (e) goto err_exit;
//OCI Event is aligned
gf_bs_align(bs);
}
gf_bs_get_content(bs, outAU, au_length);
gf_bs_del(bs);
return GF_OK;
err_exit:
if (bs) gf_bs_del(bs);
//delete everything
while (gf_list_count(codec->OCIEvents)) {
ev = (OCIEvent *)gf_list_get(codec->OCIEvents, 0);
gf_list_rem(codec->OCIEvents, 0);
gf_oci_event_del(ev);
}
return e;
}
GF_Err ohdr_Write(GF_Box *s, GF_BitStream *bs)
{
u16 cid_len, ri_len;
GF_Err e;
GF_OMADRMCommonHeaderBox *ptr = (GF_OMADRMCommonHeaderBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->EncryptionMethod);
gf_bs_write_u8(bs, ptr->PaddingScheme);
gf_bs_write_u64(bs, ptr->PlaintextLength);
cid_len = ptr->ContentID ? (u16) strlen(ptr->ContentID) : 0;
gf_bs_write_u16(bs, cid_len);
ri_len = ptr->RightsIssuerURL ? (u16) strlen(ptr->RightsIssuerURL) : 0;
gf_bs_write_u16(bs, ri_len);
gf_bs_write_u16(bs, ptr->TextualHeadersLen);
if (cid_len) gf_bs_write_data(bs, ptr->ContentID, (u32) strlen(ptr->ContentID));
if (ri_len) gf_bs_write_data(bs, ptr->RightsIssuerURL, (u32) strlen(ptr->RightsIssuerURL));
if (ptr->TextualHeadersLen) gf_bs_write_data(bs, ptr->TextualHeaders, ptr->TextualHeadersLen);
ISOM_DECREASE_SIZE(ptr, (cid_len+ri_len+ptr->TextualHeadersLen) );
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 piff_pssh_Write(GF_Box *s, GF_BitStream *bs)
{
GF_PIFFProtectionSystemHeaderBox *ptr = (GF_PIFFProtectionSystemHeaderBox *) s;
GF_Err e = gf_isom_full_box_write(s, bs);
if (e) return e;
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 Write_ImmediateDTE(GF_ImmediateDTE *dte, GF_BitStream *bs)
{
char data[14];
gf_bs_write_u8(bs, dte->source);
gf_bs_write_u8(bs, dte->dataLength);
gf_bs_write_data(bs, dte->data, dte->dataLength);
if (dte->dataLength < 14) {
memset(data, 0, 14);
gf_bs_write_data(bs, data, 14 - dte->dataLength);
}
return GF_OK;
}
GF_EXPORT
GF_Err gf_odf_avc_cfg_write(GF_AVCConfig *cfg, char **outData, u32 *outSize)
{
u32 i, count;
GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_int(bs, cfg->configurationVersion, 8);
gf_bs_write_int(bs, cfg->AVCProfileIndication , 8);
gf_bs_write_int(bs, cfg->profile_compatibility, 8);
gf_bs_write_int(bs, cfg->AVCLevelIndication, 8);
gf_bs_write_int(bs, 0x3F, 6);
gf_bs_write_int(bs, cfg->nal_unit_size - 1, 2);
gf_bs_write_int(bs, 0x7, 3);
count = gf_list_count(cfg->sequenceParameterSets);
gf_bs_write_int(bs, count, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_list_get(cfg->sequenceParameterSets, i);
gf_bs_write_int(bs, sl->size, 16);
gf_bs_write_data(bs, sl->data, sl->size);
}
count = gf_list_count(cfg->pictureParameterSets);
gf_bs_write_int(bs, count, 8);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_list_get(cfg->pictureParameterSets, i);
gf_bs_write_int(bs, sl->size, 16);
gf_bs_write_data(bs, sl->data, sl->size);
}
switch (cfg->AVCProfileIndication) {
case 100:
case 110:
case 122:
case 144:
gf_bs_write_int(bs, 0xFF, 6);
gf_bs_write_int(bs, cfg->chroma_format, 2);
gf_bs_write_int(bs, 0xFF, 5);
gf_bs_write_int(bs, cfg->luma_bit_depth - 8, 3);
gf_bs_write_int(bs, 0xFF, 5);
gf_bs_write_int(bs, cfg->chroma_bit_depth - 8, 3);
count = cfg->sequenceParameterSetExtensions ? gf_list_count(cfg->sequenceParameterSetExtensions) : 0;
gf_bs_write_u8(bs, count);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(cfg->sequenceParameterSetExtensions, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
break;
}
*outSize = 0;
*outData = NULL;
gf_bs_get_content(bs, outData, outSize);
gf_bs_del(bs);
return GF_OK;
}
static void gf_isom_write_tx3g(GF_Tx3gSampleEntryBox *a, GF_BitStream *bs, u32 sidx, u32 sidx_offset)
{
u32 size, j, fount_count;
void gpp_write_rgba(GF_BitStream *bs, u32 col);
void gpp_write_box(GF_BitStream *bs, GF_BoxRecord *rec);
void gpp_write_style(GF_BitStream *bs, GF_StyleRecord *rec);
if (sidx_offset) gf_bs_write_u8(bs, sidx + sidx_offset);
/*SINCE WINCE HAS A READONLY VERSION OF MP4 WE MUST DO IT BY HAND*/
size = 8 + 18 + 8 + 12;
size += 8 + 2;
fount_count = 0;
if (a->font_table) {
fount_count = a->font_table->entry_count;
for (j = 0; j<fount_count; j++) {
size += 3;
if (a->font_table->fonts[j].fontName) size += (u32)strlen(a->font_table->fonts[j].fontName);
}
}
/*write TextSampleEntry box*/
gf_bs_write_u32(bs, size);
gf_bs_write_u32(bs, a->type);
gf_bs_write_data(bs, a->reserved, 6);
gf_bs_write_u16(bs, a->dataReferenceIndex);
gf_bs_write_u32(bs, a->displayFlags);
gf_bs_write_u8(bs, a->horizontal_justification);
gf_bs_write_u8(bs, a->vertical_justification);
gpp_write_rgba(bs, a->back_color);
gpp_write_box(bs, &a->default_box);
gpp_write_style(bs, &a->default_style);
/*write font table box*/
size -= (8 + 18 + 8 + 12);
gf_bs_write_u32(bs, size);
gf_bs_write_u32(bs, GF_ISOM_BOX_TYPE_FTAB);
gf_bs_write_u16(bs, fount_count);
for (j = 0; j<fount_count; j++) {
gf_bs_write_u16(bs, a->font_table->fonts[j].fontID);
if (a->font_table->fonts[j].fontName) {
u32 len = (u32)strlen(a->font_table->fonts[j].fontName);
gf_bs_write_u8(bs, len);
gf_bs_write_data(bs, a->font_table->fonts[j].fontName, len);
}
else {
gf_bs_write_u8(bs, 0);
}
}
}
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 grpi_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u16 gid_len;
GF_OMADRMGroupIDBox *ptr = (GF_OMADRMGroupIDBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gid_len = ptr->GroupID ? (u16) strlen(ptr->GroupID) : 0;
gf_bs_write_u16(bs, gid_len);
gf_bs_write_u8(bs, ptr->GKEncryptionMethod);
gf_bs_write_u16(bs, ptr->GKLength);
gf_bs_write_data(bs, ptr->GroupID, gid_len);
gf_bs_write_data(bs, ptr->GroupKey, ptr->GKLength);
return GF_OK;
}
static GF_Err ISMA_ProcessData(ISMAEAPriv *priv, GF_IPMPEvent *evt)
{
if (!priv->crypt) return GF_SERVICE_ERROR;
if (!evt->is_encrypted) return GF_OK;
/*resync IV*/
if (!priv->last_IV || (priv->last_IV != evt->isma_BSO)) {
char IV[17];
u64 count;
u32 remain;
GF_BitStream *bs;
count = evt->isma_BSO / 16;
remain = (u32) (evt->isma_BSO % 16);
/*format IV to begin of counter*/
bs = gf_bs_new(IV, 17, GF_BITSTREAM_WRITE);
gf_bs_write_u8(bs, 0); /*begin of counter*/
gf_bs_write_data(bs, priv->salt, 8);
gf_bs_write_u64(bs, (s64) count);
gf_bs_del(bs);
gf_crypt_set_state(priv->crypt, IV, 17);
/*decrypt remain bytes*/
if (remain) {
char dummy[20];
gf_crypt_decrypt(priv->crypt, dummy, remain);
}
priv->last_IV = evt->isma_BSO;
}
/*decrypt*/
gf_crypt_decrypt(priv->crypt, evt->data, evt->data_size);
priv->last_IV += evt->data_size;
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 FDM_AddData(GF_FileDataMap *ptr, char *data, u32 dataSize)
{
u32 ret;
u64 orig;
if (ptr->mode == GF_ISOM_DATA_MAP_READ) return GF_BAD_PARAM;
orig = gf_bs_get_size(ptr->bs);
/*last access was read, seek to end of file*/
if (ptr->last_acces_was_read) {
gf_bs_seek(ptr->bs, orig);
ptr->last_acces_was_read = 0;
}
//OK, write our stuff to the datamap...
//we don't use bs here cause we want to know more about what has been written
ret = gf_bs_write_data(ptr->bs, data, dataSize);
if (ret != dataSize) {
ptr->curPos = orig;
gf_bs_seek(ptr->bs, orig);
return GF_IO_ERR;
}
ptr->curPos = gf_bs_get_position(ptr->bs);
//flush the stream !!
if (ptr->stream) fflush(ptr->stream);
return GF_OK;
}
/********************************************************************
Writing of DataTable entries in the RTP sample
********************************************************************/
GF_Err Write_EmptyDTE(GF_EmptyDTE *dte, GF_BitStream *bs)
{
gf_bs_write_u8(bs, dte->source);
//empty but always 15 bytes !!!
gf_bs_write_data(bs, "empty hint DTE", 15);
return GF_OK;
}
GF_Err gf_isom_hint_sample_write(GF_HintSample *ptr, GF_BitStream *bs)
{
u32 count, i;
GF_HintPacket *pck;
GF_Err e;
if (ptr->hint_subtype==GF_ISOM_BOX_TYPE_FDP_STSD) {
e = gf_isom_box_size((GF_Box*)ptr);
if (!e) e = gf_isom_box_write((GF_Box*)ptr, bs);
return e;
}
count = gf_list_count(ptr->packetTable);
gf_bs_write_u16(bs, count);
gf_bs_write_u16(bs, ptr->reserved);
//write the packet table
for (i=0; i<count; i++) {
pck = (GF_HintPacket *)gf_list_get(ptr->packetTable, i);
e = gf_isom_hint_pck_write(pck, bs);
if (e) return e;
}
//write additional data
if (ptr->AdditionalData) {
gf_bs_write_data(bs, ptr->AdditionalData, ptr->dataLength);
}
return GF_OK;
}
//Write a sample to the file - this is only called for self-contained media
GF_Err WriteSample(MovieWriter *mw, u32 size, u64 offset, u8 isEdited, GF_BitStream *bs)
{
GF_DataMap *map;
u32 bytes;
if (size>mw->size) {
mw->buffer = (char*)gf_realloc(mw->buffer, size);
mw->size = size;
}
if (!mw->buffer) return GF_OUT_OF_MEM;
if (isEdited) {
map = mw->movie->editFileMap;
} else {
map = mw->movie->movieFileMap;
}
//get the payload...
bytes = gf_isom_datamap_get_data(map, mw->buffer, size, offset);
if (bytes != size) return GF_IO_ERR;
//write it to our stream...
bytes = gf_bs_write_data(bs, mw->buffer, size);
if (bytes != size) return GF_IO_ERR;
mw->nb_done++;
gf_set_progress("ISO File Writing", mw->nb_done, mw->total_samples);
return GF_OK;
}
GF_EXPORT
GF_Err gf_odf_encode_ui_config(GF_UIConfig *cfg, GF_DefaultDescriptor **out_dsi)
{
u32 i, len;
GF_BitStream *bs;
GF_DefaultDescriptor *dsi;
if (!out_dsi || (cfg->tag != GF_ODF_UI_CFG_TAG)) return GF_BAD_PARAM;
*out_dsi = NULL;
if (!cfg->deviceName) return GF_OK;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
len = strlen(cfg->deviceName);
gf_bs_write_int(bs, len, 8);
for (i=0; i<len; i++) gf_bs_write_int(bs, cfg->deviceName[i], 8);
if (!stricmp(cfg->deviceName, "StringSensor")) {
/*fixme - this should be UTF-8 chars*/
if (cfg->delChar || cfg->termChar) {
gf_bs_write_int(bs, cfg->termChar, 8);
gf_bs_write_int(bs, cfg->delChar, 8);
}
}
if (cfg->ui_data) gf_bs_write_data(bs, cfg->ui_data, cfg->ui_data_length);
dsi = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
gf_bs_get_content(bs, &dsi->data, &dsi->dataLength);
gf_bs_del(bs);
*out_dsi = dsi;
return GF_OK;
}
void gf_ipmpx_write_array(GF_BitStream *bs, char *data, u32 data_len)
{
u32 length;
unsigned char vals[4];
if (!data || !data_len) return;
length = data_len;
vals[3] = (unsigned char) (length & 0x7f); length >>= 7;
vals[2] = (unsigned char) ((length & 0x7f) | 0x80); length >>= 7;
vals[1] = (unsigned char) ((length & 0x7f) | 0x80); length >>= 7;
vals[0] = (unsigned char) ((length & 0x7f) | 0x80);
if (data_len < 0x00000080) {
gf_bs_write_int(bs, vals[3], 8);
} else if (data_len < 0x00004000) {
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else if (data_len < 0x00200000) {
gf_bs_write_int(bs, vals[1], 8);
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else if (data_len < 0x10000000) {
gf_bs_write_int(bs, vals[0], 8);
gf_bs_write_int(bs, vals[1], 8);
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else {
return;
}
gf_bs_write_data(bs, data, data_len);
}
GF_Err infe_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 len;
GF_ItemInfoEntryBox *ptr = (GF_ItemInfoEntryBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
if (ptr->version == 3) {
gf_bs_write_u32(bs, ptr->item_ID);
}
else {
gf_bs_write_u16(bs, ptr->item_ID);
}
gf_bs_write_u16(bs, ptr->item_protection_index);
if (ptr->version >= 2) {
gf_bs_write_u32(bs, ptr->item_type);
}
if (ptr->item_name) {
len = (u32) strlen(ptr->item_name)+1;
gf_bs_write_data(bs, ptr->item_name, len);
} else {
gf_bs_write_byte(bs, 0, 1);
}
if (ptr->item_type == GF_META_ITEM_TYPE_MIME || ptr->item_type == GF_META_ITEM_TYPE_URI) {
if (ptr->content_type) {
len = (u32)strlen(ptr->content_type) + 1;
gf_bs_write_data(bs, ptr->content_type, len);
}
else {
gf_bs_write_byte(bs, 0, 1);
}
}
if (ptr->item_type == GF_META_ITEM_TYPE_MIME) {
if (ptr->content_encoding) {
len = (u32)strlen(ptr->content_encoding) + 1;
gf_bs_write_data(bs, ptr->content_encoding, len);
}
else {
gf_bs_write_byte(bs, 0, 1);
}
}
return GF_OK;
}
GF_Err iKMS_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ISMAKMSBox *ptr = (GF_ISMAKMSBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_data(bs, ptr->URI, (u32) strlen(ptr->URI)+1);
return GF_OK;
}
GF_Err odrb_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_OMADRMRightsObjectBox *ptr = (GF_OMADRMRightsObjectBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_data(bs, ptr->oma_ro, ptr->oma_ro_size);
return GF_OK;
}
GF_Err bxml_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_BinaryXMLBox *ptr = (GF_BinaryXMLBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
if (ptr->data_length) gf_bs_write_data(bs, ptr->data, ptr->data_length);
return GF_OK;
}
GF_Err odtt_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_OMADRMTransactionTrackingBox *ptr = (GF_OMADRMTransactionTrackingBox*)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_data(bs, ptr->TransactionID, 16);
return GF_OK;
}
static void rewrite_nalus_list(GF_List *nalus, GF_BitStream *bs, Bool rewrite_start_codes, u32 nal_unit_size_field)
{
u32 i, count = gf_list_count(nalus);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = gf_list_get(nalus, i);
if (rewrite_start_codes) gf_bs_write_u32(bs, 1);
else gf_bs_write_int(bs, sl->size, 8*nal_unit_size_field);
gf_bs_write_data(bs, sl->data, sl->size);
}
}
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 xml_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_XMLBox *ptr = (GF_XMLBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
if (ptr->xml) gf_bs_write_data(bs, ptr->xml, (u32) strlen(ptr->xml));
gf_bs_write_u8(bs, 0);
return GF_OK;
}
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;
}
void gf_isom_audio_sample_entry_write(GF_AudioSampleEntryBox *ptr, GF_BitStream *bs)
{
gf_bs_write_data(bs, ptr->reserved, 6);
gf_bs_write_u16(bs, ptr->dataReferenceIndex);
gf_bs_write_u16(bs, ptr->version);
gf_bs_write_u16(bs, ptr->revision);
gf_bs_write_u32(bs, ptr->vendor);
gf_bs_write_u16(bs, ptr->channel_count);
gf_bs_write_u16(bs, ptr->bitspersample);
gf_bs_write_u16(bs, ptr->compression_id);
gf_bs_write_u16(bs, ptr->packet_size);
gf_bs_write_u16(bs, ptr->samplerate_hi);
gf_bs_write_u16(bs, ptr->samplerate_lo);
if (ptr->version==1) {
gf_bs_write_data(bs, (char *) ptr->extensions, 16);
} else if (ptr->version==2) {
gf_bs_write_data(bs, (char *) ptr->extensions, 36);
}
}