@@ -30,6 +30,7 @@ version next:

 - MicroDVD decoder

 - Avid Meridien (AVUI) decoder

 - accept + prefix to -pix_fmt option to disable automatic conversions.

+- audio filters support in libavfilter and avconv

 version 0.10:

@@ -27,13 +27,30 @@ API changes, most recent first:

 2012-03-26 - a67d9cf - lavfi 2.66.100

   Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.

-2012-xx-xx - xxxxxxx - lavc 54.13.1

+2012-05-15 - lavfi 2.17.0

+  Add support for audio filters

+  ac71230/a2cd9be - add video/audio buffer sink in a new installed

+                    header buffersink.h

+  720c6b7 - add av_buffersrc_write_frame(), deprecate

+            av_vsrc_buffer_add_frame()

+  ab16504 - add avfilter_copy_buf_props()

+  9453c9e - add extended_data to AVFilterBuffer

+  1b8c927 - add avfilter_get_audio_buffer_ref_from_arrays()

+

+2012-05-09 - lavu 51.30.0 - samplefmt.h

+  142e740 - add av_samples_copy()

+  6d7f617 - add av_samples_set_silence()

+

+2012-05-09 - a5117a2 - lavc 54.13.1

   For audio formats with fixed frame size, the last frame

   no longer needs to be padded with silence, libavcodec

   will handle this internally (effectively all encoders

   behave as if they had CODEC_CAP_SMALL_LAST_FRAME set).

-2012-xx-xx - xxxxxxx - lavr 0.0.1

+2012-05-07 - 828bd08 - lavc 54.13.0 - avcodec.h

+  Add sample_rate and channel_layout fields to AVFrame.

+

+2012-05-01 - 4010d72 - lavr 0.0.1

   Change AV_MIX_COEFF_TYPE_Q6 to AV_MIX_COEFF_TYPE_Q8.

 2012-04-25 - 3527a73 - lavu 51.29.0 - cpu.h

@@ -499,6 +499,11 @@ Set the audio codec. This is an alias for @code{-codec:a}.

 @item -sample_fmt[:@var{stream_specifier}] @var{sample_fmt} (@emph{output,per-stream})

 Set the audio sample format. Use @code{-sample_fmts} to get a list

 of supported sample formats.

+@item -af @var{filter_graph} (@emph{output})

+@var{filter_graph} is a description of the filter graph to apply to

+the input audio.

+Use the option "-filters" to show all the available filters (including

+also sources and sinks).  This is an alias for @code{-filter:a}.

 @end table

 @section Advanced Audio options:

@@ -781,6 +786,7 @@ Audio sync method. "Stretches/squeezes" the audio stream to match the timestamps

 the parameter is the maximum samples per second by which the audio is changed.

 -async 1 is a special case where only the start of the audio stream is corrected

 without any later correction.

+This option has been deprecated. Use the @code{asyncts} audio filter instead.

 @item -copyts

 Copy timestamps from input to output.

 @item -copytb @var{mode}

@@ -211,6 +211,32 @@ amovie=input.mkv:si=5 [a5];

 [x3][a5] amerge" -c:a pcm_s16le output.mkv

 @end example

+@section aformat

+

+Convert the input audio to one of the specified formats. The framework will

+negotiate the most appropriate format to minimize conversions.

+

+The filter accepts the following named parameters:

+@table @option

+

+@item sample_fmts

+A comma-separated list of requested sample formats.

+

+@item sample_rates

+A comma-separated list of requested sample rates.

+

+@item channel_layouts

+A comma-separated list of requested channel layouts.

+

+@end table

+

+If a parameter is omitted, all values are allowed.

+

+For example to force the output to either unsigned 8-bit or signed 16-bit stereo:

+@example

+aformat=sample_fmts\=u8\,s16:channel_layouts\=stereo

+@end example

+

 @section anull

 Pass the audio source unchanged to the output.

@@ -502,6 +528,25 @@ volume=-12dB

 @end example

 @end itemize

+@section asyncts

+Synchronize audio data with timestamps by squeezing/stretching it and/or

+dropping samples/adding silence when needed.

