Ticket #5900: audioencoding-fixes-vdpau-jya7.patch

mythplugins/mythmusic/mythmusic/main.cpp

@@ -378 +378 @@
     REG_KEY("Music", "VOLUMEDOWN", "Volume down",       "[,{,F10,Volume Down");
     REG_KEY("Music", "VOLUMEUP",   "Volume up",         "],},F11,Volume Up");
     REG_KEY("Music", "MUTE",       "Mute",              "|,\\,F9,Volume Mute");
+    REG_KEY("Music", "TOGGLEUPMIX","Toggle upmixer",             "Ctrl+U");
     REG_KEY("Music", "CYCLEVIS",   "Cycle visualizer mode",      "6");
     REG_KEY("Music", "BLANKSCR",   "Blank screen",               "5");
     REG_KEY("Music", "THMBUP",     "Increase rating",            "9");

mythplugins/mythmusic/mythmusic/musicplayer.cpp

@@ -347 +347 @@
 
 void MusicPlayer::openOutputDevice(void)
 {
-    QString adevice;
+    QString adevice, pdevice;
 
     if (gContext->GetSetting("MusicAudioDevice") == "default")
         adevice = gContext->GetSetting("AudioOutputDevice");
     else
         adevice = gContext->GetSetting("MusicAudioDevice");
 
+    if (!gContext->GetNumSetting("MythAC3Upmix", 0))
+        pdevice = "default";
+    else
+        pdevice = gContext->GetSetting("PassThruOutputDevice");
+
     // TODO: Error checking that device is opened correctly!
-    m_output = AudioOutput::OpenAudio(adevice, "default", 16, 2, 44100,
+    m_output = AudioOutput::OpenAudio(adevice, pdevice, 16, 2, 44100,
                                     AUDIOOUTPUT_MUSIC, true, false);
     m_output->setBufferSize(256 * 1024);
     m_output->SetBlocking(false);

mythplugins/mythmusic/mythmusic/playbackbox.cpp

@@ -358 +358 @@
             changeSpeed(true);
         else if (action == "MUTE")
             toggleMute();
+        else if (action == "TOGGLEUPMIX")
+            toggleUpmix();
         else if (action == "MENU" && visualizer_status != 2)
         {
             menufilters = false;
@@ -1178 +1180 @@
     }
 }
 
+void PlaybackBoxMusic::toggleUpmix()
+{
+    if (gPlayer->getOutput())
+        gPlayer->getOutput()->ToggleUpmix();
+}
+    
+
 void PlaybackBoxMusic::showProgressBar()
 {
     if (progress_bar)

mythplugins/mythmusic/mythmusic/playbackbox.h

@@ -69 +69 @@
     void changeVolume(bool up_or_down);
     void changeSpeed(bool up_or_down);
     void toggleMute();
+    void toggleUpmix();
     void resetTimer();
     void hideVolume(){showVolume(false);}
     void showVolume(bool on_or_off);

mythtv/libs/libmyth/audiooutput.cpp

@@ -36 +36 @@
                                     int audio_bits,
                                     int audio_channels, int audio_samplerate,
                                     AudioOutputSource source,
-                                    bool set_initial_vol, bool audio_passthru)
+                                    bool set_initial_vol, bool audio_passthru, bool AC3upmix)
 {
     if (passthru_device.isEmpty() || passthru_device.lower() == "default")
         passthru_device = main_device;
@@ -47 +47 @@
         return new AudioOutputALSA(main_device.remove(0, 5),
                                    passthru_device.remove(0, 5), audio_bits,
                                    audio_channels, audio_samplerate, source,
-                                   set_initial_vol, audio_passthru);
+                                   set_initial_vol, audio_passthru, AC3upmix);
 #else
         VERBOSE(VB_IMPORTANT, "Audio output device is set to an ALSA device "
                               "but ALSA support is not compiled in!");

mythtv/libs/libmyth/audiooutput.h

@@ -22 +22 @@
                                   int audio_bits,
                                   int audio_channels, int audio_samplerate,
                                   AudioOutputSource source,
-                                  bool set_initial_vol, bool audio_passthru);
+                                  bool set_initial_vol, bool audio_passthru, bool AC3upmix=false);
 
     AudioOutput() :
         VolumeBase(),             OutputListeners(),
-        lastError(QString::null), lastWarn(QString::null) {}
+        isAC3upmix(false),
+        lastError(QString::null), lastWarn(QString::null) { };
 
     virtual ~AudioOutput() { };
 
@@ -39 +40 @@
     
     virtual void SetStretchFactor(float factor);
     virtual float GetStretchFactor(void) { return 1.0f; }
+    virtual bool ToggleUpmix(void) = 0;
+    bool isAC3upmix;
 
     // do AddSamples calls block?
     virtual void SetBlocking(bool blocking) = 0;

mythtv/libs/libmyth/audiooutputalsa.cpp

@@ -17 +17 @@
     QString laudio_main_device, QString           laudio_passthru_device,
     int     laudio_bits,        int               laudio_channels,
     int     laudio_samplerate,  AudioOutputSource lsource,
-    bool    lset_initial_vol,   bool              laudio_passthru) :
+    bool    lset_initial_vol,   bool              laudio_passthru,
+    bool    AC3upmix) :
     AudioOutputBase(laudio_main_device, laudio_passthru_device,
                     laudio_bits,        laudio_channels,
                     laudio_samplerate,  lsource,
-                    lset_initial_vol,   laudio_passthru),
+                    lset_initial_vol,   laudio_passthru,
+                    AC3upmix),
     pcm_handle(NULL),             numbadioctls(0),
     killAudioLock(false),         mixer_handle(NULL),
     mixer_control(QString::null), volume_range_multiplier(1.0f),
@@ -35 +37 @@
 AudioOutputALSA::~AudioOutputALSA()
 {
     KillAudio();
+    if (isAC3upmix)
+        SetIECStatus(true);
+}
+
+void AudioOutputALSA::SetIECStatus(bool audio) {
+    
+    snd_ctl_t *ctl;
+    const char *spdif_str = SND_CTL_NAME_IEC958("", PLAYBACK, DEFAULT);
+    int spdif_index = -1;
+    snd_ctl_elem_list_t *clist;
+    snd_ctl_elem_id_t *cid;
+    snd_ctl_elem_value_t *cval;
+    snd_aes_iec958_t iec958;
+    int cidx, controls;
+
+    VERBOSE(VB_AUDIO, QString("Setting IEC958 status: %1")
+                      .arg(audio ? "audio" : "non-audio"));
+    
+    snd_ctl_open(&ctl, "default", 0);
+    snd_ctl_elem_list_alloca(&clist);
+    snd_ctl_elem_list(ctl, clist);
+    snd_ctl_elem_list_alloc_space(clist, snd_ctl_elem_list_get_count(clist));
+    snd_ctl_elem_list(ctl, clist);
+    controls = snd_ctl_elem_list_get_used(clist);
+    for (cidx = 0; cidx < controls; cidx++) 
+    {
+        if (!strcmp(snd_ctl_elem_list_get_name(clist, cidx), spdif_str))
+            if (spdif_index < 0 ||
+                snd_ctl_elem_list_get_index(clist, cidx) == (uint)spdif_index)
+                    break;
+    }
+
+    if (cidx >= controls)
+        return;
+
+    snd_ctl_elem_id_alloca(&cid);
+    snd_ctl_elem_list_get_id(clist, cidx, cid);
+    snd_ctl_elem_value_alloca(&cval);
+    snd_ctl_elem_value_set_id(cval, cid);
+    snd_ctl_elem_read(ctl,cval);
+    snd_ctl_elem_value_get_iec958(cval, &iec958);
+    
+    if (!audio) 
+        iec958.status[0] |= IEC958_AES0_NONAUDIO;
+    else
+        iec958.status[0] &= ~IEC958_AES0_NONAUDIO;
+
+    snd_ctl_elem_value_set_iec958(cval, &iec958);
+    snd_ctl_elem_write(ctl, cval);
+
 }
 
 bool AudioOutputALSA::OpenDevice()
@@ -42 +94 @@
     snd_pcm_format_t format;
     unsigned int buffer_time, period_time;
     int err;
+    QString real_device;
 
     if (pcm_handle != NULL)
         CloseDevice();
@@ -49 +102 @@
     pcm_handle = NULL;
     numbadioctls = 0;
 
-    QString real_device = (audio_passthru) ?
-        audio_passthru_device : audio_main_device;
+    if (!isAC3upmix) {
+        real_device = (audio_passthru) ?
+            audio_passthru_device : audio_main_device;
+    }
+    else
+        if (audio_passthru || audio_enc)
+        {
+            real_device = audio_passthru_device;
+            SetIECStatus(false);
+        }
+        else 
+        {
+            real_device = audio_main_device;
+            SetIECStatus(true);
+        }
 
     VERBOSE(VB_GENERAL, QString("Opening ALSA audio device '%1'.")
             .arg(real_device));

mythtv/libs/libmyth/audiooutputalsa.h

@@ -20 +20 @@
                     int laudio_bits,
                     int laudio_channels, int laudio_samplerate,
                     AudioOutputSource source,
-                    bool set_initial_vol, bool laudio_passthru);
+                    bool set_initial_vol, bool laudio_passthru,
+                    bool AC3upmix = false);
     virtual ~AudioOutputALSA();
 
     // Volume control
@@ -37 +38 @@
     virtual inline int getBufferedOnSoundcard(void);
 
   private:
+    void SetIECStatus(bool audio);
     inline int SetParameters(snd_pcm_t *handle,
                              snd_pcm_format_t format, unsigned int channels,
                              unsigned int rate, unsigned int buffer_time,

mythtv/libs/libmyth/audiooutputbase.cpp

@@ -27 +27 @@
     QString laudio_main_device,    QString           laudio_passthru_device,
     int     /*laudio_bits*/,       int               /*laudio_channels*/,
     int     /*laudio_samplerate*/, AudioOutputSource lsource,
-    bool    lset_initial_vol,      bool              /*laudio_passthru*/) :
+    bool    lset_initial_vol,      bool              /*laudio_passthru*/,
+    bool    AC3upmix) :
 
     effdsp(0),                  effdspstretched(0),
     audio_channels(-1),         audio_bytes_per_sample(0),
