juce/source/src/audio/processors/juce_AudioProcessor.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_AudioProcessor.h"
  31 #include "../../text/juce_XmlDocument.h"
  32
  33
  34 //==============================================================================
  35 AudioProcessor::AudioProcessor()
  36     : playHead (nullptr),
  37       sampleRate (0),
  38       blockSize (0),
  39       numInputChannels (0),
  40       numOutputChannels (0),
  41       latencySamples (0),
  42       suspended (false),
  43       nonRealtime (false)
  44 {
  45 }
  46
  47 AudioProcessor::~AudioProcessor()
  48 {
  49     // ooh, nasty - the editor should have been deleted before the filter
  50     // that it refers to is deleted..
  51     jassert (activeEditor == nullptr);
  52
  53 #if JUCE_DEBUG
  54     // This will fail if you've called beginParameterChangeGesture() for one
  55     // or more parameters without having made a corresponding call to endParameterChangeGesture...
  56     jassert (changingParams.countNumberOfSetBits() == 0);
  57 #endif
  58 }
  59
  60 void AudioProcessor::setPlayHead (AudioPlayHead* const newPlayHead) noexcept
  61 {
  62     playHead = newPlayHead;
  63 }
  64
  65 void AudioProcessor::addListener (AudioProcessorListener* const newListener)
  66 {
  67     const ScopedLock sl (listenerLock);
  68     listeners.addIfNotAlreadyThere (newListener);
  69 }
  70
  71 void AudioProcessor::removeListener (AudioProcessorListener* const listenerToRemove)
  72 {
  73     const ScopedLock sl (listenerLock);
  74     listeners.removeValue (listenerToRemove);
  75 }
  76
  77 void AudioProcessor::setPlayConfigDetails (const int numIns,
  78                                            const int numOuts,
  79                                            const double sampleRate_,
  80                                            const int blockSize_) noexcept
  81 {
  82     numInputChannels = numIns;
  83     numOutputChannels = numOuts;
  84     sampleRate = sampleRate_;
  85     blockSize = blockSize_;
  86 }
  87
  88 void AudioProcessor::setNonRealtime (const bool nonRealtime_) noexcept
  89 {
  90     nonRealtime = nonRealtime_;
  91 }
  92
  93 void AudioProcessor::setLatencySamples (const int newLatency)
  94 {
  95     if (latencySamples != newLatency)
  96     {
  97         latencySamples = newLatency;
  98         updateHostDisplay();
  99     }
 100 }
 101
 102 void AudioProcessor::setParameterNotifyingHost (const int parameterIndex,
 103                                                 const float newValue)
 104 {
 105     setParameter (parameterIndex, newValue);
 106     sendParamChangeMessageToListeners (parameterIndex, newValue);
 107 }
 108
 109 void AudioProcessor::sendParamChangeMessageToListeners (const int parameterIndex, const float newValue)
 110 {
 111     jassert (isPositiveAndBelow (parameterIndex, getNumParameters()));
 112
 113     for (int i = listeners.size(); --i >= 0;)
 114     {
 115         AudioProcessorListener* l;
 116
 117         {
 118             const ScopedLock sl (listenerLock);
 119             l = listeners [i];
 120         }
 121
 122         if (l != nullptr)
 123             l->audioProcessorParameterChanged (this, parameterIndex, newValue);
 124     }
 125 }
 126
 127 void AudioProcessor::beginParameterChangeGesture (int parameterIndex)
 128 {
 129     jassert (isPositiveAndBelow (parameterIndex, getNumParameters()));
 130
 131 #if JUCE_DEBUG
 132     // This means you've called beginParameterChangeGesture twice in succession without a matching
 133     // call to endParameterChangeGesture. That might be fine in most hosts, but better to avoid doing it.
 134     jassert (! changingParams [parameterIndex]);
 135     changingParams.setBit (parameterIndex);
 136 #endif
 137
 138     for (int i = listeners.size(); --i >= 0;)
 139     {
 140         AudioProcessorListener* l;
 141
 142         {
 143             const ScopedLock sl (listenerLock);
 144             l = listeners [i];
 145         }
 146
 147         if (l != nullptr)
 148             l->audioProcessorParameterChangeGestureBegin (this, parameterIndex);
 149     }
 150 }
 151
 152 void AudioProcessor::endParameterChangeGesture (int parameterIndex)
 153 {
 154     jassert (isPositiveAndBelow (parameterIndex, getNumParameters()));
 155
 156 #if JUCE_DEBUG
 157     // This means you've called endParameterChangeGesture without having previously called
 158     // endParameterChangeGesture. That might be fine in most hosts, but better to keep the
 159     // calls matched correctly.
 160     jassert (changingParams [parameterIndex]);
 161     changingParams.clearBit (parameterIndex);
 162 #endif
 163
 164     for (int i = listeners.size(); --i >= 0;)
 165     {
 166         AudioProcessorListener* l;
 167
 168         {
 169             const ScopedLock sl (listenerLock);
 170             l = listeners [i];
 171         }
 172
 173         if (l != nullptr)
 174             l->audioProcessorParameterChangeGestureEnd (this, parameterIndex);
 175     }
 176 }
 177
 178 void AudioProcessor::updateHostDisplay()
 179 {
 180     for (int i = listeners.size(); --i >= 0;)
 181     {
 182         AudioProcessorListener* l;
 183
 184         {
 185             const ScopedLock sl (listenerLock);
 186             l = listeners [i];
 187         }
 188
 189         if (l != nullptr)
 190             l->audioProcessorChanged (this);
 191     }
 192 }
 193
 194 bool AudioProcessor::isParameterAutomatable (int /*parameterIndex*/) const
 195 {
 196     return true;
 197 }
 198
 199 bool AudioProcessor::isMetaParameter (int /*parameterIndex*/) const
 200 {
 201     return false;
 202 }
 203
 204 void AudioProcessor::suspendProcessing (const bool shouldBeSuspended)
 205 {
 206     const ScopedLock sl (callbackLock);
 207     suspended = shouldBeSuspended;
 208 }
 209
 210 void AudioProcessor::reset()
 211 {
 212 }
 213
 214 //==============================================================================
 215 void AudioProcessor::editorBeingDeleted (AudioProcessorEditor* const editor) noexcept
 216 {
 217     const ScopedLock sl (callbackLock);
 218
 219     if (activeEditor == editor)
 220         activeEditor = nullptr;
 221 }
 222
 223 AudioProcessorEditor* AudioProcessor::createEditorIfNeeded()
 224 {
 225     if (activeEditor != nullptr)
 226         return activeEditor;
 227
 228     AudioProcessorEditor* const ed = createEditor();
 229
 230     // You must make your hasEditor() method return a consistent result!
 231     jassert (hasEditor() == (ed != nullptr));
 232
 233     if (ed != nullptr)
 234     {
 235         // you must give your editor comp a size before returning it..
 236         jassert (ed->getWidth() > 0 && ed->getHeight() > 0);
 237
 238         const ScopedLock sl (callbackLock);
 239         activeEditor = ed;
 240     }
 241
 242     return ed;
 243 }
 244
 245 //==============================================================================
 246 void AudioProcessor::getCurrentProgramStateInformation (JUCE_NAMESPACE::MemoryBlock& destData)
 247 {
 248     getStateInformation (destData);
 249 }
 250
 251 void AudioProcessor::setCurrentProgramStateInformation (const void* data, int sizeInBytes)
 252 {
 253     setStateInformation (data, sizeInBytes);
 254 }
 255
 256 //==============================================================================
 257 // magic number to identify memory blocks that we've stored as XML
 258 const uint32 magicXmlNumber = 0x21324356;
 259
 260 void AudioProcessor::copyXmlToBinary (const XmlElement& xml,
 261                                       JUCE_NAMESPACE::MemoryBlock& destData)
 262 {
 263     const String xmlString (xml.createDocument (String::empty, true, false));
 264     const int stringLength = xmlString.getNumBytesAsUTF8();
 265
 266     destData.setSize (stringLength + 10);
 267
 268     char* const d = static_cast<char*> (destData.getData());
 269     *(uint32*) d = ByteOrder::swapIfBigEndian ((const uint32) magicXmlNumber);
 270     *(uint32*) (d + 4) = ByteOrder::swapIfBigEndian ((const uint32) stringLength);
 271
 272     xmlString.copyToUTF8 (d + 8, stringLength + 1);
 273 }
 274
 275 XmlElement* AudioProcessor::getXmlFromBinary (const void* data,
 276                                               const int sizeInBytes)
 277 {
 278     if (sizeInBytes > 8
 279          && ByteOrder::littleEndianInt (data) == magicXmlNumber)
 280     {
 281         const int stringLength = (int) ByteOrder::littleEndianInt (addBytesToPointer (data, 4));
 282
 283         if (stringLength > 0)
 284             return XmlDocument::parse (String::fromUTF8 (static_cast<const char*> (data) + 8,
 285                                                          jmin ((sizeInBytes - 8), stringLength)));
 286     }
 287
 288     return nullptr;
 289 }
 290
 291 //==============================================================================
 292 void AudioProcessorListener::audioProcessorParameterChangeGestureBegin (AudioProcessor*, int) {}
 293 void AudioProcessorListener::audioProcessorParameterChangeGestureEnd (AudioProcessor*, int) {}
 294
 295 //==============================================================================
 296 bool AudioPlayHead::CurrentPositionInfo::operator== (const CurrentPositionInfo& other) const noexcept
 297 {
 298     return timeInSeconds == other.timeInSeconds
 299         && ppqPosition == other.ppqPosition
 300         && editOriginTime == other.editOriginTime
 301         && ppqPositionOfLastBarStart == other.ppqPositionOfLastBarStart
 302         && frameRate == other.frameRate
 303         && isPlaying == other.isPlaying
 304         && isRecording == other.isRecording
 305         && bpm == other.bpm
 306         && timeSigNumerator == other.timeSigNumerator
 307         && timeSigDenominator == other.timeSigDenominator;
 308 }
 309
 310 bool AudioPlayHead::CurrentPositionInfo::operator!= (const CurrentPositionInfo& other) const noexcept
 311 {
 312     return ! operator== (other);
 313 }
 314
 315 void AudioPlayHead::CurrentPositionInfo::resetToDefault()
 316 {
 317     zerostruct (*this);
 318     timeSigNumerator = 4;
 319     timeSigDenominator = 4;
 320     bpm = 120;
 321 }
 322
 323
 324 END_JUCE_NAMESPACE