+

+The filter accepts the following named parameters:

+@table @option

+

+@item compensate

+Enable stretching/squeezing the data to make it match the timestamps.

+

+@item min_delta

+Minimum difference between timestamps and audio data (in seconds) to trigger

+adding/dropping samples.

+

+@item max_comp

+Maximum compensation in samples per second.

+

+@end table

+

 @section resample

 Convert the audio sample format, sample rate and channel layout. This filter is

 not meant to be used directly.

@@ -721,6 +766,33 @@ anullsrc=r=48000:cl=4

 anullsrc=r=48000:cl=mono

 @end example

+@section abuffer

+Buffer audio frames, and make them available to the filter chain.

+

+This source is not intended to be part of user-supplied graph descriptions but

+for insertion by calling programs through the interface defined in

+@file{libavfilter/buffersrc.h}.

+

+It accepts the following named parameters:

+@table @option

+

+@item time_base

+Timebase which will be used for timestamps of submitted frames. It must be

+either a floating-point number or in @var{numerator}/@var{denominator} form.

+

+@item sample_rate

+Audio sample rate.

+

+@item sample_fmt

+Name of the sample format, as returned by @code{av_get_sample_fmt_name()}.

+

+@item channel_layout

+Channel layout of the audio data, in the form that can be accepted by

+@code{av_get_channel_layout()}.

+@end table

+

+All the parameters need to be explicitly defined.

+

 @c man end AUDIO SOURCES

 @chapter Audio Sinks

@@ -745,6 +817,13 @@ Null audio sink, do absolutely nothing with the input audio. It is

 mainly useful as a template and to be employed in analysis / debugging

 tools.

+@section abuffersink

+This sink is intended for programmatic use. Frames that arrive on this sink can

+be retrieved by the calling program using the interface defined in

+@file{libavfilter/buffersink.h}.

+

+This filter accepts no parameters.

+

 @c man end AUDIO SINKS

 @chapter Video Filters

@@ -1549,6 +1549,19 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)

     return 0;

 }

+static void close_input_file(AVFormatContext **ctx_ptr)

+{

+    int i;

+    AVFormatContext *fmt_ctx = *ctx_ptr;

+

+    /* close decoder for each stream */

+    for (i = 0; i < fmt_ctx->nb_streams; i++)

+        if (fmt_ctx->streams[i]->codec->codec_id != CODEC_ID_NONE)

+            avcodec_close(fmt_ctx->streams[i]->codec);

+

+    avformat_close_input(ctx_ptr);

+}

+

 #define PRINT_CHAPTER(name) do {                                        \

     if (do_show_ ## name) {                                             \

         writer_print_chapter_header(wctx, #name);                       \

@@ -1586,10 +1599,7 @@ static int probe_file(WriterContext *wctx, const char *filename)

         }

         PRINT_CHAPTER(streams);

         PRINT_CHAPTER(format);

-        for (i = 0; i < fmt_ctx->nb_streams; i++)

-            if (fmt_ctx->streams[i]->codec->codec_id != CODEC_ID_NONE)

-                avcodec_close(fmt_ctx->streams[i]->codec);

-        avformat_close_input(&fmt_ctx);

+        close_input_file(&fmt_ctx);

         av_freep(&nb_streams_frames);

         av_freep(&nb_streams_packets);

     }

@@ -1803,6 +1813,10 @@ int main(int argc, char **argv)

 end:

     av_freep(&print_format);

+

+    uninit_opts();

+    av_dict_free(&fmt_entries_to_show);

+

     avformat_network_deinit();

     return ret;

@@ -26,6 +26,7 @@

 #include <lame/lame.h>

+#include "libavutil/audioconvert.h"

 #include "libavutil/intreadwrite.h"

 #include "libavutil/log.h"

 #include "libavutil/opt.h"

@@ -76,13 +77,7 @@ static av_cold int mp3lame_encode_init(AVCodecContext *avctx)

     if ((s->gfp = lame_init()) == NULL)

         return AVERROR(ENOMEM);

-    /* channels */

