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

 - drawtext video filter: fontconfig support

 - ffmpeg -benchmark_all option

 - super2xsai filter ported from libmpcodecs

+- add libavresample audio conversion library for compatibility

 version 0.10:

@@ -31,6 +31,7 @@ ALLMANPAGES = $(BASENAMES:%=%.1)

 FFLIBS-$(CONFIG_AVDEVICE) += avdevice

 FFLIBS-$(CONFIG_AVFILTER) += avfilter

 FFLIBS-$(CONFIG_AVFORMAT) += avformat

+FFLIBS-$(CONFIG_AVRESAMPLE) += avresample

 FFLIBS-$(CONFIG_AVCODEC)  += avcodec

 FFLIBS-$(CONFIG_POSTPROC) += postproc

 FFLIBS-$(CONFIG_SWRESAMPLE)+= swresample

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

 #include "libavformat/avformat.h"

 #include "libavfilter/avfilter.h"

 #include "libavdevice/avdevice.h"

+#include "libavresample/avresample.h"

 #include "libswscale/swscale.h"

 #include "libswresample/swresample.h"

 #if CONFIG_POSTPROC

@@ -633,7 +634,8 @@ static int warned_cfg = 0;

         const char *indent = flags & INDENT? "  " : "";                 \

         if (flags & SHOW_VERSION) {                                     \

             unsigned int version = libname##_version();                 \

-            av_log(NULL, level, "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",\

+            av_log(NULL, level,                                         \

+                   "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \

                    indent, #libname,                                    \

                    LIB##LIBNAME##_VERSION_MAJOR,                        \

                    LIB##LIBNAME##_VERSION_MINOR,                        \

@@ -662,6 +664,7 @@ static void print_all_libs_info(int flags, int level)

     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);

     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);

     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);

+//    PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);

     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);

     PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);

 #if CONFIG_POSTPROC

@@ -20,7 +20,7 @@ $(foreach VAR,$(SILENT),$(eval override $(VAR) = @$($(VAR))))

 $(eval INSTALL = @$(call ECHO,INSTALL,$$(^:$(SRC_DIR)/%=%)); $(INSTALL))

 endif

-ALLFFLIBS = avcodec avdevice avfilter avformat avutil postproc swscale swresample

+ALLFFLIBS = avcodec avdevice avfilter avformat avresample avutil postproc swscale swresample

 # NASM requires -I path terminated with /

 IFLAGS     := -I. -I$(SRC_PATH)/

@@ -112,6 +112,7 @@ Component options:

   --disable-swscale        disable libswscale build

   --disable-postproc       disable libpostproc build

   --disable-avfilter       disable video filter support [no]

+  --disable-avresample     disable libavresample build [no]

   --disable-pthreads       disable pthreads [auto]

   --disable-w32threads     disable Win32 threads [auto]

   --disable-os2threads     disable OS/2 threads [auto]

@@ -1013,6 +1014,7 @@ CONFIG_LIST="

     avdevice

     avfilter

     avformat

+    avresample

     avisynth

     bzlib

     crystalhd

@@ -1870,6 +1872,7 @@ enable avcodec

 enable avdevice

 enable avfilter

 enable avformat

+enable avresample

 enable avutil

 enable postproc

 enable stripping

@@ -3724,6 +3727,7 @@ get_version LIBAVCODEC  libavcodec/version.h

 get_version LIBAVDEVICE libavdevice/avdevice.h

 get_version LIBAVFILTER libavfilter/version.h

 get_version LIBAVFORMAT libavformat/version.h

+get_version LIBAVRESAMPLE libavresample/version.h

 get_version LIBAVUTIL   libavutil/avutil.h

 get_version LIBPOSTPROC libpostproc/postprocess.h

 get_version LIBSWRESAMPLE libswresample/swresample.h

