static GF_Err gf_isom_get_3gpp_audio_esd(GF_SampleTableBox *stbl, GF_GenericAudioSampleEntryBox *entry, GF_ESD **out_esd)
{
GF_BitStream *bs;
char szName[80];
(*out_esd) = gf_odf_desc_esd_new(2);
(*out_esd)->decoderConfig->streamType = GF_STREAM_AUDIO;
/*official mapping to MPEG-4*/
switch (entry->type) {
case GF_ISOM_SUBTYPE_3GP_EVRC:
(*out_esd)->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_EVRC_VOICE;
return GF_OK;
case GF_ISOM_SUBTYPE_3GP_QCELP:
{
u32 block_size, sample_rate, sample_size, i;
GF_SttsEntry *ent;
/*only map CBR*/
sample_size = stbl->SampleSize->sampleSize;
(*out_esd)->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_13K_VOICE;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_data(bs, "QLCMfmt ", 8);
gf_bs_write_u32_le(bs, 150);/*fmt chunk size*/
gf_bs_write_u8(bs, 1);
gf_bs_write_u8(bs, 0);
/*QCELP GUID*/
gf_bs_write_data(bs, "\x41\x6D\x7F\x5E\x15\xB1\xD0\x11\xBA\x91\x00\x80\x5F\xB4\xB9\x7E", 16);
gf_bs_write_u16_le(bs, 1);
memset(szName, 0, 80);
strcpy(szName, "QCELP-13K(GPAC-emulated)");
gf_bs_write_data(bs, szName, 80);
ent = &stbl->TimeToSample->entries[0];
sample_rate = entry->samplerate_hi;
block_size = ent ? ent->sampleDelta : 160;
gf_bs_write_u16_le(bs, 8*sample_size*sample_rate/block_size);
gf_bs_write_u16_le(bs, sample_size);
gf_bs_write_u16_le(bs, block_size);
gf_bs_write_u16_le(bs, sample_rate);
gf_bs_write_u16_le(bs, entry->bitspersample);
gf_bs_write_u32_le(bs, sample_size ? 0 : 7);
/**/
for (i=0; i<7; i++) {
static const u32 qcelp_r2s [] = {0, 1, 1, 4, 2, 8, 3, 17, 4, 35, 5, 8, 14, 1};
if (sample_size) {
gf_bs_write_u16(bs, 0);
} else {
gf_bs_write_u8(bs, qcelp_r2s[2*i+1]);
gf_bs_write_u8(bs, qcelp_r2s[2*i]);
}
}
gf_bs_write_u16(bs, 0);
memset(szName, 0, 80);
gf_bs_write_data(bs, szName, 20);/*reserved*/
gf_bs_get_content(bs, & (*out_esd)->decoderConfig->decoderSpecificInfo->data, & (*out_esd)->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
}
return GF_OK;
case GF_ISOM_SUBTYPE_3GP_SMV:
(*out_esd)->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_SMV_VOICE;
return GF_OK;
default:
break;
}
/*this is a user-reserved used in gpac - we need a std OTI for AMR/AMRWB*/
(*out_esd)->decoderConfig->objectTypeIndication = GPAC_OTI_MEDIA_GENERIC;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, entry->type);
gf_bs_write_u16(bs, entry->samplerate_hi);
gf_bs_write_u16(bs, (entry->type == GF_ISOM_SUBTYPE_3GP_AMR) ? 160 : 320);
gf_bs_write_u8(bs, entry->channel_count);
gf_bs_write_u8(bs, entry->bitspersample);
gf_bs_write_u8(bs, 0);
gf_bs_get_content(bs, & (*out_esd)->decoderConfig->decoderSpecificInfo->data, & (*out_esd)->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
return GF_OK;
}
static GF_Err gf_sm_live_setup(GF_SceneEngine *seng)
{
GF_Err e;
GF_StreamContext *sc;
GF_InitialObjectDescriptor *iod;
GF_ESD *esd;
u32 i, j;
e = GF_OK;
iod = (GF_InitialObjectDescriptor *) seng->ctx->root_od;
/*build an IOD*/
if (!iod) {
seng->ctx->root_od = (GF_ObjectDescriptor*) gf_odf_desc_new(GF_ODF_IOD_TAG);
iod = (GF_InitialObjectDescriptor *) seng->ctx->root_od;
i=0;
while ((sc = gf_list_enum(seng->ctx->streams, &i))) {
if (sc->streamType != GF_STREAM_SCENE) continue;
if (!sc->ESID) sc->ESID = 1;
esd = gf_odf_desc_esd_new(2);
gf_odf_desc_del((GF_Descriptor *) esd->decoderConfig->decoderSpecificInfo);
esd->decoderConfig->decoderSpecificInfo = NULL;
esd->ESID = sc->ESID;
esd->decoderConfig->streamType = GF_STREAM_SCENE;
esd->decoderConfig->objectTypeIndication = sc->objectType;
gf_list_add(iod->ESDescriptors, esd);
if (!sc->timeScale) sc->timeScale = 1000;
esd->slConfig->timestampResolution = sc->timeScale;
}
}
i=0;
while ((sc = (GF_StreamContext*)gf_list_enum(seng->ctx->streams, &i))) {
j=0;
while ((esd = gf_list_enum(seng->ctx->root_od->ESDescriptors, &j))) {
if (sc->ESID==esd->ESID) {
break;
}
}
if (!esd) continue;
if (!esd->slConfig) esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
if (!esd->slConfig->timestampResolution) esd->slConfig->timestampResolution = 1000;
if (!sc->timeScale) sc->timeScale = esd->slConfig->timestampResolution;
if (sc->streamType == GF_STREAM_SCENE) {
switch (sc->objectType) {
#ifndef GPAC_DISABLE_BIFS_ENC
case GPAC_OTI_SCENE_BIFS:
case GPAC_OTI_SCENE_BIFS_V2:
e = gf_sm_setup_bifsenc(seng, sc, esd);
break;
#endif
#ifndef GPAC_DISABLE_LASER
case GPAC_OTI_SCENE_LASER:
e = gf_sm_setup_lsrenc(seng, sc, esd);
break;
#endif
case GPAC_OTI_SCENE_DIMS:
/* Nothing to be done here */
break;
default:
e = GF_NOT_SUPPORTED;
break;
}
if (e) return e;
}
}
return e;
}
static GF_ESD *FFD_GetESDescriptor(FFDemux *ffd, Bool for_audio)
{
GF_BitStream *bs;
Bool dont_use_sl;
GF_ESD *esd = (GF_ESD *) gf_odf_desc_esd_new(0);
esd->ESID = 1 + (for_audio ? ffd->audio_st : ffd->video_st);
esd->decoderConfig->streamType = for_audio ? GF_STREAM_AUDIO : GF_STREAM_VISUAL;
esd->decoderConfig->avgBitrate = esd->decoderConfig->maxBitrate = 0;
/*remap std object types - depending on input formats, FFMPEG may not have separate DSI from initial frame.
In this case we have no choice but using FFMPEG decoders*/
if (for_audio) {
AVCodecContext *dec = ffd->ctx->streams[ffd->audio_st]->codec;
esd->slConfig->timestampResolution = ffd->audio_tscale.den;
switch (dec->codec_id) {
case CODEC_ID_MP2:
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG1;
break;
case CODEC_ID_MP3:
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG2_PART3;
break;
case CODEC_ID_AAC:
if (!dec->extradata_size) goto opaque_audio;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
esd->decoderConfig->decoderSpecificInfo->dataLength = dec->extradata_size;
esd->decoderConfig->decoderSpecificInfo->data = gf_malloc(sizeof(char)*dec->extradata_size);
memcpy(esd->decoderConfig->decoderSpecificInfo->data,
dec->extradata,
sizeof(char)*dec->extradata_size);
break;
default:
opaque_audio:
esd->decoderConfig->objectTypeIndication = GPAC_OTI_MEDIA_FFMPEG;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, dec->codec_id);
gf_bs_write_u32(bs, dec->sample_rate);
gf_bs_write_u16(bs, dec->channels);
gf_bs_write_u16(bs, dec->frame_size);
gf_bs_write_u8(bs, 16);
gf_bs_write_u8(bs, 0);
/*ffmpeg specific*/
gf_bs_write_u16(bs, dec->block_align);
gf_bs_write_u32(bs, dec->bit_rate);
gf_bs_write_u32(bs, dec->codec_tag);
if (dec->extradata_size) {
gf_bs_write_data(bs, (char *) dec->extradata, dec->extradata_size);
}
gf_bs_get_content(bs, (char **) &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
break;
}
dont_use_sl = ffd->unreliable_audio_timing;
} else {
AVCodecContext *dec = ffd->ctx->streams[ffd->video_st]->codec;
esd->slConfig->timestampResolution = ffd->video_tscale.den;
switch (dec->codec_id) {
case CODEC_ID_MPEG4:
/*there is a bug in fragmentation of raw H264 in ffmpeg, the NALU startcode (0x00000001) is split across
two frames - we therefore force internal ffmpeg codec ID to avoid NALU size recompute
at the decoder level*/
// case CODEC_ID_H264:
/*if dsi not detected force use ffmpeg*/
if (!dec->extradata_size) goto opaque_video;
/*otherwise use any MPEG-4 Visual*/
esd->decoderConfig->objectTypeIndication = (dec->codec_id==CODEC_ID_H264) ? GPAC_OTI_VIDEO_AVC : GPAC_OTI_VIDEO_MPEG4_PART2;
esd->decoderConfig->decoderSpecificInfo->dataLength = dec->extradata_size;
esd->decoderConfig->decoderSpecificInfo->data = gf_malloc(sizeof(char)*dec->extradata_size);
memcpy(esd->decoderConfig->decoderSpecificInfo->data,
dec->extradata,
sizeof(char)*dec->extradata_size);
break;
case CODEC_ID_MPEG1VIDEO:
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG1;
break;
case CODEC_ID_MPEG2VIDEO:
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG2_422;
break;
default:
opaque_video:
esd->decoderConfig->objectTypeIndication = GPAC_OTI_MEDIA_FFMPEG;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, dec->codec_id);
gf_bs_write_u16(bs, dec->width);
gf_bs_write_u16(bs, dec->height);
/*ffmpeg specific*/
gf_bs_write_u32(bs, dec->bit_rate);
gf_bs_write_u32(bs, dec->codec_tag);
gf_bs_write_u32(bs, dec->pix_fmt);
if (dec->extradata_size) {
gf_bs_write_data(bs, (char *) dec->extradata, dec->extradata_size);
}
gf_bs_get_content(bs, (char **) &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
break;
}
dont_use_sl = 0;
}
if (dont_use_sl) {
esd->slConfig->predefined = SLPredef_SkipSL;
} else {
/*only send full AUs*/
esd->slConfig->useAccessUnitStartFlag = esd->slConfig->useAccessUnitEndFlag = 0;
esd->slConfig->hasRandomAccessUnitsOnlyFlag = 1;
esd->slConfig->useTimestampsFlag = 1;
}
return esd;
}
GF_Err Media_GetESD(GF_MediaBox *mdia, u32 sampleDescIndex, GF_ESD **out_esd, Bool true_desc_only)
{
GF_ESD *esd;
GF_MPEGSampleEntryBox *entry = NULL;
GF_ESDBox *ESDa;
GF_SampleDescriptionBox *stsd = mdia->information->sampleTable->SampleDescription;
*out_esd = NULL;
if (!stsd || !stsd->other_boxes || !sampleDescIndex || (sampleDescIndex > gf_list_count(stsd->other_boxes)) )
return GF_BAD_PARAM;
esd = NULL;
entry = (GF_MPEGSampleEntryBox*)gf_list_get(stsd->other_boxes, sampleDescIndex - 1);
if (! entry) return GF_ISOM_INVALID_MEDIA;
*out_esd = NULL;
ESDa = NULL;
switch (entry->type) {
case GF_ISOM_BOX_TYPE_MP4V:
case GF_ISOM_BOX_TYPE_ENCV:
ESDa = ((GF_MPEGVisualSampleEntryBox*)entry)->esd;
if (ESDa) esd = (GF_ESD *) ESDa->desc;
/*avc1 encrypted*/
else esd = ((GF_MPEGVisualSampleEntryBox*) entry)->emul_esd;
break;
case GF_ISOM_BOX_TYPE_AVC1:
case GF_ISOM_BOX_TYPE_AVC2:
case GF_ISOM_BOX_TYPE_AVC3:
case GF_ISOM_BOX_TYPE_AVC4:
case GF_ISOM_BOX_TYPE_SVC1:
case GF_ISOM_BOX_TYPE_HVC1:
case GF_ISOM_BOX_TYPE_HEV1:
case GF_ISOM_BOX_TYPE_HVC2:
case GF_ISOM_BOX_TYPE_HEV2:
case GF_ISOM_BOX_TYPE_SHC1:
case GF_ISOM_BOX_TYPE_SHV1:
esd = ((GF_MPEGVisualSampleEntryBox*) entry)->emul_esd;
break;
case GF_ISOM_BOX_TYPE_MP4A:
case GF_ISOM_BOX_TYPE_ENCA:
ESDa = ((GF_MPEGAudioSampleEntryBox*)entry)->esd;
if (ESDa) esd = (GF_ESD *) ESDa->desc;
break;
case GF_ISOM_BOX_TYPE_MP4S:
case GF_ISOM_BOX_TYPE_ENCS:
ESDa = entry->esd;
if (ESDa) esd = (GF_ESD *) ESDa->desc;
break;
case GF_ISOM_BOX_TYPE_TX3G:
case GF_ISOM_BOX_TYPE_TEXT:
if (!true_desc_only && mdia->mediaTrack->moov->mov->convert_streaming_text) {
GF_Err e = gf_isom_get_ttxt_esd(mdia, out_esd);
if (e) return e;
break;
}
else return GF_ISOM_INVALID_MEDIA;
#ifndef GPAC_DISABLE_TTXT
case GF_ISOM_BOX_TYPE_WVTT:
{
GF_BitStream *bs;
esd = gf_odf_desc_esd_new(2);
*out_esd = esd;
esd->decoderConfig->streamType = GF_STREAM_TEXT;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_SCENE_VTT_MP4;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, entry->type);
boxstring_Write((GF_Box *)((GF_WebVTTSampleEntryBox*)entry)->config, bs);
gf_bs_get_content(bs, & esd->decoderConfig->decoderSpecificInfo->data, & esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
}
break;
case GF_ISOM_BOX_TYPE_STSE:
{
GF_BitStream *bs;
esd = gf_odf_desc_esd_new(2);
*out_esd = esd;
esd->decoderConfig->streamType = GF_STREAM_TEXT;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_SCENE_SIMPLE_TEXT_MP4;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, entry->type);
boxstring_Write((GF_Box *)((GF_SimpleTextSampleEntryBox*)entry)->config, bs);
gf_bs_get_content(bs, & esd->decoderConfig->decoderSpecificInfo->data, & esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
}
break;
#endif
case GF_ISOM_SUBTYPE_3GP_AMR:
case GF_ISOM_SUBTYPE_3GP_AMR_WB:
case GF_ISOM_SUBTYPE_3GP_EVRC:
case GF_ISOM_SUBTYPE_3GP_QCELP:
case GF_ISOM_SUBTYPE_3GP_SMV:
if (!true_desc_only) {
GF_Err e = gf_isom_get_3gpp_audio_esd(mdia->information->sampleTable, (GF_GenericAudioSampleEntryBox*)entry, out_esd);
if (e) return e;
break;
} else return GF_ISOM_INVALID_MEDIA;
case GF_ISOM_SUBTYPE_3GP_H263:
if (true_desc_only) {
return GF_ISOM_INVALID_MEDIA;
} else {
GF_BitStream *bs;
esd = gf_odf_desc_esd_new(2);
*out_esd = esd;
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_MEDIA_GENERIC;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, entry->type);
gf_bs_write_u16(bs, ((GF_MPEGVisualSampleEntryBox*)entry)->Width);
gf_bs_write_u16(bs, ((GF_MPEGVisualSampleEntryBox*)entry)->Height);
gf_bs_get_content(bs, & esd->decoderConfig->decoderSpecificInfo->data, & esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
break;
}
case GF_ISOM_SUBTYPE_LSR1:
if (true_desc_only) {
return GF_ISOM_INVALID_MEDIA;
} else {
GF_LASeRSampleEntryBox*ptr = (GF_LASeRSampleEntryBox*)entry;
esd = gf_odf_desc_esd_new(2);
*out_esd = esd;
esd->decoderConfig->streamType = GF_STREAM_SCENE;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_SCENE_LASER;
esd->decoderConfig->decoderSpecificInfo->dataLength = ptr->lsr_config->hdr_size;
esd->decoderConfig->decoderSpecificInfo->data = gf_malloc(sizeof(char)*ptr->lsr_config->hdr_size);
memcpy(esd->decoderConfig->decoderSpecificInfo->data, ptr->lsr_config->hdr, sizeof(char)*ptr->lsr_config->hdr_size);
break;
}
default: return GF_ISOM_INVALID_MEDIA;
}
if (true_desc_only) {
if (!esd) return GF_ISOM_INVALID_MEDIA;
*out_esd = esd;
return GF_OK;
} else {
if (!esd && !*out_esd) return GF_ISOM_INVALID_MEDIA;
if (*out_esd == NULL) gf_odf_desc_copy((GF_Descriptor *)esd, (GF_Descriptor **)out_esd);
}
return GF_OK;
}
static GF_ObjectDescriptor *MP2TS_GetOD(M2TSIn *m2ts, GF_M2TS_PES *stream, char *dsi, u32 dsi_size, u32 *streamType)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
/*create a stream description for this channel*/
esd = gf_odf_desc_esd_new(0);
esd->ESID = stream->mpeg4_es_id ? stream->mpeg4_es_id : stream->pid;
switch (stream->stream_type) {
case GF_M2TS_VIDEO_MPEG1:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG1;
break;
case GF_M2TS_VIDEO_MPEG2:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG2_422;
break;
case GF_M2TS_VIDEO_MPEG4:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG4_PART2;
break;
case GF_M2TS_VIDEO_H264:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_AVC;
break;
case GF_M2TS_VIDEO_VC1:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_SMPTE_VC1;
break;
case GF_M2TS_AUDIO_MPEG1:
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG1;
break;
case GF_M2TS_AUDIO_MPEG2:
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG2_PART3;
break;
case GF_M2TS_AUDIO_LATM_AAC:
case GF_M2TS_AUDIO_AAC:
if (!dsi) {
/*discard regulate until we fetch the AAC config*/
m2ts->ts->file_regulate = 0;
/*turn on parsing*/
gf_m2ts_set_pes_framing(stream, GF_M2TS_PES_FRAMING_DEFAULT);
gf_odf_desc_del((GF_Descriptor *)esd);
return NULL;
}
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
break;
case GF_M2TS_SYSTEMS_MPEG4_SECTIONS:
default:
gf_odf_desc_del((GF_Descriptor *)esd);
return NULL;
}
esd->decoderConfig->bufferSizeDB = 0;
/*we only use AUstart indicator*/
esd->slConfig->useAccessUnitStartFlag = 1;
esd->slConfig->useAccessUnitEndFlag = 0;
esd->slConfig->useRandomAccessPointFlag = 1;
esd->slConfig->AUSeqNumLength = 0;
esd->slConfig->timestampResolution = 90000;
/*ASSIGN PCR here*/
esd->OCRESID = stream->program->pcr_pid;
if (stream->pid == stream->program->pcr_pid) {
esd->slConfig->OCRResolution = 27000000;
}
/*decoder config*/
if (dsi) {
esd->decoderConfig->decoderSpecificInfo->data = gf_malloc(sizeof(char)*dsi_size);
memcpy(esd->decoderConfig->decoderSpecificInfo->data, dsi, sizeof(char)*dsi_size);
esd->decoderConfig->decoderSpecificInfo->dataLength = dsi_size;
}
/*declare object to terminal*/
od = (GF_ObjectDescriptor*)gf_odf_desc_new(GF_ODF_OD_TAG);
gf_list_add(od->ESDescriptors, esd);
od->objectDescriptorID = 0;
if (streamType) *streamType = esd->decoderConfig->streamType;
/*remember program number for service/program selection*/
od->ServiceID = stream->program->number;
od->service_ifce = m2ts->owner;
return od;
}
int main(int argc, char **argv)
{
GF_ISOFile *movie;
GF_ESD *esd;
GF_Err e;
Double gb_size = 5.0;
u8 store_mode;
u32 track, di, i, nb_samp;
GF_ISOSample *samp;
store_mode = GF_ISOM_OPEN_WRITE;
for (i=1; i<argc; i++) {
if (!strcmp(argv[i], "-flat")) store_mode = GF_ISOM_OPEN_WRITE;
else if (!strcmp(argv[i], "-inter")) store_mode = GF_ISOM_WRITE_EDIT;
else if (!strcmp(argv[i], "-size") && (i+1<argc)) {
gb_size = atof(argv[i+1]);
i++;
}
else if (!strcmp(argv[i], "-h")) {
PrintUsage();
return 0;
}
}
nb_samp = (u32) (gb_size*1024);
fprintf(stdout, "Creating test file %s - %g GBytes - %d samples - %s mode\n", TEST_FILE_NAME, gb_size, nb_samp, (store_mode == GF_ISOM_OPEN_WRITE) ? "Flat" : "Interleaved");
movie = gf_isom_open(TEST_FILE_NAME, store_mode, NULL);
if (!movie) {
fprintf(stdout, "Error creating file: %s\n", gf_error_to_string(gf_isom_last_error(NULL)));
return 1;
}
track = gf_isom_new_track(movie, 1, GF_ISOM_MEDIA_VISUAL, 25);
esd = gf_odf_desc_esd_new(2);
esd->decoderConfig->streamType = 4;
gf_isom_new_mpeg4_description(movie, track, esd, NULL, NULL, &di);
samp = gf_isom_sample_new();
samp->dataLength = 1024*1024;
samp->data = gf_malloc(sizeof(char)*samp->dataLength);
memset(samp->data, 0, sizeof(char)*samp->dataLength);
for (i=0; i<nb_samp; i++) {
if (samp->DTS % 25) samp->IsRAP = 0;
else samp->IsRAP = 1;
e = gf_isom_add_sample(movie, track, di, samp);
samp->DTS += 1;
fprintf(stdout, "Writing sample %d / %d \r", i+1, nb_samp);
if (e) break;
}
gf_isom_sample_del(&samp);
if (e) {
fprintf(stdout, "\nError writing sample %d\n", i);
gf_isom_delete(movie);
return 1;
}
fprintf(stdout, "\nDone writing samples\n");
e = gf_isom_close(movie);
if (e) {
fprintf(stdout, "Error writing file\n");
return 1;
}
return 0;
}
static GF_Err gf_sm_live_setup(GF_BifsEngine *codec)
{
GF_Err e;
char *data;
u32 data_len;
GF_InitialObjectDescriptor *iod;
u32 i, j, count, nbb;
GF_ESD *esd;
Bool is_in_iod, delete_desc, encode_names, delete_bcfg;
GF_BIFSConfig *bcfg;
e = GF_OK;
iod = (GF_InitialObjectDescriptor *) codec->ctx->root_od;
/*if no iod check we only have one bifs*/
if (!iod) {
count = 0;
i=0;
while ((codec->sc = (GF_StreamContext*)gf_list_enum(codec->ctx->streams, &i))) {
if (codec->sc->streamType == GF_STREAM_OD) count++;
codec->sc = NULL;
}
if (!iod && count>1) return GF_NOT_SUPPORTED;
}
codec->sc = NULL;
count = gf_list_count(codec->ctx->streams);
i=0;
while ((codec->sc = (GF_StreamContext*)gf_list_enum(codec->ctx->streams, &i))) {
if (codec->sc->streamType == GF_STREAM_SCENE) break;
}
if (!codec->sc) return GF_NOT_SUPPORTED;
if (!codec->sc->ESID) codec->sc->ESID = 1;
codec->bifsenc = gf_bifs_encoder_new(codec->ctx->scene_graph);
delete_desc = 0;
esd = NULL;
is_in_iod = 1;
if (iod) {
is_in_iod = 0;
j=0;
while ((esd = (GF_ESD*)gf_list_enum(iod->ESDescriptors, &j))) {
if (esd->decoderConfig && esd->decoderConfig->streamType == GF_STREAM_SCENE) {
if (!codec->sc->ESID) codec->sc->ESID = esd->ESID;
if (codec->sc->ESID == esd->ESID) {
is_in_iod = 1;
break;
}
}
/*special BIFS direct import from NHNT*/
else if (gf_list_count(iod->ESDescriptors)==1) {
codec->sc->ESID = esd->ESID;
is_in_iod = 1;
break;
}
esd = NULL;
}
}
if (!esd) {
delete_desc = 1;
esd = gf_odf_desc_esd_new(2);
gf_odf_desc_del((GF_Descriptor *) esd->decoderConfig->decoderSpecificInfo);
esd->decoderConfig->decoderSpecificInfo = NULL;
esd->ESID = codec->sc->ESID;
esd->decoderConfig->streamType = GF_STREAM_SCENE;
}
delete_bcfg = 0;
/*should NOT happen (means inputctx is not properly setup)*/
if (!esd->decoderConfig->decoderSpecificInfo) {
bcfg = (GF_BIFSConfig*)gf_odf_desc_new(GF_ODF_BIFS_CFG_TAG);
bcfg->pixelMetrics = codec->ctx->is_pixel_metrics;
bcfg->pixelWidth = codec->ctx->scene_width;
bcfg->pixelHeight = codec->ctx->scene_height;
delete_bcfg = 1;
}
/*regular retrieve from ctx*/
else if (esd->decoderConfig->decoderSpecificInfo->tag == GF_ODF_BIFS_CFG_TAG) {
bcfg = (GF_BIFSConfig *)esd->decoderConfig->decoderSpecificInfo;
}
/*should not happen either (unless loading from MP4 in which case BIFSc is not decoded)*/
else {
bcfg = gf_odf_get_bifs_config(esd->decoderConfig->decoderSpecificInfo, esd->decoderConfig->objectTypeIndication);
delete_bcfg = 1;
}
/*NO CHANGE TO BIFSC otherwise the generated update will not match the input context, UNLESS NO NbBits
were specified*/
nbb = gf_get_bit_size(codec->ctx->max_node_id);
if (!bcfg->nodeIDbits) bcfg->nodeIDbits = nbb;
else if (bcfg->nodeIDbits<nbb) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[BIFS] BIFSConfig.NodeIDBits too small (%d bits vs %d nodes)\n", bcfg->nodeIDbits, codec->ctx->max_node_id));
}
nbb = gf_get_bit_size(codec->ctx->max_route_id);
if (!bcfg->routeIDbits) bcfg->routeIDbits = nbb;
else if (bcfg->routeIDbits<nbb) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[BIFS] BIFSConfig.RouteIDBits too small (%d bits vs %d routes)\n", bcfg->routeIDbits, codec->ctx->max_route_id));
}
nbb = gf_get_bit_size(codec->ctx->max_proto_id);
if (!bcfg->protoIDbits) bcfg->protoIDbits=nbb;
else if (bcfg->protoIDbits<nbb) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[BIFS] BIFSConfig.ProtoIDBits too small (%d bits vs %d protos)\n", bcfg->protoIDbits, codec->ctx->max_proto_id));
}
/*this is the real pb, not stored in cfg or file level, set at EACH replaceScene*/
encode_names = 0;
/* The BIFS Config that is passed here should be the BIFSConfig from the IOD */
gf_bifs_encoder_new_stream(codec->bifsenc, codec->sc->ESID, bcfg, encode_names, 0);
if (delete_bcfg) gf_odf_desc_del((GF_Descriptor *)bcfg);
if (!esd->slConfig) esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
if (codec->sc->timeScale) esd->slConfig->timestampResolution = codec->sc->timeScale;
if (!esd->slConfig->timestampResolution) esd->slConfig->timestampResolution = 1000;
esd->ESID = codec->sc->ESID;
gf_bifs_encoder_get_config(codec->bifsenc, codec->sc->ESID, &data, &data_len);
if (esd->decoderConfig->decoderSpecificInfo) gf_odf_desc_del((GF_Descriptor *) esd->decoderConfig->decoderSpecificInfo);
esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->decoderConfig->decoderSpecificInfo->data = data;
esd->decoderConfig->decoderSpecificInfo->dataLength = data_len;
codec->stream_ts_res = esd->slConfig->timestampResolution;
memcpy(codec->encoded_bifs_config, data, data_len);
codec->encoded_bifs_config_size = data_len;
esd->decoderConfig->objectTypeIndication = gf_bifs_encoder_get_version(codec->bifsenc, codec->sc->ESID);
return e;
}
GF_Err LIBPLAYER_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
LibPlayerIn *read = (LibPlayerIn *) plug->priv;
#ifndef TEST_LIBPLAYER
unsigned long prop;
mrl_t *mrl = NULL;
#endif
printf("[LibPlayerIN]connecting\n");
if (!read || !serv || !url) return GF_BAD_PARAM;
if (!strnicmp(url, "libplayer://", 12)) url+=12;
if (!read->init) {
read->init=1;
/* libplayer init */
read->url = url;
read->player_id = libplayer_id;
#ifndef TEST_LIBPLAYER
read->player = player_init(PLAYER_TYPE_DUMMY, PLAYER_AO_AUTO, PLAYER_VO_AUTO, PLAYER_MSG_INFO, read->player_id, on_libplayer_event);
//~ read->width = 0;
//~ read->height = 0;
if (!read->player) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Failed to instanciate libplayer instance %d\n", read->player_id));
gf_term_on_connect(serv, NULL, GF_REMOTE_SERVICE_ERROR);
return GF_OK;
}
#endif
libplayer_id++;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIN] Opening URL %s for Player instance %d\n", url, read->player_id));
//~ player_local_location_set(read->player, url);
}
#ifndef TEST_LIBPLAYER
mrl = NULL;
if (!strnicmp(url, "dvb://", 6)) {
}
else if (!strnicmp(url, "file://", 7) || !strstr(url, "://")) {
mrl_resource_local_args_t *mrl_args;
mrl_args = calloc(1, sizeof(mrl_resource_local_args_t));
if (!strnicmp(url, "file://", 7)) {
mrl_args->location = strdup(url + 7);
} else {
mrl_args->location = strdup(url);
}
mrl = mrl_new (read->player, MRL_RESOURCE_FILE, mrl_args);
}
else {
}
if (!mrl) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Failed to create MRL for url %s\n", url));
gf_term_on_connect(serv, NULL, GF_URL_ERROR);
return GF_OK;
}
player_mrl_set(read->player, mrl);
#endif
read->state = 0;
read->service = serv;
/*ACK connection is OK*/
gf_term_on_connect(serv, NULL, GF_OK);
/*setup LIBPLAYER object descriptor*/
{
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1+read->player_id;
esd = gf_odf_desc_esd_new(0);
esd->ESID = 1+read->player_id;
esd->slConfig->timestampResolution = 1000;
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_MEDIA;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_PRIVATE_MEDIA_LIBPLAYER;
#ifndef TEST_LIBPLAYER
esd->decoderConfig->decoderSpecificInfo->data = read;
#endif
gf_list_add(od->ESDescriptors, esd);
gf_term_add_media(read->service, (GF_Descriptor*)od, 0);
}
return GF_OK;
}
GF_Err gf_isom_get_ttxt_esd(GF_MediaBox *mdia, GF_ESD **out_esd)
{
GF_BitStream *bs;
u32 count, i;
Bool has_v_info;
GF_List *sampleDesc;
GF_ESD *esd;
GF_TrackBox *tk;
*out_esd = NULL;
sampleDesc = mdia->information->sampleTable->SampleDescription->other_boxes;
count = gf_list_count(sampleDesc);
if (!count) return GF_ISOM_INVALID_MEDIA;
esd = gf_odf_desc_esd_new(2);
esd->decoderConfig->streamType = GF_STREAM_TEXT;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_TEXT_MPEG4;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
/*Base3GPPFormat*/
gf_bs_write_u8(bs, 0x10);
/*MPEGExtendedFormat*/
gf_bs_write_u8(bs, 0x10);
/*profileLevel*/
gf_bs_write_u8(bs, 0x10);
gf_bs_write_u24(bs, mdia->mediaHeader->timeScale);
gf_bs_write_int(bs, 0, 1); /*no alt formats*/
gf_bs_write_int(bs, 2, 2); /*only out-of-band-band sample desc*/
gf_bs_write_int(bs, 1, 1); /*we will write sample desc*/
/*write v info if any visual track in this movie*/
has_v_info = 0;
i=0;
while ((tk = (GF_TrackBox*)gf_list_enum(mdia->mediaTrack->moov->trackList, &i))) {
if (tk->Media->handler && (tk->Media->handler->handlerType == GF_ISOM_MEDIA_VISUAL)) {
has_v_info = 1;
}
}
gf_bs_write_int(bs, has_v_info, 1);
gf_bs_write_int(bs, 0, 3); /*reserved, spec doesn't say the values*/
gf_bs_write_u8(bs, mdia->mediaTrack->Header->layer);
gf_bs_write_u16(bs, mdia->mediaTrack->Header->width>>16);
gf_bs_write_u16(bs, mdia->mediaTrack->Header->height>>16);
/*write desc*/
gf_bs_write_u8(bs, count);
for (i=0; i<count; i++) {
GF_Tx3gSampleEntryBox *a;
a = (GF_Tx3gSampleEntryBox *) gf_list_get(sampleDesc, i);
if ((a->type != GF_ISOM_BOX_TYPE_TX3G) && (a->type != GF_ISOM_BOX_TYPE_TEXT) ) continue;
gf_isom_write_tx3g(a, bs, i+1, SAMPLE_INDEX_OFFSET);
}
if (has_v_info) {
u32 trans;
/*which video shall we pick for MPEG-4, and how is the associations indicated in 3GP ???*/
gf_bs_write_u16(bs, 0);
gf_bs_write_u16(bs, 0);
trans = mdia->mediaTrack->Header->matrix[6];
trans >>= 16;
gf_bs_write_u16(bs, trans);
trans = mdia->mediaTrack->Header->matrix[7];
trans >>= 16;
gf_bs_write_u16(bs, trans);
}
gf_bs_get_content(bs, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
*out_esd = esd;
return GF_OK;
}
/*import cubic QTVR to mp4*/
GF_Err gf_sm_load_init_QT(GF_SceneLoader *load)
{
u32 i, di, w, h, tk, pano_t, nb_samp;
Bool has_qtvr;
GF_ISOSample *samp;
GF_ISOFile *src;
GF_StreamContext *st;
GF_AUContext *au;
GF_Command *com;
M_Background *back;
M_NavigationInfo *ni;
M_Group *gr;
GF_ODUpdate *odU;
GF_SceneGraph *sg;
GF_ObjectDescriptor *od;
GF_ESD *esd;
if (!load->ctx) return GF_NOT_SUPPORTED;
src = gf_isom_open(load->fileName, GF_ISOM_OPEN_READ, NULL);
if (!src) return gf_qt_report(load, GF_URL_ERROR, "Opening file %s failed", load->fileName);
w = h = tk = 0;
pano_t = 0;
nb_samp = 0;
has_qtvr = 0;
for (i=0; i<gf_isom_get_track_count(src); i++) {
switch (gf_isom_get_media_type(src, i+1)) {
case GF_ISOM_MEDIA_VISUAL:
if (gf_isom_get_media_subtype(src, i+1, 1) == GF_4CC('j', 'p', 'e', 'g')) {
GF_GenericSampleDescription *udesc = gf_isom_get_generic_sample_description(src, i+1, 1);
if ((udesc->width>w) || (udesc->height>h)) {
w = udesc->width;
h = udesc->height;
tk = i+1;
nb_samp = gf_isom_get_sample_count(src, i+1);
}
if (udesc->extension_buf) free(udesc->extension_buf);
free(udesc);
}
break;
case GF_4CC('q','t','v','r'):
has_qtvr = 1;
break;
}
}
if (!has_qtvr) {
gf_isom_delete(src);
return gf_qt_report(load, GF_NOT_SUPPORTED, "QTVR not found - no conversion available for this QuickTime movie");
}
if (!tk) {
gf_isom_delete(src);
return gf_qt_report(load, GF_NON_COMPLIANT_BITSTREAM, "No associated visual track with QTVR movie");
}
if (nb_samp!=6) {
gf_isom_delete(src);
return gf_qt_report(load, GF_NOT_SUPPORTED, "Movie %s doesn't look a Cubic QTVR - sorry...", load->fileName);
}
GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("QT: Importing Cubic QTVR Movie"));
/*create scene*/
sg = load->ctx->scene_graph;
gr = (M_Group *) gf_node_new(sg, TAG_MPEG4_Group);
gf_node_register((GF_Node *)gr, NULL);
st = gf_sm_stream_new(load->ctx, 1, GF_STREAM_SCENE, 1);
au = gf_sm_stream_au_new(st, 0, 0, 1);
com = gf_sg_command_new(load->ctx->scene_graph, GF_SG_SCENE_REPLACE);
gf_list_add(au->commands, com);
com->node = (GF_Node *)gr;
back = (M_Background *) gf_node_new(sg, TAG_MPEG4_Background);
gf_node_list_add_child( &gr->children, (GF_Node*)back);
gf_node_register((GF_Node *)back, (GF_Node *)gr);
gf_sg_vrml_mf_alloc(&back->leftUrl, GF_SG_VRML_MFURL, 1);
back->leftUrl.vals[0].OD_ID = 2;
gf_sg_vrml_mf_alloc(&back->frontUrl, GF_SG_VRML_MFURL, 1);
back->frontUrl.vals[0].OD_ID = 3;
gf_sg_vrml_mf_alloc(&back->rightUrl, GF_SG_VRML_MFURL, 1);
back->rightUrl.vals[0].OD_ID = 4;
gf_sg_vrml_mf_alloc(&back->backUrl, GF_SG_VRML_MFURL, 1);
back->backUrl.vals[0].OD_ID = 5;
gf_sg_vrml_mf_alloc(&back->topUrl, GF_SG_VRML_MFURL, 1);
back->topUrl.vals[0].OD_ID = 6;
gf_sg_vrml_mf_alloc(&back->bottomUrl, GF_SG_VRML_MFURL, 1);
back->bottomUrl.vals[0].OD_ID = 7;
ni = (M_NavigationInfo *) gf_node_new(sg, TAG_MPEG4_NavigationInfo);
gf_node_list_add_child(&gr->children, (GF_Node*)ni);
gf_node_register((GF_Node *)ni, (GF_Node *)gr);
gf_sg_vrml_mf_reset(&ni->type, GF_SG_VRML_MFSTRING);
gf_sg_vrml_mf_alloc(&ni->type, GF_SG_VRML_MFSTRING, 1);
ni->type.vals[0] = strdup("QTVR");
/*create ODs*/
st = gf_sm_stream_new(load->ctx, 2, GF_STREAM_OD, 1);
au = gf_sm_stream_au_new(st, 0, 0, 1);
odU = (GF_ODUpdate*) gf_odf_com_new(GF_ODF_OD_UPDATE_TAG);
gf_list_add(au->commands, odU);
for (i=0; i<6; i++) {
GF_MuxInfo *mi;
FILE *img;
char szName[1024];
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 2+i;
esd = gf_odf_desc_esd_new(2);
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = 0x6C;
esd->ESID = 3+i;
/*extract image and remember it*/
mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG);
gf_list_add(esd->extensionDescriptors, mi);
mi->delete_file = 1;
sprintf(szName, "%s_img%d.jpg", load->fileName, esd->ESID);
mi->file_name = strdup(szName);
gf_list_add(od->ESDescriptors, esd);
gf_list_add(odU->objectDescriptors, od);
samp = gf_isom_get_sample(src, tk, i+1, &di);
img = fopen(mi->file_name, "wb");
fwrite(samp->data, samp->dataLength, 1, img);
fclose(img);
gf_isom_sample_del(&samp);
}
gf_isom_delete(src);
return GF_OK;
}
int dc_gpac_audio_moov_create(AudioOutputFile *audio_output_file, char *filename)
{
GF_Err ret;
u32 di, track;
u8 bpsample;
GF_ESD *esd;
#ifndef GPAC_DISABLE_AV_PARSERS
GF_M4ADecSpecInfo acfg;
#endif
AVCodecContext *audio_codec_ctx = audio_output_file->codec_ctx;
audio_output_file->isof = gf_isom_open(filename, GF_ISOM_OPEN_WRITE, NULL);
if (!audio_output_file->isof) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot open iso file %s\n", filename));
return -1;
}
esd = gf_odf_desc_esd_new(2);
if (!esd) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot create GF_ESD\n"));
return -1;
}
esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
if (!strcmp(audio_output_file->codec_ctx->codec->name, "aac")) { //TODO: find an automatic table
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
esd->decoderConfig->bufferSizeDB = 20;
esd->slConfig->timestampResolution = audio_codec_ctx->sample_rate;
esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->ESID = 1;
#ifndef GPAC_DISABLE_AV_PARSERS
memset(&acfg, 0, sizeof(GF_M4ADecSpecInfo));
acfg.base_object_type = GF_M4A_AAC_LC;
acfg.base_sr = audio_codec_ctx->sample_rate;
acfg.nb_chan = audio_codec_ctx->channels;
acfg.sbr_object_type = 0;
acfg.audioPL = gf_m4a_get_profile(&acfg);
ret = gf_m4a_write_config(&acfg, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
assert(ret == GF_OK);
#endif
} else {
if (strcmp(audio_output_file->codec_ctx->codec->name, "mp2")) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("Unlisted codec, setting GPAC_OTI_AUDIO_MPEG1 descriptor.\n"));
}
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG1;
esd->decoderConfig->bufferSizeDB = 20;
esd->slConfig->timestampResolution = audio_codec_ctx->sample_rate;
esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->ESID = 1;
#ifndef GPAC_DISABLE_AV_PARSERS
memset(&acfg, 0, sizeof(GF_M4ADecSpecInfo));
acfg.base_object_type = GF_M4A_LAYER2;
acfg.base_sr = audio_codec_ctx->sample_rate;
acfg.nb_chan = audio_codec_ctx->channels;
acfg.sbr_object_type = 0;
acfg.audioPL = gf_m4a_get_profile(&acfg);
ret = gf_m4a_write_config(&acfg, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
assert(ret == GF_OK);
#endif
}
//gf_isom_store_movie_config(video_output_file->isof, 0);
track = gf_isom_new_track(audio_output_file->isof, esd->ESID, GF_ISOM_MEDIA_AUDIO, audio_codec_ctx->sample_rate);
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("TimeScale: %d \n", audio_codec_ctx->time_base.den));
if (!track) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot create new track\n"));
return -1;
}
ret = gf_isom_set_track_enabled(audio_output_file->isof, track, 1);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_track_enabled\n", gf_error_to_string(ret)));
return -1;
}
// if (!esd->ESID) esd->ESID = gf_isom_get_track_id(audio_output_file->isof, track);
ret = gf_isom_new_mpeg4_description(audio_output_file->isof, track, esd, NULL, NULL, &di);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_new_mpeg4_description\n", gf_error_to_string(ret)));
return -1;
}
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
bpsample = av_get_bytes_per_sample(audio_output_file->codec_ctx->sample_fmt) * 8;
ret = gf_isom_set_audio_info(audio_output_file->isof, track, di, audio_codec_ctx->sample_rate, audio_output_file->codec_ctx->channels, bpsample);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_audio_info\n", gf_error_to_string(ret)));
return -1;
}
#ifndef GPAC_DISABLE_AV_PARSERS
ret = gf_isom_set_pl_indication(audio_output_file->isof, GF_ISOM_PL_AUDIO, acfg.audioPL);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_pl_indication\n", gf_error_to_string(ret)));
return -1;
}
#endif
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("time scale: %d sample dur: %d \n", audio_codec_ctx->time_base.den, audio_output_file->codec_ctx->frame_size));
ret = gf_isom_setup_track_fragment(audio_output_file->isof, track, 1, audio_output_file->codec_ctx->frame_size, 0, 0, 0, 0);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_setup_track_fragment\n", gf_error_to_string(ret)));
return -1;
}
//gf_isom_add_track_to_root_od(video_output_file->isof,1);
ret = gf_isom_finalize_for_fragment(audio_output_file->isof, 1);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_finalize_for_fragment\n", gf_error_to_string(ret)));
return -1;
}
ret = gf_media_get_rfc_6381_codec_name(audio_output_file->isof, track, audio_output_file->audio_data_conf->codec6381, GF_FALSE, GF_FALSE);
if (ret != GF_OK) return -1;
return 0;
}
GF_Err LIBPLAYER_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
LibPlayerIn *read = (LibPlayerIn *) plug->priv;
#ifndef TEST_LIBPLAYER
mrl_t *mrl = NULL;
#endif
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Connecting\n"));
if (!read || !serv || !url) return GF_BAD_PARAM;
if (!strnicmp(url, "libplayer://", 12)) url+=12;
if (!read->init) {
read->init=1;
/* libplayer init with default width/height */
read->width = 80;
read->height = 20;
read->url = url;
read->player_id = libplayer_id;
read->player_type = PLAYER_FILE;
#ifndef TEST_LIBPLAYER
read->player = player_init(PLAYER_TYPE_DUMMY, PLAYER_AO_AUTO, PLAYER_VO_AUTO, PLAYER_MSG_INFO, read->player_id, on_libplayer_event);
if (!read->player) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Failed to instanciate libplayer instance %d\n", read->player_id));
gf_service_connect_ack(serv, NULL, GF_REMOTE_SERVICE_ERROR);
return GF_OK;
}
#endif
libplayer_id++;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIN] Opening URL %s for Player instance %d\n", url, read->player_id));
}
#ifndef TEST_LIBPLAYER
mrl = NULL;
// dvb
if (!strnicmp(url, "dvb://", 6)) {
read->player_type = PLAYER_DVB;
mrl_resource_dvb_args_t *mrl_dvb_args;
mrl_dvb_args = calloc(1, sizeof(mrl_resource_dvb_args_t));
char *frequency;
// fetch frequency
if (frequency = strchr(url+6, '@')) {
char *enc, *pid;
mrl_dvb_args->frequency = atoi(frequency+1);
/*
* video
*/
// video codec
if (enc = strstr(url+6, "mpeg2")) {
mrl_dvb_args->video_enc = PLAYER_VIDEO_MPEG2;
}
else if (enc = strstr(url+6, "h264")) {
mrl_dvb_args->video_enc = PLAYER_VIDEO_H264;
}
else {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Unknown video encoding\n"));
mrl_dvb_args->video_enc = PLAYER_VIDEO_UNKNOWN;
}
// video PID
if (mrl_dvb_args->video_enc != PLAYER_VIDEO_UNKNOWN) {
pid = strchr(enc, ':');
mrl_dvb_args->video_pid = atoi(pid+1);
}
/*
* audio
*/
// audio codec
if (enc = strstr(url+6, "mp2")) {
mrl_dvb_args->audio_enc = PLAYER_AUDIO_MP2;
}
else if (enc = strstr(url+6, "ac3")) {
mrl_dvb_args->audio_enc = PLAYER_AUDIO_AC3;
}
else {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Unknown audio encoding\n"));
mrl_dvb_args->audio_enc = PLAYER_AUDIO_UNKNOWN;
}
// audio PID
if (mrl_dvb_args->audio_enc != PLAYER_AUDIO_UNKNOWN) {
pid = strchr(enc, ':');
mrl_dvb_args->audio_pid = atoi(pid+1);
}
if (mrl_dvb_args->video_enc == PLAYER_VIDEO_UNKNOWN && mrl_dvb_args->audio_enc == PLAYER_AUDIO_UNKNOWN) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Unknown video and audio encoding\n"));
free(mrl_dvb_args);
return GF_BAD_PARAM;
}
}
else {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN]�Unknown frequency\n"));
free(mrl_dvb_args);
return GF_BAD_PARAM;
}
// player instance 1 has not starter yet in dvb case <=> player instance 1 is not created yet
if (start_dvb == 0) {
mrl = mrl_new(read->player, MRL_RESOURCE_DVB, mrl_dvb_args);
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIN] MRL created for DVB\n"));
// player has already started, zapping case, make sure the player is not recreated
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIN] Starting DVB PES filtering\n"));
player_dvb_pes_filter_start(read->player, mrl_dvb_args->video_enc, mrl_dvb_args->video_pid, mrl_dvb_args->audio_enc, mrl_dvb_args->audio_pid);
}
}
else if (!strnicmp(url, "file://", 7) || !strstr(url, "://")) {
mrl_resource_local_args_t *mrl_args;
mrl_args = calloc(1, sizeof(mrl_resource_local_args_t));
if (!strnicmp(url, "file://", 7)) {
mrl_args->location = strdup(url + 7);
} else {
mrl_args->location = strdup(url);
}
mrl = mrl_new (read->player, MRL_RESOURCE_FILE, mrl_args);
}
// only for DVB case to make sure player is only set once
if (start_dvb == 0) {
if (!mrl) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[LibPlayerIN] Failed to create MRL for url %s\n", url));
gf_service_connect_ack(serv, NULL, GF_URL_ERROR);
return GF_OK;
}
player_mrl_set(read->player, mrl);
}
#endif
read->state = 0;
read->service = serv;
/*ACK connection is OK*/
gf_service_connect_ack(serv, NULL, GF_OK);
/*setup LIBPLAYER object descriptor*/
{
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1+read->player_id;
esd = gf_odf_desc_esd_new(0);
esd->ESID = 1+read->player_id;
esd->slConfig->timestampResolution = 1000;
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_MEDIA;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_PRIVATE_MEDIA_LIBPLAYER;
#ifndef TEST_LIBPLAYER
esd->decoderConfig->decoderSpecificInfo->data = read;
#endif
gf_list_add(od->ESDescriptors, esd);
gf_service_declare_media(read->service, (GF_Descriptor*)od, 0);
}
return GF_OK;
}
int dc_gpac_audio_moov_create(AudioOutputFile * p_aoutf, char * psz_name) {
GF_Err ret;
AVCodecContext * p_audio_codec_ctx = p_aoutf->p_codec_ctx;
u32 di;
u32 track;
GF_M4ADecSpecInfo acfg;
p_aoutf->p_isof = gf_isom_open(psz_name,
GF_ISOM_OPEN_WRITE, NULL);
if (!p_aoutf->p_isof) {
fprintf(stderr, "Cannot open iso file %s\n",
psz_name);
return -1;
}
memset(&acfg, 0, sizeof(GF_M4ADecSpecInfo));
acfg.base_object_type = GF_M4A_AAC_LC;
acfg.base_sr = p_audio_codec_ctx->sample_rate;
acfg.nb_chan = p_audio_codec_ctx->channels;
acfg.sbr_object_type = 0;
acfg.audioPL = gf_m4a_get_profile(&acfg);
GF_ESD * p_esd = gf_odf_desc_esd_new(2);
if (!p_esd) {
fprintf(stderr, "Cannot create GF_ESD\n");
return -1;
}
p_esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
p_esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
p_esd->decoderConfig->streamType = GF_STREAM_AUDIO;
p_esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
p_esd->decoderConfig->bufferSizeDB = 20;
p_esd->slConfig->timestampResolution = p_audio_codec_ctx->sample_rate;
p_esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
p_esd->ESID = 1;
ret = gf_m4a_write_config(&acfg, &p_esd->decoderConfig->decoderSpecificInfo->data, &p_esd->decoderConfig->decoderSpecificInfo->dataLength);
//gf_isom_store_movie_config(p_voutf->p_isof, 0);
track = gf_isom_new_track(p_aoutf->p_isof, p_esd->ESID,
GF_ISOM_MEDIA_AUDIO, p_audio_codec_ctx->sample_rate);
//printf("TimeScale: %d \n", p_video_codec_ctx->time_base.den);
if (!track) {
fprintf(stderr, "Cannot create new track\n");
return -1;
}
ret = gf_isom_set_track_enabled(p_aoutf->p_isof, track, 1);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_set_track_enabled\n",
gf_error_to_string(ret));
return -1;
}
// if (!p_esd->ESID) p_esd->ESID = gf_isom_get_track_id(p_aoutf->p_isof, track);
ret = gf_isom_new_mpeg4_description(p_aoutf->p_isof, track, p_esd, NULL,
NULL, &di);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_new_mpeg4_description\n",
gf_error_to_string(ret));
return -1;
}
gf_odf_desc_del((GF_Descriptor *) p_esd);
p_esd = NULL;
u8 bpsample = av_get_bytes_per_sample(p_aoutf->p_codec_ctx->sample_fmt) * 8;
ret = gf_isom_set_audio_info(p_aoutf->p_isof, track, di,
p_audio_codec_ctx->sample_rate, p_aoutf->p_codec_ctx->channels,
bpsample);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_set_audio_info\n",
gf_error_to_string(ret));
return -1;
}
ret = gf_isom_set_pl_indication(p_aoutf->p_isof, GF_ISOM_PL_AUDIO, acfg.audioPL);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_set_pl_indication\n",
gf_error_to_string(ret));
return -1;
}
//printf("time scale: %d sample dur: %d \n",
// p_video_codec_ctx->time_base.den, p_aoutf->p_codec_ctx->frame_size);
ret = gf_isom_setup_track_fragment(p_aoutf->p_isof, track, 1,
p_aoutf->p_codec_ctx->frame_size, 0, 0, 0, 0);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_setup_track_fragment\n",
gf_error_to_string(ret));
return -1;
}
//gf_isom_add_track_to_root_od(p_voutf->p_isof,1);
ret = gf_isom_finalize_for_fragment(p_aoutf->p_isof, 1);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_finalize_for_fragment\n",
gf_error_to_string(ret));
return -1;
}
return 0;
}
static void SAF_NetIO(void *cbk, GF_NETIO_Parameter *param)
{
GF_Err e;
Bool is_rap, go;
SAFChannel *ch;
u32 cts, au_sn, au_size, type, i, stream_id;
u64 bs_pos;
GF_BitStream *bs;
GF_SLHeader sl_hdr;
SAFIn *read = (SAFIn *) cbk;
e = param->error;
/*done*/
if (param->msg_type==GF_NETIO_DATA_TRANSFERED) {
if (read->stream && (read->saf_type==SAF_FILE_REMOTE)) read->saf_type = SAF_FILE_LOCAL;
return;
} else {
/*handle service message*/
gf_service_download_update_stats(read->dnload);
if (param->msg_type!=GF_NETIO_DATA_EXCHANGE) {
if (e<0) {
if (read->needs_connection) {
read->needs_connection = 0;
gf_service_connect_ack(read->service, NULL, e);
}
return;
}
if (read->needs_connection) {
u32 total_size;
gf_dm_sess_get_stats(read->dnload, NULL, NULL, &total_size, NULL, NULL, NULL);
if (!total_size) read->saf_type = SAF_LIVE_STREAM;
}
return;
}
}
if (!param->size) return;
if (!read->run_state) return;
if (read->alloc_size < read->saf_size + param->size) {
read->saf_data = (char*)gf_realloc(read->saf_data, sizeof(char)*(read->saf_size + param->size) );
read->alloc_size = read->saf_size + param->size;
}
memcpy(read->saf_data + read->saf_size, param->data, sizeof(char)*param->size);
read->saf_size += param->size;
/*first AU not complete yet*/
if (read->saf_size<10) return;
bs = gf_bs_new(read->saf_data, read->saf_size, GF_BITSTREAM_READ);
bs_pos = 0;
go = 1;
while (go) {
u64 avail = gf_bs_available(bs);
bs_pos = gf_bs_get_position(bs);
if (avail<10) break;
is_rap = gf_bs_read_int(bs, 1);
au_sn = gf_bs_read_int(bs, 15);
gf_bs_read_int(bs, 2);
cts = gf_bs_read_int(bs, 30);
au_size = gf_bs_read_int(bs, 16);
avail-=8;
if (au_size > avail) break;
assert(au_size>=2);
is_rap = 1;
type = gf_bs_read_int(bs, 4);
stream_id = gf_bs_read_int(bs, 12);
au_size -= 2;
ch = saf_get_channel(read, stream_id, NULL);
switch (type) {
case 1:
case 2:
case 7:
if (ch) {
gf_bs_skip_bytes(bs, au_size);
} else {
SAFChannel *first = (SAFChannel *)gf_list_get(read->channels, 0);
GF_SAFEALLOC(ch, SAFChannel);
ch->stream_id = stream_id;
ch->esd = gf_odf_desc_esd_new(0);
ch->esd->ESID = stream_id;
ch->esd->OCRESID = first ? first->stream_id : stream_id;
ch->esd->slConfig->useRandomAccessPointFlag = 1;
ch->esd->slConfig->AUSeqNumLength = 0;
ch->esd->decoderConfig->objectTypeIndication = gf_bs_read_u8(bs);
ch->esd->decoderConfig->streamType = gf_bs_read_u8(bs);
ch->ts_res = ch->esd->slConfig->timestampResolution = gf_bs_read_u24(bs);
ch->esd->decoderConfig->bufferSizeDB = gf_bs_read_u16(bs);
au_size -= 7;
if ((ch->esd->decoderConfig->objectTypeIndication == 0xFF) && (ch->esd->decoderConfig->streamType == 0xFF) ) {
u16 mimeLen = gf_bs_read_u16(bs);
gf_bs_skip_bytes(bs, mimeLen);
au_size -= mimeLen+2;
}
if (type==7) {
u16 urlLen = gf_bs_read_u16(bs);
ch->esd->URLString = (char*)gf_malloc(sizeof(char)*(urlLen+1));
gf_bs_read_data(bs, ch->esd->URLString, urlLen);
ch->esd->URLString[urlLen] = 0;
au_size -= urlLen+2;
}
if (au_size) {
ch->esd->decoderConfig->decoderSpecificInfo->dataLength = au_size;
ch->esd->decoderConfig->decoderSpecificInfo->data = (char*)gf_malloc(sizeof(char)*au_size);
gf_bs_read_data(bs, ch->esd->decoderConfig->decoderSpecificInfo->data, au_size);
}
if (ch->esd->decoderConfig->streamType==4) ch->buffer_min=100;
else if (ch->esd->decoderConfig->streamType==5) ch->buffer_min=400;
else ch->buffer_min=0;
if (read->needs_connection && (ch->esd->decoderConfig->streamType==GF_STREAM_SCENE)) {
gf_list_add(read->channels, ch);
read->needs_connection = 0;
gf_service_connect_ack(read->service, NULL, GF_OK);
} else if (read->needs_connection) {
gf_odf_desc_del((GF_Descriptor *) ch->esd);
gf_free(ch);
ch = NULL;
} else {
GF_ObjectDescriptor *od;
gf_list_add(read->channels, ch);
od = (GF_ObjectDescriptor*)gf_odf_desc_new(GF_ODF_OD_TAG);
gf_list_add(od->ESDescriptors, ch->esd);
ch->esd = NULL;
od->objectDescriptorID = ch->stream_id;
gf_service_declare_media(read->service, (GF_Descriptor*)od, 0);
}
}
break;
case 4:
if (ch) {
bs_pos = gf_bs_get_position(bs);
memset(&sl_hdr, 0, sizeof(GF_SLHeader));
sl_hdr.accessUnitLength = au_size;
sl_hdr.AU_sequenceNumber = au_sn;
sl_hdr.compositionTimeStampFlag = 1;
sl_hdr.compositionTimeStamp = cts;
sl_hdr.randomAccessPointFlag = is_rap;
if (read->start_range && (read->start_range*ch->ts_res>cts*1000)) {
sl_hdr.compositionTimeStamp = read->start_range*ch->ts_res/1000;
}
gf_service_send_packet(read->service, ch->ch, read->saf_data+bs_pos, au_size, &sl_hdr, GF_OK);
}
gf_bs_skip_bytes(bs, au_size);
break;
case 3:
if (ch) gf_service_send_packet(read->service, ch->ch, NULL, 0, NULL, GF_EOS);
break;
case 5:
go = 0;
read->run_state = 0;
i=0;
while ((ch = (SAFChannel *)gf_list_enum(read->channels, &i))) {
gf_service_send_packet(read->service, ch->ch, NULL, 0, NULL, GF_EOS);
}
break;
}
}
gf_bs_del(bs);
if (bs_pos) {
u32 remain = (u32) (read->saf_size - bs_pos);
if (remain) memmove(read->saf_data, read->saf_data+bs_pos, sizeof(char)*remain);
read->saf_size = remain;
}
SAF_Regulate(read);
}
static GF_ESD *MP2TS_GetESD(M2TSIn *m2ts, GF_M2TS_PES *stream, char *dsi, u32 dsi_size)
{
GF_ESD *esd;
esd = gf_odf_desc_esd_new(0);
esd->ESID = stream->mpeg4_es_id ? stream->mpeg4_es_id : stream->pid;
switch (stream->stream_type) {
case GF_M2TS_VIDEO_MPEG1:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG1;
break;
case GF_M2TS_VIDEO_MPEG2:
case GF_M2TS_VIDEO_DCII:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG2_422;
break;
case GF_M2TS_VIDEO_MPEG4:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_MPEG4_PART2;
break;
case GF_M2TS_VIDEO_H264:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_AVC;
break;
case GF_M2TS_VIDEO_SVC:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_SVC;
break;
case GF_M2TS_VIDEO_HEVC:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_HEVC;
break;
case GF_M2TS_VIDEO_VC1:
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_VIDEO_SMPTE_VC1;
break;
case GF_M2TS_AUDIO_MPEG1:
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG1;
break;
case GF_M2TS_AUDIO_MPEG2:
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG2_PART3;
break;
case GF_M2TS_AUDIO_LATM_AAC:
case GF_M2TS_AUDIO_AAC:
case GPAC_OTI_AUDIO_AAC_MPEG2_MP:
case GPAC_OTI_AUDIO_AAC_MPEG2_LCP:
case GPAC_OTI_AUDIO_AAC_MPEG2_SSRP:
if (!dsi) {
/*turn on parsing to get AAC config
NB: we removed "no file regulation" since we may get broken files where PMT declares an AAC stream but no AAC PID is in the MUX
(filtered out). In this case, "no regulation" will make the entire TS to be read as fast as possible
*/
if (m2ts->ts->file)
m2ts->ts->file_regulate = 2;
gf_m2ts_set_pes_framing(stream, GF_M2TS_PES_FRAMING_DEFAULT);
gf_odf_desc_del((GF_Descriptor *)esd);
return NULL;
}
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
break;
case GF_M2TS_SYSTEMS_MPEG4_SECTIONS:
default:
gf_odf_desc_del((GF_Descriptor *)esd);
return NULL;
}
esd->decoderConfig->bufferSizeDB = 0;
/*we only use AUstart indicator*/
esd->slConfig->useAccessUnitStartFlag = 1;
esd->slConfig->useAccessUnitEndFlag = 0;
esd->slConfig->useRandomAccessPointFlag = 1;
esd->slConfig->AUSeqNumLength = 0;
esd->slConfig->timestampResolution = 90000;
/*ASSIGN PCR here*/
esd->OCRESID = stream->program->pcr_pid;
if (stream->pid == stream->program->pcr_pid) {
esd->slConfig->OCRResolution = 27000000;
}
/*decoder config*/
if (dsi) {
esd->decoderConfig->decoderSpecificInfo->data = gf_malloc(sizeof(char)*dsi_size);
memcpy(esd->decoderConfig->decoderSpecificInfo->data, dsi, sizeof(char)*dsi_size);
esd->decoderConfig->decoderSpecificInfo->dataLength = dsi_size;
}
return esd;
}
