Ticket #1104: mythtv_ac3.36.patch

libs/libmyth/audiooutputdigitalencoder.cpp

@@ +1 @@
+// Std C headers
+#include <cstdio>
+
+// libav headers
+extern "C" {
+#include "libavcodec/avcodec.h"
+#ifdef ENABLE_AC3_DECODER
+#include "libavcodec/parser.h"
+#else
+#include <a52dec/a52.h>
+#endif
+}
+
+// MythTV headers
+#include "config.h"
+#include "mythcontext.h"
+#include "audiooutputdigitalencoder.h"
+#include "compat.h"
+
+#define LOC QString("DEnc: ")
+
+#define MAX_AC3_FRAME_SIZE 6144
+
+AudioOutputDigitalEncoder::AudioOutputDigitalEncoder()
+{
+    av_context = NULL;
+    outbuf = NULL;
+    outbuf_size = 0;
+    one_frame_bytes = 0;
+    frame_buffer = NULL;
+}
+
+AudioOutputDigitalEncoder::~AudioOutputDigitalEncoder()
+{
+    Dispose();
+}
+
+void AudioOutputDigitalEncoder::Dispose()
+{
+    if (av_context)
+    {
+        avcodec_close(av_context);
+        av_free(av_context);
+        av_context = NULL;
+    }
+    if (outbuf)
+    {
+        delete [] outbuf;
+        outbuf = NULL;
+        outbuf_size = 0;
+    }
+    if (frame_buffer)
+    {
+        delete [] frame_buffer;
+        frame_buffer = NULL;
+        one_frame_bytes = 0;
+    }
+}
+
+//CODEC_ID_AC3
+bool AudioOutputDigitalEncoder::Init(CodecID codec_id, int bitrate, int samplerate, int channels)
+{
+    AVCodec * codec;
+    int ret;
+
+    VERBOSE(VB_AUDIO, QString("DigitalEncoder::Init codecid=%1, br=%2, sr=%3, ch=%4")
+            .arg(codec_id_string(codec_id))
+            .arg(bitrate)
+            .arg(samplerate)
+            .arg(channels));
+    //codec = avcodec_find_encoder(codec_id);
+    // always AC3 as there is no DTS encoder at the moment 2005/1/9
+    codec = avcodec_find_encoder(CODEC_ID_AC3);
+    if (!codec)
+    {
+        VERBOSE(VB_IMPORTANT,"Error: could not find codec");
+        return false;
+    }
+    av_context = avcodec_alloc_context();
+    av_context->bit_rate = bitrate;
+    av_context->sample_rate = samplerate;
+    av_context->channels = channels;
+    // open it */
+    if ((ret = avcodec_open(av_context, codec)) < 0) 
+    {
+        VERBOSE(VB_IMPORTANT,"Error: could not open codec, invalid bitrate or samplerate");
+        Dispose();
+        return false;
+    }
+
+    size_t bytes_per_frame = av_context->channels * sizeof(short);
+    audio_bytes_per_sample = bytes_per_frame;
+    one_frame_bytes = bytes_per_frame * av_context->frame_size;
+
+    outbuf_size = 16384;    // ok for AC3 but DTS?
+    outbuf = new char [outbuf_size];
+    VERBOSE(VB_AUDIO, QString("DigitalEncoder::Init fs=%1, bpf=%2 ofb=%3")
+            .arg(av_context->frame_size)
+            .arg(bytes_per_frame)
+            .arg(one_frame_bytes)
+           );
+
+    return true;
+}
+
+static int DTS_SAMPLEFREQS[16] =
+{
+    0,      8000,   16000,  32000,  64000,  128000, 11025,  22050,
+    44100,  88200,  176400, 12000,  24000,  48000,  96000,  192000
+};
+
+static int DTS_BITRATES[30] =
+{
+    32000,    56000,    64000,    96000,    112000,   128000,
+    192000,   224000,   256000,   320000,   384000,   448000,
+    512000,   576000,   640000,   768000,   896000,   1024000,
+    1152000,  1280000,  1344000,  1408000,  1411200,  1472000,
+    1536000,  1920000,  2048000,  3072000,  3840000,  4096000
+};
+
+static int dts_decode_header(uint8_t *indata_ptr, int *rate,
+                             int *nblks, int *sfreq)
+{
+    uint id = ((indata_ptr[0] << 24) | (indata_ptr[1] << 16) |
+               (indata_ptr[2] << 8)  | (indata_ptr[3]));
+
+    if (id != 0x7ffe8001)
+        return -1;
+
+    int ftype = indata_ptr[4] >> 7;
+
+    int surp = (indata_ptr[4] >> 2) & 0x1f;
+    surp = (surp + 1) % 32;
+
+    *nblks = (indata_ptr[4] & 0x01) << 6 | (indata_ptr[5] >> 2);
+    ++*nblks;
+
+    int fsize = (indata_ptr[5] & 0x03) << 12 |
+                (indata_ptr[6]         << 4) | (indata_ptr[7] >> 4);
+    ++fsize;
+
+    *sfreq = (indata_ptr[8] >> 2) & 0x0f;
+    *rate = (indata_ptr[8] & 0x03) << 3 | ((indata_ptr[9] >> 5) & 0x07);
+
+    if (ftype != 1)
+    {
+        VERBOSE(VB_IMPORTANT, LOC +
+                QString("DTS: Termination frames not handled (ftype %1)")
+                .arg(ftype));
+        return -1;
+    }
+
+    if (*sfreq != 13)
+    {
+        VERBOSE(VB_IMPORTANT, LOC +
+                QString("DTS: Only 48kHz supported (sfreq %1)").arg(*sfreq));
+        return -1;
+    }
+
+    if ((fsize > 8192) || (fsize < 96))
+    {
+        VERBOSE(VB_IMPORTANT, LOC +
+                QString("DTS: fsize: %1 invalid").arg(fsize));
+        return -1;
+    }
+
+    if (*nblks != 8 && *nblks != 16 && *nblks != 32 &&
+        *nblks != 64 && *nblks != 128 && ftype == 1)
+    {
+        VERBOSE(VB_IMPORTANT, LOC +
+                QString("DTS: nblks %1 not valid for normal frame")
+                .arg(*nblks));
+        return -1;
+    }
+
+    return fsize;
+}
+
+static int dts_syncinfo(uint8_t *indata_ptr, int * /*flags*/,
+                        int *sample_rate, int *bit_rate)
+{
+    int nblks;
+    int rate;
+    int sfreq;
+
+    int fsize = dts_decode_header(indata_ptr, &rate, &nblks, &sfreq);
+    if (fsize >= 0)
+    {
+        if (rate >= 0 && rate <= 29)
+            *bit_rate = DTS_BITRATES[rate];
+        else
+            *bit_rate = 0;
+        if (sfreq >= 1 && sfreq <= 15)
+            *sample_rate = DTS_SAMPLEFREQS[sfreq];
+        else
+            *sample_rate = 0;
+    }
+    return fsize;
+}
+
+// until there is an easy way to do this with ffmpeg
+// get the code from libavcodec/parser.c made non static
+extern "C" int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
+                            int *bit_rate, int *samples);
+
+static int encode_frame(
+        bool dts, 
+        unsigned char *data,
+        size_t &len)
+{
+    size_t enc_len;
+    int flags, sample_rate, bit_rate;
+
+    // we don't do any length/crc validation of the AC3 frame here; presumably
+    // the receiver will have enough sense to do that.  if someone has a
+    // receiver that doesn't, here would be a good place to put in a call
+    // to a52_crc16_block(samples+2, data_size-2) - but what do we do if the
+    // packet is bad?  we'd need to send something that the receiver would
+    // ignore, and if so, may as well just assume that it will ignore
+    // anything with a bad CRC...
+
+    uint nr_samples = 0, block_len;
+    if (dts)
+    {
+        enc_len = dts_syncinfo(data+8, &flags, &sample_rate, &bit_rate);
+        int rate, sfreq, nblks;
+        dts_decode_header(data+8, &rate, &nblks, &sfreq);
+        nr_samples = nblks * 32;
+        block_len = nr_samples * 2 * 2;
+    }
+    else
+    {
+#ifdef ENABLE_AC3_DECODER
+        enc_len = ac3_sync(data+8, &flags, &sample_rate, &bit_rate, (int*)&block_len);
+#else
+        enc_len = a52_syncinfo(data+8, &flags, &sample_rate, &bit_rate);
+        block_len = MAX_AC3_FRAME_SIZE;
+#endif
+    }
+
+    if (enc_len == 0 || enc_len > len)
+    {
+        int l = len;
+        len = 0;
+        return l;
+    }
+
+    enc_len = min((uint)enc_len, block_len - 8);
+
+    //uint32_t x = *(uint32_t*)(data+8);
+    // in place swab
+    swab(data+8, data+8, enc_len);
+    //VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
+    //        QString("DigitalEncoder::Encode swab test %1 %2")
+    //        .arg(x,0,16).arg(*(uint32_t*)(data+8),0,16));
+
+    // the following values come from libmpcodecs/ad_hwac3.c in mplayer.
+    // they form a valid IEC958 AC3 header.
+    data[0] = 0x72;
+    data[1] = 0xF8;
+    data[2] = 0x1F;
+    data[3] = 0x4E;
+    data[4] = 0x01;
+    if (dts)
+    {
+        switch(nr_samples)
+        {
+            case 512:
+                data[4] = 0x0B;      /* DTS-1 (512-sample bursts) */
+                break;
+
+            case 1024:
+                data[4] = 0x0C;      /* DTS-2 (1024-sample bursts) */
+                break;
+
+            case 2048:
+                data[4] = 0x0D;      /* DTS-3 (2048-sample bursts) */
+                break;
+
+            default:
+                VERBOSE(VB_IMPORTANT, LOC +
+                        QString("DTS: %1-sample bursts not supported")
+                        .arg(nr_samples));
+                data[4] = 0x00;
+                break;
+        }
+    }
+    data[5] = 0x00;
+    data[6] = (enc_len << 3) & 0xFF;
+    data[7] = (enc_len >> 5) & 0xFF;
+    memset(data + 8 + enc_len, 0, block_len - 8 - enc_len);
+    len = block_len;
+
+    return enc_len;
+}
+
+// must have exactly 1 frames worth of data
+size_t AudioOutputDigitalEncoder::Encode(short * buff)
+{
+    int encsize = 0;
+    size_t outsize = 0;
+ 
+    // put data in the correct spot for encode frame
+    outsize = avcodec_encode_audio(
+                av_context, 
+                ((uchar*)outbuf)+8, 
+                outbuf_size-8, 
+                buff);
+    size_t tmpsize = outsize;
+
+    outsize = MAX_AC3_FRAME_SIZE;
+    encsize = encode_frame(
+            //av_context->codec_id==CODEC_ID_DTS,
+            false,
+            (unsigned char*)outbuf, outsize);
+    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
+            QString("DigitalEncoder::Encode len1=%1 len2=%2 finallen=%3")
+                .arg(tmpsize)
+                .arg(encsize)
+                .arg(outsize)
+           );
+
+    return outsize;
+}

libs/libmyth/audiooutputdigitalencoder.h

@@ +1 @@
+#ifndef AUDIOOUTPUTREENCODER
+#define AUDIOOUTPUTREENCODER
+
+extern "C" {
+#include "libavcodec/avcodec.h"
+};
+
+class AudioOutputDigitalEncoder
+{
+public:
+    AudioOutputDigitalEncoder();
+    ~AudioOutputDigitalEncoder();
+    void Dispose();
+    bool Init(CodecID codec_id, int bitrate, int samplerate, int channels);
+    size_t Encode(short * buff);
+
+    // if needed
+    char * GetFrameBuffer() 
+    { 
+        if (!frame_buffer && av_context)
+        {
+            frame_buffer = new char [one_frame_bytes];
+        }
+        return frame_buffer; 
+    }    
+    size_t FrameSize() const { return one_frame_bytes; }
+    char * GetOutBuff() const { return outbuf; }
+
+    size_t audio_bytes_per_sample;
+private:
+    AVCodecContext *av_context;
+    char * outbuf;
+    char * frame_buffer;
+    int outbuf_size;
+    size_t one_frame_bytes;
+};
+
+
+#endif

libs/libmythfreesurround/el_processor.cpp

