/*****************************************************************************
* OpenFilter:
*****************************************************************************/
static int OpenFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
if( p_filter->fmt_in.audio.i_format != VLC_CODEC_MPGA &&
p_filter->fmt_in.audio.i_format != VLC_FOURCC('m','p','g','3') )
return VLC_EGENERIC;
if( p_filter->fmt_out.audio.i_format != VLC_CODEC_FI32 )
return VLC_EGENERIC;
if( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )
return VLC_EGENERIC;
/* Allocate the memory needed to store the module's structure */
p_sys = p_filter->p_sys = malloc( sizeof(filter_sys_t) );
if( p_sys == NULL )
return -1;
p_sys->i_reject_count = 0;
p_filter->pf_audio_filter = Convert;
/* Initialize libmad */
mad_stream_init( &p_sys->mad_stream );
mad_frame_init( &p_sys->mad_frame );
mad_synth_init( &p_sys->mad_synth );
mad_stream_options( &p_sys->mad_stream, MAD_OPTION_IGNORECRC );
msg_Dbg( p_this, "%4.4s->%4.4s, bits per sample: %i",
(char *)&p_filter->fmt_in.audio.i_format,
(char *)&p_filter->fmt_out.audio.i_format,
p_filter->fmt_out.audio.i_bitspersample );
return 0;
}
/*****************************************************************************
* Open: initialize as "audio filter"
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
bool b_fit = true;
if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ||
p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 )
{
b_fit = false;
p_filter->fmt_in.audio.i_format = p_filter->fmt_out.audio.i_format = VLC_CODEC_FL32;
msg_Warn( p_filter, "bad input or output format" );
}
if( ! AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )
{
b_fit = false;
memcpy( &p_filter->fmt_out.audio, &p_filter->fmt_in.audio, sizeof(audio_sample_format_t) );
msg_Warn( p_filter, "input and output formats are not similar" );
}
if( ! b_fit )
return VLC_EGENERIC;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof(*p_sys) );
if( ! p_sys )
return VLC_ENOMEM;
p_filter->pf_audio_filter = DoWork;
p_sys->scale = 1.0;
p_sys->sample_rate = p_filter->fmt_in.audio.i_rate;
p_sys->samples_per_frame = aout_FormatNbChannels( &p_filter->fmt_in.audio );
p_sys->bytes_per_sample = 4;
p_sys->bytes_per_frame = p_sys->samples_per_frame * p_sys->bytes_per_sample;
msg_Dbg( p_this, "format: %5i rate, %i nch, %i bps, %s",
p_sys->sample_rate,
p_sys->samples_per_frame,
p_sys->bytes_per_sample,
"fl32" );
p_sys->ms_stride = var_InheritInteger( p_this, "scaletempo-stride" );
p_sys->percent_overlap = var_InheritFloat( p_this, "scaletempo-overlap" );
p_sys->ms_search = var_InheritInteger( p_this, "scaletempo-search" );
msg_Dbg( p_this, "params: %i stride, %.3f overlap, %i search",
p_sys->ms_stride, p_sys->percent_overlap, p_sys->ms_search );
p_sys->buf_queue = NULL;
p_sys->buf_overlap = NULL;
p_sys->table_blend = NULL;
p_sys->buf_pre_corr = NULL;
p_sys->table_window = NULL;
p_sys->bytes_overlap = 0;
p_sys->bytes_queued = 0;
p_sys->bytes_to_slide = 0;
p_sys->frames_stride_error = 0;
if( reinit_buffers( p_filter ) != VLC_SUCCESS )
{
Close( p_this );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/**
* Open the module
* @param p_this: the filter object
* @return VLC_SUCCESS or vlc error codes
*/
static int Open( vlc_object_t * p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
/* Test the audio format */
if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ||
p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 )
{
msg_Warn( p_filter, "bad input or output format" );
return VLC_EGENERIC;
}
if( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )
{
msg_Warn( p_filter, "input and outut are not similar" );
return VLC_EGENERIC;
}
p_filter->pf_audio_filter = DoWork;
p_sys = p_filter->p_sys = (filter_sys_t*)malloc( sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
/* Create the object for the thread */
vlc_sem_init( &p_sys->ready, 0 );
p_sys->b_error = false;
p_sys->b_quit = false;
p_sys->i_width = var_InheritInteger( p_filter, "projectm-width" );
p_sys->i_height = var_InheritInteger( p_filter, "projectm-height" );
p_sys->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio );
#ifndef HAVE_PROJECTM2
p_sys->psz_config = var_InheritString( p_filter, "projectm-config" );
#else
p_sys->psz_preset_path = var_InheritString( p_filter, "projectm-preset-path" );
p_sys->psz_title_font = var_InheritString( p_filter, "projectm-title-font" );
p_sys->psz_menu_font = var_InheritString( p_filter, "projectm-menu-font" );
#endif
vlc_mutex_init( &p_sys->lock );
p_sys->p_buffer = NULL;
p_sys->i_buffer_size = 0;
p_sys->i_nb_samples = 0;
/* Create the thread */
if( vlc_clone( &p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_LOW ) )
goto error;
vlc_sem_wait( &p_sys->ready );
if( p_sys->b_error )
{
vlc_join( p_sys->thread, NULL );
goto error;
}
return VLC_SUCCESS;
error:
vlc_sem_destroy( &p_sys->ready );
free (p_sys );
return VLC_EGENERIC;
}
/**
* Open: initialize and create stuff
* @param p_this
*/
static int Open( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t*)p_this;
filter_sys_t *p_sys;
if ( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )
{
msg_Err( p_filter, "input and output formats are not similar" );
return VLC_EGENERIC;
}
if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ||
p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 )
{
p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32;
p_filter->fmt_out.audio.i_format = VLC_CODEC_FL32;
msg_Warn( p_filter, "bad input or output format" );
}
p_filter->pf_audio_filter = DoWork;
p_sys = p_filter->p_sys = malloc( sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
p_sys->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio );
p_sys->f_delayTime = var_CreateGetFloat( p_this, "delay-time" );
p_sys->f_sweepDepth = var_CreateGetFloat( p_this, "sweep-depth" );
p_sys->f_sweepRate = var_CreateGetFloat( p_this, "sweep-rate" );
p_sys->f_feedbackGain = var_CreateGetFloat( p_this, "feedback-gain" );
p_sys->f_dryLevel = var_CreateGetFloat( p_this, "dry-mix" );
p_sys->f_wetLevel = var_CreateGetFloat( p_this, "wet-mix" );
if( p_sys->f_delayTime < 0.0)
{
msg_Err( p_filter, "Delay Time is invalid" );
free(p_sys);
return VLC_EGENERIC;
}
if( p_sys->f_sweepDepth > p_sys->f_delayTime || p_sys->f_sweepDepth < 0.0 )
{
msg_Err( p_filter, "Sweep Depth is invalid" );
free( p_sys );
return VLC_EGENERIC;
}
if( p_sys->f_sweepRate < 0.0 )
{
msg_Err( p_filter, "Sweep Rate is invalid" );
free( p_sys );
return VLC_EGENERIC;
}
/* Max delay = delay + depth. Min = delay - depth */
p_sys->i_bufferLength = p_sys->i_channels * ( (int)( ( p_sys->f_delayTime
+ p_sys->f_sweepDepth ) * p_filter->fmt_in.audio.i_rate/1000 ) + 1 );
msg_Dbg( p_filter , "Buffer length:%d, Channels:%d, Sweep Depth:%f, Delay "
"time:%f, Sweep Rate:%f, Sample Rate: %d", p_sys->i_bufferLength,
p_sys->i_channels, p_sys->f_sweepDepth, p_sys->f_delayTime,
p_sys->f_sweepRate, p_filter->fmt_in.audio.i_rate );
if( p_sys->i_bufferLength <= 0 )
{
msg_Err( p_filter, "Delay-time, Sampl rate or Channels was incorrect" );
free(p_sys);
return VLC_EGENERIC;
}
p_sys->pf_delayLineStart = calloc( p_sys->i_bufferLength, sizeof( float ) );
if( !p_sys->pf_delayLineStart )
{
free( p_sys );
return VLC_ENOMEM;
}
p_sys->i_cumulative = 0;
p_sys->f_step = p_sys->f_sweepRate / 1000.0;
p_sys->i_step = p_sys->f_sweepRate > 0 ? 1 : 0;
p_sys->f_offset = 0;
p_sys->i_offset = 0;
p_sys->f_temp = 0;
p_sys->pf_delayLineEnd = p_sys->pf_delayLineStart + p_sys->i_bufferLength;
p_sys->pf_write = p_sys->pf_delayLineStart;
if( p_sys->f_sweepDepth < small_value() ||
p_filter->fmt_in.audio.i_rate < small_value() ) {
p_sys->f_sinMultiplier = 0.0;
}
else {
p_sys->f_sinMultiplier = 11 * p_sys->f_sweepRate /
( 7 * p_sys->f_sweepDepth * p_filter->fmt_in.audio.i_rate ) ;
}
p_sys->i_sampleRate = p_filter->fmt_in.audio.i_rate;
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: open a scope effect plugin
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
goom_thread_t *p_thread;
int width, height;
video_format_t fmt;
if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ||
p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 )
{
msg_Warn( p_filter, "bad input or output format" );
return VLC_EGENERIC;
}
if( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )
{
msg_Warn( p_filter, "input and output formats are not similar" );
return VLC_EGENERIC;
}
p_filter->pf_audio_filter = DoWork;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
/* Create goom thread */
p_sys->p_thread = p_thread =
vlc_object_create( p_filter, sizeof( goom_thread_t ) );
vlc_object_attach( p_thread, p_this );
width = var_CreateGetInteger( p_thread, "goom-width" );
height = var_CreateGetInteger( p_thread, "goom-height" );
memset( &fmt, 0, sizeof(video_format_t) );
fmt.i_width = fmt.i_visible_width = width;
fmt.i_height = fmt.i_visible_height = height;
fmt.i_chroma = VLC_CODEC_RGB32;
fmt.i_sar_num = fmt.i_sar_den = 1;
p_thread->p_vout = aout_filter_RequestVout( p_filter, NULL, &fmt );
if( p_thread->p_vout == NULL )
{
msg_Err( p_filter, "no suitable vout module" );
vlc_object_release( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
vlc_mutex_init( &p_thread->lock );
vlc_cond_init( &p_thread->wait );
p_thread->i_blocks = 0;
date_Init( &p_thread->date, p_filter->fmt_out.audio.i_rate, 1 );
date_Set( &p_thread->date, 0 );
p_thread->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio );
p_thread->psz_title = TitleGet( VLC_OBJECT( p_filter ) );
if( vlc_thread_create( p_thread, Thread,
VLC_THREAD_PRIORITY_LOW ) )
{
msg_Err( p_filter, "cannot lauch goom thread" );
vlc_object_release( p_thread->p_vout );
vlc_mutex_destroy( &p_thread->lock );
vlc_cond_destroy( &p_thread->wait );
free( p_thread->psz_title );
vlc_object_release( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
bool b_fit = true;
unsigned i_samplerate;
if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ||
p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 )
{
b_fit = false;
p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32;
p_filter->fmt_out.audio.i_format = VLC_CODEC_FL32;
msg_Warn( p_filter, "bad input or output format" );
}
if ( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )
{
b_fit = false;
memcpy( &p_filter->fmt_out.audio, &p_filter->fmt_in.audio,
sizeof(audio_sample_format_t) );
msg_Warn( p_filter, "input and output formats are not similar" );
}
if ( ! b_fit )
{
return VLC_EGENERIC;
}
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( *p_sys ) );
if( !p_sys )
return VLC_EGENERIC;
p_filter->pf_audio_filter = DoWork;
p_sys->f_lowf = var_InheritFloat( p_this, "param-eq-lowf");
p_sys->f_lowgain = var_InheritFloat( p_this, "param-eq-lowgain");
p_sys->f_highf = var_InheritFloat( p_this, "param-eq-highf");
p_sys->f_highgain = var_InheritFloat( p_this, "param-eq-highgain");
p_sys->f_f1 = var_InheritFloat( p_this, "param-eq-f1");
p_sys->f_Q1 = var_InheritFloat( p_this, "param-eq-q1");
p_sys->f_gain1 = var_InheritFloat( p_this, "param-eq-gain1");
p_sys->f_f2 = var_InheritFloat( p_this, "param-eq-f2");
p_sys->f_Q2 = var_InheritFloat( p_this, "param-eq-q2");
p_sys->f_gain2 = var_InheritFloat( p_this, "param-eq-gain2");
p_sys->f_f3 = var_InheritFloat( p_this, "param-eq-f3");
p_sys->f_Q3 = var_InheritFloat( p_this, "param-eq-q3");
p_sys->f_gain3 = var_InheritFloat( p_this, "param-eq-gain3");
i_samplerate = p_filter->fmt_in.audio.i_rate;
CalcPeakEQCoeffs(p_sys->f_f1, p_sys->f_Q1, p_sys->f_gain1,
i_samplerate, p_sys->coeffs+0*5);
CalcPeakEQCoeffs(p_sys->f_f2, p_sys->f_Q2, p_sys->f_gain2,
i_samplerate, p_sys->coeffs+1*5);
CalcPeakEQCoeffs(p_sys->f_f3, p_sys->f_Q3, p_sys->f_gain3,
i_samplerate, p_sys->coeffs+2*5);
CalcShelfEQCoeffs(p_sys->f_lowf, 1, p_sys->f_lowgain, 0,
i_samplerate, p_sys->coeffs+3*5);
CalcShelfEQCoeffs(p_sys->f_highf, 1, p_sys->f_highgain, 0,
i_samplerate, p_sys->coeffs+4*5);
p_sys->p_state = (float*)calloc( p_filter->fmt_in.audio.i_channels*5*4,
sizeof(float) );
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: open a scope effect plugin
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
aout_filter_t *p_filter = (aout_filter_t *)p_this;
aout_filter_sys_t *p_sys;
goom_thread_t *p_thread;
vlc_value_t width, height;
if ( p_filter->input.i_format != VLC_FOURCC('f','l','3','2' )
|| p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
{
msg_Warn( p_filter, "Bad input or output format" );
return VLC_EGENERIC;
}
if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
{
msg_Warn( p_filter, "input and output formats are not similar" );
return VLC_EGENERIC;
}
p_filter->pf_do_work = DoWork;
p_filter->b_in_place = 1;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
/* Create goom thread */
p_sys->p_thread = p_thread =
vlc_object_create( p_filter, sizeof( goom_thread_t ) );
vlc_object_attach( p_thread, p_this );
var_Create( p_thread, "goom-width", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
var_Get( p_thread, "goom-width", &width );
var_Create( p_thread, "goom-height", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
var_Get( p_thread, "goom-height", &height );
p_thread->p_vout =
vout_Request( p_filter, NULL, width.i_int, height.i_int,
VLC_FOURCC('R','V','3','2'),
VOUT_ASPECT_FACTOR * width.i_int/height.i_int );
if( p_thread->p_vout == NULL )
{
msg_Err( p_filter, "no suitable vout module" );
vlc_object_detach( p_thread );
vlc_object_destroy( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
vlc_mutex_init( p_filter, &p_thread->lock );
vlc_cond_init( p_filter, &p_thread->wait );
p_thread->i_blocks = 0;
aout_DateInit( &p_thread->date, p_filter->output.i_rate );
aout_DateSet( &p_thread->date, 0 );
p_thread->i_channels = aout_FormatNbChannels( &p_filter->input );
p_thread->psz_title = TitleGet( VLC_OBJECT( p_filter ) );
if( vlc_thread_create( p_thread, "Goom Update Thread", Thread,
VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
{
msg_Err( p_filter, "cannot lauch goom thread" );
vout_Destroy( p_thread->p_vout );
vlc_mutex_destroy( &p_thread->lock );
vlc_cond_destroy( &p_thread->wait );
if( p_thread->psz_title ) free( p_thread->psz_title );
vlc_object_detach( p_thread );
vlc_object_destroy( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
static int Open(vlc_object_t *object)
{
filter_t *filter = (filter_t *)object;
const es_format_t *src = &filter->fmt_in;
es_format_t *dst = &filter->fmt_out;
if (!AOUT_FMTS_SIMILAR(&src->audio, &dst->audio))
return VLC_EGENERIC;
if (src->i_codec == dst->i_codec)
return VLC_EGENERIC;
cvt_direct_t direct = FindDirect(src->i_codec, dst->i_codec);
if (direct) {
filter->pf_audio_filter = direct;
filter->p_sys = NULL;
goto end;
}
/* */
filter_sys_t *sys = malloc(sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
/* Find the cost minimal conversion */
for (unsigned mask = 0; mask <= 0x07; mask++) {
memset(sys, 0, sizeof(*sys));
vlc_fourcc_t fsrc = src->i_codec;
vlc_fourcc_t fdst = dst->i_codec;
if (mask & 0x01) {
sys->pre = FindSwap(&fsrc, fsrc);
if (!sys->pre)
continue;
}
if (mask & 0x02) {
sys->post = FindSwap(&fdst, fdst);
if (!sys->post)
continue;
}
const bool has_middle = mask & 0x04;
for (int i = 0; fsrc != fdst && i < 1 + has_middle; i++) {
/* XXX Hardcoded middle format: native 16 bits */
vlc_fourcc_t ftarget = has_middle && i == 0 ? VLC_CODEC_S16N : fdst;
sys->directs[i] = FindDirect(fsrc, ftarget);
if (!sys->directs[i]) {
sys->indirects[i] = FindIndirect(fsrc, ftarget);
if (!sys->indirects[i])
break;
sys->indirects_ratio[i][0] = aout_BitsPerSample(fsrc) / 8;
sys->indirects_ratio[i][1] = aout_BitsPerSample(ftarget) / 8;
}
fsrc = ftarget;
}
if (fsrc != fdst)
continue;
/* We have a full conversion */
filter->pf_audio_filter = Filter;
filter->p_sys = sys;
goto end;
}
free(sys);
return VLC_EGENERIC;
end:
dst->audio = src->audio;
dst->audio.i_format = dst->i_codec;
aout_FormatPrepare(&dst->audio);
msg_Dbg(filter, "%4.4s->%4.4s, bits per sample: %i->%i",
(char *)&src->i_codec, (char *)&dst->i_codec,
src->audio.i_bitspersample, dst->audio.i_bitspersample);
return VLC_SUCCESS;
}