@@ -37 +38 @@
 
     audio_main_device(QDeepCopy<QString>(laudio_main_device)),
     audio_passthru_device(QDeepCopy<QString>(laudio_passthru_device)),
-    audio_passthru(false),      audio_stretchfactor(1.0f),
+    audio_passthru(false),      audio_enc(false),
+    audio_reenc(false),         audio_stretchfactor(1.0f),
 
     audio_codec(NULL),
     source(lsource),            killaudio(false),
@@ -54 +56 @@
     pSoundStretch(NULL),        
     encoder(NULL),
     upmixer(NULL),
+
     source_audio_channels(-1),
+    source_audio_samplerate(0),
     source_audio_bytes_per_sample(0),
     needs_upmix(false),
     surround_mode(FreeSurround::SurroundModePassive),
+    old_audio_stretchfactor(1.0),
 
     blocking(false),
 
@@ -84 +89 @@
     memset(&audiotime_updated, 0, sizeof(audiotime_updated));
     memset(audiobuffer,        0, sizeof(char)  * AUDBUFSIZE);
     configured_audio_channels = gContext->GetNumSetting("MaxChannels", 2);
+    orig_config_channels = configured_audio_channels;
+    allow_ac3_passthru = gContext->GetNumSetting("AC3PassThru", false);
+    src_quality = gContext->GetNumSetting("SRCQuality", 3);
+    isAC3upmix = AC3upmix;
 
     // You need to call Reconfigure from your concrete class.
     // Reconfigure(laudio_bits,       laudio_channels,
@@ -110 +119 @@
 void AudioOutputBase::SetStretchFactorLocked(float laudio_stretchfactor)
 {
     effdspstretched = (int)((float)effdsp / laudio_stretchfactor);
-    if (audio_stretchfactor != laudio_stretchfactor)
+    if ((audio_stretchfactor != laudio_stretchfactor) || !pSoundStretch)
     {
         audio_stretchfactor = laudio_stretchfactor;
         if (pSoundStretch)
@@ -124 +133 @@
             VERBOSE(VB_GENERAL, LOC + QString("Using time stretch %1")
                                         .arg(audio_stretchfactor));
             pSoundStretch = new soundtouch::SoundTouch();
-            if (audio_codec)
-            {
-                if (!encoder)
+            if (!isAC3upmix) {
+                if (audio_codec)
                 {
-                    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
-                                ))
+                    if (!encoder)
                     {
-                        // eeks
-                        delete encoder;
-                        encoder = NULL;
                         VERBOSE(VB_AUDIO, LOC +
-                                QString("Failed to Create Encoder"));
+                                QString("Creating Encoder for codec %1 origfs %2")
+                                .arg(audio_codec->codec_id)
+                                .arg(audio_codec->frame_size));
+
+                        encoder = new AudioOutputDigitalEncoder(isAC3upmix);
+                        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 (audio_codec && encoder)
-            {
-                pSoundStretch->setSampleRate(audio_codec->sample_rate);
-                pSoundStretch->setChannels(audio_codec->channels);
-            }
-            else
-            {
+                if (audio_codec && encoder)
+                {
+                    pSoundStretch->setSampleRate(audio_codec->sample_rate);
+                    pSoundStretch->setChannels(audio_codec->channels);
+                }
+                else
+                {
+                    pSoundStretch->setSampleRate(audio_samplerate);
+                    pSoundStretch->setChannels(audio_channels);
+                }
+            } else {
                 pSoundStretch->setSampleRate(audio_samplerate);
-                pSoundStretch->setChannels(audio_channels);
+                pSoundStretch->setChannels(upmixer ? 
+                    configured_audio_channels : source_audio_channels);
             }
-
             pSoundStretch->setTempo(audio_stretchfactor);
             pSoundStretch->setSetting(SETTING_SEQUENCE_MS, 35);
 
             // dont need these with only tempo change
             //pSoundStretch->setPitch(1.0);
             //pSoundStretch->setRate(1.0);
-
             //pSoundStretch->setSetting(SETTING_USE_QUICKSEEK, true);
             //pSoundStretch->setSetting(SETTING_USE_AA_FILTER, false);
         }
@@ -184 +197 @@
     return audio_stretchfactor;
 }
 
+bool AudioOutputBase::ToggleUpmix(void)
+{
+    if (orig_config_channels == 2 || audio_passthru)
+        return false;
+    if (configured_audio_channels == 6)
+        configured_audio_channels = 2;
+    else
+        configured_audio_channels = 6;
+    
+    Reconfigure(audio_bits, source_audio_channels, 
+        source_audio_samplerate, audio_passthru);
+    return (configured_audio_channels == 6);
+}
+
 void AudioOutputBase::Reconfigure(int laudio_bits, int laudio_channels, 
                                   int laudio_samplerate, bool laudio_passthru,
                                   void *laudio_codec)
@@ -194 +221 @@
     int cchannels = 0;
     int lsource_audio_channels = laudio_channels;
     bool lneeds_upmix = false;
+    bool laudio_reenc = 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 (!isAC3upmix) {
+        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 (audio_codec)
+        {
+            codec_id = audio_codec->codec_id;
+            cchannels = ((AVCodecContext*)audio_codec)->channels;
+        }
 
-    if ((configured_audio_channels == 6) && 
-        !(laudio_codec || audio_codec))
-    {
-        laudio_channels = configured_audio_channels;
-        lneeds_upmix = true;
-        VERBOSE(VB_AUDIO,LOC + "Needs upmix");
+        if ((configured_audio_channels == 6) && 
+            !(laudio_codec || audio_codec))
+        {
+            laudio_channels = configured_audio_channels;
+            lneeds_upmix = true;
+            VERBOSE(VB_AUDIO,LOC + "Needs upmix");
+        }
+    } else { //AC3 Upmix
+        // Are we perhaps reencoding a (previously) timestretched bitstream?
+        if (laudio_channels > 2 && !laudio_passthru)
+            laudio_reenc = true;
+  
+        // Enough channels? Upmix if not
+        if (laudio_channels < configured_audio_channels && !laudio_passthru)
+        {
+            laudio_channels = configured_audio_channels;
+            lneeds_upmix = true;
+            VERBOSE(VB_AUDIO,LOC + "Needs upmix");
+        }
     }
-
+    
     ClearError();
     bool general_deps = (laudio_bits == audio_bits && 
         laudio_channels == audio_channels &&
         laudio_samplerate == audio_samplerate && !need_resampler &&
         laudio_passthru == audio_passthru &&
         lneeds_upmix == needs_upmix &&
-        lcodec_id == codec_id && lcchannels == cchannels);
+        (isAC3upmix ? (laudio_reenc == audio_reenc) : (lcodec_id == codec_id && lcchannels == cchannels))
+        );
     bool upmix_deps =
         (lsource_audio_channels == source_audio_channels);
     if (general_deps && upmix_deps)
@@ -256 +299 @@
     audio_channels = laudio_channels;
     source_audio_channels = lsource_audio_channels;
     audio_bits = laudio_bits;
-    audio_samplerate = laudio_samplerate;
-    audio_codec = (AVCodecContext*)laudio_codec;
+    if (!isAC3upmix) {
+        audio_samplerate = laudio_samplerate;
+        audio_codec = (AVCodecContext*)laudio_codec;
+    } else {
+        source_audio_samplerate = audio_samplerate = laudio_samplerate;
+        audio_reenc = laudio_reenc;
+    }
     audio_passthru = laudio_passthru;
     needs_upmix = lneeds_upmix;
 
@@ -268 +316 @@
         Error("AudioOutput only supports 8 or 16bit audio.");
         return;
     }
-    audio_bytes_per_sample = audio_channels * audio_bits / 8;
-    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
     
     need_resampler = false;
     killaudio = false;
@@ -279 +325 @@
     
     numlowbuffer = 0;
 
+    if (!isAC3upmix) {
+    audio_bytes_per_sample = audio_channels * audio_bits / 8;
+    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
+    } else {
+    // Encode to AC-3 if not passing thru, there's more than 2 channels
+    // and we're allowed to passthru AC-3
+    // This won't reencode timestretched 2ch AC-3 but there's no point doing so
+    if (!audio_passthru && audio_channels > 2 && allow_ac3_passthru) 
+    {
+        VERBOSE(VB_AUDIO, LOC + "Creating AC-3 Encoder");
+        int srate = src_quality == 0 ? audio_samplerate : 48000;
+        encoder = new AudioOutputDigitalEncoder();
+        if (!encoder->Init(CODEC_ID_AC3, 448000, srate, 
+                           audio_channels, audio_reenc)) 
+        {
+            VERBOSE(VB_AUDIO, LOC + "Can't create AC-3 encoder");
+            delete encoder;
+            encoder = NULL;
+        }
+        
+        audio_enc = true;
+    }        
+    
+    if(audio_passthru || audio_enc)
+        // AC-3 output - soundcard expects a 2ch 48k stream
+        audio_channels = 2;
+    
+    audio_bytes_per_sample = audio_channels * audio_bits / 8;
+    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
+
+    // Always resample to 48k - many cards can't do anything else
+    // and ALSA will do it with linear interpolation (yuk) if we don't anyway
+    if (src_quality != 0 && audio_samplerate != 48000)
+    {
+        int error;
+        audio_samplerate = 48000;
+        VERBOSE(VB_GENERAL, LOC + QString("Using resampler. From: %1 to %2")
+            .arg(laudio_samplerate).arg(audio_samplerate));
+        src_ctx = src_new(3-src_quality, audio_channels, &error);
+        if (error)
+        {
+            Error(QString("Error creating resampler, the error was: %1")
+                  .arg(src_strerror(error)) );
+            pthread_mutex_unlock(&avsync_lock);
+            pthread_mutex_unlock(&audio_buflock);
+            src_ctx = NULL;
+            return;
+        }
+        src_data.src_ratio = (double) audio_samplerate / laudio_samplerate;
+        src_data.data_in = src_in;
+        src_data.data_out = src_out;
+        src_data.output_frames = 16384*6;
+        need_resampler = true;
+    }
+    }
     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));
