u32 gf_isom_fdm_get_data(GF_FileDataMap *ptr, char *buffer, u32 bufferLength, u64 fileOffset)
{
u32 bytesRead;
//can we seek till that point ???
if (fileOffset > gf_bs_get_size(ptr->bs)) return 0;
//ouch, we are not at the previous location, do a seek
if (ptr->curPos != fileOffset) {
if (gf_bs_seek(ptr->bs, fileOffset) != GF_OK) return 0;
ptr->curPos = fileOffset;
}
//read our data.
bytesRead = gf_bs_read_data(ptr->bs, buffer, bufferLength);
//update our cache
if (bytesRead == bufferLength) {
ptr->curPos += bytesRead;
} else {
gf_bs_get_refreshed_size(ptr->bs);
gf_bs_seek(ptr->bs, fileOffset);
bytesRead = gf_bs_read_data(ptr->bs, buffer, bufferLength);
//update our cache
if (bytesRead == bufferLength) {
ptr->curPos += bytesRead;
} else {
gf_bs_seek(ptr->bs, ptr->curPos);
bytesRead = 0;
}
}
ptr->last_acces_was_read = 1;
return bytesRead;
}
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 avcc_Read(GF_Box *s, GF_BitStream *bs)
{
u32 i, count;
GF_AVCConfigurationBox *ptr = (GF_AVCConfigurationBox *)s;
if (ptr->config) gf_odf_avc_cfg_del(ptr->config);
ptr->config = gf_odf_avc_cfg_new();
ptr->config->configurationVersion = gf_bs_read_u8(bs);
ptr->config->AVCProfileIndication = gf_bs_read_u8(bs);
ptr->config->profile_compatibility = gf_bs_read_u8(bs);
ptr->config->AVCLevelIndication = gf_bs_read_u8(bs);
gf_bs_read_int(bs, 6);
ptr->config->nal_unit_size = 1 + gf_bs_read_int(bs, 2);
gf_bs_read_int(bs, 3);
count = gf_bs_read_int(bs, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) malloc(sizeof(GF_AVCConfigSlot));
sl->size = gf_bs_read_u16(bs);
sl->data = (char *)malloc(sizeof(char) * sl->size);
gf_bs_read_data(bs, sl->data, sl->size);
gf_list_add(ptr->config->sequenceParameterSets, sl);
}
count = gf_bs_read_u8(bs);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot));
sl->size = gf_bs_read_u16(bs);
sl->data = (char *)malloc(sizeof(char) * sl->size);
gf_bs_read_data(bs, sl->data, sl->size);
gf_list_add(ptr->config->pictureParameterSets, sl);
}
return GF_OK;
}
GF_EXPORT
GF_AVCConfig *gf_odf_avc_cfg_read(char *dsi, u32 dsi_size)
{
u32 i, count;
GF_AVCConfig *avcc = gf_odf_avc_cfg_new();
GF_BitStream *bs = gf_bs_new(dsi, dsi_size, GF_BITSTREAM_READ);
avcc->configurationVersion = gf_bs_read_int(bs, 8);
avcc->AVCProfileIndication = gf_bs_read_int(bs, 8);
avcc->profile_compatibility = gf_bs_read_int(bs, 8);
avcc->AVCLevelIndication = gf_bs_read_int(bs, 8);
gf_bs_read_int(bs, 6);
avcc->nal_unit_size = 1 + gf_bs_read_int(bs, 2);
gf_bs_read_int(bs, 3);
count = gf_bs_read_int(bs, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->size = gf_bs_read_int(bs, 16);
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
gf_bs_read_data(bs, sl->data, sl->size);
gf_list_add(avcc->sequenceParameterSets, sl);
}
count = gf_bs_read_int(bs, 8);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->size = gf_bs_read_int(bs, 16);
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
gf_bs_read_data(bs, sl->data, sl->size);
gf_list_add(avcc->pictureParameterSets, sl);
}
gf_bs_del(bs);
return avcc;
}
GF_Err gf_isom_audio_sample_entry_read(GF_AudioSampleEntryBox *ptr, GF_BitStream *bs)
{
if (ptr->size<28) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->version = gf_bs_read_u16(bs);
ptr->revision = gf_bs_read_u16(bs);
ptr->vendor = gf_bs_read_u32(bs);
ptr->channel_count = gf_bs_read_u16(bs);
ptr->bitspersample = gf_bs_read_u16(bs);
ptr->compression_id = gf_bs_read_u16(bs);
ptr->packet_size = gf_bs_read_u16(bs);
ptr->samplerate_hi = gf_bs_read_u16(bs);
ptr->samplerate_lo = gf_bs_read_u16(bs);
ptr->size -= 28;
if (ptr->version==1) {
if (ptr->size<16) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, (char *) ptr->extensions, 16);
ptr->size-=16;
} else if (ptr->version==2) {
if (ptr->size<36) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, (char *) ptr->extensions, 36);
ptr->size -= 36;
}
return GF_OK;
}
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 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 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;
}
static GF_Err gf_isom_cenc_get_sai_by_saiz_saio(GF_MediaBox *mdia, u32 sampleNumber, u8 IV_size, GF_CENCSampleAuxInfo **sai)
{
GF_BitStream *bs;
u32 prev_sai_size, size, i, j, nb_saio;
u64 cur_position, offset;
GF_Err e = GF_OK;
char *buffer;
nb_saio = size = prev_sai_size = 0;
offset = 0;
for (i = 0; i < gf_list_count(mdia->information->sampleTable->sai_offsets); i++) {
GF_SampleAuxiliaryInfoOffsetBox *saio = (GF_SampleAuxiliaryInfoOffsetBox *)gf_list_get(mdia->information->sampleTable->sai_offsets, i);
if (saio->aux_info_type == GF_4CC('c', 'e', 'n', 'c')) {
if (saio->entry_count == 1)
offset = saio->version ? saio->offsets_large[0] : saio->offsets[0];
else
offset = saio->version ? saio->offsets_large[sampleNumber-1]: saio->offsets[sampleNumber-1];
nb_saio = saio->entry_count;
break;
}
}
for (i = 0; i < gf_list_count(mdia->information->sampleTable->sai_sizes); i++) {
GF_SampleAuxiliaryInfoSizeBox *saiz = (GF_SampleAuxiliaryInfoSizeBox *)gf_list_get(mdia->information->sampleTable->sai_sizes, i);
if (saiz->aux_info_type == GF_4CC('c', 'e', 'n', 'c')) {
for (j = 0; j < sampleNumber-1; j++)
prev_sai_size += saiz->default_sample_info_size ? saiz->default_sample_info_size : saiz->sample_info_size[j];
size = saiz->default_sample_info_size ? saiz->default_sample_info_size : saiz->sample_info_size[sampleNumber-1];
break;
}
}
offset += (nb_saio == 1) ? prev_sai_size : 0;
cur_position = gf_bs_get_position(mdia->information->dataHandler->bs);
gf_bs_seek(mdia->information->dataHandler->bs, offset);
buffer = (char *)gf_malloc(size);
gf_bs_read_data(mdia->information->dataHandler->bs, buffer, size);
gf_bs_seek(mdia->information->dataHandler->bs, cur_position);
*sai = (GF_CENCSampleAuxInfo *)gf_malloc(sizeof(GF_CENCSampleAuxInfo));
memset(*sai, 0, sizeof(GF_CENCSampleAuxInfo));
bs = gf_bs_new(buffer, size, GF_BITSTREAM_READ);
gf_bs_read_data(bs, (char *)(*sai)->IV, IV_size);
if (size > IV_size) {
(*sai)->subsample_count = gf_bs_read_u16(bs);
(*sai)->subsamples = (GF_CENCSubSampleEntry *)gf_malloc(sizeof(GF_CENCSubSampleEntry)*(*sai)->subsample_count);
for (i = 0; i < (*sai)->subsample_count; i++) {
(*sai)->subsamples[i].bytes_clear_data = gf_bs_read_u16(bs);
(*sai)->subsamples[i].bytes_encrypted_data = gf_bs_read_u32(bs);
}
}
gf_bs_del(bs);
return e;
}
GF_ISMASample *gf_isom_ismacryp_sample_from_data(char *data, u32 dataLength, Bool use_selective_encryption, u8 KI_length, u8 IV_length)
{
GF_ISMASample *s;
GF_BitStream *bs;
/*empty text sample*/
if (!data || !dataLength) {
return gf_isom_ismacryp_new_sample();
}
s = gf_isom_ismacryp_new_sample();
/*empty sample*/
if (!data || !dataLength) return s;
bs = gf_bs_new(data, dataLength, GF_BITSTREAM_READ);
s->dataLength = dataLength;
s->IV_length = IV_length;
s->KI_length = KI_length;
if (use_selective_encryption) {
s->flags = GF_ISOM_ISMA_USE_SEL_ENC;
if (s->dataLength < 1) goto exit;
if (gf_bs_read_int(bs, 1)) s->flags |= GF_ISOM_ISMA_IS_ENCRYPTED;
gf_bs_read_int(bs, 7);
s->dataLength -= 1;
} else {
s->flags = GF_ISOM_ISMA_IS_ENCRYPTED;
}
if (s->flags & GF_ISOM_ISMA_IS_ENCRYPTED) {
if (IV_length != 0) {
if (s->dataLength < IV_length) goto exit;
s->IV = gf_bs_read_long_int(bs, 8*IV_length);
s->dataLength -= IV_length;
}
if (KI_length) {
if (s->dataLength < KI_length) goto exit;
s->key_indicator = (u8 *)malloc(KI_length);
gf_bs_read_data(bs, (char*)s->key_indicator, KI_length);
s->dataLength -= KI_length;
}
}
s->data = (char*)malloc(sizeof(char)*s->dataLength);
gf_bs_read_data(bs, s->data, s->dataLength);
gf_bs_del(bs);
return s;
exit:
gf_isom_ismacryp_delete_sample(s);
return NULL;
}
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_psec_Read(GF_Box *s, GF_BitStream *bs)
{
u32 sample_count, i, j;
GF_PIFFSampleEncryptionBox *ptr = (GF_PIFFSampleEncryptionBox *)s;
if (ptr->size<4) return GF_ISOM_INVALID_FILE;
ptr->version = gf_bs_read_u8(bs);
ptr->flags = gf_bs_read_u24(bs);
ptr->size -= 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);
ptr->size -= 20;
}
if (ptr->IV_size == 0)
ptr->IV_size = 8; //default to 8
sample_count = gf_bs_read_u32(bs);
ptr->size -= 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;
}
ptr->samp_aux_info = gf_list_new();
for (i = 0; i<sample_count; ++i) {
GF_CENCSampleAuxInfo *sai;
GF_SAFEALLOC(sai, GF_CENCSampleAuxInfo);
if (!sai) return GF_OUT_OF_MEM;
sai->IV_size = ptr->IV_size;
gf_bs_read_data(bs, (char *)sai->IV, ptr->IV_size);
ptr->size -= ptr->IV_size;
if (ptr->flags & 2) {
sai->subsample_count = gf_bs_read_u16(bs);
sai->subsamples = gf_malloc(sai->subsample_count * sizeof(GF_CENCSubSampleEntry));
for (j = 0; j < sai->subsample_count; ++j) {
sai->subsamples[j].bytes_clear_data = gf_bs_read_u16(bs);
sai->subsamples[j].bytes_encrypted_data = gf_bs_read_u32(bs);
}
ptr->size -= 2 + sai->subsample_count * 6;
}
gf_list_add(ptr->samp_aux_info, sai);
}
ptr->bs_offset = gf_bs_get_position(bs);
assert(ptr->size == 0);
return GF_OK;
}
GF_Err ghnt_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Box *a;
GF_Err e;
GF_HintSampleEntryBox *ptr = (GF_HintSampleEntryBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
if (ptr->size < 16) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->HintTrackVersion = gf_bs_read_u16(bs);
ptr->LastCompatibleVersion = gf_bs_read_u16(bs);
ptr->MaxPacketSize = gf_bs_read_u32(bs);
ptr->size -= 16;
while (ptr->size) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
e = gf_list_add(ptr->HintDataTable, a);
if (e) return e;
ptr->size -= a->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 ListItem_Read(GF_Box *s,GF_BitStream *bs)
{
GF_Err e;
u32 sub_type;
GF_Box *a = NULL;
GF_ListItemBox *ptr = (GF_ListItemBox *)s;
/*iTunes way: there's a data atom containing the data*/
sub_type = gf_bs_peek_bits(bs, 32, 4);
if (sub_type == GF_ISOM_BOX_TYPE_DATA ) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) return GF_ISOM_INVALID_FILE;
ptr->size -= a->size;
if (a && ptr->data) gf_isom_box_del((GF_Box *) ptr->data);
ptr->data = (GF_DataBox *)a;
}
/*QT way*/
else {
ptr->data->type = 0;
ptr->data->dataSize = gf_bs_read_u16(bs);
gf_bs_read_u16(bs);
ptr->data->data = (char *) gf_malloc(sizeof(char)*(ptr->data->dataSize + 1));
gf_bs_read_data(bs, ptr->data->data, ptr->data->dataSize);
ptr->data->data[ptr->data->dataSize] = 0;
ptr->size -= ptr->data->dataSize;
}
return GF_OK;
}
/********************************************************************
Reading of DataTable entries in the RTP sample
********************************************************************/
GF_Err Read_EmptyDTE(GF_EmptyDTE *dte, GF_BitStream *bs)
{
char empty[15];
//empty but always 15 bytes !!!
gf_bs_read_data(bs, empty, 15);
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 ftab_Read(GF_Box *s, GF_BitStream *bs)
{
u32 i;
GF_FontTableBox *ptr = (GF_FontTableBox *)s;
ptr->entry_count = gf_bs_read_u16(bs);
ptr->size -= 2;
if (ptr->size<ptr->entry_count*3) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Corrupted ftap box, skipping\n"));
ptr->entry_count = 0;
return GF_OK;
}
ptr->fonts = (GF_FontRecord *) gf_malloc(sizeof(GF_FontRecord)*ptr->entry_count);
memset(ptr->fonts, 0, sizeof(GF_FontRecord)*ptr->entry_count);
for (i=0; i<ptr->entry_count; i++) {
u32 len;
ptr->fonts[i].fontID = gf_bs_read_u16(bs);
len = gf_bs_read_u8(bs);
if (len) {
ptr->fonts[i].fontName = (char *)gf_malloc(sizeof(char)*(len+1));
gf_bs_read_data(bs, ptr->fonts[i].fontName, len);
ptr->fonts[i].fontName[len] = 0;
}
}
return GF_OK;
}
GF_Err gf_isom_hint_sample_read(GF_HintSample *ptr, GF_BitStream *bs, u32 sampleSize)
{
u16 entryCount, i;
GF_HintPacket *pck;
GF_Err e;
u64 sizeIn, sizeOut;
sizeIn = gf_bs_available(bs);
entryCount = gf_bs_read_u16(bs);
ptr->reserved = gf_bs_read_u16(bs);
for (i = 0; i < entryCount; i++) {
pck = gf_isom_hint_pck_new(ptr->HintType);
e = gf_isom_hint_pck_read(ptr->HintType, pck, bs);
if (e) return e;
gf_list_add(ptr->packetTable, pck);
}
sizeOut = gf_bs_available(bs) - sizeIn;
//do we have some more data after the packets ??
if ((u32)sizeOut < sampleSize) {
ptr->dataLength = sampleSize - (u32)sizeOut;
ptr->AdditionalData = (char*)gf_malloc(sizeof(char) * ptr->dataLength);
gf_bs_read_data(bs, ptr->AdditionalData, ptr->dataLength);
}
return GF_OK;
}
GF_Err tx3g_Read(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_Box *a;
GF_Tx3gSampleEntryBox *ptr = (GF_Tx3gSampleEntryBox*)s;
if (ptr->size < 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->displayFlags = gf_bs_read_u32(bs);
ptr->horizontal_justification = gf_bs_read_u8(bs);
ptr->vertical_justification = gf_bs_read_u8(bs);
ptr->back_color = gpp_read_rgba(bs);
gpp_read_box(bs, &ptr->default_box);
gpp_read_style(bs, &ptr->default_style);
ptr->size -= 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE;
while (ptr->size) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) return GF_ISOM_INVALID_FILE;
ptr->size -= a->size;
if (a->type==GF_ISOM_BOX_TYPE_FTAB) {
if (ptr->font_table) gf_isom_box_del((GF_Box *) ptr->font_table);
ptr->font_table = (GF_FontTableBox *)a;
} else {
gf_isom_box_del(a);
}
}
return GF_OK;
}
u32 gf_isom_fdm_get_data(GF_FileDataMap *ptr, char *buffer, u32 bufferLength, u64 fileOffset)
{
u32 bytesRead;
//can we seek till that point ???
if (fileOffset > gf_bs_get_size(ptr->bs)) return 0;
//ouch, we are not at the previous location, do a seek
if (ptr->curPos != fileOffset) {
if (gf_bs_seek(ptr->bs, fileOffset) != GF_OK) return 0;
ptr->curPos = fileOffset;
}
//read our data.
bytesRead = gf_bs_read_data(ptr->bs, buffer, bufferLength);
//update our cache
if (bytesRead == bufferLength) {
ptr->curPos += bytesRead;
} else {
//rewind to original (if seek fails, return 0 cause this means:
//1- no support for seek on the platform
//2- corrupted file for the OS
if (ptr->stream) fflush(ptr->stream);
gf_bs_seek(ptr->bs, ptr->curPos);
}
ptr->last_acces_was_read = 1;
return bytesRead;
}
GF_Err wvtt_Read(GF_Box *s, GF_BitStream *bs)
{
GF_WebVTTSampleEntryBox *wvtt = (GF_WebVTTSampleEntryBox *)s;
gf_bs_read_data(bs, wvtt->reserved, 6);
wvtt->dataReferenceIndex = gf_bs_read_u16(bs);
wvtt->size -= 8;
return gf_isom_read_box_list(s, bs, wvtt_Add);
}
GF_Err boxstring_Read(GF_Box *s, GF_BitStream *bs)
{
GF_StringBox *box = (GF_StringBox *)s;
box->string = (char *)gf_malloc((u32)(s->size+1));
gf_bs_read_data(bs, box->string, (u32)(s->size));
box->string[(u32)(s->size)] = 0;
return GF_OK;
}
GF_Err Read_ImmediateDTE(GF_ImmediateDTE *dte, GF_BitStream *bs)
{
dte->dataLength = gf_bs_read_u8(bs);
if (dte->dataLength > 14) return GF_ISOM_INVALID_FILE;
gf_bs_read_data(bs, dte->data, dte->dataLength);
if (dte->dataLength < 14) gf_bs_skip_bytes(bs, 14 - dte->dataLength);
return GF_OK;
}
GF_Err piff_pssh_Read(GF_Box *s, GF_BitStream *bs)
{
GF_PIFFProtectionSystemHeaderBox *ptr = (GF_PIFFProtectionSystemHeaderBox*)s;
if (ptr->size<4) return GF_ISOM_INVALID_FILE;
ptr->version = gf_bs_read_u8(bs);
ptr->flags = gf_bs_read_u24(bs);
ptr->size -= 4;
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 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 senc_Parse(GF_BitStream *bs, GF_TrackBox *trak, void *traf, GF_SampleEncryptionBox *senc)
#endif
{
GF_Err e;
u32 i, j, count;
u64 pos = gf_bs_get_position(bs);
#ifdef GPAC_DISABLE_ISOM_FRAGMENTS
if (!traf)
return GF_BAD_PARAM;
#endif
gf_bs_seek(bs, senc->bs_offset);
count = gf_bs_read_u32(bs);
if (!senc->samp_aux_info) senc->samp_aux_info = gf_list_new();
for (i=0; i<count; i++) {
u32 is_encrypted;
u32 samp_count;
GF_CENCSampleAuxInfo *sai = (GF_CENCSampleAuxInfo *)gf_malloc(sizeof(GF_CENCSampleAuxInfo));
memset(sai, 0, sizeof(GF_CENCSampleAuxInfo));
samp_count = i+1;
#ifndef GPAC_DISABLE_ISOM_FRAGMENTS
if (trak) samp_count += trak->sample_count_at_seg_start;
#endif
if (trak) {
e = gf_isom_get_sample_cenc_info_ex(trak, traf, senc, samp_count, &is_encrypted, &sai->IV_size, NULL, NULL, NULL, NULL, NULL);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[isobmf] could not get cenc info for sample %d: %s\n", samp_count, gf_error_to_string(e) ));
return e;
}
}
//no init movie setup (segment dump/inspaction, assume default encrypted and 16 bytes IV
else {
is_encrypted = GF_TRUE;
sai->IV_size = 16;
}
if (is_encrypted) {
gf_bs_read_data(bs, (char *)sai->IV, sai->IV_size);
if (senc->flags & 0x00000002) {
sai->subsample_count = gf_bs_read_u16(bs);
sai->subsamples = (GF_CENCSubSampleEntry *)gf_malloc(sai->subsample_count*sizeof(GF_CENCSubSampleEntry));
for (j = 0; j < sai->subsample_count; j++) {
sai->subsamples[j].bytes_clear_data = gf_bs_read_u16(bs);
sai->subsamples[j].bytes_encrypted_data = gf_bs_read_u32(bs);
}
}
}
gf_list_add(senc->samp_aux_info, sai);
}
gf_bs_seek(bs, pos);
return GF_OK;
}
GF_Err gf_odf_read_base_command(GF_BitStream *bs, GF_BaseODCom *bcRem, u32 gf_odf_size_command)
{
if (!bcRem) return GF_BAD_PARAM;
bcRem->dataSize = gf_odf_size_command;
bcRem->data = (char *)gf_malloc(sizeof(char) * bcRem->dataSize);
if (!bcRem->data) return GF_OUT_OF_MEM;
gf_bs_read_data(bs, bcRem->data, bcRem->dataSize);
return GF_OK;
}
GF_Err bxml_Read(GF_Box *s, GF_BitStream *bs)
{
GF_BinaryXMLBox *ptr = (GF_BinaryXMLBox *)s;
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 odrb_Read(GF_Box *s, GF_BitStream *bs)
{
GF_OMADRMRightsObjectBox *ptr = (GF_OMADRMRightsObjectBox *)s;
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;
}
