GF_EXPORT
void gf_sl_depacketize (GF_SLConfig *slConfig, GF_SLHeader *Header, char *PDU, u32 PDULength, u32 *HeaderLen)
{
GF_BitStream *bs;
*HeaderLen = 0;
if (!Header) return;
//reset the input header
memset(Header, 0, sizeof(GF_SLHeader));
bs = gf_bs_new(PDU, PDULength, GF_BITSTREAM_READ);
if (!bs) return;
if (slConfig->useAccessUnitStartFlag) Header->accessUnitStartFlag = gf_bs_read_int(bs, 1);
if (slConfig->useAccessUnitEndFlag) Header->accessUnitEndFlag = gf_bs_read_int(bs, 1);
if ( !slConfig->useAccessUnitStartFlag && !slConfig->useAccessUnitEndFlag) {
Header->accessUnitStartFlag = 1;
Header->accessUnitEndFlag = 1;
}
if (slConfig->OCRLength > 0) Header->OCRflag = gf_bs_read_int(bs, 1);
if (slConfig->useIdleFlag) Header->idleFlag = gf_bs_read_int(bs, 1);
if (slConfig->usePaddingFlag) {
Header->paddingFlag = gf_bs_read_int(bs, 1);
if (Header->paddingFlag) Header->paddingBits = gf_bs_read_int(bs, 3);
}
if (!Header->idleFlag && (!Header->paddingFlag || Header->paddingBits != 0)) {
if (slConfig->packetSeqNumLength > 0) Header->packetSequenceNumber = gf_bs_read_int(bs, slConfig->packetSeqNumLength);
if (slConfig->degradationPriorityLength > 0) {
Header->degradationPriorityFlag = gf_bs_read_int(bs, 1);
if (Header->degradationPriorityFlag) Header->degradationPriority = gf_bs_read_int(bs, slConfig->degradationPriorityLength);
}
if (Header->OCRflag) Header->objectClockReference = gf_bs_read_int(bs, slConfig->OCRLength);
if (Header->accessUnitStartFlag) {
if (slConfig->useRandomAccessPointFlag) Header->randomAccessPointFlag = gf_bs_read_int(bs, 1);
if (slConfig->AUSeqNumLength > 0) Header->AU_sequenceNumber = gf_bs_read_int(bs, slConfig->AUSeqNumLength);
if (slConfig->useTimestampsFlag) {
Header->decodingTimeStampFlag = gf_bs_read_int(bs, 1);
Header->compositionTimeStampFlag = gf_bs_read_int(bs, 1);
}
if (slConfig->instantBitrateLength > 0) Header->instantBitrateFlag = gf_bs_read_int(bs, 1);
if (Header->decodingTimeStampFlag) Header->decodingTimeStamp = gf_bs_read_long_int(bs, slConfig->timestampLength);
if (Header->compositionTimeStampFlag) Header->compositionTimeStamp = gf_bs_read_long_int(bs, slConfig->timestampLength);
if (slConfig->AULength > 0) Header->accessUnitLength = gf_bs_read_int(bs, slConfig->AULength);
if (Header->instantBitrateFlag) Header->instantBitrate = gf_bs_read_int(bs, slConfig->instantBitrateLength);
}
}
gf_bs_align(bs);
*HeaderLen = (u32) gf_bs_get_position(bs);
gf_bs_del(bs);
}
GF_TextSample *gf_isom_parse_texte_sample_from_data(char *data, u32 dataLength)
{
GF_TextSample *s;
GF_BitStream *bs;
/*empty text sample*/
if (!data || !dataLength) {
return gf_isom_new_text_sample();
}
bs = gf_bs_new(data, dataLength, GF_BITSTREAM_READ);
s = gf_isom_parse_texte_sample(bs);
gf_bs_del(bs);
return s;
}
/*allocates and writes the SL-PDU (Header + PDU) given the SLConfig and the GF_SLHeader
for this PDU. AUs must be split in PDUs by another process if needed (packetizer).*/
GF_EXPORT
void gf_sl_packetize(GF_SLConfig* slConfig,
GF_SLHeader *Header,
char *PDU,
u32 size,
char **outPacket,
u32 *OutSize)
{
GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
*OutSize = 0;
if (!bs) return;
if (slConfig->useAccessUnitStartFlag) gf_bs_write_int(bs, Header->accessUnitStartFlag, 1);
if (slConfig->useAccessUnitEndFlag) gf_bs_write_int(bs, Header->accessUnitEndFlag, 1);
if (slConfig->OCRLength > 0) gf_bs_write_int(bs, Header->OCRflag, 1);
if (slConfig->useIdleFlag) gf_bs_write_int(bs, Header->idleFlag, 1);
if (slConfig->usePaddingFlag) {
gf_bs_write_int(bs, Header->paddingFlag, 1);
if (Header->paddingFlag) gf_bs_write_int(bs, Header->paddingBits, 3);
}
if (! Header->idleFlag && (! Header->paddingFlag || Header->paddingBits != 0)) {
if (slConfig->packetSeqNumLength > 0) gf_bs_write_int(bs, Header->packetSequenceNumber, slConfig->packetSeqNumLength);
if (slConfig->degradationPriorityLength > 0) {
gf_bs_write_int(bs, Header->degradationPriorityFlag, 1);
if (Header->degradationPriorityFlag) gf_bs_write_int(bs, Header->degradationPriority, slConfig->degradationPriorityLength);
}
if (Header->OCRflag) gf_bs_write_long_int(bs, Header->objectClockReference, slConfig->OCRLength);
if (Header->accessUnitStartFlag) {
if (slConfig->useRandomAccessPointFlag) gf_bs_write_int(bs, Header->randomAccessPointFlag, 1);
if (slConfig->AUSeqNumLength > 0) gf_bs_write_int(bs, Header->AU_sequenceNumber, slConfig->AUSeqNumLength);
if (slConfig->useTimestampsFlag) {
gf_bs_write_int(bs, Header->decodingTimeStampFlag, 1);
gf_bs_write_int(bs, Header->compositionTimeStampFlag, 1);
}
if (slConfig->instantBitrateLength > 0) gf_bs_write_int(bs, Header->instantBitrateFlag, 1);
if (Header->decodingTimeStampFlag) gf_bs_write_long_int(bs, Header->decodingTimeStamp, slConfig->timestampLength);
if (Header->compositionTimeStampFlag) gf_bs_write_long_int(bs, Header->compositionTimeStamp, slConfig->timestampLength);
if (slConfig->AULength > 0) gf_bs_write_int(bs, Header->accessUnitLength, slConfig->AULength);
if (Header->instantBitrateFlag) gf_bs_write_int(bs, Header->instantBitrate, slConfig->instantBitrateLength);
}
}
//done with the Header, Alin
gf_bs_align(bs);
//write the PDU - already byte aligned with stuffing (paddingBits in SL Header)
gf_bs_write_data(bs, PDU, size);
gf_bs_align(bs);
gf_bs_get_content(bs, outPacket, OutSize);
gf_bs_del(bs);
}
void gf_isom_fdm_del(GF_FileDataMap *ptr)
{
if (!ptr || (ptr->type != GF_ISOM_DATA_FILE)) return;
if (ptr->bs) gf_bs_del(ptr->bs);
if (ptr->stream) fclose(ptr->stream);
#ifndef GPAC_DISABLE_ISOM_WRITE
if (ptr->temp_file) {
gf_delete_file(ptr->temp_file);
gf_free(ptr->temp_file);
}
#endif
gf_free(ptr);
}
GF_EXPORT
GF_List *gf_webvtt_parse_cues_from_data(const char *data, u32 dataLength, u64 start)
{
GF_List *cues;
GF_WebVTTCue *cue;
GF_VTTCueBox *cuebox;
GF_BitStream *bs;
char *pre_text;
cue = NULL;
pre_text = NULL;
cues = gf_list_new();
bs = gf_bs_new(data, dataLength, GF_BITSTREAM_READ);
while(gf_bs_available(bs))
{
GF_Err e;
GF_Box *box;
e = gf_isom_box_parse(&box, bs);
if (e) return NULL;
if (box->type == GF_ISOM_BOX_TYPE_VTCC_CUE) {
cuebox = (GF_VTTCueBox *)box;
cue = gf_webvtt_cue_new();
if (pre_text) {
gf_webvtt_cue_add_property(cue, WEBVTT_PRECUE_TEXT, pre_text, (u32) strlen(pre_text));
gf_free(pre_text);
pre_text = NULL;
}
gf_list_add(cues, cue);
gf_webvtt_timestamp_set(&cue->start, start);
if (cuebox->id) {
gf_webvtt_cue_add_property(cue, WEBVTT_ID, cuebox->id->string, (u32) strlen(cuebox->id->string));
}
if (cuebox->settings) {
gf_webvtt_cue_add_property(cue, WEBVTT_SETTINGS, cuebox->settings->string, (u32) strlen(cuebox->settings->string));
}
if (cuebox->payload) {
gf_webvtt_cue_add_property(cue, WEBVTT_PAYLOAD, cuebox->payload->string, (u32) strlen(cuebox->payload->string));
}
} else if (box->type == GF_ISOM_BOX_TYPE_VTTA) {
GF_StringBox *sbox = (GF_StringBox *)box;
if (cue) {
gf_webvtt_cue_add_property(cue, WEBVTT_POSTCUE_TEXT, sbox->string, (u32) strlen(sbox->string));
} else {
pre_text = gf_strdup(sbox->string);
}
}
gf_isom_box_del(box);
}
gf_bs_del(bs);
return cues;
}
GF_EXPORT
GF_Err gf_odf_hevc_cfg_write(GF_HEVCConfig *cfg, char **outData, u32 *outSize)
{
GF_Err e;
GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
*outSize = 0;
*outData = NULL;
e = gf_odf_hevc_cfg_write_bs(cfg, bs);
if (e==GF_OK)
gf_bs_get_content(bs, outData, outSize);
gf_bs_del(bs);
return e;
}
/*special function for authoring - convert DSI to LASERConfig*/
GF_EXPORT
GF_Err gf_odf_get_laser_config(GF_DefaultDescriptor *dsi, GF_LASERConfig *cfg)
{
u32 to_skip;
GF_BitStream *bs;
if (!cfg) return GF_BAD_PARAM;
memset(cfg, 0, sizeof(GF_LASERConfig));
if (!dsi || !dsi->data || !dsi->dataLength || !cfg) return GF_BAD_PARAM;
bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
memset(cfg, 0, sizeof(GF_LASERConfig));
cfg->tag = GF_ODF_LASER_CFG_TAG;
cfg->profile = gf_bs_read_int(bs, 8);
cfg->level = gf_bs_read_int(bs, 8);
/*cfg->reserved = */gf_bs_read_int(bs, 3);
cfg->pointsCodec = gf_bs_read_int(bs, 2);
cfg->pathComponents = gf_bs_read_int(bs, 4);
cfg->fullRequestHost = gf_bs_read_int(bs, 1);
if (gf_bs_read_int(bs, 1)) cfg->time_resolution = gf_bs_read_int(bs, 16);
else cfg->time_resolution = 1000;
cfg->colorComponentBits = 1 + gf_bs_read_int(bs, 4);
cfg->resolution = gf_bs_read_int(bs, 4);
if (cfg->resolution>7) cfg->resolution -= 16;
cfg->coord_bits = gf_bs_read_int(bs, 5);
cfg->scale_bits_minus_coord_bits = gf_bs_read_int(bs, 4);
cfg->newSceneIndicator = gf_bs_read_int(bs, 1);
/*reserved2*/ gf_bs_read_int(bs, 3);
cfg->extensionIDBits = gf_bs_read_int(bs, 4);
/*hasExtConfig - we just ignore it*/
if (gf_bs_read_int(bs, 1)) {
to_skip = gf_bs_read_vluimsbf5(bs);
while (to_skip) {
gf_bs_read_int(bs, 8);
to_skip--;
}
}
/*hasExtension - we just ignore it*/
if (gf_bs_read_int(bs, 1)) {
to_skip = gf_bs_read_vluimsbf5(bs);
while (to_skip) {
gf_bs_read_int(bs, 8);
to_skip--;
}
}
gf_bs_del(bs);
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);
}
static void rtp_amr_flush(GP_RTPPacketizer *builder)
{
char *hdr;
u32 hdr_size;
if (!builder->bytesInPacket) return;
gf_bs_get_content(builder->pck_hdr, &hdr, &hdr_size);
gf_bs_del(builder->pck_hdr);
builder->pck_hdr = NULL;
/*overwrite last frame F bit*/
hdr[builder->last_au_sn] &= 0x7F;
builder->OnData(builder->cbk_obj, hdr, hdr_size, 1);
gf_free(hdr);
builder->OnPacketDone(builder->cbk_obj, &builder->rtp_header);
builder->bytesInPacket = 0;
builder->last_au_sn = 0;
}
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;
}
void main(int argc, char **argv)
{
FILE *in;
GF_BitStream *bs;
/* generation d'un TS aléatoire */
/*
if ((in=gf_fopen(argv[1], "wb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
{
char buffer[188];
u32 j, i, nb_packets = 300;
for (i = 0; i < nb_packets; i++) {
buffer[0] = 0x47;
for (j = 1; j <188; j++) {
buffer[j] = rand();//j;
}
gf_fwrite(buffer, 1, 188, in);
}
}
gf_fclose(in);
if ((in=gf_fopen(argv[1], "rb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
if (bs == NULL) return;
RS_Interleaver(bs, argv[2]);
gf_fclose(in);
gf_bs_del(bs);
*/
if ((in=gf_fopen(argv[1], "rb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
if (bs == NULL) return;
RS_Deinterleaver(bs, argv[2]);
gf_fclose(in);
gf_bs_del(bs);
}
GF_EXPORT
GF_Err gf_bifs_decode_command_list(GF_BifsDecoder *codec, u16 ESID, char *data, u32 data_length, GF_List *com_list)
{
GF_BitStream *bs;
GF_Err e;
if (!codec || !data || !codec->dec_memory_mode || !com_list) return GF_BAD_PARAM;
codec->info = gf_bifs_dec_get_stream(codec, ESID);
if (!codec->info) return GF_BAD_PARAM;
if (codec->info->config.elementaryMasks ) return GF_NOT_SUPPORTED;
/*root parse (not conditionals)*/
assert(codec->scenegraph);
/*setup current scene graph*/
codec->current_graph = codec->scenegraph;
codec->ActiveQP = (M_QuantizationParameter*) codec->scenegraph->global_qp;
bs = gf_bs_new(data, data_length, GF_BITSTREAM_READ);
gf_bs_set_eos_callback(bs, BM_EndOfStream, codec);
e = BM_ParseCommand(codec, bs, com_list);
gf_bs_del(bs);
/*decode conditionals / input sensors*/
if (!e) {
gf_bifs_flush_command_list(codec);
}
/*if err or not reset conditionals*/
while (gf_list_count(codec->command_buffers)) {
CommandBufferItem *cbi = (CommandBufferItem *)gf_list_get(codec->command_buffers, 0);
gf_free(cbi);
gf_list_rem(codec->command_buffers, 0);
}
/*reset current config*/
codec->info = NULL;
codec->current_graph = NULL;
// gf_mx_v(codec->mx);
return e;
}
/*Dummy input just send a file name, no multitrack to handle so we don't need to check sub_url nor expected type*/
static GF_Descriptor *DC_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
u32 size = 0;
char *uri;
GF_ESD *esd;
GF_BitStream *bs;
DCReader *read = (DCReader *) plug->priv;
GF_InitialObjectDescriptor *iod = (GF_InitialObjectDescriptor *) gf_odf_desc_new(GF_ODF_IOD_TAG);
iod->scene_profileAndLevel = 1;
iod->graphics_profileAndLevel = 1;
iod->OD_profileAndLevel = 1;
iod->audio_profileAndLevel = 0xFE;
iod->visual_profileAndLevel = 0xFE;
iod->objectDescriptorID = 1;
if (read->is_views_url) {
iod->URLString = gf_strdup(read->url);
return (GF_Descriptor *)iod;
}
esd = gf_odf_desc_esd_new(0);
esd->slConfig->timestampResolution = 1000;
esd->slConfig->useTimestampsFlag = 1;
esd->ESID = 0xFFFE;
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_SCENE;
esd->decoderConfig->objectTypeIndication = read->oti;
if (read->dnload) {
uri = (char *) gf_dm_sess_get_cache_name(read->dnload);
gf_dm_sess_get_stats(read->dnload, NULL, NULL, &size, NULL, NULL, NULL);
} else {
FILE *f = gf_fopen(read->url, "rt");
gf_fseek(f, 0, SEEK_END);
size = (u32) gf_ftell(f);
gf_fclose(f);
uri = read->url;
}
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, size);
gf_bs_write_data(bs, uri, (u32) strlen(uri));
gf_bs_get_content(bs, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
gf_list_add(iod->ESDescriptors, esd);
return (GF_Descriptor *)iod;
}
GF_Err MCDec_InitMpeg4Decoder(MCDec *ctx)
{
char *dsi_data = NULL;
u32 dsi_data_size = 0;
if (!ctx->esd->decoderConfig->decoderSpecificInfo) {
ctx->esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
}
if (ctx->esd->decoderConfig->decoderSpecificInfo->data) {
GF_M4VDecSpecInfo vcfg;
GF_BitStream *bs;
gf_m4v_get_config(ctx->esd->decoderConfig->decoderSpecificInfo->data, ctx->esd->decoderConfig->decoderSpecificInfo->dataLength, &vcfg);
ctx->width = vcfg.width;
ctx->height = vcfg.height;
if (ctx->esd->slConfig) {
ctx->esd->slConfig->predefined = 2;
}
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, 0);
gf_odf_desc_write_bs((GF_Descriptor *) ctx->esd, bs);
gf_bs_get_content(bs, &dsi_data, &dsi_data_size);
gf_bs_del(bs);
ctx->mime = "video/mp4v-es";
char *esds = (char *)malloc(dsi_data_size);
memcpy(esds, dsi_data, dsi_data_size);
esds[0] = 0x00;
esds[1] = 0x00;
esds[2] = 0x00;
esds[3] = 0x01;
AMediaFormat_setBuffer(ctx->format, "csd-0", esds, dsi_data_size);
gf_free(dsi_data);
return GF_OK;
}
return GF_NOT_SUPPORTED;
}
GF_ESD *IMG_GetESD(IMGLoader *read)
{
GF_ESD *esd = gf_odf_desc_esd_new(0);
esd->slConfig->timestampResolution = 1000;
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->ESID = 1;
if (read->img_type == IMG_BMP)
esd->decoderConfig->objectTypeIndication = GPAC_BMP_OTI;
else {
u8 OTI=0;
GF_BitStream *bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
#ifndef GPAC_DISABLE_AV_PARSERS
u32 mtype, w, h;
gf_img_parse(bs, &OTI, &mtype, &w, &h, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
#endif
gf_bs_del(bs);
if (!OTI) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[IMG_IN] Unable to guess format image - assigning from extension\n"));
if (read->img_type==IMG_JPEG) OTI = GPAC_OTI_IMAGE_JPEG;
else if (read->img_type==IMG_PNG) OTI = GPAC_OTI_IMAGE_PNG;
}
esd->decoderConfig->objectTypeIndication = OTI;
if (read->img_type == IMG_PNGD) {
GF_Descriptor *d = gf_odf_desc_new(GF_ODF_AUX_VIDEO_DATA);
((GF_AuxVideoDescriptor*)d)->aux_video_type = 1;
gf_list_add(esd->extensionDescriptors, d);
}
else if (read->img_type == IMG_PNGDS) {
GF_Descriptor *d = gf_odf_desc_new(GF_ODF_AUX_VIDEO_DATA);
((GF_AuxVideoDescriptor*)d)->aux_video_type = 2;
gf_list_add(esd->extensionDescriptors, d);
}
else if (read->img_type == IMG_PNGS) {
GF_Descriptor *d = gf_odf_desc_new(GF_ODF_AUX_VIDEO_DATA);
((GF_AuxVideoDescriptor*)d)->aux_video_type = 3;
gf_list_add(esd->extensionDescriptors, d);
}
}
return esd;
}
GF_Err gf_webvtt_dump_iso_sample(FILE *dump, u32 timescale, GF_ISOSample *iso_sample, Bool box_mode)
{
GF_Err e;
GF_BitStream *bs;
if (box_mode) {
fprintf(dump, "<WebVTTSample decodingTimeStamp=\""LLU"\" compositionTimeStamp=\""LLD"\" RAP=\"%d\" dataLength=\"%d\" >\n", iso_sample->DTS, (s64)iso_sample->DTS + iso_sample->CTS_Offset, iso_sample->IsRAP, iso_sample->dataLength);
}
bs = gf_bs_new(iso_sample->data, iso_sample->dataLength, GF_BITSTREAM_READ);
while(gf_bs_available(bs))
{
GF_Box *box;
GF_WebVTTTimestamp ts;
e = gf_isom_box_parse(&box, bs);
if (e) return e;
if (box_mode) {
gf_isom_box_dump(box, dump);
} else if (box->type == GF_ISOM_BOX_TYPE_VTCC_CUE) {
GF_VTTCueBox *cuebox = (GF_VTTCueBox *)box;
if (cuebox->id) fprintf(dump, "%s", cuebox->id->string);
gf_webvtt_timestamp_set(&ts, (iso_sample->DTS * 1000) / timescale);
gf_webvtt_timestamp_dump(&ts, dump, GF_FALSE);
fprintf(dump, " --> NEXT");
if (cuebox->settings) fprintf(dump, " %s", cuebox->settings->string);
fprintf(dump, "\n");
if (cuebox->payload) fprintf(dump, "%s", cuebox->payload->string);
fprintf(dump, "\n");
} else if (box->type == GF_ISOM_BOX_TYPE_VTTE) {
gf_webvtt_timestamp_set(&ts, (iso_sample->DTS * 1000) / timescale);
gf_webvtt_timestamp_dump(&ts, dump, GF_FALSE);
fprintf(dump, " --> NEXT\n\n");
} else if (box->type == GF_ISOM_BOX_TYPE_VTTA) {
fprintf(dump, "%s\n\n", ((GF_StringBox *)box)->string);
}
gf_isom_box_del(box);
}
gf_bs_del(bs);
if (box_mode) {
fprintf(dump, "</WebVTTSample>\n");
}
return GF_OK;
}
GF_EXPORT
GF_Err gf_odf_desc_write(GF_Descriptor *desc, char **outEncDesc, u32 *outSize)
{
GF_Err e;
GF_BitStream *bs;
if (!desc || !outEncDesc || !outSize) return GF_BAD_PARAM;
*outEncDesc = NULL;
*outSize = 0;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if (!bs) return GF_OUT_OF_MEM;
e = gf_odf_desc_write_bs(desc, bs);
//then get the content from our bitstream
gf_bs_get_content(bs, outEncDesc, outSize);
gf_bs_del(bs);
return e;
}
GF_Err gf_webvtt_dump_header_boxed(FILE *dump, const char *data, u32 dataLength, u32 *dumpedLength)
{
GF_Err e;
GF_Box *box;
GF_StringBox *config;
GF_BitStream *bs;
*dumpedLength = 0;
bs = gf_bs_new(data, dataLength, GF_BITSTREAM_READ);
e = gf_isom_parse_box(&box, bs);
if (!box || (box->type != GF_ISOM_BOX_TYPE_VTTC)) return GF_BAD_PARAM;
config = (GF_StringBox *)box;
if (config->string) {
fprintf(dump, "%s", config->string);
*dumpedLength = (u32)strlen(config->string)+1;
}
gf_bs_del(bs);
gf_isom_box_del(box);
return e;
}
GF_EXPORT
GF_Err gf_odf_codec_encode(GF_ODCodec *codec, u32 cleanup_type)
{
GF_ODCom *com;
GF_Err e = GF_OK;
u32 i;
if (!codec) return GF_BAD_PARAM;
//check our bitstream: if existing, this means the previous encoded AU was not retrieved
//we DON'T allow that
if (codec->bs) return GF_BAD_PARAM;
codec->bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if (!codec->bs) return GF_OUT_OF_MEM;
/*encode each command*/
i = 0;
while ((com = (GF_ODCom *)gf_list_enum(codec->CommandList, &i))) {
e = gf_odf_write_command(codec->bs, com);
if (e) goto err_exit;
//don't forget OD Commands are aligned...
gf_bs_align(codec->bs);
}
//if an error occurs, delete the GF_BitStream and empty the codec
err_exit:
if (e) {
gf_bs_del(codec->bs);
codec->bs = NULL;
}
if (cleanup_type == 1) {
while (gf_list_count(codec->CommandList)) {
com = (GF_ODCom *)gf_list_get(codec->CommandList, 0);
gf_odf_delete_command(com);
gf_list_rem(codec->CommandList, 0);
}
}
if (cleanup_type == 0) {
gf_list_reset(codec->CommandList);
}
return e;
}
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);
}
GF_EXPORT
GF_Err gf_odf_get_ui_config(GF_DefaultDescriptor *dsi, GF_UIConfig *cfg)
{
u32 len, i;
GF_BitStream *bs;
if (!dsi || !dsi->data || !dsi->dataLength || !cfg) return GF_BAD_PARAM;
memset(cfg, 0, sizeof(GF_UIConfig));
cfg->tag = GF_ODF_UI_CFG_TAG;
bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
len = gf_bs_read_int(bs, 8);
cfg->deviceName = (char*)gf_malloc(sizeof(char) * (len+1));
for (i=0; i<len; i++) cfg->deviceName[i] = gf_bs_read_int(bs, 8);
cfg->deviceName[i] = 0;
if (!stricmp(cfg->deviceName, "StringSensor") && gf_bs_available(bs)) {
cfg->termChar = gf_bs_read_int(bs, 8);
cfg->delChar = gf_bs_read_int(bs, 8);
}
gf_bs_del(bs);
return GF_OK;
}
GF_Err gf_isom_text_get_encoded_tx3g(GF_ISOFile *file, u32 track, u32 sidx, u32 sidx_offset, char **tx3g, u32 *tx3g_size)
{
GF_BitStream *bs;
GF_TrackBox *trak;
GF_Tx3gSampleEntryBox *a;
trak = gf_isom_get_track_from_file(file, track);
if (!trak) return GF_BAD_PARAM;
a = (GF_Tx3gSampleEntryBox *) gf_list_get(trak->Media->information->sampleTable->SampleDescription->boxList, sidx-1);
if (!a) return GF_BAD_PARAM;
if ((a->type != GF_ISOM_BOX_TYPE_TX3G) && (a->type != GF_ISOM_BOX_TYPE_TEXT)) return GF_BAD_PARAM;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_isom_write_tx3g(a, bs, sidx, sidx_offset);
*tx3g = NULL;
*tx3g_size = 0;
gf_bs_get_content(bs, tx3g, tx3g_size);
gf_bs_del(bs);
return GF_OK;
}
static void rtp_evrc_smv_flush(GP_RTPPacketizer *builder)
{
if (!builder->bytesInPacket) return;
if (builder->auh_size>1) {
char *hdr;
u32 hdr_size;
/*padding*/
if (builder->last_au_sn % 2) gf_bs_write_int(builder->pck_hdr, 0, 4);
gf_bs_get_content(builder->pck_hdr, &hdr, &hdr_size);
gf_bs_del(builder->pck_hdr);
builder->pck_hdr = NULL;
/*overwrite count*/
hdr[0] = 0;
hdr[1] = builder->last_au_sn-1;/*MMM + frameCount-1*/
builder->OnData(builder->cbk_obj, hdr, hdr_size, 1);
gf_free(hdr);
}
builder->OnPacketDone(builder->cbk_obj, &builder->rtp_header);
builder->bytesInPacket = 0;
builder->last_au_sn = 0;
}
static GF_ESD* get_esd()
{
GF_BitStream *dsi = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
GF_ESD *esd = gf_odf_desc_esd_new(0);
esd->ESID = 1;
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_RAW_MEDIA_STREAM;
esd->decoderConfig->avgBitrate = esd->decoderConfig->maxBitrate = 0;
esd->slConfig->timestampResolution = FM_FAKE_PULL_AUDIO_FREQ;
/*Decoder Specific Info for raw media*/
gf_bs_write_u32(dsi, FM_FAKE_PULL_AUDIO_FREQ); /*u32 sample_rate*/
gf_bs_write_u16(dsi, FM_FAKE_PULL_CHAN_NUM); /*u16 nb_channels*/
gf_bs_write_u16(dsi, FM_FAKE_PULL_BITS); /*u16 nb_bits_per_sample*/
gf_bs_write_u32(dsi, FM_FAKE_PULL_FRAME_LEN); /*u32 frame_size*/
gf_bs_write_u32(dsi, 0); /*u32 channel_config*/
gf_bs_get_content(dsi, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(dsi);
return esd;
}
static GF_ESD *AAC_GetESD(AACReader *read)
{
GF_BitStream *dsi;
GF_ESD *esd;
u32 i, sbr_sr_idx;
esd = gf_odf_desc_esd_new(0);
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = read->oti;
esd->ESID = 1;
esd->OCRESID = 1;
esd->slConfig->timestampResolution = read->sample_rate;
if (read->is_live) esd->slConfig->useAccessUnitEndFlag = esd->slConfig->useAccessUnitStartFlag = 1;
dsi = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
/*write as regular AAC*/
gf_bs_write_int(dsi, read->prof, 5);
gf_bs_write_int(dsi, read->sr_idx, 4);
gf_bs_write_int(dsi, read->nb_ch, 4);
gf_bs_align(dsi);
/*always signal implicit S BR in case it's used*/
sbr_sr_idx = read->sr_idx;
for (i=0; i<16; i++) {
if (GF_M4ASampleRates[i] == (u32) 2*read->sample_rate) {
sbr_sr_idx = i;
break;
}
}
gf_bs_write_int(dsi, 0x2b7, 11);
gf_bs_write_int(dsi, 5, 5);
gf_bs_write_int(dsi, 1, 1);
gf_bs_write_int(dsi, sbr_sr_idx, 4);
gf_bs_align(dsi);
gf_bs_get_content(dsi, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(dsi);
return esd;
}
static GF_Err HEVC_ConfigurationScalableStream(HEVCDec *ctx, GF_ESD *esd)
{
GF_HEVCConfig *cfg = NULL;
char *data;
u32 data_len;
GF_BitStream *bs;
u32 i, j;
if (!esd->decoderConfig->decoderSpecificInfo || !esd->decoderConfig->decoderSpecificInfo->data)
return GF_OK;
cfg = gf_odf_hevc_cfg_read(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_FALSE);
if (!cfg) return GF_NON_COMPLIANT_BITSTREAM;
if (ctx->nalu_size_length != cfg->nal_unit_size)
return GF_NON_COMPLIANT_BITSTREAM;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
for (i=0; i< gf_list_count(cfg->param_array); i++) {
GF_HEVCParamArray *ar = (GF_HEVCParamArray *)gf_list_get(cfg->param_array, i);
for (j=0; j< gf_list_count(ar->nalus); j++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *)gf_list_get(ar->nalus, j);
gf_bs_write_int(bs, sl->size, 8*ctx->nalu_size_length);
gf_bs_write_data(bs, sl->data, sl->size);
}
}
gf_bs_get_content(bs, &data, &data_len);
gf_bs_del(bs);
libOpenHevcDecode(ctx->openHevcHandle, (u8 *)data, data_len, 0);
if (ctx->raw_out) fwrite((u8 *)data, 1, data_len, ctx->raw_out);
gf_free(data);
libOpenHevcSetActiveDecoders(ctx->openHevcHandle, 2);
libOpenHevcSetViewLayers(ctx->openHevcHandle, 1);
return GF_OK;
}
GF_Err gf_isom_ismacryp_sample_to_sample(GF_ISMASample *s, GF_ISOSample *dest)
{
GF_BitStream *bs;
if (!s || !dest) return GF_BAD_PARAM;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if (s->flags & GF_ISOM_ISMA_USE_SEL_ENC) {
gf_bs_write_int(bs, (s->flags & GF_ISOM_ISMA_IS_ENCRYPTED) ? 1 : 0, 1);
gf_bs_write_int(bs, 0, 7);
}
if (s->flags & GF_ISOM_ISMA_IS_ENCRYPTED) {
if (s->IV_length) gf_bs_write_long_int(bs, s->IV, 8*s->IV_length);
if (s->KI_length) gf_bs_write_data(bs, (char*)s->key_indicator, s->KI_length);
}
gf_bs_write_data(bs, s->data, s->dataLength);
if (dest->data) free(dest->data);
dest->data = NULL;
dest->dataLength = 0;
gf_bs_get_content(bs, &dest->data, &dest->dataLength);
gf_bs_del(bs);
return GF_OK;
}
static void DEV_Start(struct __input_device *ifce)
{
GF_BitStream *bs;
char *buf, *szWord;
u32 len, val, i, buf_size;
szWord = "Hello InputSensor!";
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
/*HTK sensor buffer format: SFString - SFInt32 - SFFloat*/
gf_bs_write_int(bs, 1, 1);
len = strlen(szWord);
val = gf_get_bit_size(len);
gf_bs_write_int(bs, val, 5);
gf_bs_write_int(bs, len, val);
for (i=0; i<len; i++) gf_bs_write_int(bs, szWord[i], 8);
gf_bs_align(bs);
gf_bs_get_content(bs, &buf, &buf_size);
gf_bs_del(bs);
ifce->DispatchFrame(ifce, buf, buf_size);
gf_free(buf);
}
static GF_Err gf_isom_load_next_hint_sample(GF_ISOFile *the_file, u32 trackNumber, GF_TrackBox *trak, GF_HintSampleEntryBox *entry)
{
GF_BitStream *bs;
u32 descIdx;
GF_ISOSample *samp;
if (!entry->cur_sample) return GF_BAD_PARAM;
if (entry->cur_sample>trak->Media->information->sampleTable->SampleSize->sampleCount) return GF_EOS;
samp = gf_isom_get_sample(the_file, trackNumber, entry->cur_sample, &descIdx);
if (!samp) return GF_IO_ERR;
entry->cur_sample++;
if (entry->hint_sample) gf_isom_hint_sample_del(entry->hint_sample);
bs = gf_bs_new(samp->data, samp->dataLength, GF_BITSTREAM_READ);
entry->hint_sample = gf_isom_hint_sample_new(entry->type);
gf_isom_hint_sample_read(entry->hint_sample, bs, samp->dataLength);
gf_bs_del(bs);
entry->hint_sample->TransmissionTime = samp->DTS;
gf_isom_sample_del(&samp);
entry->hint_sample->sample_cache = gf_list_new();
return GF_OK;
}
u32 MPEGVS_OnData(struct __input_device * dr, const char* data)
{
GF_BitStream *bs;
char *buf;
u32 buf_size;
float x, y, z, q, a, b;
MPEGVSCTX;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if ( rc->sensorAndroidType == 1
|| rc->sensorAndroidType == 2
|| rc->sensorAndroidType == 3
|| rc->sensorAndroidType == 4 )
{
sscanf(data, "%f;%f;%f;", &x, &y, &z);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, x);
gf_bs_write_float(bs, y);
gf_bs_write_float(bs, z);
}
else if ( rc->sensorAndroidType == 5
|| rc->sensorAndroidType == 6 )
{
sscanf(data, "%f;", &x);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, x);
}
else if ( rc->sensorAndroidType == 11 )
{
sscanf(data, "%f;%f;%f;", &x, &y, &z);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, x);
gf_bs_write_float(bs, y);
gf_bs_write_float(bs, z);
/*gf_bs_write_float(bs, q);*/
}
else if ( rc->sensorAndroidType == 100 )
{
sscanf(data, "%f;%f;%f;%f;%f;", &x, &y, &z, &a, &b);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, x);
gf_bs_write_float(bs, y);
gf_bs_write_float(bs, z);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, a);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, b);
/*gf_bs_write_float(bs, q);*/
}
gf_bs_align(bs);
gf_bs_get_content(bs, &buf, &buf_size);
gf_bs_del(bs);
dr->DispatchFrame(dr, (u8*)buf, buf_size);
gf_free(buf);
return GF_OK;
}
