@@ -33,6 +33,7 @@ FFLIBS-$(CONFIG_AVFILTER) += avfilter

 FFLIBS-$(CONFIG_AVFORMAT) += avformat

 FFLIBS-$(CONFIG_AVCODEC)  += avcodec

 FFLIBS-$(CONFIG_POSTPROC) += postproc

+FFLIBS-$(CONFIG_SWRESAMPLE)+= swresample

 FFLIBS-$(CONFIG_SWSCALE)  += swscale

 FFLIBS := avutil

@@ -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

+ALLFFLIBS = avcodec avdevice avfilter avformat avutil postproc swscale swresample

 # NASM requires -I path terminated with /

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

@@ -89,6 +89,7 @@ Configuration options:

   --disable-avdevice       disable libavdevice build

   --disable-avcodec        disable libavcodec build

   --disable-avformat       disable libavformat build

+  --disable-swresample     disable libswresample build

   --disable-swscale        disable libswscale build

   --disable-postproc       disable libpostproc build

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

@@ -1037,6 +1038,7 @@ CONFIG_LIST="

     small

     sram

     static

+    swresample

     swscale

     swscale_alpha

     thumb

@@ -1603,7 +1605,7 @@ avformat_deps="avcodec"

 postproc_deps="gpl"

 # programs

-ffmpeg_deps="avcodec avformat swscale"

+ffmpeg_deps="avcodec avformat swscale swresample"

 ffmpeg_select="buffer_filter buffersink_filter"

 avconv_deps="avcodec avformat swscale"

 avconv_select="buffer_filter"

@@ -1766,6 +1768,7 @@ enable postproc

 enable protocols

 enable static

 enable stripping

+enable swresample

 enable swscale

 enable swscale_alpha

@@ -3143,7 +3146,7 @@ enabled extra_warnings && check_cflags -Winline

 # add some linker flags

 check_ldflags -Wl,--warn-common

-check_ldflags -Wl,-rpath-link=libpostproc:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil

+check_ldflags -Wl,-rpath-link=libpostproc:libswresample:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil

 test_ldflags -Wl,-Bsymbolic && append SHFLAGS -Wl,-Bsymbolic

 echo "X{};" > $TMPV

@@ -45,6 +45,7 @@

 #include "libavutil/avstring.h"

 #include "libavutil/libm.h"

 #include "libavformat/os_support.h"

+#include "libswresample/swresample.h"

 #include "libavformat/ffm.h" // not public API

@@ -229,15 +230,14 @@ typedef struct OutputStream {

     /* audio only */

     int audio_resample;

-    ReSampleContext *resample; /* for audio resampling */

     int resample_sample_fmt;

     int resample_channels;

     int resample_sample_rate;

-    int reformat_pair;

-    AVAudioConvert *reformat_ctx;

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

     FILE *logfile;

+    struct SwrContext *swr;

+

 #if CONFIG_AVFILTER

     AVFilterContext *output_video_filter;

     AVFilterContext *input_video_filter;

@@ -843,14 +843,15 @@ need_realloc:

         exit_program(1);

     }

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

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

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

         ost->audio_resample = 1;

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

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

                        ost->resample_sample_rate != dec->sample_rate;

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

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

         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",

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

@@ -859,24 +860,29 @@ need_realloc:

             ost->resample_sample_fmt  = dec->sample_fmt;

             ost->resample_channels    = dec->channels;

             ost->resample_sample_rate = dec->sample_rate;

-            if (ost->resample)

-                audio_resample_close(ost->resample);

+            swr_free(&ost->swr);

         }

         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */

         if (audio_sync_method <= 1 &&

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

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

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

-            ost->resample = NULL;

+            //ost->swr = NULL;

             ost->audio_resample = 0;

         } else {

-            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)

-                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");

-            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,

-                                                   enc->sample_rate, dec->sample_rate,

-                                                   enc->sample_fmt,  dec->sample_fmt,