@@ -3869,5 +3873,6 @@ pkgconfig_generate libavformat "FFmpeg container format library" "$LIBAVFORMAT_V

 pkgconfig_generate libavdevice "FFmpeg device handling library" "$LIBAVDEVICE_VERSION" "$extralibs" "$libavdevice_pc_deps"

 pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "$libavfilter_pc_deps"

 pkgconfig_generate libpostproc "FFmpeg postprocessing library" "$LIBPOSTPROC_VERSION" "" "libavutil = $LIBAVUTIL_VERSION"

+pkgconfig_generate libavresample "Libav audio resampling library" "$LIBAVRESAMPLE_VERSION" "$extralibs"

 pkgconfig_generate libswscale "FFmpeg image rescaling library" "$LIBSWSCALE_VERSION" "$LIBM" "libavutil = $LIBAVUTIL_VERSION"

 pkgconfig_generate libswresample "FFmpeg audio rescaling library" "$LIBSWRESAMPLE_VERSION" "$LIBM" "libavutil = $LIBAVUTIL_VERSION"

@@ -6,6 +6,7 @@ libavcodec:  2012-01-27

 libavdevice: 2011-04-18

 libavfilter: 2011-04-18

 libavformat: 2012-01-27

+libavresample: 2012-xx-xx

 libpostproc: 2011-04-18

 libswscale:  2011-06-20

 libavutil:   2011-04-18

@@ -22,6 +23,9 @@ 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 - lavr 0.0.0

+  Add libavresample audio conversion library

+

 2012-xx-xx - xxxxxxx - lavu 51.28.0 - audio_fifo.h

   Add audio FIFO functions:

     av_audio_fifo_free()

@@ -36,7 +36,6 @@

 #include "libavdevice/avdevice.h"

 #include "libswscale/swscale.h"

 #include "libavutil/opt.h"

-#include "libavcodec/audioconvert.h"

 #include "libavutil/audioconvert.h"

 #include "libavutil/parseutils.h"

 #include "libavutil/samplefmt.h"

@@ -300,6 +299,7 @@ typedef struct OutputStream {

     int audio_channels_mapped;           ///< number of channels in audio_channels_map

     int resample_sample_fmt;

     int resample_channels;

+    uint64_t resample_channel_layout;

     int resample_sample_rate;

     float rematrix_volume;

     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */

@@ -1525,7 +1525,7 @@ static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,

 }

 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,

-                                  int nb_samples)

+                                  int nb_samples, int *buf_linesize)

 {

     int64_t audio_buf_samples;

     int audio_buf_size;

@@ -1538,7 +1538,7 @@ static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,

     if (audio_buf_samples > INT_MAX)

         return AVERROR(EINVAL);

-    audio_buf_size = av_samples_get_buffer_size(NULL, enc->channels,

+    audio_buf_size = av_samples_get_buffer_size(buf_linesize, enc->channels,

                                                 audio_buf_samples,

                                                 enc->sample_fmt, 0);

     if (audio_buf_size < 0)

@@ -1557,7 +1557,7 @@ static void do_audio_out(AVFormatContext *s, OutputStream *ost,

     uint8_t *buftmp;

     int64_t size_out;

-    int frame_bytes, resample_changed;

+    int frame_bytes, resample_changed, ret;

     AVCodecContext *enc = ost->st->codec;

     AVCodecContext *dec = ist->st->codec;

     int osize = av_get_bytes_per_sample(enc->sample_fmt);

@@ -1566,37 +1566,46 @@ static void do_audio_out(AVFormatContext *s, OutputStream *ost,

     int size     = decoded_frame->nb_samples * dec->channels * isize;

     int planes   = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;

     int i;

+    int out_linesize = 0;

+    int buf_linesize = decoded_frame->linesize[0];

     av_assert0(planes <= AV_NUM_DATA_POINTERS);

     for(i=0; i<planes; i++)

         buf[i]= decoded_frame->data[i];

+

     get_default_channel_layouts(ost, ist);

-    if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples) < 0) {

+    if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples, &out_linesize) < 0) {

         av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");

         exit_program(1);

     }

-    if (enc->channels != dec->channels

-     || enc->sample_fmt != dec->sample_fmt

-     || enc->sample_rate!= dec->sample_rate

-    )

+    if (audio_sync_method > 1                      ||

+        enc->channels       != dec->channels       ||

+        enc->channel_layout != dec->channel_layout ||

+        enc->sample_rate    != dec->sample_rate    ||

+        dec->sample_fmt     != enc->sample_fmt)

         ost->audio_resample = 1;

     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||

                        ost->resample_channels    != dec->channels   ||

+                       ost->resample_channel_layout != dec->channel_layout ||

                        ost->resample_sample_rate != dec->sample_rate;

     if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {

+

         if (resample_changed) {

-            av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",

+            av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:0x%"PRIx64" to rate:%d fmt:%s ch:%d chl:0x%"PRIx64"\n",

                    ist->file_index, ist->st->index,

-                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,

-                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);

+                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt),

+                   ost->resample_channels, ost->resample_channel_layout,

+                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt),

