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); }