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