/*****************************************************************************
* 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;
sout_CfgParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
p_sys = malloc( sizeof( sout_stream_sys_t ) );
p_sys->p_input = vlc_object_find( p_stream, VLC_OBJECT_INPUT,
FIND_PARENT );
if( !p_sys->p_input )
{
msg_Err( p_stream, "cannot find p_input" );
free( p_sys );
return VLC_EGENERIC;
}
var_Get( p_stream, SOUT_CFG_PREFIX "audio", &val );
p_sys->b_audio = val.b_bool;
var_Get( p_stream, SOUT_CFG_PREFIX "video", &val );
p_sys->b_video = val.b_bool;
var_Get( p_stream, SOUT_CFG_PREFIX "delay", &val );
p_sys->i_delay = (int64_t)val.i_int * 1000;
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys = p_sys;
/* update p_sout->i_out_pace_nocontrol */
p_stream->p_sout->i_out_pace_nocontrol++;
return VLC_SUCCESS;
}
int E_(OpenEncoder)( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys = p_enc->p_sys;
AVCodecContext *p_context;
AVCodec *p_codec;
int i_codec_id, i_cat;
char *psz_namecodec;
vlc_value_t val;
if( !E_(GetFfmpegCodec)( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
&psz_namecodec ) )
{
if( E_(GetFfmpegChroma)( p_enc->fmt_out.i_codec ) < 0 )
{
/* handed chroma output */
return VLC_EGENERIC;
}
i_cat = VIDEO_ES;
i_codec_id = CODEC_ID_RAWVIDEO;
psz_namecodec = "Raw video";
}
if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
{
msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
return VLC_EGENERIC;
}
if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
{
msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
return VLC_EGENERIC;
}
/* Initialization must be done before avcodec_find_decoder() */
E_(InitLibavcodec)(p_this);
p_codec = avcodec_find_encoder( i_codec_id );
if( !p_codec )
{
msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the decoder's structure */
if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
{
msg_Err( p_enc, "out of memory" );
return VLC_EGENERIC;
}
memset( p_sys, 0, sizeof(encoder_sys_t) );
p_enc->p_sys = p_sys;
p_sys->p_codec = p_codec;
p_enc->pf_encode_video = EncodeVideo;
p_enc->pf_encode_audio = EncodeAudio;
p_sys->p_buffer_out = NULL;
p_sys->p_buffer = NULL;
p_sys->p_context = p_context = avcodec_alloc_context();
/* Set CPU capabilities */
p_context->dsp_mask = 0;
if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_MMX) )
{
p_context->dsp_mask |= FF_MM_MMX;
}
if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_MMXEXT) )
{
p_context->dsp_mask |= FF_MM_MMXEXT;
}
if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_3DNOW) )
{
p_context->dsp_mask |= FF_MM_3DNOW;
}
if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_SSE) )
{
p_context->dsp_mask |= FF_MM_SSE;
p_context->dsp_mask |= FF_MM_SSE2;
}
sout_CfgParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
p_sys->i_key_int = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
p_sys->i_b_frames = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
p_sys->i_vtolerance = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
p_sys->b_interlace = val.b_bool;
var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
p_sys->b_pre_me = val.b_bool;
var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
p_sys->b_hurry_up = val.b_bool;
if( p_sys->b_hurry_up )
{
/* hurry up mode needs noise reduction, even small */
p_sys->i_noise_reduction = 1;
}
var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val );
p_sys->b_strict_rc = val.b_bool;
var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
p_sys->i_rc_buffer_size = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
p_sys->f_rc_buffer_aggressivity = val.f_float;
var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
p_sys->f_i_quant_factor = val.f_float;
var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
p_sys->i_noise_reduction = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
p_sys->b_mpeg4_matrix = val.b_bool;
var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
if( val.psz_string && *val.psz_string )
{
if( !strcmp( val.psz_string, "rd" ) )
p_sys->i_hq = FF_MB_DECISION_RD;
else if( !strcmp( val.psz_string, "bits" ) )
p_sys->i_hq = FF_MB_DECISION_BITS;
else if( !strcmp( val.psz_string, "simple" ) )
p_sys->i_hq = FF_MB_DECISION_SIMPLE;
else
p_sys->i_hq = FF_MB_DECISION_RD;
}
if( val.psz_string ) free( val.psz_string );
var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
p_sys->i_qmin = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
p_sys->i_qmax = val.i_int;
var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
p_sys->b_trellis = val.b_bool;
var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
p_context->strict_std_compliance = val.i_int;
if( p_enc->fmt_in.i_cat == VIDEO_ES )
{
int i_aspect_num, i_aspect_den;
if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
{
msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
p_enc->fmt_in.video.i_height );
free( p_sys );
return VLC_EGENERIC;
}
p_context->width = p_enc->fmt_in.video.i_width;
p_context->height = p_enc->fmt_in.video.i_height;
p_context->frame_rate = p_enc->fmt_in.video.i_frame_rate;
p_context->frame_rate_base= p_enc->fmt_in.video.i_frame_rate_base;
/* Defaults from ffmpeg.c */
p_context->qblur = 0.5;
p_context->qcompress = 0.5;
p_context->b_quant_offset = 1.25;
p_context->b_quant_factor = 1.25;
p_context->i_quant_offset = 0.0;
p_context->i_quant_factor = -0.8;
if( p_sys->i_key_int > 0 )
p_context->gop_size = p_sys->i_key_int;
p_context->max_b_frames =
__MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
p_context->b_frame_strategy = 0;
#if LIBAVCODEC_BUILD >= 4687
av_reduce( &i_aspect_num, &i_aspect_den,
p_enc->fmt_in.video.i_aspect,
VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
av_reduce( &p_context->sample_aspect_ratio.num,
&p_context->sample_aspect_ratio.den,
i_aspect_num * (int64_t)p_context->height,
i_aspect_den * (int64_t)p_context->width, 1 << 30 );
#else
p_context->aspect_ratio = ((float)p_enc->fmt_in.video.i_aspect) /
VOUT_ASPECT_FACTOR;
#endif
p_sys->p_buffer_out = malloc( AVCODEC_MAX_VIDEO_FRAME_SIZE );
p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
if ( p_sys->b_strict_rc )
{
p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
}
if ( p_sys->f_i_quant_factor != 0.0 )
p_context->i_quant_factor = p_sys->f_i_quant_factor;
#if LIBAVCODEC_BUILD >= 4690
p_context->noise_reduction = p_sys->i_noise_reduction;
#endif
if ( p_sys->b_mpeg4_matrix )
{
p_context->intra_matrix = ff_mpeg4_default_intra_matrix;
p_context->inter_matrix = ff_mpeg4_default_non_intra_matrix;
}
if ( p_sys->b_pre_me )
{
p_context->pre_me = 1;
p_context->me_pre_cmp = FF_CMP_CHROMA;
}
if ( p_sys->b_interlace )
{
p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
#if LIBAVCODEC_BUILD >= 4698
p_context->flags |= CODEC_FLAG_INTERLACED_ME;
#endif
}
if ( p_sys->b_trellis )
p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
#if LIBAVCODEC_BUILD >= 4702
if ( p_enc->i_threads >= 1 )
p_context->thread_count = p_enc->i_threads;
#endif
if( p_sys->i_vtolerance > 0 )
p_context->bit_rate_tolerance = p_sys->i_vtolerance;
if( p_sys->i_qmin > 0 )
p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
if( p_sys->i_qmax > 0 )
p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
p_context->max_qdiff = 3;
p_context->mb_decision = p_sys->i_hq;
if( p_sys->i_quality )
{
p_context->flags |= CODEC_FLAG_QSCALE;
#if LIBAVCODEC_BUILD >= 4668
p_context->global_quality = p_sys->i_quality;
#endif
}
}
else if( p_enc->fmt_in.i_cat == AUDIO_ES )
{
p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
p_context->sample_rate = p_enc->fmt_in.audio.i_rate;
p_context->channels = p_enc->fmt_in.audio.i_channels;
}
/* Misc parameters */
p_context->bit_rate = p_enc->fmt_out.i_bitrate;
if( i_codec_id == CODEC_ID_RAWVIDEO )
{
/* XXX: hack: Force same codec (will be handled by transcode) */
p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
}
/* Make sure we get extradata filled by the encoder */
p_context->extradata_size = 0;
p_context->extradata = NULL;
p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
if( avcodec_open( p_context, p_codec ) )
{
if( p_enc->fmt_in.i_cat == AUDIO_ES && p_context->channels > 2 )
{
p_context->channels = 2;
p_enc->fmt_in.audio.i_channels = 2; // FIXME
if( avcodec_open( p_context, p_codec ) )
{
msg_Err( p_enc, "cannot open encoder" );
free( p_sys );
return VLC_EGENERIC;
}
msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
}
else
{
msg_Err( p_enc, "cannot open encoder" );
free( p_sys );
return VLC_EGENERIC;
}
}
p_enc->fmt_out.i_extra = p_context->extradata_size;
p_enc->fmt_out.p_extra = p_context->extradata;
p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
if( p_enc->fmt_in.i_cat == AUDIO_ES )
{
p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
p_sys->p_buffer = malloc( p_sys->i_frame_size );
}
msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
return VLC_SUCCESS;
}
/*****************************************************************************
* OpenEncoder: probe the encoder and return score
*****************************************************************************/
static int OpenEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys;
vlc_value_t val;
if( p_enc->fmt_out.i_codec != VLC_FOURCC('m','p','g','a') &&
p_enc->fmt_out.i_codec != VLC_FOURCC('m','p','2','a') &&
p_enc->fmt_out.i_codec != VLC_FOURCC('m','p','2',' ') &&
!p_enc->b_force )
{
return VLC_EGENERIC;
}
if( p_enc->fmt_in.audio.i_channels > 2 )
{
msg_Err( p_enc, "doesn't support > 2 channels" );
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the decoder's structure */
if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
{
msg_Err( p_enc, "out of memory" );
return VLC_EGENERIC;
}
p_enc->p_sys = p_sys;
p_enc->pf_encode_audio = Encode;
p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
p_enc->fmt_out.i_codec = VLC_FOURCC('m','p','g','a');
sout_CfgParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
p_sys->p_toolame = toolame_init();
/* Set options */
toolame_setSampleFreq( p_sys->p_toolame, p_enc->fmt_out.audio.i_rate );
var_Get( p_enc, ENC_CFG_PREFIX "vbr", &val );
if ( val.b_bool )
{
FLOAT i_quality;
var_Get( p_enc, ENC_CFG_PREFIX "quality", &val );
i_quality = val.i_int;
if ( i_quality > 50.0 ) i_quality = 50.0;
if ( i_quality < 0.0 ) i_quality = 0.0;
toolame_setVBR( p_sys->p_toolame, 1 );
toolame_setVBRLevel( p_sys->p_toolame, i_quality );
}
else
{
toolame_setBitrate( p_sys->p_toolame, p_enc->fmt_out.i_bitrate / 1000 );
}
if ( p_enc->fmt_in.audio.i_channels == 1 )
{
toolame_setMode( p_sys->p_toolame, MPG_MD_MONO );
}
else
{
var_Get( p_enc, ENC_CFG_PREFIX "mode", &val );
switch ( val.i_int )
{
case 1:
toolame_setMode( p_sys->p_toolame, MPG_MD_DUAL_CHANNEL );
break;
case 2:
toolame_setMode( p_sys->p_toolame, MPG_MD_JOINT_STEREO );
break;
case 0:
default:
toolame_setMode( p_sys->p_toolame, MPG_MD_STEREO );
break;
}
}
if ( toolame_init_params( p_sys->p_toolame ) )
{
msg_Err( p_enc, "toolame initialization failed" );
return -VLC_EGENERIC;
}
p_sys->i_nb_samples = 0;
aout_DateInit( &p_sys->pts, p_enc->fmt_out.audio.i_rate );
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;
p_sys = malloc( sizeof(sout_stream_sys_t) );
memset( p_sys, 0, sizeof(sout_stream_sys_t) );
p_sys->p_out = sout_StreamNew( p_stream->p_sout, p_stream->psz_next );
if( !p_sys->p_out )
{
msg_Err( p_stream, "cannot create chain" );
free( p_sys );
return VLC_EGENERIC;
}
sout_CfgParse( 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_OpenUDP( p_stream, NULL, val.i_int, NULL, 0 );
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;
avcodec_init();
avcodec_register_all();
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: open the shout connection
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
sout_access_out_sys_t *p_sys;
shout_t *p_shout;
long i_ret;
unsigned int i_port;
vlc_value_t val;
char *psz_accessname = NULL;
char *psz_parser = NULL;
char *psz_user = NULL;
char *psz_pass = NULL;
char *psz_host = NULL;
char *psz_mount = NULL;
char *psz_name = NULL;
char *psz_description = NULL;
char *tmp_port = NULL;
sout_CfgParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
psz_accessname = psz_parser = strdup( p_access->psz_name );
if( !p_access->psz_name )
{
msg_Err( p_access,
"please specify url=user:password@host:port/mountpoint" );
return VLC_EGENERIC;
}
/* Parse connection data user:pwd@host:port/mountpoint */
psz_user = psz_parser;
while( psz_parser[0] && psz_parser[0] != ':' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
psz_pass = psz_parser;
while( psz_parser[0] && psz_parser[0] != '@' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
psz_host = psz_parser;
while( psz_parser[0] && psz_parser[0] != ':' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
tmp_port = psz_parser;
while( psz_parser[0] && psz_parser[0] != '/' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
psz_mount = psz_parser;
i_port = atoi( tmp_port );
p_sys = p_access->p_sys = malloc( sizeof( sout_access_out_sys_t ) );
if( !p_sys )
{
msg_Err( p_access, "out of memory" );
free( psz_accessname );
return VLC_ENOMEM;
}
var_Get( p_access, SOUT_CFG_PREFIX "name", &val );
if( *val.psz_string )
psz_name = val.psz_string;
else
free( val.psz_string );
var_Get( p_access, SOUT_CFG_PREFIX "description", &val );
if( *val.psz_string )
psz_description = val.psz_string;
else
free( val.psz_string );
p_shout = p_sys->p_shout = shout_new();
if( !p_shout
|| shout_set_host( p_shout, psz_host ) != SHOUTERR_SUCCESS
|| shout_set_protocol( p_shout, SHOUT_PROTOCOL_ICY ) != SHOUTERR_SUCCESS
|| shout_set_port( p_shout, i_port ) != SHOUTERR_SUCCESS
|| shout_set_password( p_shout, psz_pass ) != SHOUTERR_SUCCESS
|| shout_set_mount( p_shout, psz_mount ) != SHOUTERR_SUCCESS
|| shout_set_user( p_shout, psz_user ) != SHOUTERR_SUCCESS
|| shout_set_agent( p_shout, "VLC media player " VERSION ) != SHOUTERR_SUCCESS
|| shout_set_name( p_shout, psz_name ) != SHOUTERR_SUCCESS
|| shout_set_description( p_shout, psz_description ) != SHOUTERR_SUCCESS
/* || shout_set_nonblocking( p_shout, 1 ) != SHOUTERR_SUCCESS */
)
{
msg_Err( p_access, "failed to initialize shout streaming to %s:%i/%s",
psz_host, i_port, psz_mount );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
if( psz_name ) free( psz_name );
if( psz_description ) free( psz_description );
var_Get( p_access, SOUT_CFG_PREFIX "mp3", &val );
if( val.b_bool == VLC_TRUE )
i_ret = shout_set_format( p_shout, SHOUT_FORMAT_MP3 );
else
i_ret = shout_set_format( p_shout, SHOUT_FORMAT_OGG );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the shoutcast streaming format" );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
/* Shoutcast using ICY protocol */
i_ret = shout_open( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_CONNECTED;
msg_Dbg( p_access, "connected using 'icy' (shoutcast) protocol" );
}
else
{
msg_Warn( p_access, "failed to connect using 'icy' (shoutcast) protocol" );
/* Shout parameters cannot be changed on an open connection */
i_ret = shout_close( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_UNCONNECTED;
}
/* IceCAST using HTTP protocol */
i_ret = shout_set_protocol( p_shout, SHOUT_PROTOCOL_HTTP );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the protocol to 'http'" );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
i_ret = shout_open( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_CONNECTED;
msg_Dbg( p_access, "connected using 'http' (icecast 2.x) protocol" );
}
else
msg_Warn( p_access, "failed to connect using 'http' (icecast 2.x) protocol " );
}
/*
for non-blocking, use:
while( i_ret == SHOUTERR_BUSY )
{
sleep( 1 );
i_ret = shout_get_connected( p_shout );
}
*/
if( i_ret != SHOUTERR_CONNECTED )
{
msg_Err( p_access, "failed to open shout stream to %s:%i/%s: %s",
psz_host, i_port, psz_mount, shout_get_error(p_shout) );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
p_access->pf_write = Write;
p_access->pf_read = Read;
p_access->pf_seek = Seek;
msg_Dbg( p_access, "shout access output opened (%s@%s:%i/%s)",
psz_user, psz_host, i_port, psz_mount );
/* Update pace control flag */
if( p_access->psz_access && !strcmp( p_access->psz_access, "stream" ) )
{
p_access->p_sout->i_out_pace_nocontrol++;
}
free( psz_accessname );
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_instance_t *p_sout = p_stream->p_sout;
slp_session_t *p_slp = NULL;
char *psz_mux;
char *psz_access;
char *psz_url;
vlc_value_t val;
sout_access_out_t *p_access;
sout_mux_t *p_mux;
char *psz_mux_byext = NULL;
sout_CfgParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
var_Get( p_stream, SOUT_CFG_PREFIX "access", &val );
psz_access = *val.psz_string ? val.psz_string : NULL;
if( val.psz_string && !*val.psz_string ) free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "mux", &val );
psz_mux = *val.psz_string ? val.psz_string : NULL;
if( val.psz_string && !*val.psz_string ) free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "url", &val );
psz_url = *val.psz_string ? val.psz_string : NULL;
if( val.psz_string && !*val.psz_string ) free( val.psz_string );
p_stream->p_sys = malloc( sizeof( sout_stream_sys_t) );
p_stream->p_sys->p_session = NULL;
msg_Dbg( p_this, "creating `%s/%s://%s'", psz_access, psz_mux, psz_url );
/* ext -> muxer name */
if( psz_url && strrchr( psz_url, '.' ) )
{
/* by extention */
static struct { char *ext; char *mux; } exttomux[] =
{
{ "avi", "avi" },
{ "ogg", "ogg" },
{ "ogm", "ogg" },
{ "mp4", "mp4" },
{ "mov", "mov" },
{ "moov","mov" },
{ "asf", "asf" },
{ "wma", "asf" },
{ "wmv", "asf" },
{ "trp", "ts" },
{ "ts", "ts" },
{ "mpg", "ps" },
{ "mpeg","ps" },
{ "ps", "ps" },
{ "mpeg1","mpeg1" },
{ NULL, NULL }
};
char *psz_ext = strrchr( psz_url, '.' ) + 1;
int i;
msg_Dbg( p_this, "extention is %s", psz_ext );
for( i = 0; exttomux[i].ext != NULL; i++ )
{
if( !strcasecmp( psz_ext, exttomux[i].ext ) )
{
psz_mux_byext = exttomux[i].mux;
break;
}
}
msg_Dbg( p_this, "extention -> mux=%s", psz_mux_byext );
}
/* We fix access/mux to valid couple */
if( !psz_access && !psz_mux )
{
if( psz_mux_byext )
{
msg_Warn( p_stream,
"no access _and_ no muxer, extention gives file/%s",
psz_mux_byext );
psz_access = strdup("file");
psz_mux = strdup(psz_mux_byext);
}
else
{
msg_Err( p_stream, "no access _and_ no muxer (fatal error)" );
return VLC_EGENERIC;
}
}
if( psz_access && !psz_mux )
{
/* access given, no mux */
if( !strncmp( psz_access, "mmsh", 4 ) )
{
psz_mux = strdup("asfh");
}
else if( !strncmp( psz_access, "udp", 3 ) )
{
psz_mux = strdup("ts");
}
else if( psz_mux_byext )
{
psz_mux = strdup(psz_mux_byext);
}
else
{
msg_Err( p_stream, "no mux specified or found by extention" );
return VLC_EGENERIC;
}
}
else if( psz_mux && !psz_access )
{
/* mux given, no access */
if( !strncmp( psz_mux, "asfh", 4 ) )
{
psz_access = strdup("mmsh");
}
else
{
/* default file */
psz_access = strdup("file");
}
}
/* fix or warm of incompatible couple */
if( psz_mux && psz_access )
{
if( !strncmp( psz_access, "mmsh", 4 ) &&
strncmp( psz_mux, "asfh", 4 ) )
{
char *p = strchr( psz_mux,'{' );
msg_Warn( p_stream, "fixing to mmsh/asfh" );
if( p )
{
/* -> a little memleak but ... */
psz_mux = malloc( strlen( "asfh" ) + strlen( p ) + 1);
sprintf( psz_mux, "asfh%s", p );
}
else
{
psz_mux = strdup("asfh");
}
}
else if( ( !strncmp( psz_access, "rtp", 3 ) ||
!strncmp( psz_access, "udp", 3 ) ) &&
strncmp( psz_mux, "ts", 2 ) )
{
msg_Err( p_stream, "for now udp and rtp are only valid with TS" );
}
else if( strncmp( psz_access, "file", 4 ) &&
( !strncmp( psz_mux, "mov", 3 ) ||
!strncmp( psz_mux, "mp4", 3 ) ) )
{
msg_Err( p_stream, "mov and mp4 work only with file output" );
}
}
msg_Dbg( p_this, "using `%s/%s://%s'", psz_access, psz_mux, psz_url );
/* *** find and open appropriate access module *** */
p_access = sout_AccessOutNew( p_sout, psz_access, psz_url );
if( p_access == NULL )
{
msg_Err( p_stream, "no suitable sout access module for `%s/%s://%s'",
psz_access, psz_mux, psz_url );
if( psz_access ) free( psz_access );
if( psz_mux ) free( psz_mux );
return VLC_EGENERIC;
}
msg_Dbg( p_stream, "access opened" );
/* *** find and open appropriate mux module *** */
p_mux = sout_MuxNew( p_sout, psz_mux, p_access );
if( p_mux == NULL )
{
msg_Err( p_stream, "no suitable sout mux module for `%s/%s://%s'",
psz_access, psz_mux, psz_url );
sout_AccessOutDelete( p_access );
if( psz_access ) free( psz_access );
if( psz_mux ) free( psz_mux );
return VLC_EGENERIC;
}
msg_Dbg( p_stream, "mux opened" );
/* *** Create the SAP Session structure *** */
var_Get( p_stream, SOUT_CFG_PREFIX "sap", &val );
if( val.b_bool &&
( strstr( psz_access, "udp" ) || strstr( psz_access , "rtp" ) ) )
{
session_descriptor_t *p_session = sout_AnnounceSessionCreate();
announce_method_t *p_method =
sout_AnnounceMethodCreate( METHOD_TYPE_SAP );
vlc_url_t url;
var_Get( p_stream, SOUT_CFG_PREFIX "name", &val );
if( *val.psz_string )
{
p_session->psz_name = strdup( val.psz_string );
}
else
{
p_session->psz_name = strdup( psz_url );
}
free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "group", &val );
if( *val.psz_string )
{
p_session->psz_group = strdup( val.psz_string );
}
free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "sap-ipv6", &val );
p_method->i_ip_version = val.b_bool ? 6 : 4;
/* Now, parse the URL to extract host and port */
vlc_UrlParse( &url, psz_url , 0);
if( url.psz_host )
{
if( url.i_port == 0 ) url.i_port = DEFAULT_PORT;
p_session->psz_uri = url.psz_host;
p_session->i_port = url.i_port;
p_session->psz_sdp = NULL;
p_session->i_ttl = config_GetInt( p_sout, "ttl" );
p_session->i_payload = 33;
msg_Info( p_this, "SAP Enabled");
sout_AnnounceRegister( p_sout, p_session, p_method );
/* FIXME: Free p_method */
p_stream->p_sys->p_session = p_session;
}
vlc_UrlClean( &url );
if( p_method->psz_address) free( p_method->psz_address );
free( p_method );
}
/* *** Register with slp *** */
#ifdef HAVE_SLP_H
var_Get( p_stream, SOUT_CFG_PREFIX "slp", &val );
if( val.b_bool &&
( strstr( psz_access, "udp" ) || strstr( psz_access , "rtp" ) ) )
{
int i_ret;
msg_Info( p_this, "SLP Enabled");
var_Get( p_stream, SOUT_CFG_PREFIX "name", &val );
if( *val.psz_string )
{
i_ret = sout_SLPReg( p_sout, psz_url, val.psz_string );
}
else
{
i_ret = sout_SLPReg( p_sout, psz_url, psz_url );
}
if( i_ret )
{
msg_Warn( p_sout, "SLP Registering failed");
}
else
{
p_slp = malloc(sizeof(slp_session_t));
p_slp->psz_url = strdup( psz_url );
p_slp->psz_name =
strdup( *val.psz_string ? val.psz_string : psz_url );
}
free( val.psz_string );
}
#endif
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys->p_mux = p_mux;
p_stream->p_sys->p_slp = p_slp;
if( psz_access ) free( psz_access );
if( psz_mux ) free( psz_mux );
if( psz_url ) free( psz_url );
return VLC_SUCCESS;
}