-    if (avctx->channels > 2) {

-        av_log(avctx, AV_LOG_ERROR,

-               "Invalid number of channels %d, must be <= 2\n", avctx->channels);

-        ret =  AVERROR(EINVAL);

-        goto error;

-    }

+

     lame_set_num_channels(s->gfp, avctx->channels);

     lame_set_mode(s->gfp, avctx->channels > 1 ? JOINT_STEREO : MONO);

@@ -308,6 +303,8 @@ AVCodec ff_libmp3lame_encoder = {

                                                              AV_SAMPLE_FMT_S16,

                                                              AV_SAMPLE_FMT_NONE },

     .supported_samplerates = libmp3lame_sample_rates,

+    .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_MONO,

+                                                  AV_CH_LAYOUT_STEREO },

     .long_name             = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),

     .priv_class            = &libmp3lame_class,

     .defaults              = libmp3lame_defaults,

@@ -2,6 +2,7 @@ include $(SUBDIR)../config.mak

 NAME = avfilter

 FFLIBS = avutil swscale

+FFLIBS-$(CONFIG_ASYNCTS_FILTER) += avresample

 FFLIBS-$(CONFIG_RESAMPLE_FILTER) += avresample

 FFLIBS-$(CONFIG_ACONVERT_FILTER)             += swresample

@@ -25,6 +26,7 @@ OBJS = allfilters.o                                                     \

        audio.o                                                          \

        avfilter.o                                                       \

        avfiltergraph.o                                                  \

+       buffer.o                                                         \

        buffersink.o                                                     \

        defaults.o                                                       \

        drawutils.o                                                      \

@@ -34,6 +36,8 @@ OBJS = allfilters.o                                                     \

        src_buffer.o                                                     \

        transform.o                                                      \

        vf_scale.o                                                       \

+       video.o                                                          \

+

 OBJS-$(CONFIG_AVCODEC)                       += avcodec.o

 OBJS-$(CONFIG_AVFORMAT)                      += lavfutils.o

@@ -47,6 +51,7 @@ OBJS-$(CONFIG_ARESAMPLE_FILTER)              += af_aresample.o

 OBJS-$(CONFIG_ASHOWINFO_FILTER)              += af_ashowinfo.o

 OBJS-$(CONFIG_ASPLIT_FILTER)                 += af_asplit.o

 OBJS-$(CONFIG_ASTREAMSYNC_FILTER)            += af_astreamsync.o

+OBJS-$(CONFIG_ASYNCTS_FILTER)                += af_asyncts.o

 OBJS-$(CONFIG_EARWAX_FILTER)                 += af_earwax.o

 OBJS-$(CONFIG_PAN_FILTER)                    += af_pan.o

 OBJS-$(CONFIG_RESAMPLE_FILTER)               += af_resample.o

@@ -74,6 +74,7 @@ static int query_formats(AVFilterContext *ctx)

     AVFilterLink *inlink  = ctx->inputs[0];

     AVFilterLink *outlink = ctx->outputs[0];

     int out_packing = av_sample_fmt_is_planar(aconvert->out_sample_fmt);

+    AVFilterChannelLayouts *layouts;

     avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),

                          &inlink->out_formats);

@@ -85,15 +86,15 @@ static int query_formats(AVFilterContext *ctx)

         avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),

                              &outlink->in_formats);

-    avfilter_formats_ref(avfilter_make_all_channel_layouts(),

-                         &inlink->out_chlayouts);

+    ff_channel_layouts_ref(ff_all_channel_layouts(),

+                         &inlink->out_channel_layouts);

     if (aconvert->out_chlayout != 0) {

-        formats = NULL;

-        avfilter_add_format(&formats, aconvert->out_chlayout);

-        avfilter_formats_ref(formats, &outlink->in_chlayouts);

+        layouts = NULL;

+        ff_add_channel_layout(&layouts, aconvert->out_chlayout);

+        ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);

     } else

-        avfilter_formats_ref(avfilter_make_all_channel_layouts(),

-                             &outlink->in_chlayouts);

+        ff_channel_layouts_ref(ff_all_channel_layouts(),

+                             &outlink->in_channel_layouts);

     avfilter_formats_ref(avfilter_make_all_packing_formats(),

                          &inlink->out_packing);

