qcap: Use the right FAILED/SUCCEEDED macro instead of negating the opposite.
[wine] / dlls / winecoreaudio.drv / audiounit.c
1 /*
2  * Wine Driver for CoreAudio / AudioUnit
3  *
4  * Copyright 2005, 2006 Emmanuel Maillard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(wave);
25
26 #ifdef HAVE_AUDIOUNIT_AUDIOUNIT_H
27 #include <AudioUnit/AudioUnit.h>
28 #include <AudioToolbox/AudioToolbox.h>
29
30 WINE_DECLARE_DEBUG_CHANNEL(midi);
31
32 extern OSStatus CoreAudio_woAudioUnitIOProc(void *inRefCon, 
33                                 AudioUnitRenderActionFlags *ioActionFlags, 
34                                 const AudioTimeStamp *inTimeStamp, 
35                                 UInt32 inBusNumber, 
36                                 UInt32 inNumberFrames, 
37                                 AudioBufferList *ioData);
38
39 extern OSStatus CoreAudio_wiAudioUnitIOProc(void *inRefCon,
40                                 AudioUnitRenderActionFlags *ioActionFlags,
41                                 const AudioTimeStamp *inTimeStamp,
42                                 UInt32 inBusNumber,
43                                 UInt32 inNumberFrames,
44                                 AudioBufferList *ioData);
45
46 int AudioUnit_CreateDefaultAudioUnit(void *wwo, AudioUnit *au)
47 {
48     OSStatus err;
49     Component comp;
50     ComponentDescription desc;
51     AURenderCallbackStruct callbackStruct;
52     
53     desc.componentType = kAudioUnitType_Output;
54     desc.componentSubType = kAudioUnitSubType_DefaultOutput;
55     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
56     desc.componentFlags = 0;
57     desc.componentFlagsMask = 0;
58
59     comp = FindNextComponent(NULL, &desc);
60     if (comp == NULL)
61         return 0;
62     
63     err = OpenAComponent(comp, au);
64     if (comp == NULL)
65         return 0;
66         
67     callbackStruct.inputProc = CoreAudio_woAudioUnitIOProc;
68     callbackStruct.inputProcRefCon = wwo;
69
70     err = AudioUnitSetProperty( *au, 
71                                 kAudioUnitProperty_SetRenderCallback, 
72                                 kAudioUnitScope_Input,
73                                 0, 
74                                 &callbackStruct, 
75                                 sizeof(callbackStruct));
76     return (err == noErr);
77 }
78
79 int AudioUnit_CloseAudioUnit(AudioUnit au)
80 {
81     OSStatus err = CloseComponent(au);
82     return (err == noErr);
83 }
84
85 int AudioUnit_InitializeWithStreamDescription(AudioUnit au, AudioStreamBasicDescription *stream)
86 {
87     OSStatus err = noErr;
88         
89     err = AudioUnitSetProperty(au, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
90                                 0, stream, sizeof(*stream));
91
92     if (err != noErr)
93     {
94         ERR("AudioUnitSetProperty return an error %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
95         return 0;
96     }
97     
98     err = AudioUnitInitialize(au);
99     if (err != noErr)
100     {
101         ERR("AudioUnitInitialize return an error %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
102         return 0;
103     }
104     return 1;
105 }
106
107 int AudioUnit_SetVolume(AudioUnit au, float left, float right)
108 {
109     OSStatus err = noErr;
110    
111     err = AudioUnitSetParameter(au, kHALOutputParam_Volume, kAudioUnitParameterFlag_Output, 0, left, 0);
112                                 
113     if (err != noErr)
114     {
115         ERR("AudioUnitSetParameter return an error %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
116         return 0;
117     }
118     return 1;
119 }
120
121 int AudioUnit_GetVolume(AudioUnit au, float *left, float *right)
122 {
123     OSStatus err = noErr;
124     
125     err = AudioUnitGetParameter(au, kHALOutputParam_Volume, kAudioUnitParameterFlag_Output, 0, left);
126     if (err != noErr)
127     {
128         ERR("AudioUnitGetParameter return an error %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
129         return 0;
130     }
131     *right = *left;
132     return 1;
133 }
134
135
136 /* FIXME: implement sample rate conversion on input */
137 int AudioUnit_GetInputDeviceSampleRate(void)
138 {
139     AudioDeviceID               defaultInputDevice;
140     UInt32                      param;
141     Float64                     sampleRate;
142     OSStatus                    err;
143
144     param = sizeof(defaultInputDevice);
145     err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &param, &defaultInputDevice);
146     if (err != noErr || defaultInputDevice == kAudioDeviceUnknown)
147     {
148         ERR("Couldn't get the default audio input device ID: %08lx\n", err);
149         return 0;
150     }
151
152     param = sizeof(sampleRate);
153     err = AudioDeviceGetProperty(defaultInputDevice, 0, 1, kAudioDevicePropertyNominalSampleRate, &param, &sampleRate);
154     if (err != noErr)
155     {
156         ERR("Couldn't get the device sample rate: %08lx\n", err);
157         return 0;
158     }
159
160     return sampleRate;
161 }
162
163
164 int AudioUnit_CreateInputUnit(void* wwi, AudioUnit* out_au,
165         WORD nChannels, DWORD nSamplesPerSec, WORD wBitsPerSample,
166         UInt32* outFrameCount)
167 {
168     OSStatus                    err = noErr;
169     ComponentDescription        description;
170     Component                   component;
171     AudioUnit                   au;
172     UInt32                      param;
173     AURenderCallbackStruct      callback;
174     AudioDeviceID               defaultInputDevice;
175     AudioStreamBasicDescription desiredFormat;
176
177
178     if (!outFrameCount)
179     {
180         ERR("Invalid parameter\n");
181         return 0;
182     }
183
184     /* Open the AudioOutputUnit */
185     description.componentType           = kAudioUnitType_Output;
186     description.componentSubType        = kAudioUnitSubType_HALOutput;
187     description.componentManufacturer   = kAudioUnitManufacturer_Apple;
188     description.componentFlags          = 0;
189     description.componentFlagsMask      = 0;
190
191     component = FindNextComponent(NULL, &description);
192     if (!component)
193     {
194         ERR("FindNextComponent(kAudioUnitSubType_HALOutput) failed\n");
195         return 0;
196     }
197
198     err = OpenAComponent(component, &au);
199     if (err != noErr || au == NULL)
200     {
201         ERR("OpenAComponent failed: %08lx\n", err);
202         return 0;
203     }
204
205     /* Configure the AudioOutputUnit */
206     /* The AUHAL has two buses (AKA elements).  Bus 0 is output from the app
207      * to the device.  Bus 1 is input from the device to the app.  Each bus
208      * has two ends (AKA scopes).  Data goes from the input scope to the
209      * output scope.  The terminology is somewhat confusing because the terms
210      * "input" and "output" have two meanings.  Here's a summary:
211      *
212      *      Bus 0, input scope: refers to the source of data to be output as sound
213      *      Bus 0, output scope: refers to the actual sound output device
214      *      Bus 1, input scope: refers to the actual sound input device
215      *      Bus 1, output scope: refers to the destination of data received by the input device
216      */
217
218     /* Enable input on the AUHAL */
219     param = 1;
220     err = AudioUnitSetProperty(au, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &param, sizeof(param));
221     if (err != noErr)
222     {
223         ERR("Couldn't enable input on AUHAL: %08lx\n", err);
224         goto error;
225     }
226
227     /* Disable Output on the AUHAL */
228     param = 0;
229     err = AudioUnitSetProperty(au, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &param, sizeof(param));
230     if (err != noErr)
231     {
232         ERR("Couldn't disable output on AUHAL: %08lx\n", err);
233         goto error;
234     }
235
236     /* Find the default input device */
237     param = sizeof(defaultInputDevice);
238     err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &param, &defaultInputDevice);
239     if (err != noErr || defaultInputDevice == kAudioDeviceUnknown)
240     {
241         ERR("Couldn't get the default audio device ID: %08lx\n", err);
242         goto error;
243     }
244
245     /* Set the current device to the default input device. */
246     err = AudioUnitSetProperty(au, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &defaultInputDevice, sizeof(defaultInputDevice));
247     if (err != noErr)
248     {
249         ERR("Couldn't set current device of AUHAL to default input device: %08lx\n", err);
250         goto error;
251     }
252
253     /* Setup render callback */
254     /* This will be called when the AUHAL has input data.  However, it won't
255      * be passed the data itself.  The callback will have to all AudioUnitRender. */
256     callback.inputProc = CoreAudio_wiAudioUnitIOProc;
257     callback.inputProcRefCon = wwi;
258     err = AudioUnitSetProperty(au, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &callback, sizeof(callback));
259     if (err != noErr)
260     {
261         ERR("Couldn't set input callback of AUHAL: %08lx\n", err);
262         goto error;
263     }
264
265     /* Setup the desired data format. */
266     /* FIXME: implement sample rate conversion on input.  We shouldn't set
267      * the mSampleRate of this to the desired sample rate.  We need to query
268      * the input device and use that.  If they don't match, we need to set up
269      * an AUConverter to do the sample rate conversion on a separate thread. */
270     desiredFormat.mFormatID         = kAudioFormatLinearPCM;
271     desiredFormat.mFormatFlags      = kLinearPCMFormatFlagIsPacked;
272     if (wBitsPerSample != 8)
273         desiredFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
274     desiredFormat.mSampleRate       = nSamplesPerSec;
275     desiredFormat.mChannelsPerFrame = nChannels;
276     desiredFormat.mFramesPerPacket  = 1;
277     desiredFormat.mBitsPerChannel   = wBitsPerSample;
278     desiredFormat.mBytesPerFrame    = desiredFormat.mBitsPerChannel * desiredFormat.mChannelsPerFrame / 8;
279     desiredFormat.mBytesPerPacket   = desiredFormat.mBytesPerFrame * desiredFormat.mFramesPerPacket;
280
281     /* Set the AudioOutputUnit output data format */
282     err = AudioUnitSetProperty(au, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &desiredFormat, sizeof(desiredFormat));
283     if (err != noErr)
284     {
285         ERR("Couldn't set desired input format of AUHAL: %08lx\n", err);
286         goto error;
287     }
288
289     /* Get the number of frames in the IO buffer(s) */
290     param = sizeof(*outFrameCount);
291     err = AudioUnitGetProperty(au, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Global, 0, outFrameCount, &param);
292     if (err != noErr)
293     {
294         ERR("Failed to get audio sample size: %08lx\n", err);
295         goto error;
296     }
297
298     TRACE("Frame count: %lu\n", *outFrameCount);
299
300     /* Initialize the AU */
301     err = AudioUnitInitialize(au);
302     if (err != noErr)
303     {
304         ERR("Failed to initialize AU: %08lx\n", err);
305         goto error;
306     }
307
308     *out_au = au;
309
310     return 1;
311
312 error:
313     if (au)
314         CloseComponent(au);
315     return 0;
316 }
317
318 /*
319  *  MIDI Synth Unit
320  */
321 int SynthUnit_CreateDefaultSynthUnit(AUGraph *graph, AudioUnit *synth)
322 {
323     OSStatus err;
324     ComponentDescription desc;
325     AUNode synthNode;
326     AUNode outNode;
327
328     err = NewAUGraph(graph);
329     if (err != noErr)
330     {
331         ERR_(midi)("NewAUGraph return %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
332         return 0;
333     }
334
335     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
336     desc.componentFlags = 0;
337     desc.componentFlagsMask = 0;
338
339     /* create synth node */
340     desc.componentType = kAudioUnitType_MusicDevice;
341     desc.componentSubType = kAudioUnitSubType_DLSSynth;
342
343     err = AUGraphNewNode(*graph, &desc, 0, NULL, &synthNode);
344     if (err != noErr)
345     {
346         ERR_(midi)("AUGraphNewNode cannot create synthNode : %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
347         return 0;
348     }
349
350     /* create out node */
351     desc.componentType = kAudioUnitType_Output;
352     desc.componentSubType = kAudioUnitSubType_DefaultOutput;
353
354     err = AUGraphNewNode(*graph, &desc, 0, NULL, &outNode);
355     if (err != noErr)
356     {
357         ERR_(midi)("AUGraphNewNode cannot create outNode %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
358         return 0;
359     }
360
361     err = AUGraphOpen(*graph);
362     if (err != noErr)
363     {
364         ERR_(midi)("AUGraphOpen return %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
365         return 0;
366     }
367
368     /* connecting the nodes */
369     err = AUGraphConnectNodeInput(*graph, synthNode, 0, outNode, 0);
370     if (err != noErr)
371     {
372         ERR_(midi)("AUGraphConnectNodeInput cannot connect synthNode to outNode : %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
373         return 0;
374     }
375
376     /* Get the synth unit */
377     err = AUGraphGetNodeInfo(*graph, synthNode, 0, 0, 0, synth);
378     if (err != noErr)
379     {
380         ERR_(midi)("AUGraphGetNodeInfo return %c%c%c%c\n", (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
381         return 0;
382     }
383
384     return 1;
385 }
386
387 int SynthUnit_Initialize(AudioUnit synth, AUGraph graph)
388 {
389     OSStatus err = noErr;
390
391     err = AUGraphInitialize(graph);
392     if (err != noErr)
393     {
394         ERR_(midi)("AUGraphInitialize(%p) return %c%c%c%c\n", graph, (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
395         return 0;
396     }
397
398     err = AUGraphStart(graph);
399     if (err != noErr)
400     {
401         ERR_(midi)("AUGraphStart(%p) return %c%c%c%c\n", graph, (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
402         return 0;
403     }
404
405     return 1;
406 }
407
408 int SynthUnit_Close(AUGraph graph)
409 {
410     OSStatus err = noErr;
411
412     err = AUGraphStop(graph);
413     if (err != noErr)
414     {
415         ERR_(midi)("AUGraphStop(%p) return %c%c%c%c\n", graph, (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
416         return 0;
417     }
418
419     err = DisposeAUGraph(graph);
420     if (err != noErr)
421     {
422         ERR_(midi)("DisposeAUGraph(%p) return %c%c%c%c\n", graph, (char) (err >> 24), (char) (err >> 16), (char) (err >> 8), (char) err);
423         return 0;
424     }
425
426     return 1;
427 }
428
429 #endif