-                                                   16, 10, 0, 0.8);

-            if (!ost->resample) {

+            ost->swr = swr_alloc2(ost->swr,

+                                  enc->channel_layout, enc->sample_fmt, enc->sample_rate,

+                                  dec->channel_layout, dec->sample_fmt, dec->sample_rate,

+                                  0, NULL);

+            av_set_int(ost->swr, "ich", dec->channels);

+            av_set_int(ost->swr, "och", enc->channels);

+            if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);

+            if(ost->swr && swr_init(ost->swr) < 0){

+                fprintf(stderr, "swr_init() failed\n");

+                swr_free(&ost->swr);

+            }

+

+            if (!ost->swr) {

                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",

                         dec->channels, dec->sample_rate,

                         enc->channels, enc->sample_rate);

@@ -885,21 +891,7 @@ need_realloc:

         }

     }

-#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))

-    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&

-        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {

-        if (ost->reformat_ctx)

-            av_audio_convert_free(ost->reformat_ctx);

-        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,

-                                                   dec->sample_fmt, 1, NULL, 0);

-        if (!ost->reformat_ctx) {

-            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",

-                av_get_sample_fmt_name(dec->sample_fmt),

-                av_get_sample_fmt_name(enc->sample_fmt));

-            exit_program(1);

-        }

-        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);

-    }

+    av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);

     if(audio_sync_method){

         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts

@@ -941,7 +933,7 @@ need_realloc:

                 if(verbose > 2)

                     fprintf(stderr, "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));

-                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);

+                swr_compensate(ost->swr, comp, enc->sample_rate);

             }

         }

     }else

@@ -950,30 +942,15 @@ need_realloc:

     if (ost->audio_resample) {

         buftmp = audio_buf;

-        size_out = audio_resample(ost->resample,

-                                  (short *)buftmp, (short *)buf,

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

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

+                                         (const uint8_t*[]){buf   }, size / (dec->channels * isize));

         size_out = size_out * enc->channels * osize;

     } else {

         buftmp = buf;

         size_out = size;

     }

-    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {

-        const void *ibuf[6]= {buftmp};

-        void *obuf[6]= {audio_buf};

-        int istride[6]= {isize};

-        int ostride[6]= {osize};

-        int len= size_out/istride[0];

-        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

-            printf("av_audio_convert() failed\n");

-            if (exit_on_error)

-                exit_program(1);

-            return;

-        }

-        buftmp = audio_buf;

-        size_out = len*osize;

-    }

