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 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;
}
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_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 iloc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 i, j, item_count, extent_count;
GF_ItemLocationBox *ptr = (GF_ItemLocationBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_int(bs, ptr->offset_size, 4);
gf_bs_write_int(bs, ptr->length_size, 4);
gf_bs_write_int(bs, ptr->base_offset_size, 4);
gf_bs_write_int(bs, 0, 4);
item_count = gf_list_count(ptr->location_entries);
gf_bs_write_u16(bs, item_count);
for (i = 0; i < item_count; i++) {
GF_ItemLocationEntry *location = (GF_ItemLocationEntry *)gf_list_get(ptr->location_entries, i);
gf_bs_write_u16(bs, location->item_ID);
gf_bs_write_u16(bs, location->data_reference_index);
gf_bs_write_long_int(bs, location->base_offset, 8*ptr->base_offset_size);
extent_count = gf_list_count(location->extent_entries);
gf_bs_write_u16(bs, extent_count);
for (j=0; j<extent_count; j++) {
GF_ItemExtentEntry *extent = (GF_ItemExtentEntry *)gf_list_get(location->extent_entries, j);
gf_bs_write_long_int(bs, extent->extent_offset, 8*ptr->offset_size);
gf_bs_write_long_int(bs, extent->extent_length, 8*ptr->length_size);
}
}
return GF_OK;
}
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 Write_SampleDTE(GF_SampleDTE *dte, GF_BitStream *bs)
{
gf_bs_write_u8(bs, dte->source);
gf_bs_write_u8(bs, dte->trackRefIndex);
gf_bs_write_u16(bs, dte->dataLength);
gf_bs_write_u32(bs, dte->sampleNumber);
gf_bs_write_u32(bs, dte->byteOffset);
gf_bs_write_u16(bs, dte->bytesPerComp);
gf_bs_write_u16(bs, dte->samplesPerComp);
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 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 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;
}
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 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 gf_isom_hint_rtp_write(GF_RTPPacket *ptr, GF_BitStream *bs)
{
GF_Err e;
u32 TLVcount, DTEcount, i;
GF_Box none;
GF_GenericDTE *dte;
gf_bs_write_u32(bs, ptr->relativeTransTime);
//RTP Header
// gf_bs_write_int(bs, 2, 2);
//version is 2
gf_bs_write_int(bs, 2, 2);
gf_bs_write_int(bs, ptr->P_bit, 1);
gf_bs_write_int(bs, ptr->X_bit, 1);
gf_bs_write_int(bs, 0, 4);
gf_bs_write_int(bs, ptr->M_bit, 1);
gf_bs_write_int(bs, ptr->payloadType, 7);
gf_bs_write_u16(bs, ptr->SequenceNumber);
gf_bs_write_int(bs, 0, 13);
TLVcount = gf_list_count(ptr->TLV);
DTEcount = gf_list_count(ptr->DataTable);
gf_bs_write_int(bs, TLVcount ? 1 : 0, 1);
gf_bs_write_int(bs, ptr->B_bit, 1);
gf_bs_write_int(bs, ptr->R_bit, 1);
gf_bs_write_u16(bs, DTEcount);
if (TLVcount) {
//first write the size of the table ...
none.size = 4; //WE INCLUDE THE SIZE FIELD LENGTH
none.type = 0;
gf_isom_box_array_size(&none, ptr->TLV);
gf_bs_write_u32(bs, (u32) none.size);
e = gf_isom_box_array_write(&none, ptr->TLV, bs);
if (e) return e;
}
//write the DTE...
for (i = 0; i < DTEcount; i++) {
dte = (GF_GenericDTE *)gf_list_get(ptr->DataTable, i);
e = WriteDTE(dte, bs);
if (e) return e;
}
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;
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;
}
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);
}
GF_Err pitm_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PrimaryItemBox *ptr = (GF_PrimaryItemBox *)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);
return GF_OK;
}
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 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 gf_isom_hint_rtcp_write(GF_RTCPPacket *ptr, GF_BitStream *bs)
{
//RTP Header
gf_bs_write_int(bs, ptr->Version, 2);
gf_bs_write_int(bs, ptr->Padding, 1);
gf_bs_write_int(bs, ptr->Count, 5);
gf_bs_write_u8(bs, ptr->PayloadType);
gf_bs_write_u16(bs, 4*ptr->length);
gf_bs_write_data(bs, ptr->data, ptr->length);
return GF_OK;
}
GF_Err Write_StreamDescDTE(GF_StreamDescDTE *dte, GF_BitStream *bs)
{
gf_bs_write_u8(bs, dte->source);
gf_bs_write_u8(bs, dte->trackRefIndex);
gf_bs_write_u16(bs, dte->dataLength);
gf_bs_write_u32(bs, dte->streamDescIndex);
gf_bs_write_u32(bs, dte->byteOffset);
gf_bs_write_u32(bs, dte->reserved);
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;
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(ptr->HintType, pck, bs);
if (e) return e;
}
//write additional data
if (ptr->AdditionalData) {
gf_bs_write_data(bs, ptr->AdditionalData, ptr->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;
}
GF_Err gf_isom_rewrite_text_sample(GF_ISOSample *samp, u32 sampleDescriptionIndex, u32 sample_dur)
{
GF_BitStream *bs;
u32 pay_start, txt_size;
Bool is_utf_16 = 0;
if (!samp || !samp->data || !samp->dataLength) return GF_OK;
bs = gf_bs_new(samp->data, samp->dataLength, GF_BITSTREAM_READ);
txt_size = gf_bs_read_u16(bs);
gf_bs_del(bs);
/*remove BOM*/
pay_start = 2;
if (txt_size>2) {
/*seems 3GP only accepts BE UTF-16 (no LE, no UTF32)*/
if (((u8) samp->data[2]==(u8) 0xFE) && ((u8)samp->data[3]==(u8) 0xFF)) {
is_utf_16 = 1;
pay_start = 4;
txt_size -= 2;
}
}
/*rewrite as TTU(1)*/
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_int(bs, is_utf_16, 1);
gf_bs_write_int(bs, 0, 4);
gf_bs_write_int(bs, 1, 3);
gf_bs_write_u16(bs, 8 + samp->dataLength - pay_start);
gf_bs_write_u8(bs, sampleDescriptionIndex + SAMPLE_INDEX_OFFSET);
gf_bs_write_u24(bs, sample_dur);
/*write text size*/
gf_bs_write_u16(bs, txt_size);
if (txt_size) gf_bs_write_data(bs, samp->data + pay_start, samp->dataLength - pay_start);
gf_free(samp->data);
samp->data = NULL;
gf_bs_get_content(bs, &samp->data, &samp->dataLength);
gf_bs_del(bs);
return GF_OK;
}
static GF_ESD* get_esd()
{
GF_BitStream *dsi = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
GF_ESD *esd = gf_odf_desc_esd_new(0);
esd->ESID = 1;
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_RAW_MEDIA_STREAM;
esd->decoderConfig->avgBitrate = esd->decoderConfig->maxBitrate = 0;
esd->slConfig->timestampResolution = FM_FAKE_PULL_AUDIO_FREQ;
/*Decoder Specific Info for raw media*/
gf_bs_write_u32(dsi, FM_FAKE_PULL_AUDIO_FREQ); /*u32 sample_rate*/
gf_bs_write_u16(dsi, FM_FAKE_PULL_CHAN_NUM); /*u16 nb_channels*/
gf_bs_write_u16(dsi, FM_FAKE_PULL_BITS); /*u16 nb_bits_per_sample*/
gf_bs_write_u32(dsi, FM_FAKE_PULL_FRAME_LEN); /*u32 frame_size*/
gf_bs_write_u32(dsi, 0); /*u32 channel_config*/
gf_bs_get_content(dsi, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(dsi);
return esd;
}
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 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 ? strlen(ptr->ContentID) : 0;
gf_bs_write_u16(bs, cid_len);
ri_len = ptr->RightsIssuerURL ? 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, strlen(ptr->ContentID));
if (ri_len) gf_bs_write_data(bs, ptr->RightsIssuerURL, strlen(ptr->RightsIssuerURL));
if (ptr->TextualHeadersLen) gf_bs_write_data(bs, ptr->TextualHeaders, ptr->TextualHeadersLen);
ptr->size -= cid_len+ri_len+ptr->TextualHeadersLen;
return gf_isom_box_array_write(s, ptr->ExtendedHeaders, bs);
}
void gf_isom_video_sample_entry_write(GF_VisualSampleEntryBox *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_u32(bs, ptr->temporal_quality);
gf_bs_write_u32(bs, ptr->spatial_quality);
gf_bs_write_u16(bs, ptr->Width);
gf_bs_write_u16(bs, ptr->Height);
gf_bs_write_u32(bs, ptr->horiz_res);
gf_bs_write_u32(bs, ptr->vert_res);
gf_bs_write_u32(bs, ptr->entry_data_size);
gf_bs_write_u16(bs, ptr->frames_per_sample);
gf_bs_write_data(bs, ptr->compressor_name, 32);
gf_bs_write_u16(bs, ptr->bit_depth);
gf_bs_write_u16(bs, ptr->color_table_index);
}
GF_Err ipro_Write(GF_Box *s, GF_BitStream *bs)
{
u32 count, i;
GF_Err e;
GF_ItemProtectionBox *ptr = (GF_ItemProtectionBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
count = gf_list_count(ptr->protection_information);
gf_bs_write_u16(bs, count);
if (count) {
for (i = 0; i < count; i++) {
GF_Box *a = (GF_Box *)gf_list_get(ptr->protection_information, i);
e = gf_isom_box_write(a, bs);
if (e) return e;
}
}
return GF_OK;
}
GF_Err iinf_Write(GF_Box *s, GF_BitStream *bs)
{
u32 count;
GF_Err e;
GF_ItemInfoBox *ptr = (GF_ItemInfoBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
count = gf_list_count(ptr->item_infos);
if (ptr->version == 0)
gf_bs_write_u16(bs, count);
else
gf_bs_write_u32(bs, count);
if (count) {
gf_isom_box_array_write(s, ptr->item_infos, bs);
}
return GF_OK;
}
