Merge lp:~mixxxdevelopers/mixxx/features_hydra into lp:~mixxxdevelopers/mixxx/trunk

[RJ Skerry-Ryan]

Threw together some quick engine changes, but I'd like a review on them because they're substantial:

* Delete EngineVolume -- it was a trivial wrapper around a ControlLogpotmeter

* Make per-channel volume a gain factor when mixing the master output. This eliminates some hackyness w/ EngineChannel::isPFL that has been bugging me and saves 1 pass over every channel buffer.

* Eliminate use of QList in EngineMaster::process(). I noticed from gprof and some of Jus's traces that time spent in the QList in EngineMaster::process was higher than I had expected. Furthermore, allocating a QList on the stack malloc's every callback. It's not desirable if we can get around it. I removed that in favor of a bitvector approach, and I made way for some hard-coding of the mixing of higher #s of decks, because Mixxx will by default come with 6 or 7 EngineChannels turned on in 1.10.0, this is going to be more important than before.

[RJ Skerry-Ryan (rryan)]

BTW, the EngineMaster tests still pass, so I'm pretty confident this is fine for our uses. Something should be done about the 16-deck limit. With an int64, we could support 64-decks. We could also use two to get 128, but those aren't realistic cases for Mixxx right now so I didn't bother.

[lp:~mixxxdevelopers/mixxx/features_hydra]

2721. By RJ Skerry-Ryan on 2011-04-01

More improvements to EngineMaster. Headphone mixing now goes through the fast-path of mixing channels instead of being added one by one (this has the added benefit of unifying the mixing code used for both the master and headphone channels). Added special-casing for the mixing of up to 7 channels. Folded the master volume into the master mixing step so we save a pass over the buffer there.

[RJ Skerry-Ryan (rryan)]

Many more improvements now. I think this tightens up the EngineMaster code quite a bit. Headphone and master mixing are both done through the same codepath now. I also shaved another pass off by folding the master volume into the master mixing step. Headphone mixing is now faster because it uses the hard-coded mixing steps instead of the N-pass adding.

[lp:~mixxxdevelopers/mixxx/features_hydra]

2722. By RJ Skerry-Ryan on 2011-04-01

Forgot a return value, and for some braindead reason GCC compiled it.

[Albert Santoni (gamegod)]

I checked the coefficients and looked over the code, didn't see anything that looks out of place. Though we haven't measured the performance gains, this is definitely a step in the right direction.

Thanks RJ!

review: Approve

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2011-03-29 08:45:42 +0000
+++ mixxx/build/depends.py	2011-04-01 04:36:32 +0000
@@ -358,7 +358,6 @@
                    "engine/enginefilter.cpp",
                    "engine/engineobject.cpp",
                    "engine/enginepregain.cpp",
-                   "engine/enginevolume.cpp",
                    "engine/enginechannel.cpp",
                    "engine/enginemaster.cpp",
                    "engine/enginedelay.cpp",

=== modified file 'mixxx/src/engine/enginechannel.cpp'
--- mixxx/src/engine/enginechannel.cpp	2011-03-13 00:21:05 +0000
+++ mixxx/src/engine/enginechannel.cpp	2011-04-01 04:36:32 +0000
@@ -22,7 +22,6 @@
 #include "enginechannel.h"
 #include "engineclipping.h"
 #include "enginepregain.h"
-#include "enginevolume.h"
 #include "engineflanger.h"
 #include "enginefilterblock.h"
 #include "enginevumeter.h"
@@ -39,7 +38,6 @@
     m_pClipping = new EngineClipping(group);
     m_pBuffer = new EngineBuffer(group, pConfig);
     m_pVinylSoundEmu = new EngineVinylSoundEmu(pConfig, group);
-    m_pVolume = new EngineVolume(ConfigKey(group, "volume"));
     m_pVUMeter = new EngineVuMeter(group);
     m_pPFL = new ControlPushButton(ConfigKey(group, "pfl"));
     m_pPFL->setToggleButton(true);
@@ -54,7 +52,6 @@
     delete m_pFlanger;
     delete m_pPregain;
     delete m_pVinylSoundEmu;
-    delete m_pVolume;
     delete m_pVUMeter;
     delete m_pPFL;
 }
@@ -82,14 +79,6 @@
     m_pClipping->process(pOut, pOut, iBufferSize);
     // Update VU meter
     m_pVUMeter->process(pOut, pOut, iBufferSize);
-    // Apply channel volume if we aren't PFL
-    if (!isPFL()) {
-        m_pVolume->process(pOut, pOut, iBufferSize);
-    }
-}
-
-void EngineChannel::applyVolume(CSAMPLE *pBuff, const int iBufferSize) const {
-    m_pVolume->process(pBuff, pBuff, iBufferSize);
 }
 
 EngineBuffer* EngineChannel::getEngineBuffer() {

=== modified file 'mixxx/src/engine/enginechannel.h'
--- mixxx/src/engine/enginechannel.h	2011-03-13 00:21:05 +0000
+++ mixxx/src/engine/enginechannel.h	2011-04-01 04:36:32 +0000
@@ -27,7 +27,6 @@
 class EngineBuffer;
 class EngineFilterBlock;
 class EngineClipping;
-class EngineVolume;
 class EngineFlanger;
 class EngineVuMeter;
 class EngineVinylSoundEmu;
@@ -50,7 +49,6 @@
     virtual const QString& getGroup();
 
     virtual void process(const CSAMPLE *pIn, const CSAMPLE *pOut, const int iBufferSize);
-    virtual void applyVolume(CSAMPLE *pBuff, const int iBufferSize) const;
 
     // TODO(XXX) This hack needs to be removed.
     virtual EngineBuffer* getEngineBuffer();
@@ -68,7 +66,6 @@
     EngineFlanger* m_pFlanger;
     EnginePregain* m_pPregain;
     EngineVinylSoundEmu* m_pVinylSoundEmu;
-    EngineVolume* m_pVolume;
     EngineVuMeter* m_pVUMeter;
 };
 