+                   dec->channels, dec->channel_layout);

             ost->resample_sample_fmt  = dec->sample_fmt;

             ost->resample_channels    = dec->channels;

+            ost->resample_channel_layout = dec->channel_layout;

             ost->resample_sample_rate = dec->sample_rate;

             swr_free(&ost->swr);

         }

@@ -1604,6 +1613,7 @@ static void do_audio_out(AVFormatContext *s, OutputStream *ost,

         if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&

             ost->resample_sample_fmt  == enc->sample_fmt &&

             ost->resample_channels    == enc->channels   &&

+            ost->resample_channel_layout == enc->channel_layout &&

             ost->resample_sample_rate == enc->sample_rate) {

             //ost->swr = NULL;

             ost->audio_resample = 0;

@@ -1673,7 +1683,7 @@ static void do_audio_out(AVFormatContext *s, OutputStream *ost,

                         exit_program(1);

                     }

-                    if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta) < 0) {

+                    if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta, &out_linesize) < 0) {

                         av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");

                         exit_program(1);

                     }

@@ -1686,11 +1696,11 @@ static void do_audio_out(AVFormatContext *s, OutputStream *ost,

                         buf[i] = t;

                     }

                     size += byte_delta;

+                    buf_linesize = allocated_async_buf_size;

                     av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);

                 }

             } else if (audio_sync_method > 1) {

                 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);

-                av_assert0(ost->audio_resample);

                 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",

                        delta, comp, enc->sample_rate);

 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));

