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;
}
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 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 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;
}
static void gpp_read_box(GF_BitStream *bs, GF_BoxRecord *rec)
{
rec->top = gf_bs_read_u16(bs);
rec->left = gf_bs_read_u16(bs);
rec->bottom = gf_bs_read_u16(bs);
rec->right = gf_bs_read_u16(bs);
}
GF_Err ghnt_Read(GF_Box *s, GF_BitStream *bs)
{
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;
e = gf_isom_base_sample_entry_read((GF_SampleEntryBox *)ptr, bs);
if (e) return e;
ptr->HintTrackVersion = gf_bs_read_u16(bs);
ptr->LastCompatibleVersion = gf_bs_read_u16(bs);
ptr->size -= 12;
if ((s->type == GF_ISOM_BOX_TYPE_RTP_STSD) || (s->type == GF_ISOM_BOX_TYPE_SRTP_STSD) || (s->type == GF_ISOM_BOX_TYPE_RRTP_STSD) || (s->type == GF_ISOM_BOX_TYPE_RTCP_STSD)) {
ptr->MaxPacketSize = gf_bs_read_u32(bs);
ptr->size -= 4;
} else if (s->type == GF_ISOM_BOX_TYPE_FDP_STSD) {
ptr->partition_entry_ID = gf_bs_read_u16(bs);
ptr->FEC_overhead = gf_bs_read_u16(bs);
ptr->size -= 4;
}
return gf_isom_box_array_read(s, bs, gf_isom_box_add_default);
}
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;
}
static void gpp_read_style(GF_BitStream *bs, GF_StyleRecord *rec)
{
rec->startCharOffset = gf_bs_read_u16(bs);
rec->endCharOffset = gf_bs_read_u16(bs);
rec->fontID = gf_bs_read_u16(bs);
rec->style_flags = gf_bs_read_u8(bs);
rec->font_size = gf_bs_read_u8(bs);
rec->text_color = gpp_read_rgba(bs);
}
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;
}
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_Err Read_SampleDTE(GF_SampleDTE *dte, GF_BitStream *bs)
{
dte->trackRefIndex = gf_bs_read_u8(bs);
dte->dataLength = gf_bs_read_u16(bs);
dte->sampleNumber = gf_bs_read_u32(bs);
dte->byteOffset = gf_bs_read_u32(bs);
dte->bytesPerComp = gf_bs_read_u16(bs);
dte->samplesPerComp = gf_bs_read_u16(bs);
return GF_OK;
}
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;
}
static GF_Err JP2_AttachStream(GF_BaseDecoder *ifcg, GF_ESD *esd)
{
GF_BitStream *bs;
JP2CTX();
if (esd->dependsOnESID || esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
if (!esd->decoderConfig->decoderSpecificInfo) return GF_OK;
if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_IMAGE_JPEG_2000) {
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
ctx->height = gf_bs_read_u32(bs);
ctx->width = gf_bs_read_u32(bs);
ctx->nb_comp = gf_bs_read_u16(bs);
ctx->bpp = 1 + gf_bs_read_u8(bs);
ctx->out_size = ctx->width * ctx->height * ctx->nb_comp /* * ctx->bpp / 8 */;
gf_bs_del(bs);
switch (ctx->nb_comp) {
case 1: ctx->pixel_format = GF_PIXEL_GREYSCALE; break;
case 2: ctx->pixel_format = GF_PIXEL_ALPHAGREY; break;
case 3: ctx->pixel_format = GF_PIXEL_RGB_24; break;
case 4: ctx->pixel_format = GF_PIXEL_RGBA; break;
default: return GF_NOT_SUPPORTED;
}
} else {
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
gf_bs_read_u32(bs);
ctx->width = gf_bs_read_u16(bs);
ctx->height = gf_bs_read_u16(bs);
gf_bs_del(bs);
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, 12);
gf_bs_write_u32(bs, GF_4CC('j','P',' ',' ') );
gf_bs_write_u32(bs, 0x0D0A870A);
gf_bs_write_u32(bs, 20);
gf_bs_write_u32(bs, GF_4CC('f','t','y','p') );
gf_bs_write_u32(bs, GF_4CC('j','p','2',' ') );
gf_bs_write_u32(bs, 0);
gf_bs_write_u32(bs, GF_4CC('j','p','2',' ') );
gf_bs_write_data(bs, esd->decoderConfig->decoderSpecificInfo->data+8, esd->decoderConfig->decoderSpecificInfo->dataLength-8);
gf_bs_get_content(bs, &ctx->dsi, &ctx->dsi_size);
gf_bs_del(bs);
ctx->nb_comp = 3;
ctx->out_size = 3*ctx->width*ctx->height/2;
ctx->pixel_format = GF_PIXEL_YV12;
}
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 Read_SampleDTE(GF_SampleDTE *dte, GF_BitStream *bs)
{
dte->trackRefIndex = (s8) gf_bs_read_u8(bs);
dte->dataLength = gf_bs_read_u16(bs);
dte->sampleNumber = gf_bs_read_u32(bs);
dte->byteOffset = gf_bs_read_u32(bs);
dte->bytesPerComp = gf_bs_read_u16(bs);
dte->samplesPerComp = gf_bs_read_u16(bs);
if (dte->bytesPerComp != 1) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso] hint packet constructor with bytesperblock %d, not 1\n", dte->bytesPerComp));
}
if (dte->samplesPerComp != 1) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso] hint packet constructor with samplesperblock %d, not 1\n", dte->bytesPerComp));
}
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;
}
GF_Err pitm_Read(GF_Box *s, GF_BitStream *bs)
{
GF_PrimaryItemBox *ptr = (GF_PrimaryItemBox *)s;
ptr->item_ID = gf_bs_read_u16(bs);
return GF_OK;
}
GF_Err gppc_Read(GF_Box *s, GF_BitStream *bs)
{
GF_3GPPConfigBox *ptr = (GF_3GPPConfigBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
memset(&ptr->cfg, 0, sizeof(GF_3GPConfig));
ptr->cfg.vendor = gf_bs_read_u32(bs);
ptr->cfg.decoder_version = gf_bs_read_u8(bs);
switch (ptr->type) {
case GF_ISOM_BOX_TYPE_D263:
ptr->cfg.H263_level = gf_bs_read_u8(bs);
ptr->cfg.H263_profile = gf_bs_read_u8(bs);
break;
case GF_ISOM_BOX_TYPE_DAMR:
ptr->cfg.AMR_mode_set = gf_bs_read_u16(bs);
ptr->cfg.AMR_mode_change_period = gf_bs_read_u8(bs);
ptr->cfg.frames_per_sample = gf_bs_read_u8(bs);
break;
case GF_ISOM_BOX_TYPE_DEVC:
case GF_ISOM_BOX_TYPE_DQCP:
case GF_ISOM_BOX_TYPE_DSMV:
ptr->cfg.frames_per_sample = gf_bs_read_u8(bs);
break;
}
return GF_OK;
}
GF_Err gf_isom_track_cenc_add_sample_info(GF_ISOFile *the_file, u32 trackNumber, u32 container_type, u8 IV_size, char *buf, u32 len)
{
u32 i;
GF_SampleEncryptionBox *senc;
GF_CENCSampleAuxInfo *sai;
GF_SampleTableBox *stbl;
GF_TrackBox *trak = gf_isom_get_track_from_file(the_file, trackNumber);
if (!trak) return GF_BAD_PARAM;
stbl = trak->Media->information->sampleTable;
if (!stbl) return GF_BAD_PARAM;
switch (container_type) {
case GF_ISOM_BOX_UUID_PSEC:
senc = (GF_SampleEncryptionBox *) stbl->piff_psec;
break;
case GF_ISOM_BOX_TYPE_SENC:
senc = (GF_SampleEncryptionBox *)stbl->senc;
break;
default:
return GF_NOT_SUPPORTED;
}
sai = (GF_CENCSampleAuxInfo *)gf_malloc(sizeof(GF_CENCSampleAuxInfo));
if (!sai) return GF_OUT_OF_MEM;
memset(sai, 0, sizeof(GF_CENCSampleAuxInfo));
if (len) {
GF_BitStream *bs = gf_bs_new(buf, len, GF_BITSTREAM_READ);
sai->IV_size = IV_size;
gf_bs_read_data(bs, (char *)sai->IV, IV_size);
sai->subsample_count = gf_bs_read_u16(bs);
if (sai->subsample_count) senc->flags = 0x00000002;
sai->subsamples = (GF_CENCSubSampleEntry *)gf_malloc(sai->subsample_count*sizeof(GF_CENCSubSampleEntry));
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);
}
gf_list_add(senc->samp_aux_info, sai);
#ifndef GPAC_DISABLE_ISOM_FRAGMENTS
gf_isom_cenc_set_saiz_saio(senc, stbl, NULL, len);
#endif
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);
}
switch (avcc->AVCProfileIndication) {
case 100:
case 110:
case 122:
case 144:
gf_bs_read_int(bs, 6);
avcc->chroma_format = gf_bs_read_int(bs, 2);
gf_bs_read_int(bs, 5);
avcc->luma_bit_depth = 8 + gf_bs_read_int(bs, 3);
gf_bs_read_int(bs, 5);
avcc->chroma_bit_depth = 8 + gf_bs_read_int(bs, 3);
count = gf_bs_read_int(bs, 8);
if (count) {
avcc->sequenceParameterSetExtensions = gf_list_new();
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->size = gf_bs_read_u16(bs);
sl->data = (char *)gf_malloc(sizeof(char) * sl->size);
gf_bs_read_data(bs, sl->data, sl->size);
gf_list_add(avcc->sequenceParameterSetExtensions, sl);
}
}
break;
}
gf_bs_del(bs);
return avcc;
}
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 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 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 Read_StreamDescDTE(GF_StreamDescDTE *dte, GF_BitStream *bs)
{
dte->trackRefIndex = gf_bs_read_u8(bs);
dte->dataLength = gf_bs_read_u16(bs);
dte->streamDescIndex = gf_bs_read_u32(bs);
dte->byteOffset = gf_bs_read_u32(bs);
dte->reserved = gf_bs_read_u32(bs);
return GF_OK;
}
static Bool ADTS_SyncFrame(GF_BitStream *bs, Bool is_complete, ADTSHeader *hdr)
{
u32 val, pos, start_pos;
start_pos = (u32) gf_bs_get_position(bs);
while (gf_bs_available(bs)) {
val = gf_bs_read_u8(bs);
if (val!=0xFF) continue;
val = gf_bs_read_int(bs, 4);
if (val != 0x0F) {
gf_bs_read_int(bs, 4);
continue;
}
hdr->is_mp2 = gf_bs_read_int(bs, 1);
gf_bs_read_int(bs, 2);
hdr->no_crc = gf_bs_read_int(bs, 1);
pos = (u32) gf_bs_get_position(bs) - 2;
hdr->profile = 1 + gf_bs_read_int(bs, 2);
hdr->sr_idx = gf_bs_read_int(bs, 4);
gf_bs_read_int(bs, 1);
hdr->nb_ch = gf_bs_read_int(bs, 3);
gf_bs_read_int(bs, 4);
hdr->frame_size = gf_bs_read_int(bs, 13);
gf_bs_read_int(bs, 11);
gf_bs_read_int(bs, 2);
hdr->hdr_size = 7;
if (!hdr->no_crc) {
gf_bs_read_u16(bs);
hdr->hdr_size = 9;
}
if (hdr->frame_size < hdr->hdr_size) {
gf_bs_seek(bs, pos+1);
continue;
}
hdr->frame_size -= hdr->hdr_size;
if (is_complete && (gf_bs_available(bs) == hdr->frame_size)) return 1;
else if (gf_bs_available(bs) <= hdr->frame_size) break;
gf_bs_skip_bytes(bs, hdr->frame_size);
val = gf_bs_read_u8(bs);
if (val!=0xFF) {
gf_bs_seek(bs, pos+1);
continue;
}
val = gf_bs_read_int(bs, 4);
if (val!=0x0F) {
gf_bs_read_int(bs, 4);
gf_bs_seek(bs, pos+1);
continue;
}
gf_bs_seek(bs, pos+hdr->hdr_size);
return 1;
}
gf_bs_seek(bs, start_pos);
return 0;
}
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->fonts = (GF_FontRecord *) gf_malloc(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 ireftype_Read(GF_Box *s, GF_BitStream *bs)
{
u32 bytesToRead;
u32 i;
GF_ItemReferenceTypeBox *ptr = (GF_ItemReferenceTypeBox *)s;
bytesToRead = (u32)(ptr->size);
if (!bytesToRead) return GF_OK;
ptr->from_item_id = gf_bs_read_u16(bs);
ptr->reference_count = gf_bs_read_u16(bs);
ptr->to_item_IDs = (u32 *)gf_malloc(ptr->reference_count * sizeof(u32));
if (!ptr->to_item_IDs) return GF_OUT_OF_MEM;
for (i = 0; i < ptr->reference_count; i++) {
ptr->to_item_IDs[i] = gf_bs_read_u16(bs);
}
return GF_OK;
}
GF_Err senc_Parse(GF_BitStream *bs, GF_TrackBox *trak, void *traf, GF_SampleEncryptionBox *ptr)
#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, ptr->bs_offset);
count = gf_bs_read_u32(bs);
if (!ptr->samp_aux_info) ptr->samp_aux_info = gf_list_new();
for (i=0; i<count; i++) {
u32 is_encrypted;
GF_CENCSampleAuxInfo *sai = (GF_CENCSampleAuxInfo *)gf_malloc(sizeof(GF_CENCSampleAuxInfo));
memset(sai, 0, sizeof(GF_CENCSampleAuxInfo));
e = gf_isom_get_sample_cenc_info_ex(trak, traf, (trak ? trak->sample_count_at_seg_start : 0 )+ i+1, &is_encrypted, &sai->IV_size, NULL);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[isobmf] could not get cenc info for sample %d: %s\n", trak->sample_count_at_seg_start + i+1, gf_error_to_string(e) ));
return e;
}
if (is_encrypted) {
gf_bs_read_data(bs, (char *)sai->IV, sai->IV_size);
if (ptr->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(ptr->samp_aux_info, sai);
}
gf_bs_seek(bs, pos);
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;
}
static void SAF_CheckFile(SAFIn *read)
{
u32 nb_streams, i, cts, au_size, au_type, stream_id, ts_res;
GF_BitStream *bs;
StreamInfo si[1024];
gf_f64_seek(read->stream, 0, SEEK_SET);
bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
nb_streams=0;
while (gf_bs_available(bs)) {
gf_bs_read_u16(bs);
gf_bs_read_int(bs, 2);
cts = gf_bs_read_int(bs, 30);
au_size = gf_bs_read_int(bs, 16);
au_type = gf_bs_read_int(bs, 4);
stream_id = gf_bs_read_int(bs, 12);
au_size-=2;
ts_res = 0;
for (i=0; i<nb_streams; i++) {
if (si[i].stream_id==stream_id) ts_res = si[i].ts_res;
}
if (!ts_res) {
if ((au_type==1) || (au_type==2) || (au_type==7)) {
gf_bs_read_u16(bs);
ts_res = gf_bs_read_u24(bs);
au_size -= 5;
si[nb_streams].stream_id = stream_id;
si[nb_streams].ts_res = ts_res;
nb_streams++;
}
}
if (ts_res && (au_type==4)) {
Double ts = cts;
ts /= ts_res;
if (ts>read->duration) read->duration = ts;
}
gf_bs_skip_bytes(bs, au_size);
}
gf_bs_del(bs);
gf_f64_seek(read->stream, 0, SEEK_SET);
}