@@ -25,72 +25,110 @@

 #include "libavutil/audioconvert.h"

 #include "libavutil/avstring.h"

-#include "avfilter.h"

+#include "libavutil/opt.h"

+

 #include "audio.h"

+#include "avfilter.h"

+#include "formats.h"

 #include "internal.h"

-typedef struct {

-    AVFilterFormats *formats, *chlayouts, *packing;

+typedef struct AFormatContext {

+    const AVClass   *class;

+

+    AVFilterFormats *formats;

+    AVFilterFormats *sample_rates;

+    AVFilterChannelLayouts *channel_layouts;

+

+    char *formats_str;

+    char *sample_rates_str;

+    char *channel_layouts_str;

 } AFormatContext;

+#define OFFSET(x) offsetof(AFormatContext, x)

+#define A AV_OPT_FLAG_AUDIO_PARAM

+static const AVOption options[] = {

+    { "sample_fmts",     "A comma-separated list of sample formats.",  OFFSET(formats_str),         AV_OPT_TYPE_STRING, .flags = A },

+    { "sample_rates",    "A comma-separated list of sample rates.",    OFFSET(sample_rates_str),    AV_OPT_TYPE_STRING, .flags = A },

+    { "channel_layouts", "A comma-separated list of channel layouts.", OFFSET(channel_layouts_str), AV_OPT_TYPE_STRING, .flags = A },

+    { NULL },

+};

+

+static const AVClass aformat_class = {

+    .class_name = "aformat filter",

+    .item_name  = av_default_item_name,

+    .option     = options,

+    .version    = LIBAVUTIL_VERSION_INT,

+};

+

+#define PARSE_FORMATS(str, type, list, add_to_list, get_fmt, none, desc)    \

+do {                                                                        \

+    char *next, *cur = str;                                                 \

+    while (cur) {                                                           \

+        type fmt;                                                           \

+        next = strchr(cur, ',');                                            \

+        if (next)                                                           \

+            *next++ = 0;                                                    \

+                                                                            \

+        if ((fmt = get_fmt(cur)) == none) {                                 \

+            av_log(ctx, AV_LOG_ERROR, "Error parsing " desc ": %s.\n", cur);\

+            ret = AVERROR(EINVAL);                                          \

+            goto fail;                                                      \

+        }                                                                   \

+        add_to_list(&list, fmt);                                            \

+                                                                            \

+        cur = next;                                                         \

+    }                                                                       \

+} while (0)

+

+static int get_sample_rate(const char *samplerate)

+{

+    int ret = strtol(samplerate, NULL, 0);

+    return FFMAX(ret, 0);

+}

+

 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)

 {

-    AFormatContext * const aformat = ctx->priv;

-    char *fmts_str = NULL, *fmt_str, *ptr = NULL;

-    int64_t fmt;

+    AFormatContext *s = ctx->priv;

     int ret;

-    if (!args)

-        goto arg_fail;

-

-#define ADD_FORMATS(all_formats, fmt_name, fmt_type, fmts_list) do {    \

-    fmts_str = av_get_token(&args, ":");                                \

-    if (!fmts_str || !*fmts_str)                                        \

-        goto arg_fail;                                                  \

-    if (!strcmp(fmts_str, "all")) {                                     \

-        aformat->fmts_list = all_formats;                               \

-    } else {                                                            \

-        for (fmt_str = fmts_str;                                        \

-             fmt_str = av_strtok(fmt_str, ",", &ptr); fmt_str = NULL) { \

-            if ((ret = ff_parse_##fmt_name((fmt_type *)&fmt,            \

-                                           fmt_str, ctx)) < 0) {        \

-                av_freep(&fmts_str);                                    \

-                return ret;                                             \

-            }                                                           \

-            avfilter_add_format(&aformat->fmts_list, fmt);              \

-        }                                                               \

-    }                                                                   \

-    av_freep(&fmts_str);                                                \

-    if (*args)                                                          \

-        args++;                                                         \

-} while (0)