@@ +1 @@
+/*
+Copyright (C) 2007 Christian Kothe
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include "el_processor.h"
+#include <complex>
+#include <cmath>
+#include <vector>
+#include "fftw3.h"
+
+//#define FILTERED_LFE
+
+#pragma comment (lib,"libfftw3f-3.lib")
+
+typedef std::complex<float> cfloat;
+
+const float PI = 3.141592654;
+const float epsilon = 0.000001;
+const float center_level = 0.5*sqrt(0.5);       // gain of the center channel
+
+// private implementation of the surround decoder
+class decoder_impl {
+public:
+        // create an instance of the decoder
+        //  blocksize is fixed over the lifetime of this object for performance reasons
+        decoder_impl(unsigned blocksize=8192): N(blocksize) {
+                // create FFTW buffers
+                lt = (float*)fftwf_malloc(sizeof(float)*N);
+                rt = (float*)fftwf_malloc(sizeof(float)*N);
+                dst = (float*)fftwf_malloc(sizeof(float)*N);
+                dftL = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*N);
+                dftR = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*N);
+                src = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*N);
+                loadL = fftwf_plan_dft_r2c_1d(N, lt, dftL,FFTW_MEASURE);
+                loadR = fftwf_plan_dft_r2c_1d(N, rt, dftR,FFTW_MEASURE);
+                store = fftwf_plan_dft_c2r_1d(N, src, dst,FFTW_MEASURE);        
+                // resize our own buffers
+                frontR.resize(N);
+                frontL.resize(N);
+                avg.resize(N);
+                surR.resize(N);
+                surL.resize(N);
+#ifdef FILTERED_LFE
+                trueavg.resize(N);
+#endif
+                xfs.resize(N);
+                yfs.resize(N);
+                inbuf[0].resize(N + N/2);
+                inbuf[1].resize(N + N/2);
+                for (unsigned c=0;c<6;c++) {
+                        outbuf[c].resize(N + N/2);
+                        filter[c].resize(N);
+                }
+        // lfe filter is just straight through
+                for (unsigned f=0;f<=N/2;f++) {                 
+            if (f>1 && f<42)
+                filter[5][f] = 1.0;
+            else
+                filter[5][f] = 0.0;
+        }
+                // generate the window function (square root of hann, b/c it is applied before and after the transform)
+                wnd.resize(N);
+                for (unsigned k=0;k<N;k++)
+                        wnd[k] = sqrt(0.5*(1-cos(2*PI*k/N)));
+                // set the default coefficients
+                surround_coefficients(0.8165,0.5774);
+                phase_mode(0);
+                separation(1,1);
+                steering_mode(1);
+        }
+
+        // destructor
+        ~decoder_impl() {
+                // clean up the FFTW stuff
+                fftwf_destroy_plan(store);
+                fftwf_destroy_plan(loadR);
+                fftwf_destroy_plan(loadL);
+                fftwf_free(src); 
+                fftwf_free(dftR);
+                fftwf_free(dftL);
+                fftwf_free(dst);
+                fftwf_free(rt);
+                fftwf_free(lt);
+        }
+
+        // decode a chunk of stereo sound, has to contain exactly blocksize samples
+        //  center_width [0..1] distributes the center information towards the front left/right channels, 1=full distribution, 0=no distribution
+        //  dimension [0..1] moves the soundfield backwards, 0=front, 1=side
+        //  adaption_rate [0..1] determines how fast the steering gets adapted, 1=instantaneous, 0.1 = very slow adaption
+        void decode(float *input[2], float *output[6], float center_width, float dimension, float adaption_rate) {
+                // append incoming data to the end of the input buffer 
+                for (unsigned k=0;k<N;k++) {            
+                        inbuf[0][k+N/2] = input[0][k];
+                        inbuf[1][k+N/2] = input[1][k];
+                }
+                // process first part
+                float *in_first[2] = {&inbuf[0][0],&inbuf[1][0]};
+                add_output(in_first,output,center_width,dimension,adaption_rate);
+                // process second part (overlapped) and return result
+                float *in_second[2] = {&inbuf[0][N/2],&inbuf[1][N/2]};
+                add_output(in_second,output,center_width,dimension,adaption_rate,true);
+                // shift last third of input buffer to the beginning
+                for (unsigned k=0;k<N/2;k++) {          
+                        inbuf[0][k] = inbuf[0][k+N];
+                        inbuf[1][k] = inbuf[1][k+N];
+                }
+        }
+        
+        // flush the internal buffers
+        void flush() {
+                for (unsigned k=0;k<N+N/2;k++) {
+                        for (unsigned c=0;c<6;c++)
+                                outbuf[c][k] = 0;
+                        inbuf[0][k] = 0;
+                        inbuf[1][k] = 0;
+                }
+        }
+
+        // set the assumed surround mixing coefficients
+        void surround_coefficients(float a, float b) {
+                master_gain = 1.0;
+                // calc the simple coefficients
+                surround_high = a;
+                surround_low = b;
+                surround_balance = (a-b)/(a+b);
+                surround_level = 1/(a+b);
+                // calc the linear coefficients
+                cfloat i(0,1), u((a+b)*i), v((b-a)*i), n(0.25,0),o(1,0);
+                A = (v-o)*n; B = (o-u)*n; C = (-o-v)*n; D = (o+u)*n;
+                E = (o+v)*n; F = (o+u)*n; G = (o-v)*n;  H = (o-u)*n;
+        }
+
+        // set the phase shifting mode
+        void phase_mode(unsigned mode) {
+                const float modes[4][2] = {{0,0},{0,PI},{PI,0},{-PI/2,PI/2}};
+                phase_offsetL = modes[mode][0];
+                phase_offsetR = modes[mode][1];
+        }
+
+        // what steering mode should be chosen
+        void steering_mode(bool mode) { linear_steering = mode; }
+
+        // set front & rear separation controls
+        void separation(float front, float rear) {
+                front_separation = front;
+                rear_separation = rear;
+        }
+
+private:
+        // polar <-> cartesian coodinates conversion
+        static inline float amplitude(const float cf[2]) { return sqrt(cf[0]*cf[0] + cf[1]*cf[1]); }
+        static inline float phase(const float cf[2]) { return atan2(cf[1],cf[0]); }
+        static inline cfloat polar(float a, float p) { return cfloat(a*cos(p),a*sin(p)); }
+        static inline float sqr(float x) { return x*x; }
+        // the dreaded min/max
+        static inline float min(float a, float b) { return a<b?a:b; }
+        static inline float max(float a, float b) { return a>b?a:b; }
+        static inline float clamp(float x) { return max(-1,min(1,x)); }
+
+        // handle the output buffering for overlapped calls of block_decode
+        void add_output(float *input[2], float *output[6], float center_width, float dimension, float adaption_rate, bool result=false) {
+                // add the windowed data to the last 2/3 of the output buffer
+                float *out[6] = {&outbuf[0][N/2],&outbuf[1][N/2],&outbuf[2][N/2],&outbuf[3][N/2],&outbuf[4][N/2],&outbuf[5][N/2]};
+                block_decode(input,out,center_width,dimension,adaption_rate);
+                for (unsigned c=0;c<6;c++) {
+                        if (result) 
+                                // return the first 2/3 of the ouput buffer
+                                for (unsigned k=0;k<N;k++)                              
+                                        output[c][k] = outbuf[c][k];
+                        for (unsigned k=0;k<N;k++)
+                                // shift the last 2/3 to the first 2/3 of the output buffer
+                                outbuf[c][k] = outbuf[c][k+N/2];
+                        // and clear the rest
+                        for (unsigned k=N;k<N+N/2;k++)
+                                outbuf[c][k] = 0;
+                }
+        }
+
+        // CORE FUNCTION: decode a block of data
+        void block_decode(float *input[2], float *output[6], float center_width, float dimension, float adaption_rate) {
+                // 1. scale the input by the window function; this serves a dual purpose:
+                // - first it improves the FFT resolution b/c boundary discontinuities (and their frequencies) get removed
+                // - second it allows for smooth blending of varying filters between the blocks
+                for (unsigned k=0;k<N;k++) {
+                        lt[k] = input[0][k] * wnd[k] * master_gain;
+                        rt[k] = input[1][k] * wnd[k] * master_gain;
+                }
+
+                // ... and tranform it into the frequency domain
+                fftwf_execute(loadL);
+                fftwf_execute(loadR);
+
+                // 2. compare amplitude and phase of each DFT bin and produce the X/Y coordinates in the sound field
+                for (unsigned f=0;f<=N/2;f++) {                 
+                        // get left/right amplitudes/phases
+                        float ampL = amplitude(dftL[f]), ampR = amplitude(dftR[f]);
+                        float phaseL = phase(dftL[f]), phaseR = phase(dftR[f]);
+//                      if (ampL+ampR < epsilon)
+//                              continue;               
+
+                        // calculate the amplitude/phase difference
+                        float ampDiff = clamp((ampL+ampR < epsilon) ? 0 : (ampR-ampL) / (ampR+ampL));
+                        float phaseDiff = phaseL - phaseR;
+                        if (phaseDiff < -PI) phaseDiff += 2*PI;
+                        if (phaseDiff > PI) phaseDiff -= 2*PI;
+                        phaseDiff = abs(phaseDiff);
+
+                        if (linear_steering) {
+/*                              cfloat w = polar(sqrt(ampL*ampL+ampR*ampR), (phaseL+phaseR)/2);
+                                cfloat lt = cfloat(dftL[f][0],dftL[f][1])/w, rt = cfloat(dftR[f][0],dftR[f][1])/w;                              */
+//                              xfs[f] = -(C*(rt-H) - B*E + F*A + G*(D-lt)) / (G*A - C*E).real();
+//                              yfs[f] = (rt - (xfs[f]*E+H))/(F+xfs[f]*G);
+
+                                /*
+                                Problem: 
+                                This assumes that the values are interpolated linearly between the cardinal points.
+                                But this way we have no chance of knowing the average volume...
+                                - Can we solve that computing everything under the assumption of normalized volume?
+                                  No. Seemingly not.
+                                - Maybe we should add w explitcitly into the equation and see if we can solve it...
+                                */
+
+
+                                //cfloat lt(0.5,0),rt(0.5,0);
+                                //cfloat x(0,0), y(1,0);
+                                /*cfloat p = (C*(rt-H) - B*E + F*A + G*(D-lt)) / (G*A - C*E);
+                                cfloat q = B*(rt+H) + F*(D-lt) / (G*A - C*E);
+                                cfloat s = sqrt(p*p/4.0f - q);
+                                cfloat x = -p;
+                                cfloat x1 = -p/2.0f + s;
+                                cfloat x2 = -p/2.0f - s;
+                                float x = 0;
+                                if (x1.real() >= -1 && x1.real() <= 1)
+                                        x = x1.real();
+                                else if (x2.real() >= -1 && x2.real() <= 1)
+                                        x = x2.real();*/
+
+                                //cfloat yp = (rt - (x*E+H))/(F+x*G);
+                                //cfloat xp = (lt - (y*B+D))/(A+y*C);
+
+                                /*xfs[f] = x;
+                                yfs[f] = y.real();*/
+
+                                // --- this is the fancy new linear mode ---
+
+                                // get sound field x/y position
+                                yfs[f] = get_yfs(ampDiff,phaseDiff);
+                                xfs[f] = get_xfs(ampDiff,yfs[f]);
+
+                                // add dimension control
+                                yfs[f] = clamp(yfs[f] - dimension);
+
+                                // add crossfeed control
+                                xfs[f] = clamp(xfs[f] * (front_separation*(1+yfs[f])/2 + rear_separation*(1-yfs[f])/2));
+
+                                // 3. generate frequency filters for each output channel
+                                float left = (1-xfs[f])/2, right = (1+xfs[f])/2;
+                                float front = (1+yfs[f])/2, back = (1-yfs[f])/2;
+                                float volume[5] = {
+                                        front * (left * center_width + max(0,-xfs[f]) * (1-center_width)),      // left
+                                        front * center_level*((1-abs(xfs[f])) * (1-center_width)),                      // center
+                                        front * (right * center_width + max(0, xfs[f]) * (1-center_width)),     // right
+                                        back * surround_level * left,                                                                           // left surround
+                                        back * surround_level * right                                                                           // right surround
+                                };
+
+                                // adapt the prior filter
+                                for (unsigned c=0;c<5;c++)
+                                        filter[c][f] = (1-adaption_rate)*filter[c][f] + adaption_rate*volume[c]/N;
+
+                        } else {
+                                // --- this is the old & simple steering mode ---
+
+                                // calculate the amplitude/phase difference
+                                float ampDiff = clamp((ampL+ampR < epsilon) ? 0 : (ampR-ampL) / (ampR+ampL));
+                                float phaseDiff = phaseL - phaseR;
+                                if (phaseDiff < -PI) phaseDiff += 2*PI;
+                                if (phaseDiff > PI) phaseDiff -= 2*PI;
+                                phaseDiff = abs(phaseDiff);
+
+                                // determine sound field x-position
+                                xfs[f] = ampDiff;
+
+                                // determine preliminary sound field y-position from phase difference
+                                yfs[f] = 1 - (phaseDiff/PI)*2;
+
+                                if (abs(xfs[f]) > surround_balance) {
+                                        // blend linearly between the surrounds and the fronts if the balance exceeds the surround encoding balance
+                                        // this is necessary because the sound field is trapezoidal and will be stretched behind the listener
+                                        float frontness = (abs(xfs[f]) - surround_balance)/(1-surround_balance);
+                                        yfs[f]  = (1-frontness) * yfs[f] + frontness * 1; 
+                                }
+
+                                // add dimension control
+                                yfs[f] = clamp(yfs[f] - dimension);
+
+                                // add crossfeed control
+                                xfs[f] = clamp(xfs[f] * (front_separation*(1+yfs[f])/2 + rear_separation*(1-yfs[f])/2));
+
+                                // 3. generate frequency filters for each output channel, according to the signal position
+                                // the sum of all channel volumes must be 1.0
+                                float left = (1-xfs[f])/2, right = (1+xfs[f])/2;
+                                float front = (1+yfs[f])/2, back = (1-yfs[f])/2;
+                                float volume[5] = {
+                                        front * (left * center_width + max(0,-xfs[f]) * (1-center_width)),              // left
+                                        front * center_level*((1-abs(xfs[f])) * (1-center_width)),                              // center
+                                        front * (right * center_width + max(0, xfs[f]) * (1-center_width)),             // right
+                                        back * surround_level*max(0,min(1,((1-(xfs[f]/surround_balance))/2))),  // left surround
+                                        back * surround_level*max(0,min(1,((1+(xfs[f]/surround_balance))/2)))   // right surround
+                                };
+
+                                // adapt the prior filter
+                                for (unsigned c=0;c<5;c++)
+                                        filter[c][f] = (1-adaption_rate)*filter[c][f] + adaption_rate*volume[c]/N;
+                        }
+
+                        // ... and build the signal which we want to position
+                        frontL[f] = polar(ampL+ampR,phaseL);
+                        frontR[f] = polar(ampL+ampR,phaseR);
+                        avg[f] = frontL[f] + frontR[f];
+                        surL[f] = polar(ampL+ampR,phaseL+phase_offsetL);
+                        surR[f] = polar(ampL+ampR,phaseR+phase_offsetR);
+#ifdef FILTERED_LFE
+                        trueavg[f] = cfloat(dftL[f][0] + dftR[f][0], dftL[f][1] + dftR[f][1]);
+#endif
+                }
+
+                // 4. distribute the unfiltered reference signals over the channels
+                apply_filter(&frontL[0],&filter[0][0],&output[0][0]);   // front left
+                apply_filter(&avg[0], &filter[1][0],&output[1][0]);             // front center
+                apply_filter(&frontR[0],&filter[2][0],&output[2][0]);   // front right
+                apply_filter(&surL[0],&filter[3][0],&output[3][0]);             // surround left
+                apply_filter(&surR[0],&filter[4][0],&output[4][0]);             // surround right
+#ifdef FILTERED_LFE
+                apply_filter(&trueavg[0],&filter[5][0],&output[5][0]);          // lfe
+#else
+        double g = master_gain;
+        // introduce a delay of N/2 too to match the other channels
+                for (unsigned k=0,k2=N/4;k<N/2;k++,k2++) {
+                        output[5][k] = (input[0][k2] + input[1][k2]) * g;
+                }
+#endif
+        }
+
+#define FASTER_CALC
+        // map from amplitude difference and phase difference to yfs
+        inline double get_yfs(double ampDiff, double phaseDiff) {
+                double x = 1-(((1-sqr(ampDiff))*phaseDiff)/PI*2);
+#ifdef FASTER_CALC
+        double tanX = tan(x);
+                return 0.16468622925824683 + 0.5009268347818189*x - 0.06462757726992101*x*x
+                        + 0.09170680403453149*x*x*x + 0.2617754892323973*tanX - 0.04180413533856156*sqr(tanX);
+#else
+                return 0.16468622925824683 + 0.5009268347818189*x - 0.06462757726992101*x*x
+                        + 0.09170680403453149*x*x*x + 0.2617754892323973*tan(x) - 0.04180413533856156*sqr(tan(x));
+#endif
+        }
+
+        // map from amplitude difference and yfs to xfs
+        inline double get_xfs(double ampDiff, double yfs) {
+                double x=ampDiff,y=yfs;
+#ifdef FASTER_CALC
+        double tanX = tan(x);
+        double tanY = tan(y);
+        double asinX = asin(x);
+        double sinX = sin(x);
+        double sinY = sin(y);
+        double x3 = x*x*x;
+        double y2 = y*y;
+        double y3 = y*y2;
+                return 2.464833559224702*x - 423.52131153259404*x*y + 
+                        67.8557858606918*x3*y + 788.2429425544392*x*y2 - 
+                        79.97650354902909*x3*y2 - 513.8966153850349*x*y3 + 
+                        35.68117670186306*x3*y3 + 13867.406173420834*y*asinX - 
+                        2075.8237075786396*y2*asinX - 908.2722068360281*y3*asinX - 
+                        12934.654772878019*asinX*sinY - 13216.736529661162*y*tanX + 
+                        1288.6463247741938*y2*tanX + 1384.372969378453*y3*tanX + 
+                        12699.231471126128*sinY*tanX + 95.37131275594336*sinX*tanY - 
+                        91.21223198407546*tanX*tanY;
+#else
+                return 2.464833559224702*x - 423.52131153259404*x*y + 
+                        67.8557858606918*x*x*x*y + 788.2429425544392*x*y*y - 
+                        79.97650354902909*x*x*x*y*y - 513.8966153850349*x*y*y*y + 
+                        35.68117670186306*x*x*x*y*y*y + 13867.406173420834*y*asin(x) - 
+                        2075.8237075786396*y*y*asin(x) - 908.2722068360281*y*y*y*asin(x) - 
+                        12934.654772878019*asin(x)*sin(y) - 13216.736529661162*y*tan(x) + 
+                        1288.6463247741938*y*y*tan(x) + 1384.372969378453*y*y*y*tan(x) + 
+                        12699.231471126128*sin(y)*tan(x) + 95.37131275594336*sin(x)*tan(y) - 
+                        91.21223198407546*tan(x)*tan(y);
+#endif
+        }
+
+        // filter the complex source signal and add it to target
+        void apply_filter(cfloat *signal, float *flt, float *target) {
+                // filter the signal
+                for (unsigned f=0;f<=N/2;f++) {         
+                        src[f][0] = signal[f].real() * flt[f];
+                        src[f][1] = signal[f].imag() * flt[f];
+                }
+                // transform into time domain
+                fftwf_execute(store);
+                // add the result to target, windowed
+                for (unsigned k=0;k<N;k++)
+                        target[k] += wnd[k]*dst[k];
+        }
+
+        unsigned N;                                                // the block size
+        // FFTW data structures
+        float *lt,*rt,*dst;                                // left total, right total (source arrays), destination array
+        fftwf_complex *dftL,*dftR,*src;    // intermediate arrays (FFTs of lt & rt, processing source)
+        fftwf_plan loadL,loadR,store;      // plans for loading the data into the intermediate format and back
+        // buffers
+        std::vector<cfloat> frontL,frontR,avg,surL,surR; // the signal (phase-corrected) in the frequency domain
+#ifdef FILTERED_LFE
+    std::vector<cfloat> trueavg;       // for lfe generation
+#endif
+        std::vector<float> xfs,yfs;                // the feature space positions for each frequency bin
+        std::vector<float> wnd;                    // the window function, precalculated
+        std::vector<float> filter[6];      // a frequency filter for each output channel
+        std::vector<float> inbuf[2];       // the sliding input buffers
+        std::vector<float> outbuf[6];      // the sliding output buffers
+        // coefficients
+        float surround_high,surround_low;  // high and low surround mixing coefficient (e.g. 0.8165/0.5774)
+        float surround_balance;                    // the xfs balance that follows from the coeffs
+        float surround_level;                      // gain for the surround channels (follows from the coeffs
+        float master_gain;                                 // gain for all channels
+        float phase_offsetL, phase_offsetR;// phase shifts to be applied to the rear channels
+        float front_separation;                    // front stereo separation
+        float rear_separation;                     // rear stereo separation
+        bool linear_steering;                      // whether the steering should be linear or not
+        cfloat A,B,C,D,E,F,G,H;                    // coefficients for the linear steering
+};
+
+
+// implementation of the shell class
+
+fsurround_decoder::fsurround_decoder(unsigned blocksize): impl(new decoder_impl(blocksize)) { }
+
+fsurround_decoder::~fsurround_decoder() { delete impl; }
+
+void fsurround_decoder::decode(float *input[2], float *output[6], float center_width, float dimension, float adaption_rate) {
+        impl->decode(input,output,center_width,dimension,adaption_rate);
+}
+
+void fsurround_decoder::flush() { impl->flush(); }
+
+void fsurround_decoder::surround_coefficients(float a, float b) { impl->surround_coefficients(a,b); }
+
+void fsurround_decoder::phase_mode(unsigned mode) { impl->phase_mode(mode); }
+
+void fsurround_decoder::steering_mode(bool mode) { impl->steering_mode(mode); }
+
+void fsurround_decoder::separation(float front, float rear) { impl->separation(front,rear); }