@@ -314 +415 @@
     current_seconds = -1;
     source_bitrate = -1;
 
+    if (!isAC3upmix) {
     // NOTE: this won't do anything as above samplerate vars are set equal
     // Check if we need the resampler
     if (audio_samplerate != laudio_samplerate)
@@ -336 +438 @@
         src_data.output_frames = 16384*6;
         need_resampler = true;
     }
-
+    }
     if (needs_upmix)
     {
         VERBOSE(VB_AUDIO, LOC + QString("create upmixer"));
@@ -348 +450 @@
         upmixer = new FreeSurround(
             audio_samplerate, 
             source == AUDIOOUTPUT_VIDEO, 
-            (FreeSurround::SurroundMode)surround_mode);
+            (FreeSurround::SurroundMode)surround_mode,isAC3upmix);
 
         VERBOSE(VB_AUDIO, LOC +
                 QString("create upmixer done with surround mode %1")
@@ -357 +459 @@
 
     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"));
-
-    if (redo_stretch)
-    {
-        float laudio_stretchfactor = audio_stretchfactor;
-        delete pSoundStretch;
-        pSoundStretch = NULL;
-        audio_stretchfactor = 0.0f;
-        SetStretchFactorLocked(laudio_stretchfactor);
-    }
-    else
-    {
-        SetStretchFactorLocked(audio_stretchfactor);
-        if (pSoundStretch)
+    if (!isAC3upmix) {
+        VERBOSE(VB_AUDIO, QString("Audio Codec Used: %1")
+                .arg((audio_codec) ?
+                  codec_id_string(audio_codec->codec_id) : "not set"));
+
+        if (redo_stretch)
+        {
+            delete pSoundStretch;
+            pSoundStretch = NULL;
+            SetStretchFactorLocked(audio_stretchfactor);
+        }
+        else
         {
-            // if its passthru then we need to reencode
-            if (audio_codec)
+            SetStretchFactorLocked(audio_stretchfactor);
+            if (pSoundStretch)
             {
-                if (!encoder)
+                // if its passthru then we need to reencode
+                if (audio_codec)
                 {
-                    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
-                                ))
+                    if (!encoder)
                     {
-                        // eeks
-                        delete encoder;
-                        encoder = NULL;
-                        VERBOSE(VB_AUDIO, LOC + "Failed to Create Encoder");
+                        VERBOSE(VB_AUDIO, LOC +
+                                QString("Creating Encoder for codec %1")
+                                .arg(audio_codec->codec_id));
+
+                        encoder = new AudioOutputDigitalEncoder(isAC3upmix);
+                        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 + "Failed to Create Encoder");
+                        }
                     }
                 }
-            }
-            if (audio_codec && encoder)
-            {
-                pSoundStretch->setSampleRate(audio_codec->sample_rate);
-                pSoundStretch->setChannels(audio_codec->channels);
-            }
-            else
-            {
-                pSoundStretch->setSampleRate(audio_samplerate);
-                pSoundStretch->setChannels(audio_channels);
+                if (audio_codec && encoder)
+                {
+                    pSoundStretch->setSampleRate(audio_codec->sample_rate);
+                    pSoundStretch->setChannels(audio_codec->channels);
+                }
+                else
+                {
+                    pSoundStretch->setSampleRate(audio_samplerate);
+                    pSoundStretch->setChannels(audio_channels);
+                }
             }
         }
+    } else {
+        SetStretchFactorLocked(old_audio_stretchfactor);
     }
-
     // Setup visualisations, zero the visualisations buffers
     prepareVisuals();
 
@@ -456 +559 @@
     killaudio = true;
     StopOutputThread();
 
+    if (isAC3upmix)
+        pthread_mutex_lock(&audio_buflock);
+
     // Close resampler?
-    if (src_ctx)
+    if (src_ctx) {
         src_delete(src_ctx);
+        if (isAC3upmix)
+            src_ctx = NULL;
+    }
     need_resampler = false;
 
     // close sound stretcher
@@ -466 +575 @@
     {
         delete pSoundStretch;
         pSoundStretch = NULL;
+        if (isAC3upmix) {
+            old_audio_stretchfactor = audio_stretchfactor;
+            audio_stretchfactor = 1.0;
+        }
     }
 
     if (encoder)
@@ -480 +593 @@
         upmixer = NULL;
     }
     needs_upmix = false;
+    if (isAC3upmix)
+        audio_enc = false;
 
     CloseDevice();
 
+    if (isAC3upmix)
+        pthread_mutex_unlock(&audio_buflock);
     killAudioLock.unlock();
 }
 
@@ -642 +759 @@
     // 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);
+        if (!isAC3upmix) {
+            // 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);
@@ -656 +775 @@
         totalbuffer += upmixer->sampleLatency() * audio_bytes_per_sample;
     }
 
+    if (isAC3upmix && encoder) 
+        totalbuffer += encoder->Buffered();
+
     audiotime = audbuf_timecode - (int)(totalbuffer * 100000.0 /
                                    (audio_bytes_per_sample * effdspstretched));
  
@@ -709 +831 @@
         return false; // would overflow
     }
 
+    if (isAC3upmix)
+        pthread_mutex_lock(&audio_buflock);
+
     // resample input if necessary
     if (need_resampler && src_ctx) 
     {
@@ -742 +867 @@
         _AddSamples(buffers, false, samples, timecode);
     }
 
+    if (isAC3upmix)
+        pthread_mutex_unlock(&audio_buflock);
+
     return true;
 }
 
@@ -753 +881 @@
     int abps = (encoder) ?
         encoder->audio_bytes_per_sample : audio_bytes_per_sample;
     int len = samples * abps;
+ 
+    if (isAC3upmix) {
+        // Give original samples to mythmusic visualisation
+        dispatchVisual((unsigned char *)buffer, len, timecode,
+                       source_audio_channels, audio_bits);
+    }
 
     // Check we have enough space to write the data
     if (need_resampler && src_ctx)
@@ -777 +911 @@
         return false; // would overflow
     }
 
+    if (isAC3upmix)
+        pthread_mutex_lock(&audio_buflock);
+
     // resample input if necessary
     if (need_resampler && src_ctx) 
     {
@@ -805 +942 @@
         _AddSamples(buffer, true, samples, timecode);
     }
 
+    if (isAC3upmix)
+        pthread_mutex_unlock(&audio_buflock);
+
     return true;
 }
 
@@ -837 +977 @@
             {
                 int error = src_reset(src_ctx);
                 if (error)
+                {
                     VERBOSE(VB_IMPORTANT, LOC_ERR + QString(
                             "Error occured while resetting resampler: %1")
                             .arg(src_strerror(error)));
+                    if (isAC3upmix)
+                        src_ctx = NULL;
+                }
             }
         }
     }
@@ -849 +993 @@
 void AudioOutputBase::_AddSamples(void *buffer, bool interleaved, int samples, 
                                   long long timecode)
 {
-    pthread_mutex_lock(&audio_buflock);
+    if (!isAC3upmix)
+        pthread_mutex_lock(&audio_buflock);
 
     int len; // = samples * audio_bytes_per_sample;
     int audio_bytes = audio_bits / 8;
@@ -868 +1013 @@
             .arg(AUDBUFSIZE-afree).arg(afree).arg(timecode)
             .arg(needs_upmix));
     
+    if (isAC3upmix)
+        len = WaitForFreeSpace(samples);
+    
     if (upmixer && needs_upmix)
     {
         int out_samples = 0;
         int step = (interleaved)?source_audio_channels:1;
-        len = WaitForFreeSpace(samples);    // test
+        
+        if (!isAC3upmix) {
+            org_waud = waud;
+            len = WaitForFreeSpace(samples);
+        }
         for (int itemp = 0; itemp < samples; )
         {
             // 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 (!isAC3upmix)
+                pthread_mutex_unlock(&audio_buflock);
             if (audio_bytes == 2)
             {
                 itemp += upmixer->putSamples(
@@ -894 +1047 @@
                     source_audio_channels,
                     (interleaved) ? 0 : samples);
             }
-            pthread_mutex_lock(&audio_buflock);
+            if (!isAC3upmix)
+                pthread_mutex_lock(&audio_buflock);
 
             int copy_samples = upmixer->numSamples();
             if (copy_samples)
@@ -928 +1082 @@
     }
     else
     {
-        len = WaitForFreeSpace(samples);
-
+        if (!isAC3upmix)
+            len = WaitForFreeSpace(samples);
         if (interleaved) 
         {
             char *mybuf = (char*)buffer;
@@ -965 +1119 @@
         }
     }
 
+    if (!isAC3upmix) {
     if (samples > 0)
     {
         if (pSoundStretch)
@@ -1022 +1177 @@
                         continue;
 
                     //len = WaitForFreeSpace(amount);
-                    char *ob = encoder->GetOutBuff();
+                    const char *ob = encoder->GetOutBuff();
                     if (amount >= bdiff)
                     {
                         memcpy(audiobuffer + org_waud, ob, bdiff);
@@ -1035 +1190 @@
 
                     bdiff = AUDBUFSIZE - amount;
                     org_waud += amount;
+                    if (org_waud >= AUDBUFSIZE)
+                    {
+                        VERBOSE(VB_IMPORTANT, QString("org_waud >= kAudioRingBufferSize %1 %2").arg(org_waud).arg(amount));
+                        org_waud -= AUDBUFSIZE;
+                    }
                 }
             }
             else
@@ -1064 +1224 @@
                         org_waud += nSamples * audio_bytes_per_sample;
                         nSamplesToEnd -= nSamples;
                     }
+                    if (org_waud >= AUDBUFSIZE)
+                    {
+                        VERBOSE(VB_IMPORTANT, QString("org_waud >= kAudioRingBufferSize %1 %2 %3").arg(org_waud).arg(nSamples).arg(audio_bytes_per_sample));
+                        org_waud -= AUDBUFSIZE;
+                    }
 
                     newLen += nSamples * audio_bytes_per_sample;
                     len -= nSamples * audio_bytes_per_sample;
@@ -1096 +1261 @@
     }
 
     pthread_mutex_unlock(&audio_buflock);