+    if (!args) {

+        av_log(ctx, AV_LOG_ERROR, "No parameters supplied.\n");

+        return AVERROR(EINVAL);

+    }

-    ADD_FORMATS(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO), sample_format, int, formats);

-    ADD_FORMATS(avfilter_make_all_channel_layouts(), channel_layout, int64_t, chlayouts);

-    ADD_FORMATS(avfilter_make_all_packing_formats(), packing_format, int, packing);

+    s->class = &aformat_class;

+    av_opt_set_defaults(s);

-    return 0;

+    if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {

+        av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args);

+        return ret;

+    }

-arg_fail:

-    av_log(ctx, AV_LOG_ERROR, "Invalid arguments, they must be of the form "

-                              "sample_fmts:channel_layouts:packing_fmts\n");

-    av_freep(&fmts_str);

-    return AVERROR(EINVAL);

+    PARSE_FORMATS(s->formats_str, enum AVSampleFormat, s->formats,

+                  avfilter_add_format, av_get_sample_fmt, AV_SAMPLE_FMT_NONE, "sample format");

+    PARSE_FORMATS(s->sample_rates_str, int, s->sample_rates, avfilter_add_format,

+                  get_sample_rate, 0, "sample rate");

+    PARSE_FORMATS(s->channel_layouts_str, uint64_t, s->channel_layouts,

+                  ff_add_channel_layout, av_get_channel_layout, 0,

+                  "channel layout");

+

+fail:

+    av_opt_free(s);

+    return ret;

 }

 static int query_formats(AVFilterContext *ctx)

 {

-    AFormatContext * const aformat = ctx->priv;

+    AFormatContext *s = ctx->priv;

-    avfilter_set_common_sample_formats (ctx, aformat->formats);

-    avfilter_set_common_channel_layouts(ctx, aformat->chlayouts);

-    avfilter_set_common_packing_formats(ctx, aformat->packing);

-    return 0;

-}

+    avfilter_set_common_formats(ctx, s->formats ? s->formats :

+                                                  avfilter_all_formats(AVMEDIA_TYPE_AUDIO));

+    ff_set_common_samplerates(ctx, s->sample_rates ? s->sample_rates :

+                                                     ff_all_samplerates());

+    ff_set_common_channel_layouts(ctx, s->channel_layouts ? s->channel_layouts :

+                                                            ff_all_channel_layouts());

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

-{

-    ff_filter_samples(inlink->dst->outputs[0], insamplesref);

+    return 0;

 }

 AVFilter avfilter_af_aformat = {

@@ -100,11 +138,11 @@ AVFilter avfilter_af_aformat = {

     .query_formats = query_formats,

     .priv_size     = sizeof(AFormatContext),

-    .inputs        = (const AVFilterPad[]) {{ .name      = "default",

+    .inputs        = (AVFilterPad[]) {{ .name            = "default",

                                         .type            = AVMEDIA_TYPE_AUDIO,

-                                        .filter_samples  = filter_samples},

+                                        .filter_samples  = ff_null_filter_samples },

                                       { .name = NULL}},

-    .outputs       = (const AVFilterPad[]) {{ .name      = "default",

+    .outputs       = (AVFilterPad[]) {{ .name            = "default",

                                         .type            = AVMEDIA_TYPE_AUDIO},

                                       { .name = NULL}},

 };

@@ -56,17 +56,18 @@ static int query_formats(AVFilterContext *ctx)

     int64_t inlayout[2], outlayout;

     const int packing_fmts[] = { AVFILTER_PACKED, -1 };

     AVFilterFormats *formats;

+    AVFilterChannelLayouts *layouts;

     int i;

     for (i = 0; i < 2; i++) {

-        if (!ctx->inputs[i]->in_chlayouts ||

-            !ctx->inputs[i]->in_chlayouts->format_count) {

+        if (!ctx->inputs[i]->in_channel_layouts ||

+            !ctx->inputs[i]->in_channel_layouts->nb_channel_layouts) {

             av_log(ctx, AV_LOG_ERROR,

                    "No channel layout for input %d\n", i + 1);

             return AVERROR(EINVAL);

         }

-        inlayout[i] = ctx->inputs[i]->in_chlayouts->formats[0];

-        if (ctx->inputs[i]->in_chlayouts->format_count > 1) {

+        inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0];

+        if (ctx->inputs[i]->in_channel_layouts->nb_channel_layouts > 1) {

             char buf[256];

             av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]);

             av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1);

@@ -101,13 +102,13 @@ static int query_formats(AVFilterContext *ctx)

     formats = avfilter_make_format_list(packing_fmts);

     avfilter_set_common_packing_formats(ctx, formats);

     for (i = 0; i < 2; i++) {

-        formats = NULL;

-        avfilter_add_format(&formats, inlayout[i]);

-        avfilter_formats_ref(formats, &ctx->inputs[i]->out_chlayouts);

+        layouts = NULL;

+        ff_add_channel_layout(&layouts, inlayout[i]);

+        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);

     }

-    formats = NULL;

-    avfilter_add_format(&formats, outlayout);

-    avfilter_formats_ref(formats, &ctx->outputs[0]->in_chlayouts);

+    layouts = NULL;

+    ff_add_channel_layout(&layouts, outlayout);

+    ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);

     return 0;

 }

@@ -56,6 +56,42 @@ static av_cold void uninit(AVFilterContext *ctx)

     swr_free(&aresample->swr);

 }