libs/libmythfreesurround/el_processor.h

@@ +1 @@
+/*
+Copyright (C) 2007 Christian Kothe
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#ifndef EL_PROCESSOR_H
+#define EL_PROCESSOR_H
+
+// the Free Surround decoder
+class fsurround_decoder {
+public:
+        // create an instance of the decoder
+        //  blocksize is fixed over the lifetime of this object for performance reasons
+        fsurround_decoder(unsigned blocksize=8192);
+        // destructor
+        ~fsurround_decoder();
+        
+        // decode a chunk of stereo sound, has to contain exactly blocksize samples
+        //  center_width [0..1] distributes the center information towards the front left/right channels, 1=full distribution, 0=no distribution
+        //  dimension [0..1] moves the soundfield backwards, 0=front, 1=side
+        //  adaption_rate [0..1] determines how fast the steering gets adapted, 1=instantaneous, 0.1 = very slow adaption
+        void decode(float *input[2], float *output[6], float center_width=1, float dimension=0, float adaption_rate=1); 
+        
+        // flush the internal buffers
+        void flush();
+
+        // --- advanced configuration ---
+
+        // override the surround coefficients
+        //  a is the coefficient of left rear in left total, b is the coefficient of left rear in right total; the same is true for right.
+        void surround_coefficients(float a, float b);
+
+        // set the phase shifting mode for decoding
+        // 0 = (+0°,+0°)   - music mode
+        // 1 = (+0°,+180°) - PowerDVD compatibility
+        // 2 = (+180°,+0°) - BeSweet compatibility
+        // 3 = (-90°,+90°) - This seems to work. I just don't know why.
+        void phase_mode(unsigned mode);
+
+        // override the steering mode
+        //  false = simple non-linear steering (old)
+        //  true  = advanced linear steering (new)
+        void steering_mode(bool mode);
+
+        // set front/rear stereo separation
+        //  1.0 is default, 0.0 is mono
+        void separation(float front,float rear);
+private:
+        class decoder_impl *impl; // private implementation (details hidden)
+};
+
+
+#endif

libs/libmythfreesurround/freesurround.cpp

@@ +1 @@
+/*
+Copyright (C) 2007 Christian Kothe, Mark Spieth
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <cstdio>
+#include <cstdlib>
+#include <cerrno>
+#include <iostream>
+#include <sstream>
+//#include "compat.h"
+#include "freesurround.h"
+#include "el_processor.h"
+#include <vector>
+#include <list>
+#include <map>
+#include <math.h>
+
+#include <qstring.h>
+#include <qdatetime.h>
+
+using namespace std;
+
+#if 0
+#define VERBOSE(args...) \
+    do { \
+        QDateTime dtmp = QDateTime::currentDateTime(); \
+        QString dtime = dtmp.toString("yyyy-MM-dd hh:mm:ss.zzz"); \
+        ostringstream verbose_macro_tmp; \
+        verbose_macro_tmp << dtime << " " << args; \
+        cout << verbose_macro_tmp.str() << endl; \
+    } while (0)
+#else
+#define VERBOSE(args...)
+#endif
+#if 0
+#define VERBOSE1(args...) \
+    do { \
+        QDateTime dtmp = QDateTime::currentDateTime(); \
+        QString dtime = dtmp.toString("yyyy-MM-dd hh:mm:ss.zzz"); \
+        ostringstream verbose_macro_tmp; \
+        verbose_macro_tmp << dtime << " " << args; \
+        cout << verbose_macro_tmp.str() << endl; \
+    } while (0)
+#else
+#define VERBOSE1(args...)
+#endif
+
+// our default internal block size, in floats
+const unsigned block_size = 8192;
+// there will be a slider for this in the future
+const float master_gain = 1.0/(1<<15);
+const float inv_master_gain = (1<<15);
+
+unsigned bs = block_size;
+
+// stupidity countermeasure...
+template<class T> T pop_back(std::list<T> &l)
+{
+    T result(l.back());
+    l.pop_back();
+    return result;
+}
+
+// a pool, where the DSP can throw its objects at after it got deleted and get them back when it is recreated...
+class object_pool
+{
+public:
+        typedef void* (*callback)();
+        // initialize
+        object_pool(callback cbf):construct(cbf) { }
+        ~object_pool()
+    {
+                for (std::map<void*,void*>::iterator i=pool.begin(),e=pool.end();i!=e;i++)
+                        delete i->second;
+                for (std::list<void*>::iterator i=freelist.begin(),e=freelist.end();i!=e;i++)
+                        delete *i;
+        }
+        // (re)acquire an object
+        void *acquire(void *who)
+    {
+                std::map<void*,void*>::iterator i(pool.find(who));
+                if (i != pool.end())
+                        return i->second;
+                else
+                        if (!freelist.empty())
+                                return pool.insert(std::make_pair(who,pop_back(freelist))).first->second;
+                        else
+                                return pool.insert(std::make_pair(who,construct())).first->second;
+        }
+        // release an object into the wild
+        void release(void *who)
+    {
+                std::map<void*,void*>::iterator i(pool.find(who));
+                if (i != pool.end()) {
+                        freelist.push_back(i->second);
+                        pool.erase(i);
+                }
+        }       
+public:
+        callback construct;                     // object constructor callback
+        std::list<void*> freelist;              // list of available objects
+        std::map<void*,void*> pool;     // pool of used objects, by class
+};
+
+// buffers which we usually need (and want to share between plugin lifespans)
+struct buffers
+{
+        buffers(unsigned int s): 
+        //block(),result(s),
+        lt(s),rt(s),
+        l(s),r(s),c(s),ls(s),rs(s),lfe(s),cs(s),lcs(s),rcs(s) { }
+        void resize(unsigned int s)
+    {
+                lt.resize(s); rt.resize(s); l.resize(s); r.resize(s); lfe.resize(s); 
+                ls.resize(s); rs.resize(s); c.resize(s); cs.resize(s); lcs.resize(s); rcs.resize(s);
+        }
+        void clear()
+    {
+                lt.clear(); rt.clear(); l.clear(); r.clear();
+                ls.clear(); rs.clear(); c.clear();
+                //block.clear(); result.clear();
+        }
+        std::vector<float> lt,rt;                                               // for multiplexing
+        std::vector<float> l,r,c,ls,rs,lfe,cs,lcs,rcs;  // for demultiplexing
+};
+
+// construction methods
+void *new_decoder() { return new fsurround_decoder(block_size); }
+void *new_buffers() { return new buffers(bs); }
+
+object_pool dp(&new_decoder);
+object_pool bp(&new_buffers);
+
+//#define SPEAKERTEST
+#ifdef SPEAKERTEST
+int channel_select = -1;
+#endif
+
+FreeSurround::FreeSurround(uint srate, bool moviemode) :
+        srate(srate),
+        open_(false),
+        initialized_(false),
+        bufs((buffers*)bp.acquire(this)),
+        decoder(0),
+        in_count(0),
+        out_count(0),
+        processed(true)
+{
+    VERBOSE(QString("FreeSurround::FreeSurround rate %1 moviemode %2").arg(srate).arg(moviemode));
+    if (moviemode)
+    {
+        params.phasemode = 1;
+        params.center_width = 0;
+        //params.steering = 0;
+    }
+    else
+    {
+        params.center_width = 50;
+    }
+    open();
+#ifdef SPEAKERTEST
+    channel_select++;
+    if (channel_select>=6)
+        channel_select = 0;
+    VERBOSE(QString("FreeSurround::FreeSurround channel_select %1").arg(channel_select));
+#endif
+
+    VERBOSE(QString("FreeSurround::FreeSurround done"));
+}
+
+FreeSurround::fsurround_params::fsurround_params(
+        int32_t center_width, 
+        int32_t dimension
+    ) : 
+    center_width(center_width), 
+    dimension(dimension),
+    coeff_a(0.8165),coeff_b(0.5774),
+    phasemode(0),
+    steering(1),
+    front_sep(100),
+    rear_sep(100) 
+{
+}
+
+FreeSurround::~FreeSurround()
+{
+    VERBOSE(QString("FreeSurround::~FreeSurround"));
+    close();
+    bp.release(this);
+    VERBOSE(QString("FreeSurround::~FreeSurround done"));
+}
+
+uint FreeSurround::putSamples(short* samples, uint numSamples, uint numChannels, int step)
+{
+    int i;
+    int ic = in_count;
+    int bs = block_size;
+    bool process = true;
+    // demultiplex
+    switch (numChannels)
+    {
+        case 1:
+            for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+            {
+                bufs->lt[ic] = 
+                bufs->rt[ic] = 
+                    samples[i] * master_gain;
+            }
+            break;
+        case 2:
+            if (step>0)
+            {
+                for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+                {
+                    bufs->lt[ic] = samples[i] * master_gain;
+                    bufs->rt[ic] = samples[i+step] * master_gain;
+                }
+            }
+            else
+            {
+                for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+                {
+                    bufs->lt[ic] = samples[i*2] * master_gain;
+                    bufs->rt[ic] = samples[i*2+1] * master_gain;
+                }
+            }
+            break;
+        case 6:
+            process = false;
+            for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+            {
+                bufs->l[ic] = *samples++ * master_gain;
+                bufs->c[ic] = *samples++ * master_gain;
+                bufs->r[ic] = *samples++ * master_gain;
+                bufs->ls[ic] = *samples++ * master_gain;
+                bufs->rs[ic] = *samples++ * master_gain;
+                bufs->lfe[ic] = *samples++ * master_gain;
+            }
+            break;
+    }
+    in_count = ic;
+    processed = process;
+    if (ic == bs)
+    {
+        in_count = 0;
+        if (process)
+            process_block();
+        out_count = bs;
+    }
+    VERBOSE1(QString("FreeSurround::putSamples %1 %2 %3 used %4 generated %5")
+            .arg(numSamples)
+            .arg(numChannels)
+            .arg(step)
+            .arg(i)
+            .arg(out_count)
+           );
+    return i;
+}
+
+uint FreeSurround::putSamples(char* samples, uint numSamples, uint numChannels, int step)
+{
+    int i;
+    int ic = in_count;
+    int bs = block_size;
+    bool process = true;
+    // demultiplex
+    switch (numChannels)
+    {
+        case 1:
+            for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+            {
+                bufs->lt[ic] = 
+                bufs->rt[ic] = 
+                    samples[i] * master_gain;
+            }
+            break;
+        case 2:
+            if (step>0)
+            {
+                for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+                {
+                    bufs->lt[ic] = samples[i] * master_gain;
+                    bufs->rt[ic] = samples[i+step] * master_gain;
+                }
+            }
+            else
+            {
+                for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+                {
+                    bufs->lt[ic] = samples[i*2] * master_gain;
+                    bufs->rt[ic] = samples[i*2+1] * master_gain;
+                }
+            }
+            break;
+        case 6:
+            process = false;
+            for (i=0;(i<numSamples) && (ic < bs);i++,ic++)
+            {
+                bufs->l[ic] = *samples++ * master_gain;
+                bufs->c[ic] = *samples++ * master_gain;
+                bufs->r[ic] = *samples++ * master_gain;
+                bufs->ls[ic] = *samples++ * master_gain;
+                bufs->rs[ic] = *samples++ * master_gain;
+                bufs->lfe[ic] = *samples++ * master_gain;
+            }
+            break;
+    }
+    in_count = ic;
+    processed = process;
+    if (ic == bs)
+    {
+        in_count = 0;
+        if (process)
+            process_block();
+        out_count = bs;
+    }
+    VERBOSE1(QString("FreeSurround::putSamples %1 %2 %3 used %4 generated %5")
+            .arg(numSamples)
+            .arg(numChannels)
+            .arg(step)
+            .arg(i)
+            .arg(out_count)
+           );
+    return i;
+}
+
+uint FreeSurround::receiveSamples(
+        short *output, 
+        uint maxSamples
+        )
+{
+    uint i;
+    uint oc = out_count;
+    if (maxSamples>oc) maxSamples = oc;
+    uint outindex = block_size - oc;
+    for (unsigned int i=0;i<maxSamples;i++) 
+    {
+#ifndef BYPASS
+#ifdef SPEAKERTEST
+        *output++ = (channel_select==0)?(short)bufs->l[outindex]:0; //L
+        *output++ = (channel_select==1)?(short)bufs->r[outindex]:0; //R
+        *output++ = (channel_select==2)?(short)bufs->c[outindex]:0; //LS
+        *output++ = (channel_select==3)?(short)bufs->c[outindex]:0; //RS
+        *output++ = (channel_select==4)?(short)bufs->c[outindex]:0; //C
+        *output++ = (channel_select==5)?(short)bufs->c[outindex]:0; //LFE
+#else
+        *output++ = lrintf(bufs->l[outindex] * inv_master_gain);
+        *output++ = lrintf(bufs->r[outindex] * inv_master_gain);
+        *output++ = lrintf(bufs->ls[outindex] * inv_master_gain);
+        *output++ = lrintf(bufs->rs[outindex] * inv_master_gain);
+        *output++ = lrintf(bufs->c[outindex] * inv_master_gain);
+        *output++ = lrintf(bufs->lfe[outindex] * inv_master_gain);
+#endif
+#else
+        *output++ = (short)bufs->lt[outindex];
+        *output++ = (short)bufs->rt[outindex];
+        *output++ = (short)((bufs->lt[outindex] - bufs->rt[outindex])*0.7);
+        *output++ = (short)((bufs->lt[outindex] - bufs->rt[outindex])*0.7);
+        *output++ = (short)((bufs->lt[outindex] + bufs->rt[outindex])*0.5);
+        *output++ = (short)((bufs->lt[outindex] + bufs->rt[outindex])*0.5);
+#endif
+        oc--;
+        outindex++;
+    }
+    out_count = oc;
+    VERBOSE1(QString("FreeSurround::receiveSamples %1")
+            .arg(maxSamples)
+           );
+    return maxSamples;
+}
+
+void FreeSurround::process_block()
+{
+#ifndef BYPASS
+    // process the data
+    try 
+    {
+        float *input[2] = {&bufs->lt[0], &bufs->rt[0]};
+        float *output[8] = {&bufs->l[0], &bufs->c[0], &bufs->r[0], &bufs->ls[0], &bufs->rs[0], &bufs->lfe[0], &bufs->lcs[0], &bufs->rcs[0]};
+        if (decoder) 
+        {
+            // actually these params need only be set when they change... but it doesn't hurt
+            decoder->steering_mode(params.steering);
+            decoder->phase_mode(params.phasemode);
+            decoder->surround_coefficients(params.coeff_a, params.coeff_b);                             
+            decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
+            // decode the bufs->block
+            decoder->decode(input,output,params.center_width/100.0,params.dimension/100.0);
+        }
+    }
+    catch(...)
+    {
+        //throw(std::runtime_error(std::string("error during processing (unsupported input format?)")));
+    }
+#endif
+}
+
+long long FreeSurround::getLatency() 
+{
+    // returns in usec
+    return decoder ? ((block_size + in_count)*1000000)/(2*srate) : 0;
+}
+
+void FreeSurround::flush()
+{
+    if (decoder)
+        decoder->flush(); 
+    bufs->clear();
+}
+
+// load the lib and initialize the interface
+void FreeSurround::open() 
+{               
+    if (!decoder)
+    {
+        decoder = (fsurround_decoder*)dp.acquire(this);
+        decoder->flush();
+        bufs->clear();
+    }
+}
+
+void FreeSurround::close() 
+{
+    if (decoder)
+    {
+        dp.release(this);
+        decoder = 0;
+    }
+}
+
+uint FreeSurround::numUnprocessedSamples()
+{
+    return in_count;
+}
+
+uint FreeSurround::numSamples()
+{
+    return out_count;
+}
+
+uint FreeSurround::sampleLatency()
+{
+    if (processed)
+        return in_count + out_count + (block_size/2);
+    else
+        return in_count + out_count;
+}
+
+uint FreeSurround::samplesPerBlock()
+{
+    return block_size;
+}
+

libs/libmythfreesurround/freesurround.h

@@ +1 @@
+/*
+Copyright (C) 2007 Christian Kothe, Mark Spieth
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#ifndef FREESURROUND_H
+#define FREESURROUND_H
+
+class FreeSurround
+{
+public:
+    FreeSurround(uint srate, bool moviemode);
+    ~FreeSurround();
+
+    // put samples in buffer, returns number of samples used
+    uint putSamples(short* samples, uint numSamples, uint numChannels, int step);
+    uint putSamples(char* samples, uint numSamples, uint numChannels, int step);
+    // get a number of samples
+    uint receiveSamples(short *output, 
+                        uint maxSamples
+                        );
+    // flush unprocessed samples
+    void flush();
+    //void setSampleRate(uint srate);
+    uint numUnprocessedSamples();
+    uint numSamples();
+
+    long long getLatency();
+    uint sampleLatency();
+
+    uint samplesPerBlock();
+
+protected:
+    void process_block();
+    void open();
+    void close();
+
+private:
+
+        // the changeable parameters
+    struct fsurround_params {
+        int32_t center_width;       // presence of the center channel
+        int32_t dimension;                  // dimension
+        float coeff_a,coeff_b;  // surround mixing coefficients
+        int32_t phasemode;                      // phase shifting mode
+        int32_t steering;                       // steering mode (0=simple, 1=linear)
+        int32_t front_sep, rear_sep;// front/rear stereo separation
+
+        // (default) constructor
+        fsurround_params(int32_t center_width=100, int32_t dimension=0);
+    } params;
+
+        // additional settings
+        uint srate;
+
+        // info about the current setup
+        bool open_;                                     // whether a stream is currently open
+        bool initialized_;                      // whether the thing is intialized      
+        struct buffers *bufs;                           // our buffers
+        class fsurround_decoder *decoder;       // the surround decoder
+    int in_count;               // amount in lt,rt
+    int out_count;              // amount in output bufs
+    bool processed;             // whether processing is enabled or not for latency calc
+
+};
+
+#endif
+

libs/libmythfreesurround/libmythfreesurround.pro

@@ +1 @@
+include ( ../../config.mak )
+include ( ../../settings.pro )
+
+TEMPLATE = lib
+TARGET = mythfreesurround-$$LIBVERSION
+CONFIG += thread staticlib warn_off
+
+INCLUDEPATH += ../../libs/libavcodec ../..
+
+#build position independent code since the library is linked into a shared library
+QMAKE_CXXFLAGS += -fPIC -DPIC
+
+QMAKE_CLEAN += $(TARGET) $(TARGETA) $(TARGETD) $(TARGET0) $(TARGET1) $(TARGET2)
+
+# Input
+HEADERS += el_processor.h
+HEADERS += freesurround.h
+
+SOURCES += el_processor.cpp
+SOURCES += freesurround.cpp
+
+#required until its rewritten to use avcodec fft lib
+#LIBS += -lfftw3
+LIBS += -lfftw3f
+

libs/libs.pro

@@ -7 +7 @@
 
 # Directories
 SUBDIRS += libavutil libavcodec libavformat libmythsamplerate 
+#SUBDIRS += libaf
 SUBDIRS += libmythsoundtouch libmythmpeg2 libmythdvdnav
+SUBDIRS += libmythfreesurround
 SUBDIRS += libmyth
 
 SUBDIRS += libmythupnp libmythui

libs/libmyth/libmyth.pro

@@ -25 +25 @@
 HEADERS += volumebase.h volumecontrol.h virtualkeyboard.h visual.h xmlparse.h
 HEADERS += mythhdd.h mythcdrom.h
 HEADERS += compat.h
+HEADERS += audiooutputdigitalencoder.h
 
 SOURCES += audiooutput.cpp audiooutputbase.cpp audiooutputnull.cpp
 SOURCES += backendselect.cpp dbsettings.cpp dialogbox.cpp
@@ -40 +41 @@
 SOURCES += uilistbtntype.cpp uitypes.cpp util.cpp util-x11.cpp
 SOURCES += volumebase.cpp volumecontrol.cpp virtualkeyboard.cpp xmlparse.cpp
 SOURCES += mythhdd.cpp mythcdrom.cpp
+SOURCES += audiooutputdigitalencoder.cpp
 
 INCLUDEPATH += ../libmythsamplerate ../libmythsoundtouch ../.. ../ ./
+INCLUDEPATH += ../libavutil
+INCLUDEPATH += ../libmythfreesurround
 DEPENDPATH += ../libmythsamplerate ../libmythsoundtouch ../ ../libmythui
 DEPENDPATH += ../libmythupnp
+DEPENDPATH += ../libavutil ../libavcodec
+DEPENDPATH += ../libmythfreesurround
 
 LIBS += -L../libmythsamplerate -lmythsamplerate-$${LIBVERSION}
 LIBS += -L../libmythsoundtouch -lmythsoundtouch-$${LIBVERSION}
+LIBS += -L../libmythfreesurround -lmythfreesurround-$${LIBVERSION}
+LIBS += -L../libavcodec -lmythavcodec-$${LIBVERSION}
+LIBS += -lfftw3f
 
 TARGETDEPS += ../libmythsamplerate/libmythsamplerate-$${MYTH_LIB_EXT}
 TARGETDEPS += ../libmythsoundtouch/libmythsoundtouch-$${MYTH_LIB_EXT}
+TARGETDEPS += ../libmythfreesurround/libmythfreesurround-$${MYTH_LIB_EXT}
 
 inc.path = $${PREFIX}/include/mythtv/
 inc.files  = dialogbox.h lcddevice.h mythcontext.h mythdbcon.h
@@ -207 +217 @@
 use_hidesyms {
     QMAKE_CXXFLAGS += -fvisibility=hidden
 }
+
+contains( CONFIG_LIBA52, yes ) {
+    LIBS += -la52
+}

libs/libmyth/audiooutput.h

@@ -31 +31 @@
     virtual ~AudioOutput() { };
 
     // reconfigure sound out for new params
-    virtual void Reconfigure(int audio_bits, int audio_channels,
-                             int audio_samplerate, bool audio_passthru) = 0;
+    virtual void Reconfigure(int audio_bits, 
+                             int audio_channels, 
+                             int audio_samplerate,
+                             bool audio_passthru,
+                             void* audio_codec = NULL
+                             ) = 0;
     
     virtual void SetStretchFactor(float factor);
 
@@ -74 +78 @@
         lastError = msg;
         VERBOSE(VB_IMPORTANT, "AudioOutput Error: " + lastError);
     }
+    void ClearError()
+     { lastError = QString::null; };
 
     void Warn(QString msg)
     {

libs/libmyth/audiooutputdx.h

@@ -35 +35 @@
     /// END HACK HACK HACK HACK
         
     virtual void Reset(void);
-    virtual void Reconfigure(int audio_bits,       int audio_channels,
-                             int audio_samplerate, int audio_passthru);
+    virtual void Reconfigure(int audio_bits, 
+                         int audio_channels, 
+                         int audio_samplerate,
+                         bool audio_passthru,
+                         AudioCodecMode aom = AUDIOCODECMODE_NORMAL);
     virtual void SetBlocking(bool blocking);
 
     virtual bool AddSamples(char *buffer, int samples, long long timecode);

libs/libmyth/audiooutputdx.cpp

@@ -130 +130 @@
     // FIXME: kedl: not sure what else could be required here?
 }
 
-void AudioOutputDX::Reconfigure(int audio_bits, int audio_channels,
-                                int audio_samplerate, int audio_passthru)
+void AudioOutputDX::Reconfigure(int audio_bits, 
+                                int audio_channels, 
+                                int audio_samplerate,
+                                int audio_passthru,
+                                AudioCodecMode laom
+                                )
 {
     if (dsbuffer)
         DestroyDSBuffer();

libs/libmyth/audiooutputbase.h

@@ -16 +16 @@
 // MythTV headers
 #include "audiooutput.h"
 #include "samplerate.h"
-#include "SoundTouch.h"
 
-#define AUDBUFSIZE 768000
+#define UPMIXINLOOP 0
+
+namespace soundtouch {
+class SoundTouch;
+};
+class FreeSurround;
+class AudioOutputDigitalEncoder;
+struct AVCodecContext;
+
 #define AUDIO_SRC_IN_SIZE   16384
 #define AUDIO_SRC_OUT_SIZE (16384*6)
 #define AUDIO_TMP_BUF_SIZE (16384*6)
 
+//#define AUDBUFSIZE 768000
+//divisible by 12,10,8,6,4,2 and around 1024000
+//#define AUDBUFSIZE 1024080
+#define AUDBUFSIZE 1536000
+
 class AudioOutputBase : public AudioOutput
 {
  public:
@@ -35 +47 @@
     virtual ~AudioOutputBase();
 
     // reconfigure sound out for new params
-    virtual void Reconfigure(int audio_bits, int audio_channels,
-                             int audio_samplerate, bool audio_passthru);
+    virtual void Reconfigure(int audio_bits, 
+                             int audio_channels, 
+                             int audio_samplerate,
+                             bool audio_passthru,
+                             void* audio_codec = NULL);
     
     // do AddSamples calls block?
     virtual void SetBlocking(bool blocking);
@@ -94 +109 @@
     void OutputAudioLoop(void);
     static void *kickoffOutputAudioLoop(void *player);
     void SetAudiotime(void);
-    int WaitForFreeSpace(int len);
+    int WaitForFreeSpace(int len, bool wait_min);
 
     int audiolen(bool use_lock); // number of valid bytes in audio buffer
     int audiofree(bool use_lock); // number of free bytes in audio buffer
@@ -125 +140 @@
     bool audio_passthru;
 
     float audio_stretchfactor;
+    AVCodecContext *audio_codec;
     AudioOutputSource source;
 
     bool killaudio;
@@ -133 +149 @@
     bool set_initial_vol;
     bool buffer_output_data_for_use; //  used by AudioOutputNULL
     
+    int configured_audio_channels;
+
  private:
     // resampler
     bool need_resampler;
@@ -144 +162 @@
 
     // timestretch
     soundtouch::SoundTouch * pSoundStretch;
+    AudioOutputDigitalEncoder * encoder;
+    FreeSurround * upmixer;
 
+#if !UPMIXINLOOP
+    int source_audio_channels;
+    int source_audio_bytes_per_sample;
+#endif
+    bool needs_upmix;
+
     bool blocking; // do AddSamples calls block?
 
     int lastaudiolen;
@@ -162 +188 @@
 
     pthread_mutex_t avsync_lock; /* must hold avsync_lock to read or write
                                     'audiotime' and 'audiotime_updated' */