+    } else {
+    if (samples <= 0)
+        return;
+    
+    if (pSoundStretch)
+    {
+        // 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)
+        {
+            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);
+
+        int nSamples = pSoundStretch->numSamples();
+        len = WaitForFreeSpace(nSamples); 
+        
+        while ((nSamples = pSoundStretch->numSamples())) 
+        {
+            if (nSamples > nSamplesToEnd) 
+                nSamples = nSamplesToEnd;
+            
+            nSamples = pSoundStretch->receiveSamples(
+                (soundtouch::SAMPLETYPE*)
+                (audiobuffer + org_waud), nSamples
+            );
+            
+            if (nSamples == nSamplesToEnd) {
+                org_waud = 0;
+                nSamplesToEnd = AUDBUFSIZE/abps;
+            }
+            else {
+                org_waud += nSamples * abps;
+                nSamplesToEnd -= nSamples;
+            }
+            
+        }
+        
+    }
+
+    // Encode to AC-3? 
+    if (encoder) 
+    {
+        
+        org_waud = waud;
+        int bdiff = AUDBUFSIZE - org_waud;
+        int to_get = 0;
+
+        if (bdiff < len) 
+        {
+            encoder->EncodeUpmix(audiobuffer + org_waud, bdiff);
+            to_get = encoder->EncodeUpmix(audiobuffer, len - bdiff);
+        }
+        else 
+            to_get = encoder->EncodeUpmix(audiobuffer + org_waud, len);
+        
+        if (to_get > 0) 
+        {
+            
+            if (to_get >= bdiff)
+            {
+                encoder->GetFrames(audiobuffer + org_waud, bdiff);
+                to_get -= bdiff;
+                org_waud = 0;
+            }
+            if (to_get > 0)
+                encoder->GetFrames(audiobuffer + org_waud, to_get);
+
+            org_waud += to_get;
+
+        }
+
+    }
+
+    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);
+    } // End AC3 upmiz
 }
 
 void AudioOutputBase::Status()

mythtv/libs/libmyth/audiooutputbase.h

@@ -41 +41 @@
                     int laudio_bits,
                     int laudio_channels, int laudio_samplerate,
                     AudioOutputSource lsource,
-                    bool lset_initial_vol, bool laudio_passthru);
+                    bool lset_initial_vol, bool laudio_passthru,
+                    bool AC3upmix = false);
     virtual ~AudioOutputBase();
 
     // reconfigure sound out for new params
@@ -59 +60 @@
 
     virtual void SetStretchFactor(float factor);
     virtual float GetStretchFactor(void);
+    virtual bool ToggleUpmix(void);
 
     virtual void Reset(void);
 
@@ -139 +141 @@
     QString audio_passthru_device;
 
     bool audio_passthru;
+    bool audio_enc;
+    bool audio_reenc;
 
     float audio_stretchfactor;
     AVCodecContext *audio_codec;
@@ -151 +155 @@
     bool buffer_output_data_for_use; //  used by AudioOutputNULL
     
     int configured_audio_channels;
+    int orig_config_channels;
+    int src_quality;
 
  private:
     // resampler
@@ -167 +173 @@
     FreeSurround              *upmixer;
 
     int source_audio_channels;
+    int source_audio_samplerate;
     int source_audio_bytes_per_sample;
     bool needs_upmix;
     int surround_mode;
+    bool allow_ac3_passthru;
+    float old_audio_stretchfactor;
 
     bool blocking; // do AddSamples calls block?
 

mythtv/libs/libmyth/audiooutputdigitalencoder.cpp

@@ -27 +27 @@
 
 AudioOutputDigitalEncoder::AudioOutputDigitalEncoder(void) :
     av_context(NULL),
-    outbuf(NULL),
-    outbuf_size(0),
     frame_buffer(NULL),
-    one_frame_bytes(0)
+    one_frame_bytes(0),
+    outbuflen(0),
+    inbuflen(0),
+    reorder(true),
+    isAC3upmix(false)
+{
+}
+
+AudioOutputDigitalEncoder::AudioOutputDigitalEncoder(bool AC3upmix) :
+    av_context(NULL),
+    frame_buffer(NULL),
+    one_frame_bytes(0),
+    outbuflen(0),
+    inbuflen(0),
+    reorder(true),
+    isAC3upmix(AC3upmix)
 {
 }
 
@@ -48 +61 @@
         av_context = NULL;
     }
 
-    if (outbuf)
-    {
-        delete [] outbuf;
-        outbuf = NULL;
-        outbuf_size = 0;
-    }
-
-    if (frame_buffer)
+    if (!isAC3upmix && frame_buffer)
     {
         delete [] frame_buffer;
         frame_buffer = NULL;
@@ -65 +71 @@
 
 //CODEC_ID_AC3
 bool AudioOutputDigitalEncoder::Init(
-    CodecID codec_id, int bitrate, int samplerate, int channels)
+    CodecID codec_id, int bitrate, int samplerate, int channels, bool reencoding)
 {
     AVCodec *codec;
     int ret;
 
-    VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4")
+    VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4 re=%5")
             .arg(codec_id_string(codec_id))
             .arg(bitrate)
             .arg(samplerate)
-            .arg(channels));
-
+            .arg(channels)
+            .arg(reencoding));
+    
+    reorder = !reencoding;
+
+    // We need to do this when called from mythmusic
+    if (isAC3upmix) {
+        avcodec_init();
+        avcodec_register_all();
+    }
     //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);
@@ -105 +119 @@
     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)
@@ -256 +268 @@
 
 } AESHeader;
 
+void reorder_6ch_ac3(void *buf, unsigned int len) {
+    unsigned short *src = (unsigned short *)buf;
+    unsigned short tmp;
+    unsigned int samples = len >> 1;
+
+    for (uint i = 0; i < samples; i += 6) {
+        tmp = src[i+4];
+        src[i+4] = src[i+3];
+        src[i+3] = src[i+2];
+        src[i+2] = src[i+1];
+        src[i+1] = tmp;
+    }
+}
+
 static int encode_frame(
         bool dts, 
         unsigned char *data,
-        size_t &len)
+        size_t &len, bool AC3upmix)
 {
-    size_t enc_len;
+    size_t enc_len = len;
     int flags, sample_rate, bit_rate;
 
     // we don't do any length/crc validation of the AC3 frame here; presumably
@@ -272 +298 @@
     // ignore, and if so, may as well just assume that it will ignore
     // anything with a bad CRC...
 
-    uint nr_samples = 0, block_len;
+    uint nr_samples = 0, block_len = 0;
+    
     if (dts)
     {
         enc_len = dts_syncinfo(data+8, &flags, &sample_rate, &bit_rate);
@@ -293 +320 @@
 #endif
     }
 
-    if (enc_len == 0 || enc_len > len)
+    if (!AC3upmix && (enc_len == 0 || enc_len > len))
     {
         int l = len;
         len = 0;
@@ -352 +379 @@
     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;
+    if (!AC3upmix)
+        len = block_len;
 
     return enc_len;
 }
@@ -365 +393 @@
  
     // put data in the correct spot for encode frame
     outsize = avcodec_encode_audio(
-        av_context, ((uchar*)outbuf) + 8, outbuf_size - 8, buff);
+        av_context, ((uchar*)outbuf) + 8, OUTBUFSIZE - 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);
+        (unsigned char*)outbuf, outsize, false);
 
     VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
             QString("DigitalEncoder::Encode len1=%1 len2=%2 finallen=%3")
@@ -380 +408 @@
 
     return outsize;
 }
+
+size_t AudioOutputDigitalEncoder::EncodeUpmix(void *buf, int len)
+{
+    size_t outsize = 0;
+ 
+    int fs = FrameSize();
+    memcpy(inbuf+inbuflen, buf, len);
+    inbuflen += len;
+    int frames = inbuflen / fs;
+
+    while (frames--) 
+    {
+        if (reorder)
+            reorder_6ch_ac3(inbuf, fs);
+        
+        // put data in the correct spot for encode frame
+        outsize = avcodec_encode_audio(
+            av_context, ((uchar*)outbuf) + outbuflen + 8, OUTBUFSIZE - 8, (short int *)inbuf);
+
+        encode_frame(
+            /*av_context->codec_id==CODEC_ID_DTS*/ false,
+            (unsigned char*)outbuf + outbuflen, outsize, true
+        );
+
+        outbuflen += MAX_AC3_FRAME_SIZE;
+        inbuflen -= fs;
+        memmove(inbuf, inbuf+fs, inbuflen);
+    }
+
+    return outbuflen;
+}
+
+void AudioOutputDigitalEncoder::GetFrames(void *ptr, int maxlen)
+{
+    int len = (maxlen < outbuflen ? maxlen : outbuflen);
+    memcpy(ptr, outbuf, len);
+    outbuflen -= len;
+    memmove(outbuf, outbuf+len, outbuflen);
+}

mythtv/libs/libmyth/audiooutputdigitalencoder.h

@@ -5 +5 @@
 #include "libavcodec/avcodec.h"
 };
 
+#define INBUFSIZE 131072
+#define OUTBUFSIZE 98304
+
 class AudioOutputDigitalEncoder
 {
   public:
     AudioOutputDigitalEncoder(void);
+    AudioOutputDigitalEncoder(bool AC3upmix);
     ~AudioOutputDigitalEncoder();
 
-    bool   Init(CodecID codec_id, int bitrate, int samplerate, int channels);
+    bool   Init(CodecID codec_id, int bitrate, int samplerate, 
+                int channels, bool reencoding = false);
     void   Dispose(void);
     size_t Encode(short * buff);
 
     inline char *GetFrameBuffer(void);
     size_t FrameSize(void)  const { return one_frame_bytes; }
-    char  *GetOutBuff(void) const { return outbuf;          }
+    const char  *GetOutBuff(void) const { return outbuf; }
+    //AC3 upmix
+    size_t EncodeUpmix(void *buf, int len);
+    void   GetFrames(void *ptr, int maxlen);
+    int    Buffered(void) const { return inbuflen; }
 
   public:
     size_t audio_bytes_per_sample;
 
   private:
     AVCodecContext *av_context;
-    char           *outbuf;
-    int             outbuf_size;
+    char            outbuf[OUTBUFSIZE];
     char           *frame_buffer;
     size_t          one_frame_bytes;
+    // AC3 upmix
+    char            inbuf[INBUFSIZE];
+    int             outbuflen;
+    int             inbuflen;
+    bool            reorder;
+    bool            isAC3upmix;
 };
 
 inline char *AudioOutputDigitalEncoder::GetFrameBuffer(void)

