GF_Err pssh_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ProtectionSystemHeaderBox *ptr = (GF_ProtectionSystemHeaderBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
gf_bs_read_data(bs, (char *) ptr->SystemID, 16);
ptr->size -= 16;
if (ptr->version > 0) {
ptr->KID_count = gf_bs_read_u32(bs);
ptr->size -= 4;
if (ptr->KID_count) {
u32 i;
ptr->KIDs = gf_malloc(sizeof(bin128));
for (i=0; i<ptr->KID_count; i++) {
gf_bs_read_data(bs, (char *) ptr->KIDs[i], 16);
ptr->size -= 16;
}
}
}
ptr->private_data_size = gf_bs_read_u32(bs);
ptr->size -= 4;
if (ptr->private_data_size) {
ptr->private_data = gf_malloc(sizeof(char)*ptr->private_data_size);
gf_bs_read_data(bs, (char *) ptr->private_data, ptr->private_data_size);
ptr->size -= ptr->private_data_size;
}
return GF_OK;
}
GF_Err aprm_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
return gf_isom_read_box_list(s, bs, aprm_AddBox);
}
GF_Err tenc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_TrackEncryptionBox *ptr = (GF_TrackEncryptionBox*)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
gf_bs_read_u8(bs); //reserved
if (!ptr->version) {
gf_bs_read_u8(bs); //reserved
}
else {
ptr->crypt_byte_block = gf_bs_read_int(bs, 4);
ptr->skip_byte_block = gf_bs_read_int(bs, 4);
}
ptr->isProtected = gf_bs_read_u8(bs);
ptr->Per_Sample_IV_Size = gf_bs_read_u8(bs);
gf_bs_read_data(bs, (char *)ptr->KID, 16);
ptr->size -= 20;
if ((ptr->isProtected == 1) && !ptr->Per_Sample_IV_Size) {
ptr->constant_IV_size = gf_bs_read_u8(bs);
gf_bs_read_data(bs, (char *)ptr->constant_IV, ptr->constant_IV_size);
ptr->size -= 1 + ptr->constant_IV_size;
}
return GF_OK;
}
GF_Err odkm_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
if (s == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
return gf_isom_read_box_list(s, bs, odkm_Add);
}
GF_Err pitm_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PrimaryItemBox *ptr = (GF_PrimaryItemBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->item_ID = gf_bs_read_u16(bs);
return GF_OK;
}
GF_Err meta_Read(GF_Box *s, GF_BitStream *bs)
{
u32 next_size = gf_bs_peek_bits(bs, 32, 4);
GF_Err e;
/*try to hack around QT files which don't use a full box for meta*/
if (next_size<s->size) {
e = gf_isom_full_box_read(s, bs);
if (e) return e;
}
return gf_isom_read_box_list(s, bs, meta_AddBox);
}
GF_Err odtt_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_OMADRMTransactionTrackingBox *ptr = (GF_OMADRMTransactionTrackingBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
gf_bs_read_data(bs, ptr->TransactionID, 16);
ptr->size -= 16;
return GF_OK;
}
GF_Err bxml_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_BinaryXMLBox *ptr = (GF_BinaryXMLBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->data_length = (u32)(ptr->size);
ptr->data = (char*)gf_malloc(sizeof(char)*ptr->data_length);
if (!ptr->data) return GF_OUT_OF_MEM;
gf_bs_read_data(bs, ptr->data, ptr->data_length);
return GF_OK;
}
GF_Err xml_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_XMLBox *ptr = (GF_XMLBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->xml_length = (u32)(ptr->size);
ptr->xml = (char *)gf_malloc(sizeof(char)*ptr->xml_length);
if (!ptr->xml) return GF_OUT_OF_MEM;
gf_bs_read_data(bs, ptr->xml, ptr->xml_length);
return GF_OK;
}
GF_Err odrb_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_OMADRMRightsObjectBox *ptr = (GF_OMADRMRightsObjectBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->oma_ro_size = (u32) ptr->size;
ptr->oma_ro = (char*) gf_malloc(sizeof(char)*ptr->oma_ro_size);
gf_bs_read_data(bs, ptr->oma_ro, ptr->oma_ro_size);
ptr->size = 0;
return GF_OK;
}
GF_Err iSFM_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ISMASampleFormatBox *ptr = (GF_ISMASampleFormatBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->selective_encryption = gf_bs_read_int(bs, 1);
gf_bs_read_int(bs, 7);
ptr->key_indicator_length = gf_bs_read_u8(bs);
ptr->IV_length = gf_bs_read_u8(bs);
return GF_OK;
}
GF_Err tenc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_TrackEncryptionBox *ptr = (GF_TrackEncryptionBox*)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->IsEncrypted = gf_bs_read_int(bs, 24);
ptr->IV_size = gf_bs_read_u8(bs);
gf_bs_read_data(bs, (char *) ptr->KID, 16);
ptr->size -= 20;
return GF_OK;
}
GF_Err iKMS_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 len;
GF_ISMAKMSBox *ptr = (GF_ISMAKMSBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
len = (u32) (ptr->size);
ptr->URI = (char*) gf_malloc(sizeof(char)*len);
if (!ptr->URI) return GF_OUT_OF_MEM;
gf_bs_read_data(bs, ptr->URI, len);
return GF_OK;
}
GF_Err adaf_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeDRMAUFormatBox *ptr = (GF_AdobeDRMAUFormatBox*)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->selective_enc = gf_bs_read_u8(bs);
gf_bs_read_u8(bs);//resersed
ptr->IV_length = gf_bs_read_u8(bs);
ptr->size -= 3;
return GF_OK;
}
GF_Err piff_pssh_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PIFFProtectionSystemHeaderBox *ptr = (GF_PIFFProtectionSystemHeaderBox*)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
gf_bs_read_data(bs, (char *)ptr->SystemID, 16);
ptr->private_data_size = gf_bs_read_u32(bs);
ptr->size -= 20;
ptr->private_data = gf_malloc(sizeof(char)*ptr->private_data_size);
gf_bs_read_data(bs, (char *)ptr->private_data, ptr->private_data_size);
ptr->size -= ptr->private_data_size;
return GF_OK;
}
GF_Err schm_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_SchemeTypeBox *ptr = (GF_SchemeTypeBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->scheme_type = gf_bs_read_u32(bs);
ptr->scheme_version = gf_bs_read_u32(bs);
ptr->size -= 8;
if (ptr->size && (ptr->flags & 0x000001)) {
u32 len = (u32) (ptr->size);
ptr->URI = (char*)gf_malloc(sizeof(char)*len);
if (!ptr->URI) return GF_OUT_OF_MEM;
gf_bs_read_data(bs, ptr->URI, len);
}
return GF_OK;
}
GF_Err data_Read(GF_Box *s,GF_BitStream *bs)
{
GF_Err e;
GF_DataBox *ptr = (GF_DataBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->reserved = gf_bs_read_int(bs, 32);
ptr->size -= 4;
if (ptr->size) {
ptr->dataSize = (u32) ptr->size;
ptr->data = (char*)gf_malloc(ptr->dataSize * sizeof(ptr->data[0]) + 1);
if (ptr->data == NULL) return GF_OUT_OF_MEM;
ptr->data[ptr->dataSize] = 0;
gf_bs_read_data(bs, ptr->data, ptr->dataSize);
}
return GF_OK;
}
GF_Err aeib_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_AdobeEncryptionInfoBox *ptr = (GF_AdobeEncryptionInfoBox*)s;
u32 len;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
len = (u32)ptr->size - 1;
if (len) {
if (ptr->enc_algo) return GF_ISOM_INVALID_FILE;
ptr->enc_algo = (char *)gf_malloc(len * sizeof(char));
gf_bs_read_data(bs, ptr->enc_algo, len);
}
ptr->key_length = gf_bs_read_u8(bs);
ptr->size = 0;
return GF_OK;
}
GF_Err infe_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
char *buf;
u32 buf_len, i, string_len, string_start;
GF_ItemInfoEntryBox *ptr = (GF_ItemInfoEntryBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->item_ID = gf_bs_read_u16(bs);
ptr->item_protection_index = gf_bs_read_u16(bs);
ptr->size -= 4;
buf_len = (u32) (ptr->size);
buf = (char*)gf_malloc(buf_len);
if (buf_len != gf_bs_read_data(bs, buf, buf_len)) {
gf_free(buf);
return GF_ISOM_INVALID_FILE;
}
string_len = 1;
string_start = 0;
for (i = 0; i < buf_len; i++) {
if (buf[i] == 0) {
if (!ptr->item_name) {
ptr->item_name = (char*)gf_malloc(sizeof(char)*string_len);
memcpy(ptr->item_name, buf+string_start, string_len);
} else if (!ptr->content_type) {
ptr->content_type = (char*)gf_malloc(sizeof(char)*string_len);
memcpy(ptr->content_type, buf+string_start, string_len);
} else {
ptr->content_encoding = (char*)gf_malloc(sizeof(char)*string_len);
memcpy(ptr->content_encoding, buf+string_start, string_len);
}
string_start += string_len;
string_len = 0;
}
string_len++;
}
gf_free(buf);
if (!ptr->item_name || !ptr->content_type) return GF_ISOM_INVALID_FILE;
return GF_OK;
}
GF_Err ohdr_Read(GF_Box *s, GF_BitStream *bs)
{
u16 cid_len, ri_len;
GF_Err e;
GF_OMADRMCommonHeaderBox *ptr = (GF_OMADRMCommonHeaderBox*)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->EncryptionMethod = gf_bs_read_u8(bs);
ptr->PaddingScheme = gf_bs_read_u8(bs);
ptr->PlaintextLength = gf_bs_read_u64(bs);
cid_len = gf_bs_read_u16(bs);
ri_len = gf_bs_read_u16(bs);
ptr->TextualHeadersLen = gf_bs_read_u16(bs);
ptr->size -= 1+1+8+2+2+2;
if (ptr->size<cid_len+ri_len+ptr->TextualHeadersLen) return GF_ISOM_INVALID_FILE;
if (cid_len) {
ptr->ContentID = (char *)gf_malloc(sizeof(char)*(cid_len+1));
gf_bs_read_data(bs, ptr->ContentID, cid_len);
ptr->ContentID[cid_len]=0;
}
if (ri_len) {
ptr->RightsIssuerURL = (char *)gf_malloc(sizeof(char)*(ri_len+1));
gf_bs_read_data(bs, ptr->RightsIssuerURL, ri_len);
ptr->RightsIssuerURL[ri_len]=0;
}
if (ptr->TextualHeadersLen) {
ptr->TextualHeaders = (char *)gf_malloc(sizeof(char)*(ptr->TextualHeadersLen+1));
gf_bs_read_data(bs, ptr->TextualHeaders, ptr->TextualHeadersLen);
ptr->TextualHeaders[ptr->TextualHeadersLen] = 0;
}
ptr->size -= cid_len+ri_len+ptr->TextualHeadersLen;
return gf_isom_read_box_list(s, bs, ohdr_AddBox);
}
GF_Err iloc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 item_count, extent_count, i, j;
GF_ItemLocationBox *ptr = (GF_ItemLocationBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
ptr->offset_size = gf_bs_read_int(bs, 4);
ptr->length_size = gf_bs_read_int(bs, 4);
ptr->base_offset_size = gf_bs_read_int(bs, 4);
gf_bs_read_int(bs, 4);
item_count = gf_bs_read_u16(bs);
for (i = 0; i < item_count; i++) {
GF_ItemLocationEntry *location_entry = (GF_ItemLocationEntry *)gf_malloc(sizeof(GF_ItemLocationEntry));
gf_list_add(ptr->location_entries, location_entry);
location_entry->item_ID = gf_bs_read_u16(bs);
location_entry->data_reference_index = gf_bs_read_u16(bs);
location_entry->base_offset = gf_bs_read_int(bs, 8*ptr->base_offset_size);
#ifndef GPAC_DISABLE_ISOM_WRITE
location_entry->original_base_offset = location_entry->base_offset;
#endif
extent_count = gf_bs_read_u16(bs);
location_entry->extent_entries = gf_list_new();
for (j = 0; j < extent_count; j++) {
GF_ItemExtentEntry *extent_entry = (GF_ItemExtentEntry *)gf_malloc(sizeof(GF_ItemExtentEntry));
gf_list_add(location_entry->extent_entries, extent_entry);
extent_entry->extent_offset = gf_bs_read_int(bs, 8*ptr->offset_size);
extent_entry->extent_length = gf_bs_read_int(bs, 8*ptr->length_size);
#ifndef GPAC_DISABLE_ISOM_WRITE
extent_entry->original_extent_offset = extent_entry->extent_offset;
#endif
}
}
return GF_OK;
}
GF_Err iinf_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_Box *a;
u32 count;
GF_ItemInfoBox *ptr = (GF_ItemInfoBox *)s;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
count = gf_bs_read_u16(bs);
while (count) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) return GF_ISOM_INVALID_FILE;
if (a->type == GF_ISOM_BOX_TYPE_INFE)
gf_list_add(ptr->item_infos, a);
else
gf_isom_box_del(a);
count --;
}
return GF_OK;
}
GF_Err grpi_Read(GF_Box *s, GF_BitStream *bs)
{
u16 gid_len;
GF_Err e;
GF_OMADRMGroupIDBox *ptr = (GF_OMADRMGroupIDBox*)s;
if (ptr == NULL) return GF_BAD_PARAM;
e = gf_isom_full_box_read(s, bs);
if (e) return e;
gid_len = gf_bs_read_u16(bs);
ptr->GKEncryptionMethod = gf_bs_read_u8(bs);
ptr->GKLength = gf_bs_read_u16(bs);
ptr->size -= 1+2+2;
if (ptr->size<gid_len+ptr->GKLength) return GF_ISOM_INVALID_FILE;
ptr->GroupID = gf_malloc(sizeof(char)*(gid_len+1));
gf_bs_read_data(bs, ptr->GroupID, gid_len);
ptr->GroupID[gid_len]=0;
ptr->GroupKey = (char *)gf_malloc(sizeof(char)*ptr->GKLength);
gf_bs_read_data(bs, ptr->GroupKey, ptr->GKLength);
ptr->size -= gid_len+ptr->GKLength;
return GF_OK;
}
