zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
coreaudio.c
Go to the documentation of this file.
1 
21 #include "config.h"
22 
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 
27 #include "alMain.h"
28 #include "alu.h"
29 
30 #include <CoreServices/CoreServices.h>
31 #include <unistd.h>
32 #include <AudioUnit/AudioUnit.h>
33 #include <AudioToolbox/AudioToolbox.h>
34 
35 
36 typedef struct {
37  AudioUnit audioUnit;
38 
39  ALuint frameSize;
40  ALdouble sampleRateRatio; // Ratio of hardware sample rate / requested sample rate
41  AudioStreamBasicDescription format; // This is the OpenAL format as a CoreAudio ASBD
42 
43  AudioConverterRef audioConverter; // Sample rate converter if needed
44  AudioBufferList *bufferList; // Buffer for data coming from the input device
45  ALCvoid *resampleBuffer; // Buffer for returned RingBuffer data when resampling
46 
47  RingBuffer *ring;
48 } ca_data;
49 
50 static const ALCchar ca_device[] = "CoreAudio Default";
51 
52 
53 static void destroy_buffer_list(AudioBufferList* list)
54 {
55  if(list)
56  {
57  UInt32 i;
58  for(i = 0;i < list->mNumberBuffers;i++)
59  free(list->mBuffers[i].mData);
60  free(list);
61  }
62 }
63 
64 static AudioBufferList* allocate_buffer_list(UInt32 channelCount, UInt32 byteSize)
65 {
66  AudioBufferList *list;
67 
68  list = calloc(1, sizeof(AudioBufferList) + sizeof(AudioBuffer));
69  if(list)
70  {
71  list->mNumberBuffers = 1;
72 
73  list->mBuffers[0].mNumberChannels = channelCount;
74  list->mBuffers[0].mDataByteSize = byteSize;
75  list->mBuffers[0].mData = malloc(byteSize);
76  if(list->mBuffers[0].mData == NULL)
77  {
78  free(list);
79  list = NULL;
80  }
81  }
82  return list;
83 }
84 
85 static OSStatus ca_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp,
86  UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
87 {
88  ALCdevice *device = (ALCdevice*)inRefCon;
89  ca_data *data = (ca_data*)device->ExtraData;
90 
91  aluMixData(device, ioData->mBuffers[0].mData,
92  ioData->mBuffers[0].mDataByteSize / data->frameSize);
93 
94  return noErr;
95 }
96 
97 static OSStatus ca_capture_conversion_callback(AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets,
98  AudioBufferList *ioData, AudioStreamPacketDescription **outDataPacketDescription, void* inUserData)
99 {
100  ALCdevice *device = (ALCdevice*)inUserData;
101  ca_data *data = (ca_data*)device->ExtraData;
102 
103  // Read from the ring buffer and store temporarily in a large buffer
104  ReadRingBuffer(data->ring, data->resampleBuffer, (ALsizei)(*ioNumberDataPackets));
105 
106  // Set the input data
107  ioData->mNumberBuffers = 1;
108  ioData->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
109  ioData->mBuffers[0].mData = data->resampleBuffer;
110  ioData->mBuffers[0].mDataByteSize = (*ioNumberDataPackets) * data->format.mBytesPerFrame;
111 
112  return noErr;
113 }
114 
115 static OSStatus ca_capture_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags,
116  const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
117  UInt32 inNumberFrames, AudioBufferList *ioData)
118 {
119  ALCdevice *device = (ALCdevice*)inRefCon;
120  ca_data *data = (ca_data*)device->ExtraData;
121  AudioUnitRenderActionFlags flags = 0;
122  OSStatus err;
123 
124  // fill the bufferList with data from the input device
125  err = AudioUnitRender(data->audioUnit, &flags, inTimeStamp, 1, inNumberFrames, data->bufferList);
126  if(err != noErr)
127  {
128  ERR("AudioUnitRender error: %d\n", err);
129  return err;
130  }
131 
132  WriteRingBuffer(data->ring, data->bufferList->mBuffers[0].mData, inNumberFrames);
133 
134  return noErr;
135 }
136 
137 static ALCenum ca_open_playback(ALCdevice *device, const ALCchar *deviceName)
138 {
139  ComponentDescription desc;
140  Component comp;
141  ca_data *data;
142  OSStatus err;
143 
144  if(!deviceName)
145  deviceName = ca_device;
146  else if(strcmp(deviceName, ca_device) != 0)
147  return ALC_INVALID_VALUE;
148 
149  /* open the default output unit */
150  desc.componentType = kAudioUnitType_Output;
151  desc.componentSubType = kAudioUnitSubType_DefaultOutput;
152  desc.componentManufacturer = kAudioUnitManufacturer_Apple;
153  desc.componentFlags = 0;
154  desc.componentFlagsMask = 0;
155 
156  comp = FindNextComponent(NULL, &desc);
157  if(comp == NULL)
158  {
159  ERR("FindNextComponent failed\n");
160  return ALC_INVALID_VALUE;
161  }
162 
163  data = calloc(1, sizeof(*data));
164 
165  err = OpenAComponent(comp, &data->audioUnit);
166  if(err != noErr)
167  {
168  ERR("OpenAComponent failed\n");
169  free(data);
170  return ALC_INVALID_VALUE;
171  }
172 
173  /* init and start the default audio unit... */
174  err = AudioUnitInitialize(data->audioUnit);
175  if(err != noErr)
176  {
177  ERR("AudioUnitInitialize failed\n");
178  CloseComponent(data->audioUnit);
179  free(data);
180  return ALC_INVALID_VALUE;
181  }
182 
183  device->DeviceName = strdup(deviceName);
184  device->ExtraData = data;
185  return ALC_NO_ERROR;
186 }
187 
188 static void ca_close_playback(ALCdevice *device)
189 {
190  ca_data *data = (ca_data*)device->ExtraData;
191 
192  AudioUnitUninitialize(data->audioUnit);
193  CloseComponent(data->audioUnit);
194 
195  free(data);
196  device->ExtraData = NULL;
197 }
198 
200 {
201  ca_data *data = (ca_data*)device->ExtraData;
202  AudioStreamBasicDescription streamFormat;
203  AURenderCallbackStruct input;
204  OSStatus err;
205  UInt32 size;
206 
207  err = AudioUnitUninitialize(data->audioUnit);
208  if(err != noErr)
209  ERR("-- AudioUnitUninitialize failed.\n");
210 
211  /* retrieve default output unit's properties (output side) */
212  size = sizeof(AudioStreamBasicDescription);
213  err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &streamFormat, &size);
214  if(err != noErr || size != sizeof(AudioStreamBasicDescription))
215  {
216  ERR("AudioUnitGetProperty failed\n");
217  return ALC_FALSE;
218  }
219 
220 #if 0
221  TRACE("Output streamFormat of default output unit -\n");
222  TRACE(" streamFormat.mFramesPerPacket = %d\n", streamFormat.mFramesPerPacket);
223  TRACE(" streamFormat.mChannelsPerFrame = %d\n", streamFormat.mChannelsPerFrame);
224  TRACE(" streamFormat.mBitsPerChannel = %d\n", streamFormat.mBitsPerChannel);
225  TRACE(" streamFormat.mBytesPerPacket = %d\n", streamFormat.mBytesPerPacket);
226  TRACE(" streamFormat.mBytesPerFrame = %d\n", streamFormat.mBytesPerFrame);
227  TRACE(" streamFormat.mSampleRate = %5.0f\n", streamFormat.mSampleRate);
228 #endif
229 
230  /* set default output unit's input side to match output side */
231  err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, size);
232  if(err != noErr)
233  {
234  ERR("AudioUnitSetProperty failed\n");
235  return ALC_FALSE;
236  }
237 
238  if(device->Frequency != streamFormat.mSampleRate)
239  {
240  device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
241  streamFormat.mSampleRate /
242  device->Frequency);
243  device->Frequency = streamFormat.mSampleRate;
244  }
245 
246  /* FIXME: How to tell what channels are what in the output device, and how
247  * to specify what we're giving? eg, 6.0 vs 5.1 */
248  switch(streamFormat.mChannelsPerFrame)
249  {
250  case 1:
251  device->FmtChans = DevFmtMono;
252  break;
253  case 2:
254  device->FmtChans = DevFmtStereo;
255  break;
256  case 4:
257  device->FmtChans = DevFmtQuad;
258  break;
259  case 6:
260  device->FmtChans = DevFmtX51;
261  break;
262  case 7:
263  device->FmtChans = DevFmtX61;
264  break;
265  case 8:
266  device->FmtChans = DevFmtX71;
267  break;
268  default:
269  ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
270  device->FmtChans = DevFmtStereo;
271  streamFormat.mChannelsPerFrame = 2;
272  break;
273  }
275 
276  /* use channel count and sample rate from the default output unit's current
277  * parameters, but reset everything else */
278  streamFormat.mFramesPerPacket = 1;
279  streamFormat.mFormatFlags = 0;
280  switch(device->FmtType)
281  {
282  case DevFmtUByte:
283  device->FmtType = DevFmtByte;
284  /* fall-through */
285  case DevFmtByte:
286  streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
287  streamFormat.mBitsPerChannel = 8;
288  break;
289  case DevFmtUShort:
290  device->FmtType = DevFmtShort;
291  /* fall-through */
292  case DevFmtShort:
293  streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
294  streamFormat.mBitsPerChannel = 16;
295  break;
296  case DevFmtUInt:
297  device->FmtType = DevFmtInt;
298  /* fall-through */
299  case DevFmtInt:
300  streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
301  streamFormat.mBitsPerChannel = 32;
302  break;
303  case DevFmtFloat:
304  streamFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat;
305  streamFormat.mBitsPerChannel = 32;
306  break;
307  }
308  streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame *
309  streamFormat.mBitsPerChannel / 8;
310  streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame;
311  streamFormat.mFormatID = kAudioFormatLinearPCM;
312  streamFormat.mFormatFlags |= kAudioFormatFlagsNativeEndian |
313  kLinearPCMFormatFlagIsPacked;
314 
315  err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, sizeof(AudioStreamBasicDescription));
316  if(err != noErr)
317  {
318  ERR("AudioUnitSetProperty failed\n");
319  return ALC_FALSE;
320  }
321 
322  /* setup callback */
323  data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
324  input.inputProc = ca_callback;
325  input.inputProcRefCon = device;
326 
327  err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
328  if(err != noErr)
329  {
330  ERR("AudioUnitSetProperty failed\n");
331  return ALC_FALSE;
332  }
333 
334  /* init the default audio unit... */
335  err = AudioUnitInitialize(data->audioUnit);
336  if(err != noErr)
337  {
338  ERR("AudioUnitInitialize failed\n");
339  return ALC_FALSE;
340  }
341 
342  return ALC_TRUE;
343 }
344 
346 {
347  ca_data *data = (ca_data*)device->ExtraData;
348  OSStatus err;
349 
350  err = AudioOutputUnitStart(data->audioUnit);
351  if(err != noErr)
352  {
353  ERR("AudioOutputUnitStart failed\n");
354  return ALC_FALSE;
355  }
356 
357  return ALC_TRUE;
358 }
359 
360 static void ca_stop_playback(ALCdevice *device)
361 {
362  ca_data *data = (ca_data*)device->ExtraData;
363  OSStatus err;
364 
365  err = AudioOutputUnitStop(data->audioUnit);
366  if(err != noErr)
367  ERR("AudioOutputUnitStop failed\n");
368 }
369 
370 static ALCenum ca_open_capture(ALCdevice *device, const ALCchar *deviceName)
371 {
372  AudioStreamBasicDescription requestedFormat; // The application requested format
373  AudioStreamBasicDescription hardwareFormat; // The hardware format
374  AudioStreamBasicDescription outputFormat; // The AudioUnit output format
375  AURenderCallbackStruct input;
376  ComponentDescription desc;
377  AudioDeviceID inputDevice;
378  UInt32 outputFrameCount;
379  UInt32 propertySize;
380  UInt32 enableIO;
381  Component comp;
382  ca_data *data;
383  OSStatus err;
384 
385  desc.componentType = kAudioUnitType_Output;
386  desc.componentSubType = kAudioUnitSubType_HALOutput;
387  desc.componentManufacturer = kAudioUnitManufacturer_Apple;
388  desc.componentFlags = 0;
389  desc.componentFlagsMask = 0;
390 
391  // Search for component with given description
392  comp = FindNextComponent(NULL, &desc);
393  if(comp == NULL)
394  {
395  ERR("FindNextComponent failed\n");
396  return ALC_INVALID_VALUE;
397  }
398 
399  data = calloc(1, sizeof(*data));
400  device->ExtraData = data;
401 
402  // Open the component
403  err = OpenAComponent(comp, &data->audioUnit);
404  if(err != noErr)
405  {
406  ERR("OpenAComponent failed\n");
407  goto error;
408  }
409 
410  // Turn off AudioUnit output
411  enableIO = 0;
412  err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
413  if(err != noErr)
414  {
415  ERR("AudioUnitSetProperty failed\n");
416  goto error;
417  }
418 
419  // Turn on AudioUnit input
420  enableIO = 1;
421  err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
422  if(err != noErr)
423  {
424  ERR("AudioUnitSetProperty failed\n");
425  goto error;
426  }
427 
428  // Get the default input device
429  propertySize = sizeof(AudioDeviceID);
430  err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &inputDevice);
431  if(err != noErr)
432  {
433  ERR("AudioHardwareGetProperty failed\n");
434  goto error;
435  }
436 
437  if(inputDevice == kAudioDeviceUnknown)
438  {
439  ERR("No input device found\n");
440  goto error;
441  }
442 
443  // Track the input device
444  err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
445  if(err != noErr)
446  {
447  ERR("AudioUnitSetProperty failed\n");
448  goto error;
449  }
450 
451  // set capture callback
452  input.inputProc = ca_capture_callback;
453  input.inputProcRefCon = device;
454 
455  err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
456  if(err != noErr)
457  {
458  ERR("AudioUnitSetProperty failed\n");
459  goto error;
460  }
461 
462  // Initialize the device
463  err = AudioUnitInitialize(data->audioUnit);
464  if(err != noErr)
465  {
466  ERR("AudioUnitInitialize failed\n");
467  goto error;
468  }
469 
470  // Get the hardware format
471  propertySize = sizeof(AudioStreamBasicDescription);
472  err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &hardwareFormat, &propertySize);
473  if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
474  {
475  ERR("AudioUnitGetProperty failed\n");
476  goto error;
477  }
478 
479  // Set up the requested format description
480  switch(device->FmtType)
481  {
482  case DevFmtUByte:
483  requestedFormat.mBitsPerChannel = 8;
484  requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
485  break;
486  case DevFmtShort:
487  requestedFormat.mBitsPerChannel = 16;
488  requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
489  break;
490  case DevFmtInt:
491  requestedFormat.mBitsPerChannel = 32;
492  requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
493  break;
494  case DevFmtFloat:
495  requestedFormat.mBitsPerChannel = 32;
496  requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
497  break;
498  case DevFmtByte:
499  case DevFmtUShort:
500  case DevFmtUInt:
501  ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
502  goto error;
503  }
504 
505  switch(device->FmtChans)
506  {
507  case DevFmtMono:
508  requestedFormat.mChannelsPerFrame = 1;
509  break;
510  case DevFmtStereo:
511  requestedFormat.mChannelsPerFrame = 2;
512  break;
513 
514  case DevFmtQuad:
515  case DevFmtX51:
516  case DevFmtX51Side:
517  case DevFmtX61:
518  case DevFmtX71:
519  ERR("%s not supported\n", DevFmtChannelsString(device->FmtChans));
520  goto error;
521  }
522 
523  requestedFormat.mBytesPerFrame = requestedFormat.mChannelsPerFrame * requestedFormat.mBitsPerChannel / 8;
524  requestedFormat.mBytesPerPacket = requestedFormat.mBytesPerFrame;
525  requestedFormat.mSampleRate = device->Frequency;
526  requestedFormat.mFormatID = kAudioFormatLinearPCM;
527  requestedFormat.mReserved = 0;
528  requestedFormat.mFramesPerPacket = 1;
529 
530  // save requested format description for later use
531  data->format = requestedFormat;
532  data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
533 
534  // Use intermediate format for sample rate conversion (outputFormat)
535  // Set sample rate to the same as hardware for resampling later
536  outputFormat = requestedFormat;
537  outputFormat.mSampleRate = hardwareFormat.mSampleRate;
538 
539  // Determine sample rate ratio for resampling
540  data->sampleRateRatio = outputFormat.mSampleRate / device->Frequency;
541 
542  // The output format should be the requested format, but using the hardware sample rate
543  // This is because the AudioUnit will automatically scale other properties, except for sample rate
544  err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, (void *)&outputFormat, sizeof(outputFormat));
545  if(err != noErr)
546  {
547  ERR("AudioUnitSetProperty failed\n");
548  goto error;
549  }
550 
551  // Set the AudioUnit output format frame count
552  outputFrameCount = device->UpdateSize * data->sampleRateRatio;
553  err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
554  if(err != noErr)
555  {
556  ERR("AudioUnitSetProperty failed: %d\n", err);
557  goto error;
558  }
559 
560  // Set up sample converter
561  err = AudioConverterNew(&outputFormat, &requestedFormat, &data->audioConverter);
562  if(err != noErr)
563  {
564  ERR("AudioConverterNew failed: %d\n", err);
565  goto error;
566  }
567 
568  // Create a buffer for use in the resample callback
569  data->resampleBuffer = malloc(device->UpdateSize * data->frameSize * data->sampleRateRatio);
570 
571  // Allocate buffer for the AudioUnit output
572  data->bufferList = allocate_buffer_list(outputFormat.mChannelsPerFrame, device->UpdateSize * data->frameSize * data->sampleRateRatio);
573  if(data->bufferList == NULL)
574  goto error;
575 
576  data->ring = CreateRingBuffer(data->frameSize, (device->UpdateSize * data->sampleRateRatio) * device->NumUpdates);
577  if(data->ring == NULL)
578  goto error;
579 
580  return ALC_NO_ERROR;
581 
582 error:
583  DestroyRingBuffer(data->ring);
584  free(data->resampleBuffer);
585  destroy_buffer_list(data->bufferList);
586 
587  if(data->audioConverter)
588  AudioConverterDispose(data->audioConverter);
589  if(data->audioUnit)
590  CloseComponent(data->audioUnit);
591 
592  free(data);
593  device->ExtraData = NULL;
594 
595  return ALC_INVALID_VALUE;
596 }
597 
598 static void ca_close_capture(ALCdevice *device)
599 {
600  ca_data *data = (ca_data*)device->ExtraData;
601 
602  DestroyRingBuffer(data->ring);
603  free(data->resampleBuffer);
604  destroy_buffer_list(data->bufferList);
605 
606  AudioConverterDispose(data->audioConverter);
607  CloseComponent(data->audioUnit);
608 
609  free(data);
610  device->ExtraData = NULL;
611 }
612 
613 static void ca_start_capture(ALCdevice *device)
614 {
615  ca_data *data = (ca_data*)device->ExtraData;
616  OSStatus err = AudioOutputUnitStart(data->audioUnit);
617  if(err != noErr)
618  ERR("AudioOutputUnitStart failed\n");
619 }
620 
621 static void ca_stop_capture(ALCdevice *device)
622 {
623  ca_data *data = (ca_data*)device->ExtraData;
624  OSStatus err = AudioOutputUnitStop(data->audioUnit);
625  if(err != noErr)
626  ERR("AudioOutputUnitStop failed\n");
627 }
628 
630 {
631  ca_data *data = (ca_data*)device->ExtraData;
632  AudioBufferList *list;
633  UInt32 frameCount;
634  OSStatus err;
635 
636  // If no samples are requested, just return
637  if(samples == 0)
638  return ALC_NO_ERROR;
639 
640  // Allocate a temporary AudioBufferList to use as the return resamples data
641  list = alloca(sizeof(AudioBufferList) + sizeof(AudioBuffer));
642 
643  // Point the resampling buffer to the capture buffer
644  list->mNumberBuffers = 1;
645  list->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
646  list->mBuffers[0].mDataByteSize = samples * data->frameSize;
647  list->mBuffers[0].mData = buffer;
648 
649  // Resample into another AudioBufferList
650  frameCount = samples;
651  err = AudioConverterFillComplexBuffer(data->audioConverter, ca_capture_conversion_callback,
652  device, &frameCount, list, NULL);
653  if(err != noErr)
654  {
655  ERR("AudioConverterFillComplexBuffer error: %d\n", err);
656  return ALC_INVALID_VALUE;
657  }
658  return ALC_NO_ERROR;
659 }
660 
662 {
663  ca_data *data = device->ExtraData;
664  return RingBufferSize(data->ring) / data->sampleRateRatio;
665 }
666 
667 
668 static const BackendFuncs ca_funcs = {
683 };
684 
686 {
687  *func_list = ca_funcs;
688  return ALC_TRUE;
689 }
690 
691 void alc_ca_deinit(void)
692 {
693 }
694 
696 {
697  switch(type)
698  {
699  case ALL_DEVICE_PROBE:
701  break;
704  break;
705  }
706 }
#define ALC_TRUE
Definition: alc.h:84
static OSStatus ca_capture_conversion_callback(AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets, AudioBufferList *ioData, AudioStreamPacketDescription **outDataPacketDescription, void *inUserData)
Definition: coreaudio.c:97
static ALCenum ca_open_capture(ALCdevice *device, const ALCchar *deviceName)
Definition: coreaudio.c:370
static void destroy_buffer_list(AudioBufferList *list)
Definition: coreaudio.c:53
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum type
Definition: gl2ext.h:845
char * strdup(const char *inStr)
Definition: strdup.c:6
#define NULL
Definition: ftobjs.h:61
#define TRACE(...)
Definition: alMain.h:806
static ALCuint ca_available_samples(ALCdevice *device)
Definition: coreaudio.c:661
const ALCchar * DevFmtChannelsString(enum DevFmtChannels chans)
Definition: ALc.c:1150
static void ca_close_capture(ALCdevice *device)
Definition: coreaudio.c:598
int ALsizei
Definition: al.h:62
SDL_EventEntry * free
Definition: SDL_events.c:80
ALuint Frequency
Definition: alMain.h:569
ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
Definition: ALu.c:970
ALint64 ALCdevice_GetLatencyDefault(ALCdevice *device)
Definition: ALc.c:1285
static int comp(const void *a, const void *b)
Definition: lsp.c:298
void alc_ca_probe(enum DevProbe type)
Definition: coreaudio.c:695
ALsizei RingBufferSize(RingBuffer *ring)
Definition: alcRing.c:67
void AppendCaptureDeviceList(const ALCchar *name)
unsigned int ALCuint
Definition: alc.h:60
static ALCboolean ca_reset_playback(ALCdevice *device)
Definition: coreaudio.c:199
#define calloc
Definition: SDL_malloc.c:636
char ALCchar
Definition: alc.h:42
struct RingBuffer RingBuffer
Definition: alMain.h:750
static void ca_stop_playback(ALCdevice *device)
Definition: coreaudio.c:360
EGLContext EGLenum EGLClientBuffer buffer
Definition: eglext.h:87
void * ExtraData
Definition: alMain.h:630
#define ALC_FALSE
Definition: alc.h:81
double ALdouble
Definition: al.h:71
static OSStatus ca_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
Definition: coreaudio.c:85
void SetDefaultWFXChannelOrder(ALCdevice *device)
Definition: ALc.c:1295
ALCboolean alc_ca_init(BackendFuncs *func_list)
Definition: coreaudio.c:685
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl2ext.h:848
FT_Error error
Definition: cffdrivr.c:407
static void ca_start_capture(ALCdevice *device)
Definition: coreaudio.c:613
GLsizei samples
Definition: gl2ext.h:970
RingBuffer * CreateRingBuffer(ALsizei frame_size, ALsizei length)
Definition: alcRing.c:41
static void ca_stop_capture(ALCdevice *device)
Definition: coreaudio.c:621
static ALCenum ca_open_playback(ALCdevice *device, const ALCchar *deviceName)
Definition: coreaudio.c:137
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl2ext.h:845
static const BackendFuncs ca_funcs
Definition: coreaudio.c:668
unsigned int ALuint
Definition: al.h:59
enum DevFmtChannels FmtChans
Definition: alMain.h:572
void alc_ca_deinit(void)
Definition: coreaudio.c:691
static const ALCchar ca_device[]
Definition: coreaudio.c:50
#define ALC_NO_ERROR
Definition: alc.h:102
void ALCdevice_LockDefault(ALCdevice *device)
Definition: ALc.c:1277
#define malloc
Definition: SDL_malloc.c:635
static OSStatus ca_capture_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
Definition: coreaudio.c:115
GLenum GLenum GLenum input
Definition: glew.h:12631
char ALCboolean
Definition: alc.h:39
void ALCvoid
Definition: alc.h:75
#define ERR(...)
Definition: alMain.h:816
GLenum GLsizei GLsizei GLsizei GLsizei GLbitfield flags
Definition: glew.h:2767
ALuint UpdateSize
Definition: alMain.h:570
ALuint NumUpdates
Definition: alMain.h:571
static ALCboolean ca_start_playback(ALCdevice *device)
Definition: coreaudio.c:345
static void ca_close_playback(ALCdevice *device)
Definition: coreaudio.c:188
enum DevFmtType FmtType
Definition: alMain.h:573
ALCchar * DeviceName
Definition: alMain.h:575
#define ALC_INVALID_VALUE
Definition: alc.h:114
void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len)
Definition: alcRing.c:108
static ALCenum ca_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
Definition: coreaudio.c:629
int i
Definition: pngrutil.c:1377
static AudioBufferList * allocate_buffer_list(UInt32 channelCount, UInt32 byteSize)
Definition: coreaudio.c:64
int ALCenum
Definition: alc.h:66
const ALCchar * DevFmtTypeString(enum DevFmtType type)
Definition: ALc.c:1136
void DestroyRingBuffer(RingBuffer *ring)
Definition: alcRing.c:58
void ALCdevice_UnlockDefault(ALCdevice *device)
Definition: ALc.c:1281
void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len)
Definition: alcRing.c:78
void AppendAllDevicesList(const ALCchar *name)
DevProbe
Definition: alMain.h:383
static __inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type)
Definition: alMain.h:523
GLsizei size
Definition: gl2ext.h:1467