+static int query_formats(AVFilterContext *ctx)

+{

+    AResampleContext *aresample = ctx->priv;

+

+    AVFilterLink *inlink  = ctx->inputs[0];

+    AVFilterLink *outlink = ctx->outputs[0];

+

+    AVFilterFormats        *in_formats      = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);

+    AVFilterFormats        *out_formats     = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);

+    AVFilterFormats        *in_samplerates  = ff_all_samplerates();

+    AVFilterFormats        *out_samplerates;

+

+

+    AVFilterChannelLayouts *in_layouts      = ff_all_channel_layouts();

+    AVFilterChannelLayouts *out_layouts     = ff_all_channel_layouts();

+

+    avfilter_formats_ref(in_formats,  &inlink->out_formats);

+    avfilter_formats_ref(out_formats, &outlink->in_formats);

+

+    avfilter_formats_ref(in_samplerates,  &inlink->out_samplerates);

+

+    ff_channel_layouts_ref(in_layouts,  &inlink->out_channel_layouts);

+    ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);

+

+    if(aresample->out_rate > 0) {

+        int sample_rates[] = { aresample->out_rate, -1 };

+        ff_set_common_samplerates(ctx, avfilter_make_format_list(sample_rates));

+    } else {

+        out_samplerates = ff_all_samplerates();

+        avfilter_formats_ref(out_samplerates, &outlink->in_samplerates);

+    }

+

+    return 0;

+}

+

+

 static int config_output(AVFilterLink *outlink)

 {

     int ret;

@@ -113,6 +149,7 @@ AVFilter avfilter_af_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",

@@ -81,6 +81,7 @@ static int query_formats(AVFilterContext *ctx)

 {

     int i;

     AVFilterFormats *formats;

+    AVFilterChannelLayouts *layouts;

     for (i = 0; i < 2; i++) {

         formats = ctx->inputs[i]->in_formats;

@@ -89,9 +90,9 @@ static int query_formats(AVFilterContext *ctx)

         formats = ctx->inputs[i]->in_packing;

         avfilter_formats_ref(formats, &ctx->inputs[i]->out_packing);

         avfilter_formats_ref(formats, &ctx->outputs[i]->in_packing);

-        formats = ctx->inputs[i]->in_chlayouts;

-        avfilter_formats_ref(formats, &ctx->inputs[i]->out_chlayouts);

-        avfilter_formats_ref(formats, &ctx->outputs[i]->in_chlayouts);

+        layouts = ctx->inputs[i]->in_channel_layouts;

+        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);

+        ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts);

     }

     return 0;

 }

new file mode 100644

@@ -0,0 +1,237 @@

