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; }