+    av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);

     /* now encode as many frames as possible */

     if (enc->frame_size > 1) {

@@ -2133,7 +2110,6 @@ static int transcode_init(OutputFile *output_files, int nb_output_files,

                 if (!ost->fifo) {

                     return AVERROR(ENOMEM);

                 }

-                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);

                 if (!codec->sample_rate) {

                     codec->sample_rate = icodec->sample_rate;

                 }

@@ -2149,6 +2125,8 @@ static int transcode_init(OutputFile *output_files, int nb_output_files,

                 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;

                 ist->decoding_needed = 1;

                 ost->encoding_needed = 1;

@@ -2679,10 +2657,7 @@ static int transcode(OutputFile *output_files, int nb_output_files,

                 av_free(ost->forced_kf_pts);

                 if (ost->video_resample)

                     sws_freeContext(ost->img_resample_ctx);

-                if (ost->resample)

-                    audio_resample_close(ost->resample);

-                if (ost->reformat_ctx)

-                    av_audio_convert_free(ost->reformat_ctx);

+                swr_free(&ost->swr);

                 av_dict_free(&ost->opts);

             }

         }

new file mode 100644

@@ -0,0 +1,12 @@

+include $(SUBDIR)../config.mak

+

+NAME = swresample

+FFLIBS = avutil

+

+HEADERS = swresample.h

+

+OBJS = swresample.o audioconvert.o resample2.o rematrix.o

+

+TESTPROGS = swresample_test

+

+include $(SUBDIR)../subdir.mak

new file mode 100644

@@ -0,0 +1,113 @@

+/*

+ * audio conversion

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

+ *

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

+ * audio conversion

+ * @author Michael Niedermayer <michaelni@gmx.at>

+ */

+

+#include "libavutil/avstring.h"

+#include "libavutil/avassert.h"

+#include "libavutil/libm.h"

+#include "libavutil/samplefmt.h"

+#include "audioconvert.h"

+

+

+struct AVAudioConvert {

+    int channels;

+    int fmt_pair;

+};

+

+AVAudioConvert *swr_audio_convert_alloc(enum AVSampleFormat out_fmt,

+                                        enum AVSampleFormat in_fmt,

+                                        int channels, int flags)

+{

+    AVAudioConvert *ctx;

+    ctx = av_malloc(sizeof(AVAudioConvert));

+    if (!ctx)

+        return NULL;

+    ctx->channels = channels;

+    ctx->fmt_pair = out_fmt + AV_SAMPLE_FMT_NB*in_fmt;

+    return ctx;

+}

+

+void swr_audio_convert_free(AVAudioConvert **ctx)

+{

+    av_freep(ctx);

+}

+

+int swr_audio_convert(AVAudioConvert *ctx, AudioData *out, AudioData*in, int len)

+{

+    int ch;

+

+    av_assert0(ctx->channels == out->ch_count);

+

+    //FIXME optimize common cases

+

+    for(ch=0; ch<ctx->channels; ch++){

+        const int is= (in ->planar ? 1 : in->ch_count) * in->bps;

+        const int os= (out->planar ? 1 :out->ch_count) *out->bps;

+        const uint8_t *pi= in ->ch[ch];

+        uint8_t       *po= out->ch[ch];

+        uint8_t *end= po + os*len;

+        if(!po)

+            continue;

+

+#define CONV(ofmt, otype, ifmt, expr)\

+if(ctx->fmt_pair == ofmt + AV_SAMPLE_FMT_NB*ifmt){\

+    do{\

+        *(otype*)po = expr; pi += is; po += os;\

+    }while(po < end);\

+}

+

+//FIXME put things below under ifdefs so we do not waste space for cases no codec will need

+//FIXME rounding ?

+

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

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

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

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

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

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

+        else CONV(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S16,  *(const int16_t*)pi)

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

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

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

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

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

+        else CONV(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S32,  *(const int32_t*)pi)

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

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

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

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

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

+        else CONV(AV_SAMPLE_FMT_FLT, float  , AV_SAMPLE_FMT_FLT, *(const float*)pi)

+        else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_FLT, *(const float*)pi)

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

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

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

+        else CONV(AV_SAMPLE_FMT_FLT, float  , AV_SAMPLE_FMT_DBL, *(const double*)pi)

+        else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_DBL, *(const double*)pi)

+        else return -1;

+    }

+    return 0;

+}

new file mode 100644

@@ -0,0 +1,65 @@

+/*

+ * audio conversion

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

+ * Copyright (c) 2008 Peter Ross

+ *

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

+ */

+

+#ifndef SWR_AUDIOCONVERT_H

+#define SWR_AUDIOCONVERT_H

+

+/**

+ * @file

+ * Audio format conversion routines

+ */

+

+

+#include "swresample_internal.h"

+#include "libavutil/cpu.h"

+#include "libavutil/audioconvert.h"

+

+struct AVAudioConvert;

+typedef struct AVAudioConvert AVAudioConvert;

+

+/**

+ * Create an audio sample format converter context

+ * @param out_fmt Output sample format

+ * @param in_fmt Input sample format

+ * @param channels Number of channels

+ * @param flags See AV_CPU_FLAG_xx

+ * @return NULL on error

+ */

+AVAudioConvert *swr_audio_convert_alloc(enum AVSampleFormat out_fmt,

+                                        enum AVSampleFormat in_fmt,

+                                        int channels, int flags);

