juce/source/src/audio/processors/juce_AudioProcessorPlayer.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_AudioProcessorPlayer.h"
  31
  32
  33 //==============================================================================
  34 AudioProcessorPlayer::AudioProcessorPlayer()
  35     : processor (nullptr),
  36       sampleRate (0),
  37       blockSize (0),
  38       isPrepared (false),
  39       numInputChans (0),
  40       numOutputChans (0),
  41       tempBuffer (1, 1)
  42 {
  43 }
  44
  45 AudioProcessorPlayer::~AudioProcessorPlayer()
  46 {
  47     setProcessor (nullptr);
  48 }
  49
  50 //==============================================================================
  51 void AudioProcessorPlayer::setProcessor (AudioProcessor* const processorToPlay)
  52 {
  53     if (processor != processorToPlay)
  54     {
  55         if (processorToPlay != nullptr && sampleRate > 0 && blockSize > 0)
  56         {
  57             processorToPlay->setPlayConfigDetails (numInputChans, numOutputChans,
  58                                                    sampleRate, blockSize);
  59
  60             processorToPlay->prepareToPlay (sampleRate, blockSize);
  61         }
  62
  63         AudioProcessor* oldOne;
  64
  65         {
  66             const ScopedLock sl (lock);
  67             oldOne = isPrepared ? processor : nullptr;
  68             processor = processorToPlay;
  69             isPrepared = true;
  70         }
  71
  72         if (oldOne != nullptr)
  73             oldOne->releaseResources();
  74     }
  75 }
  76
  77 //==============================================================================
  78 void AudioProcessorPlayer::audioDeviceIOCallback (const float** const inputChannelData,
  79                                                   const int numInputChannels,
  80                                                   float** const outputChannelData,
  81                                                   const int numOutputChannels,
  82                                                   const int numSamples)
  83 {
  84     // these should have been prepared by audioDeviceAboutToStart()...
  85     jassert (sampleRate > 0 && blockSize > 0);
  86
  87     incomingMidi.clear();
  88     messageCollector.removeNextBlockOfMessages (incomingMidi, numSamples);
  89     int i, totalNumChans = 0;
  90
  91     if (numInputChannels > numOutputChannels)
  92     {
  93         // if there aren't enough output channels for the number of
  94         // inputs, we need to create some temporary extra ones (can't
  95         // use the input data in case it gets written to)
  96         tempBuffer.setSize (numInputChannels - numOutputChannels, numSamples,
  97                             false, false, true);
  98
  99         for (i = 0; i < numOutputChannels; ++i)
 100         {
 101             channels[totalNumChans] = outputChannelData[i];
 102             memcpy (channels[totalNumChans], inputChannelData[i], sizeof (float) * numSamples);
 103             ++totalNumChans;
 104         }
 105
 106         for (i = numOutputChannels; i < numInputChannels; ++i)
 107         {
 108             channels[totalNumChans] = tempBuffer.getSampleData (i - numOutputChannels, 0);
 109             memcpy (channels[totalNumChans], inputChannelData[i], sizeof (float) * numSamples);
 110             ++totalNumChans;
 111         }
 112     }
 113     else
 114     {
 115         for (i = 0; i < numInputChannels; ++i)
 116         {
 117             channels[totalNumChans] = outputChannelData[i];
 118             memcpy (channels[totalNumChans], inputChannelData[i], sizeof (float) * numSamples);
 119             ++totalNumChans;
 120         }
 121
 122         for (i = numInputChannels; i < numOutputChannels; ++i)
 123         {
 124             channels[totalNumChans] = outputChannelData[i];
 125             zeromem (channels[totalNumChans], sizeof (float) * numSamples);
 126             ++totalNumChans;
 127         }
 128     }
 129
 130     AudioSampleBuffer buffer (channels, totalNumChans, numSamples);
 131
 132     const ScopedLock sl (lock);
 133
 134     if (processor != nullptr)
 135     {
 136         const ScopedLock sl2 (processor->getCallbackLock());
 137
 138         if (processor->isSuspended())
 139         {
 140             for (i = 0; i < numOutputChannels; ++i)
 141                 zeromem (outputChannelData[i], sizeof (float) * numSamples);
 142         }
 143         else
 144         {
 145             processor->processBlock (buffer, incomingMidi);
 146         }
 147     }
 148 }
 149
 150 void AudioProcessorPlayer::audioDeviceAboutToStart (AudioIODevice* device)
 151 {
 152     const ScopedLock sl (lock);
 153
 154     sampleRate = device->getCurrentSampleRate();
 155     blockSize = device->getCurrentBufferSizeSamples();
 156     numInputChans = device->getActiveInputChannels().countNumberOfSetBits();
 157     numOutputChans = device->getActiveOutputChannels().countNumberOfSetBits();
 158
 159     messageCollector.reset (sampleRate);
 160     zeromem (channels, sizeof (channels));
 161
 162     if (processor != nullptr)
 163     {
 164         if (isPrepared)
 165             processor->releaseResources();
 166
 167         AudioProcessor* const oldProcessor = processor;
 168         setProcessor (nullptr);
 169         setProcessor (oldProcessor);
 170     }
 171 }
 172
 173 void AudioProcessorPlayer::audioDeviceStopped()
 174 {
 175     const ScopedLock sl (lock);
 176
 177     if (processor != nullptr && isPrepared)
 178         processor->releaseResources();
 179
 180     sampleRate = 0.0;
 181     blockSize = 0;
 182     isPrepared = false;
 183     tempBuffer.setSize (1, 1);
 184 }
 185
 186 void AudioProcessorPlayer::handleIncomingMidiMessage (MidiInput*, const MidiMessage& message)
 187 {
 188     messageCollector.addMessageToQueue (message);
 189 }
 190
 191
 192 END_JUCE_NAMESPACE