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 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 btrt_Read(GF_Box *s, GF_BitStream *bs)
{
GF_MPEG4BitRateBox *ptr = (GF_MPEG4BitRateBox *)s;
ptr->bufferSizeDB = gf_bs_read_u32(bs);
ptr->maxBitrate = gf_bs_read_u32(bs);
ptr->avgBitrate = gf_bs_read_u32(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;
}
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 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;
}
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 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 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 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 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 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 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;
}
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 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 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;
}
static GF_Err CTXLoad_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd)
{
const char *ext;
GF_BitStream *bs;
u32 size;
CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack;
if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
/*animation stream like*/
if (priv->ctx) {
GF_StreamContext *sc;
u32 i = 0;
while ((sc = (GF_StreamContext *)gf_list_enum(priv->ctx->streams, &i))) {
if (esd->ESID == sc->ESID) {
priv->nb_streams++;
return GF_OK;
}
}
return GF_NON_COMPLIANT_BITSTREAM;
}
/*main dummy stream we need a dsi*/
if (!esd->decoderConfig->decoderSpecificInfo)
return GF_NON_COMPLIANT_BITSTREAM;
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
priv->file_size = gf_bs_read_u32(bs);
gf_bs_del(bs);
size = esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32);
priv->file_name = (char *) gf_malloc(sizeof(char)*(1 + size) );
memcpy(priv->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), sizeof(char)*(esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) );
priv->file_name[size] = 0;
priv->nb_streams = 1;
priv->load_flags = 0;
priv->base_stream_id = esd->ESID;
priv->service_url = esd->service_url;
CTXLoad_Setup(plug);
priv->progressive_support = GF_FALSE;
priv->sax_max_duration = 0;
ext = strrchr(priv->file_name, '.');
if (!ext) return GF_OK;
ext++;
if (!stricmp(ext, "xmt") || !stricmp(ext, "xmtz") || !stricmp(ext, "xmta")
|| !stricmp(ext, "x3d") || !stricmp(ext, "x3dz")
) {
ext = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive");
priv->progressive_support = (ext && !stricmp(ext, "yes")) ? GF_TRUE : GF_FALSE;
}
if (priv->progressive_support) {
ext = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration");
if (ext) priv->sax_max_duration = atoi(ext);
}
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 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;
}
static void VTT_ReadFileNameFromDSI(VTTDec *vttdec, GF_DefaultDescriptor *dsi)
{
GF_BitStream *bs;
bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
vttdec->file_size = gf_bs_read_u32(bs);
vttdec->file_pos = 0;
gf_bs_del(bs);
vttdec->file_name = (char *) gf_malloc(sizeof(char)*(1 + dsi->dataLength - sizeof(u32)) );
memcpy(vttdec->file_name, dsi->data + sizeof(u32), dsi->dataLength - sizeof(u32) );
vttdec->file_name[dsi->dataLength - sizeof(u32) ] = 0;
}
/*this is a quicktime specific box - see apple documentation*/
GF_Err text_Read(GF_Box *s, GF_BitStream *bs)
{
u16 pSize;
GF_TextSampleEntryBox *ptr = (GF_TextSampleEntryBox*)s;
gf_bs_read_data(bs, ptr->reserved, 6);
ptr->dataReferenceIndex = gf_bs_read_u16(bs);
ptr->displayFlags = gf_bs_read_u32(bs); /*Display flags*/
ptr->textJustification = gf_bs_read_u32(bs); /*Text justification*/
gf_bs_read_data(bs, ptr->background_color, 6); /*Background color*/
gpp_read_box(bs, &ptr->default_box); /*Default text box*/
gf_bs_read_data(bs, ptr->reserved1, 8); /*Reserved*/
ptr->fontNumber = gf_bs_read_u16(bs); /*Font number*/
ptr->fontFace = gf_bs_read_u16(bs); /*Font face*/
ptr->reserved2 = gf_bs_read_u8(bs); /*Reserved*/
ptr->reserved3 = gf_bs_read_u16(bs); /*Reserved*/
gf_bs_read_data(bs, ptr->foreground_color, 6); /*Foreground color*/
if (ptr->size < 51)
return GF_ISOM_INVALID_FILE;
ptr->size -= 51;
if (!ptr->size)
return GF_OK; /*ffmpeg compatibility with iPod streams: no pascal string*/
pSize = gf_bs_read_u8(bs); /*a Pascal string begins with its size: get textName size*/
ptr->size -= 1;
if (ptr->size < pSize)
return GF_ISOM_INVALID_FILE;
if (pSize) {
ptr->textName = (char*) gf_malloc(pSize+1 * sizeof(char));
if (gf_bs_read_data(bs, ptr->textName, pSize) != pSize) {
gf_free(ptr->textName);
ptr->textName = NULL;
return GF_ISOM_INVALID_FILE;
}
ptr->textName[pSize] = '\0'; /*Font name*/
}
ptr->size -= pSize;
return GF_OK;
}
static GF_Err SVG_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd)
{
const char *sOpt;
GF_BitStream *bs;
SVGIn *svgin = (SVGIn *)plug->privateStack;
if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
svgin->loader.type = GF_SM_LOAD_SVG;
/* decSpecInfo is not null only when reading from an SVG file (local or distant, cached or not) */
switch (esd->decoderConfig->objectTypeIndication) {
case GPAC_OTI_SCENE_SVG:
case GPAC_OTI_SCENE_SVG_GZ:
svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING;
/*no decSpecInfo defined for streaming svg yet*/
break;
case GPAC_OTI_SCENE_DIMS:
svgin->loader.type = GF_SM_LOAD_DIMS;
svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING;
/*decSpecInfo not yet supported for DIMS svg - we need properties at the scene level to store the
various indications*/
break;
case GPAC_OTI_PRIVATE_SCENE_SVG:
default:
if (!esd->decoderConfig->decoderSpecificInfo) return GF_NON_COMPLIANT_BITSTREAM;
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
svgin->file_size = gf_bs_read_u32(bs);
svgin->file_pos = 0;
gf_bs_del(bs);
svgin->file_name = (char *) gf_malloc(sizeof(char)*(1 + esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) );
memcpy(svgin->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) );
svgin->file_name[esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) ] = 0;
break;
}
svgin->oti = esd->decoderConfig->objectTypeIndication;
if (!esd->dependsOnESID) svgin->base_es_id = esd->ESID;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive");
if (sOpt && !strcmp(sOpt, "yes")) {
svgin->sax_max_duration = 30;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration");
if (sOpt) {
svgin->sax_max_duration = atoi(sOpt);
} else {
svgin->sax_max_duration = 30;
gf_modules_set_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration", "30");
}
} else {
svgin->sax_max_duration = (u32) -1;
}
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_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;
}
static void VTT_ReadConfigFromDSI(VTTDec *vttdec, GF_DefaultDescriptor *dsi)
{
GF_BitStream *bs;
u32 entry_type;
bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
entry_type = gf_bs_read_u32(bs);
if (entry_type == GF_ISOM_BOX_TYPE_WVTT) {
GF_Box *b;
gf_isom_parse_box(&b, bs);
vttdec->config = ((GF_StringBox *)b)->string;
((GF_StringBox *)b)->string = NULL;
gf_isom_box_del(b);
}
gf_bs_del(bs);
}
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_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 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;
}