-    int audiotime; // timecode of audio leaving the soundcard (same units as
+    long long audiotime; // timecode of audio leaving the soundcard (same units as
                    //                                          timecodes) ...
     struct timeval audiotime_updated; // ... which was last updated at this time
 
     /* Audio circular buffer */
     unsigned char audiobuffer[AUDBUFSIZE];  /* buffer */
     int raud, waud;     /* read and write positions */
-    int audbuf_timecode;    /* timecode of audio most recently placed into
+    long long audbuf_timecode;    /* timecode of audio most recently placed into
                    buffer */
 
     int numlowbuffer;

libs/libmyth/audiooutputbase.cpp

@@ -15 +15 @@
 
 // MythTV headers
 #include "audiooutputbase.h"
+#include "audiooutputdigitalencoder.h"
+#include "SoundTouch.h"
+#include "freesurround.h"
 #include "compat.h"
 
 #define LOC QString("AO: ")
@@ -36 +39 @@
     audio_passthru_device(QDeepCopy<QString>(laudio_passthru_device)),
     audio_passthru(false),      audio_stretchfactor(1.0f),
 
+    audio_codec(NULL),
     source(lsource),            killaudio(false),
 
     pauseaudio(false),          audio_actually_paused(false),
@@ -47 +51 @@
 
     src_ctx(NULL),
 
