1 /*
   2  * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 //#define USE_ERROR
  27 //#define USE_TRACE
  28 //#define USE_VERBOSE_TRACE
  29 
  30 #include <AudioUnit/AudioUnit.h>
  31 #include <CoreServices/CoreServices.h>
  32 #include <AudioToolbox/AudioConverter.h>
  33 #include <pthread.h>
  34 #include <math.h>
  35 /*
  36 #if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
  37 #include <CoreAudio/CoreAudioTypes.h>
  38 #else
  39 #include <CoreAudioTypes.h>
  40 #endif
  41 */
  42 
  43 #include "PLATFORM_API_MacOSX_Utils.h"
  44 
  45 extern "C" {
  46 #include "Utilities.h"
  47 #include "DirectAudio.h"
  48 }
  49 
  50 #if USE_DAUDIO == TRUE
  51 
  52 
  53 #ifdef USE_TRACE
  54 static void PrintStreamDesc(const AudioStreamBasicDescription *inDesc) {
  55     TRACE4("ID='%c%c%c%c'", (char)(inDesc->mFormatID >> 24), (char)(inDesc->mFormatID >> 16), (char)(inDesc->mFormatID >> 8), (char)(inDesc->mFormatID));
  56     TRACE2(", %f Hz, flags=0x%lX", (float)inDesc->mSampleRate, (long unsigned)inDesc->mFormatFlags);
  57     TRACE2(", %ld channels, %ld bits", (long)inDesc->mChannelsPerFrame, (long)inDesc->mBitsPerChannel);
  58     TRACE1(", %ld bytes per frame\n", (long)inDesc->mBytesPerFrame);
  59 }
  60 #else
  61 static inline void PrintStreamDesc(const AudioStreamBasicDescription *inDesc) { }
  62 #endif
  63 
  64 
  65 #define MAX(x, y)   ((x) >= (y) ? (x) : (y))
  66 #define MIN(x, y)   ((x) <= (y) ? (x) : (y))
  67 
  68 
  69 // =======================================
  70 // MixerProvider functions implementation
  71 
  72 static DeviceList deviceCache;
  73 
  74 INT32 DAUDIO_GetDirectAudioDeviceCount() {
  75     deviceCache.Refresh();
  76     int count = deviceCache.GetCount();
  77     if (count > 0) {
  78         // add "default" device
  79         count++;
  80         TRACE1("DAUDIO_GetDirectAudioDeviceCount: returns %d devices\n", count);
  81     } else {
  82         TRACE0("DAUDIO_GetDirectAudioDeviceCount: no devices found\n");
  83     }
  84     return count;
  85 }
  86 
  87 INT32 DAUDIO_GetDirectAudioDeviceDescription(INT32 mixerIndex, DirectAudioDeviceDescription *desc) {
  88     bool result = true;
  89     desc->deviceID = 0;
  90     if (mixerIndex == 0) {
  91         // default device
  92         strncpy(desc->name, "Default Audio Device", DAUDIO_STRING_LENGTH);
  93         strncpy(desc->description, "Default Audio Device", DAUDIO_STRING_LENGTH);
  94         desc->maxSimulLines = -1;
  95     } else {
  96         AudioDeviceID deviceID;
  97         result = deviceCache.GetDeviceInfo(mixerIndex-1, &deviceID, DAUDIO_STRING_LENGTH,
  98             desc->name, desc->vendor, desc->description, desc->version);
  99         if (result) {
 100             desc->deviceID = (INT32)deviceID;
 101             desc->maxSimulLines = -1;
 102         }
 103     }
 104     return result ? TRUE : FALSE;
 105 }
 106 
 107 
 108 void DAUDIO_GetFormats(INT32 mixerIndex, INT32 deviceID, int isSource, void* creator) {
 109     TRACE3(">>DAUDIO_GetFormats mixerIndex=%d deviceID=0x%x isSource=%d\n", (int)mixerIndex, (int)deviceID, isSource);
 110 
 111     AudioDeviceID audioDeviceID = deviceID == 0 ? GetDefaultDevice(isSource) : (AudioDeviceID)deviceID;
 112 
 113     if (audioDeviceID == 0) {
 114         return;
 115     }
 116 
 117     int totalChannels = GetChannelCount(audioDeviceID, isSource);
 118 
 119     if (totalChannels == 0) {
 120         TRACE0("<<DAUDIO_GetFormats, no streams!\n");
 121         return;
 122     }
 123 
 124     if (isSource && totalChannels < 2) {
 125         // report 2 channels even if only mono is supported
 126         totalChannels = 2;
 127     }
 128 
 129     int channels[] = {1, 2, totalChannels};
 130     int channelsCount = MIN(totalChannels, 3);
 131 
 132     float hardwareSampleRate = GetSampleRate(audioDeviceID, isSource);
 133     TRACE2("  DAUDIO_GetFormats: got %d channels, sampleRate == %f\n", totalChannels, hardwareSampleRate);
 134 
 135     // any sample rates are supported
 136     float sampleRate = -1;
 137 
 138     static int sampleBits[] = {8, 16, 24};
 139     static int sampleBitsCount = sizeof(sampleBits)/sizeof(sampleBits[0]);
 140 
 141     // the last audio format is the default one (used by DataLine.open() if format is not specified)
 142     // consider as default 16bit PCM stereo (mono is stereo is not supported) with the current sample rate
 143     int defBits = 16;
 144     int defChannels = MIN(2, channelsCount);
 145     float defSampleRate = hardwareSampleRate;
 146     // don't add default format is sample rate is not specified
 147     bool addDefault = defSampleRate > 0;
 148 
 149     // TODO: CoreAudio can handle signed/unsigned, little-endian/big-endian
 150     // TODO: register the formats (to prevent DirectAudio software conversion) - need to fix DirectAudioDevice.createDataLineInfo
 151     // to avoid software conversions if both signed/unsigned or big-/little-endian are supported
 152     for (int channelIndex = 0; channelIndex < channelsCount; channelIndex++) {
 153         for (int bitIndex = 0; bitIndex < sampleBitsCount; bitIndex++) {
 154             int bits = sampleBits[bitIndex];
 155             if (addDefault && bits == defBits && channels[channelIndex] != defChannels && sampleRate == defSampleRate) {
 156                 // the format is the default one, don't add it now
 157                 continue;
 158             }
 159             DAUDIO_AddAudioFormat(creator,
 160                 bits,                       // sample size in bits
 161                 -1,                         // frame size (auto)
 162                 channels[channelIndex],     // channels
 163                 sampleRate,                 // sample rate
 164                 DAUDIO_PCM,                 // only accept PCM
 165                 bits == 8 ? FALSE : TRUE,   // signed
 166                 bits == 8 ? FALSE           // little-endian for 8bit
 167                     : UTIL_IsBigEndianPlatform());
 168         }
 169     }
 170     // add default format
 171     if (addDefault) {
 172         DAUDIO_AddAudioFormat(creator,
 173             defBits,                        // 16 bits
 174             -1,                             // automatically calculate frame size
 175             defChannels,                    // channels
 176             defSampleRate,                  // sample rate
 177             DAUDIO_PCM,                     // PCM
 178             TRUE,                           // signed
 179             UTIL_IsBigEndianPlatform());    // native endianess
 180     }
 181 
 182     TRACE0("<<DAUDIO_GetFormats\n");
 183 }
 184 
 185 
 186 // =======================================
 187 // Source/Target DataLine functions implementation
 188 
 189 // ====
 190 /* 1writer-1reader ring buffer class with flush() support */
 191 class RingBuffer {
 192 public:
 193     RingBuffer() : pBuffer(NULL), nBufferSize(0) {
 194         pthread_mutex_init(&lockMutex, NULL);
 195     }
 196     ~RingBuffer() {
 197         Deallocate();
 198         pthread_mutex_destroy(&lockMutex);
 199     }
 200 
 201     // extraBytes: number of additionally allocated bytes to prevent data
 202     // overlapping when almost whole buffer is filled
 203     // (required only if Write() can override the buffer)
 204     bool Allocate(int requestedBufferSize, int extraBytes) {
 205         int fullBufferSize = requestedBufferSize + extraBytes;
 206         int powerOfTwo = 1;
 207         while (powerOfTwo < fullBufferSize) {
 208             powerOfTwo <<= 1;
 209         }
 210         pBuffer = (Byte*)malloc(powerOfTwo);
 211         if (pBuffer == NULL) {
 212             ERROR0("RingBuffer::Allocate: OUT OF MEMORY\n");
 213             return false;
 214         }
 215 
 216         nBufferSize = requestedBufferSize;
 217         nAllocatedBytes = powerOfTwo;
 218         nPosMask = powerOfTwo - 1;
 219         nWritePos = 0;
 220         nReadPos = 0;
 221         nFlushPos = -1;
 222 
 223         TRACE2("RingBuffer::Allocate: OK, bufferSize=%d, allocated:%d\n", nBufferSize, nAllocatedBytes);
 224         return true;
 225     }
 226 
 227     void Deallocate() {
 228         if (pBuffer) {
 229             free(pBuffer);
 230             pBuffer = NULL;
 231             nBufferSize = 0;
 232         }
 233     }
 234 
 235     inline int GetBufferSize() {
 236         return nBufferSize;
 237     }
 238 
 239     inline int GetAllocatedSize() {
 240         return nAllocatedBytes;
 241     }
 242 
 243     // gets number of bytes available for reading
 244     int GetValidByteCount() {
 245         lock();
 246         INT64 result = nWritePos - (nFlushPos >= 0 ? nFlushPos : nReadPos);
 247         unlock();
 248         return result > (INT64)nBufferSize ? nBufferSize : (int)result;
 249     }
 250 
 251     int Write(void *srcBuffer, int len, bool preventOverflow) {
 252         lock();
 253         TRACE2("RingBuffer::Write (%d bytes, preventOverflow=%d)\n", len, preventOverflow ? 1 : 0);
 254         TRACE2("  writePos = %lld (%d)", (long long)nWritePos, Pos2Offset(nWritePos));
 255         TRACE2("  readPos=%lld (%d)", (long long)nReadPos, Pos2Offset(nReadPos));
 256         TRACE2("  flushPos=%lld (%d)\n", (long long)nFlushPos, Pos2Offset(nFlushPos));
 257 
 258         INT64 writePos = nWritePos;
 259         if (preventOverflow) {
 260             INT64 avail_read = writePos - (nFlushPos >= 0 ? nFlushPos : nReadPos);
 261             if (avail_read >= (INT64)nBufferSize) {
 262                 // no space
 263                 TRACE0("  preventOverlow: OVERFLOW => len = 0;\n");
 264                 len = 0;
 265             } else {
 266                 int avail_write = nBufferSize - (int)avail_read;
 267                 if (len > avail_write) {
 268                     TRACE2("  preventOverlow: desrease len: %d => %d\n", len, avail_write);
 269                     len = avail_write;
 270                 }
 271             }
 272         }
 273         unlock();
 274 
 275         if (len > 0) {
 276 
 277             write((Byte *)srcBuffer, Pos2Offset(writePos), len);
 278 
 279             lock();
 280             TRACE4("--RingBuffer::Write writePos: %lld (%d) => %lld, (%d)\n",
 281                 (long long)nWritePos, Pos2Offset(nWritePos), (long long)nWritePos + len, Pos2Offset(nWritePos + len));
 282             nWritePos += len;
 283             unlock();
 284         }
 285         return len;
 286     }
 287 
 288     int Read(void *dstBuffer, int len) {
 289         lock();
 290         TRACE1("RingBuffer::Read (%d bytes)\n", len);
 291         TRACE2("  writePos = %lld (%d)", (long long)nWritePos, Pos2Offset(nWritePos));
 292         TRACE2("  readPos=%lld (%d)", (long long)nReadPos, Pos2Offset(nReadPos));
 293         TRACE2("  flushPos=%lld (%d)\n", (long long)nFlushPos, Pos2Offset(nFlushPos));
 294 
 295         applyFlush();
 296         INT64 avail_read = nWritePos - nReadPos;
 297         // check for overflow
 298         if (avail_read > (INT64)nBufferSize) {
 299             nReadPos = nWritePos - nBufferSize;
 300             avail_read = nBufferSize;
 301             TRACE0("  OVERFLOW\n");
 302         }
 303         INT64 readPos = nReadPos;
 304         unlock();
 305 
 306         if (len > (int)avail_read) {
 307             TRACE2("  RingBuffer::Read - don't have enough data, len: %d => %d\n", len, (int)avail_read);
 308             len = (int)avail_read;
 309         }
 310 
 311         if (len > 0) {
 312 
 313             read((Byte *)dstBuffer, Pos2Offset(readPos), len);
 314 
 315             lock();
 316             if (applyFlush()) {
 317                 // just got flush(), results became obsolete
 318                 TRACE0("--RingBuffer::Read, got Flush, return 0\n");
 319                 len = 0;
 320             } else {
 321                 TRACE4("--RingBuffer::Read readPos: %lld (%d) => %lld (%d)\n",
 322                     (long long)nReadPos, Pos2Offset(nReadPos), (long long)nReadPos + len, Pos2Offset(nReadPos + len));
 323                 nReadPos += len;
 324             }
 325             unlock();
 326         } else {
 327             // underrun!
 328         }
 329         return len;
 330     }
 331 
 332     // returns number of the flushed bytes
 333     int Flush() {
 334         lock();
 335         INT64 flushedBytes = nWritePos - (nFlushPos >= 0 ? nFlushPos : nReadPos);
 336         nFlushPos = nWritePos;
 337         unlock();
 338         return flushedBytes > (INT64)nBufferSize ? nBufferSize : (int)flushedBytes;
 339     }
 340 
 341 private:
 342     Byte *pBuffer;
 343     int nBufferSize;
 344     int nAllocatedBytes;
 345     INT64 nPosMask;
 346 
 347     pthread_mutex_t lockMutex;
 348 
 349     volatile INT64 nWritePos;
 350     volatile INT64 nReadPos;
 351     // Flush() sets nFlushPos value to nWritePos;
 352     // next Read() sets nReadPos to nFlushPos and resests nFlushPos to -1
 353     volatile INT64 nFlushPos;
 354 
 355     inline void lock() {
 356         pthread_mutex_lock(&lockMutex);
 357     }
 358     inline void unlock() {
 359         pthread_mutex_unlock(&lockMutex);
 360     }
 361 
 362     inline bool applyFlush() {
 363         if (nFlushPos >= 0) {
 364             nReadPos = nFlushPos;
 365             nFlushPos = -1;
 366             return true;
 367         }
 368         return false;
 369     }
 370 
 371     inline int Pos2Offset(INT64 pos) {
 372         return (int)(pos & nPosMask);
 373     }
 374 
 375     void write(Byte *srcBuffer, int dstOffset, int len) {
 376         int dstEndOffset = dstOffset + len;
 377 
 378         int lenAfterWrap = dstEndOffset - nAllocatedBytes;
 379         if (lenAfterWrap > 0) {
 380             // dest.buffer does wrap
 381             len = nAllocatedBytes - dstOffset;
 382             memcpy(pBuffer+dstOffset, srcBuffer, len);
 383             memcpy(pBuffer, srcBuffer+len, lenAfterWrap);
 384         } else {
 385             // dest.buffer does not wrap
 386             memcpy(pBuffer+dstOffset, srcBuffer, len);
 387         }
 388     }
 389 
 390     void read(Byte *dstBuffer, int srcOffset, int len) {
 391         int srcEndOffset = srcOffset + len;
 392 
 393         int lenAfterWrap = srcEndOffset - nAllocatedBytes;
 394         if (lenAfterWrap > 0) {
 395             // need to unwrap data
 396             len = nAllocatedBytes - srcOffset;
 397             memcpy(dstBuffer, pBuffer+srcOffset, len);
 398             memcpy(dstBuffer+len, pBuffer, lenAfterWrap);
 399         } else {
 400             // source buffer is not wrapped
 401             memcpy(dstBuffer, pBuffer+srcOffset, len);
 402         }
 403     }
 404 };
 405 
 406 
 407 class Resampler {
 408 private:
 409     enum {
 410         kResamplerEndOfInputData = 1 // error to interrupt conversion (end of input data)
 411     };
 412 public:
 413     Resampler() : converter(NULL), outBuffer(NULL) { }
 414     ~Resampler() {
 415         if (converter != NULL) {
 416             AudioConverterDispose(converter);
 417         }
 418         if (outBuffer != NULL) {
 419             free(outBuffer);
 420         }
 421     }
 422 
 423     // inFormat & outFormat must be interleaved!
 424     bool Init(const AudioStreamBasicDescription *inFormat, const AudioStreamBasicDescription *outFormat,
 425             int inputBufferSizeInBytes)
 426     {
 427         TRACE0(">>Resampler::Init\n");
 428         TRACE0("  inFormat: ");
 429         PrintStreamDesc(inFormat);
 430         TRACE0("  outFormat: ");
 431         PrintStreamDesc(outFormat);
 432         TRACE1("  inputBufferSize: %d bytes\n", inputBufferSizeInBytes);
 433         OSStatus err;
 434 
 435         if ((outFormat->mFormatFlags & kAudioFormatFlagIsNonInterleaved) != 0 && outFormat->mChannelsPerFrame != 1) {
 436             ERROR0("Resampler::Init ERROR: outFormat is non-interleaved\n");
 437             return false;
 438         }
 439         if ((inFormat->mFormatFlags & kAudioFormatFlagIsNonInterleaved) != 0 && inFormat->mChannelsPerFrame != 1) {
 440             ERROR0("Resampler::Init ERROR: inFormat is non-interleaved\n");
 441             return false;
 442         }
 443 
 444         memcpy(&asbdIn, inFormat, sizeof(AudioStreamBasicDescription));
 445         memcpy(&asbdOut, outFormat, sizeof(AudioStreamBasicDescription));
 446 
 447         err = AudioConverterNew(inFormat, outFormat, &converter);
 448 
 449         if (err || converter == NULL) {
 450             OS_ERROR1(err, "Resampler::Init (AudioConverterNew), converter=%p", converter);
 451             return false;
 452         }
 453 
 454         // allocate buffer for output data
 455         int maximumInFrames = inputBufferSizeInBytes / inFormat->mBytesPerFrame;
 456         // take into account trailingFrames
 457         AudioConverterPrimeInfo primeInfo = {0, 0};
 458         UInt32 sizePrime = sizeof(primeInfo);
 459         err = AudioConverterGetProperty(converter, kAudioConverterPrimeInfo, &sizePrime, &primeInfo);
 460         if (err) {
 461             OS_ERROR0(err, "Resampler::Init (get kAudioConverterPrimeInfo)");
 462             // ignore the error
 463         } else {
 464             // the default primeMethod is kConverterPrimeMethod_Normal, so we need only trailingFrames
 465             maximumInFrames += primeInfo.trailingFrames;
 466         }
 467         float outBufferSizeInFrames = (outFormat->mSampleRate / inFormat->mSampleRate) * ((float)maximumInFrames);
 468         // to avoid complex calculation just set outBufferSize as double of the calculated value
 469         outBufferSize = (int)outBufferSizeInFrames * outFormat->mBytesPerFrame * 2;
 470         // safety check - consider 256 frame as the minimum input buffer
 471         int minOutSize = 256 * outFormat->mBytesPerFrame;
 472         if (outBufferSize < minOutSize) {
 473             outBufferSize = minOutSize;
 474         }
 475 
 476         outBuffer = malloc(outBufferSize);
 477 
 478         if (outBuffer == NULL) {
 479             ERROR1("Resampler::Init ERROR: malloc failed (%d bytes)\n", outBufferSize);
 480             AudioConverterDispose(converter);
 481             converter = NULL;
 482             return false;
 483         }
 484 
 485         TRACE1("  allocated: %d bytes for output buffer\n", outBufferSize);
 486 
 487         TRACE0("<<Resampler::Init: OK\n");
 488         return true;
 489     }
 490 
 491     // returns size of the internal output buffer
 492     int GetOutBufferSize() {
 493         return outBufferSize;
 494     }
 495 
 496     // process next part of data (writes resampled data to the ringBuffer without overflow check)
 497     int Process(void *srcBuffer, int len, RingBuffer *ringBuffer) {
 498         int bytesWritten = 0;
 499         TRACE2(">>Resampler::Process: %d bytes, converter = %p\n", len, converter);
 500         if (converter == NULL) {    // sanity check
 501             bytesWritten = ringBuffer->Write(srcBuffer, len, false);
 502         } else {
 503             InputProcData data;
 504             data.pThis = this;
 505             data.data = (Byte *)srcBuffer;
 506             data.dataSize = len;
 507 
 508             OSStatus err;
 509             do {
 510                 AudioBufferList abl;    // by default it contains 1 AudioBuffer
 511                 abl.mNumberBuffers = 1;
 512                 abl.mBuffers[0].mNumberChannels = asbdOut.mChannelsPerFrame;
 513                 abl.mBuffers[0].mDataByteSize   = outBufferSize;
 514                 abl.mBuffers[0].mData           = outBuffer;
 515 
 516                 UInt32 packets = (UInt32)outBufferSize / asbdOut.mBytesPerPacket;
 517 
 518                 TRACE2(">>AudioConverterFillComplexBuffer: request %d packets, provide %d bytes buffer\n",
 519                     (int)packets, (int)abl.mBuffers[0].mDataByteSize);
 520 
 521                 err = AudioConverterFillComplexBuffer(converter, ConverterInputProc, &data, &packets, &abl, NULL);
 522 
 523                 TRACE2("<<AudioConverterFillComplexBuffer: got %d packets (%d bytes)\n",
 524                     (int)packets, (int)abl.mBuffers[0].mDataByteSize);
 525                 if (packets > 0) {
 526                     int bytesToWrite = (int)(packets * asbdOut.mBytesPerPacket);
 527                     bytesWritten += ringBuffer->Write(abl.mBuffers[0].mData, bytesToWrite, false);
 528                 }
 529 
 530                 // if outputBuffer is small to store all available frames,
 531                 // we get noErr here. In the case just continue the conversion
 532             } while (err == noErr);
 533 
 534             if (err != kResamplerEndOfInputData) {
 535                 // unexpected error
 536                 OS_ERROR0(err, "Resampler::Process (AudioConverterFillComplexBuffer)");
 537             }
 538         }
 539         TRACE2("<<Resampler::Process: written %d bytes (converted from %d bytes)\n", bytesWritten, len);
 540 
 541         return bytesWritten;
 542     }
 543 
 544     // resets internal bufferes
 545     void Discontinue() {
 546         TRACE0(">>Resampler::Discontinue\n");
 547         if (converter != NULL) {
 548             AudioConverterReset(converter);
 549         }
 550         TRACE0("<<Resampler::Discontinue\n");
 551     }
 552 
 553 private:
 554     AudioConverterRef converter;
 555 
 556     // buffer for output data
 557     // note that there is no problem if the buffer is not big enough to store
 558     // all converted data - it's only performance issue
 559     void *outBuffer;
 560     int outBufferSize;
 561 
 562     AudioStreamBasicDescription asbdIn;
 563     AudioStreamBasicDescription asbdOut;
 564 
 565     struct InputProcData {
 566         Resampler *pThis;
 567         Byte *data;     // data == NULL means we handle Discontinue(false)
 568         int dataSize;   // == 0 if all data was already provided to the converted of we handle Discontinue(false)
 569     };
 570 
 571     static OSStatus ConverterInputProc(AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets,
 572             AudioBufferList *ioData, AudioStreamPacketDescription **outDataPacketDescription, void *inUserData)
 573     {
 574         InputProcData *data = (InputProcData *)inUserData;
 575 
 576         TRACE3("  >>ConverterInputProc: requested %d packets, data contains %d bytes (%d packets)\n",
 577             (int)*ioNumberDataPackets, (int)data->dataSize, (int)(data->dataSize / data->pThis->asbdIn.mBytesPerPacket));
 578         if (data->dataSize == 0) {
 579             // already called & provided all input data
 580             // interrupt conversion by returning error
 581             *ioNumberDataPackets = 0;
 582             TRACE0("  <<ConverterInputProc: returns kResamplerEndOfInputData\n");
 583             return kResamplerEndOfInputData;
 584         }
 585 
 586         ioData->mNumberBuffers = 1;
 587         ioData->mBuffers[0].mNumberChannels = data->pThis->asbdIn.mChannelsPerFrame;
 588         ioData->mBuffers[0].mDataByteSize   = data->dataSize;
 589         ioData->mBuffers[0].mData           = data->data;
 590 
 591         *ioNumberDataPackets = data->dataSize / data->pThis->asbdIn.mBytesPerPacket;
 592 
 593         // all data has been provided to the converter
 594         data->dataSize = 0;
 595 
 596         TRACE1("  <<ConverterInputProc: returns %d packets\n", (int)(*ioNumberDataPackets));
 597         return noErr;
 598     }
 599 
 600 };
 601 
 602 
 603 struct OSX_DirectAudioDevice {
 604     AudioUnit   audioUnit;
 605     RingBuffer  ringBuffer;
 606     AudioStreamBasicDescription asbd;
 607 
 608     // only for target lines
 609     UInt32      inputBufferSizeInBytes;
 610     Resampler   *resampler;
 611     // to detect discontinuity (to reset resampler)
 612     SInt64      lastWrittenSampleTime;
 613 
 614 
 615     OSX_DirectAudioDevice() : audioUnit(NULL), asbd(), resampler(NULL), lastWrittenSampleTime(0) {
 616     }
 617 
 618     ~OSX_DirectAudioDevice() {
 619         if (audioUnit) {
 620             CloseComponent(audioUnit);
 621         }
 622         if (resampler) {
 623             delete resampler;
 624         }
 625     }
 626 };
 627 
 628 static AudioUnit CreateOutputUnit(AudioDeviceID deviceID, int isSource)
 629 {
 630     OSStatus err;
 631     AudioUnit unit;
 632     UInt32 size;
 633 
 634     ComponentDescription desc;
 635     desc.componentType         = kAudioUnitType_Output;
 636     desc.componentSubType      = (deviceID == 0 && isSource) ? kAudioUnitSubType_DefaultOutput : kAudioUnitSubType_HALOutput;
 637     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 638     desc.componentFlags        = 0;
 639     desc.componentFlagsMask    = 0;
 640 
 641     Component comp = FindNextComponent(NULL, &desc);
 642     err = OpenAComponent(comp, &unit);
 643 
 644     if (err) {
 645         OS_ERROR0(err, "CreateOutputUnit:OpenAComponent");
 646         return NULL;
 647     }
 648 
 649     if (!isSource) {
 650         int enableIO = 0;
 651         err = AudioUnitSetProperty(unit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output,
 652                                     0, &enableIO, sizeof(enableIO));
 653         if (err) {
 654             OS_ERROR0(err, "SetProperty (output EnableIO)");
 655         }
 656         enableIO = 1;
 657         err = AudioUnitSetProperty(unit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input,
 658                                     1, &enableIO, sizeof(enableIO));
 659         if (err) {
 660             OS_ERROR0(err, "SetProperty (input EnableIO)");
 661         }
 662 
 663         if (!deviceID) {
 664             // get real AudioDeviceID for default input device (macosx current input device)
 665             deviceID = GetDefaultDevice(isSource);
 666             if (!deviceID) {
 667                 CloseComponent(unit);
 668                 return NULL;
 669             }
 670         }
 671     }
 672 
 673     if (deviceID) {
 674         err = AudioUnitSetProperty(unit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global,
 675                                     0, &deviceID, sizeof(deviceID));
 676         if (err) {
 677             OS_ERROR0(err, "SetProperty (CurrentDevice)");
 678             CloseComponent(unit);
 679             return NULL;
 680         }
 681     }
 682 
 683     return unit;
 684 }
 685 
 686 static OSStatus OutputCallback(void                         *inRefCon,
 687                                AudioUnitRenderActionFlags   *ioActionFlags,
 688                                const AudioTimeStamp         *inTimeStamp,
 689                                UInt32                       inBusNumber,
 690                                UInt32                       inNumberFrames,
 691                                AudioBufferList              *ioData)
 692 {
 693     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)inRefCon;
 694 
 695     int nchannels = ioData->mNumberBuffers; // should be always == 1 (interleaved channels)
 696     AudioBuffer *audioBuffer = ioData->mBuffers;
 697 
 698     TRACE3(">>OutputCallback: busNum=%d, requested %d frames (%d bytes)\n",
 699         (int)inBusNumber, (int)inNumberFrames, (int)(inNumberFrames * device->asbd.mBytesPerFrame));
 700     TRACE3("  abl: %d buffers, buffer[0].channels=%d, buffer.size=%d\n",
 701         nchannels, (int)audioBuffer->mNumberChannels, (int)audioBuffer->mDataByteSize);
 702 
 703     int bytesToRead = inNumberFrames * device->asbd.mBytesPerFrame;
 704     if (bytesToRead > (int)audioBuffer->mDataByteSize) {
 705         TRACE0("--OutputCallback: !!! audioBuffer IS TOO SMALL!!!\n");
 706         bytesToRead = audioBuffer->mDataByteSize / device->asbd.mBytesPerFrame * device->asbd.mBytesPerFrame;
 707     }
 708     int bytesRead = device->ringBuffer.Read(audioBuffer->mData, bytesToRead);
 709     if (bytesRead < bytesToRead) {
 710         // no enough data (underrun)
 711         TRACE2("--OutputCallback: !!! UNDERRUN (read %d bytes of %d)!!!\n", bytesRead, bytesToRead);
 712         // silence the rest
 713         memset((Byte*)audioBuffer->mData + bytesRead, 0, bytesToRead-bytesRead);
 714         bytesRead = bytesToRead;
 715     }
 716 
 717     audioBuffer->mDataByteSize = (UInt32)bytesRead;
 718     // SAFETY: set mDataByteSize for all other AudioBuffer in the AudioBufferList to zero
 719     while (--nchannels > 0) {
 720         audioBuffer++;
 721         audioBuffer->mDataByteSize = 0;
 722     }
 723     TRACE1("<<OutputCallback (returns %d)\n", bytesRead);
 724 
 725     return noErr;
 726 }
 727 
 728 static OSStatus InputCallback(void                          *inRefCon,
 729                               AudioUnitRenderActionFlags    *ioActionFlags,
 730                               const AudioTimeStamp          *inTimeStamp,
 731                               UInt32                        inBusNumber,
 732                               UInt32                        inNumberFrames,
 733                               AudioBufferList               *ioData)
 734 {
 735     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)inRefCon;
 736 
 737     TRACE4(">>InputCallback: busNum=%d, timeStamp=%lld, %d frames (%d bytes)\n",
 738         (int)inBusNumber, (long long)inTimeStamp->mSampleTime, (int)inNumberFrames, (int)(inNumberFrames * device->asbd.mBytesPerFrame));
 739 
 740     AudioBufferList abl;    // by default it contains 1 AudioBuffer
 741     abl.mNumberBuffers = 1;
 742     abl.mBuffers[0].mNumberChannels = device->asbd.mChannelsPerFrame;
 743     abl.mBuffers[0].mDataByteSize   = device->inputBufferSizeInBytes;   // assume this is == (inNumberFrames * device->asbd.mBytesPerFrame)
 744     abl.mBuffers[0].mData           = NULL;     // request for the audioUnit's buffer
 745 
 746     OSStatus err = AudioUnitRender(device->audioUnit, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, &abl);
 747     if (err) {
 748         OS_ERROR0(err, "<<InputCallback: AudioUnitRender");
 749     } else {
 750         if (device->resampler != NULL) {
 751             // test for discontinuity
 752             // AUHAL starts timestamps at zero, so test if the current timestamp less then the last written
 753             SInt64 sampleTime = inTimeStamp->mSampleTime;
 754             if (sampleTime < device->lastWrittenSampleTime) {
 755                 // discontinuity, reset the resampler
 756                 TRACE2("  InputCallback (RESAMPLED), DISCONTINUITY (%f -> %f)\n",
 757                     (float)device->lastWrittenSampleTime, (float)sampleTime);
 758 
 759                 device->resampler->Discontinue();
 760             } else {
 761                 TRACE2("  InputCallback (RESAMPLED), continuous: lastWrittenSampleTime = %f, sampleTime=%f\n",
 762                     (float)device->lastWrittenSampleTime, (float)sampleTime);
 763             }
 764             device->lastWrittenSampleTime = sampleTime + inNumberFrames;
 765 
 766             int bytesWritten = device->resampler->Process(abl.mBuffers[0].mData, (int)abl.mBuffers[0].mDataByteSize, &device->ringBuffer);
 767             TRACE2("<<InputCallback (RESAMPLED, saved %d bytes of %d)\n", bytesWritten, (int)abl.mBuffers[0].mDataByteSize);
 768         } else {
 769             int bytesWritten = device->ringBuffer.Write(abl.mBuffers[0].mData, (int)abl.mBuffers[0].mDataByteSize, false);
 770             TRACE2("<<InputCallback (saved %d bytes of %d)\n", bytesWritten, (int)abl.mBuffers[0].mDataByteSize);
 771         }
 772     }
 773 
 774     return noErr;
 775 }
 776 
 777 
 778 static void FillASBDForNonInterleavedPCM(AudioStreamBasicDescription& asbd,
 779     float sampleRate, int channels, int sampleSizeInBits, bool isFloat, int isSigned, bool isBigEndian)
 780 {
 781     // FillOutASBDForLPCM cannot produce unsigned integer format
 782     asbd.mSampleRate = sampleRate;
 783     asbd.mFormatID = kAudioFormatLinearPCM;
 784     asbd.mFormatFlags = (isFloat ? kAudioFormatFlagIsFloat : (isSigned ? kAudioFormatFlagIsSignedInteger : 0))
 785         | (isBigEndian ? (kAudioFormatFlagIsBigEndian) : 0)
 786         | kAudioFormatFlagIsPacked;
 787     asbd.mBytesPerPacket = channels * ((sampleSizeInBits + 7) / 8);
 788     asbd.mFramesPerPacket = 1;
 789     asbd.mBytesPerFrame = asbd.mBytesPerPacket;
 790     asbd.mChannelsPerFrame = channels;
 791     asbd.mBitsPerChannel = sampleSizeInBits;
 792 }
 793 
 794 void* DAUDIO_Open(INT32 mixerIndex, INT32 deviceID, int isSource,
 795                   int encoding, float sampleRate, int sampleSizeInBits,
 796                   int frameSize, int channels,
 797                   int isSigned, int isBigEndian, int bufferSizeInBytes)
 798 {
 799     TRACE3(">>DAUDIO_Open: mixerIndex=%d deviceID=0x%x isSource=%d\n", (int)mixerIndex, (unsigned int)deviceID, isSource);
 800     TRACE3("  sampleRate=%d sampleSizeInBits=%d channels=%d\n", (int)sampleRate, sampleSizeInBits, channels);
 801 #ifdef USE_TRACE
 802     {
 803         AudioDeviceID audioDeviceID = deviceID;
 804         if (audioDeviceID == 0) {
 805             // default device
 806             audioDeviceID = GetDefaultDevice(isSource);
 807         }
 808         char name[256];
 809         OSStatus err = GetAudioObjectProperty(audioDeviceID, kAudioUnitScope_Global, kAudioDevicePropertyDeviceName, 256, &name, 0);
 810         if (err != noErr) {
 811             OS_ERROR1(err, "  audioDeviceID=0x%x, name is N/A:", (int)audioDeviceID);
 812         } else {
 813             TRACE2("  audioDeviceID=0x%x, name=%s\n", (int)audioDeviceID, name);
 814         }
 815     }
 816 #endif
 817 
 818     if (encoding != DAUDIO_PCM) {
 819         ERROR1("<<DAUDIO_Open: ERROR: unsupported encoding (%d)\n", encoding);
 820         return NULL;
 821     }
 822 
 823     OSX_DirectAudioDevice *device = new OSX_DirectAudioDevice();
 824 
 825     AudioUnitScope scope = isSource ? kAudioUnitScope_Input : kAudioUnitScope_Output;
 826     int element = isSource ? 0 : 1;
 827     OSStatus err = noErr;
 828     int extraBufferBytes = 0;
 829 
 830     device->audioUnit = CreateOutputUnit(deviceID, isSource);
 831 
 832     if (!device->audioUnit) {
 833         delete device;
 834         return NULL;
 835     }
 836 
 837     if (!isSource) {
 838         AudioDeviceID actualDeviceID = deviceID != 0 ? deviceID : GetDefaultDevice(isSource);
 839         float hardwareSampleRate = GetSampleRate(actualDeviceID, isSource);
 840         TRACE2("--DAUDIO_Open: sampleRate = %f, hardwareSampleRate=%f\n", sampleRate, hardwareSampleRate);
 841 
 842         if (fabs(sampleRate - hardwareSampleRate) > 1) {
 843             device->resampler = new Resampler();
 844 
 845             // request HAL for Float32 with native endianess
 846             FillASBDForNonInterleavedPCM(device->asbd, hardwareSampleRate, channels, 32, true, false, kAudioFormatFlagsNativeEndian != 0);
 847         } else {
 848             sampleRate = hardwareSampleRate;    // in case sample rates are not exactly equal
 849         }
 850     }
 851 
 852     if (device->resampler == NULL) {
 853         // no resampling, request HAL for the requested format
 854         FillASBDForNonInterleavedPCM(device->asbd, sampleRate, channels, sampleSizeInBits, false, isSigned, isBigEndian);
 855     }
 856 
 857     err = AudioUnitSetProperty(device->audioUnit, kAudioUnitProperty_StreamFormat, scope, element, &device->asbd, sizeof(device->asbd));
 858     if (err) {
 859         OS_ERROR0(err, "<<DAUDIO_Open set StreamFormat");
 860         delete device;
 861         return NULL;
 862     }
 863 
 864     AURenderCallbackStruct output;
 865     output.inputProc       = isSource ? OutputCallback : InputCallback;
 866     output.inputProcRefCon = device;
 867 
 868     err = AudioUnitSetProperty(device->audioUnit,
 869                                 isSource
 870                                     ? (AudioUnitPropertyID)kAudioUnitProperty_SetRenderCallback
 871                                     : (AudioUnitPropertyID)kAudioOutputUnitProperty_SetInputCallback,
 872                                 kAudioUnitScope_Global, 0, &output, sizeof(output));
 873     if (err) {
 874         OS_ERROR0(err, "<<DAUDIO_Open set RenderCallback");
 875         delete device;
 876         return NULL;
 877     }
 878 
 879     err = AudioUnitInitialize(device->audioUnit);
 880     if (err) {
 881         OS_ERROR0(err, "<<DAUDIO_Open UnitInitialize");
 882         delete device;
 883         return NULL;
 884     }
 885 
 886     if (!isSource) {
 887         // for target lines we need extra bytes in the ringBuffer
 888         // to prevent collisions when InputCallback overrides data on overflow
 889         UInt32 size;
 890         OSStatus err;
 891 
 892         size = sizeof(device->inputBufferSizeInBytes);
 893         err  = AudioUnitGetProperty(device->audioUnit, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Global,
 894                                     0, &device->inputBufferSizeInBytes, &size);
 895         if (err) {
 896             OS_ERROR0(err, "<<DAUDIO_Open (TargetDataLine)GetBufferSize\n");
 897             delete device;
 898             return NULL;
 899         }
 900         device->inputBufferSizeInBytes *= device->asbd.mBytesPerFrame;  // convert frames to bytes
 901         extraBufferBytes = (int)device->inputBufferSizeInBytes;
 902     }
 903 
 904     if (device->resampler != NULL) {
 905         // resampler output format is a user requested format (== ringBuffer format)
 906         AudioStreamBasicDescription asbdOut; // ringBuffer format
 907         FillASBDForNonInterleavedPCM(asbdOut, sampleRate, channels, sampleSizeInBits, false, isSigned, isBigEndian);
 908 
 909         // set resampler input buffer size to the HAL buffer size
 910         if (!device->resampler->Init(&device->asbd, &asbdOut, (int)device->inputBufferSizeInBytes)) {
 911             ERROR0("<<DAUDIO_Open: resampler.Init() FAILED.\n");
 912             delete device;
 913             return NULL;
 914         }
 915         // extra bytes in the ringBuffer (extraBufferBytes) should be equal resampler output buffer size
 916         extraBufferBytes = device->resampler->GetOutBufferSize();
 917     }
 918 
 919     if (!device->ringBuffer.Allocate(bufferSizeInBytes, extraBufferBytes)) {
 920         ERROR0("<<DAUDIO_Open: Ring buffer allocation error\n");
 921         delete device;
 922         return NULL;
 923     }
 924 
 925     TRACE0("<<DAUDIO_Open: OK\n");
 926     return device;
 927 }
 928 
 929 int DAUDIO_Start(void* id, int isSource) {
 930     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 931     TRACE0("DAUDIO_Start\n");
 932 
 933     OSStatus err = AudioOutputUnitStart(device->audioUnit);
 934 
 935     if (err != noErr) {
 936         OS_ERROR0(err, "DAUDIO_Start");
 937     }
 938 
 939     return err == noErr ? TRUE : FALSE;
 940 }
 941 
 942 int DAUDIO_Stop(void* id, int isSource) {
 943     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 944     TRACE0("DAUDIO_Stop\n");
 945 
 946     OSStatus err = AudioOutputUnitStop(device->audioUnit);
 947 
 948     return err == noErr ? TRUE : FALSE;
 949 }
 950 
 951 void DAUDIO_Close(void* id, int isSource) {
 952     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 953     TRACE0("DAUDIO_Close\n");
 954 
 955     delete device;
 956 }
 957 
 958 int DAUDIO_Write(void* id, char* data, int byteSize) {
 959     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 960     TRACE1(">>DAUDIO_Write: %d bytes to write\n", byteSize);
 961 
 962     int result = device->ringBuffer.Write(data, byteSize, true);
 963 
 964     TRACE1("<<DAUDIO_Write: %d bytes written\n", result);
 965     return result;
 966 }
 967 
 968 int DAUDIO_Read(void* id, char* data, int byteSize) {
 969     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 970     TRACE1(">>DAUDIO_Read: %d bytes to read\n", byteSize);
 971 
 972     int result = device->ringBuffer.Read(data, byteSize);
 973 
 974     TRACE1("<<DAUDIO_Read: %d bytes has been read\n", result);
 975     return result;
 976 }
 977 
 978 int DAUDIO_GetBufferSize(void* id, int isSource) {
 979     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 980 
 981     int bufferSizeInBytes = device->ringBuffer.GetBufferSize();
 982 
 983     TRACE1("DAUDIO_GetBufferSize returns %d\n", bufferSizeInBytes);
 984     return bufferSizeInBytes;
 985 }
 986 
 987 int DAUDIO_StillDraining(void* id, int isSource) {
 988     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 989 
 990     int draining = device->ringBuffer.GetValidByteCount() > 0 ? TRUE : FALSE;
 991 
 992     TRACE1("DAUDIO_StillDraining returns %d\n", draining);
 993     return draining;
 994 }
 995 
 996 int DAUDIO_Flush(void* id, int isSource) {
 997     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
 998     TRACE0("DAUDIO_Flush\n");
 999 
1000     device->ringBuffer.Flush();
1001 
1002     return TRUE;
1003 }
1004 
1005 int DAUDIO_GetAvailable(void* id, int isSource) {
1006     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
1007 
1008     int bytesInBuffer = device->ringBuffer.GetValidByteCount();
1009     if (isSource) {
1010         return device->ringBuffer.GetBufferSize() - bytesInBuffer;
1011     } else {
1012         return bytesInBuffer;
1013     }
1014 }
1015 
1016 INT64 DAUDIO_GetBytePosition(void* id, int isSource, INT64 javaBytePos) {
1017     OSX_DirectAudioDevice *device = (OSX_DirectAudioDevice*)id;
1018     INT64 position;
1019 
1020     if (isSource) {
1021         position = javaBytePos - device->ringBuffer.GetValidByteCount();
1022     } else {
1023         position = javaBytePos + device->ringBuffer.GetValidByteCount();
1024     }
1025 
1026     TRACE2("DAUDIO_GetBytePosition returns %lld (javaBytePos = %lld)\n", (long long)position, (long long)javaBytePos);
1027     return position;
1028 }
1029 
1030 void DAUDIO_SetBytePosition(void* id, int isSource, INT64 javaBytePos) {
1031     // no need javaBytePos (it's available in DAUDIO_GetBytePosition)
1032 }
1033 
1034 int DAUDIO_RequiresServicing(void* id, int isSource) {
1035     return FALSE;
1036 }
1037 
1038 void DAUDIO_Service(void* id, int isSource) {
1039     // unreachable
1040 }
1041 
1042 #endif  // USE_DAUDIO == TRUE
--- EOF ---