+

+/**

+ * Free audio sample format converter context.

+ * and set the pointer to NULL

+ */

+void swr_audio_convert_free(AVAudioConvert **ctx);

+

+/**

+ * Convert between audio sample formats

+ * @param[in] out array of output buffers for each channel. set to NULL to ignore processing of the given channel.

+ * @param[in] in array of input buffers for each channel

+ * @param len length of audio frame size (measured in samples)

+ */

+int swr_audio_convert(AVAudioConvert *ctx, AudioData *out, AudioData *in, int len);

+

+#endif /* AVCODEC_AUDIOCONVERT_H */

new file mode 100644

@@ -0,0 +1,271 @@

+/*

+ * Copyright (C) 2011 Michael Niedermayer (michaelni@gmx.at)

+ *

+ * This file is part of libswresample

+ *

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

+ *

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

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

+ */

+

+#include "swresample_internal.h"

+#include "libavutil/audioconvert.h"

+#include "libavutil/avassert.h"

+

+#define SAMPLE float

+#define RENAME(x) x ## _float

+#include "rematrix_template.c"

+#undef SAMPLE

+#undef RENAME

+

+#define SAMPLE int16_t

+#define RENAME(x) x ## _s16

+#include "rematrix_template.c"

+

+

+#define FRONT_LEFT             0

+#define FRONT_RIGHT            1

+#define FRONT_CENTER           2

+#define LOW_FREQUENCY          3

+#define BACK_LEFT              4

+#define BACK_RIGHT             5

+#define FRONT_LEFT_OF_CENTER   6

+#define FRONT_RIGHT_OF_CENTER  7

+#define BACK_CENTER            8

+#define SIDE_LEFT              9

+#define SIDE_RIGHT             10

+#define TOP_CENTER             11

+#define TOP_FRONT_LEFT         12

+#define TOP_FRONT_CENTER       13

+#define TOP_FRONT_RIGHT        14

+#define TOP_BACK_LEFT          15

+#define TOP_BACK_CENTER        16

+#define TOP_BACK_RIGHT         17

+

+static int even(int64_t layout){

+    if(!layout) return 1;

+    if(layout&(layout-1)) return 1;

+    return 0;

+}

+

+static int sane_layout(int64_t layout){

+    if(!(layout & AV_CH_LAYOUT_SURROUND)) // at least 1 front speaker

+        return 0;

+    if(!even(layout & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT))) // no asymetric front

+        return 0;

+    if(!even(layout & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)))   // no asymetric side

+        return 0;

+    if(!even(layout & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)))

+        return 0;

+    if(!even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)))

+        return 0;

+    if(av_get_channel_layout_nb_channels(layout) >= SWR_CH_MAX)

+        return 0;

+

+    return 1;

+}

+

+int swr_rematrix_init(SwrContext *s){

+    int i, j, in_i, out_i;

+    float matrix[64][64]={0};

+    int64_t unaccounted= s->in_ch_layout & ~s->out_ch_layout;

+    float maxcoef=0;

+

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

+        if(s->in_ch_layout & s->out_ch_layout & (1LL<<i))

+            matrix[i][i]= 1.0;

+    }

+

+    if(!sane_layout(s->in_ch_layout)){

+        av_log(s, AV_LOG_ERROR, "Input channel layout isnt supported\n");

+        return AVERROR(EINVAL);

+    }

+    if(!sane_layout(s->out_ch_layout)){

+        av_log(s, AV_LOG_ERROR, "Output channel layout isnt supported\n");

+        return AVERROR(EINVAL);

+    }

+

+//FIXME implement dolby surround

+//FIXME implement full ac3

+

+