-    pSoundStretch(NULL),        blocking(false),
+    pSoundStretch(NULL),        
+    encoder(NULL),
+    upmixer(NULL),
+#if !UPMIXINLOOP
+    source_audio_channels(-1),
+    source_audio_bytes_per_sample(0),
+#endif
+    needs_upmix(false),
 
+    blocking(false),
+
     lastaudiolen(0),            samples_buffered(0),
 
     audio_thread_exists(false),
@@ -71 +84 @@
     memset(tmp_buff,           0, sizeof(short) * AUDIO_TMP_BUF_SIZE);
     memset(&audiotime_updated, 0, sizeof(audiotime_updated));
     memset(audiobuffer,        0, sizeof(char)  * AUDBUFSIZE);
+    configured_audio_channels = gContext->GetNumSetting("MaxChannels", 2);
 
     // You need to call Reconfigure from your concrete class.
     // Reconfigure(laudio_bits,       laudio_channels,
@@ -111 +125 @@
             VERBOSE(VB_GENERAL, LOC + QString("Using time stretch %1")
                                         .arg(audio_stretchfactor));
             pSoundStretch = new soundtouch::SoundTouch();
-            pSoundStretch->setSampleRate(audio_samplerate);
-            pSoundStretch->setChannels(audio_channels);
+            if (audio_codec)
+            {
+                if (!encoder)
+                {
+                    VERBOSE(VB_AUDIO, LOC + QString("Creating Encoder for codec %1 origfs %2").arg(audio_codec->codec_id).arg(audio_codec->frame_size));
+                    encoder = new AudioOutputDigitalEncoder();
+                    if (!encoder->Init(audio_codec->codec_id,
+                                audio_codec->bit_rate,
+                                audio_codec->sample_rate,
+                                audio_codec->channels
+                                ))
+                    {
+                        // eeks
+                        delete encoder;
+                        encoder = NULL;
+                        VERBOSE(VB_AUDIO, LOC + QString("Failed to Create Encoder"));
+                    }
+                }
+            }
+            if (encoder)
+            {
+                pSoundStretch->setSampleRate(audio_codec->sample_rate);
+                pSoundStretch->setChannels(audio_codec->channels);
+            }
+            else
+            {
+                pSoundStretch->setSampleRate(audio_samplerate);
+                pSoundStretch->setChannels(audio_channels);
+            }
 
             pSoundStretch->setTempo(audio_stretchfactor);
             pSoundStretch->setSetting(SETTING_SEQUENCE_MS, 35);
@@ -135 +176 @@
 }
 
 void AudioOutputBase::Reconfigure(int laudio_bits, int laudio_channels, 
-                                 int laudio_samplerate, bool laudio_passthru)
+                                 int laudio_samplerate, bool laudio_passthru,
+                                 void* laudio_codec)
 {
+    int codec_id = CODEC_ID_NONE;
+    int lcodec_id = CODEC_ID_NONE;
+    int lcchannels = 0;
+    int cchannels = 0;
+    int lsource_audio_channels = laudio_channels;
+    bool lneeds_upmix = false;
+
+    if (laudio_codec)
+    {
+        lcodec_id = ((AVCodecContext*)laudio_codec)->codec_id;
+        laudio_bits = 16;
+        laudio_channels = 2;
+        lsource_audio_channels = laudio_channels;
+        laudio_samplerate = 48000;
+        lcchannels = ((AVCodecContext*)laudio_codec)->channels;
+    }
+    if (audio_codec)
+    {
+        codec_id = audio_codec->codec_id;
+        cchannels = ((AVCodecContext*)audio_codec)->channels;
+    }
+    if ((configured_audio_channels == 6) && 
+        !(laudio_codec || audio_codec))
+    {
+#if !UPMIXINLOOP
+        laudio_channels = configured_audio_channels;
+#endif
+        lneeds_upmix = true;
+        VERBOSE(VB_AUDIO,LOC + "Needs upmix");
+    }
+    ClearError();
     if (laudio_bits == audio_bits && laudio_channels == audio_channels &&
-        laudio_samplerate == audio_samplerate &&
-        laudio_passthru == audio_passthru && !need_resampler)
+        laudio_samplerate == audio_samplerate && !need_resampler &&
+        laudio_passthru == audio_passthru &&
+        lneeds_upmix == needs_upmix &&
+        lcodec_id == codec_id && lcchannels == cchannels)
+    {
+        VERBOSE(VB_AUDIO,LOC + "no change exiting");
         return;
-
+    }
     KillAudio();
     
     pthread_mutex_lock(&audio_buflock);
@@ -151 +228 @@
     waud = raud = 0;
     audio_actually_paused = false;
     
+    bool redo_stretch = (pSoundStretch && audio_channels != laudio_channels);
     audio_channels = laudio_channels;
+#if !UPMIXINLOOP
+    source_audio_channels = lsource_audio_channels;
+#endif
     audio_bits = laudio_bits;
     audio_samplerate = laudio_samplerate;
+    audio_codec = (AVCodecContext*)laudio_codec;
     audio_passthru = laudio_passthru;
+    needs_upmix = lneeds_upmix;
     if (audio_bits != 8 && audio_bits != 16)
     {
         pthread_mutex_unlock(&avsync_lock);
@@ -163 +246 @@
         return;
     }
     audio_bytes_per_sample = audio_channels * audio_bits / 8;
+#if !UPMIXINLOOP
+    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
+#endif
     
     need_resampler = false;
     killaudio = false;
@@ -172 +258 @@
     
     numlowbuffer = 0;
 
+#if UPMIXINLOOP
+    int fake_channels = audio_channels;
+    audio_channels = configured_audio_channels;
+    VERBOSE(VB_GENERAL, QString("Opening audio device '%1'. ch %2(%3) sr %4")
+            .arg(audio_main_device).arg(configured_audio_channels)
+            .arg(audio_channels).arg(audio_samplerate));
+    
     // Actually do the device specific open call
+    bool openresult = OpenDevice();
+    audio_channels = fake_channels;
+    if (!openresult)
+#else
+    VERBOSE(VB_GENERAL, QString("Opening audio device '%1'. ch %2(%3) sr %4")
+            .arg(audio_main_device).arg(audio_channels)
+            .arg(source_audio_channels).arg(audio_samplerate));
+ 
+    // Actually do the device specific open call
     if (!OpenDevice())
+#endif
     {
         VERBOSE(VB_AUDIO, LOC_ERR + "Aborting reconfigure");
         pthread_mutex_unlock(&avsync_lock);
         pthread_mutex_unlock(&audio_buflock);
+        if (GetError().isEmpty())
+            Error("Aborting reconfigure");
+        VERBOSE(VB_AUDIO, "Aborting reconfigure");
         return;
     }
 
@@ -200 +306 @@
     current_seconds = -1;
     source_bitrate = -1;
 
+    // NOTE: this wont do anything as above samplerate vars are set equal
     // Check if we need the resampler
     if (audio_samplerate != laudio_samplerate)
     {
@@ -222 +329 @@
         need_resampler = true;
     }
 
+    if (needs_upmix)
+    {
+        VERBOSE(VB_AUDIO, LOC + QString("create upmixer"));
+        upmixer = new FreeSurround(audio_samplerate, source == AUDIOOUTPUT_VIDEO);
+        VERBOSE(VB_AUDIO, LOC + QString("create upmixer done"));
+    }
+
     VERBOSE(VB_AUDIO, LOC + QString("Audio Stretch Factor: %1")
             .arg(audio_stretchfactor));
+    VERBOSE(VB_AUDIO, QString("Audio Codec Used: %1")
+            .arg(audio_codec?codec_id_string(audio_codec->codec_id):"not set"));
 
-    SetStretchFactorLocked(audio_stretchfactor);
-    if (pSoundStretch)
+    if (redo_stretch)
     {
-        pSoundStretch->setSampleRate(audio_samplerate);
-        pSoundStretch->setChannels(audio_channels);
+        float laudio_stretchfactor = audio_stretchfactor;
+        delete pSoundStretch;
+        pSoundStretch = NULL;
+        audio_stretchfactor = 0.0;
+        SetStretchFactorLocked(laudio_stretchfactor);
     }
+    else
+    {
+        SetStretchFactorLocked(audio_stretchfactor);
+        if (pSoundStretch)
+        {
+            // if its passthru then we need to reencode
+            if (audio_codec)
+            {
+                if (!encoder)
+                {
+                    VERBOSE(VB_AUDIO, LOC + QString("Creating Encoder for codec %1").arg(audio_codec->codec_id));
+                    encoder = new AudioOutputDigitalEncoder();
+                    if (!encoder->Init(audio_codec->codec_id,
+                                audio_codec->bit_rate,
+                                audio_codec->sample_rate,
+                                audio_codec->channels
+                                ))
+                    {
+                        // eeks
+                        delete encoder;
+                        encoder = NULL;
+                        VERBOSE(VB_AUDIO, LOC + QString("Failed to Create Encoder"));
+                    }
+                }
+            }
+            if (encoder)
+            {
+                pSoundStretch->setSampleRate(audio_codec->sample_rate);
+                pSoundStretch->setChannels(audio_codec->channels);
+            }
+            else
+            {
+                pSoundStretch->setSampleRate(audio_samplerate);
+                pSoundStretch->setChannels(audio_channels);
+            }
+        }
+    }
 
     // Setup visualisations, zero the visualisations buffers
     prepareVisuals();