+/*

+ * This file is part of Libav.

+ *

+ * Libav 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.

+ *

+ * Libav 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 Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "libavresample/avresample.h"

+#include "libavutil/audio_fifo.h"

+#include "libavutil/mathematics.h"

+#include "libavutil/opt.h"

+#include "libavutil/samplefmt.h"

+

+#include "audio.h"

+#include "avfilter.h"

+

+typedef struct ASyncContext {

+    const AVClass *class;

+

+    AVAudioResampleContext *avr;

+    int64_t pts;            ///< timestamp in samples of the first sample in fifo

+    int min_delta;          ///< pad/trim min threshold in samples

+

+    /* options */

+    int resample;

+    float min_delta_sec;

+    int max_comp;

+} ASyncContext;

+

+#define OFFSET(x) offsetof(ASyncContext, x)

+#define A AV_OPT_FLAG_AUDIO_PARAM

+static const AVOption options[] = {

+    { "compensate", "Stretch/squeeze the data to make it match the timestamps", OFFSET(resample),      AV_OPT_TYPE_INT,   { 0 },   0, 1,       A },

+    { "min_delta",  "Minimum difference between timestamps and audio data "

+                    "(in seconds) to trigger padding/trimmin the data.",        OFFSET(min_delta_sec), AV_OPT_TYPE_FLOAT, { 0.1 }, 0, INT_MAX, A },

+    { "max_comp",   "Maximum compensation in samples per second.",              OFFSET(max_comp),      AV_OPT_TYPE_INT,   { 500 }, 0, INT_MAX, A },

+    { NULL },

+};

+

+static const AVClass async_class = {

+    .class_name = "asyncts filter",

+    .item_name  = av_default_item_name,

+    .option     = options,

+    .version    = LIBAVUTIL_VERSION_INT,

+};

+

+static int init(AVFilterContext *ctx, const char *args, void *opaque)

+{

+    ASyncContext *s = ctx->priv;

+    int ret;

+

+    s->class = &async_class;

+    av_opt_set_defaults(s);

+

+    if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {

+        av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args);

+        return ret;

+    }

+    av_opt_free(s);

+

+    s->pts = AV_NOPTS_VALUE;

+

+    return 0;

+}

+

+static void uninit(AVFilterContext *ctx)

+{

+    ASyncContext *s = ctx->priv;

+

+    if (s->avr) {

+        avresample_close(s->avr);

+        avresample_free(&s->avr);

+    }

+}

+

+static int config_props(AVFilterLink *link)

+{

+    ASyncContext *s = link->src->priv;

+    int ret;

+

+    s->min_delta = s->min_delta_sec * link->sample_rate;

+    link->time_base = (AVRational){1, link->sample_rate};

+

+    s->avr = avresample_alloc_context();

+    if (!s->avr)

+        return AVERROR(ENOMEM);

+

+    av_opt_set_int(s->avr,  "in_channel_layout", link->channel_layout, 0);

+    av_opt_set_int(s->avr, "out_channel_layout", link->channel_layout, 0);

+    av_opt_set_int(s->avr,  "in_sample_fmt",     link->format,         0);

+    av_opt_set_int(s->avr, "out_sample_fmt",     link->format,         0);

+    av_opt_set_int(s->avr,  "in_sample_rate",    link->sample_rate,    0);

+    av_opt_set_int(s->avr, "out_sample_rate",    link->sample_rate,    0);

+

+    if (s->resample)

+        av_opt_set_int(s->avr, "force_resampling", 1, 0);

+

+    if ((ret = avresample_open(s->avr)) < 0)

+        return ret;

+

+    return 0;

+}

+

+static int request_frame(AVFilterLink *link)

+{

+    AVFilterContext *ctx = link->src;

+    ASyncContext      *s = ctx->priv;

+    int ret = avfilter_request_frame(ctx->inputs[0]);

+    int nb_samples;

+

+    /* flush the fifo */

+    if (ret == AVERROR_EOF && (nb_samples = avresample_get_delay(s->avr))) {

+        AVFilterBufferRef *buf = ff_get_audio_buffer(link, AV_PERM_WRITE,

+                                                     nb_samples);

+        if (!buf)

+            return AVERROR(ENOMEM);

+        avresample_convert(s->avr, (void**)buf->extended_data, buf->linesize[0],

+                           nb_samples, NULL, 0, 0);

+        buf->pts = s->pts;

+        ff_filter_samples(link, buf);

+        return 0;

+    }

+

+    return ret;

+}