+    if(unaccounted & AV_CH_FRONT_CENTER){

+        if((s->out_ch_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO){

+            matrix[ FRONT_LEFT][FRONT_CENTER]+= sqrt(0.5);

+            matrix[FRONT_RIGHT][FRONT_CENTER]+= sqrt(0.5);

+        }else

+            av_assert0(0);

+    }

+    if(unaccounted & AV_CH_LAYOUT_STEREO){

+        if(s->out_ch_layout & AV_CH_FRONT_CENTER){

+            matrix[FRONT_CENTER][ FRONT_LEFT]+= sqrt(0.5);

+            matrix[FRONT_CENTER][FRONT_RIGHT]+= sqrt(0.5);

+            if(s->in_ch_layout & AV_CH_FRONT_CENTER)

+                matrix[FRONT_CENTER][ FRONT_CENTER] = s->clev*sqrt(2);

+        }else

+            av_assert0(0);

+    }

+

+    if(unaccounted & AV_CH_BACK_CENTER){

+        if(s->out_ch_layout & AV_CH_BACK_LEFT){

+            matrix[ BACK_LEFT][BACK_CENTER]+= sqrt(0.5);

+            matrix[BACK_RIGHT][BACK_CENTER]+= sqrt(0.5);

+        }else if(s->out_ch_layout & AV_CH_SIDE_LEFT){

+            matrix[ SIDE_LEFT][BACK_CENTER]+= sqrt(0.5);

+            matrix[SIDE_RIGHT][BACK_CENTER]+= sqrt(0.5);

+        }else if(s->out_ch_layout & AV_CH_FRONT_LEFT){

+            matrix[ FRONT_LEFT][BACK_CENTER]+= s->slev*sqrt(0.5);

+            matrix[FRONT_RIGHT][BACK_CENTER]+= s->slev*sqrt(0.5);

+        }else if(s->out_ch_layout & AV_CH_FRONT_CENTER){

+            matrix[ FRONT_CENTER][BACK_CENTER]+= s->slev*sqrt(0.5);

+        }else

+            av_assert0(0);

+    }

+    if(unaccounted & AV_CH_BACK_LEFT){

+        if(s->out_ch_layout & AV_CH_BACK_CENTER){

+            matrix[BACK_CENTER][ BACK_LEFT]+= sqrt(0.5);

+            matrix[BACK_CENTER][BACK_RIGHT]+= sqrt(0.5);

+        }else if(s->out_ch_layout & AV_CH_SIDE_LEFT){

+            if(s->in_ch_layout & AV_CH_SIDE_LEFT){

+                matrix[ SIDE_LEFT][ BACK_LEFT]+= sqrt(0.5);

+                matrix[SIDE_RIGHT][BACK_RIGHT]+= sqrt(0.5);

+            }else{

+            matrix[ SIDE_LEFT][ BACK_LEFT]+= 1.0;

+            matrix[SIDE_RIGHT][BACK_RIGHT]+= 1.0;

+            }

+        }else if(s->out_ch_layout & AV_CH_FRONT_LEFT){

+            matrix[ FRONT_LEFT][ BACK_LEFT]+= s->slev;

+            matrix[FRONT_RIGHT][BACK_RIGHT]+= s->slev;

+        }else if(s->out_ch_layout & AV_CH_FRONT_CENTER){

+            matrix[ FRONT_CENTER][BACK_LEFT ]+= s->slev*sqrt(0.5);

+            matrix[ FRONT_CENTER][BACK_RIGHT]+= s->slev*sqrt(0.5);

+        }else

+            av_assert0(0);

+    }

+

+    if(unaccounted & AV_CH_SIDE_LEFT){

+        if(s->out_ch_layout & AV_CH_BACK_LEFT){

+            matrix[ BACK_LEFT][ SIDE_LEFT]+= 1.0;

+            matrix[BACK_RIGHT][SIDE_RIGHT]+= 1.0;

+        }else if(s->out_ch_layout & AV_CH_BACK_CENTER){

+            matrix[BACK_CENTER][ SIDE_LEFT]+= sqrt(0.5);

+            matrix[BACK_CENTER][SIDE_RIGHT]+= sqrt(0.5);

+        }else if(s->out_ch_layout & AV_CH_FRONT_LEFT){

+            matrix[ FRONT_LEFT][ SIDE_LEFT]+= s->slev;

+            matrix[FRONT_RIGHT][SIDE_RIGHT]+= s->slev;

+        }else if(s->out_ch_layout & AV_CH_FRONT_CENTER){

+            matrix[ FRONT_CENTER][SIDE_LEFT ]+= s->slev*sqrt(0.5);

+            matrix[ FRONT_CENTER][SIDE_RIGHT]+= s->slev*sqrt(0.5);

+        }else

+            av_assert0(0);

+    }

+

+    if(unaccounted & AV_CH_FRONT_LEFT_OF_CENTER){

+        if(s->out_ch_layout & AV_CH_FRONT_LEFT){

+            matrix[ FRONT_LEFT][ FRONT_LEFT_OF_CENTER]+= 1.0;

+            matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER]+= 1.0;

+        }else if(s->out_ch_layout & AV_CH_FRONT_CENTER){

+            matrix[ FRONT_CENTER][ FRONT_LEFT_OF_CENTER]+= sqrt(0.5);

+            matrix[ FRONT_CENTER][FRONT_RIGHT_OF_CENTER]+= sqrt(0.5);

+        }else

+            av_assert0(0);

+    }