@@ -290 +445 @@
         pSoundStretch = NULL;
     }
 
+    if (encoder)
+    {
+        delete encoder;
+        encoder = NULL;
+    }
+
+    if (upmixer)
+    {
+        delete upmixer;
+        upmixer = NULL;
+    }
+    needs_upmix = false;
+
     CloseDevice();
 
     killAudioLock.unlock();
@@ -303 +471 @@
 
 void AudioOutputBase::Pause(bool paused)
 {
+    VERBOSE(VB_AUDIO, LOC+ QString("Pause %0").arg(paused));
     pauseaudio = paused;
     audio_actually_paused = false;
 }
@@ -385 +554 @@
        The reason is that computing 'audiotime' requires acquiring the audio 
        lock, which the video thread should not do. So, we call 'SetAudioTime()'
        from the audio thread, and then call this from the video thread. */
-    int ret;
+    long long ret;
     struct timeval now;
 
     if (audiotime == 0)
@@ -397 +566 @@
 
     ret = (now.tv_sec - audiotime_updated.tv_sec) * 1000;
     ret += (now.tv_usec - audiotime_updated.tv_usec) / 1000;
-    ret = (int)(ret * audio_stretchfactor);
+    ret = (long long)(ret * audio_stretchfactor);
 
+#if 1
+    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
+            QString("GetAudiotime now=%1.%2, set=%3.%4, ret=%5, audt=%6 sf=%7")
+            .arg(now.tv_sec).arg(now.tv_usec)
+            .arg(audiotime_updated.tv_sec).arg(audiotime_updated.tv_usec)
+            .arg(ret)
+            .arg(audiotime)
+            .arg(audio_stretchfactor)
+           );
+#endif
+
     ret += audiotime;
 
     pthread_mutex_unlock(&avsync_lock);
-    return ret;
+    return (int)ret;
 }
 
 void AudioOutputBase::SetAudiotime(void)
@@ -439 +619 @@
     // include algorithmic latencies
     if (pSoundStretch)
     {
+        // add the effect of any unused but processed samples, AC3 reencode does this
+        totalbuffer += (int)(pSoundStretch->numSamples() * audio_bytes_per_sample);
         // add the effect of unprocessed samples in time stretch algo
         totalbuffer += (int)((pSoundStretch->numUnprocessedSamples() *
                               audio_bytes_per_sample) / audio_stretchfactor);
     }
-               
+
+#if !UPMIXINLOOP
+    if (upmixer && needs_upmix)
+    {
+        totalbuffer += upmixer->sampleLatency() * audio_bytes_per_sample;
+    }
+#endif
+
     audiotime = audbuf_timecode - (int)(totalbuffer * 100000.0 /
                                    (audio_bytes_per_sample * effdspstretched));
  
     gettimeofday(&audiotime_updated, NULL);
+#if 1
+    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
+            QString("SetAudiotime set=%1.%2, audt=%3 atc=%4 tb=%5 sb=%6 eds=%7 abps=%8 sf=%9")
+            .arg(audiotime_updated.tv_sec).arg(audiotime_updated.tv_usec)
+            .arg(audiotime)
+            .arg(audbuf_timecode)
+            .arg(totalbuffer)
+            .arg(soundcard_buffer)
+            .arg(effdspstretched)
+            .arg(audio_bytes_per_sample)
+            .arg(audio_stretchfactor)
+           );
+#endif
 
     pthread_mutex_unlock(&avsync_lock);
     pthread_mutex_unlock(&audio_buflock);
@@ -464 +666 @@
     if (need_resampler && src_ctx)
         len = (int)ceilf(float(len) * src_data.src_ratio);
 
+#if !UPMIXINLOOP
+    // include samples in upmix buffer that may be flushed
+    if (needs_upmix && upmixer)
+        len += upmixer->numUnprocessedSamples()*audio_bytes_per_sample;
+#endif
+
     if ((len > afree) && !blocking)
     {
         VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + QString(
@@ -515 +723 @@
     // NOTE: This function is not threadsafe
 
     int afree = audiofree(true);
-    int len = samples * audio_bytes_per_sample;
+    int len = samples * (encoder?encoder->audio_bytes_per_sample:audio_bytes_per_sample);
 
     // Check we have enough space to write the data
     if (need_resampler && src_ctx)
         len = (int)ceilf(float(len) * src_data.src_ratio);
 
+#if !UPMIXINLOOP
+    // include samples in upmix buffer that may be flushed
+    if (needs_upmix && upmixer)
+        len += upmixer->numUnprocessedSamples()*audio_bytes_per_sample;
+#endif
+ 
     if ((len > afree) && !blocking)
     {
         VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + QString(
                 "AddSamples FAILED bytes=%1, used=%2, free=%3, timecode=%4") 
                 .arg(len).arg(AUDBUFSIZE-afree).arg(afree)
                 .arg(timecode)); 
-
         return false; // would overflow
     }
 
@@ -562 +775 @@
     return true;
 }
 
-int AudioOutputBase::WaitForFreeSpace(int samples)
+int AudioOutputBase::WaitForFreeSpace(int samples, bool wait_min)
 {
-    int len = samples * audio_bytes_per_sample;
+    int abps = encoder?encoder->audio_bytes_per_sample:audio_bytes_per_sample;
+    int len = samples * abps;
     int afree = audiofree(false);
 
     while (len > afree)
     {
         if (blocking)
         {
-            VERBOSE(VB_AUDIO, LOC + "Waiting for free space " +
+            VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + "Waiting for free space " +
                     QString("(need %1, available %2)").arg(len).arg(afree));
 
             // wait for more space
@@ -580 +794 @@
         }
         else
         {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Audio buffer overflow, audio data lost!");
-            samples = afree / audio_bytes_per_sample;
-            len = samples * audio_bytes_per_sample;
+            if (wait_min)
+            {
+                int time_to_wait = ((len-afree)*1000000)/(audio_samplerate*abps);
+                pthread_mutex_unlock(&audio_buflock);
+                usleep(time_to_wait + 5000);    // 5ms extra to allow for output loop
+                pthread_mutex_lock(&audio_buflock);
+                afree = audiofree(false);
+                wait_min = false;               // do it once only
+                continue;
+            }
+            VERBOSE(VB_IMPORTANT, LOC_ERR + 
+                    QString("Audio buffer overflow, %1 audio samples lost!")
+                        .arg(samples-afree / abps));
+            samples = afree / abps;
+            len = samples * abps;
             if (src_ctx) 
             {
                 int error = src_reset(src_ctx);
@@ -608 +833 @@
     
     int afree = audiofree(false);
 
-    VERBOSE(VB_AUDIO|VB_TIMESTAMP,
-            LOC + QString("_AddSamples bytes=%1, used=%2, free=%3, timecode=%4")
-            .arg(samples * audio_bytes_per_sample)
-            .arg(AUDBUFSIZE-afree).arg(afree).arg((long)timecode));
+    int abps = encoder?encoder->audio_bytes_per_sample:audio_bytes_per_sample;
+    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
+            LOC + QString("_AddSamples samples=%1 bytes=%2, used=%3, free=%4, timecode=%5 needsupmix %6 upmixer %7")
+            .arg(samples)
+            .arg(samples * abps)
+            .arg(AUDBUFSIZE-afree).arg(afree).arg(timecode)
+            .arg(needs_upmix).arg((uint)(void*)upmixer)
+            );
     
-    len = WaitForFreeSpace(samples);
-
-    if (interleaved) 
+#if !UPMIXINLOOP
+    if (upmixer && needs_upmix)
     {
-        char *mybuf = (char*)buffer;
-        int bdiff = AUDBUFSIZE - org_waud;
-        if (bdiff < len)
+        int out_samples = 0;
+        int step = (interleaved)?source_audio_channels:1;
+        len = WaitForFreeSpace(samples, true);    // test
+        for(int itemp=0; itemp<samples; )
         {
-            memcpy(audiobuffer + org_waud, mybuf, bdiff);
-            memcpy(audiobuffer, mybuf + bdiff, len - bdiff);
+            // just in case it does a processing cycle, release the lock
+            // to allow the output loop to do output
+            pthread_mutex_unlock(&audio_buflock);
+            if (audio_bytes == 2)
+                itemp += upmixer->putSamples((short*)buffer+itemp*step,samples-itemp,source_audio_channels,interleaved?0:samples);
+            else
+                itemp += upmixer->putSamples((char*)buffer+itemp*step,samples-itemp,source_audio_channels,interleaved?0:samples);
+            pthread_mutex_lock(&audio_buflock);
+
+            int copy_samples = upmixer->numSamples();
+            if (copy_samples)
+            {
+                int copy_len = copy_samples * abps;
+                out_samples += copy_samples;
+                if (out_samples > samples)
+                    len = WaitForFreeSpace(out_samples, true);
+                int bdiff = AUDBUFSIZE - org_waud;
+                if (bdiff < copy_len) 
+                {
+                    int bdiff_samples = bdiff/abps;
+                    upmixer->receiveSamples((short*)(audiobuffer + org_waud), bdiff_samples);
+                    upmixer->receiveSamples((short*)(audiobuffer), (copy_samples - bdiff_samples));
+                }
+                else
+                {
+                    upmixer->receiveSamples((short*)(audiobuffer + org_waud), copy_samples);
+                }
+                org_waud = (org_waud + copy_len) % AUDBUFSIZE;
+            }
         }
-        else
-            memcpy(audiobuffer + org_waud, mybuf, len);
- 
-        org_waud = (org_waud + len) % AUDBUFSIZE;
-    } 
-    else 
+        if (samples > 0)
+        {
+            len = WaitForFreeSpace(out_samples, true);
+        }
+        samples = out_samples;
+    }
+    else
+#endif
     {
-        char **mybuf = (char**)buffer;
-        for (int itemp = 0; itemp < samples * audio_bytes; itemp += audio_bytes)
+        len = WaitForFreeSpace(samples, true);
+
+        if (interleaved) 
         {
-            for (int chan = 0; chan < audio_channels; chan++)
+            char *mybuf = (char*)buffer;
+            int bdiff = AUDBUFSIZE - org_waud;
+            if (bdiff < len)
             {
-                audiobuffer[org_waud++] = mybuf[chan][itemp];
-                if (audio_bits == 16)
-                    audiobuffer[org_waud++] = mybuf[chan][itemp+1];
+                memcpy(audiobuffer + org_waud, mybuf, bdiff);
+                memcpy(audiobuffer, mybuf + bdiff, len - bdiff);
+            }
+            else
+                memcpy(audiobuffer + org_waud, mybuf, len);
+     
+            org_waud = (org_waud + len) % AUDBUFSIZE;
+        } 
+        else 
+        {
+            char **mybuf = (char**)buffer;
+            for (int itemp = 0; itemp < samples * audio_bytes; itemp += audio_bytes)
+            {
+                for (int chan = 0; chan < audio_channels; chan++)
+                {
+                    audiobuffer[org_waud++] = mybuf[chan][itemp];
+                    if (audio_bits == 16)
+                        audiobuffer[org_waud++] = mybuf[chan][itemp+1];
 
-                if (org_waud >= AUDBUFSIZE)
-                    org_waud -= AUDBUFSIZE;
+                    if (org_waud >= AUDBUFSIZE)
+                        org_waud -= AUDBUFSIZE;
+                }
             }
         }
     }
 
-    if (pSoundStretch)
+#if !UPMIXINLOOP
+    if (samples > 0)
+#endif
     {
-        // does not change the timecode, only the number of samples
-        // back to orig pos
-        org_waud = waud;
-        int bdiff = AUDBUFSIZE - org_waud;
-        int nSamplesToEnd = bdiff/audio_bytes_per_sample;
-        if (bdiff < len)
+        if (pSoundStretch)
         {
-            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)(audiobuffer + 
-                                      org_waud), nSamplesToEnd);
-            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)audiobuffer,
-                                      (len - bdiff) / audio_bytes_per_sample);
-        }
-        else
-        {
-            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)(audiobuffer + 
-                                      org_waud), len / audio_bytes_per_sample);
-        }
 
-        int newLen = 0;
-        int nSamples;
-        len = WaitForFreeSpace(pSoundStretch->numSamples() * 
-                               audio_bytes_per_sample);
-        do 
-        {
-            int samplesToGet = len/audio_bytes_per_sample;
-            if (samplesToGet > nSamplesToEnd)
+            // does not change the timecode, only the number of samples
+            // back to orig pos
+            org_waud = waud;
+            int bdiff = AUDBUFSIZE - org_waud;
+            int nSamplesToEnd = bdiff/abps;
+            if (bdiff < len)
             {
-                samplesToGet = nSamplesToEnd;    
+                pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)(audiobuffer + 
+                                          org_waud), nSamplesToEnd);
+                pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)audiobuffer,
+                                          (len - bdiff) / abps);
             }
+            else
+            {
+                pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)(audiobuffer + 
+                                          org_waud), len / abps);
+            }
 