@@ -1703,8 +1713,10 @@ static void do_audio_out(AVFormatContext *s, OutputStream *ost,

     if (ost->audio_resample || ost->audio_channels_mapped) {

         buftmp = audio_buf;

-        size_out = swr_convert(ost->swr, (      uint8_t*[]){buftmp}, allocated_audio_buf_size / (enc->channels * osize),

-                                         buf, size / (dec->channels * isize));

+        size_out = swr_convert(ost->swr, (      uint8_t*[]){buftmp},

+                                      allocated_audio_buf_size / (enc->channels * osize),

+                                      buf,

+                                      size / (dec->channels * isize));

         if (size_out < 0) {

             av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");

             exit_program(1);

@@ -3078,6 +3090,7 @@ static int transcode_init(void)

                 if (!ost->fifo) {

                     return AVERROR(ENOMEM);

                 }

+

                 if (!codec->sample_rate)

                     codec->sample_rate = icodec->sample_rate;

                 choose_sample_rate(ost->st, ost->enc);

@@ -3110,13 +3123,15 @@ static int transcode_init(void)

                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)

                     codec->channel_layout = 0;

-                ost->audio_resample       = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;

-                ost->audio_resample      |=    codec->sample_fmt     != icodec->sample_fmt

-                                            || codec->channel_layout != icodec->channel_layout;

-                icodec->request_channels  = codec->channels;

+

+//                 ost->audio_resample       = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;

+//                 ost->audio_resample      |=    codec->sample_fmt     != icodec->sample_fmt

+//                                             || codec->channel_layout != icodec->channel_layout;

+                icodec->request_channels  = codec-> channels;

                 ost->resample_sample_fmt  = icodec->sample_fmt;

                 ost->resample_sample_rate = icodec->sample_rate;

                 ost->resample_channels    = icodec->channels;

+                ost->resample_channel_layout = icodec->channel_layout;

                 break;

             case AVMEDIA_TYPE_VIDEO:

                 if (!ost->filter) {

new file mode 100644

@@ -0,0 +1,15 @@

+NAME = avresample

+FFLIBS = avutil

+

+HEADERS = avresample.h                                                  \

+          version.h

+

+OBJS = audio_convert.o                                                  \

+       audio_data.o                                                     \

+       audio_mix.o                                                      \

+       audio_mix_matrix.o                                               \

+       options.o                                                        \

+       resample.o                                                       \

+       utils.o

+

+TESTPROGS = avresample

new file mode 100644

@@ -0,0 +1,334 @@

+/*

+ * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>

+ * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>

+ *

+ * 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 <stdint.h>

+

+#include "config.h"

+#include "libavutil/libm.h"

+#include "libavutil/log.h"

+#include "libavutil/mem.h"

+#include "libavutil/samplefmt.h"

+#include "audio_convert.h"

+#include "audio_data.h"

+

+enum ConvFuncType {

+    CONV_FUNC_TYPE_FLAT,

+    CONV_FUNC_TYPE_INTERLEAVE,

+    CONV_FUNC_TYPE_DEINTERLEAVE,

+};

+

+typedef void (conv_func_flat)(uint8_t *out, const uint8_t *in, int len);

+

+typedef void (conv_func_interleave)(uint8_t *out, uint8_t *const *in,

+                                    int len, int channels);

+

+typedef void (conv_func_deinterleave)(uint8_t **out, const uint8_t *in, int len,

+                                      int channels);

+

+struct AudioConvert {

+    AVAudioResampleContext *avr;

+    enum AVSampleFormat in_fmt;

+    enum AVSampleFormat out_fmt;

+    int channels;

+    int planes;

+    int ptr_align;

+    int samples_align;

+    int has_optimized_func;

+    const char *func_descr;

+    const char *func_descr_generic;

+    enum ConvFuncType func_type;

+    conv_func_flat         *conv_flat;

+    conv_func_flat         *conv_flat_generic;

+    conv_func_interleave   *conv_interleave;

+    conv_func_interleave   *conv_interleave_generic;

+    conv_func_deinterleave *conv_deinterleave;

+    conv_func_deinterleave *conv_deinterleave_generic;

+};

+

+void ff_audio_convert_set_func(AudioConvert *ac, enum AVSampleFormat out_fmt,

+                               enum AVSampleFormat in_fmt, int channels,

+                               int ptr_align, int samples_align,

+                               const char *descr, void *conv)

+{

+    int found = 0;

+

+    switch (ac->func_type) {

+    case CONV_FUNC_TYPE_FLAT:

+        if (av_get_packed_sample_fmt(ac->in_fmt)  == in_fmt &&

+            av_get_packed_sample_fmt(ac->out_fmt) == out_fmt) {

+            ac->conv_flat     = conv;

+            ac->func_descr    = descr;

+            ac->ptr_align     = ptr_align;

+            ac->samples_align = samples_align;

+            if (ptr_align == 1 && samples_align == 1) {

+                ac->conv_flat_generic  = conv;

+                ac->func_descr_generic = descr;

+            } else {

+                ac->has_optimized_func = 1;

+            }

+            found = 1;

+        }

+        break;

+    case CONV_FUNC_TYPE_INTERLEAVE:

+        if (ac->in_fmt == in_fmt && ac->out_fmt == out_fmt &&

+            (!channels || ac->channels == channels)) {

+            ac->conv_interleave = conv;

+            ac->func_descr      = descr;

+            ac->ptr_align       = ptr_align;

+            ac->samples_align   = samples_align;

+            if (ptr_align == 1 && samples_align == 1) {

+                ac->conv_interleave_generic = conv;

+                ac->func_descr_generic      = descr;

+            } else {

+                ac->has_optimized_func = 1;

+            }

+            found = 1;

+        }

+        break;

+    case CONV_FUNC_TYPE_DEINTERLEAVE:

+        if (ac->in_fmt == in_fmt && ac->out_fmt == out_fmt &&

+            (!channels || ac->channels == channels)) {

+            ac->conv_deinterleave = conv;

+            ac->func_descr        = descr;

+            ac->ptr_align         = ptr_align;

+            ac->samples_align     = samples_align;

+            if (ptr_align == 1 && samples_align == 1) {

+                ac->conv_deinterleave_generic = conv;

+                ac->func_descr_generic        = descr;

+            } else {

+                ac->has_optimized_func = 1;

+            }

+            found = 1;

+        }

+        break;

+    }

+    if (found) {

+        av_log(ac->avr, AV_LOG_DEBUG, "audio_convert: found function: %-4s "

+               "to %-4s (%s)\n", av_get_sample_fmt_name(ac->in_fmt),

+               av_get_sample_fmt_name(ac->out_fmt), descr);

+    }

+}

+

+#define CONV_FUNC_NAME(dst_fmt, src_fmt) conv_ ## src_fmt ## _to_ ## dst_fmt

+

+#define CONV_LOOP(otype, expr)                                              \

+    do {                                                                    \

+        *(otype *)po = expr;                                                \

+        pi += is;                                                           \

+        po += os;                                                           \

+    } while (po < end);                                                     \

+

+#define CONV_FUNC_FLAT(ofmt, otype, ifmt, itype, expr)                      \

+static void CONV_FUNC_NAME(ofmt, ifmt)(uint8_t *out, const uint8_t *in,     \

+                                       int len)                             \

+{                                                                           \

+    int is       = sizeof(itype);                                           \

+    int os       = sizeof(otype);                                           \

+    const uint8_t *pi = in;                                                 \

+    uint8_t       *po = out;                                                \

+    uint8_t *end = out + os * len;                                          \

+    CONV_LOOP(otype, expr)                                                  \

+}

+

+#define CONV_FUNC_INTERLEAVE(ofmt, otype, ifmt, itype, expr)                \

+static void CONV_FUNC_NAME(ofmt, ifmt)(uint8_t *out, const uint8_t **in,    \

+                                       int len, int channels)               \

+{                                                                           \

+    int ch;                                                                 \

+    int out_bps = sizeof(otype);                                            \

+    int is      = sizeof(itype);                                            \

+    int os      = channels * out_bps;                                       \

+    for (ch = 0; ch < channels; ch++) {                                     \

+        const uint8_t *pi = in[ch];                                         \

+        uint8_t       *po = out + ch * out_bps;                             \

+        uint8_t      *end = po + os * len;                                  \

+        CONV_LOOP(otype, expr)                                              \

+    }                                                                       \

+}

+

+#define CONV_FUNC_DEINTERLEAVE(ofmt, otype, ifmt, itype, expr)              \

+static void CONV_FUNC_NAME(ofmt, ifmt)(uint8_t **out, const uint8_t *in,    \

+                                       int len, int channels)               \

+{                                                                           \

+    int ch;                                                                 \

+    int in_bps = sizeof(itype);                                             \

+    int is     = channels * in_bps;                                         \

+    int os     = sizeof(otype);                                             \

+    for (ch = 0; ch < channels; ch++) {                                     \

+        const uint8_t *pi = in  + ch * in_bps;                              \

+        uint8_t       *po = out[ch];                                        \

+        uint8_t      *end = po + os * len;                                  \

+        CONV_LOOP(otype, expr)                                              \

+    }                                                                       \

+}

+

+#define CONV_FUNC_GROUP(ofmt, otype, ifmt, itype, expr) \

+CONV_FUNC_FLAT(        ofmt,      otype, ifmt,      itype, expr) \

+CONV_FUNC_INTERLEAVE(  ofmt,      otype, ifmt ## P, itype, expr) \

+CONV_FUNC_DEINTERLEAVE(ofmt ## P, otype, ifmt,      itype, expr)

+

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_U8,  uint8_t,  *(const uint8_t *)pi)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) <<  8)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) << 24)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) * (1.0f / (1 << 7)))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) * (1.0  / (1 << 7)))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_S16, int16_t, (*(const int16_t *)pi >> 8) + 0x80)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi << 16)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi * (1.0f / (1 << 15)))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi * (1.0  / (1 << 15)))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_S32, int32_t, (*(const int32_t *)pi >> 24) + 0x80)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi >> 16)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi * (1.0f / (1U << 31)))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi * (1.0  / (1U << 31)))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_FLT, float,   av_clip_uint8(  lrintf(*(const float *)pi * (1  <<  7)) + 0x80))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float,   av_clip_int16(  lrintf(*(const float *)pi * (1  << 15))))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float,   av_clipl_int32(llrintf(*(const float *)pi * (1U << 31))))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_FLT, float,   *(const float *)pi)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_FLT, float,   *(const float *)pi)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_DBL, double,  av_clip_uint8(  lrint(*(const double *)pi * (1  <<  7)) + 0x80))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double,  av_clip_int16(  lrint(*(const double *)pi * (1  << 15))))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double,  av_clipl_int32(llrint(*(const double *)pi * (1U << 31))))

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_DBL, double,  *(const double *)pi)

+CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_DBL, double,  *(const double *)pi)

+

+#define SET_CONV_FUNC_GROUP(ofmt, ifmt)                                                             \

+ff_audio_convert_set_func(ac, ofmt,      ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt)); \

+ff_audio_convert_set_func(ac, ofmt ## P, ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt ## P, ifmt)); \

+ff_audio_convert_set_func(ac, ofmt,      ifmt ## P, 0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt ## P));

+

+static void set_generic_function(AudioConvert *ac)

+{

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_U8)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_S16)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_S32)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_FLT)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_DBL)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL)

+    SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL)

+}

+

+AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr,

+                                     enum AVSampleFormat out_fmt,

+                                     enum AVSampleFormat in_fmt,

+                                     int channels)

+{

+    AudioConvert *ac;

+    int in_planar, out_planar;

+

+    ac = av_mallocz(sizeof(*ac));

+    if (!ac)

+        return NULL;

+

+    ac->avr      = avr;

+    ac->out_fmt  = out_fmt;

+    ac->in_fmt   = in_fmt;

+    ac->channels = channels;

+

+    in_planar  = av_sample_fmt_is_planar(in_fmt);

+    out_planar = av_sample_fmt_is_planar(out_fmt);

+

+    if (in_planar == out_planar) {

+        ac->func_type = CONV_FUNC_TYPE_FLAT;

+        ac->planes    = in_planar ? ac->channels : 1;

+    } else if (in_planar)

+        ac->func_type = CONV_FUNC_TYPE_INTERLEAVE;

+    else

+        ac->func_type = CONV_FUNC_TYPE_DEINTERLEAVE;

+

+    set_generic_function(ac);

+

+    if (ARCH_X86)

+        ff_audio_convert_init_x86(ac);

+

+    return ac;

+}

+

+int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in, int len)

+{

+    int use_generic = 1;

+

+    /* determine whether to use the optimized function based on pointer and

+       samples alignment in both the input and output */

+    if (ac->has_optimized_func) {

+        int ptr_align     = FFMIN(in->ptr_align,     out->ptr_align);

+        int samples_align = FFMIN(in->samples_align, out->samples_align);

+        int aligned_len   = FFALIGN(len, ac->samples_align);

+        if (!(ptr_align % ac->ptr_align) && samples_align >= aligned_len) {

+            len = aligned_len;

+            use_generic = 0;

+        }

+    }

+    av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (%s)\n", len,

+            av_get_sample_fmt_name(ac->in_fmt),

+            av_get_sample_fmt_name(ac->out_fmt),

+            use_generic ? ac->func_descr_generic : ac->func_descr);

+

+    switch (ac->func_type) {

+    case CONV_FUNC_TYPE_FLAT: {

+        int p;

+        if (!in->is_planar)

+            len *= in->channels;

+        if (use_generic) {

+            for (p = 0; p < ac->planes; p++)

+                ac->conv_flat_generic(out->data[p], in->data[p], len);

+        } else {

+            for (p = 0; p < ac->planes; p++)

+                ac->conv_flat(out->data[p], in->data[p], len);

+        }

+        break;

+    }

+    case CONV_FUNC_TYPE_INTERLEAVE:

+        if (use_generic)

+            ac->conv_interleave_generic(out->data[0], in->data, len, ac->channels);

+        else

+            ac->conv_interleave(out->data[0], in->data, len, ac->channels);

+        break;

+    case CONV_FUNC_TYPE_DEINTERLEAVE:

+        if (use_generic)

+            ac->conv_deinterleave_generic(out->data, in->data[0], len, ac->channels);

+        else

+            ac->conv_deinterleave(out->data, in->data[0], len, ac->channels);

+        break;

+    }

+

+    out->nb_samples = in->nb_samples;

+    return 0;

+}

new file mode 100644

@@ -0,0 +1,87 @@

+/*

+ * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>

+ *

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

+ */

+

+#ifndef AVRESAMPLE_AUDIO_CONVERT_H

+#define AVRESAMPLE_AUDIO_CONVERT_H

+

+#include "libavutil/samplefmt.h"

+#include "avresample.h"

+#include "audio_data.h"

+

+typedef struct AudioConvert AudioConvert;

+

+/**

+ * Set conversion function if the parameters match.

+ *

+ * This compares the parameters of the conversion function to the parameters

+ * in the AudioConvert context. If the parameters do not match, no changes are

+ * made to the active functions. If the parameters do match and the alignment

+ * is not constrained, the function is set as the generic conversion function.

+ * If the parameters match and the alignment is constrained, the function is

+ * set as the optimized conversion function.

+ *

+ * @param ac             AudioConvert context

+ * @param out_fmt        output sample format

+ * @param in_fmt         input sample format

+ * @param channels       number of channels, or 0 for any number of channels

+ * @param ptr_align      buffer pointer alignment, in bytes

+ * @param sample_align   buffer size alignment, in samples

+ * @param descr          function type description (e.g. "C" or "SSE")

+ * @param conv           conversion function pointer

+ */

+void ff_audio_convert_set_func(AudioConvert *ac, enum AVSampleFormat out_fmt,

+                               enum AVSampleFormat in_fmt, int channels,

+                               int ptr_align, int samples_align,

+                               const char *descr, void *conv);

+

+/**

+ * Allocate and initialize AudioConvert context for sample format conversion.

+ *

+ * @param avr      AVAudioResampleContext

+ * @param out_fmt  output sample format

+ * @param in_fmt   input sample format

+ * @param channels number of channels

+ * @return         newly-allocated AudioConvert context

+ */

+AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr,

+                                     enum AVSampleFormat out_fmt,

+                                     enum AVSampleFormat in_fmt,

+                                     int channels);