+

+    //FIXME quantize for integeres

+    for(out_i=i=0; i<64; i++){

+        double sum=0;

+        int in_i=0;

+        int ch_in=0;

+        for(j=0; j<64; j++){

+            s->matrix[out_i][in_i]= matrix[i][j];

+            if(matrix[i][j]){

+                s->matrix_ch[out_i][++ch_in]= in_i;

+                sum += fabs(matrix[i][j]);

+            }

+            if(s->in_ch_layout & (1ULL<<j))

+                in_i++;

+        }

+        s->matrix_ch[out_i][0]= ch_in;

+        maxcoef= FFMAX(maxcoef, sum);

+        if(s->out_ch_layout & (1ULL<<i))

+            out_i++;

+    }

+    if((   s->out_sample_fmt < AV_SAMPLE_FMT_FLT

+        || s->int_sample_fmt < AV_SAMPLE_FMT_FLT) && maxcoef > 1.0){

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

+            for(j=0; j<SWR_CH_MAX; j++)

+                s->matrix[i][j] /= maxcoef;

+    }

+        for(i=0; i<av_get_channel_layout_nb_channels(s->out_ch_layout); i++){

+            for(j=0; j<av_get_channel_layout_nb_channels(s->in_ch_layout); j++){

+                av_log(NULL, AV_LOG_ERROR, "%f ", s->matrix[i][j]);

+            }

+            av_log(NULL, AV_LOG_ERROR, "\n");

+        }

+    return 0;

+}

+