-            nSamples = pSoundStretch->receiveSamples((soundtouch::SAMPLETYPE*)
-                                      (audiobuffer + org_waud), samplesToGet);
-            if (nSamples == nSamplesToEnd)
+            if (encoder)
             {
-                org_waud = 0;
-                nSamplesToEnd = AUDBUFSIZE/audio_bytes_per_sample;
+                // pull out a packet's worth and reencode it until we dont have enough
+                // for any more packets
+                soundtouch::SAMPLETYPE* temp_buff = 
+                    (soundtouch::SAMPLETYPE*)encoder->GetFrameBuffer();
+                size_t frameSize = encoder->FrameSize()/abps;
+                VERBOSE(VB_AUDIO|VB_TIMESTAMP,
+                        QString("_AddSamples Enc sfs=%1 bfs=%2 sss=%3")
+                        .arg(frameSize)
+                        .arg(encoder->FrameSize())
+                        .arg(pSoundStretch->numSamples())
+                       );
+                // process the same number of samples as it creates a full encoded buffer
+                // just like before
+                while (pSoundStretch->numSamples() >= frameSize)
+                {
+                    int got = pSoundStretch->receiveSamples(temp_buff, frameSize);
+                    int amount = encoder->Encode(temp_buff);
+                    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
+                            QString("_AddSamples Enc bytes=%1 got=%2 left=%3")
+                            .arg(amount)
+                            .arg(got)
+                            .arg(pSoundStretch->numSamples())
+                           );
+                    if (amount == 0)
+                        continue;
+                    //len = WaitForFreeSpace(amount);
+                    char * ob = encoder->GetOutBuff();
+                    if (amount >= bdiff)
+                    {
+                        memcpy(audiobuffer + org_waud, ob, bdiff);
+                        ob += bdiff;
+                        amount -= bdiff;
+                        org_waud = 0;
+                    }
+                    if (amount > 0)
+                        memcpy(audiobuffer + org_waud, ob, amount);
+                    bdiff = AUDBUFSIZE - amount;
+                    org_waud += amount;
+                }
             }
             else
             {
-                org_waud += nSamples * audio_bytes_per_sample;
-                nSamplesToEnd -= nSamples;
+                int newLen = 0;
+                int nSamples;
+                len = WaitForFreeSpace(pSoundStretch->numSamples() * 
+                                       audio_bytes_per_sample, true);
+                do 
+                {
+                    int samplesToGet = len/audio_bytes_per_sample;
+                    if (samplesToGet > nSamplesToEnd)
+                    {
+                        samplesToGet = nSamplesToEnd;    
+                    }
+
+                    nSamples = pSoundStretch->receiveSamples((soundtouch::SAMPLETYPE*)
+                                              (audiobuffer + org_waud), samplesToGet);
+                    if (nSamples == nSamplesToEnd)
+                    {
+                        org_waud = 0;
+                        nSamplesToEnd = AUDBUFSIZE/audio_bytes_per_sample;
+                    }
+                    else
+                    {
+                        org_waud += nSamples * audio_bytes_per_sample;
+                        nSamplesToEnd -= nSamples;
+                    }
+
+                    newLen += nSamples * audio_bytes_per_sample;
+                    len -= nSamples * audio_bytes_per_sample;
+                } while (nSamples > 0);
             }
+        }
 
-            newLen += nSamples * audio_bytes_per_sample;
-            len -= nSamples * audio_bytes_per_sample;
-        } while (nSamples > 0);
-    }
+        waud = org_waud;
+        lastaudiolen = audiolen(false);
 
-    waud = org_waud;
-    lastaudiolen = audiolen(false);
+        if (timecode < 0)
+        {
+            // mythmusic doesn't give timestamps..
+            timecode = (int)((samples_buffered * 100000.0) / effdsp);
+        }
+        
+        samples_buffered += samples;
+        
+        /* we want the time at the end -- but the file format stores
+           time at the start of the chunk. */
+        // even with timestretch, timecode is still calculated from original
+        // sample count
+        audbuf_timecode = timecode + (int)((samples * 100000.0) / effdsp);
 
-    samples_buffered += samples;
-    
-    if (timecode < 0)
-    {
-        // mythmusic doesn't give timestamps..
-        timecode = (int)((samples_buffered * 100000.0) / effdsp);
+        if (interleaved)
+#if UPMIXINLOOP
+            dispatchVisual((unsigned char *)buffer, len, timecode, audio_channels, audio_bits);
+#else
+            dispatchVisual((unsigned char *)buffer, len, timecode, source_audio_channels, audio_bits);
+#endif
     }
-    
-    /* we want the time at the end -- but the file format stores
-       time at the start of the chunk. */
-    // even with timestretch, timecode is still calculated from original
-    // sample count
-    audbuf_timecode = timecode + (int)((samples * 100000.0) / effdsp);
 
-    if (interleaved)
-        dispatchVisual((unsigned char *)buffer, len, timecode, audio_channels, audio_bits);
-
     pthread_mutex_unlock(&audio_buflock);
 }
 
@@ -728 +1060 @@
 
     if (source_bitrate == -1)
     {
+#if UPMIXINLOOP
         source_bitrate = audio_samplerate * audio_channels * audio_bits;
+#else
+        source_bitrate = audio_samplerate * source_audio_channels * audio_bits;
+#endif
     }
 
     if (ct / 1000 != current_seconds) 
     {
         current_seconds = ct / 1000;
+#if UPMIXINLOOP
         OutputEvent e(current_seconds, ct,
                       source_bitrate, audio_samplerate, audio_bits, 
                       audio_channels);
+#else
+        OutputEvent e(current_seconds, ct,
+                      source_bitrate, audio_samplerate, audio_bits, 
+                      source_audio_channels);
+#endif
         dispatch(e);
     }
 }
@@ -769 +1111 @@
             space_on_soundcard = getSpaceOnSoundcard();
 
             if (space_on_soundcard != last_space_on_soundcard) {
-                VERBOSE(VB_AUDIO, LOC + QString("%1 bytes free on soundcard")
+                VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + QString("%1 bytes free on soundcard")
                         .arg(space_on_soundcard));
                 last_space_on_soundcard = space_on_soundcard;
             }
