?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove erroneous assert which I added earlier.
[ardour2.git] / libs / appleutility / CAAudioUnit.cpp
blobaaf57f233de261515c033c9bcc0728017c540e64
1 /* Copyright: © Copyright 2005 Apple Computer, Inc. All rights reserved.
2
3 Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc.
4 ("Apple") in consideration of your agreement to the following terms, and your
5 use, installation, modification or redistribution of this Apple software
6 constitutes acceptance of these terms. If you do not agree with these terms,
7 please do not use, install, modify or redistribute this Apple software.
8
9 In consideration of your agreement to abide by the following terms, and subject
10 to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs
11 copyrights in this original Apple software (the "Apple Software"), to use,
12 reproduce, modify and redistribute the Apple Software, with or without
13 modifications, in source and/or binary forms; provided that if you redistribute
14 the Apple Software in its entirety and without modifications, you must retain
15 this notice and the following text and disclaimers in all such redistributions of
16 the Apple Software. Neither the name, trademarks, service marks or logos of
17 Apple Computer, Inc. may be used to endorse or promote products derived from the
18 Apple Software without specific prior written permission from Apple. Except as
19 expressly stated in this notice, no other rights or licenses, express or implied,
20 are granted by Apple herein, including but not limited to any patent rights that
21 may be infringed by your derivative works or by other works in which the Apple
22 Software may be incorporated.
23
24 The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO
25 WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
26 WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
27 PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
28 COMBINATION WITH YOUR PRODUCTS.
29
30 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
32 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
34 OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
35 (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
36 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 */
38 /*=============================================================================
39 CAAudioUnit.cpp
40
41 =============================================================================*/
42
43 #include "CAAudioUnit.h"
44
45 #if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
46 #include <AudioUnit/MusicDevice.h>
47 #else
48 #include <MusicDevice.h>
49 #endif
50
51 #include "CAReferenceCounted.h"
52 #include "AUOutputBL.h" //this is for the Preroll only
53
54
55 struct StackAUChannelInfo {
56 StackAUChannelInfo (UInt32 inSize) : mChanInfo ((AUChannelInfo*)malloc (inSize)) {}
57 ~StackAUChannelInfo() { free (mChanInfo); }
58
59 AUChannelInfo* mChanInfo;
60 };
61
62
63
64 class CAAudioUnit::AUState : public CAReferenceCounted {
65 public:
66 AUState (Component inComp)
67 : mUnit(0), mNode (0)
68 {
69 OSStatus result = ::OpenAComponent (inComp, &mUnit);
70 if (result)
71 throw result;
72 Init();
73 }
74
75 AUState (const AUNode &inNode, const AudioUnit& inUnit)
76 : mUnit (inUnit), mNode (inNode)
77 {
78 Init();
79 }
80
81 ~AUState();
82
83 AudioUnit mUnit;
84 AUNode mNode;
85
86 OSStatus GetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
87 Float32 &outValue) const
88 {
89 if (mGetParamProc != NULL) {
90 return reinterpret_cast<AudioUnitGetParameterProc>(mGetParamProc) (mConnInstanceStorage,
91 inID, scope, element, &outValue);
92 }
93 return AudioUnitGetParameter(mUnit, inID, scope, element, &outValue);
94 }
95
96 OSStatus SetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
97 Float32 value, UInt32 bufferOffsetFrames)
98 {
99 if (mSetParamProc != NULL) {
100 return reinterpret_cast<AudioUnitSetParameterProc>(mSetParamProc) (mConnInstanceStorage,
101 inID, scope, element, value, bufferOffsetFrames);
102 }
103 return AudioUnitSetParameter(mUnit, inID, scope, element, value, bufferOffsetFrames);
104 }
105
106 OSStatus Render (AudioUnitRenderActionFlags * ioActionFlags,
107 const AudioTimeStamp * inTimeStamp,
108 UInt32 inOutputBusNumber,
109 UInt32 inNumberFrames,
110 AudioBufferList * ioData)
111 {
112 if (mRenderProc != NULL) {
113 return reinterpret_cast<AudioUnitRenderProc>(mRenderProc) (mConnInstanceStorage,
114 ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData);
115 }
116 return AudioUnitRender(mUnit, ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData);
117 }
118
119 OSStatus MIDIEvent (UInt32 inStatus,
120 UInt32 inData1,
121 UInt32 inData2,
122 UInt32 inOffsetSampleFrame)
123 {
124 #if !TARGET_OS_WIN32
125 if (mMIDIEventProc != NULL) {
126 return reinterpret_cast<MusicDeviceMIDIEventProc>(mMIDIEventProc) (mConnInstanceStorage,
127 inStatus, inData1, inData2, inOffsetSampleFrame);
128 }
129 return MusicDeviceMIDIEvent (mUnit, inStatus, inData1, inData2, inOffsetSampleFrame);
130 #else
131 return paramErr;
132 #endif
133 }
134
135 OSStatus StartNote (MusicDeviceInstrumentID inInstrument,
136 MusicDeviceGroupID inGroupID,
137 NoteInstanceID * outNoteInstanceID,
138 UInt32 inOffsetSampleFrame,
139 const MusicDeviceNoteParams * inParams)
140 {
141 #if !TARGET_OS_WIN32
142 return MusicDeviceStartNote (mUnit, inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams);
143 #else
144 return paramErr;
145 #endif
146 }
147 OSStatus StopNote (MusicDeviceGroupID inGroupID,
148 NoteInstanceID inNoteInstanceID,
149 UInt32 inOffsetSampleFrame)
150 {
151 #if !TARGET_OS_WIN32
152 return MusicDeviceStopNote (mUnit, inGroupID, inNoteInstanceID, inOffsetSampleFrame);
153 #else
154 return paramErr;
155 #endif
156 }
157
158 private:
159 // get the fast dispatch pointers
160 void Init()
161 {
162 UInt32 size = sizeof(AudioUnitRenderProc);
163 if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
164 kAudioUnitScope_Global, kAudioUnitRenderSelect,
165 &mRenderProc, &size) != noErr)
166 mRenderProc = NULL;
167 if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
168 kAudioUnitScope_Global, kAudioUnitGetParameterSelect,
169 &mGetParamProc, &size) != noErr)
170 mGetParamProc = NULL;
171 if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
172 kAudioUnitScope_Global, kAudioUnitSetParameterSelect,
173 &mSetParamProc, &size) != noErr)
174 mSetParamProc = NULL;
175
176 if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
177 kAudioUnitScope_Global, kMusicDeviceMIDIEventSelect,
178 &mMIDIEventProc, &size) != noErr)
179 mMIDIEventProc = NULL;
180
181 if (mRenderProc || mGetParamProc || mSetParamProc || mMIDIEventProc)
182 mConnInstanceStorage = GetComponentInstanceStorage(mUnit);
183 else
184 mConnInstanceStorage = NULL;
185 }
186
187 ProcPtr mRenderProc, mGetParamProc, mSetParamProc, mMIDIEventProc;
188
189 void * mConnInstanceStorage;
190
191 private:
192 // get the compiler to tell us when we do a bad thing!!!
193 AUState () {}
194 AUState (const AUState&) {}
195 AUState& operator= (const AUState&) { return *this; }
196 };
197
198
199 CAAudioUnit::AUState::~AUState ()
200 {
201 if (mUnit && (mNode == 0)) {
202 ::CloseComponent (mUnit);
203 }
204 mNode = 0;
205 mUnit = 0;
206 }
207
208 OSStatus CAAudioUnit::Open (const CAComponent& inComp, CAAudioUnit &outUnit)
209 {
210 try {
211 outUnit = inComp;
212 return noErr;
213 } catch (OSStatus res) {
214 return res;
215 } catch (...) {
216 return -1;
217 }
218 }
219
220 CAAudioUnit::CAAudioUnit (const AudioUnit& inUnit)
221 : mComp (inUnit), mDataPtr (new AUState (-1, inUnit))
222 {
223 }
224
225 CAAudioUnit::CAAudioUnit (const CAComponent& inComp)
226 : mComp (inComp), mDataPtr (0)
227 {
228 mDataPtr = new AUState (mComp.Comp());
229 }
230
231 CAAudioUnit::CAAudioUnit (const AUNode &inNode, const AudioUnit& inUnit)
232 : mComp (inUnit), mDataPtr(new AUState (inNode, inUnit))
233 {
234 }
235
236 CAAudioUnit::~CAAudioUnit ()
237 {
238 if (mDataPtr) {
239 mDataPtr->release();
240 mDataPtr = NULL;
241 }
242 }
243
244 CAAudioUnit& CAAudioUnit::operator= (const CAAudioUnit &a)
245 {
246 if (mDataPtr != a.mDataPtr) {
247 if (mDataPtr)
248 mDataPtr->release();
249
250 if ((mDataPtr = a.mDataPtr) != NULL)
251 mDataPtr->retain();
252
253 mComp = a.mComp;
254 }
255
256 return *this;
257 }
258
259 bool CAAudioUnit::operator== (const CAAudioUnit& y) const
260 {
261 if (mDataPtr == y.mDataPtr) return true;
262 AudioUnit au1 = mDataPtr ? mDataPtr->mUnit : 0;
263 AudioUnit au2 = y.mDataPtr ? y.mDataPtr->mUnit : 0;
264 return au1 == au2;
265 }
266
267 bool CAAudioUnit::operator== (const AudioUnit& y) const
268 {
269 if (!mDataPtr) return false;
270 return mDataPtr->mUnit == y;
271 }
272
273 #pragma mark __State Management
274
275 bool CAAudioUnit::IsValid () const
276 {
277 return mDataPtr ? mDataPtr->mUnit != 0 : false;
278 }
279
280 AudioUnit CAAudioUnit::AU() const
281 {
282 return mDataPtr ? mDataPtr->mUnit : 0;
283 }
284
285 AUNode CAAudioUnit::GetAUNode () const
286 {
287 return mDataPtr ? mDataPtr->mNode : 0;
288 }
289
290 #pragma mark __Format Handling
291
292 bool CAAudioUnit::CanDo ( int inChannelsIn,
293 int inChannelsOut) const
294 {
295 // this is the default assumption of an audio effect unit
296 Boolean* isWritable = 0;
297 UInt32 dataSize = 0;
298 // lets see if the unit has any channel restrictions
299 OSStatus result = AudioUnitGetPropertyInfo (AU(),
300 kAudioUnitProperty_SupportedNumChannels,
301 kAudioUnitScope_Global, 0,
302 &dataSize, isWritable); //don't care if this is writable
303
304 // if this property is NOT implemented an FX unit
305 // is expected to deal with same channel valance in and out
306 if (result)
307 {
308 if (Comp().Desc().IsEffect() && (inChannelsIn == inChannelsOut)
309 || Comp().Desc().IsOffline() && (inChannelsIn == inChannelsOut))
310 {
311 return true;
312 }
313 else
314 {
315 // the au should either really tell us about this
316 // or we will assume the worst
317 return false;
318 }
319 }
320
321 StackAUChannelInfo info (dataSize);
322
323 result = GetProperty (kAudioUnitProperty_SupportedNumChannels,
324 kAudioUnitScope_Global, 0,
325 info.mChanInfo, &dataSize);
326 if (result) { return false; }
327
328 return ValidateChannelPair (inChannelsIn, inChannelsOut, info.mChanInfo, (dataSize / sizeof (AUChannelInfo)));
329 }
330
331 int CAAudioUnit::GetChannelInfo (AUChannelInfo** chaninfo, UInt32& cnt)
332 {
333 // this is the default assumption of an audio effect unit
334 Boolean* isWritable = 0;
335 UInt32 dataSize = 0;
336 // lets see if the unit has any channel restrictions
337 OSStatus result = AudioUnitGetPropertyInfo (AU(),
338 kAudioUnitProperty_SupportedNumChannels,
339 kAudioUnitScope_Global, 0,
340 &dataSize, isWritable); //don't care if this is writable
341
342 // if this property is NOT implemented an FX unit
343 // is expected to deal with same channel valance in and out
344
345 if (result)
346 {
347 if (Comp().Desc().IsEffect())
348 {
349 return 1;
350 }
351 else
352 {
353 // the au should either really tell us about this
354 // or we will assume the worst
355 return -1;
356 }
357 }
358
359 *chaninfo = (AUChannelInfo*) malloc (dataSize);
360 cnt = dataSize / sizeof (AUChannelInfo);
361
362 result = GetProperty (kAudioUnitProperty_SupportedNumChannels,
363 kAudioUnitScope_Global, 0,
364 *chaninfo, &dataSize);
365
366 if (result) { return -1; }
367 return 0;
368 }
369
370
371 bool CAAudioUnit::ValidateChannelPair (int inChannelsIn,
372 int inChannelsOut,
373 const AUChannelInfo * info,
374 UInt32 numChanInfo) const
375 {
376 // we've the following cases (some combinations) to test here:
377 /*
378 >0 An explicit number of channels on either side
379 0 that side (generally input!) has no elements
380 -1 wild card:
381 -1,-1 any num channels as long as same channels on in and out
382 -1,-2 any num channels channels on in and out - special meaning
383 -2+ indicates total num channs AU can handle
384 - elements configurable to any num channels,
385 - element count in scope must be writable
386 */
387
388 //now chan layout can contain -1 for either scope (ie. doesn't care)
389 for (unsigned int i = 0; i < numChanInfo; ++i)
390 {
391 //less than zero on both sides - check for special attributes
392 if ((info[i].inChannels < 0) && (info[i].outChannels < 0))
393 {
394 // these are our wild card matches
395 if (info[i].inChannels == -1 && info[i].outChannels == -1) {
396 if (inChannelsOut == inChannelsIn) {
397 return true;
398 }
399 }
400 else if ((info[i].inChannels == -1 && info[i].outChannels == -2)
401 || (info[i].inChannels == -2 && info[i].outChannels == -1))
402 {
403 return true;
404 }
405 // these are our total num channels matches
406 // element count MUST be writable
407 else {
408 bool outWrite = false; bool inWrite = false;
409 IsElementCountWritable (kAudioUnitScope_Output, outWrite);
410 IsElementCountWritable (kAudioUnitScope_Input, inWrite);
411 if (inWrite && outWrite) {
412 if ((inChannelsOut <= abs(info[i].outChannels))
413 && (inChannelsIn <= abs(info[i].inChannels)))
414 {
415 return true;
416 }
417 }
418 }
419 }
420
421 // special meaning on input, specific num on output
422 else if (info[i].inChannels < 0) {
423 if (info[i].outChannels == inChannelsOut)
424 {
425 // can do any in channels
426 if (info[i].inChannels == -1) {
427 return true;
428 }
429 // total chans on input
430 else {
431 bool inWrite = false;
432 IsElementCountWritable (kAudioUnitScope_Input, inWrite);
433 if (inWrite && (inChannelsIn <= abs(info[i].inChannels))) {
434 return true;
435 }
436 }
437 }
438 }
439
440 // special meaning on output, specific num on input
441 else if (info[i].outChannels < 0) {
442 if (info[i].inChannels == inChannelsIn)
443 {
444 // can do any out channels
445 if (info[i].outChannels == -1) {
446 return true;
447 }
448 // total chans on output
449 else {
450 bool outWrite = false;
451 IsElementCountWritable (kAudioUnitScope_Output, outWrite);
452 if (outWrite && (inChannelsOut <= abs(info[i].outChannels))) {
453 return true;
454 }
455 }
456 }
457 }
458
459 // both chans in struct >= 0 - thus has to explicitly match
460 else if ((info[i].inChannels == inChannelsIn) && (info[i].outChannels == inChannelsOut)) {
461 return true;
462 }
463
464 // now check to see if a wild card on the args (inChannelsIn or inChannelsOut chans is zero) is found
465 // tells us to match just one side of the scopes
466 else if (inChannelsIn == 0) {
467 if (info[i].outChannels == inChannelsOut) {
468 return true;
469 }
470 }
471 else if (inChannelsOut == 0) {
472 if (info[i].inChannels == inChannelsIn) {
473 return true;
474 }
475 }
476 }
477
478 return false;
479 }
480
481 bool CheckDynCount (SInt32 inTotalChans, const CAAUChanHelper &inHelper)
482 {
483 int totalChans = 0;
484 for (unsigned int i = 0; i < inHelper.mNumEls; ++i)
485 totalChans += inHelper.mChans[i];
486 return (totalChans <= inTotalChans);
487 }
488
489 bool CAAudioUnit::CheckOneSide (const CAAUChanHelper &inHelper,
490 bool checkOutput,
491 const AUChannelInfo *info,
492 UInt32 numInfo) const
493 {
494 // now we can use the wildcard option (see above impl) to see if this matches
495 for (unsigned int el = 0; el < inHelper.mNumEls; ++el) {
496 bool testAlready = false;
497 for (unsigned int i = 0; i < el; ++i) {
498 if (inHelper.mChans[i] == inHelper.mChans[el]) {
499 testAlready = true;
500 break;
501 }
502 }
503 if (!testAlready) {
504 if (checkOutput) {
505 if (!ValidateChannelPair (0, inHelper.mChans[el], info, numInfo)) return false;
506 } else {
507 if (!ValidateChannelPair (inHelper.mChans[el], 0, info, numInfo)) return false;
508 }
509 }
510 }
511 return true;
512 }
513
514 bool CAAudioUnit::CanDo (const CAAUChanHelper &inputs,
515 const CAAUChanHelper &outputs) const
516
517 {
518 // first check our state
519 // huh!
520 if (inputs.mNumEls == 0 && outputs.mNumEls == 0) return false;
521
522 UInt32 elCount;
523 if (GetElementCount (kAudioUnitScope_Input, elCount)) { return false; }
524 if (elCount != inputs.mNumEls) return false;
525
526 if (GetElementCount (kAudioUnitScope_Output, elCount)) { return false; }
527 if (elCount != outputs.mNumEls) return false;
528
529 // (1) special cases (effects and sources (generators and instruments) only)
530 UInt32 dataSize = 0;
531 if (GetPropertyInfo (kAudioUnitProperty_SupportedNumChannels,
532 kAudioUnitScope_Global, 0, &dataSize, NULL) != noErr)
533 {
534 if (Comp().Desc().IsEffect() || Comp().Desc().IsOffline()) {
535 UInt32 numChan = outputs.mNumEls > 0 ? outputs.mChans[0] : inputs.mChans[0];
536 for (unsigned int in = 0; in < inputs.mNumEls; ++in)
537 if (numChan != inputs.mChans[in]) return false;
538 for (unsigned int out = 0; out < outputs.mNumEls; ++out)
539 if (numChan != outputs.mChans[out]) return false;
540 return true;
541 }
542
543 // in this case, all the channels have to match the current config
544 if (Comp().Desc().IsGenerator() || Comp().Desc().IsMusicDevice()) {
545 for (unsigned int in = 0; in < inputs.mNumEls; ++in) {
546 UInt32 chan;
547 if (NumberChannels (kAudioUnitScope_Input, in, chan)) return false;
548 if (chan != UInt32(inputs.mChans[in])) return false;
549 }
550 for (unsigned int out = 0; out < outputs.mNumEls; ++out) {
551 UInt32 chan;
552 if (NumberChannels (kAudioUnitScope_Output, out, chan)) return false;
553 if (chan != UInt32(outputs.mChans[out])) return false;
554 }
555 return true;
556 }
557
558 // if we get here we can't determine anything about channel capabilities
559 return false;
560 }
561
562 StackAUChannelInfo info (dataSize);
563
564 if (GetProperty (kAudioUnitProperty_SupportedNumChannels,
565 kAudioUnitScope_Global, 0,
566 info.mChanInfo, &dataSize) != noErr)
567 {
568 return false;
569 }
570
571 int numInfo = dataSize / sizeof(AUChannelInfo);
572
573 // (2) Test for dynamic capability (or no elements on that scope)
574 SInt32 dynInChans = 0;
575 if (ValidateDynamicScope (kAudioUnitScope_Input, dynInChans, info.mChanInfo, numInfo)) {
576 if (CheckDynCount (dynInChans, inputs) == false) return false;
577 }
578
579 SInt32 dynOutChans = 0;
580 if (ValidateDynamicScope (kAudioUnitScope_Output, dynOutChans, info.mChanInfo, numInfo)) {
581 if (CheckDynCount (dynOutChans, outputs) == false) return false;
582 }
583
584 if (dynOutChans && dynInChans) { return true; }
585
586 // (3) Just need to test one side
587 if (dynInChans || (inputs.mNumEls == 0)) {
588 return CheckOneSide (outputs, true, info.mChanInfo, numInfo);
589 }
590
591 if (dynOutChans || (outputs.mNumEls == 0)) {
592 return CheckOneSide (inputs, false, info.mChanInfo, numInfo);
593 }
594
595 // (4) - not a dynamic AU, has ins and outs, and has channel constraints so we test every possible pairing
596 for (unsigned int in = 0; in < inputs.mNumEls; ++in)
597 {
598 bool testInAlready = false;
599 for (unsigned int i = 0; i < in; ++i) {
600 if (inputs.mChans[i] == inputs.mChans[in]) {
601 testInAlready = true;
602 break;
603 }
604 }
605 if (!testInAlready) {
606 for (unsigned int out = 0; out < outputs.mNumEls; ++out) {
607 // try to save a little bit and not test the same pairing multiple times...
608 bool testOutAlready = false;
609 for (unsigned int i = 0; i < out; ++i) {
610 if (outputs.mChans[i] == outputs.mChans[out]) {
611 testOutAlready = true;
612 break;
613 }
614 }
615 if (!testOutAlready) {
616 if (!ValidateChannelPair (inputs.mChans[in], outputs.mChans[out],info.mChanInfo, numInfo)) {
617 return false;
618 }
619 }
620 }
621 }
622 }
623
624 return true;
625 }
626
627 bool CAAudioUnit::SupportsNumChannels () const
628 {
629 // this is the default assumption of an audio effect unit
630 Boolean* isWritable = 0;
631 UInt32 dataSize = 0;
632 // lets see if the unit has any channel restrictions
633 OSStatus result = AudioUnitGetPropertyInfo (AU(),
634 kAudioUnitProperty_SupportedNumChannels,
635 kAudioUnitScope_Global, 0,
636 &dataSize, isWritable); //don't care if this is writable
637
638 // if this property is NOT implemented an FX unit
639 // is expected to deal with same channel valance in and out
640 if (result) {
641 if (Comp().Desc().IsEffect() || Comp().Desc().IsOffline())
642 return true;
643 }
644 return result == noErr;
645 }
646
647 bool CAAudioUnit::GetChannelLayouts (AudioUnitScope inScope,
648 AudioUnitElement inEl,
649 ChannelTagVector &outChannelVector) const
650 {
651 if (HasChannelLayouts (inScope, inEl) == false) return false;
652
653 UInt32 dataSize;
654 OSStatus result = AudioUnitGetPropertyInfo (AU(),
655 kAudioUnitProperty_SupportedChannelLayoutTags,
656 inScope, inEl,
657 &dataSize, NULL);
658
659 if (result == kAudioUnitErr_InvalidProperty) {
660 // if we get here we can do layouts but we've got the speaker config property
661 outChannelVector.erase (outChannelVector.begin(), outChannelVector.end());
662 outChannelVector.push_back (kAudioChannelLayoutTag_Stereo);
663 outChannelVector.push_back (kAudioChannelLayoutTag_StereoHeadphones);
664 outChannelVector.push_back (kAudioChannelLayoutTag_Quadraphonic);
665 outChannelVector.push_back (kAudioChannelLayoutTag_AudioUnit_5_0);
666 return true;
667 }
668
669 if (result) return false;
670
671 bool canDo = false;
672 // OK lets get our channel layouts and see if the one we want is present
673 AudioChannelLayoutTag* info = (AudioChannelLayoutTag*)malloc (dataSize);
674 result = AudioUnitGetProperty (AU(),
675 kAudioUnitProperty_SupportedChannelLayoutTags,
676 inScope, inEl,
677 info, &dataSize);
678 if (result) goto home;
679
680 outChannelVector.erase (outChannelVector.begin(), outChannelVector.end());
681 for (unsigned int i = 0; i < (dataSize / sizeof (AudioChannelLayoutTag)); ++i)
682 outChannelVector.push_back (info[i]);
683
684 home:
685 free (info);
686 return canDo;
687 }
688
689 bool CAAudioUnit::HasChannelLayouts (AudioUnitScope inScope,
690 AudioUnitElement inEl) const
691 {
692 OSStatus result = AudioUnitGetPropertyInfo (AU(),
693 kAudioUnitProperty_SupportedChannelLayoutTags,
694 inScope, inEl,
695 NULL, NULL);
696 return !result;
697 }
698
699 OSStatus CAAudioUnit::GetChannelLayout (AudioUnitScope inScope,
700 AudioUnitElement inEl,
701 CAAudioChannelLayout &outLayout) const
702 {
703 UInt32 size;
704 OSStatus result = AudioUnitGetPropertyInfo (AU(), kAudioUnitProperty_AudioChannelLayout,
705 inScope, inEl, &size, NULL);
706 if (result) return result;
707
708 AudioChannelLayout *layout = (AudioChannelLayout*)malloc (size);
709
710 require_noerr (result = AudioUnitGetProperty (AU(), kAudioUnitProperty_AudioChannelLayout,
711 inScope, inEl, layout, &size), home);
712
713 outLayout = CAAudioChannelLayout (layout);
714
715 home:
716 free (layout);
717 return result;
718 }
719
720 OSStatus CAAudioUnit::SetChannelLayout (AudioUnitScope inScope,
721 AudioUnitElement inEl,
722 CAAudioChannelLayout &inLayout)
723 {
724 OSStatus result = AudioUnitSetProperty (AU(),
725 kAudioUnitProperty_AudioChannelLayout,
726 inScope, inEl,
727 inLayout, inLayout.Size());
728 return result;
729 }
730
731 OSStatus CAAudioUnit::SetChannelLayout (AudioUnitScope inScope,
732 AudioUnitElement inEl,
733 AudioChannelLayout &inLayout,
734 UInt32 inSize)
735 {
736 OSStatus result = AudioUnitSetProperty (AU(),
737 kAudioUnitProperty_AudioChannelLayout,
738 inScope, inEl,
739 &inLayout, inSize);
740 return result;
741 }
742
743 OSStatus CAAudioUnit::ClearChannelLayout (AudioUnitScope inScope,
744 AudioUnitElement inEl)
745 {
746 return AudioUnitSetProperty (AU(),
747 kAudioUnitProperty_AudioChannelLayout,
748 inScope, inEl, NULL, 0);
749 }
750
751 OSStatus CAAudioUnit::GetFormat (AudioUnitScope inScope,
752 AudioUnitElement inEl,
753 AudioStreamBasicDescription &outFormat) const
754 {
755 UInt32 dataSize = sizeof (AudioStreamBasicDescription);
756 return AudioUnitGetProperty (AU(), kAudioUnitProperty_StreamFormat,
757 inScope, inEl,
758 &outFormat, &dataSize);
759 }
760
761 OSStatus CAAudioUnit::SetFormat (AudioUnitScope inScope,
762 AudioUnitElement inEl,
763 const AudioStreamBasicDescription &inFormat)
764 {
765 return AudioUnitSetProperty (AU(), kAudioUnitProperty_StreamFormat,
766 inScope, inEl,
767 const_cast<AudioStreamBasicDescription*>(&inFormat),
768 sizeof (AudioStreamBasicDescription));
769 }
770
771 OSStatus CAAudioUnit::GetSampleRate (AudioUnitScope inScope,
772 AudioUnitElement inEl,
773 Float64 &outRate) const
774 {
775 UInt32 dataSize = sizeof (Float64);
776 return AudioUnitGetProperty (AU(), kAudioUnitProperty_SampleRate,
777 inScope, inEl,
778 &outRate, &dataSize);
779 }
780
781 OSStatus CAAudioUnit::SetSampleRate (AudioUnitScope inScope,
782 AudioUnitElement inEl,
783 Float64 inRate)
784 {
785 AudioStreamBasicDescription desc;
786 OSStatus result = GetFormat (inScope, inEl, desc);
787 if (result) return result;
788 desc.mSampleRate = inRate;
789 return SetFormat (inScope, inEl, desc);
790 }
791
792 OSStatus CAAudioUnit::SetSampleRate (Float64 inSampleRate)
793 {
794 OSStatus result;
795
796 UInt32 elCount;
797 require_noerr (result = GetElementCount(kAudioUnitScope_Input, elCount), home);
798 if (elCount) {
799 for (unsigned int i = 0; i < elCount; ++i) {
800 require_noerr (result = SetSampleRate (kAudioUnitScope_Input, i, inSampleRate), home);
801 }
802 }
803
804 require_noerr (result = GetElementCount(kAudioUnitScope_Output, elCount), home);
805 if (elCount) {
806 for (unsigned int i = 0; i < elCount; ++i) {
807 require_noerr (result = SetSampleRate (kAudioUnitScope_Output, i, inSampleRate), home);
808 }
809 }
810
811 home:
812 return result;
813 }
814
815 OSStatus CAAudioUnit::NumberChannels (AudioUnitScope inScope,
816 AudioUnitElement inEl,
817 UInt32 &outChans) const
818 {
819 AudioStreamBasicDescription desc;
820 OSStatus result = GetFormat (inScope, inEl, desc);
821 if (!result)
822 outChans = desc.mChannelsPerFrame;
823 return result;
824 }
825
826 OSStatus CAAudioUnit::SetNumberChannels (AudioUnitScope inScope,
827 AudioUnitElement inEl,
828 UInt32 inChans)
829 {
830 // set this as the output of the AU
831 CAStreamBasicDescription desc;
832 OSStatus result = GetFormat (inScope, inEl, desc);
833 if (result) return result;
834 desc.SetCanonical (inChans, desc.IsInterleaved());
835 result = SetFormat (inScope, inEl, desc);
836 return result;
837 }
838
839 OSStatus CAAudioUnit::IsElementCountWritable (AudioUnitScope inScope, bool &outWritable) const
840 {
841 Boolean isWritable;
842 UInt32 outDataSize;
843 OSStatus result = GetPropertyInfo (kAudioUnitProperty_ElementCount, inScope, 0, &outDataSize, &isWritable);
844 if (result)
845 return result;
846 outWritable = isWritable ? true : false;
847 return noErr;
848 }
849
850 OSStatus CAAudioUnit::GetElementCount (AudioUnitScope inScope, UInt32 &outCount) const
851 {
852 UInt32 propSize = sizeof(outCount);
853 return GetProperty (kAudioUnitProperty_ElementCount, inScope, 0, &outCount, &propSize);
854 }
855
856 OSStatus CAAudioUnit::SetElementCount (AudioUnitScope inScope, UInt32 inCount)
857 {
858 return SetProperty (kAudioUnitProperty_ElementCount, inScope, 0, &inCount, sizeof(inCount));
859 }
860
861 bool CAAudioUnit::HasDynamicScope (AudioUnitScope inScope, SInt32 &outTotalNumChannels) const
862 {
863 // ok - now we need to check the AU's capability here.
864 // this is the default assumption of an audio effect unit
865 Boolean* isWritable = 0;
866 UInt32 dataSize = 0;
867 OSStatus result = GetPropertyInfo (kAudioUnitProperty_SupportedNumChannels,
868 kAudioUnitScope_Global, 0,
869 &dataSize, isWritable); //don't care if this is writable
870
871 // AU has to explicitly tell us about this.
872 if (result) return false;
873
874 StackAUChannelInfo info (dataSize);
875
876 result = GetProperty (kAudioUnitProperty_SupportedNumChannels,
877 kAudioUnitScope_Global, 0,
878 info.mChanInfo, &dataSize);
879 if (result) return false;
880
881 return ValidateDynamicScope (inScope, outTotalNumChannels, info.mChanInfo, (dataSize / sizeof(AUChannelInfo)));
882 }
883
884 // as we've already checked that the element count is writable
885 // the following conditions will match this..
886 /*
887 -1, -2 -> signifies no restrictions
888 -2, -1 -> signifies no restrictions -> in this case outTotalNumChannels == -1 (any num channels)
889
890 -N (where N is less than -2), signifies the total channel count on the scope side (in or out)
891 */
892 bool CAAudioUnit::ValidateDynamicScope (AudioUnitScope inScope,
893 SInt32 &outTotalNumChannels,
894 const AUChannelInfo *info,
895 UInt32 numInfo) const
896 {
897 bool writable = false;
898 OSStatus result = IsElementCountWritable (inScope, writable);
899 if (result || (writable == false))
900 return false;
901
902 //now chan layout can contain -1 for either scope (ie. doesn't care)
903 for (unsigned int i = 0; i < numInfo; ++i)
904 {
905 // lets test the special wild card case first...
906 // this says the AU can do any num channels on input or output - for eg. Matrix Mixer
907 if (((info[i].inChannels == -1) && (info[i].outChannels == -2))
908 || ((info[i].inChannels == -2) && (info[i].outChannels == -1)))
909 {
910 outTotalNumChannels = -1;
911 return true;
912 }
913
914 // ok lets now test our special case....
915 if (inScope == kAudioUnitScope_Input) {
916 // isn't dynamic on this side at least
917 if (info[i].inChannels >= 0)
918 continue;
919
920 if (info[i].inChannels < -2) {
921 outTotalNumChannels = abs (info[i].inChannels);
922 return true;
923 }
924 }
925
926 else if (inScope == kAudioUnitScope_Output) {
927 // isn't dynamic on this side at least
928 if (info[i].outChannels >= 0)
929 continue;
930
931 if (info[i].outChannels < -2) {
932 outTotalNumChannels = abs (info[i].outChannels);
933 return true;
934 }
935 }
936
937 else {
938 break; // wrong scope was specified
939 }
940 }
941
942 return false;
943 }
944
945 OSStatus CAAudioUnit::ConfigureDynamicScope (AudioUnitScope inScope,
946 UInt32 inNumElements,
947 UInt32 *inChannelsPerElement,
948 Float64 inSampleRate)
949 {
950 SInt32 numChannels = 0;
951 bool isDyamic = HasDynamicScope (inScope, numChannels);
952 if (isDyamic == false)
953 return kAudioUnitErr_InvalidProperty;
954
955 //lets to a sanity check...
956 // if numChannels == -1, then it can do "any"...
957 if (numChannels > 0) {
958 SInt32 count = 0;
959 for (unsigned int i = 0; i < inNumElements; ++i)
960 count += inChannelsPerElement[i];
961 if (count > numChannels)
962 return kAudioUnitErr_InvalidPropertyValue;
963 }
964
965 OSStatus result = SetElementCount (inScope, inNumElements);
966 if (result)
967 return result;
968
969 CAStreamBasicDescription desc;
970 desc.mSampleRate = inSampleRate;
971 for (unsigned int i = 0; i < inNumElements; ++i) {
972 desc.SetCanonical (inChannelsPerElement[i], false);
973 result = SetFormat (inScope, i, desc);
974 if (result)
975 return result;
976 }
977 return noErr;
978 }
979
980 #pragma mark __Properties
981
982 bool CAAudioUnit::CanBypass () const
983 {
984 Boolean outWritable;
985 OSStatus result = AudioUnitGetPropertyInfo (AU(), kAudioUnitProperty_BypassEffect,
986 kAudioUnitScope_Global, 0,
987 NULL, &outWritable);
988 return (!result && outWritable);
989 }
990
991 bool CAAudioUnit::GetBypass () const
992 {
993 UInt32 dataSize = sizeof (UInt32);
994 UInt32 outBypass;
995 OSStatus result = AudioUnitGetProperty (AU(), kAudioUnitProperty_BypassEffect,
996 kAudioUnitScope_Global, 0,
997 &outBypass, &dataSize);
998 return (result ? false : outBypass);
999 }
1000
1001 OSStatus CAAudioUnit::SetBypass (bool inBypass) const
1002 {
1003 UInt32 bypass = inBypass ? 1 : 0;
1004 return AudioUnitSetProperty (AU(), kAudioUnitProperty_BypassEffect,
1005 kAudioUnitScope_Global, 0,
1006 &bypass, sizeof (UInt32));
1007 }
1008
1009 Float64 CAAudioUnit::Latency () const
1010 {
1011 Float64 secs;
1012 UInt32 size = sizeof(secs);
1013 if (GetProperty (kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0, &secs, &size))
1014 return 0;
1015 return secs;
1016 }
1017
1018 OSStatus CAAudioUnit::GetAUPreset (CFPropertyListRef &outData) const
1019 {
1020 UInt32 dataSize = sizeof(outData);
1021 return AudioUnitGetProperty (AU(), kAudioUnitProperty_ClassInfo,
1022 kAudioUnitScope_Global, 0,
1023 &outData, &dataSize);
1024 }
1025
1026 OSStatus CAAudioUnit::SetAUPreset (CFPropertyListRef &inData)
1027 {
1028 return AudioUnitSetProperty (AU(), kAudioUnitProperty_ClassInfo,
1029 kAudioUnitScope_Global, 0,
1030 &inData, sizeof (CFPropertyListRef));
1031 }
1032
1033 OSStatus CAAudioUnit::GetPresentPreset (AUPreset &outData) const
1034 {
1035 UInt32 dataSize = sizeof(outData);
1036 OSStatus result = AudioUnitGetProperty (AU(), kAudioUnitProperty_PresentPreset,
1037 kAudioUnitScope_Global, 0,
1038 &outData, &dataSize);
1039 if (result == kAudioUnitErr_InvalidProperty) {
1040 dataSize = sizeof(outData);
1041 result = AudioUnitGetProperty (AU(), kAudioUnitProperty_CurrentPreset,
1042 kAudioUnitScope_Global, 0,
1043 &outData, &dataSize);
1044 if (result == noErr) {
1045 // we now retain the CFString in the preset so for the client of this API
1046 // it is consistent (ie. the string should be released when done)
1047 if (outData.presetName)
1048 CFRetain (outData.presetName);
1049 }
1050 }
1051 return result;
1052 }
1053
1054 OSStatus CAAudioUnit::SetPresentPreset (AUPreset &inData)
1055 {
1056 OSStatus result = AudioUnitSetProperty (AU(), kAudioUnitProperty_PresentPreset,
1057 kAudioUnitScope_Global, 0,
1058 &inData, sizeof (AUPreset));
1059 if (result == kAudioUnitErr_InvalidProperty) {
1060 result = AudioUnitSetProperty (AU(), kAudioUnitProperty_CurrentPreset,
1061 kAudioUnitScope_Global, 0,
1062 &inData, sizeof (AUPreset));
1063 }
1064 return result;
1065 }
1066
1067 bool CAAudioUnit::HasCustomView () const
1068 {
1069 UInt32 dataSize = 0;
1070 OSStatus result = GetPropertyInfo(kAudioUnitProperty_GetUIComponentList,
1071 kAudioUnitScope_Global, 0,
1072 &dataSize, NULL);
1073 if (result || !dataSize) {
1074 dataSize = 0;
1075 result = GetPropertyInfo(kAudioUnitProperty_CocoaUI,
1076 kAudioUnitScope_Global, 0,
1077 &dataSize, NULL);
1078 if (result || !dataSize)
1079 return false;
1080 }
1081 return true;
1082 }
1083
1084 OSStatus CAAudioUnit::GetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
1085 Float32 &outValue) const
1086 {
1087 return mDataPtr ? mDataPtr->GetParameter (inID, scope, element, outValue) : paramErr;
1088 }
1089
1090 OSStatus CAAudioUnit::SetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
1091 Float32 value, UInt32 bufferOffsetFrames)
1092 {
1093 return mDataPtr ? mDataPtr->SetParameter (inID, scope, element, value, bufferOffsetFrames) : paramErr;
1094 }
1095
1096 OSStatus CAAudioUnit::MIDIEvent (UInt32 inStatus,
1097 UInt32 inData1,
1098 UInt32 inData2,
1099 UInt32 inOffsetSampleFrame)
1100 {
1101 return mDataPtr ? mDataPtr->MIDIEvent (inStatus, inData1, inData2, inOffsetSampleFrame) : paramErr;
1102 }
1103
1104 OSStatus CAAudioUnit::StartNote (MusicDeviceInstrumentID inInstrument,
1105 MusicDeviceGroupID inGroupID,
1106 NoteInstanceID * outNoteInstanceID,
1107 UInt32 inOffsetSampleFrame,
1108 const MusicDeviceNoteParams * inParams)
1109 {
1110 return mDataPtr ? mDataPtr->StartNote (inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams)
1111 : paramErr;
1112 }
1113
1114 OSStatus CAAudioUnit::StopNote (MusicDeviceGroupID inGroupID,
1115 NoteInstanceID inNoteInstanceID,
1116 UInt32 inOffsetSampleFrame)
1117 {
1118 return mDataPtr ? mDataPtr->StopNote (inGroupID, inNoteInstanceID, inOffsetSampleFrame) : paramErr;
1119 }
1120
1121 #pragma mark __Render
1122
1123 OSStatus CAAudioUnit::Render (AudioUnitRenderActionFlags * ioActionFlags,
1124 const AudioTimeStamp * inTimeStamp,
1125 UInt32 inOutputBusNumber,
1126 UInt32 inNumberFrames,
1127 AudioBufferList * ioData)
1128 {
1129 return mDataPtr ? mDataPtr->Render (ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData) : paramErr;
1130 }
1131
1132 static AURenderCallbackStruct sRenderCallback;
1133 static OSStatus PrerollRenderProc ( void * /*inRefCon*/,
1134 AudioUnitRenderActionFlags * /*inActionFlags*/,
1135 const AudioTimeStamp * /*inTimeStamp*/,
1136 UInt32 /*inBusNumber*/,
1137 UInt32 /*inNumFrames*/,
1138 AudioBufferList *ioData)
1139 {
1140 AudioBuffer *buf = ioData->mBuffers;
1141 for (UInt32 i = ioData->mNumberBuffers; i--; ++buf)
1142 memset((Byte *)buf->mData, 0, buf->mDataByteSize);
1143
1144 return noErr;
1145 }
1146
1147 OSStatus CAAudioUnit::Preroll (UInt32 inFrameSize)
1148 {
1149 CAStreamBasicDescription desc;
1150 OSStatus result = GetFormat (kAudioUnitScope_Input, 0, desc);
1151 bool hasInput = false;
1152 //we have input
1153 if (result == noErr)
1154 {
1155 sRenderCallback.inputProc = PrerollRenderProc;
1156 sRenderCallback.inputProcRefCon = 0;
1157
1158 result = SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
1159 0, &sRenderCallback, sizeof(sRenderCallback));
1160 if (result) return result;
1161 hasInput = true;
1162 }
1163
1164 AudioUnitRenderActionFlags flags = 0;
1165 AudioTimeStamp time;
1166 memset (&time, 0, sizeof(time));
1167 time.mFlags = kAudioTimeStampSampleTimeValid;
1168
1169 CAStreamBasicDescription outputFormat;
1170 require_noerr (result = GetFormat (kAudioUnitScope_Output, 0, outputFormat), home);
1171 {
1172 AUOutputBL list (outputFormat, inFrameSize);
1173 list.Prepare ();
1174
1175 require_noerr (result = Render (&flags, &time, 0, inFrameSize, list.ABL()), home);
1176 require_noerr (result = GlobalReset(), home);
1177 }
1178
1179 home:
1180 if (hasInput) {
1181 // remove our installed callback
1182 sRenderCallback.inputProc = 0;
1183 sRenderCallback.inputProcRefCon = 0;
1184
1185 SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
1186 0, &sRenderCallback, sizeof(sRenderCallback));
1187 }
1188 return result;
1189 }
1190
1191 #pragma mark __CAAUChanHelper
1192
1193 CAAUChanHelper::CAAUChanHelper(const CAAudioUnit &inAU, AudioUnitScope inScope)
1194 :mChans(NULL), mNumEls(0), mDidAllocate(false)
1195 {
1196 UInt32 elCount;
1197 if (inAU.GetElementCount (inScope, elCount)) return;
1198 if (elCount > 8) {
1199 mChans = new UInt32[elCount];
1200 mDidAllocate = true;
1201 memset (mChans, 0, sizeof(int) * elCount);
1202 } else {
1203 mChans = mStaticChans;
1204 memset (mChans, 0, sizeof(int) * 8);
1205 }
1206 for (unsigned int i = 0; i < elCount; ++i) {
1207 UInt32 numChans;
1208 if (inAU.NumberChannels (inScope, i, numChans)) return;
1209 mChans[i] = numChans;
1210 }
1211 mNumEls = elCount;
1212 }
1213
1214 CAAUChanHelper::~CAAUChanHelper()
1215 {
1216 if (mDidAllocate) delete [] mChans;
1217 }
1218
1219 CAAUChanHelper& CAAUChanHelper::operator= (const CAAUChanHelper &c)
1220 {
1221 if (mDidAllocate) delete [] mChans;
1222 if (c.mDidAllocate) {
1223 mChans = new UInt32[c.mNumEls];
1224 mDidAllocate = true;
1225 } else {
1226 mDidAllocate = false;
1227 mChans = mStaticChans;
1228 }
1229 memcpy (mChans, c.mChans, c.mNumEls * sizeof(int));
1230
1231 return *this;
1232 }
1233
1234 #pragma mark __Print Utilities
1235
1236 void CAAudioUnit::Print (FILE* file) const
1237 {
1238 fprintf (file, "AudioUnit:%p\n", AU());
1239 if (IsValid()) {
1240 fprintf (file, "\tnode=%ld\t", (long)GetAUNode()); Comp().Print (file);
1241 }
1242 }
Digital Audio Workstation