mythtv/libs/libmythfreesurround/el_processor.cpp

@@ -40 +40 @@
 
 const float PI = 3.141592654;
 const float epsilon = 0.000001;
+const float center_level_upmix = 0.5*sqrt(0.5);
 //const float center_level = 0.5*sqrt(0.5);   // gain of the center channel
 //const float center_level = sqrt(0.5);   // gain of the center channel
 const float center_level = 1.0;   // gain of the center channel
@@ -57 +58 @@
 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), halfN(blocksize/2) {
+  decoder_impl(unsigned blocksize=8192, bool AC3upmix=false): N(blocksize), halfN(blocksize/2), isAC3upmix(AC3upmix) {
 #ifdef USE_FFTW3
         // create FFTW buffers
         lt = (float*)fftwf_malloc(sizeof(float)*N);
@@ -99 +100 @@
             filter[c].resize(N);
         }
         // DC component of filters is always 0
-        for (unsigned c=0;c<5;c++)
-        {
-            filter[c][0] = 0.0;
-            filter[c][1] = 0.0;
-            filter[c][halfN] = 0.0;
-        }
-        sample_rate(48000);
-        // generate the window function (square root of hann, b/c it is applied before and after the transform)
-        wnd.resize(N);
-        // dft normalization included in the window for zero cost scaling
-        // also add a gain factor of *2 due to processing gain in algo (see center_level)
-        surround_gain(1.0);
+        if (!isAC3upmix) {
+            for (unsigned c=0;c<5;c++)
+            {
+                filter[c][0] = 0.0;
+                filter[c][1] = 0.0;
+                filter[c][halfN] = 0.0;
+            }
+            sample_rate(48000);
+            // generate the window function (square root of hann, b/c it is applied before and after the transform)
+            wnd.resize(N);
+            // dft normalization included in the window for zero cost scaling
+            // also add a gain factor of *2 due to processing gain in algo (see center_level)
+            surround_gain(1.0);
+        } else {
+            sample_rate(48000);
+            // 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))/N);
+        }
         current_buf = 0;
         // set the default coefficients
         surround_coefficients(0.8165,0.5774);
@@ -192 +201 @@
     // set lfe filter params
     void sample_rate(unsigned int srate) {
         // lfe filter is just straight through band limited
-        unsigned int cutoff = (250*N)/srate;
-        for (unsigned f=0;f<=halfN;f++) {           
-            if ((f>=2) && (f<cutoff))
-                filter[5][f] = 1.0;
-            else
-                filter[5][f] = 0.0;
+        unsigned int cutoff;
+        if (!isAC3upmix) {
+             cutoff = (250*N)/srate;
+            for (unsigned f=0;f<=halfN;f++) {           
+                if ((f>=2) && (f<cutoff))
+                    filter[5][f] = 1.0;
+                else
+                    filter[5][f] = 0.0;
+            }
+        } else {
+            cutoff = (30*N)/srate;
+            for (unsigned f=0;f<=halfN;f++) {           
+                if (f<cutoff)
+                    filter[5][f] = 0.5*sqrt(0.5);
+                else
+                    filter[5][f] = 0.0;
+            }
         }
     }
 
@@ -237 +257 @@
     }
 
 private:
+    bool isAC3upmix;
     // 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]); }
@@ -290 +311 @@
 
         // 2. compare amplitude and phase of each DFT bin and produce the X/Y coordinates in the sound field
         //    but dont do DC or N/2 component
-        for (unsigned f=2;f<halfN;f++) {           
+        unsigned start_f = isAC3upmix ? 0:2;
+        for (unsigned f=start_f;f<halfN;f++) {           
             // get left/right amplitudes/phases
             float ampL = amplitude(dftL[f]), ampR = amplitude(dftR[f]);
             float phaseL = phase(dftL[f]), phaseR = phase(dftR[f]);
@@ -357 +379 @@
                 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 * (isAC3upmix ? center_level_upmix : 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
@@ -402 +424 @@
                 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 * (isAC3upmix ? center_level_upmix : 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
@@ -613 +635 @@
 
 // implementation of the shell class
 
-fsurround_decoder::fsurround_decoder(unsigned blocksize): impl(new decoder_impl(blocksize)) { }
+fsurround_decoder::fsurround_decoder(unsigned blocksize, bool AC3upmix): impl(new decoder_impl(blocksize,AC3upmix)) { }
 
 fsurround_decoder::~fsurround_decoder() { delete impl; }
 

mythtv/libs/libmythfreesurround/el_processor.h

@@ -24 +24 @@
 public:
         // create an instance of the decoder
         //  blocksize is fixed over the lifetime of this object for performance reasons
-        fsurround_decoder(unsigned blocksize=8192);
+        fsurround_decoder(unsigned blocksize=8192, bool AC3upmix=false);
         // destructor
         ~fsurround_decoder();
         
@@ -51 +51 @@
         void gain(float gain);
 
         // 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.
+        // 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
@@ -71 +71 @@
 
 private:
         class decoder_impl *impl; // private implementation (details hidden)
+        bool isAC3upmix;
 };
 
 

mythtv/libs/libmythfreesurround/freesurround.cpp

@@ -163 +163 @@
 
 // construction methods
 void *new_decoder() { return new fsurround_decoder(block_size); }
+void *new_decoder_upmix() { return new fsurround_decoder(block_size,true); }
 void *new_buffers() { return new buffers(block_size/2); }
 void *new_int16buffers() { return new int16buffers(block_size/2); }
 
 object_pool dp(&new_decoder);
+object_pool dp_upmix(&new_decoder_upmix);
 //object_pool bp(&new_buffers);
 object_pool bp16(&new_int16buffers);
 
@@ -175 +177 @@
 int channel_select = -1;
 #endif
 
-FreeSurround::FreeSurround(uint srate, bool moviemode, SurroundMode smode) :
+FreeSurround::FreeSurround(uint srate, bool moviemode, SurroundMode smode, bool AC3upmix) :
         srate(srate),
         open_(false),
         initialized_(false),
@@ -185 +187 @@
         in_count(0),
         out_count(0),
         processed(true),
-        surround_mode(smode)
+        surround_mode(smode),
+        isAC3upmix(AC3upmix)
 {
     VERBOSE(QString("FreeSurround::FreeSurround rate %1 moviemode %2").arg(srate).arg(moviemode));
     if (moviemode)
     {
         params.phasemode = 1;
-        params.center_width = 0;
-        params.gain = 1.0;
+        if (!isAC3upmix) {
+            params.center_width = 0;
+            params.gain = 1.0;
+        } else {
+            params.center_width = 25;
+            params.dimension = 0.5;
+        }
     }
     else
     {
-        params.center_width = 70;
-        // for 50, gain should be about 1.9, c/lr about 2.7
-        // for 70, gain should be about 3.1, c/lr about 1.5
-        params.gain = 3.1;
+        if (!isAC3upmix) {
+            params.center_width = 70;
+            // for 50, gain should be about 1.9, c/lr about 2.7
+            // for 70, gain should be about 3.1, c/lr about 1.5
+            params.gain = 3.1;
+        } else {
+            params.center_width = 65;
+            params.dimension = 0.3;
+        }
     }
     switch (surround_mode)
     {
@@ -235 +248 @@
         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);
-        decoder->gain(params.gain);
+        if (!isAC3upmix)
+            decoder->gain(params.gain);
     }
 }
 
@@ -654 +668 @@
     {
         if (decoder) 
         {
-            // actually these params need only be set when they change... but it doesn't hurt
-#if 0
-            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);
-#endif
-            // decode the bufs->block
-            //decoder->decode(input,output,params.center_width/100.0,params.dimension/100.0);
-            //decoder->decode(output,params.center_width/100.0,params.dimension/100.0);
             decoder->decode(params.center_width/100.0,params.dimension/100.0);
         }
     }
@@ -693 +697 @@
 {               
     if (!decoder)
     {
-        decoder = (fsurround_decoder*)dp.acquire((void*)1);
+        if (!isAC3upmix)
+            decoder = (fsurround_decoder*)dp.acquire((void*)1);
+        else
+            decoder = (fsurround_decoder*)dp_upmix.acquire((void*)1);
         decoder->flush();
         //if (bufs)
         //    bufs->clear();
@@ -708 +715 @@
 {
     if (decoder)
     {
-        dp.release(this);
+        if (!isAC3upmix)
+            dp.release(this);
+        else
+            dp_upmix.release(this);
         decoder = 0;
     }
 }

mythtv/libs/libmythfreesurround/freesurround.h

@@ -31 +31 @@
         SurroundModeActiveLinear
     } SurroundMode;
 public:
-    FreeSurround(uint srate, bool moviemode, SurroundMode mode);
+    FreeSurround(uint srate, bool moviemode, SurroundMode mode, bool AC3upmix=false);
     ~FreeSurround();
 
     // put samples in buffer, returns number of samples used
@@ -88 +88 @@
     bool processed;             // whether processing is enabled or not for latency calc
     int processed_size;         // amount processed
     SurroundMode surround_mode; // 1 of 3 surround modes supported
+    bool isAC3upmix;
 
 };
 

mythtv/libs/libmythsamplerate/samplerate.c

@@ -428 +428 @@
 
         error = src_process (src_state, src_data) ;
 
-        src_state = src_delete (src_state) ;
+        src_delete (src_state) ;
 
         return error ;
 } /* src_simple */
@@ -452 +452 @@
         {       len -- ;
 
                 scaled_value = in [len] * (8.0 * 0x10000000) ;
-                if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
+                if (scaled_value >= (1.0 * 0x7FFFFFFF))
                 {       out [len] = 32767 ;
                         continue ;
                         } ;
-                if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
+                if (scaled_value <= (-8.0 * 0x10000000))
                 {       out [len] = -32768 ;
                         continue ;
                         } ;

mythtv/libs/libmythtv/NuppelVideoPlayer.cpp

@@ -769 +769 @@
 
     no_audio_in = false;
 
+    bool isAC3upmix = gContext->GetNumSetting("MythAC3Upmix",0);
+    // If previously AC3 upmixer was different than current state, delete AudioOutput
+    if (audioOutput && (audioOutput->isAC3upmix != isAC3upmix))
+    {
+        delete audioOutput;
+        audioOutput = NULL;
+    }
+
     if (!audioOutput && !using_null_videoout)
     {
         bool setVolume = gContext->GetNumSetting("MythControlsVolume", 1);
@@ -777 +785 @@
                                              audio_bits, audio_channels,
                                              audio_samplerate,
                                              AUDIOOUTPUT_VIDEO,
-                                             setVolume, audio_passthru);
+                                             setVolume, audio_passthru, isAC3upmix);
         if (!audioOutput)
             errMsg = QObject::tr("Unable to create AudioOutput.");
         else
@@ -806 +814 @@
         audioOutput->Reconfigure(audio_bits, audio_channels,
                                  audio_samplerate, audio_passthru,
                                  audio_codec);
+        if (audioOutput->isAC3upmix && audio_passthru)
+            audio_channels = 2;
         errMsg = audioOutput->GetError();
         if (!errMsg.isEmpty())
             audioOutput->SetStretchFactor(audio_stretchfactor);
@@ -4943 +4953 @@
     }
 }
 