+

+/**

+ * Convert audio data from one sample format to another.

+ *

+ * For each call, the alignment of the input and output AudioData buffers are

+ * examined to determine whether to use the generic or optimized conversion

+ * function (when available).

+ *

+ * @param ac     AudioConvert context

+ * @param out    output audio data

+ * @param in     input audio data

+ * @param len    number of samples to convert

+ * @return       0 on success, negative AVERROR code on failure

+ */

+int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in, int len);

+

+/* arch-specific initialization functions */

+

+void ff_audio_convert_init_x86(AudioConvert *ac);

+

+#endif /* AVRESAMPLE_AUDIO_CONVERT_H */

new file mode 100644

@@ -0,0 +1,345 @@

+/*

+ * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>

+ *

+ * 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 <stdint.h>

+

+#include "libavutil/mem.h"

+#include "audio_data.h"

+

+static const AVClass audio_data_class = {

+    .class_name = "AudioData",

+    .item_name  = av_default_item_name,

+    .version    = LIBAVUTIL_VERSION_INT,

+};

+

+/*

+ * Calculate alignment for data pointers.

+ */

+static void calc_ptr_alignment(AudioData *a)

+{

+    int p;

+    int min_align = 128;

+

+    for (p = 0; p < a->planes; p++) {

+        int cur_align = 128;

+        while ((intptr_t)a->data[p] % cur_align)

+            cur_align >>= 1;

+        if (cur_align < min_align)

+            min_align = cur_align;

+    }

+    a->ptr_align = min_align;

+}

