static void *voutlet_newsig(t_symbol *s)
{
t_voutlet *x = (t_voutlet *)pd_new(voutlet_class);
x->x_canvas = canvas_getcurrent();
x->x_parentoutlet = canvas_addoutlet(x->x_canvas,
&x->x_obj.ob_pd, &s_signal);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
x->x_endbuf = x->x_buf = (t_sample *)getbytes(0);
x->x_bufsize = 0;
resample_init(&x->x_updown);
/* this should be though over:
* it might prove hard to provide consistency between labeled up- & downsampling methods
* maybe indeces would be better...
*
* up till now we provide several upsampling methods and 1 single downsampling method (no filtering !)
*/
if (s == gensym("hold"))x->x_updown.method=1; /* up: sample and hold */
else if (s == gensym("lin"))x->x_updown.method=2; /* up: linear interpolation */
else if (s == gensym("linear"))x->x_updown.method=2; /* up: linear interpolation */
else if (s == gensym("pad"))x->x_updown.method=0; /* up: zero pad */
else x->x_updown.method=3; /* up: zero-padding; down: ignore samples inbetween */
return (x);
}
static gboolean
plugin_init (GstPlugin * plugin)
{
resample_init ();
if (!gst_element_register (plugin, "audioresample", GST_RANK_PRIMARY,
GST_TYPE_AUDIORESAMPLE)) {
return FALSE;
}
return TRUE;
}
static gboolean
plugin_init (GstPlugin * plugin)
{
resample_init ();
if (!gst_element_register (plugin, "legacyresample", GST_RANK_MARGINAL,
GST_TYPE_LEGACYRESAMPLE)) {
return FALSE;
}
return TRUE;
}
bool FeMedia::onGetData( Chunk &data )
{
int offset=0;
data.samples = NULL;
data.sampleCount = 0;
if ( (!m_audio) || end_of_file() )
return false;
while ( offset < m_audio->codec_ctx->sample_rate )
{
AVPacket *packet = m_audio->pop_packet();
while (( packet == NULL ) && ( !end_of_file() ))
{
read_packet();
packet = m_audio->pop_packet();
}
if ( packet == NULL )
{
m_audio->at_end=true;
if ( offset > 0 )
return true;
return false;
}
#if (LIBAVCODEC_VERSION_INT < AV_VERSION_INT( 53, 25, 0 ))
{
sf::Lock l( m_audio->buffer_mutex );
int bsize = MAX_AUDIO_FRAME_SIZE;
if ( avcodec_decode_audio3(
m_audio->codec_ctx,
(m_audio->buffer + offset),
&bsize, packet) < 0 )
{
std::cerr << "Error decoding audio." << std::endl;
FeBaseStream::free_packet( packet );
return false;
}
else
{
offset += bsize / sizeof( sf::Int16 );
data.sampleCount += bsize / sizeof(sf::Int16);
data.samples = m_audio->buffer;
}
}
#else
#if (LIBAVCODEC_VERSION_INT >= AV_VERSION_INT( 55, 45, 0 ))
AVFrame *frame = av_frame_alloc();
m_audio->codec_ctx->refcounted_frames = 1;
#else
AVFrame *frame = avcodec_alloc_frame();
#endif
//
// TODO: avcodec_decode_audio4() can return multiple frames per packet depending on the codec.
// We don't deal with this appropriately...
//
int got_frame( 0 );
int len = avcodec_decode_audio4( m_audio->codec_ctx, frame, &got_frame, packet );
if ( len < 0 )
{
#ifdef FE_DEBUG
char buff[256];
av_strerror( len, buff, 256 );
std::cerr << "Error decoding audio: " << buff << std::endl;
#endif
}
if ( got_frame )
{
int data_size = av_samples_get_buffer_size(
NULL,
m_audio->codec_ctx->channels,
frame->nb_samples,
m_audio->codec_ctx->sample_fmt, 1);
#ifdef DO_RESAMPLE
if ( m_audio->codec_ctx->sample_fmt == AV_SAMPLE_FMT_S16 )
#endif
{
sf::Lock l( m_audio->buffer_mutex );
memcpy( (m_audio->buffer + offset), frame->data[0], data_size );
offset += data_size / sizeof( sf::Int16 );
data.sampleCount += data_size / sizeof(sf::Int16);
data.samples = m_audio->buffer;
}
#ifdef DO_RESAMPLE
else
{
sf::Lock l( m_audio->buffer_mutex );
if ( !m_audio->resample_ctx )
{
m_audio->resample_ctx = resample_alloc();
if ( !m_audio->resample_ctx )
{
std::cerr << "Error allocating audio format converter." << std::endl;
FeBaseStream::free_packet( packet );
FeBaseStream::free_frame( frame );
return false;
}
int64_t channel_layout = frame->channel_layout;
if ( !channel_layout )
{
channel_layout = av_get_default_channel_layout(
m_audio->codec_ctx->channels );
}
av_opt_set_int( m_audio->resample_ctx, "in_channel_layout", channel_layout, 0 );
av_opt_set_int( m_audio->resample_ctx, "in_sample_fmt", frame->format, 0 );
av_opt_set_int( m_audio->resample_ctx, "in_sample_rate", frame->sample_rate, 0 );
av_opt_set_int( m_audio->resample_ctx, "out_channel_layout", channel_layout, 0 );
av_opt_set_int( m_audio->resample_ctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0 );
av_opt_set_int( m_audio->resample_ctx, "out_sample_rate", frame->sample_rate, 0 );
#ifdef FE_DEBUG
std::cout << "Initializing resampler: in_sample_fmt="
<< av_get_sample_fmt_name( (AVSampleFormat)frame->format )
<< ", in_sample_rate=" << frame->sample_rate
<< ", out_sample_fmt=" << av_get_sample_fmt_name( AV_SAMPLE_FMT_S16 )
<< ", out_sample_rate=" << frame->sample_rate << std::endl;
#endif
if ( resample_init( m_audio->resample_ctx ) < 0 )
{
std::cerr << "Error initializing audio format converter, input format="
<< av_get_sample_fmt_name( (AVSampleFormat)frame->format )
<< ", input sample rate=" << frame->sample_rate << std::endl;
FeBaseStream::free_packet( packet );
FeBaseStream::free_frame( frame );
resample_free( &m_audio->resample_ctx );
m_audio->resample_ctx = NULL;
return false;
}
}
if ( m_audio->resample_ctx )
{
int out_linesize;
av_samples_get_buffer_size(
&out_linesize,
m_audio->codec_ctx->channels,
frame->nb_samples,
AV_SAMPLE_FMT_S16, 0 );
uint8_t *tmp_ptr = (uint8_t *)(m_audio->buffer + offset);
#ifdef USE_SWRESAMPLE
int out_samples = swr_convert(
m_audio->resample_ctx,
&tmp_ptr,
frame->nb_samples,
(const uint8_t **)frame->data,
frame->nb_samples );
#else // USE_AVRESAMPLE
int out_samples = avresample_convert(
m_audio->resample_ctx,
&tmp_ptr,
out_linesize,
frame->nb_samples,
frame->data,
frame->linesize[0],
frame->nb_samples );
#endif
if ( out_samples < 0 )
{
std::cerr << "Error performing audio conversion." << std::endl;
FeBaseStream::free_packet( packet );
FeBaseStream::free_frame( frame );
break;
}
offset += out_samples * m_audio->codec_ctx->channels;
data.sampleCount += out_samples * m_audio->codec_ctx->channels;
data.samples = m_audio->buffer;
}
}
#endif
}
FeBaseStream::free_frame( frame );
#endif
FeBaseStream::free_packet( packet );
}
return true;
}