+

+static void write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)

+{

+    avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,

+                       buf->linesize[0], buf->audio->nb_samples);

+    avfilter_unref_buffer(buf);

+}

+

+/* get amount of data currently buffered, in samples */

+static int64_t get_delay(ASyncContext *s)

+{

+    return avresample_available(s->avr) + avresample_get_delay(s->avr);

+}

+

+static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

+{

+    AVFilterContext  *ctx = inlink->dst;

+    ASyncContext       *s = ctx->priv;

+    AVFilterLink *outlink = ctx->outputs[0];

+    int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);

+    int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :

+                  av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);

+    int out_size;

+    int64_t delta;

+

+    /* buffer data until we get the first timestamp */

+    if (s->pts == AV_NOPTS_VALUE) {

+        if (pts != AV_NOPTS_VALUE) {

+            s->pts = pts - get_delay(s);

+        }

+        write_to_fifo(s, buf);

+        return;

+    }

+

+    /* now wait for the next timestamp */

+    if (pts == AV_NOPTS_VALUE) {

+        write_to_fifo(s, buf);

+        return;

+    }

+

+    /* when we have two timestamps, compute how many samples would we have

+     * to add/remove to get proper sync between data and timestamps */

+    delta    = pts - s->pts - get_delay(s);

+    out_size = avresample_available(s->avr);

+

+    if (labs(delta) > s->min_delta) {

+        av_log(ctx, AV_LOG_VERBOSE, "Discontinuity - %"PRId64" samples.\n", delta);

+        out_size += delta;

+    } else if (s->resample) {

+        int comp = av_clip(delta, -s->max_comp, s->max_comp);

+        av_log(ctx, AV_LOG_VERBOSE, "Compensating %d samples per second.\n", comp);

+        avresample_set_compensation(s->avr, delta, inlink->sample_rate);

+    }

+

+    if (out_size > 0) {

+        AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,

+                                                         out_size);

+        if (!buf_out)

+            return;

+

+        avresample_read(s->avr, (void**)buf_out->extended_data, out_size);

+        buf_out->pts = s->pts;

+

+        if (delta > 0) {

+            av_samples_set_silence(buf_out->extended_data, out_size - delta,

+                                   delta, nb_channels, buf->format);

+        }

+        ff_filter_samples(outlink, buf_out);

+    } else {

+        av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "

+               "whole buffer.\n");

+    }

+

+    /* drain any remaining buffered data */

+    avresample_read(s->avr, NULL, avresample_available(s->avr));

+

+    s->pts = pts - avresample_get_delay(s->avr);

+    avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,

+                       buf->linesize[0], buf->audio->nb_samples);

+    avfilter_unref_buffer(buf);

+}

+

+AVFilter avfilter_af_asyncts = {

+    .name        = "asyncts",

+    .description = NULL_IF_CONFIG_SMALL("Sync audio data to timestamps"),

+

+    .init        = init,

+    .uninit      = uninit,

+

+    .priv_size   = sizeof(ASyncContext),

+

+    .inputs      = (const AVFilterPad[]) {{ .name           = "default",

+                                            .type           = AVMEDIA_TYPE_AUDIO,

+                                            .filter_samples = filter_samples },

+                                          { NULL }},

+    .outputs     = (const AVFilterPad[]) {{ .name           = "default",

+                                            .type           = AVMEDIA_TYPE_AUDIO,

+                                            .config_props   = config_props,

+                                            .request_frame  = request_frame },

+                                          { NULL }},

+};

@@ -32,6 +32,7 @@

 #include "libavutil/audioconvert.h"

 #include "avfilter.h"

 #include "audio.h"

+#include "formats.h"

 #define NUMTAPS 64

@@ -76,15 +77,19 @@ typedef struct {

 static int query_formats(AVFilterContext *ctx)

 {

+    int sample_rates[] = { 44100, -1 };