+bool NuppelVideoPlayer::ToggleUpmix()
+{
+    if (audioOutput)
+        return audioOutput->ToggleUpmix();
+    return false;
+}
+
 void NuppelVideoPlayer::Zoom(ZoomDirection direction)
 {
     if (videoOutput)

mythtv/libs/libmythtv/NuppelVideoPlayer.h

@@ -175 +175 @@
     // Toggle Sets
     void ToggleAspectOverride(AspectOverrideMode aspectMode = kAspect_Toggle);
     void ToggleAdjustFill(AdjustFillMode adjustfillMode = kAdjustFill_Toggle);
+    bool ToggleUpmix(void);
 
     // Gets
     QSize   GetVideoBufferSize(void) const    { return video_dim; }

mythtv/libs/libmythtv/avformatdecoder.cpp

@@ -427 +427 @@
       audioSamples(new short int[AVCODEC_MAX_AUDIO_FRAME_SIZE]),
       allow_ac3_passthru(false),    allow_dts_passthru(false),
       disable_passthru(false),      max_channels(2),
-      dummy_frame(NULL),
+      last_ac3_channels(0),         dummy_frame(NULL),
       // DVD
       lastdvdtitle(-1),
       decodeStillFrame(false),
@@ -445 +445 @@
     allow_ac3_passthru = gContext->GetNumSetting("AC3PassThru", false);
     allow_dts_passthru = gContext->GetNumSetting("DTSPassThru", false);
     max_channels = (uint) gContext->GetNumSetting("MaxChannels", 2);
+    isAC3upmix = gContext->GetNumSetting("MythAC3Upmix", 0);
 
     audioIn.sample_size = -32; // force SetupAudioStream to run once
     itv = GetNVP()->GetInteractiveTV();
@@ -2946 +2947 @@
     {
         int idx = atracks[i].av_stream_index;
         AVCodecContext *codec_ctx = ic->streams[idx]->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));
         AudioInfo item(codec_ctx->codec_id,
                        codec_ctx->sample_rate, codec_ctx->channels,
-                       do_ac3_passthru || do_dts_passthru);
+                       DoPassThrough(codec_ctx));
         VERBOSE(VB_AUDIO, LOC + " * " + item.toString());
     }
 #endif
@@ -3088 +3083 @@
 bool AvFormatDecoder::GetFrame(int onlyvideo)
 {
     AVPacket *pkt = NULL;
+    AC3HeaderInfo hdr;
     int len;
     unsigned char *ptr;
     int data_size = 0;
@@ -3274 +3270 @@
         pts = 0;
 
         AVStream *curstream = ic->streams[pkt->stream_index];
+        AVCodecContext *ctx = curstream->codec;
 
         if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
             pts = (long long)(av_q2d(curstream->time_base) * pkt->dts * 1000);
 
         if (ringBuffer->isDVD() && 
-            curstream->codec->codec_type == CODEC_TYPE_VIDEO)
+            ctx->codec_type == CODEC_TYPE_VIDEO)
         {
             MpegPreProcessPkt(curstream, pkt);
 
@@ -3307 +3304 @@
 
             if (!d->HasMPEG2Dec())
             {
-                int current_width = curstream->codec->width;
+                int current_width = ctx->width;
                 int video_width = GetNVP()->GetVideoSize().width();
                 if (dvd_xvmc_enabled && GetNVP() && GetNVP()->getVideoOutput())
                 {
@@ -3348 +3345 @@
         }
 
         if (storevideoframes &&
-            curstream->codec->codec_type == CODEC_TYPE_VIDEO)
+            ctx->codec_type == CODEC_TYPE_VIDEO)
         {
             av_dup_packet(pkt);
             storedPackets.append(pkt);
@@ -3356 +3353 @@
             continue;
         }
 
-        if (len > 0 && curstream->codec->codec_type == CODEC_TYPE_VIDEO &&
+        if (len > 0 && ctx->codec_type == CODEC_TYPE_VIDEO &&
             pkt->stream_index == selectedVideoIndex)
         {
-            AVCodecContext *context = curstream->codec;
 
-            if (context->codec_id == CODEC_ID_MPEG1VIDEO ||
-                context->codec_id == CODEC_ID_MPEG2VIDEO ||
-                context->codec_id == CODEC_ID_MPEG2VIDEO_XVMC ||
-                context->codec_id == CODEC_ID_MPEG2VIDEO_XVMC_VLD ||
-                context->codec_id == CODEC_ID_MPEGVIDEO_VDPAU)
+            if (ctx->codec_id == CODEC_ID_MPEG1VIDEO ||
+                ctx->codec_id == CODEC_ID_MPEG2VIDEO ||
+                ctx->codec_id == CODEC_ID_MPEG2VIDEO_XVMC ||
+                ctx->codec_id == CODEC_ID_MPEG2VIDEO_XVMC_VLD ||
+                ctx->codec_id == CODEC_ID_MPEGVIDEO_VDPAU)
             {
                 if (!ringBuffer->isDVD())
                     MpegPreProcessPkt(curstream, pkt);
             }
-            else if (context->codec_id == CODEC_ID_H264 ||
-                     context->codec_id == CODEC_ID_H264_VDPAU)
+            else if (ctx->codec_id == CODEC_ID_H264 ||
+                     ctx->codec_id == CODEC_ID_H264_VDPAU)
             {
                 H264PreProcessPkt(curstream, pkt);
             }
@@ -3417 +3413 @@
         }
 
         if (len > 0 &&
-            curstream->codec->codec_type == CODEC_TYPE_DATA &&
-            curstream->codec->codec_id   == CODEC_ID_MPEG2VBI)
+            ctx->codec_type == CODEC_TYPE_DATA &&
+            ctx->codec_id   == CODEC_ID_MPEG2VBI)
         {
             ProcessVBIDataPacket(curstream, pkt);
 
@@ -3427 +3423 @@
         }
 
         if (len > 0 &&
-            curstream->codec->codec_type == CODEC_TYPE_DATA &&
-            curstream->codec->codec_id   == CODEC_ID_DVB_VBI)
+            ctx->codec_type == CODEC_TYPE_DATA &&
+            ctx->codec_id   == CODEC_ID_DVB_VBI)
         {
             ProcessDVBDataPacket(curstream, pkt);
 
@@ -3437 +3433 @@
         }
 
         if (len > 0 &&
-            curstream->codec->codec_type == CODEC_TYPE_DATA &&
-            curstream->codec->codec_id   == CODEC_ID_DSMCC_B)
+            ctx->codec_type == CODEC_TYPE_DATA &&
+            ctx->codec_id   == CODEC_ID_DSMCC_B)
         {
             ProcessDSMCCPacket(curstream, pkt);
 
@@ -3458 +3454 @@
         }
 
         // we don't care about other data streams
-        if (curstream->codec->codec_type == CODEC_TYPE_DATA)
+        if (ctx->codec_type == CODEC_TYPE_DATA)
         {
             av_free_packet(pkt);
             continue;
         }
 
-        if (!curstream->codec->codec)
+        if (!ctx->codec)
         {
             VERBOSE(VB_PLAYBACK, LOC +
                     QString("No codec for stream index %1, type(%2) id(%3:%4)")
                     .arg(pkt->stream_index)
-                    .arg(codec_type_string(curstream->codec->codec_type))
-                    .arg(codec_id_string(curstream->codec->codec_id))
-                    .arg(curstream->codec->codec_id));
+                    .arg(codec_type_string(ctx->codec_type))
+                    .arg(codec_id_string(ctx->codec_id))
+                    .arg(ctx->codec_id));
             av_free_packet(pkt);
             continue;
         }
@@ -3480 +3476 @@
         have_err = false;
 
         avcodeclock.lock();
-        int ctype  = curstream->codec->codec_type;
+        int ctype  = ctx->codec_type;
         int audIdx = selectedTrack[kTrackTypeAudio].av_stream_index;
         int audSubIdx = selectedTrack[kTrackTypeAudio].av_substream_index;
         int subIdx = selectedTrack[kTrackTypeSubtitle].av_stream_index;
@@ -3505 +3501 @@
 
                     // detect switches between stereo and dual languages
                     bool wasDual = audSubIdx != -1;
-                    bool isDual = curstream->codec->avcodec_dual_language;
+                    bool isDual = ctx->avcodec_dual_language;
                     if ((wasDual && !isDual) || (!wasDual &&  isDual))
                     {
                         SetupAudioStreamSubIndexes(audIdx);
                         reselectAudioTrack = true;
                     }                            
 
