GF_Err pssh_Read(GF_Box *s, GF_BitStream *bs)
{
GF_ProtectionSystemHeaderBox *ptr = (GF_ProtectionSystemHeaderBox *)s;
gf_bs_read_data(bs, (char *) ptr->SystemID, 16);
ISOM_DECREASE_SIZE(ptr, 16);
if (ptr->version > 0) {
ptr->KID_count = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 4);
if (ptr->KID_count) {
u32 i;
ptr->KIDs = gf_malloc(ptr->KID_count*sizeof(bin128));
for (i=0; i<ptr->KID_count; i++) {
gf_bs_read_data(bs, (char *) ptr->KIDs[i], 16);
ISOM_DECREASE_SIZE(ptr, 16);
}
}
}
ptr->private_data_size = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 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);
ISOM_DECREASE_SIZE(ptr, ptr->private_data_size);
}
return GF_OK;
}
GF_Err tenc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_TrackEncryptionBox *ptr = (GF_TrackEncryptionBox*)s;
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);
ISOM_DECREASE_SIZE(ptr, 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);
ISOM_DECREASE_SIZE(ptr, (1 + ptr->constant_IV_size) );
}
return GF_OK;
}
GF_Err piff_psec_Read(GF_Box *s, GF_BitStream *bs)
{
//u32 sample_count;
GF_SampleEncryptionBox *ptr = (GF_SampleEncryptionBox *)s;
if (ptr->size<4) return GF_ISOM_INVALID_FILE;
ptr->version = gf_bs_read_u8(bs);
ptr->flags = gf_bs_read_u24(bs);
ISOM_DECREASE_SIZE(ptr, 4);
if (ptr->flags & 1) {
ptr->AlgorithmID = gf_bs_read_int(bs, 24);
ptr->IV_size = gf_bs_read_u8(bs);
gf_bs_read_data(bs, (char *) ptr->KID, 16);
ISOM_DECREASE_SIZE(ptr, 20);
}
if (ptr->IV_size == 0)
ptr->IV_size = 8; //default to 8
ptr->bs_offset = gf_bs_get_position(bs);
/*sample_count = */gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 4);
if (ptr->IV_size != 8 && ptr->IV_size != 16) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] PIFF PSEC box incorrect IV size: %u - shall be 8 or 16\n", ptr->IV_size));
return GF_BAD_PARAM;
}
//as for senc, we skip parsing of the box until we have all saiz/saio info
ptr->size = 0;
return GF_OK;
}
GF_Err iinf_Read(GF_Box *s, GF_BitStream *bs)
{
GF_ItemInfoBox *ptr = (GF_ItemInfoBox *)s;
if (ptr->version == 0) {
ISOM_DECREASE_SIZE(s, 2)
gf_bs_read_u16(bs);
} else {
ISOM_DECREASE_SIZE(s, 4)
gf_bs_read_u32(bs);
}
return gf_isom_box_array_read(s, bs, iinf_AddBox);
}
GF_Err piff_pssh_Read(GF_Box *s, GF_BitStream *bs)
{
GF_PIFFProtectionSystemHeaderBox *ptr = (GF_PIFFProtectionSystemHeaderBox*)s;
gf_bs_read_data(bs, (char *) ptr->SystemID, 16);
ptr->private_data_size = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 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);
ISOM_DECREASE_SIZE(ptr, ptr->private_data_size);
return GF_OK;
}
GF_Err piff_tenc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_PIFFTrackEncryptionBox *ptr = (GF_PIFFTrackEncryptionBox*)s;
if (ptr->size<4) return GF_ISOM_INVALID_FILE;
ptr->version = gf_bs_read_u8(bs);
ptr->flags = gf_bs_read_u24(bs);
ISOM_DECREASE_SIZE(ptr, 4);
ptr->AlgorithmID = gf_bs_read_int(bs, 24);
ptr->IV_size = gf_bs_read_u8(bs);
gf_bs_read_data(bs, (char *) ptr->KID, 16);
ISOM_DECREASE_SIZE(ptr, 20);
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 odtt_Read(GF_Box *s, GF_BitStream *bs)
{
GF_OMADRMTransactionTrackingBox *ptr = (GF_OMADRMTransactionTrackingBox *)s;
gf_bs_read_data(bs, ptr->TransactionID, 16);
ISOM_DECREASE_SIZE(ptr, 16);
return GF_OK;
}
GF_Err iSLT_Read(GF_Box *s, GF_BitStream *bs)
{
GF_ISMACrypSaltBox *ptr = (GF_ISMACrypSaltBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
ISOM_DECREASE_SIZE(ptr, 8);
ptr->salt = gf_bs_read_u64(bs);
return GF_OK;
}
GF_Err infe_Read(GF_Box *s, GF_BitStream *bs)
{
char *buf;
u32 buf_len, i, string_len, string_start;
GF_ItemInfoEntryBox *ptr = (GF_ItemInfoEntryBox *)s;
ptr->item_ID = gf_bs_read_u16(bs);
ptr->item_protection_index = gf_bs_read_u16(bs);
ISOM_DECREASE_SIZE(ptr, 4);
if (ptr->version == 2) {
ptr->item_type = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 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;
if (ptr->content_encoding && ptr->version == 1) {
break;
}
}
string_len++;
}
gf_free(buf);
if (!ptr->item_name || (!ptr->content_type && ptr->version < 2)) return GF_ISOM_INVALID_FILE;
return GF_OK;
}
GF_Err adaf_Read(GF_Box *s, GF_BitStream *bs)
{
GF_AdobeDRMAUFormatBox *ptr = (GF_AdobeDRMAUFormatBox*)s;
ptr->selective_enc = gf_bs_read_u8(bs);
gf_bs_read_u8(bs);//resersed
ptr->IV_length = gf_bs_read_u8(bs);
ISOM_DECREASE_SIZE(ptr, 3);
return GF_OK;
}
GF_Err grpi_Read(GF_Box *s, GF_BitStream *bs)
{
u16 gid_len;
GF_OMADRMGroupIDBox *ptr = (GF_OMADRMGroupIDBox*)s;
gid_len = gf_bs_read_u16(bs);
ptr->GKEncryptionMethod = gf_bs_read_u8(bs);
ptr->GKLength = gf_bs_read_u16(bs);
ISOM_DECREASE_SIZE(ptr, (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);
ISOM_DECREASE_SIZE(ptr, (gid_len+ptr->GKLength) );
return GF_OK;
}
GF_Err senc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_SampleEncryptionBox *ptr = (GF_SampleEncryptionBox *)s;
//WARNING - PSEC (UUID) IS TYPECASTED TO SENC (FULL BOX) SO WE CANNOT USE USUAL FULL BOX FUNCTIONS
ptr->version = gf_bs_read_u8(bs);
ptr->flags = gf_bs_read_u24(bs);
ISOM_DECREASE_SIZE(ptr, 4);
ptr->bs_offset = gf_bs_get_position(bs);
gf_bs_skip_bytes(bs, ptr->size);
ptr->size = 0;
return GF_OK;
}
GF_Err ohdr_Read(GF_Box *s, GF_BitStream *bs)
{
u16 cid_len, ri_len;
GF_OMADRMCommonHeaderBox *ptr = (GF_OMADRMCommonHeaderBox*)s;
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);
ISOM_DECREASE_SIZE(ptr, (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;
}
ISOM_DECREASE_SIZE(ptr, (cid_len+ri_len+ptr->TextualHeadersLen) );
return gf_isom_box_array_read(s, bs, ohdr_AddBox);
}
GF_Err schm_Read(GF_Box *s, GF_BitStream *bs)
{
GF_SchemeTypeBox *ptr = (GF_SchemeTypeBox *)s;
ptr->scheme_type = gf_bs_read_u32(bs);
ptr->scheme_version = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 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;
}
