int OutOpenAvio(vlc_object_t *object)
{
sout_access_out_t *access = (sout_access_out_t*)object;
config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg );
sout_access_out_sys_t *sys = malloc(sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
sys->context = NULL;
/* */
vlc_init_avformat(object);
if (!access->psz_path)
goto error;
int ret;
#if LIBAVFORMAT_VERSION_MAJOR < 54
ret = avio_open(&sys->context, access->psz_path, AVIO_FLAG_WRITE);
#else
AVDictionary *options = NULL;
char *psz_opts = var_InheritString(access, "sout-avio-options");
if (psz_opts && *psz_opts) {
options = vlc_av_get_options(psz_opts);
free(psz_opts);
}
ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE,
NULL, &options);
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))
msg_Err( access, "unknown option \"%s\"", t->key );
av_dict_free(&options);
#endif
if (ret < 0) {
errno = AVUNERROR(ret);
msg_Err(access, "Failed to open %s", access->psz_path);
goto error;
}
#if LIBAVFORMAT_VERSION_MAJOR < 54
/* We can accept only one active user at any time */
if (SetupAvioCb(VLC_OBJECT(access))) {
msg_Err(access, "Module aready in use");
goto error;
}
#endif
access->pf_write = Write;
access->pf_control = OutControl;
access->pf_seek = OutSeek;
access->p_sys = sys;
return VLC_SUCCESS;
error:
free(sys);
return VLC_EGENERIC;
}
/*****************************************************************************
* Mux: multiplex available data in input fifos
*****************************************************************************/
static int Mux( sout_mux_t *p_mux )
{
sout_mux_sys_t *p_sys = p_mux->p_sys;
if( p_sys->b_error ) return VLC_EGENERIC;
if( p_sys->b_write_header )
{
int error;
msg_Dbg( p_mux, "writing header" );
char *psz_opts = var_GetNonEmptyString( p_mux, "sout-avformat-options" );
AVDictionary *options = NULL;
if (psz_opts) {
vlc_av_get_options(psz_opts, &options);
free(psz_opts);
}
av_dict_set( &p_sys->oc->metadata, "encoding_tool", "VLC "VERSION, 0 );
error = avformat_write_header( p_sys->oc, options ? &options : NULL);
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
msg_Err( p_mux, "Unknown option \"%s\"", t->key );
}
av_dict_free(&options);
if( error < 0 )
{
msg_Err( p_mux, "could not write header: %s",
vlc_strerror_c(AVUNERROR(error)) );
p_sys->b_write_header = false;
p_sys->b_error = true;
return VLC_EGENERIC;
}
avio_flush( p_sys->oc->pb );
p_sys->b_write_header = false;
}
for( ;; )
{
mtime_t i_dts;
int i_stream = sout_MuxGetStream( p_mux, 1, &i_dts );
if( i_stream < 0 )
return VLC_SUCCESS;
MuxBlock( p_mux, p_mux->pp_inputs[i_stream] );
}
return VLC_SUCCESS;
}
int OutOpenAvio(vlc_object_t *object)
{
sout_access_out_t *access = (sout_access_out_t*)object;
config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg );
sout_access_out_sys_t *sys = vlc_obj_malloc(object, sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
sys->context = NULL;
/* */
vlc_init_avformat(object);
if (!access->psz_path)
return VLC_EGENERIC;
int ret;
AVDictionary *options = NULL;
char *psz_opts = var_InheritString(access, "sout-avio-options");
if (psz_opts) {
vlc_av_get_options(psz_opts, &options);
free(psz_opts);
}
ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE,
NULL, &options);
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))
msg_Err( access, "unknown option \"%s\"", t->key );
av_dict_free(&options);
if (ret < 0) {
errno = AVUNERROR(ret);
msg_Err(access, "Failed to open %s", access->psz_path);
return VLC_EGENERIC;
}
access->pf_write = Write;
access->pf_control = OutControl;
access->pf_seek = OutSeek;
access->p_sys = sys;
return VLC_SUCCESS;
}
int OpenAvio(vlc_object_t *object)
{
stream_t *access = (stream_t*)object;
access_sys_t *sys = vlc_obj_malloc(object, sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
sys->context = NULL;
/* We accept:
* - avio://full_url
* - url (only a subset of available protocols).
*/
char *url;
if (!strcmp(access->psz_name, "avio"))
url = strdup(access->psz_location);
else if (asprintf(&url, "%s://%s", access->psz_name,
access->psz_location) < 0)
url = NULL;
if (!url)
return VLC_ENOMEM;
/* */
vlc_init_avformat(object);
int ret;
AVIOInterruptCB cb = {
.callback = UrlInterruptCallback,
.opaque = access,
};
AVDictionary *options = NULL;
char *psz_opts = var_InheritString(access, "avio-options");
if (psz_opts) {
vlc_av_get_options(psz_opts, &options);
free(psz_opts);
}
ret = avio_open2(&sys->context, url, AVIO_FLAG_READ, &cb, &options);
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))
msg_Err( access, "unknown option \"%s\"", t->key );
av_dict_free(&options);
if (ret < 0) {
msg_Err(access, "Failed to open %s: %s", url,
vlc_strerror_c(AVUNERROR(ret)));
free(url);
return VLC_EGENERIC;
}
free(url);
sys->size = avio_size(sys->context);
bool seekable;
seekable = sys->context->seekable;
msg_Dbg(access, "%sseekable, size=%"PRIi64, seekable ? "" : "not ",
sys->size);
/* */
access->pf_read = Read;
access->pf_block = NULL;
access->pf_control = Control;
access->pf_seek = Seek;
access->p_sys = sys;
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;
}
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;
}
int OpenAvio(vlc_object_t *object)
{
access_t *access = (access_t*)object;
access_sys_t *sys = malloc(sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
sys->context = NULL;
/* We accept:
* - avio://full_url
* - url (only a subset of available protocols).
*/
char *url;
if (!strcmp(access->psz_access, "avio"))
url = strdup(access->psz_location);
else if (asprintf(&url, "%s://%s", access->psz_access,
access->psz_location) < 0)
url = NULL;
if (!url) {
free(sys);
return VLC_ENOMEM;
}
/* */
vlc_init_avformat(object);
int ret;
#if LIBAVFORMAT_VERSION_MAJOR < 54
ret = avio_open(&sys->context, url, AVIO_FLAG_READ);
#else
AVIOInterruptCB cb = {
.callback = UrlInterruptCallback,
.opaque = access,
};
AVDictionary *options = NULL;
char *psz_opts = var_InheritString(access, "avio-options");
if (psz_opts && *psz_opts) {
options = vlc_av_get_options(psz_opts);
free(psz_opts);
}
ret = avio_open2(&sys->context, url, AVIO_FLAG_READ, &cb, &options);
AVDictionaryEntry *t = NULL;
while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))
msg_Err( access, "unknown option \"%s\"", t->key );
av_dict_free(&options);
#endif
if (ret < 0) {
errno = AVUNERROR(ret);
msg_Err(access, "Failed to open %s: %m", url);
free(url);
goto error;
}
free(url);
#if LIBAVFORMAT_VERSION_MAJOR < 54
/* We can accept only one active user at any time */
if (SetupAvioCb(VLC_OBJECT(access))) {
msg_Err(access, "Module aready in use");
avio_close(sys->context);
goto error;
}
#endif
int64_t size = avio_size(sys->context);
bool seekable;
#if LIBAVFORMAT_VERSION_MAJOR < 54
seekable = !sys->context->is_streamed;
#else
seekable = sys->context->seekable;
#endif
msg_Dbg(access, "%sseekable, size=%"PRIi64, seekable ? "" : "not ", size);
sys->size = size > 0 ? size : 0;
/* */
access_InitFields(access);
access->pf_read = Read;
access->pf_block = NULL;
access->pf_control = Control;
access->pf_seek = Seek;
access->p_sys = sys;
return VLC_SUCCESS;
error:
free(sys);
return VLC_EGENERIC;
}
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;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_stream_sys_t *p_sys;
vlc_value_t val;
char *psz_files, *psz_sizes;
int i_height = 0, i_width = 0;
vlc_init_avcodec();
p_sys = calloc( 1, sizeof(sout_stream_sys_t) );
if( !p_sys )
return VLC_ENOMEM;
if( !p_stream->p_next )
{
msg_Err( p_stream, "cannot create chain" );
free( p_sys );
return VLC_EGENERIC;
}
config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
var_Get( p_stream, SOUT_CFG_PREFIX "files", &val );
psz_files = val.psz_string;
var_Get( p_stream, SOUT_CFG_PREFIX "sizes", &val );
psz_sizes = val.psz_string;
p_sys->i_nb_pictures = 0;
while ( psz_files && *psz_files )
{
char * psz_file = psz_files;
char * psz_size = psz_sizes;
while ( *psz_files && *psz_files != ':' )
psz_files++;
if ( *psz_files == ':' )
*psz_files++ = '\0';
if ( *psz_sizes )
{
while ( *psz_sizes && *psz_sizes != ':' )
psz_sizes++;
if ( *psz_sizes == ':' )
*psz_sizes++ = '\0';
if ( sscanf( psz_size, "%dx%d", &i_width, &i_height ) != 2 )
{
msg_Err( p_stream, "bad size %s for file %s", psz_size,
psz_file );
free( p_sys );
return VLC_EGENERIC;
}
}
if ( UnpackFromFile( p_stream, psz_file, i_width, i_height,
&p_sys->p_pictures[p_sys->i_nb_pictures] ) < 0 )
{
free( p_sys );
return VLC_EGENERIC;
}
p_sys->i_nb_pictures++;
}
var_Get( p_stream, SOUT_CFG_PREFIX "aspect-ratio", &val );
if ( val.psz_string )
{
char *psz_parser = strchr( val.psz_string, ':' );
if( psz_parser )
{
*psz_parser++ = '\0';
p_sys->i_aspect = atoi( val.psz_string ) * VOUT_ASPECT_FACTOR
/ atoi( psz_parser );
}
else
{
msg_Warn( p_stream, "bad aspect ratio %s", val.psz_string );
p_sys->i_aspect = 4 * VOUT_ASPECT_FACTOR / 3;
}
free( val.psz_string );
}
else
{
p_sys->i_aspect = 4 * VOUT_ASPECT_FACTOR / 3;
}
var_Get( p_stream, SOUT_CFG_PREFIX "port", &val );
p_sys->i_fd = net_ListenUDP1( VLC_OBJECT(p_stream), NULL, val.i_int );
if ( p_sys->i_fd < 0 )
{
free( p_sys );
return VLC_EGENERIC;
}
var_Get( p_stream, SOUT_CFG_PREFIX "command", &val );
p_sys->i_cmd = val.i_int;
p_sys->i_old_cmd = 0;
var_Get( p_stream, SOUT_CFG_PREFIX "gop", &val );
p_sys->i_gop = val.i_int;
var_Get( p_stream, SOUT_CFG_PREFIX "qscale", &val );
p_sys->i_qscale = val.i_int;
var_Get( p_stream, SOUT_CFG_PREFIX "mute-audio", &val );
p_sys->b_audio = val.b_bool;
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys = p_sys;
#if LIBAVCODEC_VERSION_MAJOR >= 54
char *psz_opts = var_InheritString( p_stream, SOUT_CFG_PREFIX "options" );
if (psz_opts && *psz_opts) {
p_sys->options = vlc_av_get_options(psz_opts);
} else {
p_sys->options = NULL;
}
free(psz_opts);
#endif
return VLC_SUCCESS;
}
