static GF_ObjectDescriptor *RP_GetChannelOD(RTPStream *ch, u32 ch_idx)
{
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
if (!ch->ES_ID) ch->ES_ID = ch_idx + 1;
od->objectDescriptorID = ch->OD_ID ? ch->OD_ID : ch->ES_ID;
esd = gf_odf_desc_esd_new(0);
esd->slConfig->timestampResolution = gf_rtp_get_clockrate(ch->rtp_ch);
esd->slConfig->useRandomAccessPointFlag = 1;
esd->slConfig->useTimestampsFlag = 1;
esd->ESID = ch->ES_ID;
esd->OCRESID = 0;
esd->decoderConfig->streamType = ch->depacketizer->sl_map.StreamType;
esd->decoderConfig->objectTypeIndication = ch->depacketizer->sl_map.ObjectTypeIndication;
if (ch->depacketizer->sl_map.config) {
esd->decoderConfig->decoderSpecificInfo->data = (char*)gf_malloc(sizeof(char) * ch->depacketizer->sl_map.configSize);
memcpy(esd->decoderConfig->decoderSpecificInfo->data, ch->depacketizer->sl_map.config, sizeof(char) * ch->depacketizer->sl_map.configSize);
esd->decoderConfig->decoderSpecificInfo->dataLength = ch->depacketizer->sl_map.configSize;
}
if (ch->depacketizer->sl_map.rvc_predef) {
esd->decoderConfig->predefined_rvc_config = ch->depacketizer->sl_map.rvc_predef;
} else if (ch->depacketizer->sl_map.rvc_config) {
esd->decoderConfig->rvc_config = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->decoderConfig->rvc_config->data = ch->depacketizer->sl_map.rvc_config;
esd->decoderConfig->rvc_config->dataLength = ch->depacketizer->sl_map.rvc_config_size;
ch->depacketizer->sl_map.rvc_config = NULL;
ch->depacketizer->sl_map.rvc_config_size = 0;
}
gf_list_add(od->ESDescriptors, esd);
return od;
}
/*special authoring functions*/
GF_EXPORT
GF_BIFSConfig *gf_odf_get_bifs_config(GF_DefaultDescriptor *dsi, u8 oti)
{
Bool hasSize, cmd_stream;
GF_BitStream *bs;
GF_BIFSConfig *cfg;
if (oti>=GPAC_OTI_SCENE_BIFS_EXTENDED) return NULL;
if (!dsi || !dsi->data || !dsi->dataLength ) {
/* Hack for T-DMB non compliant streams (OnTimeTek ?) */
cfg = (GF_BIFSConfig *) gf_odf_desc_new(GF_ODF_BIFS_CFG_TAG);
cfg->pixelMetrics = 1;
cfg->version = 1;
return cfg;
}
bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
cfg = (GF_BIFSConfig *) gf_odf_desc_new(GF_ODF_BIFS_CFG_TAG);
if (oti==2) {
/*3D Mesh Coding*/
gf_bs_read_int(bs, 1);
/*PMF*/
gf_bs_read_int(bs, 1);
}
cfg->nodeIDbits = gf_bs_read_int(bs, 5);
cfg->routeIDbits = gf_bs_read_int(bs, 5);
if (oti==2) cfg->protoIDbits = gf_bs_read_int(bs, 5);
cmd_stream = gf_bs_read_int(bs, 1);
if (!cmd_stream) {
cfg->elementaryMasks = gf_list_new();
while (1) {
GF_ElementaryMask* em = (GF_ElementaryMask* ) gf_odf_New_ElemMask();
em->node_id = gf_bs_read_int(bs, cfg->nodeIDbits);
gf_list_add(cfg->elementaryMasks, em);
/*this assumes only FDP, BDP and IFS2D (no elem mask)*/
if (gf_bs_read_int(bs, 1) == 0) break;
}
gf_bs_align(bs);
if (gf_bs_get_size(bs) != gf_bs_get_position(bs)) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[ODF] Reading bifs config: shift in sizes (not supported)\n"));
}
} else {
cfg->pixelMetrics = gf_bs_read_int(bs, 1);
hasSize = gf_bs_read_int(bs, 1);
if (hasSize) {
cfg->pixelWidth = gf_bs_read_int(bs, 16);
cfg->pixelHeight = gf_bs_read_int(bs, 16);
}
gf_bs_align(bs);
if (gf_bs_get_size(bs) != gf_bs_get_position(bs))
GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[ODF] Reading bifs config: shift in sizes (invalid descriptor)\n"));
}
gf_bs_del(bs);
return cfg;
}
GF_EXPORT
GF_ESD *gf_odf_desc_esd_new(u32 sl_predefined)
{
GF_ESD *esd;
esd = (GF_ESD *)gf_odf_desc_new(GF_ODF_ESD_TAG);
esd->decoderConfig = (GF_DecoderConfig *)gf_odf_desc_new(GF_ODF_DCD_TAG);
esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *)gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->slConfig = (GF_SLConfig *)gf_odf_new_slc((u8)sl_predefined);
return esd;
}
//写入AAC信息
bool EasyMP4Writer::WriteAACInfo(unsigned char*info,int len, int nSampleRate, int nChannel, int nBitsPerSample)
{
p_audiosample=gf_isom_sample_new();
p_audiosample->data=(char*)malloc(1024*10);
GF_ESD*esd= gf_odf_desc_esd_new(0);
esd->ESID=gf_isom_get_track_id(p_file,m_audiotrackid);
esd->OCRESID=gf_isom_get_track_id(p_file,m_audiotrackid);
esd->decoderConfig->streamType=0x05;
esd->decoderConfig->objectTypeIndication=0x40;//0x40;
esd->slConfig->timestampResolution=1000;//1000;//时间单元
esd->decoderConfig->decoderSpecificInfo=(GF_DefaultDescriptor*)gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->decoderConfig->decoderSpecificInfo->data=(char*)malloc(len);
memcpy(esd->decoderConfig->decoderSpecificInfo->data,info,len);
esd->decoderConfig->decoderSpecificInfo->dataLength=len;
GF_Err gferr=gf_isom_new_mpeg4_description(p_file, m_audiotrackid, esd, NULL, NULL, &i_audiodescidx);
if (gferr!=0)
{
// TRACE("mpeg4_description:%d\n",gferr);
}
gferr=gf_isom_set_audio_info(p_file,m_audiotrackid,i_audiodescidx, nSampleRate,nChannel, nBitsPerSample);//44100 2 16
if (gferr!=0)
{
// TRACE("gf_isom_set_audio:%d\n",gferr);
}
free(esd->decoderConfig->decoderSpecificInfo->data);
return true;
}
GF_EXPORT
GF_Err gf_odf_encode_ui_config(GF_UIConfig *cfg, GF_DefaultDescriptor **out_dsi)
{
u32 i, len;
GF_BitStream *bs;
GF_DefaultDescriptor *dsi;
if (!out_dsi || (cfg->tag != GF_ODF_UI_CFG_TAG)) return GF_BAD_PARAM;
*out_dsi = NULL;
if (!cfg->deviceName) return GF_OK;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
len = strlen(cfg->deviceName);
gf_bs_write_int(bs, len, 8);
for (i=0; i<len; i++) gf_bs_write_int(bs, cfg->deviceName[i], 8);
if (!stricmp(cfg->deviceName, "StringSensor")) {
/*fixme - this should be UTF-8 chars*/
if (cfg->delChar || cfg->termChar) {
gf_bs_write_int(bs, cfg->termChar, 8);
gf_bs_write_int(bs, cfg->delChar, 8);
}
}
if (cfg->ui_data) gf_bs_write_data(bs, cfg->ui_data, cfg->ui_data_length);
dsi = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
gf_bs_get_content(bs, &dsi->data, &dsi->dataLength);
gf_bs_del(bs);
*out_dsi = dsi;
return GF_OK;
}
static GF_ObjectDescriptor *M2TS_GenerateEPG_OD(M2TSIn *m2ts)
{
/* declaring a special stream for displaying eit */
GF_ObjectDescriptor *od;
GF_ESD *esd;
/*create a stream description for this channel*/
esd = gf_odf_desc_esd_new(0);
esd->ESID = GF_M2TS_PID_EIT_ST_CIT;
esd->OCRESID = GF_M2TS_PID_EIT_ST_CIT;
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_SCENE;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_PRIVATE_SCENE_EPG;
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;*/
/*declare object to terminal*/
od = (GF_ObjectDescriptor*)gf_odf_desc_new(GF_ODF_OD_TAG);
gf_list_add(od->ESDescriptors, esd);
od->objectDescriptorID = 0;
od->service_ifce = m2ts->owner;
return od;
}
static GF_Descriptor *TTIn_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
TTIn *tti;
if (!plug)
return NULL;
tti = (TTIn *)plug->priv;
if (!tti)
return NULL;
/*visual object*/
switch (expect_type) {
case GF_MEDIA_OBJECT_UNDEF:
case GF_MEDIA_OBJECT_UPDATES:
case GF_MEDIA_OBJECT_TEXT:
{
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
GF_ESD *esd = tti_get_esd(tti);
od->objectDescriptorID = esd->ESID;
gf_list_add(od->ESDescriptors, esd);
tti->od_done = 1;
return (GF_Descriptor *) od;
}
default:
return NULL;
}
return NULL;
}
static GF_Descriptor *V4_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
V4Service *v4service= (V4Service *) plug->priv;
GF_ESD *esd;
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;
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 = 0x01; //V4_PRIVATE_SCENE_OTI;
if (v4service->GetPath()) {
esd->decoderConfig->decoderSpecificInfo->dataLength = strlen(v4service->GetPath()) + 1;
esd->decoderConfig->decoderSpecificInfo->data = strdup(v4service->GetPath());
}
gf_list_add(iod->ESDescriptors, esd);
return (GF_Descriptor *)iod;
}
static GF_ObjectDescriptor *OGG_GetOD(OGGStream *st)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = (st->info.streamType==GF_STREAM_AUDIO) ? 3 : 2;
esd = gf_odf_desc_esd_new(0);
esd->decoderConfig->streamType = st->info.streamType;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_MEDIA_OGG;
esd->decoderConfig->avgBitrate = st->info.bitrate;
esd->ESID = st->ESID;
esd->slConfig->useTimestampsFlag = 1;
esd->slConfig->useAccessUnitEndFlag = esd->slConfig->useAccessUnitStartFlag = 1;
esd->slConfig->timestampResolution = st->info.sample_rate ? st->info.sample_rate : (u32) (1000*st->info.frame_rate);
if (st->info.sample_rate) esd->slConfig->hasRandomAccessUnitsOnlyFlag = 1;
else esd->slConfig->useRandomAccessPointFlag = 1;
esd->decoderConfig->decoderSpecificInfo->dataLength = st->dsi_len;
esd->decoderConfig->decoderSpecificInfo->data = (char *) gf_malloc(sizeof(char) * st->dsi_len);
memcpy(esd->decoderConfig->decoderSpecificInfo->data, st->dsi, sizeof(char) * st->dsi_len);
gf_list_add(od->ESDescriptors, esd);
return od;
}
static GF_ObjectDescriptor *RP_GetChannelOD(RTPStream *ch, u32 ch_idx)
{
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
esd = RP_GetChannelESD(ch, ch_idx);
od->objectDescriptorID = ch->OD_ID ? ch->OD_ID : ch->ES_ID;
gf_list_add(od->ESDescriptors, esd);
// for each channel depending on this channel, get esd, set esd->dependsOnESID and add to od
if (ch->owner->is_svc)
{
u32 i, count;
count = gf_list_count(ch->owner->channels);
for (i = 0; i < count; i++)
{
RTPStream *the_channel;
GF_ESD *the_esd;
the_channel = (RTPStream *)gf_list_get(ch->owner->channels, i);
if (the_channel->base_stream == ch->mid)
{
the_esd = RP_GetChannelESD(the_channel, i);
the_esd->dependsOnESID = the_channel->prev_stream;
gf_list_add(od->ESDescriptors, the_esd);
}
}
}
return od;
}
static GF_ESD *RP_GetChannelESD(RTPStream *ch, u32 ch_idx)
{
GF_ESD *esd;
if (!ch->ES_ID) ch->ES_ID = ch_idx + 1;
esd = gf_odf_desc_esd_new(0);
esd->slConfig->timestampResolution = gf_rtp_get_clockrate(ch->rtp_ch);
esd->slConfig->useRandomAccessPointFlag = 1;
esd->slConfig->useTimestampsFlag = 1;
esd->slConfig->no_dts_signaling = ch->depacketizer->sl_map.DTSDeltaLength ? 0 : 1;
esd->ESID = ch->ES_ID;
esd->OCRESID = 0;
if (ch->mid)
esd->has_ref_base = 1;
esd->decoderConfig->streamType = ch->depacketizer->sl_map.StreamType;
esd->decoderConfig->objectTypeIndication = ch->depacketizer->sl_map.ObjectTypeIndication;
if (ch->depacketizer->sl_map.config) {
esd->decoderConfig->decoderSpecificInfo->data = (char*)gf_malloc(sizeof(char) * ch->depacketizer->sl_map.configSize);
memcpy(esd->decoderConfig->decoderSpecificInfo->data, ch->depacketizer->sl_map.config, sizeof(char) * ch->depacketizer->sl_map.configSize);
esd->decoderConfig->decoderSpecificInfo->dataLength = ch->depacketizer->sl_map.configSize;
}
if (ch->depacketizer->sl_map.rvc_predef) {
esd->decoderConfig->predefined_rvc_config = ch->depacketizer->sl_map.rvc_predef;
} else if (ch->depacketizer->sl_map.rvc_config) {
esd->decoderConfig->rvc_config = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->decoderConfig->rvc_config->data = ch->depacketizer->sl_map.rvc_config;
esd->decoderConfig->rvc_config->dataLength = ch->depacketizer->sl_map.rvc_config_size;
ch->depacketizer->sl_map.rvc_config = NULL;
ch->depacketizer->sl_map.rvc_config_size = 0;
}
return esd;
}
static void tti_setup_object(TTIn *tti)
{
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
GF_ESD *esd = tti_get_esd(tti);
od->objectDescriptorID = esd->ESID;
gf_list_add(od->ESDescriptors, esd);
gf_term_add_media(tti->service, (GF_Descriptor *)od, 0);
}
/*emulate a default IOD for all other files (3GP, weird MP4, QT )*/
GF_Descriptor *isor_emulate_iod(ISOMReader *read)
{
/*generate an IOD with our private dynamic OD stream*/
GF_InitialObjectDescriptor *fake_iod = (GF_InitialObjectDescriptor *) gf_odf_desc_new(GF_ODF_IOD_TAG);
isor_emulate_chapters(read->mov, fake_iod);
read->no_service_desc = GF_TRUE;
return (GF_Descriptor *)fake_iod;
}
static GF_ObjectDescriptor* FM_FAKE_PULL_GetOD(void)
{
/*declare object to terminal*/
GF_ObjectDescriptor *od = (GF_ObjectDescriptor*)gf_odf_desc_new(GF_ODF_OD_TAG);
GF_ESD *esd = get_esd();
od->objectDescriptorID = 1;
gf_list_add(od->ESDescriptors, esd);
return od;
}
static u32 ext_media_load_th(void *par) {
GF_HYBMEDIA *self = (GF_HYBMEDIA*) par;
/*declare object to terminal*/
GF_ObjectDescriptor *od = (GF_ObjectDescriptor*)gf_odf_desc_new(GF_ODF_OD_TAG);
od->URLString = gf_strdup("http://gpac.sourceforge.net/screenshots/lion.jpg");
od->objectDescriptorID = 0;
gf_sleep(2000); //TODO: remove the sleep
gf_term_add_media(self->owner, (GF_Descriptor*)od, 0);
return 0;
}
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;
}
static void IMG_SetupObject(IMGLoader *read)
{
if (!read->ch) {
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
GF_ESD *esd = IMG_GetESD(read);
od->objectDescriptorID = 1;
gf_list_add(od->ESDescriptors, esd);
gf_service_declare_media(read->service, (GF_Descriptor *)od, GF_FALSE);
}
}
static void AC3_SetupObject(AC3Reader *read)
{
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1;
esd = AC3_GetESD(read);
esd->OCRESID = 0;
gf_list_add(od->ESDescriptors, esd);
gf_service_declare_media(read->service, (GF_Descriptor*)od, 0);
}
void isor_emulate_chapters(GF_ISOFile *file, GF_InitialObjectDescriptor *iod)
{
GF_Segment *prev_seg;
u64 prev_start;
u64 start;
u32 i, count;
if (!iod || gf_list_count(iod->OCIDescriptors)) return;
count = gf_isom_get_chapter_count(file, 0);
if (!count) return;
prev_seg = NULL;
start = prev_start = 0;
for (i=0; i<count; i++) {
const char *name;
GF_Segment *seg;
gf_isom_get_chapter(file, 0, i+1, &start, &name);
seg = (GF_Segment *) gf_odf_desc_new(GF_ODF_SEGMENT_TAG);
seg->startTime = (Double) (s64) start;
seg->startTime /= 1000;
seg->SegmentName = gf_strdup(name);
gf_list_add(iod->OCIDescriptors, seg);
if (prev_seg) {
prev_seg->Duration = (Double) (s64) (start - prev_start);
prev_seg->Duration /= 1000;
} else if (start) {
prev_seg = (GF_Segment *) gf_odf_desc_new(GF_ODF_SEGMENT_TAG);
prev_seg->startTime = 0;
prev_seg->Duration = (Double) (s64) (start);
prev_seg->Duration /= 1000;
gf_list_insert(iod->OCIDescriptors, prev_seg, 0);
}
prev_seg = seg;
prev_start = start;
}
if (prev_seg) {
start = 1000*gf_isom_get_duration(file);
start /= gf_isom_get_timescale(file);
if (start>prev_start) {
prev_seg->Duration = (Double) (s64) (start - prev_start);
prev_seg->Duration /= 1000;
}
}
}
static void mp3_setup_object(MP3Reader *read)
{
if (read->is_inline) {
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1;
esd = MP3_GetESD(read);
gf_list_add(od->ESDescriptors, esd);
gf_term_add_media(read->service, (GF_Descriptor*)od, 0);
}
}
static GF_Descriptor *FFD_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
FFDemux *ffd = plug->priv;
if (!ffd->ctx) return NULL;
if (expect_type==GF_MEDIA_OBJECT_UNDEF) {
if (ffd->video_st>=0) expect_type=GF_MEDIA_OBJECT_VIDEO;
else if (ffd->audio_st>=0) expect_type=GF_MEDIA_OBJECT_AUDIO;
}
/*since we don't handle multitrack in ffmpeg, we don't need to check sub_url, only use expected type*/
if (expect_type==GF_MEDIA_OBJECT_AUDIO) {
if (ffd->audio_st<0) return NULL;
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1;
esd = FFD_GetESDescriptor(ffd, 1);
/*if session join, setup sync*/
if (ffd->video_ch) esd->OCRESID = ffd->video_st+1;
gf_list_add(od->ESDescriptors, esd);
ffd->service_type = 2;
return (GF_Descriptor *) od;
}
if (expect_type==GF_MEDIA_OBJECT_VIDEO) {
if (ffd->video_st<0) return NULL;
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1;
esd = FFD_GetESDescriptor(ffd, 0);
/*if session join, setup sync*/
if (ffd->audio_ch) esd->OCRESID = ffd->audio_st+1;
gf_list_add(od->ESDescriptors, esd);
ffd->service_type = 1;
return (GF_Descriptor *) od;
}
return NULL;
}
static void FFD_SetupObjects(FFDemux *ffd)
{
GF_ESD *esd;
GF_ObjectDescriptor *od;
u32 audio_esid = 0;
if ((ffd->audio_st>=0) && (ffd->service_type != 1)) {
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
esd = FFD_GetESDescriptor(ffd, 1);
od->objectDescriptorID = esd->ESID;
audio_esid = esd->ESID;
gf_list_add(od->ESDescriptors, esd);
gf_service_declare_media(ffd->service, (GF_Descriptor*)od, (ffd->video_st>=0) ? 1 : 0);
}
if ((ffd->video_st>=0) && (ffd->service_type != 2)) {
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
esd = FFD_GetESDescriptor(ffd, 0);
od->objectDescriptorID = esd->ESID;
esd->OCRESID = audio_esid;
gf_list_add(od->ESDescriptors, esd);
gf_service_declare_media(ffd->service, (GF_Descriptor*)od, 0);
}
}
static GF_Descriptor *MP3_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
MP3Reader *read = plug->priv;
/*since we don't handle multitrack in mp3, we don't need to check sub_url, only use expected type*/
/*audio object*/
if (expect_type==GF_MEDIA_OBJECT_AUDIO) {
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
GF_ESD *esd = MP3_GetESD(read);
od->objectDescriptorID = 1;
gf_list_add(od->ESDescriptors, esd);
return (GF_Descriptor *) od;
}
read->is_inline = 1;
return NULL;
}
/*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;
}
static GF_Descriptor *MP3_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
MP3Reader *read = plug->priv;
/*override default*/
if (expect_type==GF_MEDIA_OBJECT_UNDEF) expect_type=GF_MEDIA_OBJECT_AUDIO;
/*audio object*/
if (expect_type==GF_MEDIA_OBJECT_AUDIO) {
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
GF_ESD *esd = MP3_GetESD(read);
od->objectDescriptorID = 1;
gf_list_add(od->ESDescriptors, esd);
return (GF_Descriptor *) od;
}
read->is_inline = 1;
return NULL;
}
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;
}
static GF_Descriptor *SAF_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
u32 i=0;
SAFChannel *root;
SAFIn *read = (SAFIn *)plug->priv;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_IOD_TAG);
od->objectDescriptorID = 1;
while ( (root = (SAFChannel *)gf_list_enum(read->channels, &i))) {
if (root->esd && (root->esd->decoderConfig->streamType==GF_STREAM_SCENE)) break;
}
if (!root) return NULL;
/*inline scene*/
gf_list_add(od->ESDescriptors, root->esd);
root->esd = NULL;
return (GF_Descriptor *) od;
}
static GF_Descriptor *IMG_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
GF_ESD *esd;
IMGLoader *read = (IMGLoader *)plug->priv;
/*override default*/
if (expect_type==GF_MEDIA_OBJECT_UNDEF) expect_type=GF_MEDIA_OBJECT_VIDEO;
read->srv_type = expect_type;
/*visual object*/
if (expect_type==GF_MEDIA_OBJECT_VIDEO) {
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1;
esd = IMG_GetESD(read);
gf_list_add(od->ESDescriptors, esd);
return (GF_Descriptor *) od;
}
read->is_inline = GF_TRUE;
return NULL;
}
static GF_Descriptor *AC3_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
AC3Reader *read = plug->priv;
/*since we don't handle multitrack in ac3, we don't need to check sub_url, only use expected type*/
/*override default*/
if (expect_type==GF_MEDIA_OBJECT_UNDEF) expect_type=GF_MEDIA_OBJECT_AUDIO;
/*audio object*/
if (expect_type==GF_MEDIA_OBJECT_AUDIO) {
GF_ESD *esd;
GF_ObjectDescriptor *od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 1;
esd = AC3_GetESD(read);
esd->OCRESID = 0;
gf_list_add(od->ESDescriptors, esd);
return (GF_Descriptor *) od;
}
read->is_inline = 1;
/*inline scene: no specific service*/
return NULL;
}
static GF_ObjectDescriptor *MP2TS_GetOD(M2TSIn *m2ts, GF_M2TS_PES *stream, char *dsi, u32 dsi_size, u32 *streamType)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
u32 cur_ES, i, count;
/*create a stream description for this channel*/
esd = MP2TS_GetESD(m2ts, stream, dsi, dsi_size);
if (!esd) return NULL;
/*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;
/*create a stream description for the channels depending on this channel, set esd->dependsOnESID and add to od*/
cur_ES = esd->ESID;
count = gf_list_count(stream->program->streams);
for (i = 0; i < count; i++) {
GF_M2TS_ES *es = (GF_M2TS_ES *)gf_list_get(stream->program->streams, i);
if ((es->flags & GF_M2TS_ES_IS_PES) && ( ((GF_M2TS_PES *)es)->depends_on_pid == cur_ES)) {
GF_ESD *the_esd;
the_esd = MP2TS_GetESD(m2ts, (GF_M2TS_PES *)es, dsi, dsi_size);
if (the_esd) {
the_esd->dependsOnESID = cur_ES;
the_esd->has_ref_base = GF_TRUE;
gf_list_add(od->ESDescriptors, the_esd);
}
cur_ES = the_esd->ESID;
}
}
return od;
}