+

+int ff_audio_data_set_channels(AudioData *a, int channels)

+{

+    if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS ||

+        channels > a->allocated_channels)

+        return AVERROR(EINVAL);

+

+    a->channels  = channels;

+    a->planes    = a->is_planar ? channels : 1;

+

+    calc_ptr_alignment(a);

+

+    return 0;

+}

+

+int ff_audio_data_init(AudioData *a, void **src, int plane_size, int channels,

+                       int nb_samples, enum AVSampleFormat sample_fmt,

+                       int read_only, const char *name)

+{

+    int p;

+

+    memset(a, 0, sizeof(*a));

+    a->class = &audio_data_class;

+

+    if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS) {

+        av_log(a, AV_LOG_ERROR, "invalid channel count: %d\n", channels);

+        return AVERROR(EINVAL);

+    }

+

+    a->sample_size = av_get_bytes_per_sample(sample_fmt);

+    if (!a->sample_size) {

+        av_log(a, AV_LOG_ERROR, "invalid sample format\n");

+        return AVERROR(EINVAL);

+    }

+    a->is_planar = av_sample_fmt_is_planar(sample_fmt);

+    a->planes    = a->is_planar ? channels : 1;

+    a->stride    = a->sample_size * (a->is_planar ? 1 : channels);

+

