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_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 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 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 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;
}
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;
}
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 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 iSFM_Read(GF_Box *s, GF_BitStream *bs)
{
GF_ISMASampleFormatBox *ptr = (GF_ISMASampleFormatBox *)s;
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 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 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_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;
}
static u32 gpp_read_rgba(GF_BitStream *bs)
{
u8 r, g, b, a;
u32 col;
r = gf_bs_read_u8(bs);
g = gf_bs_read_u8(bs);
b = gf_bs_read_u8(bs);
a = gf_bs_read_u8(bs);
col = a; col<<=8;
col |= r; col<<=8;
col |= g; col<<=8;
col |= b;
return col;
}
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 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 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 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 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 piff_psec_Read(GF_Box *s, GF_BitStream *bs)
{
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;
}
ptr->bs_offset = gf_bs_get_position(bs);
gf_bs_skip_bytes(bs, ptr->size);
ptr->size = 0;
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) {
if (ptr->size < 8) {
/* Sometimes there are void atoms at the end of an atom and they are not parsed correctecly */
/* So just skip them if we have less than 8 bytes to parse */
/* "The actual size of an atom cannot be less than 8 bytes" from QTFF specs */
ptr->size = 0;
return GF_OK;
}
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;
}
/*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;
}
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 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 >= 8) {
e = gf_isom_parse_box(&a, bs);
if (e) return e;
if (ptr->size<a->size) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box \"%s\" larger than remaining bytes in tx3g - ignoring box\n", gf_4cc_to_str(a->type)));
ptr->size = 0;
gf_isom_box_del(a);
return GF_OK;
}
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 {
e = gf_isom_box_add_default(s, a);
if (e) return e;
}
}
return GF_OK;
}
void uir_load_event(GF_UIRecord *uir)
{
memset(&uir->next_event, 0, sizeof(GF_Event));
uir->evt_loaded = 0;
if (!gf_bs_available(uir->bs)) return;
uir->next_time = gf_bs_read_u32(uir->bs);
uir->next_event.type = gf_bs_read_u8(uir->bs);
switch (uir->next_event.type) {
case GF_EVENT_CLICK:
case GF_EVENT_MOUSEUP:
case GF_EVENT_MOUSEDOWN:
case GF_EVENT_MOUSEOVER:
case GF_EVENT_MOUSEOUT:
/*!! ALL MOUSE EVENTS SHALL BE DECLARED BEFORE MOUSEMOVE !! */
case GF_EVENT_MOUSEMOVE:
/*mouse wheel event*/
case GF_EVENT_MOUSEWHEEL:
uir->next_event.mouse.button = gf_bs_read_u8(uir->bs);
uir->next_event.mouse.x = gf_bs_read_u32(uir->bs);
uir->next_event.mouse.y = gf_bs_read_u32(uir->bs);
uir->next_event.mouse.wheel_pos = FLT2FIX( gf_bs_read_float(uir->bs) );
uir->next_event.mouse.key_states = gf_bs_read_u8(uir->bs);
break;
/*Key Events*/
case GF_EVENT_KEYUP:
case GF_EVENT_KEYDOWN:
case GF_EVENT_LONGKEYPRESS:
uir->next_event.key.key_code = gf_bs_read_u32(uir->bs);
uir->next_event.key.hw_code = gf_bs_read_u32(uir->bs);
uir->next_event.key.flags = gf_bs_read_u32(uir->bs);
break;
/*character input*/
case GF_EVENT_TEXTINPUT:
uir->next_event.character.unicode_char = gf_bs_read_u32(uir->bs);
break;
}
uir->evt_loaded = 1;
}
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)
{
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;
}
ptr->sample_count = gf_bs_read_u32(bs);
ptr->size -= 4;
ptr->cenc_data_size = (u32) ptr->size;
ptr->cenc_data = gf_malloc(sizeof(char)*ptr->cenc_data_size);
gf_bs_read_data(bs, ptr->cenc_data, ptr->cenc_data_size);
ptr->size = 0;
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 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 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 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);
}