-                    bool do_ac3_passthru =
-                        (allow_ac3_passthru && !transcoding &&
-                         (curstream->codec->codec_id == CODEC_ID_AC3));
-                    bool do_dts_passthru =
-                        (allow_dts_passthru && !transcoding &&
-                         (curstream->codec->codec_id == CODEC_ID_DTS));
-                    bool using_passthru = do_ac3_passthru || do_dts_passthru;
-
                     // detect channels on streams that need
                     // to be decoded before we can know this
                     bool already_decoded = false;
-                    if (!curstream->codec->channels)
+                    if (!ctx->channels)
                     {
                         QMutexLocker locker(&avcodeclock);
                         VERBOSE(VB_IMPORTANT, LOC +
                                 QString("Setting channels to %1")
                                 .arg(audioOut.channels));
 
-                        if (using_passthru)
+                        if (DoPassThrough(ctx))
                         {
                             // for passthru let it select the max number
                             // of channels
-                            curstream->codec->channels = 0;
-                            curstream->codec->request_channels = 0;
+                            ctx->channels = 0;
+                            ctx->request_channels = 0;
                         }
                         else
                         {
-                            curstream->codec->channels = audioOut.channels;
-                            curstream->codec->request_channels =
+                            ctx->channels = audioOut.channels;
+                            ctx->request_channels =
                                 audioOut.channels;
                         }
                         ret = avcodec_decode_audio(
-                            curstream->codec, audioSamples,
+                            ctx, audioSamples,
                             &data_size, ptr, len);
                         already_decoded = true;
 
-                        reselectAudioTrack |= curstream->codec->channels;
+                        reselectAudioTrack |= ctx->channels;
+                    }
+
+                    if (isAC3upmix && ctx->codec_id == CODEC_ID_AC3 &&
+                        !ff_ac3_parse_header(ptr, &hdr)) 
+                    {
+                        if (hdr.channels != last_ac3_channels) 
+                        {
+                            last_ac3_channels = ctx->channels = hdr.channels;
+                            SetupAudioStream();
+                        }
                     }
 
                     if (reselectAudioTrack)
@@ -3564 +3562 @@
                             .av_stream_index;
                         audSubIdx = selectedTrack[kTrackTypeAudio]
                             .av_substream_index;
+                        ctx = curstream->codec;
                     }
 
                     if ((onlyvideo > 0) || (pkt->stream_index != audIdx))
@@ -3595 +3594 @@
                     if (audioOut.do_passthru)
                     {
                         data_size = pkt->size;
-                        bool dts = CODEC_ID_DTS == curstream->codec->codec_id;
+                        bool dts = CODEC_ID_DTS == ctx->codec_id;
                         ret = encode_frame(dts, ptr, len,
                                            audioSamples, data_size);
                     }
                     else
                     {
-                        AVCodecContext *ctx = curstream->codec;
-
                         if ((ctx->channels == 0) ||
                             (ctx->channels > audioOut.channels))
                         {
@@ -3611 +3608 @@
 
                         if (!already_decoded)
                         {
-                            curstream->codec->request_channels =
-                                audioOut.channels;
+                            ctx->request_channels = audioOut.channels;
                             ret = avcodec_decode_audio(
                                 ctx, audioSamples, &data_size, ptr, len);
                         }
@@ -3629 +3625 @@
                             audIdx = -1;
                             AutoSelectAudioTrack();
                             data_size = 0;
+                            ctx = curstream->codec;
                         }
                     }
                     avcodeclock.unlock();
@@ -3646 +3643 @@
 
                     // calc for next frame
                     lastapts += (long long)((double)(data_size * 1000) /
-                                (curstream->codec->channels * 2) / 
-                                curstream->codec->sample_rate);
+                                (ctx->channels * 2) / ctx->sample_rate);
 
                     VERBOSE(VB_PLAYBACK|VB_TIMESTAMP,
                             LOC + QString("audio timecode %1 %2 %3 %4") 
@@ -3707 +3703 @@
                         continue;
                     }
 
-                    AVCodecContext *context = curstream->codec;
                     AVFrame mpa_pic;
                     bzero(&mpa_pic, sizeof(AVFrame));
 
@@ -3722 +3717 @@
                             // HACK
                             while (!gotpicture && count < 5)
                             {
-                                ret = d->DecodeMPEG2Video(context, &mpa_pic,
+                                ret = d->DecodeMPEG2Video(ctx, &mpa_pic,
                                                   &gotpicture, ptr, len);
                                 count++;
                             }
                         }
                         else
                         {
-                            ret = d->DecodeMPEG2Video(context, &mpa_pic,
+                            ret = d->DecodeMPEG2Video(ctx, &mpa_pic,
                                                 &gotpicture, ptr, len);
                         }
                     }
                     else
                     {
-                        ret = avcodec_decode_video(context, &mpa_pic,
+                        ret = avcodec_decode_video(ctx, &mpa_pic,
                                                    &gotpicture, ptr, len);
                         // Reparse it to not drop the DVD still frame
                         if (decodeStillFrame)
-                            ret = avcodec_decode_video(context, &mpa_pic,
+                            ret = avcodec_decode_video(ctx, &mpa_pic,
                                                         &gotpicture, ptr, len);
                     }
                     avcodeclock.unlock();
@@ -3806 +3801 @@
 
                         img_convert(&tmppicture, PIX_FMT_YUV420P, 
                                     (AVPicture *)&mpa_pic,
-                                    context->pix_fmt,
-                                    context->width,
-                                    context->height);
+                                    ctx->pix_fmt,
+                                    ctx->width,
+                                    ctx->height);
 
                         if (xf)
                         {
@@ -3831 +3826 @@
                         (temppts + 10000 > lastvpts || temppts < 0))
                     {
                         temppts = lastvpts;
-                        temppts += (long long)(1000 * av_q2d(context->time_base));
+                        temppts += (long long)(1000 * av_q2d(ctx->time_base));
                         // MPEG2 frames can be repeated, update pts accordingly
                         temppts += (long long)(mpa_pic.repeat_pict * 500
-                                      * av_q2d(curstream->codec->time_base));
+                                      * av_q2d(ctx->time_base));
                     }
 
                     VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, LOC +
@@ -3870 +3865 @@
                     picframe->frameNumber = framesPlayed;
                     GetNVP()->ReleaseNextVideoFrame(picframe, temppts);
                     if (d->HasMPEG2Dec() && mpa_pic.data[3])
-                        context->release_buffer(context, &mpa_pic);
+                        ctx->release_buffer(ctx, &mpa_pic);
 
                     decoded_video_frame = picframe;
                     gotvideo = 1;
@@ -3929 +3924 @@
                 }
                 default:
                 {
-                    AVCodecContext *enc = curstream->codec;
                     VERBOSE(VB_IMPORTANT, LOC_ERR +
                             QString("Decoding - id(%1) type(%2)")
-                            .arg(codec_id_string(enc->codec_id))
-                            .arg(codec_type_string(enc->codec_type)));
+                            .arg(codec_id_string(ctx->codec_id))
+                            .arg(codec_type_string(ctx->codec_type)));
                     have_err = true;
                     break;
                 }
@@ -4082 +4076 @@
     }
 }
 
+bool AvFormatDecoder::DoPassThrough(const AVCodecContext *ctx)
+{
+    bool do_ac3_passthru =
+        (allow_ac3_passthru && !transcoding &&
+        (ctx->codec_id == CODEC_ID_AC3));
+    bool do_dts_passthru =
+        (allow_dts_passthru && !transcoding &&
+        (ctx->codec_id == CODEC_ID_DTS));
+    bool using_passthru = do_ac3_passthru || do_dts_passthru;
+
+    if (!isAC3upmix)
+        return using_passthru;
+
+    bool passthru = false; 
+
+    if (ctx->codec_id == CODEC_ID_AC3)
+        passthru = allow_ac3_passthru && 
+                   ctx->channels >= (int)max_channels;
+    else if (ctx->codec_id == CODEC_ID_DTS)
+        passthru = allow_dts_passthru;
+    
+    passthru &= !transcoding && !disable_passthru;
+    // Don't know any cards that support spdif clocked at < 44100
+    // Some US cable transmissions have 2ch 32k AC-3 streams
+    passthru &= ctx->sample_rate >= 44100;
+
+    return passthru;
+}
+
 /** \fn AvFormatDecoder::SetupAudioStream(void)
  *  \brief Reinitializes audio if it needs to be reinitialized.
  *
@@ -4107 +4130 @@
         assert(curstream);
         assert(curstream->codec);
         codec_ctx = curstream->codec;        
-        bool do_ac3_passthru = (allow_ac3_passthru && !transcoding &&
-                                (codec_ctx->codec_id == CODEC_ID_AC3));
-        bool do_dts_passthru = (allow_dts_passthru && !transcoding &&
-                                (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,
-                         using_passthru && !disable_passthru);
+        using_passthru = DoPassThrough(codec_ctx);
+        if (!isAC3upmix)
+            info = AudioInfo(codec_ctx->codec_id, codec_ctx->sample_rate, codec_ctx->channels, using_passthru && !disable_passthru);
+        else
+            info = AudioInfo(codec_ctx->codec_id, codec_ctx->sample_rate, 
+                             codec_ctx->channels, using_passthru);
     }
 
     if (info == audioIn)
@@ -4125 +4146 @@
             QString("audio track #%1").arg(currentTrack[kTrackTypeAudio]+1));
 
     audioOut = audioIn = info;
+    if (!isAC3upmix) {
     if (using_passthru)
     {
         // A passthru stream looks like a 48KHz 2ch (@ 16bit) to the sound card
@@ -4181 +4203 @@
 
     // allow the audio stuff to reencode
     GetNVP()->SetAudioCodec(using_passthru?codec_ctx:NULL);
+    } else {
+
+    if (!using_passthru && audioOut.channels > (int)max_channels)
+    {
+        audioOut.channels = (int)max_channels;
+        audioOut.sample_size = audioOut.channels * 2;
+        codec_ctx->channels = audioOut.channels;
+    }
+    
+    VERBOSE(VB_AUDIO, LOC + "Audio format changed " +
+            QString("\n\t\t\tfrom %1 to %2")
+            .arg(old_in.toString()).arg(audioOut.toString()));
+
+    if (audioOut.sample_rate > 0)
+        GetNVP()->SetEffDsp(audioOut.sample_rate * 100);
+
+    GetNVP()->SetAudioParams(audioOut.bps(), audioOut.channels,
+                             audioOut.sample_rate,
+                             audioOut.do_passthru);
+    
+    }
     QString errMsg = GetNVP()->ReinitAudio();
     bool audiook = errMsg.isEmpty();
 

mythtv/libs/libmythtv/avformatdecoder.h

@@ -185 +185 @@
     void InitVideoCodec(AVStream *stream, AVCodecContext *enc,
                         bool selectedStream = false);
 
-    /// Preprocess a packet, setting the video parms if nessesary.
+    /// Preprocess a packet, setting the video parms if necessary.
     void MpegPreProcessPkt(AVStream *stream, AVPacket *pkt);
     void H264PreProcessPkt(AVStream *stream, AVPacket *pkt);
 
@@ -198 +198 @@
 
     void SeekReset(long long, uint skipFrames, bool doFlush, bool discardFrames);
 
+    bool DoPassThrough(const AVCodecContext *ctx);
     bool SetupAudioStream(void);
     void SetupAudioStreamSubIndexes(int streamIndex);
     void RemoveAudioStreams();
@@ -266 +267 @@
     bool              allow_dts_passthru;
     bool              disable_passthru;
     uint              max_channels;
+    uint              last_ac3_channels;
+    bool              isAC3upmix;
 
     VideoFrame       *dummy_frame;
 

mythtv/libs/libmythtv/tv_play.cpp

@@ -348 +348 @@
     REG_KEY("TV Playback", "VOLUMEDOWN", "Volume down", "[,{,F10,Volume Down");
     REG_KEY("TV Playback", "VOLUMEUP",   "Volume up",   "],},F11,Volume Up");
     REG_KEY("TV Playback", "MUTE",       "Mute",        "|,\\,F9,Volume Mute");
+    REG_KEY("TV Playback", "TOGGLEUPMIX", "Toggle upmixer", "Ctrl+U");
     REG_KEY("TV Playback", "TOGGLEPIPMODE", "Toggle Picture-in-Picture mode",
             "V");
     REG_KEY("TV Playback", "TOGGLEPIPWINDOW", "Toggle active PiP window", "B");
@@ -480 +481 @@
   Teletext     F2,F3,F4,F5,F6,F7,F8
   ITV          F2,F3,F4,F5,F6,F7,F12
 
-  Playback: Ctrl-B,Ctrl-G,Ctrl-Y
+  Playback: Ctrl-B,Ctrl-G,Ctrl-Y,Ctrl-U
 */
 }
 