@@ -782 +1124 @@
                     WriteAudio(zeros, fragment_size);
                 } else {
                     // this should never happen now -dag
-                    VERBOSE(VB_AUDIO, LOC +
+                    VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + 
                             QString("waiting for space on soundcard "
                                     "to write zeros: have %1 need %2")
                             .arg(space_on_soundcard).arg(fragment_size));
@@ -818 +1160 @@
         if (fragment_size > audiolen(true))
         {
             if (audiolen(true) > 0)  // only log if we're sending some audio
-                VERBOSE(VB_AUDIO, LOC +
+                VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC +
                         QString("audio waiting for buffer to fill: "
                                 "have %1 want %2")
                         .arg(audiolen(true)).arg(fragment_size));
 
-            VERBOSE(VB_AUDIO, LOC + "Broadcasting free space avail");
+            //VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + "Broadcasting free space avail");
             pthread_mutex_lock(&audio_buflock);
             pthread_cond_broadcast(&audio_bufsig);
             pthread_mutex_unlock(&audio_buflock);
@@ -837 +1179 @@
         if (fragment_size > space_on_soundcard)
         {
             if (space_on_soundcard != last_space_on_soundcard) {
-                VERBOSE(VB_AUDIO, LOC +
+                VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC +
                         QString("audio waiting for space on soundcard: "
                                 "have %1 need %2")
                         .arg(space_on_soundcard).arg(fragment_size));
@@ -899 +1241 @@
 
         /* update raud */
         raud = (raud + fragment_size) % AUDBUFSIZE;
-        VERBOSE(VB_AUDIO, LOC + "Broadcasting free space avail");
+        //VERBOSE(VB_AUDIO|VB_TIMESTAMP, LOC + "Broadcasting free space avail");
         pthread_cond_broadcast(&audio_bufsig);
 
         written_size = fragment_size;

libs/libmyth/audiooutputalsa.cpp

@@ -52 +52 @@
     QString real_device = (audio_passthru) ?
         audio_passthru_device : audio_main_device;
 
+    int index;
+    if ((index=real_device.find('|'))>=0)
+    {
+        if (audio_channels >= 2)
+            real_device = real_device.mid(index+1);
+        else
+            real_device = real_device.left(index);
+    }
+
     VERBOSE(VB_GENERAL, QString("Opening ALSA audio device '%1'.")
             .arg(real_device));
 
@@ -89 +98 @@
     }
     else
     {
-        fragment_size = 6144; // nicely divisible by 2,4,6,8 channels @ 16-bits
-        buffer_time = 500000;  // .5 seconds
+        //fragment_size = 6144; // nicely divisible by 2,4,6,8 channels @ 16-bits
+        //fragment_size = 3072*audio_channels; // nicely divisible by 2,4,6,8 channels @ 16-bits
+        fragment_size = (audio_bits * audio_channels * audio_samplerate) / (8*30);
+        buffer_time = 100000;  // .5 seconds
         period_time = buffer_time / 4;  // 4 interrupts per buffer
     }
 
@@ -162 +173 @@
     
     tmpbuf = aubuf;
 
-    VERBOSE(VB_AUDIO, QString("WriteAudio: Preparing %1 bytes (%2 frames)")
+    VERBOSE(VB_AUDIO|VB_TIMESTAMP, QString("WriteAudio: Preparing %1 bytes (%2 frames)")
             .arg(size).arg(frames));
     
     while (frames > 0) 

programs/mythfrontend/globalsettings.cpp

@@ -57 +57 @@
 #endif
 #ifdef USING_ALSA
     gc->addSelection("ALSA:default", "ALSA:default");
+    gc->addSelection("ALSA:surround51", "ALSA:surround51");
+    gc->addSelection("ALSA:analog", "ALSA:analog");
+    gc->addSelection("ALSA:digital", "ALSA:digital");
+    gc->addSelection("ALSA:mixed-analog", "ALSA:mixed-analog");
+    gc->addSelection("ALSA:mixed-digital", "ALSA:mixed-digital");
 #endif
 #ifdef USING_ARTS
     gc->addSelection("ARTS:", "ARTS:");
@@ -78 +83 @@
     return gc;
 }
 
+static HostComboBox *MaxAudioChannels()
+{
+    HostComboBox *gc = new HostComboBox("MaxChannels",false);
+    gc->setLabel(QObject::tr("Max Audio Channels"));
+    gc->addSelection(QObject::tr("Stereo"), "2", true); // default
+    gc->addSelection(QObject::tr("5.1 Ch"), "6");
+    gc->setHelpText(
+            QObject::tr("Set the maximum number of audio channels to be decoded. "
+                "This is for multi-channel/surround audio playback."));
+    return gc;
+}
+
 static HostComboBox *PassThroughOutputDevice()
 {
     HostComboBox *gc = new HostComboBox("PassThruOutputDevice", true);
@@ -3144 +3161 @@
              new VerticalConfigurationGroup(false, false, true, true);
          vgrp0->addChild(AC3PassThrough());
          vgrp0->addChild(DTSPassThrough());
+         addChild(MaxAudioChannels());
 
          VerticalConfigurationGroup *vgrp1 =
              new VerticalConfigurationGroup(false, false, true, true);

programs/mythtranscode/transcode.cpp

@@ -55 +55 @@
 
     // reconfigure sound out for new params
     virtual void Reconfigure(int audio_bits, int audio_channels,
-                             int audio_samplerate, bool audio_passthru)
+                             int audio_samplerate, bool audio_passthru,
+                             void * = NULL)
     {
+        ClearError();
         (void)audio_samplerate;
         (void)audio_passthru;
         bits = audio_bits;
         channels = audio_channels;
         bytes_per_sample = bits * channels / 8;
+        if (channels>2)
+            Error("Invalid channel count");
     }
 
     // dsprate is in 100 * samples/second

programs/mythuitest/mythuitest.pro

@@ -6 +6 @@
 TARGET = mythuitest
 CONFIG += thread opengl
 
+LIBS += -L../../libs/libavcodec -L../../libs/libavutil
+LIBS += -lmythavcodec-$$LIBVERSION -lmythavutil-$$LIBVERSION
 LIBS += $$EXTRA_LIBS
 
+TARGETDEPS += ../../libs/libavcodec/libmythavcodec-$${LIBVERSION}.$${QMAKE_EXTENSION_SHLIB}
+TARGETDEPS += ../../libs/libavutil/libmythavutil-$${LIBVERSION}.$${QMAKE_EXTENSION_SHLIB}
+
 macx {
     # Duplication of source with libmyth (e.g. oldsettings.cpp)
     # means that the linker complains, so we have to ignore duplicates 

libs/libmythtv/avformatdecoder.h

@@ -259 +259 @@
     bool              allow_ac3_passthru;
     bool              allow_dts_passthru;
     bool              disable_passthru;
+    int               max_channels;
 
     AudioInfo         audioIn;
     AudioInfo         audioOut;

libs/libmythtv/avformatdecoder.cpp

@@ -51 +51 @@
 
 #define MAX_AC3_FRAME_SIZE 6144
 
-/** Set to zero to allow any number of AC3 channels. */
-#define MAX_OUTPUT_CHANNELS 2
-
 static int cc608_parity(uint8_t byte);
 static int cc608_good_parity(const int *parity_table, uint16_t data);
 static void cc608_build_parity_table(int *parity_table);
@@ -417 +414 @@
 
     allow_ac3_passthru = gContext->GetNumSetting("AC3PassThru", false);
     allow_dts_passthru = gContext->GetNumSetting("DTSPassThru", false);
+    max_channels = gContext->GetNumSetting("MaxChannels", 2);
 
     audioIn.sample_size = -32; // force SetupAudioStream to run once
     itv = GetNVP()->GetInteractiveTV();
@@ -1580 +1578 @@
                             <<") already open, leaving it alone.");
                 }
                 //assert(enc->codec_id);
+                VERBOSE(VB_GENERAL, QString("AVFD: codec %1 has %2 channels").arg(codec_id_string(enc->codec_id)).arg(enc->channels));
 
+#if 0
+                // HACK MULTICHANNEL DTS passthru disabled for multichannel, dont know how to handle this
                 // HACK BEGIN REALLY UGLY HACK FOR DTS PASSTHRU
                 if (enc->codec_id == CODEC_ID_DTS)
                 {
@@ -1589 +1590 @@
                     // enc->bit_rate = what??;
                 }
                 // HACK END REALLY UGLY HACK FOR DTS PASSTHRU
+#endif
 
                 bitrate += enc->bit_rate;
                 break;
@@ -3260 +3262 @@
                     if (!curstream->codec->channels)
                     {
                         QMutexLocker locker(&avcodeclock);
-                        curstream->codec->channels = MAX_OUTPUT_CHANNELS;
+                        VERBOSE(VB_IMPORTANT, LOC + QString("Setting channels to %1").arg(audioOut.channels));
+                        curstream->codec->channels = audioOut.channels;
                         ret = avcodec_decode_audio(
                             curstream->codec, audioSamples,
                             &data_size, ptr, len);
@@ -3321 +3324 @@
                         AVCodecContext *ctx = curstream->codec;
 
                         if ((ctx->channels == 0) ||
-                            (ctx->channels > MAX_OUTPUT_CHANNELS))
-                            ctx->channels = MAX_OUTPUT_CHANNELS;
+                            (ctx->channels > audioOut.channels))
+                            ctx->channels = audioOut.channels;
 
                         ret = avcodec_decode_audio(
                             ctx, audioSamples, &data_size, ptr, len);
@@ -3675 +3678 @@
 
 void AvFormatDecoder::SetDisablePassThrough(bool disable)
 {
+    // can only disable never reenable as once timestretch is on its on for the session
+    if (disable_passthru)
+        return;
     if (selectedTrack[kTrackTypeAudio].av_stream_index < 0)
     {
         disable_passthru = disable;
@@ -3707 +3713 @@
     AVCodecContext *codec_ctx = NULL;
     AudioInfo old_in  = audioIn;
     AudioInfo old_out = audioOut;
+    bool using_passthru = false;
 
     if ((currentTrack[kTrackTypeAudio] >= 0) &&
         (selectedTrack[kTrackTypeAudio].av_stream_index <=
@@ -3718 +3725 @@
         assert(curstream->codec);
         codec_ctx = curstream->codec;        
         bool do_ac3_passthru = (allow_ac3_passthru && !transcoding &&
-                                !disable_passthru &&
                                 (codec_ctx->codec_id == CODEC_ID_AC3));
         bool do_dts_passthru = (allow_dts_passthru && !transcoding &&
-                                !disable_passthru &&
                                 (codec_ctx->codec_id == CODEC_ID_DTS));
+        using_passthru = do_ac3_passthru || do_dts_passthru;
         info = AudioInfo(codec_ctx->codec_id,
                          codec_ctx->sample_rate, codec_ctx->channels,
-                         do_ac3_passthru || do_dts_passthru);
+                         using_passthru && !disable_passthru);
     }
 
     if (info == audioIn)
         return false; // no change
 
+    QString ptmsg = "";
+    if (using_passthru)
+    {
+        ptmsg = QString(" using passthru");
+    }
     VERBOSE(VB_AUDIO, LOC + "Initializing audio parms from " +
             QString("audio track #%1").arg(currentTrack[kTrackTypeAudio]+1));
 
     audioOut = audioIn = info;
-    if (audioIn.do_passthru)
+    if (using_passthru)
     {
         // A passthru stream looks like a 48KHz 2ch (@ 16bit) to the sound card
-        audioOut.channels    = 2;
-        audioOut.sample_rate = 48000;
-        audioOut.sample_size = 4;
+        AudioInfo digInfo = audioOut;
+        if (!disable_passthru)
+        {
+            digInfo.channels    = 2;
+            digInfo.sample_rate = 48000;
+            digInfo.sample_size = 4;
+        }
+        if (audioOut.channels > max_channels)
+        {
+            audioOut.channels = max_channels;
+            audioOut.sample_size = audioOut.channels * 2;
+            codec_ctx->channels = audioOut.channels;
+        }
+        VERBOSE(VB_AUDIO, LOC + "Audio format changed digital passthrough " +
+                QString("%1\n\t\t\tfrom %2 ; %3\n\t\t\tto   %4 ; %5")
+                .arg(digInfo.toString())
+                .arg(old_in.toString()).arg(old_out.toString())
+                .arg(audioIn.toString()).arg(audioOut.toString()));
+
+        if (digInfo.sample_rate > 0)
+            GetNVP()->SetEffDsp(digInfo.sample_rate * 100);
+
+        GetNVP()->SetAudioParams(digInfo.bps(), digInfo.channels,
+                                 digInfo.sample_rate, audioIn.do_passthru);
+        // allow the audio stuff to reencode
+        GetNVP()->SetAudioCodec(codec_ctx);
+        GetNVP()->ReinitAudio();
+        return true;
     }
     else
     {
-        if (audioOut.channels > MAX_OUTPUT_CHANNELS)
+        if (audioOut.channels > max_channels)
         {
-            audioOut.channels = MAX_OUTPUT_CHANNELS;
+            audioOut.channels = max_channels;
             audioOut.sample_size = audioOut.channels * 2;
-            codec_ctx->channels = MAX_OUTPUT_CHANNELS;
+            codec_ctx->channels = audioOut.channels;
         }
     }
+    bool audiook;
 
     VERBOSE(VB_AUDIO, LOC + "Audio format changed " +
             QString("\n\t\t\tfrom %1 ; %2\n\t\t\tto   %3 ; %4")
@@ -3763 +3800 @@
     GetNVP()->SetAudioParams(audioOut.bps(), audioOut.channels,
                              audioOut.sample_rate,
                              audioIn.do_passthru);
-    GetNVP()->ReinitAudio();
+    // allow the audio stuff to reencode
+    GetNVP()->SetAudioCodec(using_passthru?codec_ctx:NULL);
+    QString errMsg = GetNVP()->ReinitAudio();
+    audiook = errMsg.isEmpty();
 
     return true;
 }

libs/libmythtv/NuppelVideoPlayer.h

@@ -127 +127 @@
     void SetAudioInfo(const QString &main, const QString &passthru, uint rate);
     void SetAudioParams(int bits, int channels, int samplerate, bool passthru);
     void SetEffDsp(int dsprate);
+    void SetAudioCodec(void *ac);
 
     // Sets
     void SetParentWidget(QWidget *widget)     { parentWidget = widget; }
@@ -682 +683 @@
     int      audio_bits;
     int      audio_samplerate;
     float    audio_stretchfactor;
+    void     *audio_codec;
     bool     audio_passthru;
 
     // Picture-in-Picture

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -206 +206 @@
       audio_passthru_device(QString::null),
       audio_channels(2),            audio_bits(-1),
       audio_samplerate(44100),      audio_stretchfactor(1.0f),
+      audio_codec(NULL),
       // Picture-in-Picture
       pipplayer(NULL), setpipplayer(NULL), needsetpipplayer(false),
       // Preview window support
@@ -767 +768 @@
     if (audioOutput)
     {
         audioOutput->Reconfigure(audio_bits, audio_channels,
-                                 audio_samplerate, audio_passthru);
+                                 audio_samplerate, audio_passthru,
+                                 audio_codec);
         errMsg = audioOutput->GetError();
         if (!errMsg.isEmpty())
             audioOutput->SetStretchFactor(audio_stretchfactor);
@@ -3650 +3657 @@
     audio_passthru = passthru;
 }
 
+void NuppelVideoPlayer::SetAudioCodec(void* ac)
+{
+    audio_codec = ac;
+}
+
 void NuppelVideoPlayer::SetEffDsp(int dsprate)
 {
     if (audioOutput)

libs/libavcodec/liba52.c

@@ -134 +134 @@
     }
 }
 
+static inline int16_t convert(int32_t i)
+{
+    return av_clip_int16(i - 0x43c00000);
+}
+
+void float2s16_2 (float * _f, int16_t * s16)
+{
+    int i;
+    int32_t * f = (int32_t *) _f;
+
+    for (i = 0; i < 256; i++) {
+        s16[2*i] = convert (f[i]);
+        s16[2*i+1] = convert (f[i+256]);
+    }
+}
+
+void float2s16_4 (float * _f, int16_t * s16)
+{
+    int i;
+    int32_t * f = (int32_t *) _f;
+
+    for (i = 0; i < 256; i++) {
+        s16[4*i] = convert (f[i]);
+        s16[4*i+1] = convert (f[i+256]);
+        s16[4*i+2] = convert (f[i+512]);
+        s16[4*i+3] = convert (f[i+768]);
+    }
+}
+
+void float2s16_5 (float * _f, int16_t * s16)
+{
+    int i;
+    int32_t * f = (int32_t *) _f;
+
+    for (i = 0; i < 256; i++) {
+        s16[5*i] = convert (f[i]);
+        s16[5*i+1] = convert (f[i+256]);
+        s16[5*i+2] = convert (f[i+512]);
+        s16[5*i+3] = convert (f[i+768]);
+        s16[5*i+4] = convert (f[i+1024]);
+    }
+}
+
+#define LIKEAC3DEC 1
+int channels_multi (int flags)
+{
+    if (flags & A52_LFE)
+        return 6;
+    else if (flags & 1) /* center channel */
+        return 5;
+    else if ((flags & A52_CHANNEL_MASK) == A52_2F2R)
+        return 4;
+    else
+        return 2;
+}
+
+void float2s16_multi (float * _f, int16_t * s16, int flags)
+{
+    int i;
+    int32_t * f = (int32_t *) _f;
+
+    switch (flags) {
+    case A52_MONO:
+        for (i = 0; i < 256; i++) {
+            s16[5*i] = s16[5*i+1] = s16[5*i+2] = s16[5*i+3] = 0;
+            s16[5*i+4] = convert (f[i]);
+        }
+        break;
+    case A52_CHANNEL:
+    case A52_STEREO:
+    case A52_DOLBY:
+        float2s16_2 (_f, s16);
+        break;
+    case A52_3F:
+        for (i = 0; i < 256; i++) {
+            s16[5*i] = convert (f[i]);
+            s16[5*i+1] = convert (f[i+512]);
+            s16[5*i+2] = s16[5*i+3] = 0;
+            s16[5*i+4] = convert (f[i+256]);
+        }
+        break;
+    case A52_2F2R:
+        float2s16_4 (_f, s16);
+        break;
+    case A52_3F2R:
+        float2s16_5 (_f, s16);
+        break;
+    case A52_MONO | A52_LFE:
+        for (i = 0; i < 256; i++) {
+#if LIKEAC3DEC
+            s16[6*i] = s16[6*i+2] = s16[6*i+3] = s16[6*i+4] = 0;
+            s16[6*i+1] = convert (f[i+256]);
+            s16[6*i+5] = convert (f[i]);
+#else
+            s16[6*i] = s16[6*i+1] = s16[6*i+2] = s16[6*i+3] = 0;
+            s16[6*i+4] = convert (f[i+256]);
+            s16[6*i+5] = convert (f[i]);
+#endif
+        }
+        break;
+    case A52_CHANNEL | A52_LFE:
+    case A52_STEREO | A52_LFE:
+    case A52_DOLBY | A52_LFE:
+        for (i = 0; i < 256; i++) {
+#if LIKEAC3DEC
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+2] = convert (f[i+512]);
+            s16[6*i+1] = s16[6*i+3] = s16[6*i+4] = 0;
+            s16[6*i+5] = convert (f[i]);
+#else
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+1] = convert (f[i+512]);
+            s16[6*i+2] = s16[6*i+3] = s16[6*i+4] = 0;
+            s16[6*i+5] = convert (f[i]);
+#endif
+        }
+        break;
+    case A52_3F | A52_LFE:
+        for (i = 0; i < 256; i++) {
+#if LIKEAC3DEC
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+2] = convert (f[i+768]);
+            s16[6*i+3] = s16[6*i+4] = 0;
+            s16[6*i+1] = convert (f[i+512]);
+            s16[6*i+5] = convert (f[i]);
+#else
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+1] = convert (f[i+768]);
+            s16[6*i+2] = s16[6*i+3] = 0;
+            s16[6*i+4] = convert (f[i+512]);
+            s16[6*i+5] = convert (f[i]);
+#endif
+        }
+        break;
+    case A52_2F2R | A52_LFE:
+        for (i = 0; i < 256; i++) {
+#if LIKEAC3DEC
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+1] = 0;
+            s16[6*i+2] = convert (f[i+512]);
+            s16[6*i+3] = convert (f[i+768]);
+            s16[6*i+4] = convert (f[i+1024]);
+            s16[6*i+5] = convert (f[i]);
+#else
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+1] = convert (f[i+512]);
+            s16[6*i+2] = convert (f[i+768]);
+            s16[6*i+3] = convert (f[i+1024]);
+            s16[6*i+4] = 0;
+            s16[6*i+5] = convert (f[i]);
+#endif
+        }
+        break;
+    case A52_3F2R | A52_LFE:
+        for (i = 0; i < 256; i++) {
+#if LIKEAC3DEC
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+1] = convert (f[i+512]);
+            s16[6*i+2] = convert (f[i+768]);
+            s16[6*i+3] = convert (f[i+1024]);
+            s16[6*i+4] = convert (f[i+1280]);
+            s16[6*i+5] = convert (f[i]);
+#else
+            s16[6*i] = convert (f[i+256]);
+            s16[6*i+1] = convert (f[i+768]);
+            s16[6*i+2] = convert (f[i+1024]);
+            s16[6*i+3] = convert (f[i+1280]);
+            s16[6*i+4] = convert (f[i+512]);
+            s16[6*i+5] = convert (f[i]);
+#endif
+        }
+        break;
+    }
+}
+
 /**** end */
 
 #define HEADER_SIZE 7
@@ -177 +352 @@
                     /* update codec info */
                     avctx->sample_rate = sample_rate;
                     s->channels = ac3_channels[s->flags & 7];
+                    if (avctx->cqp >= 0)
+                        avctx->channels = avctx->cqp;
                     if (s->flags & A52_LFE)
                         s->channels++;
                     if (avctx->channels == 0)
@@ -199 +376 @@
             s->inbuf_ptr += len;
             buf_size -= len;
         } else {
+            int chans;
             flags = s->flags;
             if (avctx->channels == 1)
                 flags = A52_MONO;
-            else if (avctx->channels == 2)
-                flags = A52_STEREO;
+            else if (avctx->channels == 2) {
+                if (s->channels>2)
+                    flags = A52_DOLBY;
+                else
+                    flags = A52_STEREO;
+            }
             else
                 flags |= A52_ADJUST_LEVEL;
             level = 1;
+            chans = channels_multi(flags);
             if (s->a52_frame(s->state, s->inbuf, &flags, &level, 384)) {
             fail:
                 av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
@@ -217 +400 @@
             for (i = 0; i < 6; i++) {
                 if (s->a52_block(s->state))
                     goto fail;
-                float_to_int(s->samples, out_samples + i * 256 * avctx->channels, avctx->channels);
+                float2s16_multi(s->samples, out_samples + i * 256 * chans, flags);
             }
             s->inbuf_ptr = s->inbuf;
             s->frame_size = 0;

libs/libavcodec/ac3_parser.c

@@ -84 +84 @@
     return 0;
 }
 
-static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
+/*static*/ int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
                     int *bit_rate, int *samples)
 {
     int err;