+int swr_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy){

+    int out_i, in_i, i, j;

+

+av_assert0(out->ch_count == av_get_channel_layout_nb_channels(s->out_ch_layout));

+av_assert0(in ->ch_count == av_get_channel_layout_nb_channels(s-> in_ch_layout));

+

+    for(out_i=0; out_i<out->ch_count; out_i++){

+        switch(s->matrix_ch[out_i][0]){

+        case 1:

+            in_i= s->matrix_ch[out_i][1];

+            if(mustcopy || s->matrix[out_i][in_i]!=1.0){

+                if(s->int_sample_fmt == AV_SAMPLE_FMT_FLT){

+                    copy_float(out->ch[out_i], in->ch[in_i], s->matrix[out_i][in_i], len);

+                }else

+                    copy_s16  (out->ch[out_i], in->ch[in_i], s->matrix[out_i][in_i], len);

+            }else{

+                out->ch[out_i]= in->ch[in_i];

+            }

+            break;

+        case 2:

+            if(s->int_sample_fmt == AV_SAMPLE_FMT_FLT){

+                sum2_float(out->ch[out_i], in->ch[ s->matrix_ch[out_i][1] ],           in->ch[ s->matrix_ch[out_i][2] ],

+                                 s->matrix[out_i][ s->matrix_ch[out_i][1] ], s->matrix[out_i][ s->matrix_ch[out_i][2] ],

+                           len);

+            }else{

+                sum2_s16  (out->ch[out_i], in->ch[ s->matrix_ch[out_i][1] ],           in->ch[ s->matrix_ch[out_i][2] ],

+                                 s->matrix[out_i][ s->matrix_ch[out_i][1] ], s->matrix[out_i][ s->matrix_ch[out_i][2] ],

+                           len);

+            }

+            break;

+        default:

+            if(s->int_sample_fmt == AV_SAMPLE_FMT_FLT){

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

+                    float v=0;

+                    for(j=0; j<s->matrix_ch[out_i][0]; j++){

+                        in_i= s->matrix_ch[out_i][1+j];

+                        v+= ((float*)in->ch[in_i])[i] * s->matrix[out_i][in_i];

+                    }

+                    ((float*)out->ch[out_i])[i]= v;

+                }

+            }else{

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

+                    int v=0;

+                    for(j=0; j<s->matrix_ch[out_i][0]; j++){

+                        in_i= s->matrix_ch[out_i][1+j];

+                        v+= ((int16_t*)in->ch[in_i])[i] * s->matrix[out_i][in_i]; //FIXME use int16 coeffs

+                    }

+                    ((int16_t*)out->ch[out_i])[i]= v;

+                }

+            }

+        }

+    }

+    return 0;

+}

new file mode 100644

@@ -0,0 +1,38 @@

+/*

+ * Copyright (C) 2011 Michael Niedermayer (michaelni@gmx.at)

+ *

+ * This file is part of libswresample

+ *

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

+ *

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

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

+ */

+

+

+static void RENAME(sum2)(SAMPLE *out, const SAMPLE *in1, const SAMPLE *in2, float coeff1, float coeff2, int len){

+    int i;

+

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

+        out[i] = coeff1*in1[i] + coeff2*in2[i]; //FIXME better int16

+}

+

+static void RENAME(copy)(SAMPLE *out, const SAMPLE *in, float coeff, int len){

+    if(coeff == 1.0){

+        memcpy(out, in, sizeof(SAMPLE)*len);

+    }else{

+        int i;

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

+            out[i] = coeff*in[i]; //FIXME better int16

+    }

+}

+

new file mode 100644

@@ -0,0 +1,352 @@

+/*

+ * audio resampling

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

+ *

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

+ * audio resampling

+ * @author Michael Niedermayer <michaelni@gmx.at>

+ */

+

+#include "libavutil/log.h"

+#include "swresample_internal.h"

+

+#ifndef CONFIG_RESAMPLE_HP

+#define FILTER_SHIFT 15

+

+#define FELEM int16_t

+#define FELEM2 int32_t

+#define FELEML int64_t

+#define FELEM_MAX INT16_MAX

+#define FELEM_MIN INT16_MIN

+#define WINDOW_TYPE 9

+#elif !defined(CONFIG_RESAMPLE_AUDIOPHILE_KIDDY_MODE)

+#define FILTER_SHIFT 30

+

+#define FELEM int32_t

+#define FELEM2 int64_t

+#define FELEML int64_t

+#define FELEM_MAX INT32_MAX

+#define FELEM_MIN INT32_MIN

+#define WINDOW_TYPE 12

+#else

+#define FILTER_SHIFT 0

+

+#define FELEM double

+#define FELEM2 double

+#define FELEML double

+#define WINDOW_TYPE 24

+#endif

+

+

+typedef struct AVResampleContext{

+    const AVClass *av_class;

+    FELEM *filter_bank;

+    int filter_length;

+    int ideal_dst_incr;

+    int dst_incr;

+    int index;

+    int frac;

+    int src_incr;

+    int compensation_distance;

+    int phase_shift;

+    int phase_mask;

+    int linear;

+    double factor;

+}AVResampleContext;

