1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
|
/*
*
* ao_macosx.c
*
* Original Copyright (C) Timothy J. Wood - Aug 2000
*
* This file is part of libao, a cross-platform library. See
* README for a history of this source code.
*
* libao is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* libao is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* The MacOS X CoreAudio framework doesn't mesh as simply as some
* simpler frameworks do. This is due to the fact that CoreAudio pulls
* audio samples rather than having them pushed at it (which is nice
* when you are wanting to do good buffering of audio).
*/
/* Change log:
*
* 14/5-2003: Ported to MPlayer libao2 by Dan Christiansen
*
* AC-3 and MPEG audio passthrough is possible, but I don't have
* access to a sound card that supports it.
*/
#include <CoreServices/CoreServices.h>
#include <AudioUnit/AudioUnit.h>
#include <AudioToolbox/AudioToolbox.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
#include <pthread.h>
#include "config.h"
#include "mp_msg.h"
#include "audio_out.h"
#include "audio_out_internal.h"
#include "libaf/af_format.h"
static ao_info_t info =
{
"Darwin/Mac OS X native audio output",
"macosx",
"Timothy J. Wood & Dan Christiansen & Chris Roccati",
""
};
LIBAO_EXTERN(macosx)
/* Prefix for all mp_msg() calls */
#define ao_msg(a, b, c...) mp_msg(a, b, "AO: [macosx] " c)
/* This is large, but best (maybe it should be even larger).
* CoreAudio supposedly has an internal latency in the order of 2ms */
#define NUM_BUFS 32
typedef struct ao_macosx_s
{
/* AudioUnit */
AudioUnit theOutputUnit;
int packetSize;
/* Ring-buffer */
/* does not need explicit synchronization, but needs to allocate
* (num_chunks + 1) * chunk_size memory to store num_chunks * chunk_size
* data */
unsigned char *buffer;
unsigned int buffer_len; ///< must always be (num_chunks + 1) * chunk_size
unsigned int num_chunks;
unsigned int chunk_size;
unsigned int buf_read_pos;
unsigned int buf_write_pos;
} ao_macosx_t;
static ao_macosx_t *ao = NULL;
/**
* \brief return number of free bytes in the buffer
* may only be called by mplayer's thread
* \return minimum number of free bytes in buffer, value may change between
* two immediately following calls, and the real number of free bytes
* might actually be larger!
*/
static int buf_free() {
int free = ao->buf_read_pos - ao->buf_write_pos - ao->chunk_size;
if (free < 0) free += ao->buffer_len;
return free;
}
/**
* \brief return number of buffered bytes
* may only be called by playback thread
* \return minimum number of buffered bytes, value may change between
* two immediately following calls, and the real number of buffered bytes
* might actually be larger!
*/
static int buf_used() {
int used = ao->buf_write_pos - ao->buf_read_pos;
if (used < 0) used += ao->buffer_len;
return used;
}
/**
* \brief add data to ringbuffer
*/
static int write_buffer(unsigned char* data, int len){
int first_len = ao->buffer_len - ao->buf_write_pos;
int free = buf_free();
if (len > free) len = free;
if (first_len > len) first_len = len;
// till end of buffer
memcpy (&ao->buffer[ao->buf_write_pos], data, first_len);
if (len > first_len) { // we have to wrap around
// remaining part from beginning of buffer
memcpy (ao->buffer, &data[first_len], len - first_len);
}
ao->buf_write_pos = (ao->buf_write_pos + len) % ao->buffer_len;
return len;
}
/**
* \brief remove data from ringbuffer
*/
static int read_buffer(unsigned char* data,int len){
int first_len = ao->buffer_len - ao->buf_read_pos;
int buffered = buf_used();
if (len > buffered) len = buffered;
if (first_len > len) first_len = len;
// till end of buffer
memcpy (data, &ao->buffer[ao->buf_read_pos], first_len);
if (len > first_len) { // we have to wrap around
// remaining part from beginning of buffer
memcpy (&data[first_len], ao->buffer, len - first_len);
}
ao->buf_read_pos = (ao->buf_read_pos + len) % ao->buffer_len;
return len;
}
OSStatus theRenderProc(void *inRefCon, AudioUnitRenderActionFlags *inActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumFrames, AudioBufferList *ioData)
{
int amt=buf_used();
int req=(inNumFrames)*ao->packetSize;
if(amt>req)
amt=req;
if(amt)
read_buffer((unsigned char *)ioData->mBuffers[0].mData, amt);
else audio_pause();
ioData->mBuffers[0].mDataByteSize = amt;
return noErr;
}
static int control(int cmd,void *arg){
switch (cmd) {
case AOCONTROL_SET_DEVICE:
case AOCONTROL_GET_DEVICE:
case AOCONTROL_GET_VOLUME:
case AOCONTROL_SET_VOLUME:
/* Everything is currently unimplemented */
return CONTROL_FALSE;
default:
return CONTROL_FALSE;
}
}
static void print_format(const char* str,AudioStreamBasicDescription *f){
uint32_t flags=(uint32_t) f->mFormatFlags;
ao_msg(MSGT_AO,MSGL_V, "%s %7.1fHz %dbit [%c%c%c%c] %s %s %s%s%s%s\n",
str, f->mSampleRate, f->mBitsPerChannel,
(int)(f->mFormatID & 0xff000000) >> 24,
(int)(f->mFormatID & 0x00ff0000) >> 16,
(int)(f->mFormatID & 0x0000ff00) >> 8,
(int)(f->mFormatID & 0x000000ff) >> 0,
(flags&kAudioFormatFlagIsFloat) ? "float" : "int",
(flags&kAudioFormatFlagIsBigEndian) ? "BE" : "LE",
(flags&kAudioFormatFlagIsSignedInteger) ? "S" : "U",
(flags&kAudioFormatFlagIsPacked) ? " packed" : "",
(flags&kAudioFormatFlagIsAlignedHigh) ? " aligned" : "",
(flags&kAudioFormatFlagIsNonInterleaved) ? " ni" : "" );
ao_msg(MSGT_AO,MSGL_DBG2, "%5d mBytesPerPacket\n",
(int)f->mBytesPerPacket);
ao_msg(MSGT_AO,MSGL_DBG2, "%5d mFramesPerPacket\n",
(int)f->mFramesPerPacket);
ao_msg(MSGT_AO,MSGL_DBG2, "%5d mBytesPerFrame\n",
(int)f->mBytesPerFrame);
ao_msg(MSGT_AO,MSGL_DBG2, "%5d mChannelsPerFrame\n",
(int)f->mChannelsPerFrame);
}
static int init(int rate,int channels,int format,int flags)
{
AudioStreamBasicDescription inDesc, outDesc;
ComponentDescription desc;
Component comp;
AURenderCallbackStruct renderCallback;
OSStatus err;
UInt32 size, maxFrames;
int aoIsCreated = ao != NULL;
if (!aoIsCreated) ao = (ao_macosx_t *)malloc(sizeof(ao_macosx_t));
// Build Description for the input format
memset(&inDesc, 0, sizeof(AudioStreamBasicDescription));
inDesc.mSampleRate=rate;
inDesc.mFormatID=kAudioFormatLinearPCM;
inDesc.mChannelsPerFrame=channels;
switch(format&AF_FORMAT_BITS_MASK){
case AF_FORMAT_8BIT:
inDesc.mBitsPerChannel=8;
break;
case AF_FORMAT_16BIT:
inDesc.mBitsPerChannel=16;
break;
case AF_FORMAT_24BIT:
inDesc.mBitsPerChannel=24;
break;
case AF_FORMAT_32BIT:
inDesc.mBitsPerChannel=32;
break;
default:
ao_msg(MSGT_AO, MSGL_WARN, "Unsupported format (0x%08x)\n", format);
return CONTROL_FALSE;
break;
}
if((format&AF_FORMAT_POINT_MASK)==AF_FORMAT_F) {
// float
inDesc.mFormatFlags = kAudioFormatFlagIsFloat|kAudioFormatFlagIsPacked;
}
else if((format&AF_FORMAT_SIGN_MASK)==AF_FORMAT_SI) {
// signed int
inDesc.mFormatFlags = kAudioFormatFlagIsSignedInteger|kAudioFormatFlagIsPacked;
}
else {
// unsigned int
inDesc.mFormatFlags = kAudioFormatFlagIsPacked;
}
if((format&AF_FORMAT_END_MASK)==AF_FORMAT_BE)
inDesc.mFormatFlags |= kAudioFormatFlagIsBigEndian;
inDesc.mFramesPerPacket = 1;
ao->packetSize = inDesc.mBytesPerPacket = inDesc.mBytesPerFrame = inDesc.mFramesPerPacket*channels*(inDesc.mBitsPerChannel/8);
print_format("source: ",&inDesc);
if (!aoIsCreated) {
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = kAudioUnitSubType_DefaultOutput;
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
comp = FindNextComponent(NULL, &desc); //Finds an component that meets the desc spec's
if (comp == NULL) {
ao_msg(MSGT_AO, MSGL_WARN, "Unable to find Output Unit component\n");
return CONTROL_FALSE;
}
err = OpenAComponent(comp, &(ao->theOutputUnit)); //gains access to the services provided by the component
if (err) {
ao_msg(MSGT_AO, MSGL_WARN, "Unable to open Output Unit component (err=%d)\n", err);
return CONTROL_FALSE;
}
// Initialize AudioUnit
err = AudioUnitInitialize(ao->theOutputUnit);
if (err) {
ao_msg(MSGT_AO, MSGL_WARN, "Unable to initialize Output Unit component (err=%d)\n", err);
return CONTROL_FALSE;
}
}
size = sizeof(AudioStreamBasicDescription);
err = AudioUnitSetProperty(ao->theOutputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &inDesc, size);
if (err) {
ao_msg(MSGT_AO, MSGL_WARN, "Unable to set the input format (err=%d)\n", err);
return CONTROL_FALSE;
}
size=sizeof(UInt32);
maxFrames=8192; // This was calculated empirically. On MY system almost everything works more or less the same...
err = AudioUnitSetProperty(ao->theOutputUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Input, 0, &maxFrames, size);
if(err) {
ao_msg(MSGT_AO, MSGL_WARN, "Unable to set the maximum number of frames per slice!! (err=%d)\n", err);
return CONTROL_FALSE;
}
ao_msg(MSGT_AO, MSGL_DBG2, "Maximum number of frames per request %d (that is %d bytes)", err, maxFrames, maxFrames*inDesc.mBytesPerFrame);
ao->chunk_size = maxFrames*inDesc.mBytesPerFrame;
ao->num_chunks = NUM_BUFS;
ao->buffer_len = (ao->num_chunks + 1) * ao->chunk_size;
ao->buffer = aoIsCreated ? (unsigned char *)realloc(ao->buffer,(ao->num_chunks + 1)*ao->chunk_size)
: (unsigned char *)calloc(ao->num_chunks + 1, ao->chunk_size);
ao_data.samplerate = inDesc.mSampleRate;
ao_data.channels = inDesc.mChannelsPerFrame;
ao_data.outburst = ao_data.buffersize = ao->chunk_size;
ao_data.bps = ao_data.samplerate * inDesc.mBytesPerFrame;
memset(&renderCallback, 0, sizeof(AURenderCallbackStruct));
renderCallback.inputProc = theRenderProc;
renderCallback.inputProcRefCon = 0;
err = AudioUnitSetProperty(ao->theOutputUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &renderCallback, sizeof(AURenderCallbackStruct));
if (err) {
ao_msg(MSGT_AO, MSGL_WARN, "Unable to set the render callback (err=%d)\n", err);
return CONTROL_FALSE;
}
audio_pause();
ao->buf_read_pos=0;
ao->buf_write_pos=0;
return CONTROL_OK;
}
static int play(void* output_samples,int num_bytes,int flags)
{
audio_resume();
return write_buffer(output_samples, num_bytes);
}
/* set variables and buffer to initial state */
static void reset()
{
audio_pause();
/* reset ring-buffer state */
ao->buf_read_pos=0;
ao->buf_write_pos=0;
audio_resume();
return;
}
/* return available space */
static int get_space()
{
return buf_free();
}
/* return delay until audio is played */
static float get_delay()
{
int buffered = ao->buffer_len - ao->chunk_size - buf_free(); // could be less
// inaccurate, should also contain the data buffered e.g. by the OS
return (float)(buffered)/(float)ao_data.bps;
}
/* unload plugin and deregister from coreaudio */
static void uninit(int immed)
{
int i;
OSErr status;
reset();
AudioOutputUnitStop(ao->theOutputUnit);
AudioUnitUninitialize(ao->theOutputUnit);
CloseComponent(ao->theOutputUnit);
free(ao->buffer);
free(ao);
ao = NULL;
}
/* stop playing, keep buffers (for pause) */
static void audio_pause()
{
OSErr status=noErr;
/* stop callback */
status=AudioOutputUnitStop(ao->theOutputUnit);
if (status)
ao_msg(MSGT_AO,MSGL_WARN, "AudioOutputUnitStop returned %d\n",
(int)status);
}
/* resume playing, after audio_pause() */
static void audio_resume()
{
OSErr status=noErr;
status=AudioOutputUnitStart(ao->theOutputUnit);
if (status)
ao_msg(MSGT_AO,MSGL_WARN, "AudioOutputUnitStart returned %d\n",
(int)status);
}
|