dlls/winecoreaudio.drv/audio.c

   1 /*
   2  * Wine Driver for CoreAudio based on Jack Driver
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1999 Eric Pouech (async playing in waveOut/waveIn)
   6  * Copyright 2000 Eric Pouech (loops in waveOut)
   7  * Copyright 2002 Chris Morgan (jack version of this file)
   8  * Copyright 2005, 2006 Emmanuel Maillard
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #ifdef HAVE_UNISTD_H
  32 # include <unistd.h>
  33 #endif
  34 #include <fcntl.h>
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winnls.h"
  39 #include "wingdi.h"
  40 #include "winerror.h"
  41 #include "mmddk.h"
  42 #include "dsound.h"
  43 #include "dsdriver.h"
  44 #include "coreaudio.h"
  45 #include "wine/unicode.h"
  46 #include "wine/library.h"
  47 #include "wine/debug.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(wave);
  50
  51
  52 #if defined(HAVE_COREAUDIO_COREAUDIO_H) && defined(HAVE_AUDIOUNIT_AUDIOUNIT_H)
  53 #include <CoreAudio/CoreAudio.h>
  54 #include <CoreFoundation/CoreFoundation.h>
  55 #include <libkern/OSAtomic.h>
  56
  57 /*
  58     Due to AudioUnit headers conflict define some needed types.
  59 */
  60
  61 typedef void *AudioUnit;
  62
  63 /* From AudioUnit/AUComponents.h */
  64 enum
  65 {
  66     kAudioUnitRenderAction_OutputIsSilence  = (1 << 4),
  67         /* provides hint on return from Render(): if set the buffer contains all zeroes */
  68 };
  69 typedef UInt32 AudioUnitRenderActionFlags;
  70
  71 typedef long ComponentResult;
  72 extern ComponentResult
  73 AudioUnitRender(                    AudioUnit                       ci,
  74                                     AudioUnitRenderActionFlags *    ioActionFlags,
  75                                     const AudioTimeStamp *          inTimeStamp,
  76                                     UInt32                          inOutputBusNumber,
  77                                     UInt32                          inNumberFrames,
  78                                     AudioBufferList *               ioData)         AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER;
  79
  80 /* only allow 10 output devices through this driver, this ought to be adequate */
  81 #define MAX_WAVEOUTDRV  (1)
  82 #define MAX_WAVEINDRV   (1)
  83
  84 /* state diagram for waveOut writing:
  85 *
  86 * +---------+-------------+---------------+---------------------------------+
  87 * |  state  |  function   |     event     |            new state             |
  88 * +---------+-------------+---------------+---------------------------------+
  89 * |          | open()      |               | STOPPED                         |
  90 * | PAUSED  | write()      |               | PAUSED                          |
  91 * | STOPPED | write()      | <thrd create> | PLAYING                         |
  92 * | PLAYING | write()      | HEADER        | PLAYING                         |
  93 * | (other) | write()      | <error>       |                                 |
  94 * | (any)   | pause()      | PAUSING       | PAUSED                          |
  95 * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
  96 * | (any)   | reset()      | RESETTING     | STOPPED                         |
  97 * | (any)   | close()      | CLOSING       | CLOSED                          |
  98 * +---------+-------------+---------------+---------------------------------+
  99 */
 100
 101 /* states of the playing device */
 102 #define WINE_WS_PLAYING   0
 103 #define WINE_WS_PAUSED    1
 104 #define WINE_WS_STOPPED   2
 105 #define WINE_WS_CLOSED    3
 106
 107 typedef struct tagCoreAudio_Device {
 108     char                        dev_name[32];
 109     char                        mixer_name[32];
 110     unsigned                    open_count;
 111     char*                       interface_name;
 112
 113     WAVEOUTCAPSW                out_caps;
 114     WAVEINCAPSW                 in_caps;
 115     DWORD                       in_caps_support;
 116     int                         sample_rate;
 117     int                         stereo;
 118     int                         format;
 119     unsigned                    audio_fragment;
 120     BOOL                        full_duplex;
 121     BOOL                        bTriggerSupport;
 122     BOOL                        bOutputEnabled;
 123     BOOL                        bInputEnabled;
 124     DSDRIVERDESC                ds_desc;
 125     DSDRIVERCAPS                ds_caps;
 126     DSCDRIVERCAPS               dsc_caps;
 127     GUID                        ds_guid;
 128     GUID                        dsc_guid;
 129
 130     AudioDeviceID outputDeviceID;
 131     AudioDeviceID inputDeviceID;
 132     AudioStreamBasicDescription streamDescription;
 133 } CoreAudio_Device;
 134
 135 /* for now use the default device */
 136 static CoreAudio_Device CoreAudio_DefaultDevice;
 137
 138 typedef struct {
 139     volatile int                state;      /* one of the WINE_WS_ manifest constants */
 140     CoreAudio_Device            *cadev;
 141     WAVEOPENDESC                waveDesc;
 142     WORD                        wFlags;
 143     PCMWAVEFORMAT               format;
 144     DWORD                       woID;
 145     AudioUnit                   audioUnit;
 146     AudioStreamBasicDescription streamDescription;
 147
 148     WAVEOUTCAPSW                caps;
 149     char                        interface_name[32];
 150     LPWAVEHDR                   lpQueuePtr;             /* start of queued WAVEHDRs (waiting to be notified) */
 151     LPWAVEHDR                   lpPlayPtr;              /* start of not yet fully played buffers */
 152     DWORD                       dwPartialOffset;        /* Offset of not yet written bytes in lpPlayPtr */
 153
 154     LPWAVEHDR                   lpLoopPtr;              /* pointer of first buffer in loop, if any */
 155     DWORD                       dwLoops;                /* private copy of loop counter */
 156
 157     DWORD                       dwPlayedTotal;          /* number of bytes actually played since opening */
 158     DWORD                       dwWrittenTotal;         /* number of bytes written to OSS buffer since opening */
 159
 160     DWORD                       tickCountMS; /* time in MS of last AudioUnit callback */
 161
 162     OSSpinLock                  lock;         /* synchronization stuff */
 163
 164     BOOL trace_on;
 165     BOOL warn_on;
 166     BOOL err_on;
 167 } WINE_WAVEOUT;
 168
 169 typedef struct {
 170     /* This device's device number */
 171     DWORD           wiID;
 172
 173     /* Access to the following fields is synchronized across threads. */
 174     volatile int    state;
 175     LPWAVEHDR       lpQueuePtr;
 176     DWORD           dwTotalRecorded;
 177
 178     /* Synchronization mechanism to protect above fields */
 179     OSSpinLock      lock;
 180
 181     /* Capabilities description */
 182     WAVEINCAPSW     caps;
 183     char            interface_name[32];
 184
 185     /* Record the arguments used when opening the device. */
 186     WAVEOPENDESC    waveDesc;
 187     WORD            wFlags;
 188     PCMWAVEFORMAT   format;
 189
 190     AudioUnit       audioUnit;
 191     AudioBufferList*bufferList;
 192
 193     /* Record state of debug channels at open.  Used to control fprintf's since
 194      * we can't use Wine debug channel calls in non-Wine AudioUnit threads. */
 195     BOOL            trace_on;
 196     BOOL            warn_on;
 197     BOOL            err_on;
 198
 199 /* These fields aren't used. */
 200 #if 0
 201     CoreAudio_Device *cadev;
 202
 203     AudioStreamBasicDescription streamDescription;
 204 #endif
 205 } WINE_WAVEIN;
 206
 207 static WINE_WAVEOUT WOutDev   [MAX_WAVEOUTDRV];
 208 static WINE_WAVEIN  WInDev    [MAX_WAVEINDRV];
 209
 210 static HANDLE hThread = NULL; /* Track the thread we create so we can clean it up later */
 211 static CFMessagePortRef Port_SendToMessageThread;
 212
 213 static void wodHelper_PlayPtrNext(WINE_WAVEOUT* wwo);
 214 static void wodHelper_NotifyDoneForList(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr);
 215 static void wodHelper_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force);
 216 static void widHelper_NotifyCompletions(WINE_WAVEIN* wwi);
 217
 218 extern int AudioUnit_CreateDefaultAudioUnit(void *wwo, AudioUnit *au);
 219 extern int AudioUnit_CloseAudioUnit(AudioUnit au);
 220 extern int AudioUnit_InitializeWithStreamDescription(AudioUnit au, AudioStreamBasicDescription *streamFormat);
 221
 222 extern OSStatus AudioOutputUnitStart(AudioUnit au);
 223 extern OSStatus AudioOutputUnitStop(AudioUnit au);
 224 extern OSStatus AudioUnitUninitialize(AudioUnit au);
 225
 226 extern int AudioUnit_SetVolume(AudioUnit au, float left, float right);
 227 extern int AudioUnit_GetVolume(AudioUnit au, float *left, float *right);
 228
 229 extern int AudioUnit_GetInputDeviceSampleRate(void);
 230
 231 extern int AudioUnit_CreateInputUnit(void* wwi, AudioUnit* out_au,
 232         WORD nChannels, DWORD nSamplesPerSec, WORD wBitsPerSample,
 233         UInt32* outFrameCount);
 234
 235 OSStatus CoreAudio_woAudioUnitIOProc(void *inRefCon,
 236                                      AudioUnitRenderActionFlags *ioActionFlags,
 237                                      const AudioTimeStamp *inTimeStamp,
 238                                      UInt32 inBusNumber,
 239                                      UInt32 inNumberFrames,
 240                                      AudioBufferList *ioData);
 241 OSStatus CoreAudio_wiAudioUnitIOProc(void *inRefCon,
 242                                      AudioUnitRenderActionFlags *ioActionFlags,
 243                                      const AudioTimeStamp *inTimeStamp,
 244                                      UInt32 inBusNumber,
 245                                      UInt32 inNumberFrames,
 246                                      AudioBufferList *ioData);
 247
 248 /* These strings used only for tracing */
 249
 250 static const char * getMessage(UINT msg)
 251 {
 252     static char unknown[32];
 253 #define MSG_TO_STR(x) case x: return #x
 254     switch(msg) {
 255         MSG_TO_STR(DRVM_INIT);
 256         MSG_TO_STR(DRVM_EXIT);
 257         MSG_TO_STR(DRVM_ENABLE);
 258         MSG_TO_STR(DRVM_DISABLE);
 259         MSG_TO_STR(WIDM_OPEN);
 260         MSG_TO_STR(WIDM_CLOSE);
 261         MSG_TO_STR(WIDM_ADDBUFFER);
 262         MSG_TO_STR(WIDM_PREPARE);
 263         MSG_TO_STR(WIDM_UNPREPARE);
 264         MSG_TO_STR(WIDM_GETDEVCAPS);
 265         MSG_TO_STR(WIDM_GETNUMDEVS);
 266         MSG_TO_STR(WIDM_GETPOS);
 267         MSG_TO_STR(WIDM_RESET);
 268         MSG_TO_STR(WIDM_START);
 269         MSG_TO_STR(WIDM_STOP);
 270         MSG_TO_STR(WODM_OPEN);
 271         MSG_TO_STR(WODM_CLOSE);
 272         MSG_TO_STR(WODM_WRITE);
 273         MSG_TO_STR(WODM_PAUSE);
 274         MSG_TO_STR(WODM_GETPOS);
 275         MSG_TO_STR(WODM_BREAKLOOP);
 276         MSG_TO_STR(WODM_PREPARE);
 277         MSG_TO_STR(WODM_UNPREPARE);
 278         MSG_TO_STR(WODM_GETDEVCAPS);
 279         MSG_TO_STR(WODM_GETNUMDEVS);
 280         MSG_TO_STR(WODM_GETPITCH);
 281         MSG_TO_STR(WODM_SETPITCH);
 282         MSG_TO_STR(WODM_GETPLAYBACKRATE);
 283         MSG_TO_STR(WODM_SETPLAYBACKRATE);
 284         MSG_TO_STR(WODM_GETVOLUME);
 285         MSG_TO_STR(WODM_SETVOLUME);
 286         MSG_TO_STR(WODM_RESTART);
 287         MSG_TO_STR(WODM_RESET);
 288         MSG_TO_STR(DRV_QUERYDEVICEINTERFACESIZE);
 289         MSG_TO_STR(DRV_QUERYDEVICEINTERFACE);
 290         MSG_TO_STR(DRV_QUERYDSOUNDIFACE);
 291         MSG_TO_STR(DRV_QUERYDSOUNDDESC);
 292     }
 293 #undef MSG_TO_STR
 294     sprintf(unknown, "UNKNOWN(0x%04x)", msg);
 295     return unknown;
 296 }
 297
 298 #define kStopLoopMessage 0
 299 #define kWaveOutNotifyCompletionsMessage 1
 300 #define kWaveInNotifyCompletionsMessage 2
 301
 302 /* Mach Message Handling */
 303 static CFDataRef wodMessageHandler(CFMessagePortRef port_ReceiveInMessageThread, SInt32 msgid, CFDataRef data, void *info)
 304 {
 305     UInt32 *buffer = NULL;
 306
 307     switch (msgid)
 308     {
 309         case kWaveOutNotifyCompletionsMessage:
 310             buffer = (UInt32 *) CFDataGetBytePtr(data);
 311             wodHelper_NotifyCompletions(&WOutDev[buffer[0]], FALSE);
 312             break;
 313         case kWaveInNotifyCompletionsMessage:
 314             buffer = (UInt32 *) CFDataGetBytePtr(data);
 315             widHelper_NotifyCompletions(&WInDev[buffer[0]]);
 316             break;
 317         default:
 318             CFRunLoopStop(CFRunLoopGetCurrent());
 319             break;
 320     }
 321
 322     return NULL;
 323 }
 324
 325 static DWORD WINAPI messageThread(LPVOID p)
 326 {
 327     CFMessagePortRef port_ReceiveInMessageThread = (CFMessagePortRef) p;
 328     CFRunLoopSourceRef source;
 329
 330     source = CFMessagePortCreateRunLoopSource(kCFAllocatorDefault, port_ReceiveInMessageThread, (CFIndex)0);
 331     CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
 332
 333     CFRunLoopRun();
 334
 335     CFRunLoopSourceInvalidate(source);
 336     CFRelease(source);
 337     CFRelease(port_ReceiveInMessageThread);
 338
 339     return 0;
 340 }
 341
 342 /**************************************************************************
 343 *                       wodSendNotifyCompletionsMessage                 [internal]
 344 *   Call from AudioUnit IO thread can't use Wine debug channels.
 345 */
 346 static void wodSendNotifyCompletionsMessage(WINE_WAVEOUT* wwo)
 347 {
 348     CFDataRef data;
 349     UInt32 buffer;
 350
 351     buffer = (UInt32) wwo->woID;
 352
 353     data = CFDataCreate(kCFAllocatorDefault, (UInt8 *)&buffer, sizeof(buffer));
 354     if (!data)
 355         return;
 356
 357     CFMessagePortSendRequest(Port_SendToMessageThread, kWaveOutNotifyCompletionsMessage, data, 0.0, 0.0, NULL, NULL);
 358     CFRelease(data);
 359 }
 360
 361 /**************************************************************************
 362 *                       wodSendNotifyInputCompletionsMessage     [internal]
 363 *   Call from AudioUnit IO thread can't use Wine debug channels.
 364 */
 365 static void wodSendNotifyInputCompletionsMessage(WINE_WAVEIN* wwi)
 366 {
 367     CFDataRef data;
 368     UInt32 buffer;
 369
 370     buffer = (UInt32) wwi->wiID;
 371
 372     data = CFDataCreate(kCFAllocatorDefault, (UInt8 *)&buffer, sizeof(buffer));
 373     if (!data)
 374         return;
 375
 376     CFMessagePortSendRequest(Port_SendToMessageThread, kWaveInNotifyCompletionsMessage, data, 0.0, 0.0, NULL, NULL);
 377     CFRelease(data);
 378 }
 379
 380 static DWORD bytes_to_mmtime(LPMMTIME lpTime, DWORD position,
 381                              PCMWAVEFORMAT* format)
 382 {
 383     TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%u nChannels=%u nAvgBytesPerSec=%u\n",
 384           lpTime->wType, format->wBitsPerSample, format->wf.nSamplesPerSec,
 385           format->wf.nChannels, format->wf.nAvgBytesPerSec);
 386     TRACE("Position in bytes=%u\n", position);
 387
 388     switch (lpTime->wType) {
 389     case TIME_SAMPLES:
 390         lpTime->u.sample = position / (format->wBitsPerSample / 8 * format->wf.nChannels);
 391         TRACE("TIME_SAMPLES=%u\n", lpTime->u.sample);
 392         break;
 393     case TIME_MS:
 394         lpTime->u.ms = 1000.0 * position / (format->wBitsPerSample / 8 * format->wf.nChannels * format->wf.nSamplesPerSec);
 395         TRACE("TIME_MS=%u\n", lpTime->u.ms);
 396         break;
 397     case TIME_SMPTE:
 398         lpTime->u.smpte.fps = 30;
 399         position = position / (format->wBitsPerSample / 8 * format->wf.nChannels);
 400         position += (format->wf.nSamplesPerSec / lpTime->u.smpte.fps) - 1; /* round up */
 401         lpTime->u.smpte.sec = position / format->wf.nSamplesPerSec;
 402         position -= lpTime->u.smpte.sec * format->wf.nSamplesPerSec;
 403         lpTime->u.smpte.min = lpTime->u.smpte.sec / 60;
 404         lpTime->u.smpte.sec -= 60 * lpTime->u.smpte.min;
 405         lpTime->u.smpte.hour = lpTime->u.smpte.min / 60;
 406         lpTime->u.smpte.min -= 60 * lpTime->u.smpte.hour;
 407         lpTime->u.smpte.fps = 30;
 408         lpTime->u.smpte.frame = position * lpTime->u.smpte.fps / format->wf.nSamplesPerSec;
 409         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
 410               lpTime->u.smpte.hour, lpTime->u.smpte.min,
 411               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
 412         break;
 413     default:
 414         WARN("Format %d not supported, using TIME_BYTES !\n", lpTime->wType);
 415         lpTime->wType = TIME_BYTES;
 416         /* fall through */
 417     case TIME_BYTES:
 418         lpTime->u.cb = position;
 419         TRACE("TIME_BYTES=%u\n", lpTime->u.cb);
 420         break;
 421     }
 422     return MMSYSERR_NOERROR;
 423 }
 424
 425 /**************************************************************************
 426 *                       CoreAudio_GetDevCaps            [internal]
 427 */
 428 BOOL CoreAudio_GetDevCaps (void)
 429 {
 430     OSStatus status;
 431     UInt32 propertySize;
 432     AudioDeviceID devId = CoreAudio_DefaultDevice.outputDeviceID;
 433
 434     char name[MAXPNAMELEN];
 435
 436     propertySize = MAXPNAMELEN;
 437     status = AudioDeviceGetProperty(devId, 0 , FALSE, kAudioDevicePropertyDeviceName, &propertySize, name);
 438     if (status) {
 439         ERR("AudioHardwareGetProperty for kAudioDevicePropertyDeviceName return %c%c%c%c\n", (char) (status >> 24),
 440                                                                                              (char) (status >> 16),
 441                                                                                              (char) (status >> 8),
 442                                                                                              (char) status);
 443         return FALSE;
 444     }
 445
 446     memcpy(CoreAudio_DefaultDevice.ds_desc.szDesc, name, sizeof(name));
 447     strcpy(CoreAudio_DefaultDevice.ds_desc.szDrvname, "winecoreaudio.drv");
 448     MultiByteToWideChar(CP_ACP, 0, name, sizeof(name),
 449                         CoreAudio_DefaultDevice.out_caps.szPname,
 450                         sizeof(CoreAudio_DefaultDevice.out_caps.szPname) / sizeof(WCHAR));
 451     memcpy(CoreAudio_DefaultDevice.dev_name, name, 32);
 452
 453     propertySize = sizeof(CoreAudio_DefaultDevice.streamDescription);
 454     status = AudioDeviceGetProperty(devId, 0, FALSE , kAudioDevicePropertyStreamFormat, &propertySize, &CoreAudio_DefaultDevice.streamDescription);
 455     if (status != noErr) {
 456         ERR("AudioHardwareGetProperty for kAudioDevicePropertyStreamFormat return %c%c%c%c\n", (char) (status >> 24),
 457                                                                                                 (char) (status >> 16),
 458                                                                                                 (char) (status >> 8),
 459                                                                                                 (char) status);
 460         return FALSE;
 461     }
 462
 463     TRACE("Device Stream Description mSampleRate : %f\n mFormatID : %c%c%c%c\n"
 464             "mFormatFlags : %lX\n mBytesPerPacket : %lu\n mFramesPerPacket : %lu\n"
 465             "mBytesPerFrame : %lu\n mChannelsPerFrame : %lu\n mBitsPerChannel : %lu\n",
 466                                CoreAudio_DefaultDevice.streamDescription.mSampleRate,
 467                                (char) (CoreAudio_DefaultDevice.streamDescription.mFormatID >> 24),
 468                                (char) (CoreAudio_DefaultDevice.streamDescription.mFormatID >> 16),
 469                                (char) (CoreAudio_DefaultDevice.streamDescription.mFormatID >> 8),
 470                                (char) CoreAudio_DefaultDevice.streamDescription.mFormatID,
 471                                CoreAudio_DefaultDevice.streamDescription.mFormatFlags,
 472                                CoreAudio_DefaultDevice.streamDescription.mBytesPerPacket,
 473                                CoreAudio_DefaultDevice.streamDescription.mFramesPerPacket,
 474                                CoreAudio_DefaultDevice.streamDescription.mBytesPerFrame,
 475                                CoreAudio_DefaultDevice.streamDescription.mChannelsPerFrame,
 476                                CoreAudio_DefaultDevice.streamDescription.mBitsPerChannel);
 477
 478     CoreAudio_DefaultDevice.out_caps.wMid = 0xcafe;
 479     CoreAudio_DefaultDevice.out_caps.wPid = 0x0001;
 480
 481     CoreAudio_DefaultDevice.out_caps.vDriverVersion = 0x0001;
 482     CoreAudio_DefaultDevice.out_caps.dwFormats = 0x00000000;
 483     CoreAudio_DefaultDevice.out_caps.wReserved1 = 0;
 484     CoreAudio_DefaultDevice.out_caps.dwSupport = WAVECAPS_VOLUME;
 485     CoreAudio_DefaultDevice.out_caps.dwSupport |= WAVECAPS_LRVOLUME;
 486
 487     CoreAudio_DefaultDevice.out_caps.wChannels = 2;
 488     CoreAudio_DefaultDevice.out_caps.dwFormats|= WAVE_FORMAT_4S16;
 489
 490     return TRUE;
 491 }
 492
 493 /******************************************************************
 494 *               CoreAudio_WaveInit
 495 *
 496 * Initialize CoreAudio_DefaultDevice
 497 */
 498 LONG CoreAudio_WaveInit(void)
 499 {
 500     OSStatus status;
 501     UInt32 propertySize;
 502     CHAR szPname[MAXPNAMELEN];
 503     int i;
 504     CFStringRef  messageThreadPortName;
 505     CFMessagePortRef port_ReceiveInMessageThread;
 506     int inputSampleRate;
 507
 508     TRACE("()\n");
 509
 510     /* number of sound cards */
 511     AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
 512     propertySize /= sizeof(AudioDeviceID);
 513     TRACE("sound cards : %lu\n", propertySize);
 514
 515     /* Get the output device */
 516     propertySize = sizeof(CoreAudio_DefaultDevice.outputDeviceID);
 517     status = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &propertySize, &CoreAudio_DefaultDevice.outputDeviceID);
 518     if (status) {
 519         ERR("AudioHardwareGetProperty return %c%c%c%c for kAudioHardwarePropertyDefaultOutputDevice\n", (char) (status >> 24),
 520                                                                                                 (char) (status >> 16),
 521                                                                                                 (char) (status >> 8),
 522                                                                                                 (char) status);
 523         return 1;
 524     }
 525     if (CoreAudio_DefaultDevice.outputDeviceID == kAudioDeviceUnknown) {
 526         ERR("AudioHardwareGetProperty: CoreAudio_DefaultDevice.outputDeviceID == kAudioDeviceUnknown\n");
 527         return 1;
 528     }
 529
 530     if ( ! CoreAudio_GetDevCaps() )
 531         return 1;
 532
 533     CoreAudio_DefaultDevice.interface_name=HeapAlloc(GetProcessHeap(),0,strlen(CoreAudio_DefaultDevice.dev_name)+1);
 534     sprintf(CoreAudio_DefaultDevice.interface_name, "%s", CoreAudio_DefaultDevice.dev_name);
 535
 536     for (i = 0; i < MAX_WAVEOUTDRV; ++i)
 537     {
 538         WOutDev[i].state = WINE_WS_CLOSED;
 539         WOutDev[i].cadev = &CoreAudio_DefaultDevice;
 540         WOutDev[i].woID = i;
 541
 542         memset(&WOutDev[i].caps, 0, sizeof(WOutDev[i].caps));
 543
 544         WOutDev[i].caps.wMid = 0xcafe;  /* Manufac ID */
 545         WOutDev[i].caps.wPid = 0x0001;  /* Product ID */
 546         snprintf(szPname, sizeof(szPname), "CoreAudio WaveOut %d", i);
 547         MultiByteToWideChar(CP_ACP, 0, szPname, -1, WOutDev[i].caps.szPname, sizeof(WOutDev[i].caps.szPname)/sizeof(WCHAR));
 548         snprintf(WOutDev[i].interface_name, sizeof(WOutDev[i].interface_name), "winecoreaudio: %d", i);
 549
 550         WOutDev[i].caps.vDriverVersion = 0x0001;
 551         WOutDev[i].caps.dwFormats = 0x00000000;
 552         WOutDev[i].caps.dwSupport = WAVECAPS_VOLUME;
 553
 554         WOutDev[i].caps.wChannels = 2;
 555       /*  WOutDev[i].caps.dwSupport |= WAVECAPS_LRVOLUME; */ /* FIXME */
 556
 557         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_96M08;
 558         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_96S08;
 559         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_96M16;
 560         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_96S16;
 561         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_48M08;
 562         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_48S08;
 563         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_48M16;
 564         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_48S16;
 565         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
 566         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S08;
 567         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
 568         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
 569         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
 570         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S08;
 571         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
 572         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
 573         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
 574         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;
 575         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
 576         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
 577
 578         WOutDev[i].lock = 0; /* initialize the mutex */
 579     }
 580
 581     /* FIXME: implement sample rate conversion on input */
 582     inputSampleRate = AudioUnit_GetInputDeviceSampleRate();
 583
 584     for (i = 0; i < MAX_WAVEINDRV; ++i)
 585     {
 586         memset(&WInDev[i], 0, sizeof(WInDev[i]));
 587         WInDev[i].wiID = i;
 588
 589         /* Establish preconditions for widOpen */
 590         WInDev[i].state = WINE_WS_CLOSED;
 591         WInDev[i].lock = 0; /* initialize the mutex */
 592
 593         /* Fill in capabilities.  widGetDevCaps can be called at any time. */
 594         WInDev[i].caps.wMid = 0xcafe;   /* Manufac ID */
 595         WInDev[i].caps.wPid = 0x0001;   /* Product ID */
 596         WInDev[i].caps.vDriverVersion = 0x0001;
 597
 598         snprintf(szPname, sizeof(szPname), "CoreAudio WaveIn %d", i);
 599         MultiByteToWideChar(CP_ACP, 0, szPname, -1, WInDev[i].caps.szPname, sizeof(WInDev[i].caps.szPname)/sizeof(WCHAR));
 600         snprintf(WInDev[i].interface_name, sizeof(WInDev[i].interface_name), "winecoreaudio in: %d", i);
 601
 602         if (inputSampleRate == 96000)
 603         {
 604             WInDev[i].caps.dwFormats |= WAVE_FORMAT_96M08;
 605             WInDev[i].caps.dwFormats |= WAVE_FORMAT_96S08;
 606             WInDev[i].caps.dwFormats |= WAVE_FORMAT_96M16;
 607             WInDev[i].caps.dwFormats |= WAVE_FORMAT_96S16;
 608         }
 609         if (inputSampleRate == 48000)
 610         {
 611             WInDev[i].caps.dwFormats |= WAVE_FORMAT_48M08;
 612             WInDev[i].caps.dwFormats |= WAVE_FORMAT_48S08;
 613             WInDev[i].caps.dwFormats |= WAVE_FORMAT_48M16;
 614             WInDev[i].caps.dwFormats |= WAVE_FORMAT_48S16;
 615         }
 616         if (inputSampleRate == 44100)
 617         {
 618             WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
 619             WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S08;
 620             WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
 621             WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
 622         }
 623         if (inputSampleRate == 22050)
 624         {
 625             WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
 626             WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S08;
 627             WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
 628             WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
 629         }
 630         if (inputSampleRate == 11025)
 631         {
 632             WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
 633             WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;
 634             WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
 635             WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
 636         }
 637
 638         WInDev[i].caps.wChannels = 2;
 639     }
 640
 641     /* create mach messages handler */
 642     srandomdev();
 643     messageThreadPortName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
 644         CFSTR("WaveMessagePort.%d.%lu"), getpid(), (unsigned long)random());
 645     if (!messageThreadPortName)
 646     {
 647         ERR("Can't create message thread port name\n");
 648         return 1;
 649     }
 650
 651     port_ReceiveInMessageThread = CFMessagePortCreateLocal(kCFAllocatorDefault, messageThreadPortName,
 652                                         &wodMessageHandler, NULL, NULL);
 653     if (!port_ReceiveInMessageThread)
 654     {
 655         ERR("Can't create message thread local port\n");
 656         CFRelease(messageThreadPortName);
 657         return 1;
 658     }
 659
 660     Port_SendToMessageThread = CFMessagePortCreateRemote(kCFAllocatorDefault, messageThreadPortName);
 661     CFRelease(messageThreadPortName);
 662     if (!Port_SendToMessageThread)
 663     {
 664         ERR("Can't create port for sending to message thread\n");
 665         CFRelease(port_ReceiveInMessageThread);
 666         return 1;
 667     }
 668
 669     /* Cannot WAIT for any events because we are called from the loader (which has a lock on loading stuff) */
 670     /* We might want to wait for this thread to be created -- but we cannot -- not here at least */
 671     /* Instead track the thread so we can clean it up later */
 672     if ( hThread )
 673     {
 674         ERR("Message thread already started -- expect problems\n");
 675     }
 676     hThread = CreateThread(NULL, 0, messageThread, (LPVOID)port_ReceiveInMessageThread, 0, NULL);
 677     if ( !hThread )
 678     {
 679         ERR("Can't create message thread\n");
 680         CFRelease(port_ReceiveInMessageThread);
 681         CFRelease(Port_SendToMessageThread);
 682         Port_SendToMessageThread = NULL;
 683         return 1;
 684     }
 685
 686     /* The message thread is responsible for releasing port_ReceiveInMessageThread. */
 687
 688     return 0;
 689 }
 690
 691 void CoreAudio_WaveRelease(void)
 692 {
 693     /* Stop CFRunLoop in messageThread */
 694     TRACE("()\n");
 695
 696     CFMessagePortSendRequest(Port_SendToMessageThread, kStopLoopMessage, NULL, 0.0, 0.0, NULL, NULL);
 697     CFRelease(Port_SendToMessageThread);
 698     Port_SendToMessageThread = NULL;
 699
 700     /* Wait for the thread to finish and clean it up */
 701     /* This rids us of any quick start/shutdown driver crashes */
 702     WaitForSingleObject(hThread, INFINITE);
 703     CloseHandle(hThread);
 704     hThread = NULL;
 705 }
 706
 707 /*======================================================================*
 708 *                  Low level WAVE OUT implementation                    *
 709 *======================================================================*/
 710
 711 /**************************************************************************
 712 *                       wodNotifyClient                 [internal]
 713 */
 714 static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
 715 {
 716     switch (wMsg) {
 717         case WOM_OPEN:
 718         case WOM_CLOSE:
 719         case WOM_DONE:
 720             if (wwo->wFlags != DCB_NULL &&
 721                 !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags,
 722                                 (HDRVR)wwo->waveDesc.hWave, wMsg, wwo->waveDesc.dwInstance,
 723                                 dwParam1, dwParam2))
 724             {
 725                 return MMSYSERR_ERROR;
 726             }
 727             break;
 728         default:
 729             return MMSYSERR_INVALPARAM;
 730     }
 731     return MMSYSERR_NOERROR;
 732 }
 733
 734
 735 /**************************************************************************
 736 *                       wodGetDevCaps               [internal]
 737 */
 738 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSW lpCaps, DWORD dwSize)
 739 {
 740     TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
 741
 742     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
 743
 744     if (wDevID >= MAX_WAVEOUTDRV)
 745     {
 746         TRACE("MAX_WAVOUTDRV reached !\n");
 747         return MMSYSERR_BADDEVICEID;
 748     }
 749
 750     TRACE("dwSupport=(0x%x), dwFormats=(0x%x)\n", WOutDev[wDevID].caps.dwSupport, WOutDev[wDevID].caps.dwFormats);
 751     memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
 752     return MMSYSERR_NOERROR;
 753 }
 754
 755 /**************************************************************************
 756 *                               wodOpen                         [internal]
 757 */
 758 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
 759 {
 760     WINE_WAVEOUT*       wwo;
 761     DWORD retval;
 762     DWORD               ret;
 763     AudioStreamBasicDescription streamFormat;
 764
 765     TRACE("(%u, %p, %08x);\n", wDevID, lpDesc, dwFlags);
 766     if (lpDesc == NULL)
 767     {
 768         WARN("Invalid Parameter !\n");
 769         return MMSYSERR_INVALPARAM;
 770     }
 771     if (wDevID >= MAX_WAVEOUTDRV) {
 772         TRACE("MAX_WAVOUTDRV reached !\n");
 773         return MMSYSERR_BADDEVICEID;
 774     }
 775
 776     TRACE("Format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
 777           lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
 778           lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
 779
 780     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
 781         lpDesc->lpFormat->nChannels == 0 ||
 782         lpDesc->lpFormat->nSamplesPerSec == 0
 783          )
 784     {
 785         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
 786              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
 787              lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
 788         return WAVERR_BADFORMAT;
 789     }
 790
 791     if (dwFlags & WAVE_FORMAT_QUERY)
 792     {
 793         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
 794               lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
 795               lpDesc->lpFormat->nSamplesPerSec);
 796         return MMSYSERR_NOERROR;
 797     }
 798
 799     wwo = &WOutDev[wDevID];
 800     if (!OSSpinLockTry(&wwo->lock))
 801         return MMSYSERR_ALLOCATED;
 802
 803     if (wwo->state != WINE_WS_CLOSED)
 804     {
 805         OSSpinLockUnlock(&wwo->lock);
 806         return MMSYSERR_ALLOCATED;
 807     }
 808
 809     if (!AudioUnit_CreateDefaultAudioUnit((void *) wwo, &wwo->audioUnit))
 810     {
 811         ERR("CoreAudio_CreateDefaultAudioUnit(%p) failed\n", wwo);
 812         OSSpinLockUnlock(&wwo->lock);
 813         return MMSYSERR_ERROR;
 814     }
 815
 816     if ((dwFlags & WAVE_DIRECTSOUND) &&
 817         !(wwo->caps.dwSupport & WAVECAPS_DIRECTSOUND))
 818         /* not supported, ignore it */
 819         dwFlags &= ~WAVE_DIRECTSOUND;
 820
 821     streamFormat.mFormatID = kAudioFormatLinearPCM;
 822     streamFormat.mFormatFlags = kLinearPCMFormatFlagIsPacked;
 823     /* FIXME check for 32bits float -> kLinearPCMFormatFlagIsFloat */
 824     if (lpDesc->lpFormat->wBitsPerSample != 8)
 825         streamFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
 826 # ifdef WORDS_BIGENDIAN
 827     streamFormat.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; /* FIXME Wave format is little endian */
 828 # endif
 829
 830     streamFormat.mSampleRate = lpDesc->lpFormat->nSamplesPerSec;
 831     streamFormat.mChannelsPerFrame = lpDesc->lpFormat->nChannels;
 832     streamFormat.mFramesPerPacket = 1;
 833     streamFormat.mBitsPerChannel = lpDesc->lpFormat->wBitsPerSample;
 834     streamFormat.mBytesPerFrame = streamFormat.mBitsPerChannel * streamFormat.mChannelsPerFrame / 8;
 835     streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame * streamFormat.mFramesPerPacket;
 836
 837     ret = AudioUnit_InitializeWithStreamDescription(wwo->audioUnit, &streamFormat);
 838     if (!ret)
 839     {
 840         AudioUnit_CloseAudioUnit(wwo->audioUnit);
 841         OSSpinLockUnlock(&wwo->lock);
 842         return WAVERR_BADFORMAT; /* FIXME return an error based on the OSStatus */
 843     }
 844     wwo->streamDescription = streamFormat;
 845
 846     ret = AudioOutputUnitStart(wwo->audioUnit);
 847     if (ret)
 848     {
 849         ERR("AudioOutputUnitStart failed: %08x\n", ret);
 850         AudioUnitUninitialize(wwo->audioUnit);
 851         AudioUnit_CloseAudioUnit(wwo->audioUnit);
 852         OSSpinLockUnlock(&wwo->lock);
 853         return MMSYSERR_ERROR; /* FIXME return an error based on the OSStatus */
 854     }
 855
 856     wwo->state = WINE_WS_STOPPED;
 857
 858     wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 859
 860     memcpy(&wwo->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
 861     memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
 862
 863     if (wwo->format.wBitsPerSample == 0) {
 864         WARN("Resetting zeroed wBitsPerSample\n");
 865         wwo->format.wBitsPerSample = 8 *
 866             (wwo->format.wf.nAvgBytesPerSec /
 867              wwo->format.wf.nSamplesPerSec) /
 868             wwo->format.wf.nChannels;
 869     }
 870
 871     wwo->dwPlayedTotal = 0;
 872     wwo->dwWrittenTotal = 0;
 873
 874     wwo->trace_on = TRACE_ON(wave);
 875     wwo->warn_on  = WARN_ON(wave);
 876     wwo->err_on   = ERR_ON(wave);
 877
 878     OSSpinLockUnlock(&wwo->lock);
 879
 880     retval = wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
 881
 882     return retval;
 883 }
 884
 885 /**************************************************************************
 886 *                               wodClose                        [internal]
 887 */
 888 static DWORD wodClose(WORD wDevID)
 889 {
 890     DWORD               ret = MMSYSERR_NOERROR;
 891     WINE_WAVEOUT*       wwo;
 892
 893     TRACE("(%u);\n", wDevID);
 894
 895     if (wDevID >= MAX_WAVEOUTDRV)
 896     {
 897         WARN("bad device ID !\n");
 898         return MMSYSERR_BADDEVICEID;
 899     }
 900
 901     wwo = &WOutDev[wDevID];
 902     OSSpinLockLock(&wwo->lock);
 903     if (wwo->lpQueuePtr)
 904     {
 905         WARN("buffers still playing !\n");
 906         OSSpinLockUnlock(&wwo->lock);
 907         ret = WAVERR_STILLPLAYING;
 908     } else
 909     {
 910         OSStatus err;
 911         /* sanity check: this should not happen since the device must have been reset before */
 912         if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
 913
 914         wwo->state = WINE_WS_CLOSED; /* mark the device as closed */
 915
 916         OSSpinLockUnlock(&wwo->lock);
 917
 918         err = AudioUnitUninitialize(wwo->audioUnit);
 919         if (err) {
 920             ERR("AudioUnitUninitialize return %c%c%c%c\n", (char) (err >> 24),
 921                                                             (char) (err >> 16),
 922                                                             (char) (err >> 8),
 923                                                             (char) err);
 924             return MMSYSERR_ERROR; /* FIXME return an error based on the OSStatus */
 925         }
 926
 927         if ( !AudioUnit_CloseAudioUnit(wwo->audioUnit) )
 928         {
 929             ERR("Can't close AudioUnit\n");
 930             return MMSYSERR_ERROR; /* FIXME return an error based on the OSStatus */
 931         }
 932
 933         ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
 934     }
 935
 936     return ret;
 937 }
 938
 939 /**************************************************************************
 940 *                               wodPrepare                      [internal]
 941 */
 942 static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
 943 {
 944     TRACE("(%u, %p, %08x);\n", wDevID, lpWaveHdr, dwSize);
 945
 946     if (wDevID >= MAX_WAVEOUTDRV) {
 947         WARN("bad device ID !\n");
 948         return MMSYSERR_BADDEVICEID;
 949     }
 950
 951     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
 952         return WAVERR_STILLPLAYING;
 953
 954     lpWaveHdr->dwFlags |= WHDR_PREPARED;
 955     lpWaveHdr->dwFlags &= ~WHDR_DONE;
 956
 957     return MMSYSERR_NOERROR;
 958 }
 959
 960 /**************************************************************************
 961 *                               wodUnprepare                    [internal]
 962 */
 963 static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
 964 {
 965     TRACE("(%u, %p, %08x);\n", wDevID, lpWaveHdr, dwSize);
 966
 967     if (wDevID >= MAX_WAVEOUTDRV) {
 968         WARN("bad device ID !\n");
 969         return MMSYSERR_BADDEVICEID;
 970     }
 971
 972     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
 973         return WAVERR_STILLPLAYING;
 974
 975     lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
 976     lpWaveHdr->dwFlags |= WHDR_DONE;
 977
 978     return MMSYSERR_NOERROR;
 979 }
 980
 981
 982 /**************************************************************************
 983 *                               wodHelper_CheckForLoopBegin             [internal]
 984 *
 985 * Check if the new waveheader is the beginning of a loop, and set up
 986 * state if so.
 987 * This is called with the WAVEOUT lock held.
 988 * Call from AudioUnit IO thread can't use Wine debug channels.
 989 */
 990 static void wodHelper_CheckForLoopBegin(WINE_WAVEOUT* wwo)
 991 {
 992     LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
 993
 994     if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)
 995     {
 996         if (wwo->lpLoopPtr)
 997         {
 998             if (wwo->warn_on)
 999                 fprintf(stderr, "warn:winecoreaudio:wodHelper_CheckForLoopBegin Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
1000         }
1001         else
1002         {
1003             if (wwo->trace_on)
1004                 fprintf(stderr, "trace:winecoreaudio:wodHelper_CheckForLoopBegin Starting loop (%dx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
1005
1006             wwo->lpLoopPtr = lpWaveHdr;
1007             /* Windows does not touch WAVEHDR.dwLoops,
1008                 * so we need to make an internal copy */
1009             wwo->dwLoops = lpWaveHdr->dwLoops;
1010         }
1011     }
1012 }
1013
1014
1015 /**************************************************************************
1016 *                               wodHelper_PlayPtrNext           [internal]
1017 *
1018 * Advance the play pointer to the next waveheader, looping if required.
1019 * This is called with the WAVEOUT lock held.
1020 * Call from AudioUnit IO thread can't use Wine debug channels.
1021 */
1022 static void wodHelper_PlayPtrNext(WINE_WAVEOUT* wwo)
1023 {
1024     BOOL didLoopBack = FALSE;
1025
1026     wwo->dwPartialOffset = 0;
1027     if ((wwo->lpPlayPtr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr)
1028     {
1029         /* We're at the end of a loop, loop if required */
1030         if (wwo->dwLoops > 1)
1031         {
1032             wwo->dwLoops--;
1033             wwo->lpPlayPtr = wwo->lpLoopPtr;
1034             didLoopBack = TRUE;
1035         }
1036         else
1037         {
1038             wwo->lpLoopPtr = NULL;
1039         }
1040     }
1041     if (!didLoopBack)
1042     {
1043         /* We didn't loop back.  Advance to the next wave header */
1044         wwo->lpPlayPtr = wwo->lpPlayPtr->lpNext;
1045
1046         if (!wwo->lpPlayPtr)
1047             wwo->state = WINE_WS_STOPPED;
1048         else
1049             wodHelper_CheckForLoopBegin(wwo);
1050     }
1051 }
1052
1053 /* Send the "done" notification for each WAVEHDR in a list.  The list must be
1054  * free-standing.  It should not be part of a device's queue.
1055  * This function must be called with the WAVEOUT lock *not* held.  Furthermore,
1056  * it does not lock it, itself.  That's because the callback to the application
1057  * may prompt the application to operate on the device, and we don't want to
1058  * deadlock.
1059  */
1060 static void wodHelper_NotifyDoneForList(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
1061 {
1062     for ( ; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext)
1063     {
1064         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1065         lpWaveHdr->dwFlags |= WHDR_DONE;
1066
1067         wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
1068     }
1069 }
1070
1071 /* if force is TRUE then notify the client that all the headers were completed
1072  */
1073 static void wodHelper_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
1074 {
1075     LPWAVEHDR lpFirstDoneWaveHdr = NULL;
1076
1077     OSSpinLockLock(&wwo->lock);
1078
1079     /* First, excise all of the done headers from the queue into
1080      * a free-standing list. */
1081     if (force)
1082     {
1083         lpFirstDoneWaveHdr = wwo->lpQueuePtr;
1084         wwo->lpQueuePtr = NULL;
1085     }
1086     else
1087     {
1088         LPWAVEHDR lpWaveHdr;
1089         LPWAVEHDR lpLastDoneWaveHdr = NULL;
1090
1091         /* Start from lpQueuePtr and keep notifying until:
1092             * - we hit an unwritten wavehdr
1093             * - we hit the beginning of a running loop
1094             * - we hit a wavehdr which hasn't finished playing
1095             */
1096         for (
1097             lpWaveHdr = wwo->lpQueuePtr;
1098             lpWaveHdr &&
1099                 lpWaveHdr != wwo->lpPlayPtr &&
1100                 lpWaveHdr != wwo->lpLoopPtr;
1101             lpWaveHdr = lpWaveHdr->lpNext
1102             )
1103         {
1104             if (!lpFirstDoneWaveHdr)
1105                 lpFirstDoneWaveHdr = lpWaveHdr;
1106             lpLastDoneWaveHdr = lpWaveHdr;
1107         }
1108
1109         if (lpLastDoneWaveHdr)
1110         {
1111             wwo->lpQueuePtr = lpLastDoneWaveHdr->lpNext;
1112             lpLastDoneWaveHdr->lpNext = NULL;
1113         }
1114     }
1115
1116     OSSpinLockUnlock(&wwo->lock);
1117
1118     /* Now, send the "done" notification for each header in our list. */
1119     wodHelper_NotifyDoneForList(wwo, lpFirstDoneWaveHdr);
1120 }
1121
1122
1123 /**************************************************************************
1124 *                               wodWrite                        [internal]
1125 *
1126 */
1127 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1128 {
1129     LPWAVEHDR*wh;
1130     WINE_WAVEOUT *wwo;
1131
1132     TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
1133
1134     /* first, do the sanity checks... */
1135     if (wDevID >= MAX_WAVEOUTDRV)
1136     {
1137         WARN("bad dev ID !\n");
1138         return MMSYSERR_BADDEVICEID;
1139     }
1140
1141     wwo = &WOutDev[wDevID];
1142
1143     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
1144     {
1145         TRACE("unprepared\n");
1146         return WAVERR_UNPREPARED;
1147     }
1148
1149     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1150     {
1151         TRACE("still playing\n");
1152         return WAVERR_STILLPLAYING;
1153     }
1154
1155     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1156     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1157     lpWaveHdr->lpNext = 0;
1158
1159     OSSpinLockLock(&wwo->lock);
1160     /* insert buffer at the end of queue */
1161     for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext))
1162         /* Do nothing */;
1163     *wh = lpWaveHdr;
1164
1165     if (!wwo->lpPlayPtr)
1166     {
1167         wwo->lpPlayPtr = lpWaveHdr;
1168
1169         if (wwo->state == WINE_WS_STOPPED)
1170             wwo->state = WINE_WS_PLAYING;
1171
1172         wodHelper_CheckForLoopBegin(wwo);
1173
1174         wwo->dwPartialOffset = 0;
1175     }
1176     OSSpinLockUnlock(&wwo->lock);
1177
1178     return MMSYSERR_NOERROR;
1179 }
1180
1181 /**************************************************************************
1182 *                       wodPause                                [internal]
1183 */
1184 static DWORD wodPause(WORD wDevID)
1185 {
1186     OSStatus status;
1187
1188     TRACE("(%u);!\n", wDevID);
1189
1190     if (wDevID >= MAX_WAVEOUTDRV)
1191     {
1192         WARN("bad device ID !\n");
1193         return MMSYSERR_BADDEVICEID;
1194     }
1195
1196     /* The order of the following operations is important since we can't hold
1197      * the mutex while we make an Audio Unit call.  Stop the Audio Unit before
1198      * setting the PAUSED state.  In wodRestart, the order is reversed.  This
1199      * guarantees that we can't get into a situation where the state is
1200      * PLAYING or STOPPED but the Audio Unit isn't running.  Although we can
1201      * be in PAUSED state with the Audio Unit still running, that's harmless
1202      * because the render callback will just produce silence.
1203      */
1204     status = AudioOutputUnitStop(WOutDev[wDevID].audioUnit);
1205     if (status) {
1206         WARN("AudioOutputUnitStop return %c%c%c%c\n",
1207              (char) (status >> 24), (char) (status >> 16), (char) (status >> 8), (char) status);
1208     }
1209
1210     OSSpinLockLock(&WOutDev[wDevID].lock);
1211     if (WOutDev[wDevID].state == WINE_WS_PLAYING || WOutDev[wDevID].state == WINE_WS_STOPPED)
1212         WOutDev[wDevID].state = WINE_WS_PAUSED;
1213     OSSpinLockUnlock(&WOutDev[wDevID].lock);
1214
1215     return MMSYSERR_NOERROR;
1216 }
1217
1218 /**************************************************************************
1219 *                       wodRestart                              [internal]
1220 */
1221 static DWORD wodRestart(WORD wDevID)
1222 {
1223     OSStatus status;
1224
1225     TRACE("(%u);\n", wDevID);
1226
1227     if (wDevID >= MAX_WAVEOUTDRV )
1228     {
1229         WARN("bad device ID !\n");
1230         return MMSYSERR_BADDEVICEID;
1231     }
1232
1233     /* The order of the following operations is important since we can't hold
1234      * the mutex while we make an Audio Unit call.  Set the PLAYING/STOPPED
1235      * state before starting the Audio Unit.  In wodPause, the order is
1236      * reversed.  This guarantees that we can't get into a situation where
1237      * the state is PLAYING or STOPPED but the Audio Unit isn't running.
1238      * Although we can be in PAUSED state with the Audio Unit still running,
1239      * that's harmless because the render callback will just produce silence.
1240      */
1241     OSSpinLockLock(&WOutDev[wDevID].lock);
1242     if (WOutDev[wDevID].state == WINE_WS_PAUSED)
1243     {
1244         if (WOutDev[wDevID].lpPlayPtr)
1245             WOutDev[wDevID].state = WINE_WS_PLAYING;
1246         else
1247             WOutDev[wDevID].state = WINE_WS_STOPPED;
1248     }
1249     OSSpinLockUnlock(&WOutDev[wDevID].lock);
1250
1251     status = AudioOutputUnitStart(WOutDev[wDevID].audioUnit);
1252     if (status) {
1253         ERR("AudioOutputUnitStart return %c%c%c%c\n",
1254             (char) (status >> 24), (char) (status >> 16), (char) (status >> 8), (char) status);
1255         return MMSYSERR_ERROR; /* FIXME return an error based on the OSStatus */
1256     }
1257
1258     return MMSYSERR_NOERROR;
1259 }
1260
1261 /**************************************************************************
1262 *                       wodReset                                [internal]
1263 */
1264 static DWORD wodReset(WORD wDevID)
1265 {
1266     WINE_WAVEOUT* wwo;
1267     OSStatus status;
1268     LPWAVEHDR lpSavedQueuePtr;
1269
1270     TRACE("(%u);\n", wDevID);
1271
1272     if (wDevID >= MAX_WAVEOUTDRV)
1273     {
1274         WARN("bad device ID !\n");
1275         return MMSYSERR_BADDEVICEID;
1276     }
1277
1278     wwo = &WOutDev[wDevID];
1279
1280     OSSpinLockLock(&wwo->lock);
1281
1282     if (wwo->state == WINE_WS_CLOSED)
1283     {
1284         OSSpinLockUnlock(&wwo->lock);
1285         WARN("resetting a closed device\n");
1286         return MMSYSERR_INVALHANDLE;
1287     }
1288
1289     lpSavedQueuePtr = wwo->lpQueuePtr;
1290     wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
1291     wwo->state = WINE_WS_STOPPED;
1292     wwo->dwPlayedTotal = wwo->dwWrittenTotal = 0;
1293
1294     wwo->dwPartialOffset = 0;        /* Clear partial wavehdr */
1295
1296     OSSpinLockUnlock(&wwo->lock);
1297
1298     status = AudioOutputUnitStart(wwo->audioUnit);
1299
1300     if (status) {
1301         ERR( "AudioOutputUnitStart return %c%c%c%c\n",
1302              (char) (status >> 24), (char) (status >> 16), (char) (status >> 8), (char) status);
1303         return MMSYSERR_ERROR; /* FIXME return an error based on the OSStatus */
1304     }
1305
1306     /* Now, send the "done" notification for each header in our list. */
1307     /* Do this last so the reset operation is effectively complete before the
1308      * app does whatever it's going to do in response to these notifications. */
1309     wodHelper_NotifyDoneForList(wwo, lpSavedQueuePtr);
1310
1311     return MMSYSERR_NOERROR;
1312 }
1313
1314 /**************************************************************************
1315 *                               wodGetPosition                  [internal]
1316 */
1317 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1318 {
1319     DWORD               val;
1320     WINE_WAVEOUT*       wwo;
1321
1322     TRACE("(%u, %p, %u);\n", wDevID, lpTime, uSize);
1323
1324     if (wDevID >= MAX_WAVEOUTDRV)
1325     {
1326         WARN("bad device ID !\n");
1327         return MMSYSERR_BADDEVICEID;
1328     }
1329
1330     /* if null pointer to time structure return error */
1331     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1332
1333     wwo = &WOutDev[wDevID];
1334
1335     OSSpinLockLock(&WOutDev[wDevID].lock);
1336     val = wwo->dwPlayedTotal;
1337     OSSpinLockUnlock(&WOutDev[wDevID].lock);
1338
1339     return bytes_to_mmtime(lpTime, val, &wwo->format);
1340 }
1341
1342 /**************************************************************************
1343 *                               wodGetVolume                    [internal]
1344 */
1345 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1346 {
1347     float left;
1348     float right;
1349
1350     if (wDevID >= MAX_WAVEOUTDRV)
1351     {
1352         WARN("bad device ID !\n");
1353         return MMSYSERR_BADDEVICEID;
1354     }
1355
1356     TRACE("(%u, %p);\n", wDevID, lpdwVol);
1357
1358     AudioUnit_GetVolume(WOutDev[wDevID].audioUnit, &left, &right);
1359
1360     *lpdwVol = ((WORD) left * 0xFFFFl) + (((WORD) right * 0xFFFFl) << 16);
1361
1362     return MMSYSERR_NOERROR;
1363 }
1364
1365 /**************************************************************************
1366 *                               wodSetVolume                    [internal]
1367 */
1368 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1369 {
1370     float left;
1371     float right;
1372
1373     if (wDevID >= MAX_WAVEOUTDRV)
1374     {
1375         WARN("bad device ID !\n");
1376         return MMSYSERR_BADDEVICEID;
1377     }
1378
1379     left  = LOWORD(dwParam) / 65535.0f;
1380     right = HIWORD(dwParam) / 65535.0f;
1381
1382     TRACE("(%u, %08x);\n", wDevID, dwParam);
1383
1384     AudioUnit_SetVolume(WOutDev[wDevID].audioUnit, left, right);
1385
1386     return MMSYSERR_NOERROR;
1387 }
1388
1389 /**************************************************************************
1390 *                               wodGetNumDevs                   [internal]
1391 */
1392 static DWORD wodGetNumDevs(void)
1393 {
1394     TRACE("\n");
1395     return MAX_WAVEOUTDRV;
1396 }
1397
1398 /**************************************************************************
1399 *                              wodDevInterfaceSize             [internal]
1400 */
1401 static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1402 {
1403     TRACE("(%u, %p)\n", wDevID, dwParam1);
1404
1405     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].cadev->interface_name, -1,
1406                                     NULL, 0 ) * sizeof(WCHAR);
1407     return MMSYSERR_NOERROR;
1408 }
1409
1410 /**************************************************************************
1411 *                              wodDevInterface                 [internal]
1412 */
1413 static DWORD wodDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1414 {
1415     TRACE("\n");
1416     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].cadev->interface_name, -1,
1417                                         NULL, 0 ) * sizeof(WCHAR))
1418     {
1419         MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].cadev->interface_name, -1,
1420                             dwParam1, dwParam2 / sizeof(WCHAR));
1421         return MMSYSERR_NOERROR;
1422     }
1423     return MMSYSERR_INVALPARAM;
1424 }
1425
1426 /**************************************************************************
1427  *                              widDsCreate                     [internal]
1428  */
1429 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
1430 {
1431     TRACE("(%d,%p)\n",wDevID,drv);
1432
1433     FIXME("DirectSound not implemented\n");
1434     FIXME("The (slower) DirectSound HEL mode will be used instead.\n");
1435     return MMSYSERR_NOTSUPPORTED;
1436 }
1437
1438 /**************************************************************************
1439 *                              wodDsDesc                 [internal]
1440 */
1441 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
1442 {
1443     /* The DirectSound HEL will automatically wrap a non-DirectSound-capable
1444      * driver in a DirectSound adaptor, thus allowing the driver to be used by
1445      * DirectSound clients.  However, it only does this if we respond
1446      * successfully to the DRV_QUERYDSOUNDDESC message.  It's enough to fill in
1447      * the driver and device names of the description output parameter. */
1448     memcpy(desc, &(WOutDev[wDevID].cadev->ds_desc), sizeof(DSDRIVERDESC));
1449     return MMSYSERR_NOERROR;
1450 }
1451
1452 /**************************************************************************
1453 *                               wodMessage (WINECOREAUDIO.7)
1454 */
1455 DWORD WINAPI CoreAudio_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1456                                   DWORD dwParam1, DWORD dwParam2)
1457 {
1458     TRACE("(%u, %s, %08x, %08x, %08x);\n",
1459           wDevID, getMessage(wMsg), dwUser, dwParam1, dwParam2);
1460
1461     switch (wMsg) {
1462         case DRVM_INIT:
1463         case DRVM_EXIT:
1464         case DRVM_ENABLE:
1465         case DRVM_DISABLE:
1466
1467             /* FIXME: Pretend this is supported */
1468             return 0;
1469         case WODM_OPEN:         return wodOpen(wDevID, (LPWAVEOPENDESC) dwParam1, dwParam2);
1470         case WODM_CLOSE:        return wodClose(wDevID);
1471         case WODM_WRITE:        return wodWrite(wDevID, (LPWAVEHDR) dwParam1, dwParam2);
1472         case WODM_PAUSE:        return wodPause(wDevID);
1473         case WODM_GETPOS:       return wodGetPosition(wDevID, (LPMMTIME) dwParam1, dwParam2);
1474         case WODM_BREAKLOOP:    return MMSYSERR_NOTSUPPORTED;
1475         case WODM_PREPARE:      return wodPrepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
1476         case WODM_UNPREPARE:    return wodUnprepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
1477
1478         case WODM_GETDEVCAPS:   return wodGetDevCaps(wDevID, (LPWAVEOUTCAPSW) dwParam1, dwParam2);
1479         case WODM_GETNUMDEVS:   return wodGetNumDevs();
1480
1481         case WODM_GETPITCH:
1482         case WODM_SETPITCH:
1483         case WODM_GETPLAYBACKRATE:
1484         case WODM_SETPLAYBACKRATE:      return MMSYSERR_NOTSUPPORTED;
1485         case WODM_GETVOLUME:    return wodGetVolume(wDevID, (LPDWORD)dwParam1);
1486         case WODM_SETVOLUME:    return wodSetVolume(wDevID, dwParam1);
1487         case WODM_RESTART:      return wodRestart(wDevID);
1488         case WODM_RESET:        return wodReset(wDevID);
1489
1490         case DRV_QUERYDEVICEINTERFACESIZE:  return wodDevInterfaceSize (wDevID, (LPDWORD)dwParam1);
1491         case DRV_QUERYDEVICEINTERFACE:      return wodDevInterface (wDevID, (PWCHAR)dwParam1, dwParam2);
1492         case DRV_QUERYDSOUNDIFACE:  return wodDsCreate  (wDevID, (PIDSDRIVER*)dwParam1);
1493         case DRV_QUERYDSOUNDDESC:   return wodDsDesc    (wDevID, (PDSDRIVERDESC)dwParam1);
1494
1495         default:
1496             FIXME("unknown message %d!\n", wMsg);
1497     }
1498
1499     return MMSYSERR_NOTSUPPORTED;
1500 }
1501
1502 /*======================================================================*
1503 *                  Low level DSOUND implementation                      *
1504 *======================================================================*/
1505
1506 typedef struct IDsDriverImpl IDsDriverImpl;
1507 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
1508
1509 struct IDsDriverImpl
1510 {
1511     /* IUnknown fields */
1512     const IDsDriverVtbl *lpVtbl;
1513     DWORD               ref;
1514     /* IDsDriverImpl fields */
1515     UINT                wDevID;
1516     IDsDriverBufferImpl*primary;
1517 };
1518
1519 struct IDsDriverBufferImpl
1520 {
1521     /* IUnknown fields */
1522     const IDsDriverBufferVtbl *lpVtbl;
1523     DWORD ref;
1524     /* IDsDriverBufferImpl fields */
1525     IDsDriverImpl* drv;
1526     DWORD buflen;
1527 };
1528
1529
1530 /*
1531     CoreAudio IO threaded callback,
1532     we can't call Wine debug channels, critical section or anything using NtCurrentTeb here.
1533 */
1534 OSStatus CoreAudio_woAudioUnitIOProc(void *inRefCon,
1535                                      AudioUnitRenderActionFlags *ioActionFlags,
1536                                      const AudioTimeStamp *inTimeStamp,
1537                                      UInt32 inBusNumber,
1538                                      UInt32 inNumberFrames,
1539                                      AudioBufferList *ioData)
1540 {
1541     UInt32 buffer;
1542     WINE_WAVEOUT *wwo = (WINE_WAVEOUT *) inRefCon;
1543     int needNotify = 0;
1544
1545     unsigned int dataNeeded = ioData->mBuffers[0].mDataByteSize;
1546     unsigned int dataProvided = 0;
1547
1548     OSSpinLockLock(&wwo->lock);
1549
1550     while (dataNeeded > 0 && wwo->state == WINE_WS_PLAYING && wwo->lpPlayPtr)
1551     {
1552         unsigned int available = wwo->lpPlayPtr->dwBufferLength - wwo->dwPartialOffset;
1553         unsigned int toCopy;
1554
1555         if (available >= dataNeeded)
1556             toCopy = dataNeeded;
1557         else
1558             toCopy = available;
1559
1560         if (toCopy > 0)
1561         {
1562             memcpy((char*)ioData->mBuffers[0].mData + dataProvided,
1563                 wwo->lpPlayPtr->lpData + wwo->dwPartialOffset, toCopy);
1564             wwo->dwPartialOffset += toCopy;
1565             wwo->dwPlayedTotal += toCopy;
1566             dataProvided += toCopy;
1567             dataNeeded -= toCopy;
1568             available -= toCopy;
1569         }
1570
1571         if (available == 0)
1572         {
1573             wodHelper_PlayPtrNext(wwo);
1574             needNotify = 1;
1575         }
1576     }
1577
1578     OSSpinLockUnlock(&wwo->lock);
1579
1580     /* We can't provide any more wave data.  Fill the rest with silence. */
1581     if (dataNeeded > 0)
1582     {
1583         if (!dataProvided)
1584             *ioActionFlags |= kAudioUnitRenderAction_OutputIsSilence;
1585         memset((char*)ioData->mBuffers[0].mData + dataProvided, 0, dataNeeded);
1586         dataProvided += dataNeeded;
1587         dataNeeded = 0;
1588     }
1589
1590     /* We only fill buffer 0.  Set any others that might be requested to 0. */
1591     for (buffer = 1; buffer < ioData->mNumberBuffers; buffer++)
1592     {
1593         memset(ioData->mBuffers[buffer].mData, 0, ioData->mBuffers[buffer].mDataByteSize);
1594     }
1595
1596     if (needNotify) wodSendNotifyCompletionsMessage(wwo);
1597     return noErr;
1598 }
1599
1600
1601 /*======================================================================*
1602  *                  Low level WAVE IN implementation                    *
1603  *======================================================================*/
1604
1605 /**************************************************************************
1606  *                      widNotifyClient                 [internal]
1607  */
1608 static DWORD widNotifyClient(WINE_WAVEIN* wwi, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
1609 {
1610     TRACE("wMsg = 0x%04x dwParm1 = %04X dwParam2 = %04X\n", wMsg, dwParam1, dwParam2);
1611
1612     switch (wMsg)
1613     {
1614         case WIM_OPEN:
1615         case WIM_CLOSE:
1616         case WIM_DATA:
1617             if (wwi->wFlags != DCB_NULL &&
1618                 !DriverCallback(wwi->waveDesc.dwCallback, wwi->wFlags,
1619                                 (HDRVR)wwi->waveDesc.hWave, wMsg, wwi->waveDesc.dwInstance,
1620                                 dwParam1, dwParam2))
1621             {
1622                 WARN("can't notify client !\n");
1623                 return MMSYSERR_ERROR;
1624             }
1625             break;
1626         default:
1627             FIXME("Unknown callback message %u\n", wMsg);
1628             return MMSYSERR_INVALPARAM;
1629     }
1630     return MMSYSERR_NOERROR;
1631 }
1632
1633
1634 /**************************************************************************
1635  *                      widHelper_NotifyCompletions              [internal]
1636  */
1637 static void widHelper_NotifyCompletions(WINE_WAVEIN* wwi)
1638 {
1639     LPWAVEHDR       lpWaveHdr;
1640     LPWAVEHDR       lpFirstDoneWaveHdr = NULL;
1641     LPWAVEHDR       lpLastDoneWaveHdr = NULL;
1642
1643     OSSpinLockLock(&wwi->lock);
1644
1645     /* First, excise all of the done headers from the queue into
1646      * a free-standing list. */
1647
1648     /* Start from lpQueuePtr and keep notifying until:
1649         * - we hit an unfilled wavehdr
1650         * - we hit the end of the list
1651         */
1652     for (
1653         lpWaveHdr = wwi->lpQueuePtr;
1654         lpWaveHdr &&
1655             lpWaveHdr->dwBytesRecorded >= lpWaveHdr->dwBufferLength;
1656         lpWaveHdr = lpWaveHdr->lpNext
1657         )
1658     {
1659         if (!lpFirstDoneWaveHdr)
1660             lpFirstDoneWaveHdr = lpWaveHdr;
1661         lpLastDoneWaveHdr = lpWaveHdr;
1662     }
1663
1664     if (lpLastDoneWaveHdr)
1665     {
1666         wwi->lpQueuePtr = lpLastDoneWaveHdr->lpNext;
1667         lpLastDoneWaveHdr->lpNext = NULL;
1668     }
1669
1670     OSSpinLockUnlock(&wwi->lock);
1671
1672     /* Now, send the "done" notification for each header in our list. */
1673     for (lpWaveHdr = lpFirstDoneWaveHdr; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext)
1674     {
1675         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1676         lpWaveHdr->dwFlags |= WHDR_DONE;
1677
1678         widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
1679     }
1680 }
1681
1682
1683 /**************************************************************************
1684  *                      widGetDevCaps                           [internal]
1685  */
1686 static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPSW lpCaps, DWORD dwSize)
1687 {
1688     TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
1689
1690     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1691
1692     if (wDevID >= MAX_WAVEINDRV)
1693     {
1694         TRACE("MAX_WAVEINDRV reached !\n");
1695         return MMSYSERR_BADDEVICEID;
1696     }
1697
1698     memcpy(lpCaps, &WInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1699     return MMSYSERR_NOERROR;
1700 }
1701
1702
1703 /**************************************************************************
1704  *                    widHelper_DestroyAudioBufferList           [internal]
1705  * Convenience function to dispose of our audio buffers
1706  */
1707 static void widHelper_DestroyAudioBufferList(AudioBufferList* list)
1708 {
1709     if (list)
1710     {
1711         UInt32 i;
1712         for (i = 0; i < list->mNumberBuffers; i++)
1713         {
1714             if (list->mBuffers[i].mData)
1715                 HeapFree(GetProcessHeap(), 0, list->mBuffers[i].mData);
1716         }
1717         HeapFree(GetProcessHeap(), 0, list);
1718     }
1719 }
1720
1721
1722 /**************************************************************************
1723  *                    widHelper_AllocateAudioBufferList          [internal]
1724  * Convenience function to allocate our audio buffers
1725  */
1726 static AudioBufferList* widHelper_AllocateAudioBufferList(UInt32 numChannels, UInt32 size)
1727 {
1728     AudioBufferList*            list;
1729     UInt32                      i;
1730
1731     list = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioBufferList) + numChannels * sizeof(AudioBuffer));
1732     if (list == NULL)
1733         return NULL;
1734
1735     list->mNumberBuffers = numChannels;
1736     for (i = 0; i < numChannels; ++i)
1737     {
1738         list->mBuffers[i].mNumberChannels = 1;
1739         list->mBuffers[i].mDataByteSize = size;
1740         list->mBuffers[i].mData = HeapAlloc(GetProcessHeap(), 0, size);
1741         if (list->mBuffers[i].mData == NULL)
1742         {
1743             widHelper_DestroyAudioBufferList(list);
1744             return NULL;
1745         }
1746     }
1747     return list;
1748 }
1749
1750
1751 /**************************************************************************
1752  *                              widOpen                         [internal]
1753  */
1754 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1755 {
1756     WINE_WAVEIN*    wwi;
1757     UInt32          frameCount;
1758     UInt32          bytesPerFrame;
1759
1760     TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
1761     if (lpDesc == NULL)
1762     {
1763         WARN("Invalid Parameter !\n");
1764         return MMSYSERR_INVALPARAM;
1765     }
1766     if (wDevID >= MAX_WAVEINDRV)
1767     {
1768         TRACE ("MAX_WAVEINDRV reached !\n");
1769         return MMSYSERR_BADDEVICEID;
1770     }
1771
1772     TRACE("Format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
1773           lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1774           lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
1775
1776     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1777         lpDesc->lpFormat->nChannels == 0 ||
1778         lpDesc->lpFormat->nSamplesPerSec == 0
1779         )
1780     {
1781         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
1782              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1783              lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
1784         return WAVERR_BADFORMAT;
1785     }
1786
1787     if (dwFlags & WAVE_FORMAT_QUERY)
1788     {
1789         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1790               lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1791               lpDesc->lpFormat->nSamplesPerSec);
1792         return MMSYSERR_NOERROR;
1793     }
1794
1795     wwi = &WInDev[wDevID];
1796     if (!OSSpinLockTry(&wwi->lock))
1797         return MMSYSERR_ALLOCATED;
1798
1799     if (wwi->state != WINE_WS_CLOSED)
1800     {
1801         OSSpinLockUnlock(&wwi->lock);
1802         return MMSYSERR_ALLOCATED;
1803     }
1804
1805     wwi->state = WINE_WS_STOPPED;
1806     wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1807
1808     memcpy(&wwi->waveDesc, lpDesc,              sizeof(WAVEOPENDESC));
1809     memcpy(&wwi->format,   lpDesc->lpFormat,    sizeof(PCMWAVEFORMAT));
1810
1811     if (wwi->format.wBitsPerSample == 0)
1812     {
1813         WARN("Resetting zeroed wBitsPerSample\n");
1814         wwi->format.wBitsPerSample = 8 *
1815             (wwi->format.wf.nAvgBytesPerSec /
1816             wwi->format.wf.nSamplesPerSec) /
1817             wwi->format.wf.nChannels;
1818     }
1819
1820     wwi->dwTotalRecorded = 0;
1821
1822     wwi->trace_on = TRACE_ON(wave);
1823     wwi->warn_on  = WARN_ON(wave);
1824     wwi->err_on   = ERR_ON(wave);
1825
1826     if (!AudioUnit_CreateInputUnit(wwi, &wwi->audioUnit,
1827         wwi->format.wf.nChannels, wwi->format.wf.nSamplesPerSec,
1828         wwi->format.wBitsPerSample, &frameCount))
1829     {
1830         ERR("AudioUnit_CreateInputUnit failed\n");
1831         OSSpinLockUnlock(&wwi->lock);
1832         return MMSYSERR_ERROR;
1833     }
1834
1835     /* Allocate our audio buffers */
1836     /* For interleaved audio, we allocate one buffer for all channels. */
1837     bytesPerFrame = wwi->format.wBitsPerSample * wwi->format.wf.nChannels / 8;
1838     wwi->bufferList = widHelper_AllocateAudioBufferList(1, wwi->format.wf.nChannels * frameCount * bytesPerFrame);
1839     if (wwi->bufferList == NULL)
1840     {
1841         ERR("Failed to allocate buffer list\n");
1842         AudioUnitUninitialize(wwi->audioUnit);
1843         AudioUnit_CloseAudioUnit(wwi->audioUnit);
1844         OSSpinLockUnlock(&wwi->lock);
1845         return MMSYSERR_NOMEM;
1846     }
1847
1848     OSSpinLockUnlock(&wwi->lock);
1849
1850     return widNotifyClient(wwi, WIM_OPEN, 0L, 0L);
1851 }
1852
1853
1854 /**************************************************************************
1855  *                              widClose                        [internal]
1856  */
1857 static DWORD widClose(WORD wDevID)
1858 {
1859     DWORD           ret = MMSYSERR_NOERROR;
1860     WINE_WAVEIN*    wwi;
1861
1862     TRACE("(%u);\n", wDevID);
1863
1864     if (wDevID >= MAX_WAVEINDRV)
1865     {
1866         WARN("bad device ID !\n");
1867         return MMSYSERR_BADDEVICEID;
1868     }
1869
1870     wwi = &WInDev[wDevID];
1871     OSSpinLockLock(&wwi->lock);
1872     if (wwi->state == WINE_WS_CLOSED)
1873     {
1874         WARN("Device already closed.\n");
1875         ret = MMSYSERR_INVALHANDLE;
1876     }
1877     else if (wwi->lpQueuePtr)
1878     {
1879         WARN("Buffers in queue.\n");
1880         ret = WAVERR_STILLPLAYING;
1881     }
1882     else
1883     {
1884         wwi->state = WINE_WS_CLOSED;
1885     }
1886
1887     OSSpinLockUnlock(&wwi->lock);
1888
1889     if (ret == MMSYSERR_NOERROR)
1890     {
1891         OSStatus err = AudioUnitUninitialize(wwi->audioUnit);
1892         if (err)
1893         {
1894             ERR("AudioUnitUninitialize return %c%c%c%c\n", (char) (err >> 24),
1895                                                            (char) (err >> 16),
1896                                                            (char) (err >> 8),
1897                                                            (char) err);
1898         }
1899
1900         if (!AudioUnit_CloseAudioUnit(wwi->audioUnit))
1901         {
1902             ERR("Can't close AudioUnit\n");
1903         }
1904
1905         /* Dellocate our audio buffers */
1906         widHelper_DestroyAudioBufferList(wwi->bufferList);
1907         wwi->bufferList = NULL;
1908
1909         ret = widNotifyClient(wwi, WIM_CLOSE, 0L, 0L);
1910     }
1911
1912     return ret;
1913 }
1914
1915
1916 /**************************************************************************
1917  *                              widAddBuffer            [internal]
1918  */
1919 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1920 {
1921     DWORD           ret = MMSYSERR_NOERROR;
1922     WINE_WAVEIN*    wwi;
1923
1924     TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
1925
1926     if (wDevID >= MAX_WAVEINDRV)
1927     {
1928         WARN("invalid device ID\n");
1929         return MMSYSERR_INVALHANDLE;
1930     }
1931     if (!(lpWaveHdr->dwFlags & WHDR_PREPARED))
1932     {
1933         TRACE("never been prepared !\n");
1934         return WAVERR_UNPREPARED;
1935     }
1936     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1937     {
1938         TRACE("header already in use !\n");
1939         return WAVERR_STILLPLAYING;
1940     }
1941
1942     wwi = &WInDev[wDevID];
1943     OSSpinLockLock(&wwi->lock);
1944
1945     if (wwi->state == WINE_WS_CLOSED)
1946     {
1947         WARN("Trying to add buffer to closed device.\n");
1948         ret = MMSYSERR_INVALHANDLE;
1949     }
1950     else
1951     {
1952         LPWAVEHDR* wh;
1953
1954         lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1955         lpWaveHdr->dwFlags &= ~WHDR_DONE;
1956         lpWaveHdr->dwBytesRecorded = 0;
1957         lpWaveHdr->lpNext = NULL;
1958
1959         /* insert buffer at end of queue */
1960         for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext))
1961             /* Do nothing */;
1962         *wh = lpWaveHdr;
1963     }
1964
1965     OSSpinLockUnlock(&wwi->lock);
1966
1967     return ret;
1968 }
1969
1970
1971 /**************************************************************************
1972  *                      widStart                                [internal]
1973  */
1974 static DWORD widStart(WORD wDevID)
1975 {
1976     DWORD           ret = MMSYSERR_NOERROR;
1977     WINE_WAVEIN*    wwi;
1978
1979     TRACE("(%u);\n", wDevID);
1980     if (wDevID >= MAX_WAVEINDRV)
1981     {
1982         WARN("invalid device ID\n");
1983         return MMSYSERR_INVALHANDLE;
1984     }
1985
1986     /* The order of the following operations is important since we can't hold
1987      * the mutex while we make an Audio Unit call.  Set the PLAYING state
1988      * before starting the Audio Unit.  In widStop, the order is reversed.
1989      * This guarantees that we can't get into a situation where the state is
1990      * PLAYING but the Audio Unit isn't running.  Although we can be in STOPPED
1991      * state with the Audio Unit still running, that's harmless because the
1992      * input callback will just throw away the sound data.
1993      */
1994     wwi = &WInDev[wDevID];
1995     OSSpinLockLock(&wwi->lock);
1996
1997     if (wwi->state == WINE_WS_CLOSED)
1998     {
1999         WARN("Trying to start closed device.\n");
2000         ret = MMSYSERR_INVALHANDLE;
2001     }
2002     else
2003         wwi->state = WINE_WS_PLAYING;
2004
2005     OSSpinLockUnlock(&wwi->lock);
2006
2007     if (ret == MMSYSERR_NOERROR)
2008     {
2009         /* Start pulling for audio data */
2010         OSStatus err = AudioOutputUnitStart(wwi->audioUnit);
2011         if (err != noErr)
2012             ERR("Failed to start AU: %08lx\n", err);
2013
2014         TRACE("Recording started...\n");
2015     }
2016
2017     return ret;
2018 }
2019
2020
2021 /**************************************************************************
2022  *                      widStop                                 [internal]
2023  */
2024 static DWORD widStop(WORD wDevID)
2025 {
2026     DWORD           ret = MMSYSERR_NOERROR;
2027     WINE_WAVEIN*    wwi;
2028     WAVEHDR*        lpWaveHdr = NULL;
2029     OSStatus        err;
2030
2031     TRACE("(%u);\n", wDevID);
2032     if (wDevID >= MAX_WAVEINDRV)
2033     {
2034         WARN("invalid device ID\n");
2035         return MMSYSERR_INVALHANDLE;
2036     }
2037
2038     wwi = &WInDev[wDevID];
2039
2040     /* The order of the following operations is important since we can't hold
2041      * the mutex while we make an Audio Unit call.  Stop the Audio Unit before
2042      * setting the STOPPED state.  In widStart, the order is reversed.  This
2043      * guarantees that we can't get into a situation where the state is
2044      * PLAYING but the Audio Unit isn't running.  Although we can be in STOPPED
2045      * state with the Audio Unit still running, that's harmless because the
2046      * input callback will just throw away the sound data.
2047      */
2048     err = AudioOutputUnitStop(wwi->audioUnit);
2049     if (err != noErr)
2050         WARN("Failed to stop AU: %08lx\n", err);
2051
2052     TRACE("Recording stopped.\n");
2053
2054     OSSpinLockLock(&wwi->lock);
2055
2056     if (wwi->state == WINE_WS_CLOSED)
2057     {
2058         WARN("Trying to stop closed device.\n");
2059         ret = MMSYSERR_INVALHANDLE;
2060     }
2061     else if (wwi->state != WINE_WS_STOPPED)
2062     {
2063         wwi->state = WINE_WS_STOPPED;
2064         /* If there's a buffer in progress, it's done.  Remove it from the
2065          * queue so that we can return it to the app, below. */
2066         if (wwi->lpQueuePtr)
2067         {
2068             lpWaveHdr = wwi->lpQueuePtr;
2069             wwi->lpQueuePtr = lpWaveHdr->lpNext;
2070         }
2071     }
2072
2073     OSSpinLockUnlock(&wwi->lock);
2074
2075     if (lpWaveHdr)
2076     {
2077         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2078         lpWaveHdr->dwFlags |= WHDR_DONE;
2079         widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
2080     }
2081
2082     return ret;
2083 }
2084
2085
2086 /**************************************************************************
2087  *                      widReset                                [internal]
2088  */
2089 static DWORD widReset(WORD wDevID)
2090 {
2091     DWORD           ret = MMSYSERR_NOERROR;
2092     WINE_WAVEIN*    wwi;
2093     WAVEHDR*        lpWaveHdr = NULL;
2094
2095     TRACE("(%u);\n", wDevID);
2096     if (wDevID >= MAX_WAVEINDRV)
2097     {
2098         WARN("invalid device ID\n");
2099         return MMSYSERR_INVALHANDLE;
2100     }
2101
2102     wwi = &WInDev[wDevID];
2103     OSSpinLockLock(&wwi->lock);
2104
2105     if (wwi->state == WINE_WS_CLOSED)
2106     {
2107         WARN("Trying to reset a closed device.\n");
2108         ret = MMSYSERR_INVALHANDLE;
2109     }
2110     else
2111     {
2112         lpWaveHdr               = wwi->lpQueuePtr;
2113         wwi->lpQueuePtr         = NULL;
2114         wwi->state              = WINE_WS_STOPPED;
2115         wwi->dwTotalRecorded    = 0;
2116     }
2117
2118     OSSpinLockUnlock(&wwi->lock);
2119
2120     if (ret == MMSYSERR_NOERROR)
2121     {
2122         OSStatus err = AudioOutputUnitStop(wwi->audioUnit);
2123         if (err != noErr)
2124             WARN("Failed to stop AU: %08lx\n", err);
2125
2126         TRACE("Recording stopped.\n");
2127     }
2128
2129     while (lpWaveHdr)
2130     {
2131         WAVEHDR* lpNext = lpWaveHdr->lpNext;
2132
2133         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2134         lpWaveHdr->dwFlags |= WHDR_DONE;
2135         widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
2136
2137         lpWaveHdr = lpNext;
2138     }
2139
2140     return ret;
2141 }
2142
2143
2144 /**************************************************************************
2145  *                              widGetNumDevs                   [internal]
2146  */
2147 static DWORD widGetNumDevs(void)
2148 {
2149     return MAX_WAVEINDRV;
2150 }
2151
2152
2153 /**************************************************************************
2154  *                              widDevInterfaceSize             [internal]
2155  */
2156 static DWORD widDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
2157 {
2158     TRACE("(%u, %p)\n", wDevID, dwParam1);
2159
2160     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2161                                     NULL, 0 ) * sizeof(WCHAR);
2162     return MMSYSERR_NOERROR;
2163 }
2164
2165
2166 /**************************************************************************
2167  *                              widDevInterface                 [internal]
2168  */
2169 static DWORD widDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
2170 {
2171     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2172                                         NULL, 0 ) * sizeof(WCHAR))
2173     {
2174         MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2175                             dwParam1, dwParam2 / sizeof(WCHAR));
2176         return MMSYSERR_NOERROR;
2177     }
2178     return MMSYSERR_INVALPARAM;
2179 }
2180
2181
2182 /**************************************************************************
2183  *                              widMessage (WINECOREAUDIO.6)
2184  */
2185 DWORD WINAPI CoreAudio_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2186                             DWORD dwParam1, DWORD dwParam2)
2187 {
2188     TRACE("(%u, %04X, %08X, %08X, %08X);\n",
2189             wDevID, wMsg, dwUser, dwParam1, dwParam2);
2190
2191     switch (wMsg)
2192     {
2193         case DRVM_INIT:
2194         case DRVM_EXIT:
2195         case DRVM_ENABLE:
2196         case DRVM_DISABLE:
2197             /* FIXME: Pretend this is supported */
2198             return 0;
2199         case WIDM_OPEN:             return widOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,  dwParam2);
2200         case WIDM_CLOSE:            return widClose         (wDevID);
2201         case WIDM_ADDBUFFER:        return widAddBuffer     (wDevID, (LPWAVEHDR)dwParam1,       dwParam2);
2202         case WIDM_PREPARE:          return MMSYSERR_NOTSUPPORTED;
2203         case WIDM_UNPREPARE:        return MMSYSERR_NOTSUPPORTED;
2204         case WIDM_GETDEVCAPS:       return widGetDevCaps    (wDevID, (LPWAVEINCAPSW)dwParam1,   dwParam2);
2205         case WIDM_GETNUMDEVS:       return widGetNumDevs    ();
2206         case WIDM_RESET:            return widReset         (wDevID);
2207         case WIDM_START:            return widStart         (wDevID);
2208         case WIDM_STOP:             return widStop          (wDevID);
2209         case DRV_QUERYDEVICEINTERFACESIZE: return widDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
2210         case DRV_QUERYDEVICEINTERFACE:     return widDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
2211         default:
2212             FIXME("unknown message %d!\n", wMsg);
2213     }
2214
2215     return MMSYSERR_NOTSUPPORTED;
2216 }
2217
2218
2219 OSStatus CoreAudio_wiAudioUnitIOProc(void *inRefCon,
2220                                      AudioUnitRenderActionFlags *ioActionFlags,
2221                                      const AudioTimeStamp *inTimeStamp,
2222                                      UInt32 inBusNumber,
2223                                      UInt32 inNumberFrames,
2224                                      AudioBufferList *ioData)
2225 {
2226     WINE_WAVEIN*    wwi = (WINE_WAVEIN*)inRefCon;
2227     OSStatus        err = noErr;
2228     BOOL            needNotify = FALSE;
2229     WAVEHDR*        lpStorePtr;
2230     unsigned int    dataToStore;
2231     unsigned int    dataStored = 0;
2232
2233
2234     if (wwi->trace_on)
2235         fprintf(stderr, "trace:wave:CoreAudio_wiAudioUnitIOProc (ioActionFlags = %08lx, "
2236             "inTimeStamp = { %f, %x%08x, %f, %x%08x, %08lx }, inBusNumber = %lu, inNumberFrames = %lu)\n",
2237             *ioActionFlags, inTimeStamp->mSampleTime, (DWORD)(inTimeStamp->mHostTime >>32),
2238             (DWORD)inTimeStamp->mHostTime, inTimeStamp->mRateScalar, (DWORD)(inTimeStamp->mWordClockTime >> 32),
2239             (DWORD)inTimeStamp->mWordClockTime, inTimeStamp->mFlags, inBusNumber, inNumberFrames);
2240
2241     /* Render into audio buffer */
2242     /* FIXME: implement sample rate conversion on input.  This will require
2243      * a different render strategy.  We'll need to buffer the sound data
2244      * received here and pass it off to an AUConverter in another thread. */
2245     err = AudioUnitRender(wwi->audioUnit, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, wwi->bufferList);
2246     if (err)
2247     {
2248         if (wwi->err_on)
2249             fprintf(stderr, "err:wave:CoreAudio_wiAudioUnitIOProc AudioUnitRender failed with error %li\n", err);
2250         return err;
2251     }
2252
2253     /* Copy from audio buffer to the wavehdrs */
2254     dataToStore = wwi->bufferList->mBuffers[0].mDataByteSize;
2255
2256     OSSpinLockLock(&wwi->lock);
2257
2258     lpStorePtr = wwi->lpQueuePtr;
2259
2260     while (dataToStore > 0 && wwi->state == WINE_WS_PLAYING && lpStorePtr)
2261     {
2262         unsigned int room = lpStorePtr->dwBufferLength - lpStorePtr->dwBytesRecorded;
2263         unsigned int toCopy;
2264
2265         if (wwi->trace_on)
2266             fprintf(stderr, "trace:wave:CoreAudio_wiAudioUnitIOProc Looking to store %u bytes to wavehdr %p, which has room for %u\n",
2267                 dataToStore, lpStorePtr, room);
2268
2269         if (room >= dataToStore)
2270             toCopy = dataToStore;
2271         else
2272             toCopy = room;
2273
2274         if (toCopy > 0)
2275         {
2276             memcpy(lpStorePtr->lpData + lpStorePtr->dwBytesRecorded,
2277                 (char*)wwi->bufferList->mBuffers[0].mData + dataStored, toCopy);
2278             lpStorePtr->dwBytesRecorded += toCopy;
2279             wwi->dwTotalRecorded += toCopy;
2280             dataStored += toCopy;
2281             dataToStore -= toCopy;
2282             room -= toCopy;
2283         }
2284
2285         if (room == 0)
2286         {
2287             lpStorePtr = lpStorePtr->lpNext;
2288             needNotify = TRUE;
2289         }
2290     }
2291
2292     OSSpinLockUnlock(&wwi->lock);
2293
2294     if (needNotify) wodSendNotifyInputCompletionsMessage(wwi);
2295     return err;
2296 }
2297
2298 #else
2299
2300 /**************************************************************************
2301  *                              widMessage (WINECOREAUDIO.6)
2302  */
2303 DWORD WINAPI CoreAudio_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2304                             DWORD dwParam1, DWORD dwParam2)
2305 {
2306     FIXME("(%u, %04X, %08X, %08X, %08X): CoreAudio support not compiled into wine\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2307     return MMSYSERR_NOTENABLED;
2308 }
2309
2310 /**************************************************************************
2311 *                               wodMessage (WINECOREAUDIO.7)
2312 */
2313 DWORD WINAPI CoreAudio_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2314                                   DWORD dwParam1, DWORD dwParam2)
2315 {
2316     FIXME("(%u, %04X, %08X, %08X, %08X): CoreAudio support not compiled into wine\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2317     return MMSYSERR_NOTENABLED;
2318 }
2319
2320 #endif