=== modified file 'mixxx/src/engine/enginemaster.cpp'
--- mixxx/src/engine/enginemaster.cpp	2010-12-16 16:29:53 +0000
+++ mixxx/src/engine/enginemaster.cpp	2011-04-01 04:36:32 +0000
@@ -21,12 +21,12 @@
 
 #include "controlpushbutton.h"
 #include "configobject.h"
+#include "controllogpotmeter.h"
 #include "controlpotmeter.h"
 #include "enginebuffer.h"
 #include "enginemaster.h"
 #include "engine/engineworkerscheduler.h"
 #include "enginebuffer.h"
-#include "enginevolume.h"
 #include "enginechannel.h"
 #include "engineclipping.h"
 #include "enginevumeter.h"
@@ -66,7 +66,7 @@
     m_pBalance = new ControlPotmeter(ConfigKey(group, "balance"), -1., 1.);
 
     // Master volume
-    volume = new EngineVolume(ConfigKey(group,"volume"), 5.);
+    m_pMasterVolume = new ControlLogpotmeter(ConfigKey(group, "volume"), 5.);
 
     // Clipping
     clipping = new EngineClipping(group);
@@ -75,7 +75,7 @@
     vumeter = new EngineVuMeter(group);
 
     // Headphone volume
-    head_volume = new EngineVolume(ConfigKey(group, "headVolume"), 5.);
+    m_pHeadVolume = new ControlLogpotmeter(ConfigKey(group, "headVolume"), 5.);
 
     // Headphone mix (left/right)
     head_mix = new ControlPotmeter(ConfigKey(group, "headMix"),-1.,1.);
@@ -105,34 +105,24 @@
     delete crossfader;
     delete m_pBalance;
     delete head_mix;
-    delete volume;
-    delete head_volume;
+    delete m_pMasterVolume;
+    delete m_pHeadVolume;
     delete clipping;
     delete head_clipping;
     delete sidechain;
 
-
     SampleUtil::free(m_pHead);
     SampleUtil::free(m_pMaster);
 
-
-    QMutableListIterator<CSAMPLE*> buffer_it(m_channelBuffers);
-    while (buffer_it.hasNext()) {
-        CSAMPLE* buffer = buffer_it.next();
-        buffer_it.remove();
-        SampleUtil::free(buffer);
-    }
-
-
-    QMutableListIterator<EngineChannel*> channel_it(m_channels);
+    QMutableListIterator<ChannelInfo*> channel_it(m_channels);
     while (channel_it.hasNext()) {
-        EngineChannel* channel = channel_it.next();
+        ChannelInfo* pChannelInfo = channel_it.next();
         channel_it.remove();
-        delete channel;
+        SampleUtil::free(pChannelInfo->m_pBuffer);
+        delete pChannelInfo->m_pChannel;
+        delete pChannelInfo->m_pVolumeControl;
+        delete pChannelInfo;
     }
-
-
-
 }
 
 const CSAMPLE* EngineMaster::getMasterBuffer() const
@@ -145,6 +135,167 @@
     return m_pHead;
 }
 
