/*****************************************************************************
* CloseDecoder: decoder destruction
*****************************************************************************/
static void CloseDecoder( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t *)p_this;
decoder_sys_t *p_sys = p_dec->p_sys;
switch( p_sys->i_cat )
{
case VIDEO_ES:
EndVideoDec ( p_dec );
break;
}
if( p_sys->p_context )
{
av_free( p_sys->p_context->extradata );
p_sys->p_context->extradata = NULL;
if( !p_sys->b_delayed_open )
{
vlc_avcodec_lock();
avcodec_close( p_sys->p_context );
vlc_avcodec_unlock();
}
msg_Dbg( p_dec, "ffmpeg codec (%s) stopped", p_sys->psz_namecodec );
av_free( p_sys->p_context );
}
free( p_sys );
}
void InitLibavcodec( vlc_object_t *p_object )
{
static bool b_ffmpeginit = false;
vlc_avcodec_lock();
/* *** init ffmpeg library (libavcodec) *** */
if( !b_ffmpeginit )
{
#if LIBAVCODEC_VERSION_MAJOR < 54
avcodec_init();
#endif
avcodec_register_all();
b_ffmpeginit = true;
msg_Dbg( p_object, "libavcodec initialized (interface 0x%x)",
LIBAVCODEC_VERSION_INT );
}
else
{
msg_Dbg( p_object, "libavcodec already initialized" );
}
vlc_avcodec_unlock();
}
/*****************************************************************************
* Del: Del an elementary stream
*****************************************************************************/
static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
if ( id->b_switcher_audio )
{
int i;
for ( i = 0; i < MAX_AUDIO; i++ )
{
if ( p_sys->pp_audio_ids[i] == id )
{
p_sys->pp_audio_ids[i] = NULL;
break;
}
}
}
if ( id->ff_enc )
{
vlc_avcodec_lock();
avcodec_close( id->ff_enc_c );
vlc_avcodec_unlock();
av_free( id->ff_enc_c );
av_free( id->p_frame );
free( id->p_buffer_out );
}
if ( id->id )
{
p_sys->p_out->pf_del( p_sys->p_out, id->id );
}
free( id );
return VLC_SUCCESS;
}
/*****************************************************************************
* ffmpeg_OpenCodec:
*****************************************************************************/
static int ffmpeg_OpenCodec( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( p_sys->p_context->extradata_size <= 0 )
{
if( p_sys->i_codec_id == CODEC_ID_VC1 ||
p_sys->i_codec_id == CODEC_ID_VORBIS ||
p_sys->i_codec_id == CODEC_ID_THEORA )
{
msg_Warn( p_dec, "waiting for extra data for codec %s",
p_sys->psz_namecodec );
return 1;
}
}
p_sys->p_context->width = p_dec->fmt_in.video.i_width;
p_sys->p_context->height = p_dec->fmt_in.video.i_height;
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52, 0, 0)
p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel;
#else
p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.video.i_bits_per_pixel;
#endif
int ret;
vlc_avcodec_lock();
ret = avcodec_open( p_sys->p_context, p_sys->p_codec );
vlc_avcodec_unlock();
if( ret < 0 )
return VLC_EGENERIC;
msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
p_sys->b_delayed_open = false;
return VLC_SUCCESS;
}
/*****************************************************************************
* ffmpeg_OpenCodec:
*****************************************************************************/
int ffmpeg_OpenCodec( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( p_sys->p_context->extradata_size <= 0 )
{
if( p_sys->i_codec_id == AV_CODEC_ID_VC1 ||
p_sys->i_codec_id == AV_CODEC_ID_VORBIS ||
p_sys->i_codec_id == AV_CODEC_ID_THEORA ||
( p_sys->i_codec_id == AV_CODEC_ID_AAC &&
!p_dec->fmt_in.b_packetized ) )
{
msg_Warn( p_dec, "waiting for extra data for codec %s",
p_sys->psz_namecodec );
return 1;
}
}
if( p_dec->fmt_in.i_cat == VIDEO_ES )
{
p_sys->p_context->width = p_dec->fmt_in.video.i_visible_width;
p_sys->p_context->height = p_dec->fmt_in.video.i_visible_height;
if (p_sys->p_context->width == 0)
p_sys->p_context->width = p_dec->fmt_in.video.i_width;
else if (p_sys->p_context->width != p_dec->fmt_in.video.i_width)
p_sys->p_context->coded_width = p_dec->fmt_in.video.i_width;
if (p_sys->p_context->height == 0)
p_sys->p_context->height = p_dec->fmt_in.video.i_height;
else if (p_sys->p_context->height != p_dec->fmt_in.video.i_height)
p_sys->p_context->coded_height = p_dec->fmt_in.video.i_height;
p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.video.i_bits_per_pixel;
}
else if( p_dec->fmt_in.i_cat == AUDIO_ES )
{
p_sys->p_context->sample_rate = p_dec->fmt_in.audio.i_rate;
p_sys->p_context->channels = p_dec->fmt_in.audio.i_channels;
p_sys->p_context->block_align = p_dec->fmt_in.audio.i_blockalign;
p_sys->p_context->bit_rate = p_dec->fmt_in.i_bitrate;
p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.audio.i_bitspersample;
if( p_sys->i_codec_id == AV_CODEC_ID_ADPCM_G726 &&
p_sys->p_context->bit_rate > 0 &&
p_sys->p_context->sample_rate > 0)
p_sys->p_context->bits_per_coded_sample = p_sys->p_context->bit_rate /
p_sys->p_context->sample_rate;
}
int ret;
char *psz_opts = var_InheritString( p_dec, "avcodec-options" );
AVDictionary *options = NULL;
if (psz_opts && *psz_opts)
options = vlc_av_get_options(psz_opts);
free(psz_opts);
vlc_avcodec_lock();
ret = avcodec_open2( p_sys->p_context, p_sys->p_codec, options ? &options : NULL );
vlc_avcodec_unlock();
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
msg_Err( p_dec, "Unknown option \"%s\"", t->key );
}
av_dict_free(&options);
if( ret < 0 )
return VLC_EGENERIC;
msg_Dbg( p_dec, "avcodec codec (%s) started", p_sys->psz_namecodec );
#ifdef HAVE_AVCODEC_MT
if( p_dec->fmt_in.i_cat == VIDEO_ES )
{
switch( p_sys->p_context->active_thread_type )
{
case FF_THREAD_FRAME:
msg_Dbg( p_dec, "using frame thread mode with %d threads",
p_sys->p_context->thread_count );
break;
case FF_THREAD_SLICE:
msg_Dbg( p_dec, "using slice thread mode with %d threads",
p_sys->p_context->thread_count );
break;
case 0:
if( p_sys->p_context->thread_count > 1 )
msg_Warn( p_dec, "failed to enable threaded decoding" );
break;
default:
msg_Warn( p_dec, "using unknown thread mode with %d threads",
p_sys->p_context->thread_count );
break;
}
}
#endif
p_sys->b_delayed_open = false;
return VLC_SUCCESS;
}
/*****************************************************************************
* ffmpeg_OpenCodec:
*****************************************************************************/
int ffmpeg_OpenCodec( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( p_sys->p_context->extradata_size <= 0 )
{
if( p_sys->i_codec_id == CODEC_ID_VC1 ||
p_sys->i_codec_id == CODEC_ID_VORBIS ||
p_sys->i_codec_id == CODEC_ID_THEORA ||
p_sys->i_codec_id == CODEC_ID_AAC )
{
msg_Warn( p_dec, "waiting for extra data for codec %s",
p_sys->psz_namecodec );
return 1;
}
}
if( p_dec->fmt_in.i_cat == VIDEO_ES )
{
p_sys->p_context->width = p_dec->fmt_in.video.i_width;
p_sys->p_context->height = p_dec->fmt_in.video.i_height;
p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.video.i_bits_per_pixel;
}
else if( p_dec->fmt_in.i_cat == AUDIO_ES )
{
p_sys->p_context->sample_rate = p_dec->fmt_in.audio.i_rate;
p_sys->p_context->channels = p_dec->fmt_in.audio.i_channels;
p_sys->p_context->block_align = p_dec->fmt_in.audio.i_blockalign;
p_sys->p_context->bit_rate = p_dec->fmt_in.i_bitrate;
p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.audio.i_bitspersample;
}
int ret;
vlc_avcodec_lock();
ret = avcodec_open( p_sys->p_context, p_sys->p_codec );
vlc_avcodec_unlock();
if( ret < 0 )
return VLC_EGENERIC;
msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
#ifdef HAVE_AVCODEC_MT
if( p_dec->fmt_in.i_cat == VIDEO_ES )
{
switch( p_sys->p_context->active_thread_type )
{
case FF_THREAD_FRAME:
msg_Dbg( p_dec, "using frame thread mode with %d threads",
p_sys->p_context->thread_count );
break;
case FF_THREAD_SLICE:
msg_Dbg( p_dec, "using slice thread mode with %d threads",
p_sys->p_context->thread_count );
break;
case 0:
if( p_sys->p_context->thread_count > 1 )
msg_Warn( p_dec, "failed to enable threaded decoding" );
break;
default:
msg_Warn( p_dec, "using unknown thread mode with %d threads",
p_sys->p_context->thread_count );
break;
}
}
#endif
p_sys->b_delayed_open = false;
return VLC_SUCCESS;
}
/*****************************************************************************
* VideoCommand: Create/Delete a video encoder
*****************************************************************************/
static mtime_t VideoCommand( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
if ( p_sys->i_cmd == 0 && !(id->p_queued->i_flags & BLOCK_FLAG_TYPE_I) )
{
mtime_t i_dts = id->p_queued->i_dts;
block_t *p_block = id->p_queued->p_next;
while ( p_block != NULL )
{
if ( p_block->i_flags & BLOCK_FLAG_TYPE_I )
return i_dts;
i_dts = p_block->i_dts;
p_block = p_block->p_next;
}
return 0;
}
p_sys->i_old_cmd = p_sys->i_cmd;
if ( id->ff_enc )
{
vlc_avcodec_lock();
avcodec_close( id->ff_enc_c );
vlc_avcodec_unlock();
av_free( id->ff_enc_c );
av_free( id->p_frame );
free( id->p_buffer_out );
id->ff_enc = NULL;
}
if ( p_sys->i_cmd > 0 )
{
/* Create a new encoder. */
int i_ff_codec = CODEC_ID_MPEG2VIDEO;
int i_aspect_num, i_aspect_den;
if( i_ff_codec == 0 )
{
msg_Err( p_stream, "cannot find encoder" );
return 0;
}
id->ff_enc = avcodec_find_encoder( i_ff_codec );
if( !id->ff_enc )
{
msg_Err( p_stream, "cannot find encoder (avcodec)" );
return 0;
}
id->ff_enc_c = avcodec_alloc_context();
/* Set CPU capabilities */
unsigned i_cpu = vlc_CPU();
id->ff_enc_c->dsp_mask = 0;
if( !(i_cpu & CPU_CAPABILITY_MMX) )
{
id->ff_enc_c->dsp_mask |= FF_MM_MMX;
}
if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
{
id->ff_enc_c->dsp_mask |= FF_MM_MMXEXT;
}
if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
{
id->ff_enc_c->dsp_mask |= FF_MM_3DNOW;
}
if( !(i_cpu & CPU_CAPABILITY_SSE) )
{
id->ff_enc_c->dsp_mask |= FF_MM_SSE;
id->ff_enc_c->dsp_mask |= FF_MM_SSE2;
}
id->ff_enc_c->width = p_sys->p_pictures[p_sys->i_cmd-1].format.i_width;
id->ff_enc_c->height = p_sys->p_pictures[p_sys->i_cmd-1].format.i_height;
av_reduce( &i_aspect_num, &i_aspect_den,
p_sys->i_aspect,
VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
av_reduce( &id->ff_enc_c->sample_aspect_ratio.num,
&id->ff_enc_c->sample_aspect_ratio.den,
i_aspect_num * (int64_t)id->ff_enc_c->height,
i_aspect_den * (int64_t)id->ff_enc_c->width, 1 << 30 );
#if LIBAVCODEC_BUILD >= 4754
id->ff_enc_c->time_base.num = 1;
id->ff_enc_c->time_base.den = 25; /* FIXME */
#else
id->ff_enc_c->frame_rate = 25; /* FIXME */
id->ff_enc_c->frame_rate_base = 1;
#endif
id->ff_enc_c->gop_size = 200;
id->ff_enc_c->max_b_frames = 0;
id->ff_enc_c->flags |= CODEC_FLAG_QSCALE
| CODEC_FLAG_INPUT_PRESERVED
| CODEC_FLAG_LOW_DELAY;
id->ff_enc_c->mb_decision = FF_MB_DECISION_SIMPLE;
id->ff_enc_c->pix_fmt = PIX_FMT_YUV420P;
avcodec_lock();
if( avcodec_open( id->ff_enc_c, id->ff_enc ) )
{
avcodec_unlock();
msg_Err( p_stream, "cannot open encoder" );
return 0;
}
avcodec_unlock();
id->p_buffer_out = malloc( id->ff_enc_c->width * id->ff_enc_c->height * 3 );
id->p_frame = avcodec_alloc_frame();
id->p_frame->linesize[0] = p_sys->p_pictures[p_sys->i_cmd-1].p[0].i_pitch;
id->p_frame->linesize[1] = p_sys->p_pictures[p_sys->i_cmd-1].p[1].i_pitch;
id->p_frame->linesize[2] = p_sys->p_pictures[p_sys->i_cmd-1].p[2].i_pitch;
id->p_frame->data[0] = p_sys->p_pictures[p_sys->i_cmd-1].p[0].p_pixels;
id->p_frame->data[1] = p_sys->p_pictures[p_sys->i_cmd-1].p[1].p_pixels;
id->p_frame->data[2] = p_sys->p_pictures[p_sys->i_cmd-1].p[2].p_pixels;
id->i_nb_pred = p_sys->i_gop;
}
return 0;
}
/*****************************************************************************
* Add: Add an input elementary stream
*****************************************************************************/
static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
sout_stream_id_t *id;
id = calloc( 1, sizeof( sout_stream_id_t ) );
if( !id )
return NULL;
if( p_fmt->i_cat == VIDEO_ES &&
( p_fmt->i_codec == VLC_CODEC_MPGV ||
p_fmt->i_codec == VLC_FOURCC('f', 'a', 'k', 'e') ) )
{
id->b_switcher_video = true;
p_fmt->i_codec = VLC_CODEC_MPGV;
msg_Dbg( p_stream, "creating video switcher for fcc=`%4.4s' cmd:%d",
(char*)&p_fmt->i_codec, p_sys->i_cmd );
}
else if ( p_fmt->i_cat == AUDIO_ES &&
p_fmt->i_codec == VLC_CODEC_MPGA &&
p_sys->b_audio )
{
int i_ff_codec = CODEC_ID_MP2;
int i;
id->b_switcher_audio = true;
msg_Dbg( p_stream, "creating audio switcher for fcc=`%4.4s' cmd:%d",
(char*)&p_fmt->i_codec, p_sys->i_cmd );
/* Allocate the encoder right now. */
if( i_ff_codec == 0 )
{
msg_Err( p_stream, "cannot find encoder" );
free( id );
return NULL;
}
id->ff_enc = avcodec_find_encoder( i_ff_codec );
if( !id->ff_enc )
{
msg_Err( p_stream, "cannot find encoder (avcodec)" );
free( id );
return NULL;
}
id->ff_enc_c = avcodec_alloc_context();
/* Set CPU capabilities */
unsigned i_cpu = vlc_CPU();
id->ff_enc_c->dsp_mask = 0;
if( !(i_cpu & CPU_CAPABILITY_MMX) )
{
id->ff_enc_c->dsp_mask |= FF_MM_MMX;
}
if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
{
id->ff_enc_c->dsp_mask |= FF_MM_MMXEXT;
}
if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
{
id->ff_enc_c->dsp_mask |= FF_MM_3DNOW;
}
if( !(i_cpu & CPU_CAPABILITY_SSE) )
{
id->ff_enc_c->dsp_mask |= FF_MM_SSE;
id->ff_enc_c->dsp_mask |= FF_MM_SSE2;
}
id->ff_enc_c->sample_rate = p_fmt->audio.i_rate;
id->ff_enc_c->channels = p_fmt->audio.i_channels;
id->ff_enc_c->bit_rate = p_fmt->i_bitrate;
vlc_avcodec_lock();
if( avcodec_open( id->ff_enc_c, id->ff_enc ) )
{
avcodec_unlock();
msg_Err( p_stream, "cannot open encoder" );
av_free( id->ff_enc_c );
free( id );
return NULL;
}
avcodec_unlock();
id->p_buffer_out = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE * 2 );
id->p_samples = calloc( id->ff_enc_c->frame_size * p_fmt->audio.i_channels,
sizeof(int16_t) );
if( !id->p_buffer_out || !id->p_samples )
goto error;
for( i = 0; i < MAX_AUDIO; i++ )
{
if( p_sys->pp_audio_ids[i] == NULL )
{
p_sys->pp_audio_ids[i] = id;
break;
}
}
if( i == MAX_AUDIO )
{
msg_Err( p_stream, "too many audio streams!" );
goto error;
}
}
else
{
msg_Dbg( p_stream, "do not know what to do when switching (fcc=`%4.4s')",
(char*)&p_fmt->i_codec );
}
/* src format */
memcpy( &id->f_src, p_fmt, sizeof( es_format_t ) );
/* open output stream */
id->id = p_sys->p_out->pf_add( p_sys->p_out, p_fmt );
if( id->id != NULL )
return id;
error:
vlc_avcodec_lock();
avcodec_close( id->ff_enc_c );
vlc_avcodec_unlock();
free( id->p_samples );
free( id->p_buffer_out );
av_free( id->ff_enc_c );
free( id );
return NULL;
}
int avformat_OpenDemux( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
AVInputFormat *fmt = NULL;
vlc_tick_t i_start_time = VLC_TICK_INVALID;
bool b_can_seek;
const char *psz_url;
int error;
if( p_demux->psz_filepath )
psz_url = p_demux->psz_filepath;
else
psz_url = p_demux->psz_url;
if( avformat_ProbeDemux( p_this, &fmt, psz_url ) != VLC_SUCCESS )
return VLC_EGENERIC;
vlc_stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_can_seek );
/* Fill p_demux fields */
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
p_sys->ic = 0;
p_sys->fmt = fmt;
p_sys->tracks = NULL;
p_sys->i_ssa_order = 0;
TAB_INIT( p_sys->i_attachments, p_sys->attachments);
p_sys->p_title = NULL;
p_sys->i_seekpoint = 0;
p_sys->i_update = 0;
/* Create I/O wrapper */
unsigned char * p_io_buffer = av_malloc( AVFORMAT_IOBUFFER_SIZE );
if( !p_io_buffer )
{
avformat_CloseDemux( p_this );
return VLC_ENOMEM;
}
p_sys->ic = avformat_alloc_context();
if( !p_sys->ic )
{
av_free( p_io_buffer );
avformat_CloseDemux( p_this );
return VLC_ENOMEM;
}
AVIOContext *pb = p_sys->ic->pb = avio_alloc_context( p_io_buffer,
AVFORMAT_IOBUFFER_SIZE, 0, p_demux, IORead, NULL, IOSeek );
if( !pb )
{
av_free( p_io_buffer );
avformat_CloseDemux( p_this );
return VLC_ENOMEM;
}
p_sys->ic->pb->seekable = b_can_seek ? AVIO_SEEKABLE_NORMAL : 0;
error = avformat_open_input(&p_sys->ic, psz_url, p_sys->fmt, NULL);
if( error < 0 )
{
msg_Err( p_demux, "Could not open %s: %s", psz_url,
vlc_strerror_c(AVUNERROR(error)) );
av_free( pb->buffer );
av_free( pb );
p_sys->ic = NULL;
avformat_CloseDemux( p_this );
return VLC_EGENERIC;
}
char *psz_opts = var_InheritString( p_demux, "avformat-options" );
unsigned nb_streams = p_sys->ic->nb_streams;
AVDictionary *options[nb_streams ? nb_streams : 1];
options[0] = NULL;
for (unsigned i = 1; i < nb_streams; i++)
options[i] = NULL;
if (psz_opts) {
vlc_av_get_options(psz_opts, &options[0]);
for (unsigned i = 1; i < nb_streams; i++) {
av_dict_copy(&options[i], options[0], 0);
}
free(psz_opts);
}
vlc_avcodec_lock(); /* avformat calls avcodec behind our back!!! */
error = avformat_find_stream_info( p_sys->ic, options );
vlc_avcodec_unlock();
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options[0], "", t, AV_DICT_IGNORE_SUFFIX))) {
msg_Err( p_demux, "Unknown option \"%s\"", t->key );
}
av_dict_free(&options[0]);
for (unsigned i = 1; i < nb_streams; i++) {
av_dict_free(&options[i]);
}
nb_streams = p_sys->ic->nb_streams; /* it may have changed */
if( !nb_streams )
{
msg_Err( p_demux, "No streams found");
avformat_CloseDemux( p_this );
return VLC_EGENERIC;
}
p_sys->tracks = calloc( nb_streams, sizeof(*p_sys->tracks) );
if( !p_sys->tracks )
{
avformat_CloseDemux( p_this );
return VLC_ENOMEM;
}
p_sys->i_tracks = nb_streams;
if( error < 0 )
{
msg_Warn( p_demux, "Could not find stream info: %s",
vlc_strerror_c(AVUNERROR(error)) );
}
for( unsigned i = 0; i < nb_streams; i++ )
{
struct avformat_track_s *p_track = &p_sys->tracks[i];
AVStream *s = p_sys->ic->streams[i];
const AVCodecParameters *cp = s->codecpar;
es_format_t es_fmt;
const char *psz_type = "unknown";
/* Do not use the cover art as a stream */
if( s->disposition == AV_DISPOSITION_ATTACHED_PIC )
continue;
vlc_fourcc_t fcc = GetVlcFourcc( cp->codec_id );
switch( cp->codec_type )
{
case AVMEDIA_TYPE_AUDIO:
es_format_Init( &es_fmt, AUDIO_ES, fcc );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
es_fmt.i_bitrate = cp->bit_rate;
es_fmt.audio.i_channels = cp->channels;
es_fmt.audio.i_rate = cp->sample_rate;
es_fmt.audio.i_bitspersample = cp->bits_per_coded_sample;
es_fmt.audio.i_blockalign = cp->block_align;
psz_type = "audio";
if(cp->codec_id == AV_CODEC_ID_AAC_LATM)
{
es_fmt.i_original_fourcc = VLC_FOURCC('L','A','T','M');
es_fmt.b_packetized = false;
}
else if(cp->codec_id == AV_CODEC_ID_AAC && p_sys->fmt->long_name &&
strstr(p_sys->fmt->long_name, "raw ADTS AAC"))
{
es_fmt.i_original_fourcc = VLC_FOURCC('A','D','T','S');
es_fmt.b_packetized = false;
}
break;
case AVMEDIA_TYPE_VIDEO:
es_format_Init( &es_fmt, VIDEO_ES, fcc );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
es_fmt.video.i_bits_per_pixel = cp->bits_per_coded_sample;
/* Special case for raw video data */
if( cp->codec_id == AV_CODEC_ID_RAWVIDEO )
{
msg_Dbg( p_demux, "raw video, pixel format: %i", cp->format );
if( GetVlcChroma( &es_fmt.video, cp->format ) != VLC_SUCCESS)
{
msg_Err( p_demux, "was unable to find a FourCC match for raw video" );
}
else
es_fmt.i_codec = es_fmt.video.i_chroma;
}
/* We need this for the h264 packetizer */
else if( cp->codec_id == AV_CODEC_ID_H264 && ( p_sys->fmt == av_find_input_format("flv") ||
p_sys->fmt == av_find_input_format("matroska") || p_sys->fmt == av_find_input_format("mp4") ) )
es_fmt.i_original_fourcc = VLC_FOURCC( 'a', 'v', 'c', '1' );
es_fmt.video.i_width = cp->width;
es_fmt.video.i_height = cp->height;
es_fmt.video.i_visible_width = es_fmt.video.i_width;
es_fmt.video.i_visible_height = es_fmt.video.i_height;
get_rotation(&es_fmt, s);
# warning FIXME: implement palette transmission
psz_type = "video";
AVRational rate;
#if (LIBAVUTIL_VERSION_MICRO < 100) /* libav */
# if (LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(55, 20, 0))
rate.num = s->time_base.num;
rate.den = s->time_base.den;
# else
rate.num = s->codec->time_base.num;
rate.den = s->codec->time_base.den;
# endif
rate.den *= __MAX( s->codec->ticks_per_frame, 1 );
#else /* ffmpeg */
rate = av_guess_frame_rate( p_sys->ic, s, NULL );
#endif
if( rate.den && rate.num )
{
es_fmt.video.i_frame_rate = rate.num;
es_fmt.video.i_frame_rate_base = rate.den;
}
AVRational ar;
#if (LIBAVUTIL_VERSION_MICRO < 100) /* libav */
ar.num = s->sample_aspect_ratio.num;
ar.den = s->sample_aspect_ratio.den;
#else
ar = av_guess_sample_aspect_ratio( p_sys->ic, s, NULL );
#endif
if( ar.num && ar.den )
{
es_fmt.video.i_sar_den = ar.den;
es_fmt.video.i_sar_num = ar.num;
}
break;
case AVMEDIA_TYPE_SUBTITLE:
es_format_Init( &es_fmt, SPU_ES, fcc );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
if( strncmp( p_sys->ic->iformat->name, "matroska", 8 ) == 0 &&
cp->codec_id == AV_CODEC_ID_DVD_SUBTITLE &&
cp->extradata != NULL &&
cp->extradata_size > 0 )
{
char *psz_start;
char *psz_buf = malloc( cp->extradata_size + 1);
if( psz_buf != NULL )
{
memcpy( psz_buf, cp->extradata , cp->extradata_size );
psz_buf[cp->extradata_size] = '\0';
psz_start = strstr( psz_buf, "size:" );
if( psz_start &&
vobsub_size_parse( psz_start,
&es_fmt.subs.spu.i_original_frame_width,
&es_fmt.subs.spu.i_original_frame_height ) == VLC_SUCCESS )
{
msg_Dbg( p_demux, "original frame size: %dx%d",
es_fmt.subs.spu.i_original_frame_width,
es_fmt.subs.spu.i_original_frame_height );
}
else
{
msg_Warn( p_demux, "reading original frame size failed" );
}
psz_start = strstr( psz_buf, "palette:" );
if( psz_start &&
vobsub_palette_parse( psz_start, &es_fmt.subs.spu.palette[1] ) == VLC_SUCCESS )
{
es_fmt.subs.spu.palette[0] = SPU_PALETTE_DEFINED;
msg_Dbg( p_demux, "vobsub palette read" );
}
else
{
msg_Warn( p_demux, "reading original palette failed" );
}
free( psz_buf );
}
}
else if( cp->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
cp->extradata_size > 3 )
{
es_fmt.subs.dvb.i_id = GetWBE( cp->extradata ) |
(GetWBE( cp->extradata + 2 ) << 16);
}
else if( cp->codec_id == AV_CODEC_ID_MOV_TEXT )
{
if( cp->extradata_size && (es_fmt.p_extra = malloc(cp->extradata_size)) )
{
memcpy( es_fmt.p_extra, cp->extradata, cp->extradata_size );
es_fmt.i_extra = cp->extradata_size;
}
}
psz_type = "subtitle";
break;
default:
es_format_Init( &es_fmt, UNKNOWN_ES, 0 );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
#ifdef HAVE_AVUTIL_CODEC_ATTACHMENT
if( cp->codec_type == AVMEDIA_TYPE_ATTACHMENT )
{
input_attachment_t *p_attachment;
psz_type = "attachment";
if( cp->codec_id == AV_CODEC_ID_TTF )
{
AVDictionaryEntry *filename = av_dict_get( s->metadata, "filename", NULL, 0 );
if( filename && filename->value )
{
p_attachment = vlc_input_attachment_New(
filename->value, "application/x-truetype-font",
NULL, cp->extradata, (int)cp->extradata_size );
if( p_attachment )
TAB_APPEND( p_sys->i_attachments, p_sys->attachments,
p_attachment );
}
}
else msg_Warn( p_demux, "unsupported attachment type (%u) in avformat demux", cp->codec_id );
}
else
#endif
{
if( cp->codec_type == AVMEDIA_TYPE_DATA )
psz_type = "data";
msg_Warn( p_demux, "unsupported track type (%u:%u) in avformat demux", cp->codec_type, cp->codec_id );
}
break;
}
AVDictionaryEntry *language = av_dict_get( s->metadata, "language", NULL, 0 );
if ( language && language->value )
es_fmt.psz_language = strdup( language->value );
if( s->disposition & AV_DISPOSITION_DEFAULT )
es_fmt.i_priority = ES_PRIORITY_SELECTABLE_MIN + 1000;
#ifdef HAVE_AVUTIL_CODEC_ATTACHMENT
if( cp->codec_type != AVMEDIA_TYPE_ATTACHMENT )
#endif
if( cp->codec_type != AVMEDIA_TYPE_DATA )
{
const bool b_ogg = !strcmp( p_sys->fmt->name, "ogg" );
const uint8_t *p_extra = cp->extradata;
unsigned i_extra = cp->extradata_size;
if( cp->codec_id == AV_CODEC_ID_THEORA && b_ogg )
{
unsigned pi_size[3];
const void *pp_data[3];
unsigned i_count;
for( i_count = 0; i_count < 3; i_count++ )
{
if( i_extra < 2 )
break;
pi_size[i_count] = GetWBE( p_extra );
pp_data[i_count] = &p_extra[2];
if( i_extra < pi_size[i_count] + 2 )
break;
p_extra += 2 + pi_size[i_count];
i_extra -= 2 + pi_size[i_count];
}
if( i_count > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra,
pi_size, pp_data, i_count ) )
{
es_fmt.i_extra = 0;
es_fmt.p_extra = NULL;
}
}
else if( cp->codec_id == AV_CODEC_ID_SPEEX && b_ogg )
{
const uint8_t p_dummy_comment[] = {
0, 0, 0, 0,
0, 0, 0, 0,
};
unsigned pi_size[2];
const void *pp_data[2];
pi_size[0] = i_extra;
pp_data[0] = p_extra;
pi_size[1] = sizeof(p_dummy_comment);
pp_data[1] = p_dummy_comment;
if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra,
pi_size, pp_data, 2 ) )
{
es_fmt.i_extra = 0;
es_fmt.p_extra = NULL;
}
}
else if( cp->codec_id == AV_CODEC_ID_OPUS )
{
const uint8_t p_dummy_comment[] = {
'O', 'p', 'u', 's',
'T', 'a', 'g', 's',
0, 0, 0, 0, /* Vendor String length */
/* Vendor String */
0, 0, 0, 0, /* User Comment List Length */
};
unsigned pi_size[2];
const void *pp_data[2];
pi_size[0] = i_extra;
pp_data[0] = p_extra;
pi_size[1] = sizeof(p_dummy_comment);
pp_data[1] = p_dummy_comment;
if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra,
pi_size, pp_data, 2 ) )
{
es_fmt.i_extra = 0;
es_fmt.p_extra = NULL;
}
}
else if( cp->extradata_size > 0 && !es_fmt.i_extra )
{
es_fmt.p_extra = malloc( i_extra );
if( es_fmt.p_extra )
{
es_fmt.i_extra = i_extra;
memcpy( es_fmt.p_extra, p_extra, i_extra );
}
}
p_track->p_es = es_out_Add( p_demux->out, &es_fmt );
if( p_track->p_es && (s->disposition & AV_DISPOSITION_DEFAULT) )
es_out_Control( p_demux->out, ES_OUT_SET_ES_DEFAULT, p_track->p_es );
msg_Dbg( p_demux, "adding es: %s codec = %4.4s (%d)",
psz_type, (char*)&fcc, cp->codec_id );
}
es_format_Clean( &es_fmt );
}
if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
i_start_time = FROM_AV_TS(p_sys->ic->start_time);
msg_Dbg( p_demux, "AVFormat(%s %s) supported stream", AVPROVIDER(LIBAVFORMAT), LIBAVFORMAT_IDENT );
msg_Dbg( p_demux, " - format = %s (%s)",
p_sys->fmt->name, p_sys->fmt->long_name );
msg_Dbg( p_demux, " - start time = %"PRId64, i_start_time );
msg_Dbg( p_demux, " - duration = %"PRId64,
( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE ) ?
FROM_AV_TS(p_sys->ic->duration) : -1 );
if( p_sys->ic->nb_chapters > 0 )
{
p_sys->p_title = vlc_input_title_New();
p_sys->p_title->i_length = FROM_AV_TS(p_sys->ic->duration);
}
for( unsigned i = 0; i < p_sys->ic->nb_chapters; i++ )
{
seekpoint_t *s = vlc_seekpoint_New();
AVDictionaryEntry *title = av_dict_get( p_sys->ic->metadata, "title", NULL, 0);
if( title && title->value )
{
s->psz_name = strdup( title->value );
EnsureUTF8( s->psz_name );
msg_Dbg( p_demux, " - chapter %d: %s", i, s->psz_name );
}
s->i_time_offset = vlc_tick_from_samples( p_sys->ic->chapters[i]->start *
p_sys->ic->chapters[i]->time_base.num,
p_sys->ic->chapters[i]->time_base.den ) -
(i_start_time != VLC_TICK_INVALID ? i_start_time : 0 );
TAB_APPEND( p_sys->p_title->i_seekpoint, p_sys->p_title->seekpoint, s );
}
ResetTime( p_demux, 0 );
return VLC_SUCCESS;
}
/*****************************************************************************
* InitAudioDec: initialize audio decoder
*****************************************************************************
* The ffmpeg codec will be opened, some memory allocated.
*****************************************************************************/
int InitAudioDec( decoder_t *p_dec, AVCodecContext *p_context,
AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
{
decoder_sys_t *p_sys;
/* Allocate the memory needed to store the decoder's structure */
if( ( p_dec->p_sys = p_sys = malloc(sizeof(*p_sys)) ) == NULL )
{
return VLC_ENOMEM;
}
p_codec->type = CODEC_TYPE_AUDIO;
p_context->codec_type = CODEC_TYPE_AUDIO;
p_context->codec_id = i_codec_id;
p_sys->p_context = p_context;
p_sys->p_codec = p_codec;
p_sys->i_codec_id = i_codec_id;
p_sys->psz_namecodec = psz_namecodec;
p_sys->b_delayed_open = false;
/* ***** Fill p_context with init values ***** */
p_sys->p_context->sample_rate = p_dec->fmt_in.audio.i_rate;
p_sys->p_context->channels = p_dec->fmt_in.audio.i_channels;
p_sys->p_context->block_align = p_dec->fmt_in.audio.i_blockalign;
p_sys->p_context->bit_rate = p_dec->fmt_in.i_bitrate;
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT( 52, 0, 0 )
p_sys->p_context->bits_per_sample = p_dec->fmt_in.audio.i_bitspersample;
#else
p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.audio.i_bitspersample;
#endif
if( p_dec->fmt_in.i_extra > 0 )
{
const uint8_t * const p_src = p_dec->fmt_in.p_extra;
int i_offset;
int i_size;
if( p_dec->fmt_in.i_codec == VLC_CODEC_FLAC )
{
i_offset = 8;
i_size = p_dec->fmt_in.i_extra - 8;
}
else if( p_dec->fmt_in.i_codec == VLC_CODEC_ALAC )
{
static const uint8_t p_pattern[] = { 0, 0, 0, 36, 'a', 'l', 'a', 'c' };
/* Find alac atom XXX it is a bit ugly */
for( i_offset = 0; i_offset < p_dec->fmt_in.i_extra - sizeof(p_pattern); i_offset++ )
{
if( !memcmp( &p_src[i_offset], p_pattern, sizeof(p_pattern) ) )
break;
}
i_size = __MIN( p_dec->fmt_in.i_extra - i_offset, 36 );
if( i_size < 36 )
i_size = 0;
}
else
{
i_offset = 0;
i_size = p_dec->fmt_in.i_extra;
}
if( i_size > 0 )
{
p_sys->p_context->extradata =
malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE );
if( p_sys->p_context->extradata )
{
uint8_t *p_dst = p_sys->p_context->extradata;
p_sys->p_context->extradata_size = i_size;
memcpy( &p_dst[0], &p_src[i_offset], i_size );
memset( &p_dst[i_size], 0, FF_INPUT_BUFFER_PADDING_SIZE );
}
}
}
else
{
p_sys->p_context->extradata_size = 0;
p_sys->p_context->extradata = NULL;
}
/* ***** Open the codec ***** */
int ret;
vlc_avcodec_lock();
ret = avcodec_open( p_sys->p_context, p_sys->p_codec );
vlc_avcodec_unlock();
if( ret < 0 )
{
msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
free( p_sys->p_context->extradata );
free( p_sys );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
switch( i_codec_id )
{
case CODEC_ID_WAVPACK:
p_sys->i_output_max = 8 * sizeof(int32_t) * 131072;
break;
case CODEC_ID_TTA:
p_sys->i_output_max = p_sys->p_context->channels * sizeof(int32_t) * p_sys->p_context->sample_rate * 2;
break;
case CODEC_ID_FLAC:
p_sys->i_output_max = 8 * sizeof(int32_t) * 65535;
break;
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT( 52, 35, 0 )
case CODEC_ID_WMAPRO:
p_sys->i_output_max = 8 * sizeof(float) * 6144; /* (1 << 12) * 3/2 */
break;
#endif
default:
p_sys->i_output_max = 0;
break;
}
if( p_sys->i_output_max < AVCODEC_MAX_AUDIO_FRAME_SIZE )
p_sys->i_output_max = AVCODEC_MAX_AUDIO_FRAME_SIZE;
msg_Dbg( p_dec, "Using %d bytes output buffer", p_sys->i_output_max );
p_sys->p_output = av_malloc( p_sys->i_output_max );
p_sys->p_samples = NULL;
p_sys->i_samples = 0;
p_sys->i_reject_count = 0;
p_sys->b_extract = false;
p_sys->i_previous_channels = 0;
p_sys->i_previous_layout = 0;
date_Set( &p_sys->end_date, 0 );
if( p_dec->fmt_in.audio.i_rate )
date_Init( &p_sys->end_date, p_dec->fmt_in.audio.i_rate, 1 );
/* */
p_dec->fmt_out.i_cat = AUDIO_ES;
/* Try to set as much informations as possible but do not trust it */
SetupOutputFormat( p_dec, false );
return VLC_SUCCESS;
}
int OpenDemux( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
AVProbeData pd = { };
AVInputFormat *fmt = NULL;
int64_t i_start_time = -1;
bool b_can_seek;
char *psz_url;
const uint8_t *peek;
int error;
/* Init Probe data */
pd.buf_size = vlc_stream_Peek( p_demux->s, &peek, 2048 + 213 );
if( pd.buf_size <= 0 )
{
msg_Warn( p_demux, "cannot peek" );
return VLC_EGENERIC;
}
pd.buf = malloc( pd.buf_size + AVPROBE_PADDING_SIZE );
if( unlikely(pd.buf == NULL) )
return VLC_ENOMEM;
memcpy( pd.buf, peek, pd.buf_size );
memset( pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE );
if( p_demux->psz_file )
psz_url = strdup( p_demux->psz_file );
else
{
if( asprintf( &psz_url, "%s://%s", p_demux->psz_access,
p_demux->psz_location ) == -1)
psz_url = NULL;
}
if( psz_url != NULL )
msg_Dbg( p_demux, "trying url: %s", psz_url );
pd.filename = psz_url;
vlc_stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_can_seek );
vlc_init_avformat(p_this);
/* Guess format */
char *psz_format = var_InheritString( p_this, "avformat-format" );
if( psz_format )
{
if( (fmt = av_find_input_format(psz_format)) )
msg_Dbg( p_demux, "forcing format: %s", fmt->name );
free( psz_format );
}
if( fmt == NULL )
fmt = av_probe_input_format( &pd, 1 );
free( pd.buf );
if( fmt == NULL )
{
msg_Dbg( p_demux, "couldn't guess format" );
free( psz_url );
return VLC_EGENERIC;
}
if( !p_demux->obj.force )
{
static const char ppsz_blacklist[][16] = {
/* Don't handle MPEG unless forced */
"mpeg", "vcd", "vob", "mpegts",
/* libavformat's redirector won't work */
"redir", "sdp",
/* Don't handle subtitles format */
"ass", "srt", "microdvd",
/* No timestamps at all */
"hevc", "h264",
""
};
for( int i = 0; *ppsz_blacklist[i]; i++ )
{
if( !strcmp( fmt->name, ppsz_blacklist[i] ) )
{
free( psz_url );
return VLC_EGENERIC;
}
}
}
/* Don't trigger false alarms on bin files */
if( !p_demux->obj.force && !strcmp( fmt->name, "psxstr" ) )
{
int i_len;
if( !p_demux->psz_file )
{
free( psz_url );
return VLC_EGENERIC;
}
i_len = strlen( p_demux->psz_file );
if( i_len < 4 )
{
free( psz_url );
return VLC_EGENERIC;
}
if( strcasecmp( &p_demux->psz_file[i_len - 4], ".str" ) &&
strcasecmp( &p_demux->psz_file[i_len - 4], ".xai" ) &&
strcasecmp( &p_demux->psz_file[i_len - 3], ".xa" ) )
{
free( psz_url );
return VLC_EGENERIC;
}
}
msg_Dbg( p_demux, "detected format: %s", fmt->name );
/* Fill p_demux fields */
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
p_demux->p_sys = p_sys = xmalloc( sizeof( demux_sys_t ) );
p_sys->ic = 0;
p_sys->fmt = fmt;
p_sys->i_tk = 0;
p_sys->tk = NULL;
p_sys->tk_pcr = NULL;
p_sys->i_ssa_order = 0;
TAB_INIT( p_sys->i_attachments, p_sys->attachments);
p_sys->p_title = NULL;
/* Create I/O wrapper */
unsigned char * p_io_buffer = av_malloc( AVFORMAT_IOBUFFER_SIZE );
if( !p_io_buffer )
{
free( psz_url );
CloseDemux( p_this );
return VLC_ENOMEM;
}
p_sys->ic = avformat_alloc_context();
if( !p_sys->ic )
{
av_free( p_io_buffer );
free( psz_url );
CloseDemux( p_this );
return VLC_ENOMEM;
}
AVIOContext *pb = p_sys->ic->pb = avio_alloc_context( p_io_buffer,
AVFORMAT_IOBUFFER_SIZE, 0, p_demux, IORead, NULL, IOSeek );
if( !pb )
{
av_free( p_io_buffer );
free( psz_url );
CloseDemux( p_this );
return VLC_ENOMEM;
}
p_sys->ic->pb->seekable = b_can_seek ? AVIO_SEEKABLE_NORMAL : 0;
error = avformat_open_input(&p_sys->ic, psz_url, p_sys->fmt, NULL);
if( error < 0 )
{
msg_Err( p_demux, "Could not open %s: %s", psz_url,
vlc_strerror_c(AVUNERROR(error)) );
av_free( p_io_buffer );
av_free( pb );
p_sys->ic = NULL;
free( psz_url );
CloseDemux( p_this );
return VLC_EGENERIC;
}
free( psz_url );
char *psz_opts = var_InheritString( p_demux, "avformat-options" );
AVDictionary *options[p_sys->ic->nb_streams ? p_sys->ic->nb_streams : 1];
options[0] = NULL;
unsigned int nb_streams = p_sys->ic->nb_streams;
for (unsigned i = 1; i < nb_streams; i++)
options[i] = NULL;
if (psz_opts) {
vlc_av_get_options(psz_opts, &options[0]);
for (unsigned i = 1; i < nb_streams; i++) {
av_dict_copy(&options[i], options[0], 0);
}
free(psz_opts);
}
vlc_avcodec_lock(); /* avformat calls avcodec behind our back!!! */
error = avformat_find_stream_info( p_sys->ic, options );
/* FIXME: what if nb_streams change after that call? */
vlc_avcodec_unlock();
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options[0], "", t, AV_DICT_IGNORE_SUFFIX))) {
msg_Err( p_demux, "Unknown option \"%s\"", t->key );
}
av_dict_free(&options[0]);
for (unsigned i = 1; i < nb_streams; i++) {
av_dict_free(&options[i]);
}
if( error < 0 )
{
msg_Warn( p_demux, "Could not find stream info: %s",
vlc_strerror_c(AVUNERROR(error)) );
}
for( unsigned i = 0; i < p_sys->ic->nb_streams; i++ )
{
AVStream *s = p_sys->ic->streams[i];
const AVCodecParameters *cp = s->codecpar;
es_out_id_t *es = NULL;
es_format_t es_fmt;
const char *psz_type = "unknown";
/* Do not use the cover art as a stream */
if( s->disposition == AV_DISPOSITION_ATTACHED_PIC )
{
TAB_APPEND( p_sys->i_tk, p_sys->tk, NULL );
continue;
}
vlc_fourcc_t fcc = GetVlcFourcc( cp->codec_id );
switch( cp->codec_type )
{
case AVMEDIA_TYPE_AUDIO:
es_format_Init( &es_fmt, AUDIO_ES, fcc );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
es_fmt.i_bitrate = cp->bit_rate;
es_fmt.audio.i_channels = cp->channels;
es_fmt.audio.i_rate = cp->sample_rate;
es_fmt.audio.i_bitspersample = cp->bits_per_coded_sample;
es_fmt.audio.i_blockalign = cp->block_align;
psz_type = "audio";
if(cp->codec_id == AV_CODEC_ID_AAC_LATM)
{
es_fmt.i_original_fourcc = VLC_FOURCC('L','A','T','M');
es_fmt.b_packetized = false;
}
else if(cp->codec_id == AV_CODEC_ID_AAC &&
strstr(p_sys->fmt->long_name, "raw ADTS AAC"))
{
es_fmt.i_original_fourcc = VLC_FOURCC('A','D','T','S');
es_fmt.b_packetized = false;
}
break;
case AVMEDIA_TYPE_VIDEO:
es_format_Init( &es_fmt, VIDEO_ES, fcc );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
es_fmt.video.i_bits_per_pixel = cp->bits_per_coded_sample;
/* Special case for raw video data */
if( cp->codec_id == AV_CODEC_ID_RAWVIDEO )
{
msg_Dbg( p_demux, "raw video, pixel format: %i", cp->format );
if( GetVlcChroma( &es_fmt.video, cp->format ) != VLC_SUCCESS)
{
msg_Err( p_demux, "was unable to find a FourCC match for raw video" );
}
else
es_fmt.i_codec = es_fmt.video.i_chroma;
}
/* We need this for the h264 packetizer */
else if( cp->codec_id == AV_CODEC_ID_H264 && ( p_sys->fmt == av_find_input_format("flv") ||
p_sys->fmt == av_find_input_format("matroska") || p_sys->fmt == av_find_input_format("mp4") ) )
es_fmt.i_original_fourcc = VLC_FOURCC( 'a', 'v', 'c', '1' );
es_fmt.video.i_width = cp->width;
es_fmt.video.i_height = cp->height;
es_fmt.video.i_visible_width = es_fmt.video.i_width;
es_fmt.video.i_visible_height = es_fmt.video.i_height;
get_rotation(&es_fmt, s);
# warning FIXME: implement palette transmission
psz_type = "video";
es_fmt.video.i_frame_rate = s->codec->time_base.num;
es_fmt.video.i_frame_rate_base = s->codec->time_base.den * __MAX( s->codec->ticks_per_frame, 1 );
es_fmt.video.i_sar_num = s->sample_aspect_ratio.num;
if (s->sample_aspect_ratio.num > 0)
es_fmt.video.i_sar_den = s->sample_aspect_ratio.den;
else
es_fmt.video.i_sar_den = 0;
break;
case AVMEDIA_TYPE_SUBTITLE:
es_format_Init( &es_fmt, SPU_ES, fcc );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
if( strncmp( p_sys->ic->iformat->name, "matroska", 8 ) == 0 &&
cp->codec_id == AV_CODEC_ID_DVD_SUBTITLE &&
cp->extradata != NULL &&
cp->extradata_size > 0 )
{
char *psz_start;
char *psz_buf = malloc( cp->extradata_size + 1);
if( psz_buf != NULL )
{
memcpy( psz_buf, cp->extradata , cp->extradata_size );
psz_buf[cp->extradata_size] = '\0';
psz_start = strstr( psz_buf, "size:" );
if( psz_start &&
vobsub_size_parse( psz_start,
&es_fmt.subs.spu.i_original_frame_width,
&es_fmt.subs.spu.i_original_frame_height ) == VLC_SUCCESS )
{
msg_Dbg( p_demux, "original frame size: %dx%d",
es_fmt.subs.spu.i_original_frame_width,
es_fmt.subs.spu.i_original_frame_height );
}
else
{
msg_Warn( p_demux, "reading original frame size failed" );
}
psz_start = strstr( psz_buf, "palette:" );
if( psz_start &&
vobsub_palette_parse( psz_start, &es_fmt.subs.spu.palette[1] ) == VLC_SUCCESS )
{
es_fmt.subs.spu.palette[0] = SPU_PALETTE_DEFINED;
msg_Dbg( p_demux, "vobsub palette read" );
}
else
{
msg_Warn( p_demux, "reading original palette failed" );
}
free( psz_buf );
}
}
psz_type = "subtitle";
break;
default:
es_format_Init( &es_fmt, UNKNOWN_ES, 0 );
es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag );
#ifdef HAVE_AVUTIL_CODEC_ATTACHMENT
if( cp->codec_type == AVMEDIA_TYPE_ATTACHMENT )
{
input_attachment_t *p_attachment;
psz_type = "attachment";
if( cp->codec_id == AV_CODEC_ID_TTF )
{
AVDictionaryEntry *filename = av_dict_get( s->metadata, "filename", NULL, 0 );
if( filename && filename->value )
{
p_attachment = vlc_input_attachment_New(
filename->value, "application/x-truetype-font",
NULL, cp->extradata, (int)cp->extradata_size );
if( p_attachment )
TAB_APPEND( p_sys->i_attachments, p_sys->attachments,
p_attachment );
}
}
else msg_Warn( p_demux, "unsupported attachment type (%u) in avformat demux", cp->codec_id );
}
else
#endif
{
if( cp->codec_type == AVMEDIA_TYPE_DATA )
psz_type = "data";
msg_Warn( p_demux, "unsupported track type (%u:%u) in avformat demux", cp->codec_type, cp->codec_id );
}
break;
}
AVDictionaryEntry *language = av_dict_get( s->metadata, "language", NULL, 0 );
if ( language && language->value )
es_fmt.psz_language = strdup( language->value );
if( s->disposition & AV_DISPOSITION_DEFAULT )
es_fmt.i_priority = ES_PRIORITY_SELECTABLE_MIN + 1000;
#ifdef HAVE_AVUTIL_CODEC_ATTACHMENT
if( cp->codec_type != AVMEDIA_TYPE_ATTACHMENT )
#endif
if( cp->codec_type != AVMEDIA_TYPE_DATA )
{
const bool b_ogg = !strcmp( p_sys->fmt->name, "ogg" );
const uint8_t *p_extra = cp->extradata;
unsigned i_extra = cp->extradata_size;
if( cp->codec_id == AV_CODEC_ID_THEORA && b_ogg )
{
unsigned pi_size[3];
const void *pp_data[3];
unsigned i_count;
for( i_count = 0; i_count < 3; i_count++ )
{
if( i_extra < 2 )
break;
pi_size[i_count] = GetWBE( p_extra );
pp_data[i_count] = &p_extra[2];
if( i_extra < pi_size[i_count] + 2 )
break;
p_extra += 2 + pi_size[i_count];
i_extra -= 2 + pi_size[i_count];
}
if( i_count > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra,
pi_size, pp_data, i_count ) )
{
es_fmt.i_extra = 0;
es_fmt.p_extra = NULL;
}
}
else if( cp->codec_id == AV_CODEC_ID_SPEEX && b_ogg )
{
const uint8_t p_dummy_comment[] = {
0, 0, 0, 0,
0, 0, 0, 0,
};
unsigned pi_size[2];
const void *pp_data[2];
pi_size[0] = i_extra;
pp_data[0] = p_extra;
pi_size[1] = sizeof(p_dummy_comment);
pp_data[1] = p_dummy_comment;
if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra,
pi_size, pp_data, 2 ) )
{
es_fmt.i_extra = 0;
es_fmt.p_extra = NULL;
}
}
else if( cp->codec_id == AV_CODEC_ID_OPUS )
{
const uint8_t p_dummy_comment[] = {
'O', 'p', 'u', 's',
'T', 'a', 'g', 's',
0, 0, 0, 0, /* Vendor String length */
/* Vendor String */
0, 0, 0, 0, /* User Comment List Length */
};
unsigned pi_size[2];
const void *pp_data[2];
pi_size[0] = i_extra;
pp_data[0] = p_extra;
pi_size[1] = sizeof(p_dummy_comment);
pp_data[1] = p_dummy_comment;
if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra,
pi_size, pp_data, 2 ) )
{
es_fmt.i_extra = 0;
es_fmt.p_extra = NULL;
}
}
else if( cp->extradata_size > 0 )
{
es_fmt.p_extra = malloc( i_extra );
if( es_fmt.p_extra )
{
es_fmt.i_extra = i_extra;
memcpy( es_fmt.p_extra, p_extra, i_extra );
}
}
es = es_out_Add( p_demux->out, &es_fmt );
if( s->disposition & AV_DISPOSITION_DEFAULT )
es_out_Control( p_demux->out, ES_OUT_SET_ES_DEFAULT, es );
es_format_Clean( &es_fmt );
msg_Dbg( p_demux, "adding es: %s codec = %4.4s (%d)",
psz_type, (char*)&fcc, cp->codec_id );
}
TAB_APPEND( p_sys->i_tk, p_sys->tk, es );
}
p_sys->tk_pcr = xcalloc( p_sys->i_tk, sizeof(*p_sys->tk_pcr) );
if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
i_start_time = p_sys->ic->start_time * 1000000 / AV_TIME_BASE;
msg_Dbg( p_demux, "AVFormat(%s %s) supported stream", AVPROVIDER(LIBAVFORMAT), LIBAVFORMAT_IDENT );
msg_Dbg( p_demux, " - format = %s (%s)",
p_sys->fmt->name, p_sys->fmt->long_name );
msg_Dbg( p_demux, " - start time = %"PRId64, i_start_time );
msg_Dbg( p_demux, " - duration = %"PRId64,
( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE ) ?
p_sys->ic->duration * 1000000 / AV_TIME_BASE : -1 );
if( p_sys->ic->nb_chapters > 0 )
{
p_sys->p_title = vlc_input_title_New();
p_sys->p_title->i_length = p_sys->ic->duration * 1000000 / AV_TIME_BASE;
}
for( unsigned i = 0; i < p_sys->ic->nb_chapters; i++ )
{
seekpoint_t *s = vlc_seekpoint_New();
AVDictionaryEntry *title = av_dict_get( p_sys->ic->metadata, "title", NULL, 0);
if( title && title->value )
{
s->psz_name = strdup( title->value );
EnsureUTF8( s->psz_name );
msg_Dbg( p_demux, " - chapter %d: %s", i, s->psz_name );
}
s->i_time_offset = p_sys->ic->chapters[i]->start * 1000000 *
p_sys->ic->chapters[i]->time_base.num /
p_sys->ic->chapters[i]->time_base.den -
(i_start_time != -1 ? i_start_time : 0 );
TAB_APPEND( p_sys->p_title->i_seekpoint, p_sys->p_title->seekpoint, s );
}
ResetTime( p_demux, 0 );
return VLC_SUCCESS;
}
/*****************************************************************************
* VideoCommand: Create/Delete a video encoder
*****************************************************************************/
static mtime_t VideoCommand( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
if ( p_sys->i_cmd == 0 && !(id->p_queued->i_flags & BLOCK_FLAG_TYPE_I) )
{
mtime_t i_dts = id->p_queued->i_dts;
block_t *p_block = id->p_queued->p_next;
while ( p_block != NULL )
{
if ( p_block->i_flags & BLOCK_FLAG_TYPE_I )
return i_dts;
i_dts = p_block->i_dts;
p_block = p_block->p_next;
}
return 0;
}
p_sys->i_old_cmd = p_sys->i_cmd;
if ( id->ff_enc )
{
vlc_avcodec_lock();
avcodec_close( id->ff_enc_c );
vlc_avcodec_unlock();
av_free( id->ff_enc_c );
av_free( id->p_frame );
free( id->p_buffer_out );
id->ff_enc = NULL;
}
if ( p_sys->i_cmd > 0 )
{
/* Create a new encoder. */
int i_ff_codec = CODEC_ID_MPEG2VIDEO;
int i_aspect_num, i_aspect_den;
if( i_ff_codec == 0 )
{
msg_Err( p_stream, "cannot find encoder" );
return 0;
}
id->ff_enc = avcodec_find_encoder( i_ff_codec );
if( !id->ff_enc )
{
msg_Err( p_stream, "cannot find encoder (avcodec)" );
return 0;
}
#if LIBAVCODEC_VERSION_MAJOR < 54
id->ff_enc_c = avcodec_alloc_context();
#else
id->ff_enc_c = avcodec_alloc_context3( id->ff_enc );
#endif
id->ff_enc_c->dsp_mask = GetVlcDspMask();
id->ff_enc_c->width = p_sys->p_pictures[p_sys->i_cmd-1].format.i_width;
id->ff_enc_c->height = p_sys->p_pictures[p_sys->i_cmd-1].format.i_height;
av_reduce( &i_aspect_num, &i_aspect_den,
p_sys->i_aspect,
VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
av_reduce( &id->ff_enc_c->sample_aspect_ratio.num,
&id->ff_enc_c->sample_aspect_ratio.den,
i_aspect_num * (int64_t)id->ff_enc_c->height,
i_aspect_den * (int64_t)id->ff_enc_c->width, 1 << 30 );
#if LIBAVCODEC_BUILD >= 4754
id->ff_enc_c->time_base.num = 1;
id->ff_enc_c->time_base.den = 25; /* FIXME */
#else
id->ff_enc_c->frame_rate = 25; /* FIXME */
id->ff_enc_c->frame_rate_base = 1;
#endif
id->ff_enc_c->gop_size = 200;
id->ff_enc_c->max_b_frames = 0;
id->ff_enc_c->flags |= CODEC_FLAG_QSCALE
| CODEC_FLAG_INPUT_PRESERVED
| CODEC_FLAG_LOW_DELAY;
id->ff_enc_c->mb_decision = FF_MB_DECISION_SIMPLE;
id->ff_enc_c->pix_fmt = PIX_FMT_YUV420P;
vlc_avcodec_lock();
int ret;
#if LIBAVCODEC_VERSION_MAJOR >= 54
AVDictionary *options = NULL;
if (p_sys->options)
av_dict_copy(&options, p_sys->options, 0);
ret = avcodec_open2( id->ff_enc_c, id->ff_enc, options ? &options : NULL );
#else
ret = avcodec_open( id->ff_enc_c, id->ff_enc );
#endif
vlc_avcodec_unlock();
#if LIBAVCODEC_VERSION_MAJOR >= 54
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
msg_Err( p_stream, "Unknown option \"%s\"", t->key );
}
av_dict_free(&options);
#endif
if (ret)
{
msg_Err( p_stream, "cannot open encoder" );
return 0;
}
id->p_buffer_out = malloc( id->ff_enc_c->width * id->ff_enc_c->height * 3 );
id->p_frame = avcodec_alloc_frame();
id->p_frame->linesize[0] = p_sys->p_pictures[p_sys->i_cmd-1].p[0].i_pitch;
id->p_frame->linesize[1] = p_sys->p_pictures[p_sys->i_cmd-1].p[1].i_pitch;
id->p_frame->linesize[2] = p_sys->p_pictures[p_sys->i_cmd-1].p[2].i_pitch;
id->p_frame->data[0] = p_sys->p_pictures[p_sys->i_cmd-1].p[0].p_pixels;
id->p_frame->data[1] = p_sys->p_pictures[p_sys->i_cmd-1].p[1].p_pixels;
id->p_frame->data[2] = p_sys->p_pictures[p_sys->i_cmd-1].p[2].p_pixels;
id->i_nb_pred = p_sys->i_gop;
}
return 0;
}
/*****************************************************************************
* Add: Add an input elementary stream
*****************************************************************************/
static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
sout_stream_id_t *id;
id = calloc( 1, sizeof( sout_stream_id_t ) );
if( !id )
return NULL;
if( p_fmt->i_cat == VIDEO_ES && p_fmt->i_codec == VLC_CODEC_MPGV )
{
id->b_switcher_video = true;
p_fmt->i_codec = VLC_CODEC_MPGV;
msg_Dbg( p_stream, "creating video switcher for fcc=`%4.4s' cmd:%d",
(char*)&p_fmt->i_codec, p_sys->i_cmd );
}
else if ( p_fmt->i_cat == AUDIO_ES &&
p_fmt->i_codec == VLC_CODEC_MPGA &&
p_sys->b_audio )
{
int i_ff_codec = CODEC_ID_MP2;
int i;
id->b_switcher_audio = true;
msg_Dbg( p_stream, "creating audio switcher for fcc=`%4.4s' cmd:%d",
(char*)&p_fmt->i_codec, p_sys->i_cmd );
/* Allocate the encoder right now. */
if( i_ff_codec == 0 )
{
msg_Err( p_stream, "cannot find encoder" );
free( id );
return NULL;
}
id->ff_enc = avcodec_find_encoder( i_ff_codec );
if( !id->ff_enc )
{
msg_Err( p_stream, "cannot find encoder (avcodec)" );
free( id );
return NULL;
}
#if LIBAVCODEC_VERSION_MAJOR < 54
id->ff_enc_c = avcodec_alloc_context();
#else
id->ff_enc_c = avcodec_alloc_context3( id->ff_enc );
#endif
id->ff_enc_c->dsp_mask = GetVlcDspMask();
id->ff_enc_c->sample_rate = p_fmt->audio.i_rate;
id->ff_enc_c->time_base.num = 1;
id->ff_enc_c->time_base.den = p_fmt->audio.i_rate;
id->ff_enc_c->channels = p_fmt->audio.i_channels;
id->ff_enc_c->bit_rate = p_fmt->i_bitrate;
int ret;
#if LIBAVCODEC_VERSION_MAJOR >= 54
AVDictionary *options = NULL;
if (p_sys->options)
av_dict_copy(&options, p_sys->options, 0);
vlc_avcodec_lock();
ret = avcodec_open2( id->ff_enc_c, id->ff_enc, options ? &options : NULL );
vlc_avcodec_unlock();
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
msg_Err( p_stream, "Unknown option \"%s\"", t->key );
}
av_dict_free(&options);
#else
vlc_avcodec_lock();
ret = avcodec_open( id->ff_enc_c, id->ff_enc );
vlc_avcodec_unlock();
#endif
if (ret)
{
msg_Err( p_stream, "cannot open encoder" );
av_free( id->ff_enc_c );
free( id );
return NULL;
}
id->p_buffer_out = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE * 2 );
id->p_samples = calloc( id->ff_enc_c->frame_size * p_fmt->audio.i_channels,
sizeof(int16_t) );
if( !id->p_buffer_out || !id->p_samples )
goto error;
for( i = 0; i < MAX_AUDIO; i++ )
{
if( p_sys->pp_audio_ids[i] == NULL )
{
p_sys->pp_audio_ids[i] = id;
break;
}
}
if( i == MAX_AUDIO )
{
msg_Err( p_stream, "too many audio streams!" );
goto error;
}
}
else
{
msg_Dbg( p_stream, "do not know what to do when switching (fcc=`%4.4s')",
(char*)&p_fmt->i_codec );
}
/* src format */
memcpy( &id->f_src, p_fmt, sizeof( es_format_t ) );
/* open output stream */
id->id = p_stream->p_next->pf_add( p_stream->p_next, p_fmt );
if( id->id != NULL )
return id;
error:
vlc_avcodec_lock();
avcodec_close( id->ff_enc_c );
vlc_avcodec_unlock();
free( id->p_samples );
free( id->p_buffer_out );
av_free( id->ff_enc_c );
free( id );
return NULL;
}
