platform/mac/SuperColliderAU/AUSDK/AUScopeElement.cpp

   1 /*      Copyright © 2007 Apple Inc. All Rights Reserved.
   2
   3         Disclaimer: IMPORTANT:  This Apple software is supplied to you by
   4                         Apple Inc. ("Apple") in consideration of your agreement to the
   5                         following terms, and your use, installation, modification or
   6                         redistribution of this Apple software constitutes acceptance of these
   7                         terms.  If you do not agree with these terms, please do not use,
   8                         install, modify or redistribute this Apple software.
   9
  10                         In consideration of your agreement to abide by the following terms, and
  11                         subject to these terms, Apple grants you a personal, non-exclusive
  12                         license, under Apple's copyrights in this original Apple software (the
  13                         "Apple Software"), to use, reproduce, modify and redistribute the Apple
  14                         Software, with or without modifications, in source and/or binary forms;
  15                         provided that if you redistribute the Apple Software in its entirety and
  16                         without modifications, you must retain this notice and the following
  17                         text and disclaimers in all such redistributions of the Apple Software.
  18                         Neither the name, trademarks, service marks or logos of Apple Inc.
  19                         may be used to endorse or promote products derived from the Apple
  20                         Software without specific prior written permission from Apple.  Except
  21                         as expressly stated in this notice, no other rights or licenses, express
  22                         or implied, are granted by Apple herein, including but not limited to
  23                         any patent rights that may be infringed by your derivative works or by
  24                         other works in which the Apple Software may be incorporated.
  25
  26                         The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
  27                         MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
  28                         THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
  29                         FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
  30                         OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
  31
  32                         IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
  33                         OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34                         SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35                         INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
  36                         MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
  37                         AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
  38                         STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
  39                         POSSIBILITY OF SUCH DAMAGE.
  40 */
  41 /*=============================================================================
  42         AUScopeElement.cpp
  43
  44 =============================================================================*/
  45
  46 #include "AUScopeElement.h"
  47 #include "AUBase.h"
  48 #if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
  49         #include <CoreServices/CoreServices.h>
  50 #else
  51         #include <Endian.h>
  52 #endif
  53
  54 //_____________________________________________________________________________
  55 //
  56 //      By default, parameterIDs may be arbitrarily spaced, and an STL map
  57 //  will be used for access.  Calling UseIndexedParameters() will
  58 //      instead use an STL vector for faster indexed access.
  59 //      This assumes the paramIDs are numbered 0.....inNumberOfParameters-1
  60 //      Call this before defining/adding any parameters with SetParameter()
  61 //
  62 void    AUElement::UseIndexedParameters(int inNumberOfParameters)
  63 {
  64         mIndexedParameters.resize (inNumberOfParameters);
  65         mUseIndexedParameters = true;
  66 }
  67
  68 //_____________________________________________________________________________
  69 //
  70 //      Helper method.
  71 //      returns the ParameterMapEvent object associated with the paramID
  72 //
  73 inline ParameterMapEvent&       AUElement::GetParamEvent(AudioUnitParameterID paramID)
  74 {
  75         ParameterMapEvent *event;
  76
  77         if(mUseIndexedParameters)
  78         {
  79                 if(paramID >= mIndexedParameters.size() )
  80                         COMPONENT_THROW(kAudioUnitErr_InvalidParameter);
  81
  82                 event = &mIndexedParameters[paramID];
  83         }
  84         else
  85         {
  86                 ParameterMap::iterator i = mParameters.find(paramID);
  87                 if (i == mParameters.end())
  88                         COMPONENT_THROW(kAudioUnitErr_InvalidParameter);
  89
  90                 event = &(*i).second;
  91         }
  92
  93         return *event;
  94 }
  95
  96 //_____________________________________________________________________________
  97 //
  98 //      caller assumes that this is actually an immediate parameter
  99 //
 100 AudioUnitParameterValue         AUElement::GetParameter(AudioUnitParameterID paramID)
 101 {
 102         ParameterMapEvent &event = GetParamEvent(paramID);
 103
 104         return event.GetValue();
 105 }
 106
 107
 108 //_____________________________________________________________________________
 109 //
 110 void                    AUElement::GetRampSliceStartEnd(        AudioUnitParameterID            paramID,
 111                                                                                                         AudioUnitParameterValue &       outStartValue,
 112                                                                                                         AudioUnitParameterValue &       outEndValue,
 113                                                                                                         AudioUnitParameterValue &       outValuePerFrameDelta )
 114
 115 {
 116         ParameterMapEvent &event = GetParamEvent(paramID);
 117
 118         // works even if the value is constant (immediate parameter value)
 119         event.GetRampSliceStartEnd(outStartValue, outEndValue, outValuePerFrameDelta );
 120 }
 121
 122 //_____________________________________________________________________________
 123 //
 124 void                    AUElement::SetParameter(AudioUnitParameterID paramID, AudioUnitParameterValue inValue)
 125 {
 126         if(mUseIndexedParameters)
 127         {
 128                 ParameterMapEvent &event = GetParamEvent(paramID);
 129                 event.SetValue(inValue);
 130         }
 131         else
 132         {
 133                 ParameterMap::iterator i = mParameters.find(paramID);
 134
 135                 if (i == mParameters.end())
 136                 {
 137                         // create new entry in map for the paramID (only happens first time)
 138                         ParameterMapEvent event(inValue);
 139                         mParameters[paramID] = event;
 140                 }
 141                 else
 142                 {
 143                         // paramID already exists in map so simply change its value
 144                         ParameterMapEvent &event = (*i).second;
 145                         event.SetValue(inValue);
 146                 }
 147         }
 148 }
 149
 150 //_____________________________________________________________________________
 151 //
 152 void                    AUElement::SetScheduledEvent(   AudioUnitParameterID                    paramID,
 153                                                                                                 const AudioUnitParameterEvent   &inEvent,
 154                                                                                                 UInt32                                                  inSliceOffsetInBuffer,
 155                                                                                                 UInt32                                                  inSliceDurationFrames )
 156 {
 157         if(mUseIndexedParameters)
 158         {
 159                 ParameterMapEvent &event = GetParamEvent(paramID);
 160                 event.SetScheduledEvent(inEvent, inSliceOffsetInBuffer, inSliceDurationFrames );
 161         }
 162         else
 163         {
 164                 ParameterMap::iterator i = mParameters.find(paramID);
 165
 166                 if (i == mParameters.end())
 167                 {
 168                         // create new entry in map for the paramID (only happens first time)
 169                         ParameterMapEvent event(inEvent, inSliceOffsetInBuffer, inSliceDurationFrames );
 170                         mParameters[paramID] = event;
 171                 }
 172                 else
 173                 {
 174                         // paramID already exists in map so simply change its value
 175                         ParameterMapEvent &event = (*i).second;
 176
 177                         event.SetScheduledEvent(inEvent, inSliceOffsetInBuffer, inSliceDurationFrames );
 178                 }
 179         }
 180 }
 181
 182
 183
 184 //_____________________________________________________________________________
 185 //
 186 void                    AUElement::GetParameterList(AudioUnitParameterID *outList)
 187 {
 188         if(mUseIndexedParameters)
 189         {
 190                 UInt32 nparams = mIndexedParameters.size();
 191                 for (UInt32 i = 0; i < nparams; i++ )
 192                         *outList++ = (AudioUnitParameterID)i;
 193         }
 194         else
 195         {
 196                 for (ParameterMap::iterator i = mParameters.begin(); i != mParameters.end(); ++i)
 197                         *outList++ = (*i).first;
 198         }
 199 }
 200
 201 //_____________________________________________________________________________
 202 //
 203 void                    AUElement::SaveState(CFMutableDataRef data)
 204 {
 205         if(mUseIndexedParameters)
 206         {
 207                 UInt32 nparams = mIndexedParameters.size();
 208                 UInt32 theData = CFSwapInt32HostToBig(nparams);
 209                 CFDataAppendBytes(data, (UInt8 *)&theData, sizeof(nparams));
 210
 211                 for (UInt32 i = 0; i < nparams; i++)
 212                 {
 213                         struct {
 214                                 UInt32                          paramID;
 215                                 //CFSwappedFloat32      value; crashes gcc3 PFE
 216                                 UInt32                          value;  // really a big-endian float
 217                         } entry;
 218
 219                         entry.paramID = CFSwapInt32HostToBig(i);
 220
 221                         AudioUnitParameterValue v = mIndexedParameters[i].GetValue();
 222                         entry.value = CFSwapInt32HostToBig(*(UInt32 *)&v );
 223
 224                         CFDataAppendBytes(data, (UInt8 *)&entry, sizeof(entry));
 225                 }
 226         }
 227         else
 228         {
 229                 UInt32 nparams = CFSwapInt32HostToBig(mParameters.size());
 230                 CFDataAppendBytes(data, (UInt8 *)&nparams, sizeof(nparams));
 231
 232                 for (ParameterMap::iterator i = mParameters.begin(); i != mParameters.end(); ++i) {
 233                         struct {
 234                                 UInt32                          paramID;
 235                                 //CFSwappedFloat32      value; crashes gcc3 PFE
 236                                 UInt32                          value;  // really a big-endian float
 237                         } entry;
 238
 239                         entry.paramID = CFSwapInt32HostToBig((*i).first);
 240
 241                         AudioUnitParameterValue v = (*i).second.GetValue();
 242                         entry.value = CFSwapInt32HostToBig(*(UInt32 *)&v );
 243
 244                         CFDataAppendBytes(data, (UInt8 *)&entry, sizeof(entry));
 245                 }
 246         }
 247 }
 248
 249 //_____________________________________________________________________________
 250 //
 251 const UInt8 *   AUElement::RestoreState(const UInt8 *state)
 252 {
 253         union FloatInt32 { UInt32 i; AudioUnitParameterValue f; };
 254         const UInt8 *p = state;
 255         UInt32 nparams = CFSwapInt32BigToHost(*(UInt32 *)p);
 256         p += sizeof(UInt32);
 257
 258         for (UInt32 i = 0; i < nparams; ++i) {
 259                 struct {
 260                         AudioUnitParameterID            paramID;
 261                         AudioUnitParameterValue         value;
 262                 } entry;
 263
 264                 entry.paramID = CFSwapInt32BigToHost(*(UInt32 *)p);
 265                 p += sizeof(UInt32);
 266                 FloatInt32 temp;
 267                 temp.i = CFSwapInt32BigToHost(*(UInt32 *)p);
 268                 entry.value = temp.f;
 269                 p += sizeof(AudioUnitParameterValue);
 270
 271                 SetParameter(entry.paramID, entry.value);
 272         }
 273         return p;
 274 }
 275
 276 //_____________________________________________________________________________
 277 //
 278 void    AUElement::SetName (CFStringRef inName)
 279 {
 280         if (mElementName) CFRelease (mElementName);
 281         mElementName = inName;
 282         if (mElementName) CFRetain (mElementName);
 283 }
 284
 285
 286 //_____________________________________________________________________________
 287 //
 288 AUIOElement::AUIOElement(AUBase *audioUnit) :
 289         AUElement(audioUnit)
 290 {
 291         mStreamFormat.SetCanonical(2,   // stereo
 292                 audioUnit->AudioUnitAPIVersion() == 1);
 293                 // interleaved if API version 1, deinterleaved if version 2
 294         mStreamFormat.mSampleRate = kAUDefaultSampleRate;
 295 }
 296
 297 //_____________________________________________________________________________
 298 //
 299 OSStatus                AUIOElement::SetStreamFormat(const CAStreamBasicDescription &desc)
 300 {
 301         mStreamFormat = desc;
 302         return noErr;
 303 }
 304
 305 //_____________________________________________________________________________
 306 // inFramesToAllocate == 0 implies the AudioUnit's max-frames-per-slice will be used
 307 void                    AUIOElement::AllocateBuffer(UInt32 inFramesToAllocate)
 308 {
 309         if (GetAudioUnit()->IsInitialized())
 310         {
 311                 UInt32 framesToAllocate = inFramesToAllocate > 0 ? inFramesToAllocate : GetAudioUnit()->GetMaxFramesPerSlice();
 312
 313                 mIOBuffer.Allocate(mStreamFormat, NeedsBufferSpace() ? framesToAllocate : 0);
 314         }
 315 }
 316
 317 //_____________________________________________________________________________
 318 //
 319 void                    AUIOElement::DeallocateBuffer()
 320 {
 321         mIOBuffer.Deallocate();
 322 }
 323
 324 //_____________________________________________________________________________
 325 //
 326 //              AudioChannelLayout support
 327
 328 // outLayoutTagsPtr WILL be NULL if called to find out how many
 329 // layouts that Audio Unit will report
 330 // return 0 (ie. NO channel layouts) if the AU doesn't require channel layout knowledge
 331 UInt32          AUIOElement::GetChannelLayoutTags (AudioChannelLayoutTag                *outLayoutTagsPtr)
 332 {
 333         return 0;
 334 }
 335
 336 // As the AudioChannelLayout can be a variable length structure
 337 // (though in most cases it won't be!!!)
 338 // the AU should return the address of the current ACM in use (in outMapPtr) AND if it is writable
 339 // The size of the ACM is returned by the method
 340 // If the AU doesn't require an AudioChannelLayout, then just return 0.
 341 UInt32          AUIOElement::GetAudioChannelLayout (AudioChannelLayout          *outMapPtr,
 342                                                                                         Boolean                         &outWritable)
 343 {
 344         return 0;
 345 }
 346
 347 // the incoming channel map will be at least as big as a basic AudioChannelLayout
 348 // but its contents will determine its actual size
 349 // Subclass should overide if channel map is writable
 350 OSStatus        AUIOElement::SetAudioChannelLayout (const AudioChannelLayout &inData)
 351 {
 352         return kAudioUnitErr_InvalidProperty;
 353 }
 354
 355 // Some units support optional usage of channel maps - typically converter units
 356 // that can do channel remapping between different maps. In that optional case
 357 // the user should be able to remove a channel map if that is possible.
 358 // Typically this is NOT the case (e.g., the 3DMixer even in the stereo case
 359 // needs to know if it is rendering to speakers or headphones)
 360 OSStatus        AUIOElement::RemoveAudioChannelLayout ()
 361 {
 362         return kAudioUnitErr_InvalidPropertyValue;
 363 }
 364
 365
 366 //_____________________________________________________________________________
 367 //
 368 AUScope::~AUScope()
 369 {
 370         for (ElementVector::iterator it = mElements.begin(); it != mElements.end(); ++it)
 371                 delete *it;
 372 }
 373
 374 //_____________________________________________________________________________
 375 //
 376 void    AUScope::SetNumberOfElements(UInt32 numElements)
 377 {
 378         if (mDelegate)
 379                 return mDelegate->SetNumberOfElements(numElements);
 380
 381         if (numElements > mElements.size()) {
 382                 mElements.reserve(numElements);
 383                 while (numElements > mElements.size()) {
 384                         AUElement *elem = GetCreator()->CreateElement(GetScope(), mElements.size());
 385                         mElements.push_back(elem);
 386                 }
 387         } else
 388                 while (numElements < mElements.size()) {
 389                         AUElement *elem = mElements.back();
 390                         mElements.pop_back();
 391                         delete elem;
 392                 }
 393 }
 394
 395 //_____________________________________________________________________________
 396 //
 397 bool    AUScope::HasElementWithName () const
 398 {
 399         for (UInt32 i = 0; i < GetNumberOfElements(); ++i) {
 400                 AUElement *     el = const_cast<AUScope*>(this)->GetElement (i);
 401                 if (el && el->HasName()) {
 402                         return true;
 403                 }
 404         }
 405         return false;
 406 }
 407
 408 //_____________________________________________________________________________
 409 //
 410
 411 void    AUScope::AddElementNamesToDict (CFMutableDictionaryRef & inNameDict)
 412 {
 413         if (HasElementWithName())
 414         {
 415                 static char string[32];
 416                 CFMutableDictionaryRef elementDict = CFDictionaryCreateMutable  (NULL, 0,
 417                                                                 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 418                 CFStringRef str;
 419                 for (UInt32 i = 0; i < GetNumberOfElements(); ++i) {
 420                         AUElement *     el = GetElement (i);
 421                         if (el && el->HasName()) {
 422                                 sprintf (string, "%d", int(i));
 423                                 str = CFStringCreateWithCString (NULL, string, kCFStringEncodingASCII);
 424                                 CFDictionarySetValue (elementDict, str, el->GetName());
 425                                 CFRelease (str);
 426                         }
 427                 }
 428
 429                 sprintf (string, "%d", int(mScope));
 430                 str = CFStringCreateWithCString (NULL, string, kCFStringEncodingASCII);
 431                 CFDictionarySetValue (inNameDict, str, elementDict);
 432                 CFRelease (str);
 433                 CFRelease (elementDict);
 434         }
 435 }
 436
 437 //_____________________________________________________________________________
 438 //
 439 bool    AUScope::RestoreElementNames (CFDictionaryRef& inNameDict)
 440 {
 441         static char string[32];
 442
 443         //first we have to see if we have enough elements and if not create them
 444         bool didAddElements = false;
 445         unsigned int maxElNum = 0;
 446
 447         int dictSize = CFDictionaryGetCount(inNameDict);
 448         CFStringRef * keys = (CFStringRef*)malloc (dictSize * sizeof (CFStringRef));
 449         CFDictionaryGetKeysAndValues (inNameDict, reinterpret_cast<const void**>(keys), NULL);
 450         for (int i = 0; i < dictSize; i++)
 451         {
 452                 unsigned int intKey;
 453                 CFStringGetCString (keys[i], string, 32, kCFStringEncodingASCII);
 454                 sscanf (string, "%d", &intKey);
 455                 if (UInt32(intKey) > maxElNum)
 456                         maxElNum = intKey;
 457         }
 458
 459         if (maxElNum >= GetNumberOfElements()) {
 460                 SetNumberOfElements (maxElNum+1);
 461                 didAddElements = true;
 462         }
 463
 464                 // OK, now we have the number of elements that we need - lets restate their names
 465         for (int i = 0; i < dictSize; i++)
 466         {
 467                 CFStringRef elName = reinterpret_cast<CFStringRef>(CFDictionaryGetValue (inNameDict,  keys[i]));
 468                 int intKey;
 469                 CFStringGetCString (keys[i], string, 32, kCFStringEncodingASCII);
 470                 sscanf (string, "%d", &intKey);
 471                 GetElement (intKey)->SetName (elName);
 472         }
 473         free (keys);
 474
 475         return didAddElements;
 476 }
 477
 478