@@ -2712 +2713 @@
             else if (action == "VOLUMEDOWN" || action == "VOLUMEUP" ||
                      action == "STRETCHINC" || action == "STRETCHDEC" ||
                      action == "MUTE"       || action == "TOGGLEASPECT" ||
-                     action == "TOGGLEFILL" )
+                     action == "TOGGLEFILL" || action == "TOGGLEUPMIX")
             {
                 passThru = 1;
                 handled = false;
@@ -2767 +2768 @@
             else if (action == "VOLUMEDOWN" || action == "VOLUMEUP" ||
                      action == "STRETCHINC" || action == "STRETCHDEC" ||
                      action == "MUTE" || action == "PAUSE" ||
-                     action == "CLEAROSD")
+                     action == "CLEAROSD" || action == "TOGGLEUPMIX")
             {
                 passThru = 1;
                 handled = false;
@@ -3072 +3073 @@
             ChangeTimeStretch(0);   // just display
         else if (action == "TOGGLESTRETCH")
             ToggleTimeStretch();
+        else if (action == "TOGGLEUPMIX")
+            ToggleUpmix();
         else if (action == "CYCLECOMMSKIPMODE") {
             SetAutoCommercialSkip((enum commSkipMode)
                                   ((autoCommercialSkip + 1) % CommSkipModes));
@@ -6056 +6059 @@
     }
 }
 
+void TV::ToggleUpmix()
+{
+    AudioOutput *aud = nvp->getAudioOutput();
+    if (!aud)
+        return;
+    QString text;
+    if(!aud->isAC3upmix) {
+        text = tr("Upmixer disabled !");
+    } else {
+        if (aud->ToggleUpmix())
+            text = tr("Upmixer On");
+        else
+            text = tr("Upmixer Off");
+    }
+    
+    if (GetOSD() && !browsemode)
+        GetOSD()->SetSettingsText(text, 5);
+}
+    
+
 // dir in 10ms jumps
 void TV::ChangeAudioSync(int dir, bool allowEdit)
 {
@@ -7304 +7327 @@
 
         ChangeTimeStretch(0, !floatRead);   // just display
     }
+    else if (action == "TOGGLEUPMIX")
+        ToggleUpmix();
     else if (action.left(11) == "SELECTSCAN_")
         activenvp->SetScanType((FrameScanType) action.right(1).toInt());
     else if (action.left(15) == "TOGGLEAUDIOSYNC")
@@ -7552 +7577 @@
                                  (speedX100 == 150) ? 1 : 0, NULL,
                                  "STRETCHGROUP");
 
+    if(nvp && nvp->getAudioOutput()->isAC3upmix)
+        item = new OSDGenericTree(treeMenu, tr("Toggle Upmixer"), "TOGGLEUPMIX");
+
     // add scan mode override settings to menu
     FrameScanType scan_type = kScan_Ignore;
     bool scan_type_locked = false;

mythtv/libs/libmythtv/tv_play.h

@@ -314 +314 @@
     void ChangeSpeed(int direction);
     void ToggleTimeStretch(void);
     void ChangeTimeStretch(int dir, bool allowEdit = true);
+    void ToggleUpmix(void);
     void ChangeAudioSync(int dir, bool allowEdit = true);
     float StopFFRew(void);
     void ChangeFFRew(int direction);

mythtv/programs/mythfrontend/globalsettings.cpp

@@ -116 +116 @@
     return gc;
 }
 
+static HostCheckBox *AC3Upmix()
+{
+    HostCheckBox *gc = new HostCheckBox("MythAC3Upmix");
+    gc->setLabel(QObject::tr("AC3 audio upmixer"));
+    gc->setValue(false);
+    gc->setHelpText(QObject::tr("Enable AC3 upmixer and digital software volume control."));
+    return gc;
+}
+
+static HostComboBox *SRCQuality()
+{
+    HostComboBox *gc = new HostComboBox("SRCQuality", false);
+    gc->setLabel(QObject::tr("Sample Rate Conversion"));
+    gc->addSelection(QObject::tr("Best"), "3", true); // default
+    gc->addSelection(QObject::tr("Medium"), "2");
+    gc->addSelection(QObject::tr("Fastest"), "1");
+    gc->addSelection(QObject::tr("Disabled"), "0");
+    gc->setHelpText(
+            QObject::tr(
+                "Set the quality of audio sample rate conversion. "
+                "This only affects non 48000Hz PCM audio. "
+                "All three options offer a worst-case SNR of 97dB. "
+                "'Best' at a bandwidth of 97%. "
+                "'Medium' at a bandwidth of 90%. "
+                "'Fastest' at a bandwidth of 80%. "
+                "Set 'Disabled' only if you know what you are doing."));
+    return gc;
+}
+
 static HostComboBox *PassThroughOutputDevice()
 {
     HostComboBox *gc = new HostComboBox("PassThruOutputDevice", true);
@@ -3284 +3313 @@
     return gs;
 }
 
+class AC3UpmixSettings : public TriggeredConfigurationGroup
+{
+  public:
+     AC3UpmixSettings(Setting *checkbox, ConfigurationGroup *group) :
+         TriggeredConfigurationGroup(false, false, false, false)
+     {
+        setTrigger(checkbox);
+
+        addTarget("1", group);
+        addTarget("0", new VerticalConfigurationGroup(false,false));
+     }
+};
+
 class AudioSettings : public TriggeredConfigurationGroup
 {
   public:
@@ -3296 +3338 @@
          addChild(AudioOutputDevice());
          addChild(PassThroughOutputDevice());
 
-         // General boolean settings
-         VerticalConfigurationGroup *vgrp0 =
+        // General boolean settings
+        VerticalConfigurationGroup *vgrp0 =
              new VerticalConfigurationGroup(false, false, true, true);
-         vgrp0->addChild(AC3PassThrough());
-         vgrp0->addChild(DTSPassThrough());
+        vgrp0->addChild(AC3PassThrough());
+        vgrp0->addChild(DTSPassThrough());
 
-         HorizontalConfigurationGroup *agrp =
+        HorizontalConfigurationGroup *agrp =
              new HorizontalConfigurationGroup(false, false, true, true);
-         agrp->addChild(MaxAudioChannels());
-         agrp->addChild(AudioUpmixType());
-         addChild(agrp);
+        agrp->addChild(MaxAudioChannels());
+        agrp->addChild(AudioUpmixType());
+        addChild(agrp);
+
+        HorizontalConfigurationGroup *agrp1 =
+             new HorizontalConfigurationGroup(false, false, true, true);
+
+        VerticalConfigurationGroup *agrp1v1 =
+             new VerticalConfigurationGroup(false, false, true, true);
+
+        Setting* ac3upmix = AC3Upmix();
+            agrp1v1->addChild(ac3upmix);
+        agrp1->addChild(agrp1v1);
+
+        VerticalConfigurationGroup *agrp1v2 =
+            new VerticalConfigurationGroup(false, false, true, true);
+
+        agrp1v2->addChild(SRCQuality());
+
+        AC3UpmixSettings *sub1 =
+            new AC3UpmixSettings(ac3upmix, agrp1v2);
+        agrp1->addChild(sub1);
+        addChild(agrp1);
 
          VerticalConfigurationGroup *vgrp1 =
              new VerticalConfigurationGroup(false, false, true, true);

mythtv/programs/mythtranscode/transcode.cpp

@@ -218 +218 @@
         // Do nothing
         return MUTE_OFF;
     }
+    virtual bool ToggleUpmix(void) 
+    {
+        // Do nothing
+        return false;
+    }
 
     //  These are pure virtual in AudioOutput, but we don't need them here
     virtual void bufferOutputData(bool){ return; }