libavfilter/af_aresample.c - third_party/ffmpeg - Git at Google

 /*
  * Copyright (c) 2011 Stefano Sabatini
  * Copyright (c) 2011 Mina Nagy Zaki
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 /**
  * @file
  * resampling audio filter
  */

 #include "libavutil/eval.h"
 #include "libavcodec/avcodec.h"
 #include "avfilter.h"
 #include "internal.h"

 typedef struct {
     struct AVResampleContext *resample;
     int out_rate;
     double ratio;
     AVFilterBufferRef *outsamplesref;
     int unconsumed_nb_samples,
         max_cached_nb_samples;
     int16_t *cached_data[8],
             *resampled_data[8];
 } AResampleContext;

 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
 {
     AResampleContext *aresample = ctx->priv;
     int ret;

     if (args) {
         if ((ret = ff_parse_sample_rate(&aresample->out_rate, args, ctx)) < 0)
             return ret;
     } else {
         aresample->out_rate = -1;
     }

     return 0;
 }

 static av_cold void uninit(AVFilterContext *ctx)
 {
     AResampleContext *aresample = ctx->priv;
     if (aresample->outsamplesref) {
         int nb_channels =
             av_get_channel_layout_nb_channels(
                 aresample->outsamplesref->audio->channel_layout);
         avfilter_unref_buffer(aresample->outsamplesref);
         while (nb_channels--) {
             av_freep(&(aresample->cached_data[nb_channels]));
             av_freep(&(aresample->resampled_data[nb_channels]));
         }
     }

     if (aresample->resample)
         av_resample_close(aresample->resample);
 }

 static int config_output(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     AVFilterLink *inlink = ctx->inputs[0];
     AResampleContext *aresample = ctx->priv;

     if (aresample->out_rate == -1)
         aresample->out_rate = outlink->sample_rate;
     else
         outlink->sample_rate = aresample->out_rate;
     outlink->time_base = (AVRational) {1, aresample->out_rate};

     //TODO: make the resampling parameters configurable
     aresample->resample = av_resample_init(aresample->out_rate, inlink->sample_rate,
                                            16, 10, 0, 0.8);

     aresample->ratio = (double)outlink->sample_rate / inlink->sample_rate;

     av_log(ctx, AV_LOG_INFO, "r:%"PRId64"Hz -> r:%"PRId64"Hz\n",
            inlink->sample_rate, outlink->sample_rate);
     return 0;
 }

 static int query_formats(AVFilterContext *ctx)
 {
     AVFilterFormats *formats = NULL;

     avfilter_add_format(&formats, AV_SAMPLE_FMT_S16);
     if (!formats)
         return AVERROR(ENOMEM);
     avfilter_set_common_sample_formats(ctx, formats);

     formats = avfilter_make_all_channel_layouts();
     if (!formats)
         return AVERROR(ENOMEM);
     avfilter_set_common_channel_layouts(ctx, formats);

     formats = avfilter_make_all_packing_formats();
     if (!formats)
         return AVERROR(ENOMEM);
     avfilter_set_common_packing_formats(ctx, formats);

     return 0;
 }

 static void deinterleave(int16_t **outp, int16_t *in,
                          int nb_channels, int nb_samples)
 {
     int16_t *out[8];
     memcpy(out, outp, nb_channels * sizeof(int16_t*));

     switch (nb_channels) {
     case 2:
         while (nb_samples--) {
             *out[0]++ = *in++;
             *out[1]++ = *in++;
         }
         break;
     case 3:
         while (nb_samples--) {
             *out[0]++ = *in++;
             *out[1]++ = *in++;
             *out[2]++ = *in++;
         }
         break;
     case 4:
         while (nb_samples--) {
             *out[0]++ = *in++;
             *out[1]++ = *in++;
             *out[2]++ = *in++;
             *out[3]++ = *in++;
         }
         break;
     case 5:
         while (nb_samples--) {
             *out[0]++ = *in++;
             *out[1]++ = *in++;
             *out[2]++ = *in++;
             *out[3]++ = *in++;
             *out[4]++ = *in++;
         }
         break;
     case 6:
         while (nb_samples--) {
             *out[0]++ = *in++;
             *out[1]++ = *in++;
             *out[2]++ = *in++;
             *out[3]++ = *in++;
             *out[4]++ = *in++;
             *out[5]++ = *in++;
         }
         break;
     case 8:
         while (nb_samples--) {
             *out[0]++ = *in++;
             *out[1]++ = *in++;
             *out[2]++ = *in++;
             *out[3]++ = *in++;
             *out[4]++ = *in++;
             *out[5]++ = *in++;
             *out[6]++ = *in++;
             *out[7]++ = *in++;
         }
         break;
     }
 }

 static void interleave(int16_t *out, int16_t **inp,
         int nb_channels, int nb_samples)
 {
     int16_t *in[8];
     memcpy(in, inp, nb_channels * sizeof(int16_t*));

     switch (nb_channels) {
     case 2:
         while (nb_samples--) {
             *out++ = *in[0]++;
             *out++ = *in[1]++;
         }
         break;
     case 3:
         while (nb_samples--) {
             *out++ = *in[0]++;
             *out++ = *in[1]++;
             *out++ = *in[2]++;
         }
         break;
     case 4:
         while (nb_samples--) {
             *out++ = *in[0]++;
             *out++ = *in[1]++;
             *out++ = *in[2]++;
             *out++ = *in[3]++;
         }
         break;
     case 5:
         while (nb_samples--) {
             *out++ = *in[0]++;
             *out++ = *in[1]++;
             *out++ = *in[2]++;
             *out++ = *in[3]++;
             *out++ = *in[4]++;
         }
         break;
     case 6:
         while (nb_samples--) {
             *out++ = *in[0]++;
             *out++ = *in[1]++;
             *out++ = *in[2]++;
             *out++ = *in[3]++;
             *out++ = *in[4]++;
             *out++ = *in[5]++;
         }
         break;
     case 8:
         while (nb_samples--) {
             *out++ = *in[0]++;
             *out++ = *in[1]++;
             *out++ = *in[2]++;
             *out++ = *in[3]++;
             *out++ = *in[4]++;
             *out++ = *in[5]++;
             *out++ = *in[6]++;
             *out++ = *in[7]++;
         }
         break;
     }
 }

 static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)
 {
     AResampleContext *aresample  = inlink->dst->priv;
     AVFilterLink * const outlink = inlink->dst->outputs[0];
     int i,
         in_nb_samples            = insamplesref->audio->nb_samples,
         cached_nb_samples        = in_nb_samples + aresample->unconsumed_nb_samples,
         requested_out_nb_samples = aresample->ratio * cached_nb_samples,
         nb_channels              =
             av_get_channel_layout_nb_channels(inlink->channel_layout);

     if (cached_nb_samples > aresample->max_cached_nb_samples) {
         for (i = 0; i < nb_channels; i++) {
             aresample->cached_data[i]    =
                 av_realloc(aresample->cached_data[i], cached_nb_samples * sizeof(int16_t));
             aresample->resampled_data[i] =
                 av_realloc(aresample->resampled_data[i],
                            FFALIGN(sizeof(int16_t) * requested_out_nb_samples, 16));

             if (aresample->cached_data[i] == NULL || aresample->resampled_data[i] == NULL)
                 return;
         }
         aresample->max_cached_nb_samples = cached_nb_samples;

         if (aresample->outsamplesref)
             avfilter_unref_buffer(aresample->outsamplesref);

         aresample->outsamplesref =
             avfilter_get_audio_buffer(outlink, AV_PERM_WRITE, requested_out_nb_samples);
         outlink->out_buf = aresample->outsamplesref;
     }

     avfilter_copy_buffer_ref_props(aresample->outsamplesref, insamplesref);
     aresample->outsamplesref->audio->sample_rate = outlink->sample_rate;
     aresample->outsamplesref->pts =
         av_rescale(outlink->sample_rate, insamplesref->pts, inlink->sample_rate);

     /* av_resample() works with planar audio buffers */
     if (!inlink->planar && nb_channels > 1) {
         int16_t *out[8];
         for (i = 0; i < nb_channels; i++)
             out[i] = aresample->cached_data[i] + aresample->unconsumed_nb_samples;

         deinterleave(out, (int16_t *)insamplesref->data[0],
                      nb_channels, in_nb_samples);
     } else {
         for (i = 0; i < nb_channels; i++)
             memcpy(aresample->cached_data[i] + aresample->unconsumed_nb_samples,
                    insamplesref->data[i],
                    in_nb_samples * sizeof(int16_t));
     }

     for (i = 0; i < nb_channels; i++) {
         int consumed_nb_samples;
         const int is_last = i+1 == nb_channels;

         aresample->outsamplesref->audio->nb_samples =
             av_resample(aresample->resample,
                         aresample->resampled_data[i], aresample->cached_data[i],
                         &consumed_nb_samples,
                         cached_nb_samples,
                         requested_out_nb_samples, is_last);

         /* move unconsumed data back to the beginning of the cache */
         aresample->unconsumed_nb_samples = cached_nb_samples - consumed_nb_samples;
         memmove(aresample->cached_data[i],
                 aresample->cached_data[i] + consumed_nb_samples,
                 aresample->unconsumed_nb_samples * sizeof(int16_t));
     }


     /* copy resampled data to the output samplesref */
     if (!inlink->planar && nb_channels > 1) {
         interleave((int16_t *)aresample->outsamplesref->data[0],
                    aresample->resampled_data,
                    nb_channels, aresample->outsamplesref->audio->nb_samples);
     } else {
         for (i = 0; i < nb_channels; i++)
             memcpy(aresample->outsamplesref->data[i], aresample->resampled_data[i],
                    aresample->outsamplesref->audio->nb_samples * sizeof(int16_t));
     }

     avfilter_filter_samples(outlink, avfilter_ref_buffer(aresample->outsamplesref, ~0));
     avfilter_unref_buffer(insamplesref);
 }

 AVFilter avfilter_af_aresample = {
     .name          = "aresample",
     .description   = NULL_IF_CONFIG_SMALL("Resample audio data."),
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(AResampleContext),

     .inputs    = (const AVFilterPad[]) {{ .name      = "default",
                                     .type            = AVMEDIA_TYPE_AUDIO,
                                     .filter_samples  = filter_samples,
                                     .min_perms       = AV_PERM_READ, },
                                   { .name = NULL}},
     .outputs   = (const AVFilterPad[]) {{ .name      = "default",
                                     .config_props    = config_output,
                                     .type            = AVMEDIA_TYPE_AUDIO, },
                                   { .name = NULL}},
 };
	/*
	* Copyright (c) 2011 Stefano Sabatini
	* Copyright (c) 2011 Mina Nagy Zaki
	*
	* This file is part of FFmpeg.
	*
	* FFmpeg is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	/**
	* @file
	* resampling audio filter
	*/

	#include "libavutil/eval.h"
	#include "libavcodec/avcodec.h"
	#include "avfilter.h"
	#include "internal.h"

	typedef struct {
	struct AVResampleContext *resample;
	int out_rate;
	double ratio;
	AVFilterBufferRef *outsamplesref;
	int unconsumed_nb_samples,
	max_cached_nb_samples;
	int16_t *cached_data[8],
	*resampled_data[8];
	} AResampleContext;

	static av_cold int init(AVFilterContext ctx, const char args, void *opaque)
	{
	AResampleContext *aresample = ctx->priv;
	int ret;

	if (args) {
	if ((ret = ff_parse_sample_rate(&aresample->out_rate, args, ctx)) < 0)
	return ret;
	} else {
	aresample->out_rate = -1;
	}

	return 0;
	}

	static av_cold void uninit(AVFilterContext *ctx)
	{
	AResampleContext *aresample = ctx->priv;
	if (aresample->outsamplesref) {
	int nb_channels =
	av_get_channel_layout_nb_channels(
	aresample->outsamplesref->audio->channel_layout);
	avfilter_unref_buffer(aresample->outsamplesref);
	while (nb_channels--) {
	av_freep(&(aresample->cached_data[nb_channels]));
	av_freep(&(aresample->resampled_data[nb_channels]));
	}
	}

	if (aresample->resample)
	av_resample_close(aresample->resample);
	}

	static int config_output(AVFilterLink *outlink)
	{
	AVFilterContext *ctx = outlink->src;
	AVFilterLink *inlink = ctx->inputs[0];
	AResampleContext *aresample = ctx->priv;

	if (aresample->out_rate == -1)
	aresample->out_rate = outlink->sample_rate;
	else
	outlink->sample_rate = aresample->out_rate;
	outlink->time_base = (AVRational) {1, aresample->out_rate};

	//TODO: make the resampling parameters configurable
	aresample->resample = av_resample_init(aresample->out_rate, inlink->sample_rate,
	16, 10, 0, 0.8);

	aresample->ratio = (double)outlink->sample_rate / inlink->sample_rate;

	av_log(ctx, AV_LOG_INFO, "r:%"PRId64"Hz -> r:%"PRId64"Hz\n",
	inlink->sample_rate, outlink->sample_rate);
	return 0;
	}

	static int query_formats(AVFilterContext *ctx)
	{
	AVFilterFormats *formats = NULL;

	avfilter_add_format(&formats, AV_SAMPLE_FMT_S16);
	if (!formats)
	return AVERROR(ENOMEM);
	avfilter_set_common_sample_formats(ctx, formats);

	formats = avfilter_make_all_channel_layouts();
	if (!formats)
	return AVERROR(ENOMEM);
	avfilter_set_common_channel_layouts(ctx, formats);

	formats = avfilter_make_all_packing_formats();
	if (!formats)
	return AVERROR(ENOMEM);
	avfilter_set_common_packing_formats(ctx, formats);

	return 0;
	}

	static void deinterleave(int16_t *outp, int16_t in,
	int nb_channels, int nb_samples)
	{
	int16_t *out[8];
	memcpy(out, outp, nb_channels * sizeof(int16_t*));

	switch (nb_channels) {
	case 2:
	while (nb_samples--) {
	out[0]++ = in++;
	out[1]++ = in++;
	}
	break;
	case 3:
	while (nb_samples--) {
	out[0]++ = in++;
	out[1]++ = in++;
	out[2]++ = in++;
	}
	break;
	case 4:
	while (nb_samples--) {
	out[0]++ = in++;
	out[1]++ = in++;
	out[2]++ = in++;
	out[3]++ = in++;
	}
	break;
	case 5:
	while (nb_samples--) {
	out[0]++ = in++;
	out[1]++ = in++;
	out[2]++ = in++;
	out[3]++ = in++;
	out[4]++ = in++;
	}
	break;
	case 6:
	while (nb_samples--) {
	out[0]++ = in++;
	out[1]++ = in++;
	out[2]++ = in++;
	out[3]++ = in++;
	out[4]++ = in++;
	out[5]++ = in++;
	}
	break;
	case 8:
	while (nb_samples--) {
	out[0]++ = in++;
	out[1]++ = in++;
	out[2]++ = in++;
	out[3]++ = in++;
	out[4]++ = in++;
	out[5]++ = in++;
	out[6]++ = in++;
	out[7]++ = in++;
	}
	break;
	}
	}

	static void interleave(int16_t out, int16_t *inp,
	int nb_channels, int nb_samples)
	{
	int16_t *in[8];
	memcpy(in, inp, nb_channels * sizeof(int16_t*));

	switch (nb_channels) {
	case 2:
	while (nb_samples--) {
	out++ = in[0]++;
	out++ = in[1]++;
	}
	break;
	case 3:
	while (nb_samples--) {
	out++ = in[0]++;
	out++ = in[1]++;
	out++ = in[2]++;
	}
	break;
	case 4:
	while (nb_samples--) {
	out++ = in[0]++;
	out++ = in[1]++;
	out++ = in[2]++;
	out++ = in[3]++;
	}
	break;
	case 5:
	while (nb_samples--) {
	out++ = in[0]++;
	out++ = in[1]++;
	out++ = in[2]++;
	out++ = in[3]++;
	out++ = in[4]++;
	}
	break;
	case 6:
	while (nb_samples--) {
	out++ = in[0]++;
	out++ = in[1]++;
	out++ = in[2]++;
	out++ = in[3]++;
	out++ = in[4]++;
	out++ = in[5]++;
	}
	break;
	case 8:
	while (nb_samples--) {
	out++ = in[0]++;
	out++ = in[1]++;
	out++ = in[2]++;
	out++ = in[3]++;
	out++ = in[4]++;
	out++ = in[5]++;
	out++ = in[6]++;
	out++ = in[7]++;
	}
	break;
	}
	}

	static void filter_samples(AVFilterLink inlink, AVFilterBufferRef insamplesref)
	{
	AResampleContext *aresample = inlink->dst->priv;
	AVFilterLink * const outlink = inlink->dst->outputs[0];
	int i,
	in_nb_samples = insamplesref->audio->nb_samples,
	cached_nb_samples = in_nb_samples + aresample->unconsumed_nb_samples,
	requested_out_nb_samples = aresample->ratio * cached_nb_samples,
	nb_channels =
	av_get_channel_layout_nb_channels(inlink->channel_layout);

	if (cached_nb_samples > aresample->max_cached_nb_samples) {
	for (i = 0; i < nb_channels; i++) {
	aresample->cached_data[i] =
	av_realloc(aresample->cached_data[i], cached_nb_samples * sizeof(int16_t));
	aresample->resampled_data[i] =
	av_realloc(aresample->resampled_data[i],
	FFALIGN(sizeof(int16_t) * requested_out_nb_samples, 16));

	if (aresample->cached_data[i] == NULL \|\| aresample->resampled_data[i] == NULL)
	return;
	}
	aresample->max_cached_nb_samples = cached_nb_samples;

	if (aresample->outsamplesref)
	avfilter_unref_buffer(aresample->outsamplesref);

	aresample->outsamplesref =
	avfilter_get_audio_buffer(outlink, AV_PERM_WRITE, requested_out_nb_samples);
	outlink->out_buf = aresample->outsamplesref;
	}

	avfilter_copy_buffer_ref_props(aresample->outsamplesref, insamplesref);
	aresample->outsamplesref->audio->sample_rate = outlink->sample_rate;
	aresample->outsamplesref->pts =
	av_rescale(outlink->sample_rate, insamplesref->pts, inlink->sample_rate);

	/* av_resample() works with planar audio buffers */
	if (!inlink->planar && nb_channels > 1) {
	int16_t *out[8];
	for (i = 0; i < nb_channels; i++)
	out[i] = aresample->cached_data[i] + aresample->unconsumed_nb_samples;

	deinterleave(out, (int16_t *)insamplesref->data[0],
	nb_channels, in_nb_samples);
	} else {
	for (i = 0; i < nb_channels; i++)
	memcpy(aresample->cached_data[i] + aresample->unconsumed_nb_samples,
	insamplesref->data[i],
	in_nb_samples * sizeof(int16_t));
	}

	for (i = 0; i < nb_channels; i++) {
	int consumed_nb_samples;
	const int is_last = i+1 == nb_channels;

	aresample->outsamplesref->audio->nb_samples =
	av_resample(aresample->resample,
	aresample->resampled_data[i], aresample->cached_data[i],
	&consumed_nb_samples,
	cached_nb_samples,
	requested_out_nb_samples, is_last);

	/* move unconsumed data back to the beginning of the cache */
	aresample->unconsumed_nb_samples = cached_nb_samples - consumed_nb_samples;
	memmove(aresample->cached_data[i],
	aresample->cached_data[i] + consumed_nb_samples,
	aresample->unconsumed_nb_samples * sizeof(int16_t));
	}


	/* copy resampled data to the output samplesref */
	if (!inlink->planar && nb_channels > 1) {
	interleave((int16_t *)aresample->outsamplesref->data[0],
	aresample->resampled_data,
	nb_channels, aresample->outsamplesref->audio->nb_samples);
	} else {
	for (i = 0; i < nb_channels; i++)
	memcpy(aresample->outsamplesref->data[i], aresample->resampled_data[i],
	aresample->outsamplesref->audio->nb_samples * sizeof(int16_t));
	}

	avfilter_filter_samples(outlink, avfilter_ref_buffer(aresample->outsamplesref, ~0));
	avfilter_unref_buffer(insamplesref);
	}

	AVFilter avfilter_af_aresample = {
	.name = "aresample",
	.description = NULL_IF_CONFIG_SMALL("Resample audio data."),
	.init = init,
	.uninit = uninit,
	.query_formats = query_formats,
	.priv_size = sizeof(AResampleContext),

	.inputs = (const AVFilterPad[]) {{ .name = "default",
	.type = AVMEDIA_TYPE_AUDIO,
	.filter_samples = filter_samples,
	.min_perms = AV_PERM_READ, },
	{ .name = NULL}},
	.outputs = (const AVFilterPad[]) {{ .name = "default",
	.config_props = config_output,
	.type = AVMEDIA_TYPE_AUDIO, },
	{ .name = NULL}},
	};