+    for (p = 0; p < (a->is_planar ? channels : 1); p++) {

+        if (!src[p]) {

+            av_log(a, AV_LOG_ERROR, "invalid NULL pointer for src[%d]\n", p);

+            return AVERROR(EINVAL);

+        }

+        a->data[p] = src[p];

+    }

+    a->allocated_samples  = nb_samples * !read_only;

+    a->nb_samples         = nb_samples;

+    a->sample_fmt         = sample_fmt;

+    a->channels           = channels;

+    a->allocated_channels = channels;

+    a->read_only          = read_only;

+    a->allow_realloc      = 0;

+    a->name               = name ? name : "{no name}";

+

+    calc_ptr_alignment(a);

+    a->samples_align = plane_size / a->stride;

+

+    return 0;

+}

+

+AudioData *ff_audio_data_alloc(int channels, int nb_samples,

+                               enum AVSampleFormat sample_fmt, const char *name)

+{

+    AudioData *a;

+    int ret;

+

+    if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS)

+        return NULL;

+

+    a = av_mallocz(sizeof(*a));

+    if (!a)

+        return NULL;

+

+    a->sample_size = av_get_bytes_per_sample(sample_fmt);

+    if (!a->sample_size) {

+        av_free(a);

+        return NULL;

+    }

+    a->is_planar = av_sample_fmt_is_planar(sample_fmt);

+    a->planes    = a->is_planar ? channels : 1;

+    a->stride    = a->sample_size * (a->is_planar ? 1 : channels);

+

+    a->class              = &audio_data_class;

+    a->sample_fmt         = sample_fmt;

+    a->channels           = channels;

+    a->allocated_channels = channels;

+    a->read_only          = 0;

+    a->allow_realloc      = 1;

+    a->name               = name ? name : "{no name}";

+

+    if (nb_samples > 0) {

+        ret = ff_audio_data_realloc(a, nb_samples);

+        if (ret < 0) {

+            av_free(a);

+            return NULL;