+void EngineMaster::mixChannels(unsigned int channelBitvector, unsigned int maxChannels,
+                               CSAMPLE* pOutput, unsigned int iBufferSize,
+                               GainCalculator* pGainCalculator) {
+    // Common case: 2 decks, 4 samplers, 1 mic
+    ChannelInfo* pChannel1 = NULL;
+    ChannelInfo* pChannel2 = NULL;
+    ChannelInfo* pChannel3 = NULL;
+    ChannelInfo* pChannel4 = NULL;
+    ChannelInfo* pChannel5 = NULL;
+    ChannelInfo* pChannel6 = NULL;
+    ChannelInfo* pChannel7 = NULL;
+
+    unsigned int totalActive = 0;
+    for (unsigned int i = 0; i < maxChannels; ++i) {
+        if ((channelBitvector & (1 << i)) == 0) {
+            continue;
+        }
+
+        ++totalActive;
+
+        if (pChannel1 == NULL) {
+            pChannel1 = m_channels[i];
+        } else if (pChannel2 == NULL) {
+            pChannel2 = m_channels[i];
+        } else if (pChannel3 == NULL) {
+            pChannel3 = m_channels[i];
+        } else if (pChannel4 == NULL) {
+            pChannel4 = m_channels[i];
+        } else if (pChannel5 == NULL) {
+            pChannel5 = m_channels[i];
+        } else if (pChannel6 == NULL) {
+            pChannel6 = m_channels[i];
+        } else if (pChannel7 == NULL) {
+            pChannel7 = m_channels[i];
+        }
+    }
+
+    if (totalActive == 0) {
+        SampleUtil::applyGain(pOutput, 0.0f, iBufferSize);
+    } else if (totalActive == 1) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        SampleUtil::copyWithGain(pOutput,
+                                 pBuffer1, gain1,
+                                 iBufferSize);
+    } else if (totalActive == 2) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        CSAMPLE* pBuffer2 = pChannel2->m_pBuffer;
+        double gain2 = pGainCalculator->getGain(pChannel2);
+        SampleUtil::copy2WithGain(pOutput,
+                                  pBuffer1, gain1,
+                                  pBuffer2, gain2,
+                                  iBufferSize);
+    } else if (totalActive == 3) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        CSAMPLE* pBuffer2 = pChannel2->m_pBuffer;
+        double gain2 = pGainCalculator->getGain(pChannel2);
+        CSAMPLE* pBuffer3 = pChannel3->m_pBuffer;
+        double gain3 = pGainCalculator->getGain(pChannel3);
+
+        SampleUtil::copy3WithGain(pOutput,
+                                  pBuffer1, gain1,
+                                  pBuffer2, gain2,
+                                  pBuffer3, gain3,
+                                  iBufferSize);
+    } else if (totalActive == 4) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        CSAMPLE* pBuffer2 = pChannel2->m_pBuffer;
+        double gain2 = pGainCalculator->getGain(pChannel2);
+        CSAMPLE* pBuffer3 = pChannel3->m_pBuffer;
+        double gain3 = pGainCalculator->getGain(pChannel3);
+        CSAMPLE* pBuffer4 = pChannel4->m_pBuffer;
+        double gain4 = pGainCalculator->getGain(pChannel4);
+        SampleUtil::copy4WithGain(pOutput,
+                                  pBuffer1, gain1,
+                                  pBuffer2, gain2,
+                                  pBuffer3, gain3,
+                                  pBuffer4, gain4,
+                                  iBufferSize);
+    } else if (totalActive == 5) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        CSAMPLE* pBuffer2 = pChannel2->m_pBuffer;
+        double gain2 = pGainCalculator->getGain(pChannel2);
+        CSAMPLE* pBuffer3 = pChannel3->m_pBuffer;
+        double gain3 = pGainCalculator->getGain(pChannel3);
+        CSAMPLE* pBuffer4 = pChannel4->m_pBuffer;
+        double gain4 = pGainCalculator->getGain(pChannel4);
+        CSAMPLE* pBuffer5 = pChannel5->m_pBuffer;
+        double gain5 = pGainCalculator->getGain(pChannel5);
+
+        SampleUtil::copy5WithGain(pOutput,
+                                  pBuffer1, gain1,
+                                  pBuffer2, gain2,
+                                  pBuffer3, gain3,
+                                  pBuffer4, gain4,
+                                  pBuffer5, gain5,
+                                  iBufferSize);
+    } else if (totalActive == 6) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        CSAMPLE* pBuffer2 = pChannel2->m_pBuffer;
+        double gain2 = pGainCalculator->getGain(pChannel2);
+        CSAMPLE* pBuffer3 = pChannel3->m_pBuffer;
+        double gain3 = pGainCalculator->getGain(pChannel3);
+        CSAMPLE* pBuffer4 = pChannel4->m_pBuffer;
+        double gain4 = pGainCalculator->getGain(pChannel4);
+        CSAMPLE* pBuffer5 = pChannel5->m_pBuffer;
+        double gain5 = pGainCalculator->getGain(pChannel5);
+        CSAMPLE* pBuffer6 = pChannel6->m_pBuffer;
+        double gain6 = pGainCalculator->getGain(pChannel6);
+        SampleUtil::copy6WithGain(pOutput,
+                                  pBuffer1, gain1,
+                                  pBuffer2, gain2,
+                                  pBuffer3, gain3,
+                                  pBuffer4, gain4,
+                                  pBuffer5, gain5,
+                                  pBuffer6, gain6,
+                                  iBufferSize);
+    } else if (totalActive == 7) {
+        CSAMPLE* pBuffer1 = pChannel1->m_pBuffer;
+        double gain1 = pGainCalculator->getGain(pChannel1);
+        CSAMPLE* pBuffer2 = pChannel2->m_pBuffer;
+        double gain2 = pGainCalculator->getGain(pChannel2);
+        CSAMPLE* pBuffer3 = pChannel3->m_pBuffer;
+        double gain3 = pGainCalculator->getGain(pChannel3);
+        CSAMPLE* pBuffer4 = pChannel4->m_pBuffer;
+        double gain4 = pGainCalculator->getGain(pChannel4);
+        CSAMPLE* pBuffer5 = pChannel5->m_pBuffer;
+        double gain5 = pGainCalculator->getGain(pChannel5);
+        CSAMPLE* pBuffer6 = pChannel6->m_pBuffer;
+        double gain6 = pGainCalculator->getGain(pChannel6);
+        CSAMPLE* pBuffer7 = pChannel7->m_pBuffer;
+        double gain7 = pGainCalculator->getGain(pChannel7);
+        SampleUtil::copy7WithGain(pOutput,
+                                  pBuffer1, gain1,
+                                  pBuffer2, gain2,
+                                  pBuffer3, gain3,
+                                  pBuffer4, gain4,
+                                  pBuffer5, gain5,
+                                  pBuffer6, gain6,
+                                  pBuffer7, gain7,
+                                  iBufferSize);
+    } else {
+        // Set pOutput to all 0s
+        SampleUtil::applyGain(pOutput, 0.0f, iBufferSize);
+
+        for (unsigned int i = 0; i < maxChannels; ++i) {
+            if (channelBitvector & (1 << i)) {
+                ChannelInfo* pChannelInfo = m_channels[i];
+                CSAMPLE* pBuffer = pChannelInfo->m_pBuffer;
+                double gain = pGainCalculator->getGain(pChannelInfo);
+                SampleUtil::addWithGain(pOutput, pBuffer, gain, iBufferSize);
+            }
+        }
+    }
+}
+
 void EngineMaster::process(const CSAMPLE *, const CSAMPLE *pOut, const int iBufferSize)
 {
     CSAMPLE **pOutput = (CSAMPLE**)pOut;
@@ -152,7 +303,10 @@
 
     // Prepare each channel for output
 
-    QList<QPair<CSAMPLE*, EngineChannel::ChannelOrientation> > masterChannels;
+    // Bitvector of enabled channels
+    const unsigned int maxChannels = 32;
+    unsigned int masterOutput = 0;
+    unsigned int headphoneOutput = 0;
 
     // Compute headphone mix
     // Head phone left/right mix
@@ -162,88 +316,43 @@
     // qDebug() << "head val " << cf_val << ", head " << chead_gain
     //          << ", master " << cmaster_gain;
 
-    // we have to copy PFL channels to the headphone buffer here before we
-    // process the master mix, as PFL channels don't have their fader volume
-    // applied but the master channels do -- bkgood
-    SampleUtil::applyGain(m_pHead, 0.0f, iBufferSize);
-
-    for (int channel_number = 0; channel_number < m_channels.size(); ++channel_number) {
-        EngineChannel* channel = m_channels[channel_number];
-
-        if (!channel->isActive()) {
+    QList<ChannelInfo*>::iterator it = m_channels.begin();
+    for (unsigned int channel_number = 0;
+         it != m_channels.end(); ++it, ++channel_number) {
+        ChannelInfo* pChannelInfo = *it;
+        EngineChannel* pChannel = pChannelInfo->m_pChannel;
+
+        if (!pChannel->isActive()) {
             continue;
         }
 
-        CSAMPLE* buffer = m_channelBuffers[channel_number];
-        channel->process(NULL, buffer, iBufferSize);
+        masterOutput |= (1 << channel_number);
+
+        // Process the buffer
+        pChannel->process(NULL, pChannelInfo->m_pBuffer, iBufferSize);
 
         // If the channel is enabled for previewing in headphones, copy it
         // over to the headphone buffer
-        if (channel->isPFL()) {
-            SampleUtil::addWithGain(m_pHead, buffer, chead_gain, iBufferSize);
-            // EngineChannel doesn't apply the volume if it knows it's PFL,
-            // so apply it
-            channel->applyVolume(buffer, iBufferSize);
+        if (pChannel->isPFL()) {
+            headphoneOutput |= (1 << channel_number);
         }
-
-        // Add the channel to the list of master output channels.
-        masterChannels.push_back(
-            QPair<CSAMPLE*, EngineChannel::ChannelOrientation>(
-                buffer, channel->getOrientation()));
     }
 
-    // Perform the master mix.
+    // Mix all the enabled headphone channels together.
+    m_headphoneGain.setGain(chead_gain);
+    mixChannels(headphoneOutput, maxChannels, m_pHead, iBufferSize, &m_headphoneGain);
 
-    // Crossfader and Transform buttons
-    //set gain levels;
+    // Calculate the crossfader gains for left and right side of the crossfader
     float c1_gain, c2_gain;
     EngineXfader::getXfadeGains(c1_gain, c2_gain,
                                 crossfader->get(), xFaderCurve->get(),
                                 xFaderCalibration->get());
 
-    if (masterChannels.size() == 0) {
-        SampleUtil::applyGain(m_pMaster, 0.0f, iBufferSize);
-    } else if (masterChannels.size() == 1) {
-        QPair<CSAMPLE*, EngineChannel::ChannelOrientation>& channel =
-                masterChannels[0];
-        CSAMPLE* buffer = channel.first;
-        EngineChannel::ChannelOrientation orientation = channel.second;
-
-        // Apply gain
-        double gain = gainForOrientation(orientation, c1_gain, 1.0f, c2_gain);
-        SampleUtil::copyWithGain(m_pMaster, buffer, gain, iBufferSize);
-    } else if (masterChannels.size() == 2) {
-        QPair<CSAMPLE*, EngineChannel::ChannelOrientation> channel1 =
-                masterChannels[0];
-        QPair<CSAMPLE*, EngineChannel::ChannelOrientation> channel2 =
-                masterChannels[1];
-        CSAMPLE* buffer1 = channel1.first;
-        CSAMPLE* buffer2 = channel2.first;
-        EngineChannel::ChannelOrientation orientation1 = channel1.second;
-        EngineChannel::ChannelOrientation orientation2 = channel2.second;
-        double gain1 = gainForOrientation(orientation1, c1_gain, 1.0f, c2_gain);
-        double gain2 = gainForOrientation(orientation2, c1_gain, 1.0f, c2_gain);
-
-        SampleUtil::copy2WithGain(m_pMaster,
-                                  buffer1, gain1,
-                                  buffer2, gain2,
-                                  iBufferSize);
-    } else {
-        // Set m_pMaster to all 0s
-        SampleUtil::applyGain(m_pMaster, 0.0f, iBufferSize);
-
-        for (int i = 0; i < masterChannels.size(); ++i) {
-            QPair<CSAMPLE*, EngineChannel::ChannelOrientation> channel =
-                    masterChannels[i];
-            CSAMPLE* buffer = channel.first;
-            EngineChannel::ChannelOrientation orientation = channel.second;
-            double gain = gainForOrientation(orientation, c1_gain, 1.0f, c2_gain);
-            SampleUtil::addWithGain(m_pMaster, buffer, gain, iBufferSize);
-        }
-    }
-
-    // Master volume
-    volume->process(m_pMaster, m_pMaster, iBufferSize);
+    // Now set the gains for overall volume and the left, center, right gains.
+    m_masterGain.setGains(m_pMasterVolume->get(), c1_gain, 1.0, c2_gain);
+
+    // Perform the master mix
+    mixChannels(masterOutput, maxChannels, m_pMaster, iBufferSize, &m_masterGain);
 
 #ifdef __LADSPA__
     // LADPSA master effects
@@ -278,7 +387,7 @@
     SampleUtil::addWithGain(m_pHead, m_pMaster, cmaster_gain, iBufferSize);
 
     // Head volume and clipping
-    head_volume->process(m_pHead, m_pHead, iBufferSize);
+    SampleUtil::applyGain(m_pHead, m_pHeadVolume->get(), iBufferSize);
     head_clipping->process(m_pHead, m_pHead, iBufferSize);
 
     //Master/headphones interleaving is now done in
@@ -290,18 +399,21 @@
 }
 
 void EngineMaster::addChannel(EngineChannel* pChannel) {
-    CSAMPLE* pChannelBuffer = SampleUtil::alloc(MAX_BUFFER_LEN);
-    memset(pChannelBuffer, 0, sizeof(CSAMPLE) * MAX_BUFFER_LEN);
-    m_channelBuffers.push_back(pChannelBuffer);
-    m_channels.push_back(pChannel);
-    pChannel->getEngineBuffer()->bindWorkers(m_pWorkerScheduler);
+    ChannelInfo* pChannelInfo = new ChannelInfo();
+    pChannelInfo->m_pChannel = pChannel;
+    pChannelInfo->m_pVolumeControl = new ControlLogpotmeter(
+        ConfigKey(pChannel->getGroup(), pChannel->getGroup()), 1.0);
+    pChannelInfo->m_pBuffer = SampleUtil::alloc(MAX_BUFFER_LEN);
+    memset(pChannelInfo->m_pBuffer, 0, sizeof(CSAMPLE) * MAX_BUFFER_LEN);
+    m_channels.push_back(pChannelInfo);
+    pChannelInfo->m_pChannel->getEngineBuffer()->bindWorkers(m_pWorkerScheduler);
 
     // TODO(XXX) WARNING HUGE HACK ALERT In the case of 2-decks, this code hooks
     // the two EngineBuffers together so they can beat-sync off of each other.
     // rryan 6/2010
     if (m_channels.length() == 2) {
-        EngineBuffer *pBuffer1 = m_channels[0]->getEngineBuffer();
-        EngineBuffer *pBuffer2 = m_channels[1]->getEngineBuffer();
+        EngineBuffer *pBuffer1 = m_channels[0]->m_pChannel->getEngineBuffer();
+        EngineBuffer *pBuffer2 = m_channels[1]->m_pChannel->getEngineBuffer();
         pBuffer1->setOtherEngineBuffer(pBuffer2);
         pBuffer2->setOtherEngineBuffer(pBuffer1);
     }
@@ -313,7 +425,7 @@
 
 const CSAMPLE* EngineMaster::getChannelBuffer(unsigned int i) const {
     if (i < numChannels()) {
-        return m_channelBuffers[i];
+        return m_channels[i]->m_pBuffer;
     }
     return NULL;
 }

=== modified file 'mixxx/src/engine/enginemaster.h'
--- mixxx/src/engine/enginemaster.h	2010-10-27 18:28:54 +0000
+++ mixxx/src/engine/enginemaster.h	2011-04-01 04:36:32 +0000
@@ -18,12 +18,14 @@
 #ifndef ENGINEMASTER_H
 #define ENGINEMASTER_H
 
+#include <QMap>
+
+#include "controlobject.h"
 #include "engine/engineobject.h"
 #include "engine/enginechannel.h"
 
 class EngineWorkerScheduler;
 class EngineBuffer;
-class EngineVolume;
 class EngineChannel;
 class EngineClipping;
 class EngineFlanger;
@@ -33,7 +35,6 @@
 class EngineVuMeter;
 class ControlPotmeter;
 class ControlPushButton;
-class ControlObject;
 class EngineVinylSoundEmu;
 class EngineSideChain;
 
@@ -55,20 +56,64 @@
     // only call it before the engine has started mixing.
     void addChannel(EngineChannel* pChannel);
 
-    static double gainForOrientation(EngineChannel::ChannelOrientation orientation,
-                              double leftGain,
-                              double centerGain,
-                              double rightGain);
+    static inline double gainForOrientation(EngineChannel::ChannelOrientation orientation,
+                                            double leftGain,
+                                            double centerGain,
+                                            double rightGain);
 
   private:
-    QList<EngineChannel*> m_channels;
+    struct ChannelInfo {
+        EngineChannel* m_pChannel;
+        CSAMPLE* m_pBuffer;
+        ControlObject* m_pVolumeControl;
+    };
+
+    class GainCalculator {
+      public:
+        virtual double getGain(ChannelInfo* pChannelInfo) = 0;
+    };
+    class ConstantGainCalculator : public GainCalculator {
+      public:
+        inline double getGain(ChannelInfo* pChannelInfo) {
+            return m_dGain;
+        }
+        inline double setGain(double dGain) {
+            m_dGain = dGain;
+        }
+      private:
+        double m_dGain;
+    };
+    class OrientationVolumeGainCalculator : public GainCalculator {
+      public:
+        inline double getGain(ChannelInfo* pChannelInfo) {
+            double channelVolume = pChannelInfo->m_pVolumeControl->get();
+            double orientationGain = EngineMaster::gainForOrientation(
+                pChannelInfo->m_pChannel->getOrientation(),
+                m_dLeftGain, m_dCenterGain, m_dRightGain);
+            return m_dVolume * channelVolume * orientationGain;
+        }
+
+        inline void setGains(double dVolume, double leftGain, double centerGain, double rightGain) {
+            m_dVolume = dVolume;
+            m_dLeftGain = leftGain;
+            m_dCenterGain = centerGain;
+            m_dRightGain = rightGain;
+        }
+      private:
+        double m_dVolume, m_dLeftGain, m_dCenterGain, m_dRightGain;
+    };
+
+    void mixChannels(unsigned int channelBitvector, unsigned int maxChannels,
+                     CSAMPLE* pOutput, unsigned int iBufferSize, GainCalculator* pGainCalculator);
+
+
+    QList<ChannelInfo*> m_channels;
 
     CSAMPLE *m_pMaster, *m_pHead;
-    QList<CSAMPLE*> m_channelBuffers;
 
     EngineWorkerScheduler *m_pWorkerScheduler;
 
-    EngineVolume *volume, *head_volume;
+    ControlObject *m_pMasterVolume, *m_pHeadVolume;
     EngineClipping *clipping, *head_clipping;
 #ifdef __LADSPA__
     EngineLADSPA *ladspa;
@@ -78,6 +123,9 @@
 
     ControlPotmeter *crossfader, *head_mix,
         *m_pBalance, *xFaderCurve, *xFaderCalibration;
+
+    ConstantGainCalculator m_headphoneGain;
+    OrientationVolumeGainCalculator m_masterGain;
 };
 
 #endif

=== removed file 'mixxx/src/engine/enginevolume.cpp'
--- mixxx/src/engine/enginevolume.cpp	2010-06-02 21:26:29 +0000
+++ mixxx/src/engine/enginevolume.cpp	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/***************************************************************************
-                          enginevolume.cpp  -  description
-                             -------------------
-    copyright            : (C) 2002 by Tue and Ken Haste Andersen
-    email                :
-***************************************************************************/
-
-/***************************************************************************
-*                                                                         *
-*   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.                                   *
-*                                                                         *
-***************************************************************************/
-
-#include "enginevolume.h"
-#include "controllogpotmeter.h"
-#include "configobject.h"
-#include "sampleutil.h"
-
-/*----------------------------------------------------------------
-   Volume effect.
-   ----------------------------------------------------------------*/
-EngineVolume::EngineVolume(ConfigKey key, double maxval)
-{
-    potmeter = new ControlLogpotmeter(key, maxval);
-}
-
-EngineVolume::~EngineVolume()
-{
-    delete potmeter;
-}
-
-void EngineVolume::process(const CSAMPLE * pIn, const CSAMPLE * pOut, const int iBufferSize)
-{
-    CSAMPLE * pOutput = (CSAMPLE *)pOut;
-    double volume = potmeter->get();
-
-    // SampleUtil handles aliased buffers and gains of 1 or 0.
-    SampleUtil::copyWithGain(pOutput, pIn, volume, iBufferSize);
-}

=== removed file 'mixxx/src/engine/enginevolume.h'
--- mixxx/src/engine/enginevolume.h	2009-01-24 04:39:32 +0000
+++ mixxx/src/engine/enginevolume.h	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-/***************************************************************************
-                          enginevolume.h  -  description
-                             -------------------
-    copyright            : (C) 2002 by Tue and Ken Haste Andersen
-    email                :
- ***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   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.                                   *
- *                                                                         *
- ***************************************************************************/
-
-#ifndef ENGINEVOLUME_H
-#define ENGINEVOLUME_H
-
-#include "engineobject.h"
-
-class ControlLogpotmeter;
-class ConfigKey;
-
-class EngineVolume : public EngineObject {
-public:
-    EngineVolume(ConfigKey key, double maxval=1.);
-    ~EngineVolume();
-    void process(const CSAMPLE *pIn, const CSAMPLE *pOut, const int iBufferSize);
-
-private:
-    CSAMPLE *buffer;
-    ControlLogpotmeter *potmeter;
-};
-
-#endif

=== modified file 'mixxx/src/sampleutil.cpp'
--- mixxx/src/sampleutil.cpp	2010-06-02 11:16:22 +0000
+++ mixxx/src/sampleutil.cpp	2011-04-01 04:36:32 +0000
@@ -489,6 +489,155 @@
 }
 
 // static
+void SampleUtil::copy4WithGain(CSAMPLE* pDest,
+                               const CSAMPLE* pSrc1, CSAMPLE gain1,
+                               const CSAMPLE* pSrc2, CSAMPLE gain2,
+                               const CSAMPLE* pSrc3, CSAMPLE gain3,
+                               const CSAMPLE* pSrc4, CSAMPLE gain4,
+                               int iNumSamples) {
+    if (gain1 == 0.0f) {
+        return copy3WithGain(pDest, pSrc2, gain2, pSrc3, gain3, pSrc4, gain4, iNumSamples);
+    }
+    if (gain2 == 0.0f) {
+        return copy3WithGain(pDest, pSrc1, gain1, pSrc3, gain3, pSrc4, gain4, iNumSamples);
+    }
+    if (gain3 == 0.0f) {
+        return copy3WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc4, gain4, iNumSamples);
+    }
+    if (gain4 == 0.0f) {
+        return copy3WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3, iNumSamples);
+    }
+    if (m_sOptimizationsOn) {
+        // TODO(rryan) implement SSE for this? worth it?
+    }
+    for (int i = 0; i < iNumSamples; ++i) {
+        pDest[i] = pSrc1[i] * gain1 + pSrc2[i] * gain2 + pSrc3[i] * gain3 + pSrc4[i] * gain4;
+    }
+}
+
+// static
+void SampleUtil::copy5WithGain(CSAMPLE* pDest,
+                               const CSAMPLE* pSrc1, CSAMPLE gain1,
+                               const CSAMPLE* pSrc2, CSAMPLE gain2,
+                               const CSAMPLE* pSrc3, CSAMPLE gain3,
+                               const CSAMPLE* pSrc4, CSAMPLE gain4,
+                               const CSAMPLE* pSrc5, CSAMPLE gain5,
+                               int iNumSamples) {
+    if (gain1 == 0.0f) {
+        return copy4WithGain(pDest, pSrc2, gain2, pSrc3, gain3, pSrc4, gain4, pSrc5, gain5, iNumSamples);
+    }
+    if (gain2 == 0.0f) {
+        return copy4WithGain(pDest, pSrc1, gain1, pSrc3, gain3, pSrc4, gain4, pSrc5, gain5, iNumSamples);
+    }
+    if (gain3 == 0.0f) {
+        return copy4WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc4, gain4, pSrc5, gain5, iNumSamples);
+    }
+    if (gain4 == 0.0f) {
+        return copy4WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3, pSrc5, gain5, iNumSamples);
+    }
+    if (gain5 == 0.0f) {
+        return copy4WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3, pSrc4, gain4, iNumSamples);
+    }
+
+    if (m_sOptimizationsOn) {
+        // TODO(rryan) implement SSE for this? worth it?
+    }
+
+    for (int i = 0; i < iNumSamples; ++i) {
+        pDest[i] = pSrc1[i] * gain1 + pSrc2[i] * gain2 + pSrc3[i] * gain3 + pSrc4[i] * gain4 + pSrc5[i] * gain5;
+    }
+}
+
+// static
+void SampleUtil::copy6WithGain(CSAMPLE* pDest,
+                               const CSAMPLE* pSrc1, CSAMPLE gain1,
+                               const CSAMPLE* pSrc2, CSAMPLE gain2,
+                               const CSAMPLE* pSrc3, CSAMPLE gain3,
+                               const CSAMPLE* pSrc4, CSAMPLE gain4,
+                               const CSAMPLE* pSrc5, CSAMPLE gain5,
+                               const CSAMPLE* pSrc6, CSAMPLE gain6,
+                               int iNumSamples) {
+    if (gain1 == 0.0f) {
+        return copy5WithGain(pDest, pSrc2, gain2, pSrc3, gain3, pSrc4, gain4,
+                             pSrc5, gain5, pSrc6, gain6, iNumSamples);
+    }
+    if (gain2 == 0.0f) {
+        return copy5WithGain(pDest, pSrc1, gain1, pSrc3, gain3, pSrc4, gain4,
+                             pSrc5, gain5, pSrc6, gain6, iNumSamples);
+    }
+    if (gain3 == 0.0f) {
+        return copy5WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc4, gain4,
+                             pSrc5, gain5, pSrc6, gain6, iNumSamples);
+    }
+    if (gain4 == 0.0f) {
+        return copy5WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc5, gain5, pSrc6, gain6, iNumSamples);
+    }
+    if (gain5 == 0.0f) {
+        return copy5WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc4, gain4, pSrc6, gain6, iNumSamples);
+    }
+    if (gain6 == 0.0f) {
+        return copy5WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc4, gain4, pSrc5, gain5, iNumSamples);
+    }
+    if (m_sOptimizationsOn) {
+        // TODO(rryan) implement SSE for this? worth it?
+    }
+    for (int i = 0; i < iNumSamples; ++i) {
+        pDest[i] = pSrc1[i] * gain1 + pSrc2[i] * gain2 + pSrc3[i] * gain3 +
+                pSrc4[i] * gain4 + pSrc5[i] * gain5 + pSrc6[i] * gain6;
+    }
+}
+
+// static
+void SampleUtil::copy7WithGain(CSAMPLE* pDest,
+                               const CSAMPLE* pSrc1, CSAMPLE gain1,
+                               const CSAMPLE* pSrc2, CSAMPLE gain2,
+                               const CSAMPLE* pSrc3, CSAMPLE gain3,
+                               const CSAMPLE* pSrc4, CSAMPLE gain4,
+                               const CSAMPLE* pSrc5, CSAMPLE gain5,
+                               const CSAMPLE* pSrc6, CSAMPLE gain6,
+                               const CSAMPLE* pSrc7, CSAMPLE gain7,
+                               int iNumSamples) {
+    if (gain1 == 0.0f) {
+        return copy6WithGain(pDest, pSrc2, gain2, pSrc3, gain3, pSrc4, gain4,
+                             pSrc5, gain5, pSrc6, gain6, pSrc7, gain7, iNumSamples);
+    }
+    if (gain2 == 0.0f) {
+        return copy6WithGain(pDest, pSrc1, gain1, pSrc3, gain3, pSrc4, gain4,
+                             pSrc5, gain5, pSrc6, gain6, pSrc7, gain7, iNumSamples);
+    }
+    if (gain3 == 0.0f) {
+        return copy6WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc4, gain4,
+                             pSrc5, gain5, pSrc6, gain6, pSrc7, gain7, iNumSamples);
+    }
+    if (gain4 == 0.0f) {
+        return copy6WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc5, gain5, pSrc6, gain6, pSrc7, gain7, iNumSamples);
+    }
+    if (gain5 == 0.0f) {
+        return copy6WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc4, gain4, pSrc6, gain6, pSrc7, gain7, iNumSamples);
+    }
+    if (gain6 == 0.0f) {
+        return copy6WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc4, gain4, pSrc5, gain5, pSrc7, gain7, iNumSamples);
+    }
+    if (gain7 == 0.0f) {
+        return copy6WithGain(pDest, pSrc1, gain1, pSrc2, gain2, pSrc3, gain3,
+                             pSrc4, gain4, pSrc5, gain5, pSrc6, gain6, iNumSamples);
+    }
+    if (m_sOptimizationsOn) {
+        // TODO(rryan) implement SSE for this? worth it?
+    }
+    for (int i = 0; i < iNumSamples; ++i) {
+        pDest[i] = pSrc1[i] * gain1 + pSrc2[i] * gain2 + pSrc3[i] * gain3 +
+                pSrc4[i] * gain4 + pSrc5[i] * gain5 + pSrc6[i] * gain6 + pSrc7[i] * gain7;
+    }
+}
+
+// static
 void SampleUtil::convert(CSAMPLE* pDest, const SAMPLE* pSrc,
                          int iNumSamples) {
     if (m_sOptimizationsOn) {

=== modified file 'mixxx/src/sampleutil.h'
--- mixxx/src/sampleutil.h	2010-06-01 07:23:52 +0000
+++ mixxx/src/sampleutil.h	2011-04-01 04:36:32 +0000
@@ -73,21 +73,57 @@
     static void copyWithGain(CSAMPLE* pDest, const CSAMPLE* pSrc,
                              CSAMPLE gain, int iNumSamples);
 
-    // Copy to pDest, each sample of pSrc1 multiplied by gain1 plus pSrc2
-    // multiplied by gain2
+    // Copies the sum of each channel, multiplied by its gain into pDest
     static void copy2WithGain(CSAMPLE* pDest,
                               const CSAMPLE* pSrc1, CSAMPLE gain1,
                               const CSAMPLE* pSrc2, CSAMPLE gain2,
                               int iNumSamples);
 
-    // Copy to pDest, each sample of pSrc1 multiplied by gain1 plus pSrc2
-    // multiplied by gain2 plus pSrc3 multiplied by gain3
+    // Copies the sum of each channel, multiplied by its gain into pDest
     static void copy3WithGain(CSAMPLE* pDest,
                               const CSAMPLE* pSrc1, CSAMPLE gain1,
                               const CSAMPLE* pSrc2, CSAMPLE gain2,
                               const CSAMPLE* pSrc3, CSAMPLE gain3,
                               int iNumSamples);
 
+    // Copies the sum of each channel, multiplied by its gain into pDest
+    static void copy4WithGain(CSAMPLE* pDest,
+                              const CSAMPLE* pSrc1, CSAMPLE gain1,
+                              const CSAMPLE* pSrc2, CSAMPLE gain2,
+                              const CSAMPLE* pSrc3, CSAMPLE gain3,
+                              const CSAMPLE* pSrc4, CSAMPLE gain4,
+                              int iNumSamples);
+
+    // Copies the sum of each channel, multiplied by its gain into pDest
+    static void copy5WithGain(CSAMPLE* pDest,
+                              const CSAMPLE* pSrc1, CSAMPLE gain1,
+                              const CSAMPLE* pSrc2, CSAMPLE gain2,
+                              const CSAMPLE* pSrc3, CSAMPLE gain3,
+                              const CSAMPLE* pSrc4, CSAMPLE gain4,
+                              const CSAMPLE* pSrc5, CSAMPLE gain5,
+                              int iNumSamples);
+
+    // Copies the sum of each channel, multiplied by its gain into pDest
+    static void copy6WithGain(CSAMPLE* pDest,
+                              const CSAMPLE* pSrc1, CSAMPLE gain1,
+                              const CSAMPLE* pSrc2, CSAMPLE gain2,
+                              const CSAMPLE* pSrc3, CSAMPLE gain3,
+                              const CSAMPLE* pSrc4, CSAMPLE gain4,
+                              const CSAMPLE* pSrc5, CSAMPLE gain5,
+                              const CSAMPLE* pSrc6, CSAMPLE gain6,
+                              int iNumSamples);
+
+    // Copies the sum of each channel, multiplied by its gain into pDest
+    static void copy7WithGain(CSAMPLE* pDest,
+                              const CSAMPLE* pSrc1, CSAMPLE gain1,
+                              const CSAMPLE* pSrc2, CSAMPLE gain2,
+                              const CSAMPLE* pSrc3, CSAMPLE gain3,
+                              const CSAMPLE* pSrc4, CSAMPLE gain4,
+                              const CSAMPLE* pSrc5, CSAMPLE gain5,
+                              const CSAMPLE* pSrc6, CSAMPLE gain6,
+                              const CSAMPLE* pSrc7, CSAMPLE gain7,
+                              int iNumSamples);
+
     // Convert a buffer of SAMPLEs to a buffer of CSAMPLEs. Does not work
     // in-place! pDest and pSrc must not be aliased.
     static void convert(CSAMPLE* pDest, const SAMPLE* pSrc, int iNumSamples);