+

+/**

+ * 0th order modified bessel function of the first kind.

+ */

+static double bessel(double x){

+    double v=1;

+    double lastv=0;

+    double t=1;

+    int i;

+    static const double inv[100]={

+ 1.0/( 1* 1), 1.0/( 2* 2), 1.0/( 3* 3), 1.0/( 4* 4), 1.0/( 5* 5), 1.0/( 6* 6), 1.0/( 7* 7), 1.0/( 8* 8), 1.0/( 9* 9), 1.0/(10*10),

+ 1.0/(11*11), 1.0/(12*12), 1.0/(13*13), 1.0/(14*14), 1.0/(15*15), 1.0/(16*16), 1.0/(17*17), 1.0/(18*18), 1.0/(19*19), 1.0/(20*20),

+ 1.0/(21*21), 1.0/(22*22), 1.0/(23*23), 1.0/(24*24), 1.0/(25*25), 1.0/(26*26), 1.0/(27*27), 1.0/(28*28), 1.0/(29*29), 1.0/(30*30),

+ 1.0/(31*31), 1.0/(32*32), 1.0/(33*33), 1.0/(34*34), 1.0/(35*35), 1.0/(36*36), 1.0/(37*37), 1.0/(38*38), 1.0/(39*39), 1.0/(40*40),

+ 1.0/(41*41), 1.0/(42*42), 1.0/(43*43), 1.0/(44*44), 1.0/(45*45), 1.0/(46*46), 1.0/(47*47), 1.0/(48*48), 1.0/(49*49), 1.0/(50*50),

+ 1.0/(51*51), 1.0/(52*52), 1.0/(53*53), 1.0/(54*54), 1.0/(55*55), 1.0/(56*56), 1.0/(57*57), 1.0/(58*58), 1.0/(59*59), 1.0/(60*60),

+ 1.0/(61*61), 1.0/(62*62), 1.0/(63*63), 1.0/(64*64), 1.0/(65*65), 1.0/(66*66), 1.0/(67*67), 1.0/(68*68), 1.0/(69*69), 1.0/(70*70),

+ 1.0/(71*71), 1.0/(72*72), 1.0/(73*73), 1.0/(74*74), 1.0/(75*75), 1.0/(76*76), 1.0/(77*77), 1.0/(78*78), 1.0/(79*79), 1.0/(80*80),

+ 1.0/(81*81), 1.0/(82*82), 1.0/(83*83), 1.0/(84*84), 1.0/(85*85), 1.0/(86*86), 1.0/(87*87), 1.0/(88*88), 1.0/(89*89), 1.0/(90*90),

+ 1.0/(91*91), 1.0/(92*92), 1.0/(93*93), 1.0/(94*94), 1.0/(95*95), 1.0/(96*96), 1.0/(97*97), 1.0/(98*98), 1.0/(99*99), 1.0/(10000)

+    };

+

+    x= x*x/4;

+    for(i=0; v != lastv; i++){

+        lastv=v;

+        t *= x*inv[i];

+        v += t;

+    }

+    return v;

+}

+

+/**

+ * builds a polyphase filterbank.

+ * @param factor resampling factor

+ * @param scale wanted sum of coefficients for each filter

+ * @param type 0->cubic, 1->blackman nuttall windowed sinc, 2..16->kaiser windowed sinc beta=2..16

+ * @return 0 on success, negative on error

+ */

+static int build_filter(FELEM *filter, double factor, int tap_count, int phase_count, int scale, int type){

+    int ph, i;

+    double x, y, w;

+    double *tab = av_malloc(tap_count * sizeof(*tab));

+    const int center= (tap_count-1)/2;

+

+    if (!tab)

+        return AVERROR(ENOMEM);

+

+    /* if upsampling, only need to interpolate, no filter */

+    if (factor > 1.0)

+        factor = 1.0;