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 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 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;
}
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 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 schm_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_SchemeTypeBox *ptr = (GF_SchemeTypeBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
gf_bs_write_u32(bs, ptr->scheme_type);
gf_bs_write_u32(bs, ptr->scheme_version);
if (ptr->flags & 0x000001) gf_bs_write_data(bs, ptr->URI, strlen(ptr->URI)+1);
return GF_OK;
}
GF_Err ahdr_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeDRMHeaderBox *ptr = (GF_AdobeDRMHeaderBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
e = gf_isom_box_write((GF_Box *) ptr->std_enc_params, bs);
if (e) return e;
return GF_OK;
}
GF_Err akey_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeKeyInfoBox *ptr = (GF_AdobeKeyInfoBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
e = gf_isom_box_write((GF_Box *) ptr->params, bs);
if (e) return e;
return GF_OK;
}
GF_Err data_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_DataBox *ptr = (GF_DataBox *) s;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_int(bs, ptr->reserved, 32);
if(ptr->data != NULL && ptr->dataSize > 0) {
gf_bs_write_data(bs, ptr->data, ptr->dataSize);
}
return GF_OK;
}
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_int(bs, ptr->IsEncrypted, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
return GF_OK;
}
GF_Err adaf_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeDRMAUFormatBox *ptr = (GF_AdobeDRMAUFormatBox *) 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->selective_enc);
gf_bs_write_u8(bs, 0x0);
gf_bs_write_u8(bs, ptr->IV_length);
return GF_OK;
}
GF_Err iSFM_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ISMASampleFormatBox *ptr = (GF_ISMASampleFormatBox *)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->selective_encryption, 1);
gf_bs_write_int(bs, 0, 7);
gf_bs_write_u8(bs, ptr->key_indicator_length);
gf_bs_write_u8(bs, ptr->IV_length);
return GF_OK;
}
GF_Err aeib_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeEncryptionInfoBox *ptr = (GF_AdobeEncryptionInfoBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
if (ptr->enc_algo) {
gf_bs_write_data(bs, (char *) ptr->enc_algo, (u32) strlen(ptr->enc_algo));
gf_bs_write_u8(bs, 0); //string end
}
gf_bs_write_u8(bs, ptr->key_length);
return GF_OK;
}
GF_Err iref_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 count, i;
GF_ItemReferenceBox *ptr = (GF_ItemReferenceBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
count = gf_list_count(ptr->references);
for (i = 0; i < count; i++) {
GF_Box *a = (GF_Box *)gf_list_get(ptr->references, i);
e = gf_isom_box_write(a, bs);
if (e) return e;
}
return e;
}
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 adkm_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeDRMKeyManagementSystemBox *ptr = (GF_AdobeDRMKeyManagementSystemBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
//ahdr
e = gf_isom_box_write((GF_Box *) ptr->header, bs);
if (e) return e;
//adaf
e = gf_isom_box_write((GF_Box *) ptr->au_format, bs);
if (e) return e;
return GF_OK;
}
GF_Err aprm_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeStdEncryptionParamsBox *ptr = (GF_AdobeStdEncryptionParamsBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
//aeib
e = gf_isom_box_write((GF_Box *) ptr->enc_info, bs);
if (e) return e;
//akey
e = gf_isom_box_write((GF_Box *) ptr->key_info, bs);
if (e) return e;
return GF_OK;
}
GF_Err odkm_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_OMADRMKMSBox *ptr = (GF_OMADRMKMSBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
if (ptr->hdr) {
e = gf_isom_box_write((GF_Box*)ptr->hdr, bs);
if (e) return e;
}
if (ptr->fmt) {
e = gf_isom_box_write((GF_Box*)ptr->fmt, bs);
if (e) return e;
}
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, ptr->index_size, 4);
item_count = gf_list_count(ptr->location_entries);
if (ptr->version < 2) {
gf_bs_write_u16(bs, item_count);
}
else {
gf_bs_write_u32(bs, item_count);
}
for (i = 0; i < item_count; i++) {
GF_ItemLocationEntry *location = (GF_ItemLocationEntry *)gf_list_get(ptr->location_entries, i);
if (ptr->version < 2) {
gf_bs_write_u16(bs, location->item_ID);
}
else {
gf_bs_write_u32(bs, location->item_ID);
}
if (ptr->version == 1 || ptr->version == 2) {
gf_bs_write_u16(bs, location->construction_method);
}
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);
if ((ptr->version == 1 || ptr->version == 2) && ptr->index_size > 0) {
gf_bs_write_long_int(bs, extent->extent_index, 8 * ptr->index_size);
}
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 meta_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_MetaBox *ptr = (GF_MetaBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
if (ptr->handler) {
e = gf_isom_box_write((GF_Box *) ptr->handler, bs);
if (e) return e;
}
if (ptr->primary_resource) {
e = gf_isom_box_write((GF_Box *) ptr->primary_resource, bs);
if (e) return e;
}
if (ptr->file_locations) {
e = gf_isom_box_write((GF_Box *) ptr->file_locations, bs);
if (e) return e;
}
if (ptr->item_locations) {
e = gf_isom_box_write((GF_Box *) ptr->item_locations, bs);
if (e) return e;
}
if (ptr->protections) {
e = gf_isom_box_write((GF_Box *) ptr->protections, bs);
if (e) return e;
}
if (ptr->item_infos) {
e = gf_isom_box_write((GF_Box *) ptr->item_infos, bs);
if (e) return e;
}
if (ptr->IPMP_control) {
e = gf_isom_box_write((GF_Box *) ptr->IPMP_control, bs);
if (e) return e;
}
if (ptr->item_refs) {
e = gf_isom_box_write((GF_Box *)ptr->item_refs, bs);
if (e) return e;
}
if (ptr->item_props) {
e = gf_isom_box_write((GF_Box *) ptr->item_props, 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;
}
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;
}
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 pssh_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ProtectionSystemHeaderBox *ptr = (GF_ProtectionSystemHeaderBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_data(bs, (char *) ptr->SystemID, 16);
if (ptr->version > 0) {
u32 i;
gf_bs_write_u32(bs, ptr->KID_count);
for (i=0; i<ptr->KID_count; i++)
gf_bs_write_data(bs, (char *) ptr->KIDs[i], 16);
}
if (ptr->private_data) {
gf_bs_write_u32(bs, ptr->private_data_size);
gf_bs_write_data(bs, (char *) ptr->private_data, ptr->private_data_size);
} else
gf_bs_write_u32(bs, 0);
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_OK;
}
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;
}