dlls/winmm/waveform.c

   1 /*
   2  * Copyright 1993      Martin Ayotte
   3  *           1998-2002 Eric Pouech
   4  *           2011 Andrew Eikum for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27 #define COBJMACROS
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "mmsystem.h"
  32 #include "mmreg.h"
  33 #include "msacm.h"
  34 #include "winuser.h"
  35 #include "winnls.h"
  36 #include "winternl.h"
  37
  38 #include "winemm.h"
  39
  40 #include "ole2.h"
  41 #include "initguid.h"
  42 #include "devpkey.h"
  43 #include "mmdeviceapi.h"
  44 #include "audioclient.h"
  45 #include "audiopolicy.h"
  46
  47 #include "wine/debug.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  50
  51 /* FIXME: Should be localized */
  52 static const WCHAR volumeW[] = {'V','o','l','u','m','e',0};
  53 static const WCHAR mastervolumeW[] = {'M','a','s','t','e','r',' ','V','o','l',
  54     'u','m','e',0};
  55 static const WCHAR muteW[] = {'M','u','t','e',0};
  56
  57 /* HWAVE (and HMIXER) format:
  58  *
  59  * XXXX... 1FDD DDDD IIII IIII
  60  * X = unused (must be 0)
  61  * 1 = the bit is set to 1, to avoid all-zero HWAVEs
  62  * F = flow direction (0 = IN, 1 = OUT)
  63  * D = index into g_out_mmdevices
  64  * I = index in the mmdevice's devices array
  65  *
  66  * Two reasons that we don't just use pointers:
  67  *   - HWAVEs must fit into 16 bits for compatibility with old applications.
  68  *   - We must be able to identify bad devices without crashing.
  69  */
  70
  71 #define MAX_DEVICES 256
  72
  73 typedef struct _WINMM_CBInfo {
  74     DWORD_PTR callback;
  75     DWORD_PTR user;
  76     DWORD flags;
  77     HWAVE hwave;
  78 } WINMM_CBInfo;
  79
  80 struct _WINMM_MMDevice;
  81 typedef struct _WINMM_MMDevice WINMM_MMDevice;
  82
  83 typedef struct _WINMM_Device {
  84     WINMM_CBInfo cb_info;
  85
  86     HWAVE handle;
  87
  88     BOOL open;
  89
  90     IMMDevice *device;
  91     IAudioClient *client;
  92     IAudioRenderClient *render;
  93     IAudioCaptureClient *capture;
  94     IAudioClock *clock;
  95     IAudioStreamVolume *volume;
  96
  97     HACMSTREAM acm_handle;
  98     ACMSTREAMHEADER acm_hdr;
  99     UINT32 acm_offs;
 100
 101     WAVEHDR *first, *last, *playing, *loop_start;
 102
 103     BOOL stopped;
 104     DWORD loop_counter;
 105     UINT32 bytes_per_frame, samples_per_sec, ofs_bytes, played_frames;
 106
 107     /* stored in frames of sample rate, *not* AC::GetFrequency */
 108     UINT64 last_clock_pos;
 109
 110     HANDLE event;
 111     CRITICAL_SECTION lock;
 112
 113     WINMM_MMDevice *parent;
 114 } WINMM_Device;
 115
 116 struct _WINMM_MMDevice {
 117     WAVEOUTCAPSW out_caps; /* must not be modified outside of WINMM_InitMMDevices*/
 118     WAVEINCAPSW in_caps; /* must not be modified outside of WINMM_InitMMDevices*/
 119     WCHAR *dev_id;
 120
 121     ISimpleAudioVolume *volume;
 122
 123     GUID session;
 124
 125     /* HMIXER format is the same as the HWAVE format, but the I bits are
 126      * replaced by the value of this counter, to keep each HMIXER unique */
 127     UINT mixer_count;
 128
 129     CRITICAL_SECTION lock;
 130
 131     WINMM_Device *devices[MAX_DEVICES];
 132 };
 133
 134 static WINMM_MMDevice *g_out_mmdevices;
 135 static UINT g_outmmdevices_count;
 136
 137 static WINMM_MMDevice *g_in_mmdevices;
 138 static UINT g_inmmdevices_count;
 139
 140 static IMMDeviceEnumerator *g_devenum;
 141
 142 #define WINMM_WM_QUIT WM_USER
 143
 144 static CRITICAL_SECTION g_devthread_lock;
 145 static CRITICAL_SECTION_DEBUG g_devthread_lock_debug =
 146 {
 147     0, 0, &g_devthread_lock,
 148     { &g_devthread_lock_debug.ProcessLocksList, &g_devthread_lock_debug.ProcessLocksList },
 149       0, 0, { (DWORD_PTR)(__FILE__ ": g_devthread_lock") }
 150 };
 151 static CRITICAL_SECTION g_devthread_lock = { &g_devthread_lock_debug, -1, 0, 0, 0, 0 };
 152 static HANDLE g_devices_thread;
 153 static HWND g_devices_hwnd;
 154
 155 static UINT g_devhandle_count;
 156 static HANDLE *g_device_handles;
 157 static WINMM_Device **g_handle_devices;
 158
 159 typedef struct _WINMM_OpenInfo {
 160     HWAVE handle;
 161     UINT req_device;
 162     WAVEFORMATEX *format;
 163     DWORD_PTR callback;
 164     DWORD_PTR cb_user;
 165     DWORD flags;
 166 } WINMM_OpenInfo;
 167
 168 typedef struct _WINMM_ControlDetails {
 169     HMIXEROBJ hmix;
 170     MIXERCONTROLDETAILS *details;
 171     DWORD flags;
 172 } WINMM_ControlDetails;
 173
 174 typedef struct _WINMM_QueryInterfaceInfo {
 175     BOOL is_out;
 176     UINT index;
 177     WCHAR *str;
 178     UINT *len_bytes;
 179 } WINMM_QueryInterfaceInfo;
 180
 181 static LRESULT WOD_Open(WINMM_OpenInfo *info);
 182 static LRESULT WOD_Close(HWAVEOUT hwave);
 183 static LRESULT WID_Open(WINMM_OpenInfo *info);
 184 static LRESULT WID_Close(HWAVEIN hwave);
 185
 186 void WINMM_DeleteWaveform(void)
 187 {
 188     UINT i, j;
 189
 190     if(g_devices_hwnd){
 191         for(i = 0; i < g_outmmdevices_count; ++i){
 192             WINMM_MMDevice *mmdevice = &g_out_mmdevices[i];
 193             for(j = 0; j < MAX_DEVICES && mmdevice->devices[j]; ++j){
 194                 WINMM_Device *device = mmdevice->devices[j];
 195                 SendMessageW(g_devices_hwnd, WODM_CLOSE, (WPARAM)device->handle, 0);
 196             }
 197         }
 198
 199         for(i = 0; i < g_inmmdevices_count; ++i){
 200             WINMM_MMDevice *mmdevice = &g_in_mmdevices[i];
 201             for(j = 0; j < MAX_DEVICES && mmdevice->devices[j]; ++j){
 202                 WINMM_Device *device = mmdevice->devices[j];
 203                 SendMessageW(g_devices_hwnd, WIDM_CLOSE, (WPARAM)device->handle, 0);
 204             }
 205         }
 206
 207         SendMessageW(g_devices_hwnd, WINMM_WM_QUIT, 0, 0);
 208
 209         for(i = 0; i < g_outmmdevices_count; ++i){
 210             WINMM_MMDevice *mmdevice = &g_out_mmdevices[i];
 211
 212             for(j = 0; j < MAX_DEVICES && mmdevice->devices[j]; ++j){
 213                 WINMM_Device *device = mmdevice->devices[j];
 214                 if(device->handle)
 215                     CloseHandle(device->handle);
 216                 DeleteCriticalSection(&device->lock);
 217             }
 218
 219             if(mmdevice->volume)
 220                 ISimpleAudioVolume_Release(mmdevice->volume);
 221             CoTaskMemFree(mmdevice->dev_id);
 222             DeleteCriticalSection(&mmdevice->lock);
 223         }
 224
 225         for(i = 0; i < g_inmmdevices_count; ++i){
 226             WINMM_MMDevice *mmdevice = &g_in_mmdevices[i];
 227
 228             for(j = 0; j < MAX_DEVICES && mmdevice->devices[j]; ++j){
 229                 WINMM_Device *device = mmdevice->devices[j];
 230                 if(device->handle)
 231                     CloseHandle(device->handle);
 232                 DeleteCriticalSection(&device->lock);
 233             }
 234
 235             if(mmdevice->volume)
 236                 ISimpleAudioVolume_Release(mmdevice->volume);
 237             CoTaskMemFree(mmdevice->dev_id);
 238             DeleteCriticalSection(&mmdevice->lock);
 239         }
 240
 241         HeapFree(GetProcessHeap(), 0, g_out_mmdevices);
 242         HeapFree(GetProcessHeap(), 0, g_in_mmdevices);
 243
 244         HeapFree(GetProcessHeap(), 0, g_device_handles);
 245         HeapFree(GetProcessHeap(), 0, g_handle_devices);
 246     }
 247
 248     DeleteCriticalSection(&g_devthread_lock);
 249 }
 250
 251 static inline HWAVE WINMM_MakeHWAVE(UINT mmdevice, BOOL is_out, UINT device)
 252 {
 253     return ULongToHandle((1 << 15) | ((!!is_out) << 14) |
 254             (mmdevice << 8) | device);
 255 }
 256
 257 static inline void WINMM_DecomposeHWAVE(HWAVE hwave, UINT *mmdevice_index,
 258         BOOL *is_out, UINT *device_index, UINT *junk)
 259 {
 260     ULONG32 l = HandleToULong(hwave);
 261     *device_index = l & 0xFF;
 262     *mmdevice_index = (l >> 8) & 0x3F;
 263     *is_out = (l >> 14) & 0x1;
 264     *junk = l >> 15;
 265 }
 266
 267 static void WINMM_InitDevice(WINMM_Device *device,
 268         WINMM_MMDevice *parent, HWAVE hwave)
 269 {
 270     InitializeCriticalSection(&device->lock);
 271     device->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINMM_Device.lock");
 272
 273     device->handle = hwave;
 274     device->parent = parent;
 275 }
 276
 277 /* finds the first unused Device, marks it as "open", and returns
 278  * a pointer to the device
 279  *
 280  * IMPORTANT: it is the caller's responsibility to release the device's lock
 281  * on success
 282  */
 283 static WINMM_Device *WINMM_FindUnusedDevice(BOOL is_out, UINT mmdevice_index)
 284 {
 285     WINMM_MMDevice *mmdevice;
 286     UINT i;
 287
 288     if(is_out)
 289         mmdevice = &g_out_mmdevices[mmdevice_index];
 290     else
 291         mmdevice = &g_in_mmdevices[mmdevice_index];
 292
 293     EnterCriticalSection(&mmdevice->lock);
 294     for(i = 0; i < MAX_DEVICES; ++i){
 295         WINMM_Device *device = mmdevice->devices[i];
 296
 297         if(!device){
 298             device = mmdevice->devices[i] = HeapAlloc(GetProcessHeap(),
 299                     HEAP_ZERO_MEMORY, sizeof(WINMM_Device));
 300             if(!device){
 301                 LeaveCriticalSection(&mmdevice->lock);
 302                 return NULL;
 303             }
 304
 305             WINMM_InitDevice(device, mmdevice,
 306                     WINMM_MakeHWAVE(mmdevice_index, is_out, i));
 307             EnterCriticalSection(&device->lock);
 308         }else
 309             EnterCriticalSection(&device->lock);
 310
 311         if(!device->open){
 312             LeaveCriticalSection(&mmdevice->lock);
 313             device->open = TRUE;
 314             TRACE("Found free device: mmdevice: %u, device id: %u\n",
 315                     mmdevice_index, i);
 316             return device;
 317         }
 318
 319         LeaveCriticalSection(&device->lock);
 320     }
 321
 322     LeaveCriticalSection(&mmdevice->lock);
 323
 324     TRACE("All devices in use: mmdevice: %u\n", mmdevice_index);
 325
 326     return NULL;
 327 }
 328
 329 static inline BOOL WINMM_ValidateAndLock(WINMM_Device *device)
 330 {
 331     if(!device)
 332         return FALSE;
 333
 334     EnterCriticalSection(&device->lock);
 335
 336     if(!device->open){
 337         LeaveCriticalSection(&device->lock);
 338         return FALSE;
 339     }
 340
 341     return TRUE;
 342 }
 343
 344 static WINMM_Device *WINMM_GetDeviceFromHWAVE(HWAVE hwave)
 345 {
 346     WINMM_MMDevice *mmdevice;
 347     WINMM_Device *device;
 348     UINT mmdevice_index, device_index, junk;
 349     BOOL is_out;
 350
 351     WINMM_DecomposeHWAVE(hwave, &mmdevice_index, &is_out, &device_index, &junk);
 352
 353     if(junk != 0x1)
 354         return NULL;
 355
 356     if(mmdevice_index >= (is_out ? g_outmmdevices_count : g_inmmdevices_count))
 357         return NULL;
 358
 359     if(is_out)
 360         mmdevice = &g_out_mmdevices[mmdevice_index];
 361     else
 362         mmdevice = &g_in_mmdevices[mmdevice_index];
 363
 364     EnterCriticalSection(&mmdevice->lock);
 365
 366     device = mmdevice->devices[device_index];
 367
 368     LeaveCriticalSection(&mmdevice->lock);
 369
 370     return device;
 371 }
 372
 373 /* Note: NotifyClient should never be called while holding the device lock
 374  * since the client may call wave* functions from within the callback. */
 375 static inline void WINMM_NotifyClient(WINMM_CBInfo *info, WORD msg, DWORD_PTR param1,
 376         DWORD_PTR param2)
 377 {
 378     DriverCallback(info->callback, info->flags, (HDRVR)info->hwave,
 379         msg, info->user, param1, param2);
 380 }
 381
 382 static HRESULT WINMM_GetFriendlyName(IMMDevice *device, WCHAR *out,
 383         UINT outlen)
 384 {
 385     IPropertyStore *ps;
 386     PROPVARIANT var;
 387     HRESULT hr;
 388
 389     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 390     if(FAILED(hr))
 391         return hr;
 392
 393     PropVariantInit(&var);
 394
 395     hr = IPropertyStore_GetValue(ps,
 396             (PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &var);
 397     if(FAILED(hr)){
 398         IPropertyStore_Release(ps);
 399         return hr;
 400     }
 401
 402     lstrcpynW(out, var.u.pwszVal, outlen);
 403
 404     PropVariantClear(&var);
 405
 406     IPropertyStore_Release(ps);
 407
 408     return S_OK;
 409 }
 410
 411 static HRESULT WINMM_TestFormat(IAudioClient *client, DWORD rate, DWORD depth,
 412         WORD channels)
 413 {
 414     WAVEFORMATEX fmt, *junk;
 415     HRESULT hr;
 416
 417     fmt.wFormatTag = WAVE_FORMAT_PCM;
 418     fmt.nChannels = channels;
 419     fmt.nSamplesPerSec = rate;
 420     fmt.wBitsPerSample = depth;
 421     fmt.nBlockAlign = (channels * depth) / 8;
 422     fmt.nAvgBytesPerSec = rate * fmt.nBlockAlign;
 423     fmt.cbSize = 0;
 424
 425     hr = IAudioClient_IsFormatSupported(client, AUDCLNT_SHAREMODE_SHARED,
 426             &fmt, &junk);
 427     if(SUCCEEDED(hr))
 428         CoTaskMemFree(junk);
 429
 430     return hr;
 431 }
 432
 433 static struct _TestFormat {
 434     DWORD flag;
 435     DWORD rate;
 436     DWORD depth;
 437     WORD channels;
 438 } formats_to_test[] = {
 439     { WAVE_FORMAT_1M08, 11025, 8, 1 },
 440     { WAVE_FORMAT_1M16, 11025, 16, 1 },
 441     { WAVE_FORMAT_1S08, 11025, 8, 2 },
 442     { WAVE_FORMAT_1S16, 11025, 16, 2 },
 443     { WAVE_FORMAT_2M08, 22050, 8, 1 },
 444     { WAVE_FORMAT_2M16, 22050, 16, 1 },
 445     { WAVE_FORMAT_2S08, 22050, 8, 2 },
 446     { WAVE_FORMAT_2S16, 22050, 16, 2 },
 447     { WAVE_FORMAT_4M08, 44100, 8, 1 },
 448     { WAVE_FORMAT_4M16, 44100, 16, 1 },
 449     { WAVE_FORMAT_4S08, 44100, 8, 2 },
 450     { WAVE_FORMAT_4S16, 44100, 16, 2 },
 451     { WAVE_FORMAT_48M08, 48000, 8, 1 },
 452     { WAVE_FORMAT_48M16, 48000, 16, 1 },
 453     { WAVE_FORMAT_48S08, 48000, 8, 2 },
 454     { WAVE_FORMAT_48S16, 48000, 16, 2 },
 455     { WAVE_FORMAT_96M08, 96000, 8, 1 },
 456     { WAVE_FORMAT_96M16, 96000, 16, 1 },
 457     { WAVE_FORMAT_96S08, 96000, 8, 2 },
 458     { WAVE_FORMAT_96S16, 96000, 16, 2 },
 459     {0}
 460 };
 461
 462 static DWORD WINMM_GetSupportedFormats(IMMDevice *device)
 463 {
 464     DWORD flags = 0;
 465     HRESULT hr;
 466     struct _TestFormat *fmt;
 467     IAudioClient *client;
 468
 469     hr = IMMDevice_Activate(device, &IID_IAudioClient,
 470             CLSCTX_INPROC_SERVER, NULL, (void**)&client);
 471     if(FAILED(hr))
 472         return 0;
 473
 474     for(fmt = formats_to_test; fmt->flag; ++fmt){
 475         hr = WINMM_TestFormat(client, fmt->rate, fmt->depth, fmt->channels);
 476         if(hr == S_OK)
 477             flags |= fmt->flag;
 478     }
 479
 480     IAudioClient_Release(client);
 481
 482     return flags;
 483 }
 484
 485 static HRESULT WINMM_InitMMDevice(EDataFlow flow, IMMDevice *device,
 486         WINMM_MMDevice *dev, UINT index)
 487 {
 488     HRESULT hr;
 489
 490     if(flow == eRender){
 491         dev->out_caps.wMid = 0xFF;
 492         dev->out_caps.wPid = 0xFF;
 493         dev->out_caps.vDriverVersion = 0x00010001;
 494         dev->out_caps.dwFormats = WINMM_GetSupportedFormats(device);
 495         dev->out_caps.wReserved1 = 0;
 496         dev->out_caps.dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME |
 497             WAVECAPS_SAMPLEACCURATE;
 498         dev->out_caps.wChannels = 2;
 499         dev->out_caps.szPname[0] = '\0';
 500
 501         hr = WINMM_GetFriendlyName(device, dev->out_caps.szPname,
 502                 sizeof(dev->out_caps.szPname) /
 503                 sizeof(*dev->out_caps.szPname));
 504         if(FAILED(hr))
 505             return hr;
 506     }else{
 507         dev->in_caps.wMid = 0xFF;
 508         dev->in_caps.wPid = 0xFF;
 509         dev->in_caps.vDriverVersion = 0x00010001;
 510         dev->in_caps.dwFormats = WINMM_GetSupportedFormats(device);
 511         dev->in_caps.wReserved1 = 0;
 512         dev->in_caps.wChannels = 2;
 513         dev->in_caps.szPname[0] = '\0';
 514
 515         hr = WINMM_GetFriendlyName(device, dev->in_caps.szPname,
 516                 sizeof(dev->in_caps.szPname) /
 517                 sizeof(*dev->in_caps.szPname));
 518         if(FAILED(hr))
 519             return hr;
 520     }
 521
 522     hr = IMMDevice_GetId(device, &dev->dev_id);
 523     if(FAILED(hr))
 524         return hr;
 525
 526     CoCreateGuid(&dev->session);
 527
 528     InitializeCriticalSection(&dev->lock);
 529     dev->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINMM_Device.lock");
 530
 531     return S_OK;
 532 }
 533
 534 static HRESULT WINMM_EnumDevices(WINMM_MMDevice **devices, UINT *devcount,
 535         EDataFlow flow, IMMDeviceEnumerator *devenum)
 536 {
 537     IMMDeviceCollection *devcoll;
 538     HRESULT hr;
 539
 540     hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flow,
 541             DEVICE_STATE_ACTIVE, &devcoll);
 542     if(FAILED(hr))
 543         return hr;
 544
 545     hr = IMMDeviceCollection_GetCount(devcoll, devcount);
 546     if(FAILED(hr)){
 547         IMMDeviceCollection_Release(devcoll);
 548         return hr;
 549     }
 550
 551     if(*devcount > 0){
 552         UINT n, count;
 553         IMMDevice *def_dev = NULL;
 554
 555         *devices = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 556                 sizeof(WINMM_MMDevice) * (*devcount));
 557         if(!*devices){
 558             IMMDeviceCollection_Release(devcoll);
 559             return E_OUTOFMEMORY;
 560         }
 561
 562         count = 0;
 563
 564         /* make sure that device 0 is the default device */
 565         hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum,
 566                 flow, eConsole, &def_dev);
 567         if(SUCCEEDED(hr)){
 568             WINMM_InitMMDevice(flow, def_dev, &(*devices)[0], 0);
 569             count = 1;
 570         }
 571
 572         for(n = 0; n < *devcount; ++n){
 573             IMMDevice *device;
 574
 575             hr = IMMDeviceCollection_Item(devcoll, n, &device);
 576             if(SUCCEEDED(hr)){
 577                 if(device != def_dev){
 578                     WINMM_InitMMDevice(flow, device, &(*devices)[count], count);
 579                     ++count;
 580                 }
 581
 582                 IMMDevice_Release(device);
 583             }
 584         }
 585
 586         if(def_dev)
 587             IMMDevice_Release(def_dev);
 588
 589         *devcount = count;
 590     }
 591
 592     IMMDeviceCollection_Release(devcoll);
 593
 594     return S_OK;
 595 }
 596
 597 static HRESULT WINMM_InitMMDevices(void)
 598 {
 599     HRESULT hr, init_hr;
 600     IMMDeviceEnumerator *devenum = NULL;
 601
 602     if(g_outmmdevices_count || g_inmmdevices_count)
 603         return S_FALSE;
 604
 605     init_hr = CoInitialize(NULL);
 606
 607     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
 608             CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
 609     if(FAILED(hr))
 610         goto exit;
 611
 612     hr = WINMM_EnumDevices(&g_out_mmdevices, &g_outmmdevices_count, eRender, devenum);
 613     if(FAILED(hr)){
 614         g_outmmdevices_count = 0;
 615         g_inmmdevices_count = 0;
 616         goto exit;
 617     }
 618
 619     hr = WINMM_EnumDevices(&g_in_mmdevices, &g_inmmdevices_count, eCapture, devenum);
 620     if(FAILED(hr)){
 621         g_inmmdevices_count = 0;
 622         goto exit;
 623     }
 624
 625 exit:
 626     if(devenum)
 627         IMMDeviceEnumerator_Release(devenum);
 628     if(SUCCEEDED(init_hr))
 629         CoUninitialize();
 630
 631     return hr;
 632 }
 633
 634 static inline BOOL WINMM_IsMapper(UINT device)
 635 {
 636     return (device == WAVE_MAPPER || device == (UINT16)WAVE_MAPPER);
 637 }
 638
 639 static MMRESULT WINMM_TryDeviceMapping(WINMM_OpenInfo *info, WORD channels,
 640         DWORD freq, DWORD bits_per_samp, BOOL is_out)
 641 {
 642     WINMM_Device *device;
 643     WAVEFORMATEX target;
 644     MMRESULT mr;
 645     UINT i;
 646
 647     TRACE("format: %u, channels: %u, sample rate: %u, bit depth: %u\n",
 648             WAVE_FORMAT_PCM, channels, freq, bits_per_samp);
 649
 650     target.wFormatTag = WAVE_FORMAT_PCM;
 651     target.nChannels = channels;
 652     target.nSamplesPerSec = freq;
 653     target.wBitsPerSample = bits_per_samp;
 654     target.nBlockAlign = (target.nChannels * target.wBitsPerSample) / 8;
 655     target.nAvgBytesPerSec = target.nSamplesPerSec * target.nBlockAlign;
 656     target.cbSize = 0;
 657
 658     if(is_out)
 659         mr = acmStreamOpen(NULL, NULL, info->format, &target, NULL, 0,
 660                 0, ACM_STREAMOPENF_QUERY);
 661     else
 662         mr = acmStreamOpen(NULL, NULL, &target, info->format, NULL, 0,
 663                 0, ACM_STREAMOPENF_QUERY);
 664     if(mr != MMSYSERR_NOERROR)
 665         return mr;
 666
 667     /* ACM can convert from src->dst, so try to find a device
 668      * that supports dst */
 669     if(is_out){
 670         if(WINMM_IsMapper(info->req_device)){
 671             for(i = 0; i < g_outmmdevices_count; ++i){
 672                 WINMM_OpenInfo l_info = *info;
 673                 l_info.req_device = i;
 674                 l_info.format = &target;
 675                 mr = WOD_Open(&l_info);
 676                 if(mr == MMSYSERR_NOERROR){
 677                     info->handle = l_info.handle;
 678                     break;
 679                 }
 680             }
 681         }else{
 682             WINMM_OpenInfo l_info = *info;
 683             l_info.flags &= ~WAVE_MAPPED;
 684             l_info.format = &target;
 685             mr = WOD_Open(&l_info);
 686             if(mr == MMSYSERR_NOERROR)
 687                 info->handle = l_info.handle;
 688         }
 689     }else{
 690         if(WINMM_IsMapper(info->req_device)){
 691             for(i = 0; i < g_inmmdevices_count; ++i){
 692                 WINMM_OpenInfo l_info = *info;
 693                 l_info.req_device = i;
 694                 l_info.format = &target;
 695                 mr = WID_Open(&l_info);
 696                 if(mr == MMSYSERR_NOERROR){
 697                     info->handle = l_info.handle;
 698                     break;
 699                 }
 700             }
 701         }else{
 702             WINMM_OpenInfo l_info = *info;
 703             l_info.flags &= ~WAVE_MAPPED;
 704             l_info.format = &target;
 705             mr = WID_Open(&l_info);
 706             if(mr == MMSYSERR_NOERROR)
 707                 info->handle = l_info.handle;
 708         }
 709     }
 710     if(mr != MMSYSERR_NOERROR)
 711         return WAVERR_BADFORMAT;
 712
 713     device = WINMM_GetDeviceFromHWAVE(info->handle);
 714     if(!device)
 715         return MMSYSERR_INVALHANDLE;
 716
 717     /* set up the ACM stream */
 718     if(is_out)
 719         mr = acmStreamOpen(&device->acm_handle, NULL, info->format, &target,
 720                 NULL, 0, 0, 0);
 721     else
 722         mr = acmStreamOpen(&device->acm_handle, NULL, &target, info->format,
 723                 NULL, 0, 0, 0);
 724     if(mr != MMSYSERR_NOERROR){
 725         if(is_out)
 726             WOD_Close((HWAVEOUT)info->handle);
 727         else
 728             WID_Close((HWAVEIN)info->handle);
 729         return mr;
 730     }
 731
 732     TRACE("Success\n");
 733     return MMSYSERR_NOERROR;
 734 }
 735
 736 static MMRESULT WINMM_MapDevice(WINMM_OpenInfo *info, BOOL is_out)
 737 {
 738     UINT i;
 739     MMRESULT mr;
 740     WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)info->format;
 741
 742     TRACE("(%p, %d)\n", info, is_out);
 743
 744     /* try to find a direct match */
 745     if(is_out){
 746         WINMM_OpenInfo l_info = *info;
 747         if(WINMM_IsMapper(info->req_device)){
 748             for(i = 0; i < g_outmmdevices_count; ++i){
 749                 l_info.req_device = i;
 750                 mr = WOD_Open(&l_info);
 751                 if(mr == MMSYSERR_NOERROR){
 752                     info->handle = l_info.handle;
 753                     return mr;
 754                 }
 755             }
 756         }else{
 757             l_info.flags &= ~WAVE_MAPPED;
 758             mr = WOD_Open(&l_info);
 759             if(mr == MMSYSERR_NOERROR){
 760                 info->handle = l_info.handle;
 761                 return mr;
 762             }
 763         }
 764     }else{
 765         WINMM_OpenInfo l_info = *info;
 766         if(WINMM_IsMapper(info->req_device)){
 767             for(i = 0; i < g_inmmdevices_count; ++i){
 768                 l_info.req_device = i;
 769                 mr = WID_Open(&l_info);
 770                 if(mr == MMSYSERR_NOERROR){
 771                     info->handle = l_info.handle;
 772                     return mr;
 773                 }
 774             }
 775         }else{
 776             l_info.flags &= ~WAVE_MAPPED;
 777             mr = WID_Open(&l_info);
 778             if(mr == MMSYSERR_NOERROR){
 779                 info->handle = l_info.handle;
 780                 return mr;
 781             }
 782         }
 783     }
 784
 785     /* no direct match, so set up the ACM stream */
 786     if(info->format->wFormatTag != WAVE_FORMAT_PCM &&
 787             !(info->format->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 788               IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))){
 789         /* convert to PCM format if it's not already */
 790         mr = WINMM_TryDeviceMapping(info, info->format->nChannels,
 791                 info->format->nSamplesPerSec, 16, is_out);
 792         if(mr == MMSYSERR_NOERROR)
 793             return mr;
 794
 795         mr = WINMM_TryDeviceMapping(info, info->format->nChannels,
 796                 info->format->nSamplesPerSec, 8, is_out);
 797         if(mr == MMSYSERR_NOERROR)
 798             return mr;
 799     }else{
 800         WORD channels;
 801
 802         /* first try just changing bit depth and channels */
 803         channels = info->format->nChannels;
 804         mr = WINMM_TryDeviceMapping(info, channels,
 805                 info->format->nSamplesPerSec, 16, is_out);
 806         if(mr == MMSYSERR_NOERROR)
 807             return mr;
 808         mr = WINMM_TryDeviceMapping(info, channels,
 809                 info->format->nSamplesPerSec, 8, is_out);
 810         if(mr == MMSYSERR_NOERROR)
 811             return mr;
 812
 813         channels = (channels == 2) ? 1 : 2;
 814         mr = WINMM_TryDeviceMapping(info, channels,
 815                 info->format->nSamplesPerSec, 16, is_out);
 816         if(mr == MMSYSERR_NOERROR)
 817             return mr;
 818         mr = WINMM_TryDeviceMapping(info, channels,
 819                 info->format->nSamplesPerSec, 8, is_out);
 820         if(mr == MMSYSERR_NOERROR)
 821             return mr;
 822
 823         /* that didn't work, so now try different sample rates */
 824         channels = info->format->nChannels;
 825         mr = WINMM_TryDeviceMapping(info, channels, 96000, 16, is_out);
 826         if(mr == MMSYSERR_NOERROR)
 827             return mr;
 828         mr = WINMM_TryDeviceMapping(info, channels, 48000, 16, is_out);
 829         if(mr == MMSYSERR_NOERROR)
 830             return mr;
 831         mr = WINMM_TryDeviceMapping(info, channels, 44100, 16, is_out);
 832         if(mr == MMSYSERR_NOERROR)
 833             return mr;
 834         mr = WINMM_TryDeviceMapping(info, channels, 22050, 16, is_out);
 835         if(mr == MMSYSERR_NOERROR)
 836             return mr;
 837         mr = WINMM_TryDeviceMapping(info, channels, 11025, 16, is_out);
 838         if(mr == MMSYSERR_NOERROR)
 839             return mr;
 840
 841         channels = (channels == 2) ? 1 : 2;
 842         mr = WINMM_TryDeviceMapping(info, channels, 96000, 16, is_out);
 843         if(mr == MMSYSERR_NOERROR)
 844             return mr;
 845         mr = WINMM_TryDeviceMapping(info, channels, 48000, 16, is_out);
 846         if(mr == MMSYSERR_NOERROR)
 847             return mr;
 848         mr = WINMM_TryDeviceMapping(info, channels, 44100, 16, is_out);
 849         if(mr == MMSYSERR_NOERROR)
 850             return mr;
 851         mr = WINMM_TryDeviceMapping(info, channels, 22050, 16, is_out);
 852         if(mr == MMSYSERR_NOERROR)
 853             return mr;
 854         mr = WINMM_TryDeviceMapping(info, channels, 11025, 16, is_out);
 855         if(mr == MMSYSERR_NOERROR)
 856             return mr;
 857
 858         channels = info->format->nChannels;
 859         mr = WINMM_TryDeviceMapping(info, channels, 96000, 8, is_out);
 860         if(mr == MMSYSERR_NOERROR)
 861             return mr;
 862         mr = WINMM_TryDeviceMapping(info, channels, 48000, 8, is_out);
 863         if(mr == MMSYSERR_NOERROR)
 864             return mr;
 865         mr = WINMM_TryDeviceMapping(info, channels, 44100, 8, is_out);
 866         if(mr == MMSYSERR_NOERROR)
 867             return mr;
 868         mr = WINMM_TryDeviceMapping(info, channels, 22050, 8, is_out);
 869         if(mr == MMSYSERR_NOERROR)
 870             return mr;
 871         mr = WINMM_TryDeviceMapping(info, channels, 11025, 8, is_out);
 872         if(mr == MMSYSERR_NOERROR)
 873             return mr;
 874
 875         channels = (channels == 2) ? 1 : 2;
 876         mr = WINMM_TryDeviceMapping(info, channels, 96000, 8, is_out);
 877         if(mr == MMSYSERR_NOERROR)
 878             return mr;
 879         mr = WINMM_TryDeviceMapping(info, channels, 48000, 8, is_out);
 880         if(mr == MMSYSERR_NOERROR)
 881             return mr;
 882         mr = WINMM_TryDeviceMapping(info, channels, 44100, 8, is_out);
 883         if(mr == MMSYSERR_NOERROR)
 884             return mr;
 885         mr = WINMM_TryDeviceMapping(info, channels, 22050, 8, is_out);
 886         if(mr == MMSYSERR_NOERROR)
 887             return mr;
 888         mr = WINMM_TryDeviceMapping(info, channels, 11025, 8, is_out);
 889         if(mr == MMSYSERR_NOERROR)
 890             return mr;
 891     }
 892
 893     WARN("Unable to find compatible device!\n");
 894     return WAVERR_BADFORMAT;
 895 }
 896
 897 static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_MMDevice *mmdevice,
 898         WINMM_OpenInfo *info)
 899 {
 900     WAVEFORMATEX *closer_fmt = NULL, fmt, *passed_fmt;
 901     LRESULT ret = MMSYSERR_ERROR;
 902     HRESULT hr;
 903
 904     hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id,
 905             &device->device);
 906     if(FAILED(hr)){
 907         WARN("Device %s (%s) unavailable: %08x\n",
 908                 wine_dbgstr_w(mmdevice->dev_id),
 909                 wine_dbgstr_w(mmdevice->out_caps.szPname), hr);
 910         goto error;
 911     }
 912
 913     hr = IMMDevice_Activate(device->device, &IID_IAudioClient,
 914             CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);
 915     if(FAILED(hr)){
 916         WARN("Activate failed: %08x\n", hr);
 917         goto error;
 918     }
 919
 920     if(info->format->wFormatTag == WAVE_FORMAT_PCM){
 921         /* we aren't guaranteed that the struct in lpFormat is a full
 922          * WAVEFORMATEX struct, which IAC::IsFormatSupported requires */
 923         passed_fmt = &fmt;
 924         memcpy(passed_fmt, info->format, sizeof(PCMWAVEFORMAT));
 925         passed_fmt->cbSize = 0;
 926         if(fmt.wBitsPerSample % 8 != 0){
 927             WARN("Fixing bad wBitsPerSample (%u)\n", fmt.wBitsPerSample);
 928             fmt.wBitsPerSample = (fmt.wBitsPerSample + 7) & ~7;
 929         }
 930         /* winmm ignores broken blockalign and avgbytes */
 931         if(fmt.nBlockAlign != fmt.nChannels * fmt.wBitsPerSample/8){
 932             WARN("Fixing bad nBlockAlign (%u)\n", fmt.nBlockAlign);
 933             fmt.nBlockAlign  = fmt.nChannels * fmt.wBitsPerSample/8;
 934         }
 935         if (fmt.nAvgBytesPerSec != fmt.nSamplesPerSec * fmt.nBlockAlign) {
 936             WARN("Fixing bad nAvgBytesPerSec (%u)\n", fmt.nAvgBytesPerSec);
 937             fmt.nAvgBytesPerSec  = fmt.nSamplesPerSec * fmt.nBlockAlign;
 938         }
 939     }else
 940         passed_fmt = info->format;
 941
 942     hr = IAudioClient_IsFormatSupported(device->client,
 943             AUDCLNT_SHAREMODE_SHARED, passed_fmt, &closer_fmt);
 944     if(closer_fmt)
 945         CoTaskMemFree(closer_fmt);
 946     if(FAILED(hr) && hr != AUDCLNT_E_UNSUPPORTED_FORMAT){
 947         WARN("IsFormatSupported failed: %08x\n", hr);
 948         goto error;
 949     }
 950     if(hr == S_FALSE || hr == AUDCLNT_E_UNSUPPORTED_FORMAT){
 951         ret = WAVERR_BADFORMAT;
 952         goto error;
 953     }
 954     if(info->flags & WAVE_FORMAT_QUERY){
 955         ret = MMSYSERR_NOERROR;
 956         goto error;
 957     }
 958
 959     /* buffer size = 10 * 100000 (100 ns) = 0.1 seconds */
 960     hr = IAudioClient_Initialize(device->client, AUDCLNT_SHAREMODE_SHARED,
 961             AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
 962             10 * 100000, 50000, passed_fmt, &device->parent->session);
 963     if(FAILED(hr)){
 964         WARN("Initialize failed: %08x\n", hr);
 965         goto error;
 966     }
 967
 968     hr = IAudioClient_GetService(device->client, &IID_IAudioClock,
 969             (void**)&device->clock);
 970     if(FAILED(hr)){
 971         WARN("GetService failed: %08x\n", hr);
 972         goto error;
 973     }
 974
 975     if(!device->event){
 976         device->event = CreateEventW(NULL, FALSE, FALSE, NULL);
 977         if(!device->event){
 978             WARN("CreateEvent failed: %08x\n", hr);
 979             goto error;
 980         }
 981
 982         /* As the devices thread is waiting on g_device_handles, it can
 983          * only be modified from within this same thread. */
 984         if(g_device_handles){
 985             g_device_handles = HeapReAlloc(GetProcessHeap(), 0, g_device_handles,
 986                     sizeof(HANDLE) * (g_devhandle_count + 1));
 987             g_handle_devices = HeapReAlloc(GetProcessHeap(), 0, g_handle_devices,
 988                     sizeof(WINMM_Device *) * (g_devhandle_count + 1));
 989         }else{
 990             g_device_handles = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLE));
 991             g_handle_devices = HeapAlloc(GetProcessHeap(), 0,
 992                     sizeof(WINMM_Device *));
 993         }
 994         g_device_handles[g_devhandle_count] = device->event;
 995         g_handle_devices[g_devhandle_count] = device;
 996         ++g_devhandle_count;
 997     }
 998
 999     hr = IAudioClient_SetEventHandle(device->client, device->event);
1000     if(FAILED(hr)){
1001         WARN("SetEventHandle failed: %08x\n", hr);
1002         goto error;
1003     }
1004
1005     device->bytes_per_frame = passed_fmt->nBlockAlign;
1006     device->samples_per_sec = passed_fmt->nSamplesPerSec;
1007
1008     device->played_frames = 0;
1009     device->last_clock_pos = 0;
1010     device->ofs_bytes = 0;
1011     device->loop_counter = 0;
1012     device->stopped = TRUE;
1013     device->first = device->last = device->playing = device->loop_start = NULL;
1014
1015     device->cb_info.flags = HIWORD(info->flags & CALLBACK_TYPEMASK);
1016     device->cb_info.callback = info->callback;
1017     device->cb_info.user = info->cb_user;
1018     device->cb_info.hwave = device->handle;
1019
1020     info->handle = device->handle;
1021
1022     return MMSYSERR_NOERROR;
1023
1024 error:
1025     if(device->client){
1026         IAudioClient_Release(device->client);
1027         device->client = NULL;
1028     }
1029     if(device->device){
1030         IMMDevice_Release(device->device);
1031         device->device = NULL;
1032     }
1033
1034     return ret;
1035 }
1036
1037 static LRESULT WOD_Open(WINMM_OpenInfo *info)
1038 {
1039     WINMM_MMDevice *mmdevice;
1040     WINMM_Device *device = NULL;
1041     LRESULT ret = MMSYSERR_ERROR;
1042     HRESULT hr;
1043
1044     TRACE("(%u, %p, %08x)\n", info->req_device, info, info->flags);
1045
1046     if(WINMM_IsMapper(info->req_device) || (info->flags & WAVE_MAPPED))
1047         return WINMM_MapDevice(info, TRUE);
1048
1049     if(info->req_device >= g_outmmdevices_count)
1050         return MMSYSERR_BADDEVICEID;
1051
1052     mmdevice = &g_out_mmdevices[info->req_device];
1053
1054     if(!mmdevice->out_caps.szPname[0])
1055         return MMSYSERR_NOTENABLED;
1056
1057     device = WINMM_FindUnusedDevice(TRUE, info->req_device);
1058     if(!device)
1059         return MMSYSERR_ALLOCATED;
1060
1061     ret = WINMM_OpenDevice(device, mmdevice, info);
1062     if((info->flags & WAVE_FORMAT_QUERY) || ret != MMSYSERR_NOERROR)
1063         goto error;
1064     ret = MMSYSERR_ERROR;
1065
1066     hr = IAudioClient_GetService(device->client, &IID_IAudioRenderClient,
1067             (void**)&device->render);
1068     if(FAILED(hr)){
1069         WARN("GetService(RenderClient) failed: %08x\n", hr);
1070         goto error;
1071     }
1072
1073     hr = IAudioClient_GetService(device->client, &IID_IAudioStreamVolume,
1074             (void**)&device->volume);
1075     if(FAILED(hr)){
1076         WARN("GetService(StreamVolume) failed: %08x\n", hr);
1077         goto error;
1078     }
1079
1080     LeaveCriticalSection(&device->lock);
1081
1082     return MMSYSERR_NOERROR;
1083
1084 error:
1085     if(device->device){
1086         IMMDevice_Release(device->device);
1087         device->device = NULL;
1088     }
1089     if(device->client){
1090         IAudioClient_Release(device->client);
1091         device->client = NULL;
1092     }
1093     if(device->render){
1094         IAudioRenderClient_Release(device->render);
1095         device->render = NULL;
1096     }
1097     if(device->volume){
1098         IAudioStreamVolume_Release(device->volume);
1099         device->volume = NULL;
1100     }
1101     if(device->clock){
1102         IAudioClock_Release(device->clock);
1103         device->clock = NULL;
1104     }
1105     device->open = FALSE;
1106     LeaveCriticalSection(&device->lock);
1107     return ret;
1108 }
1109
1110 static LRESULT WID_Open(WINMM_OpenInfo *info)
1111 {
1112     WINMM_MMDevice *mmdevice;
1113     WINMM_Device *device = NULL;
1114     LRESULT ret = MMSYSERR_ERROR;
1115     HRESULT hr;
1116
1117     TRACE("(%u, %p, %08x)\n", info->req_device, info, info->flags);
1118
1119     if(WINMM_IsMapper(info->req_device) || info->flags & WAVE_MAPPED)
1120         return WINMM_MapDevice(info, FALSE);
1121
1122     if(info->req_device >= g_inmmdevices_count)
1123         return MMSYSERR_BADDEVICEID;
1124
1125     mmdevice = &g_in_mmdevices[info->req_device];
1126
1127     if(!mmdevice->in_caps.szPname[0])
1128         return MMSYSERR_NOTENABLED;
1129
1130     device = WINMM_FindUnusedDevice(FALSE, info->req_device);
1131     if(!device)
1132         return MMSYSERR_ALLOCATED;
1133
1134     ret = WINMM_OpenDevice(device, mmdevice, info);
1135     if((info->flags & WAVE_FORMAT_QUERY) || ret != MMSYSERR_NOERROR)
1136         goto error;
1137     ret = MMSYSERR_ERROR;
1138
1139     hr = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,
1140             (void**)&device->capture);
1141     if(FAILED(hr)){
1142         WARN("GetService failed: %08x\n", hr);
1143         goto error;
1144     }
1145
1146     LeaveCriticalSection(&device->lock);
1147
1148     return MMSYSERR_NOERROR;
1149
1150 error:
1151     if(device->device){
1152         IMMDevice_Release(device->device);
1153         device->device = NULL;
1154     }
1155     if(device->client){
1156         IAudioClient_Release(device->client);
1157         device->client = NULL;
1158     }
1159     if(device->capture){
1160         IAudioCaptureClient_Release(device->capture);
1161         device->capture = NULL;
1162     }
1163     if(device->clock){
1164         IAudioClock_Release(device->clock);
1165         device->clock = NULL;
1166     }
1167     device->open = FALSE;
1168     LeaveCriticalSection(&device->lock);
1169     return ret;
1170 }
1171
1172 static HRESULT WINMM_CloseDevice(WINMM_Device *device)
1173 {
1174     device->open = FALSE;
1175
1176     if(!device->stopped){
1177         IAudioClient_Stop(device->client);
1178         device->stopped = TRUE;
1179     }
1180
1181     if(device->acm_handle){
1182         acmStreamClose(device->acm_handle, 0);
1183         device->acm_handle = NULL;
1184     }
1185
1186     IMMDevice_Release(device->device);
1187     device->device = NULL;
1188
1189     IAudioClient_Release(device->client);
1190     device->client = NULL;
1191
1192     IAudioClock_Release(device->clock);
1193     device->clock = NULL;
1194
1195     return S_OK;
1196 }
1197
1198 static LRESULT WOD_Close(HWAVEOUT hwave)
1199 {
1200     WINMM_Device *device = WINMM_GetDeviceFromHWAVE((HWAVE)hwave);
1201
1202     TRACE("(%p)\n", hwave);
1203
1204     if(!WINMM_ValidateAndLock(device))
1205         return MMSYSERR_INVALHANDLE;
1206
1207     WINMM_CloseDevice(device);
1208
1209     IAudioRenderClient_Release(device->render);
1210     device->render = NULL;
1211
1212     IAudioStreamVolume_Release(device->volume);
1213     device->volume = NULL;
1214
1215     LeaveCriticalSection(&device->lock);
1216
1217     return MMSYSERR_NOERROR;
1218 }
1219
1220 static LRESULT WID_Close(HWAVEIN hwave)
1221 {
1222     WINMM_Device *device = WINMM_GetDeviceFromHWAVE((HWAVE)hwave);
1223
1224     TRACE("(%p)\n", hwave);
1225
1226     if(!WINMM_ValidateAndLock(device))
1227         return MMSYSERR_INVALHANDLE;
1228
1229     WINMM_CloseDevice(device);
1230
1231     IAudioCaptureClient_Release(device->capture);
1232     device->capture = NULL;
1233
1234     LeaveCriticalSection(&device->lock);
1235
1236     return MMSYSERR_NOERROR;
1237 }
1238
1239 static LRESULT WINMM_PrepareHeader(HWAVE hwave, WAVEHDR *header)
1240 {
1241     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1242
1243     TRACE("(%p, %p)\n", hwave, header);
1244
1245     if(!WINMM_ValidateAndLock(device))
1246         return MMSYSERR_INVALHANDLE;
1247
1248     if(device->render && device->acm_handle){
1249         ACMSTREAMHEADER *ash;
1250         DWORD size;
1251         MMRESULT mr;
1252
1253         mr = acmStreamSize(device->acm_handle, header->dwBufferLength, &size,
1254                 ACM_STREAMSIZEF_SOURCE);
1255         if(mr != MMSYSERR_NOERROR){
1256             LeaveCriticalSection(&device->lock);
1257             return mr;
1258         }
1259
1260         ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + size);
1261         if(!ash){
1262             LeaveCriticalSection(&device->lock);
1263             return MMSYSERR_NOMEM;
1264         }
1265
1266         ash->cbStruct = sizeof(*ash);
1267         ash->fdwStatus = 0;
1268         ash->dwUser = (DWORD_PTR)header;
1269         ash->pbSrc = (BYTE*)header->lpData;
1270         ash->cbSrcLength = header->dwBufferLength;
1271         ash->dwSrcUser = header->dwUser;
1272         ash->pbDst = (BYTE*)ash + sizeof(ACMSTREAMHEADER);
1273         ash->cbDstLength = size;
1274         ash->dwDstUser = 0;
1275
1276         mr = acmStreamPrepareHeader(device->acm_handle, ash, 0);
1277         if(mr != MMSYSERR_NOERROR){
1278             HeapFree(GetProcessHeap(), 0, ash);
1279             LeaveCriticalSection(&device->lock);
1280             return mr;
1281         }
1282
1283         header->reserved = (DWORD_PTR)ash;
1284     }
1285
1286     LeaveCriticalSection(&device->lock);
1287
1288     header->dwFlags |= WHDR_PREPARED;
1289     header->dwFlags &= ~WHDR_DONE;
1290
1291     return MMSYSERR_NOERROR;
1292 }
1293
1294 static LRESULT WINMM_UnprepareHeader(HWAVE hwave, WAVEHDR *header)
1295 {
1296     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1297
1298     TRACE("(%p, %p)\n", hwave, header);
1299
1300     if(!WINMM_ValidateAndLock(device))
1301         return MMSYSERR_INVALHANDLE;
1302
1303     if(device->render && device->acm_handle){
1304         ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
1305
1306         acmStreamUnprepareHeader(device->acm_handle, ash, 0);
1307
1308         HeapFree(GetProcessHeap(), 0, ash);
1309     }
1310
1311     LeaveCriticalSection(&device->lock);
1312
1313     header->dwFlags &= ~WHDR_PREPARED;
1314     header->dwFlags |= WHDR_DONE;
1315
1316     return MMSYSERR_NOERROR;
1317 }
1318
1319 static UINT32 WINMM_HeaderLenBytes(WINMM_Device *device, WAVEHDR *header)
1320 {
1321     if(device->acm_handle){
1322         ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
1323         return ash->cbDstLengthUsed;
1324     }
1325
1326     return header->dwBufferLength;
1327 }
1328
1329 static UINT32 WINMM_HeaderLenFrames(WINMM_Device *device, WAVEHDR *header)
1330 {
1331     return WINMM_HeaderLenBytes(device, header) / device->bytes_per_frame;
1332 }
1333
1334 static WAVEHDR *WOD_MarkDoneHeaders(WINMM_Device *device)
1335 {
1336     HRESULT hr;
1337     WAVEHDR *first = device->first, *queue = first, *last = NULL;
1338     UINT64 clock_freq, clock_pos, clock_frames;
1339     UINT32 nloops, queue_frames = 0;
1340
1341     hr = IAudioClock_GetFrequency(device->clock, &clock_freq);
1342     if(FAILED(hr)){
1343         WARN("GetFrequency failed: %08x\n", hr);
1344         return NULL;
1345     }
1346
1347     hr = IAudioClock_GetPosition(device->clock, &clock_pos, NULL);
1348     if(FAILED(hr)){
1349         WARN("GetPosition failed: %08x\n", hr);
1350         return NULL;
1351     }
1352
1353     clock_frames = (clock_pos * device->samples_per_sec) / clock_freq;
1354
1355     nloops = device->loop_counter;
1356     while(queue &&
1357             (queue_frames += WINMM_HeaderLenFrames(device, queue)) <=
1358                 clock_frames - device->last_clock_pos){
1359         if(!nloops){
1360             last = queue;
1361             device->last_clock_pos += queue_frames;
1362             queue_frames = 0;
1363             queue = device->first = queue->lpNext;
1364         }else{
1365             if(queue->dwFlags & WHDR_BEGINLOOP){
1366                 if(queue->dwFlags & WHDR_ENDLOOP)
1367                     --nloops;
1368                 else
1369                     queue = queue->lpNext;
1370             }else if(queue->dwFlags & WHDR_ENDLOOP){
1371                 queue = device->loop_start;
1372                 --nloops;
1373             }
1374         }
1375     }
1376
1377     if(last){
1378         last->lpNext = NULL;
1379         return first;
1380     }else
1381         return NULL;
1382 }
1383
1384 static void WOD_PushData(WINMM_Device *device)
1385 {
1386     WINMM_CBInfo cb_info;
1387     HRESULT hr;
1388     UINT32 pad, bufsize, avail_frames, queue_frames, written, ofs;
1389     UINT32 queue_bytes, nloops;
1390     BYTE *data;
1391     WAVEHDR *queue, *first = NULL;
1392
1393     TRACE("(%p)\n", device->handle);
1394
1395     EnterCriticalSection(&device->lock);
1396
1397     if(!device->device)
1398         goto exit;
1399
1400     if(!device->first){
1401         if (device->stopped)
1402             goto exit;
1403         device->stopped = TRUE;
1404         device->last_clock_pos = 0;
1405         IAudioClient_Stop(device->client);
1406         IAudioClient_Reset(device->client);
1407         goto exit;
1408     }
1409
1410     hr = IAudioClient_GetBufferSize(device->client, &bufsize);
1411     if(FAILED(hr)){
1412         WARN("GetBufferSize failed: %08x\n", hr);
1413         goto exit;
1414     }
1415
1416     hr = IAudioClient_GetCurrentPadding(device->client, &pad);
1417     if(FAILED(hr)){
1418         WARN("GetCurrentPadding failed: %08x\n", hr);
1419         goto exit;
1420     }
1421
1422     first = WOD_MarkDoneHeaders(device);
1423
1424     /* determine which is larger between the available buffer size and
1425      * the amount of data left in the queue */
1426     avail_frames = bufsize - pad;
1427
1428     queue = device->playing;
1429     ofs = device->ofs_bytes;
1430     queue_frames = 0;
1431     nloops = 0;
1432     while(queue && queue_frames < avail_frames){
1433         queue_bytes = WINMM_HeaderLenBytes(device, queue);
1434         queue_frames += (queue_bytes - ofs) / device->bytes_per_frame;
1435         ofs = 0;
1436
1437         if(queue->dwFlags & WHDR_ENDLOOP && nloops < device->loop_counter){
1438             queue = device->loop_start;
1439             ++nloops;
1440         }else
1441             queue = queue->lpNext;
1442     }
1443
1444     if(queue_frames < avail_frames)
1445         avail_frames = queue_frames;
1446     if(avail_frames == 0)
1447         goto exit;
1448
1449     hr = IAudioRenderClient_GetBuffer(device->render, avail_frames, &data);
1450     if(FAILED(hr)){
1451         WARN("GetBuffer failed: %08x\n", hr);
1452         goto exit;
1453     }
1454
1455     written = 0;
1456     while(device->playing && written < avail_frames){
1457         UINT32 copy_frames, copy_bytes;
1458         BYTE *queue_data;
1459
1460         queue = device->playing;
1461
1462         if(device->acm_handle){
1463             ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)queue->reserved;
1464             queue_bytes = ash->cbDstLengthUsed;
1465             queue_data = ash->pbDst;
1466         }else{
1467             queue_bytes = queue->dwBufferLength;
1468             queue_data = (BYTE*)queue->lpData;
1469         }
1470
1471         queue_frames = (queue_bytes - device->ofs_bytes) /
1472             device->bytes_per_frame;
1473
1474         copy_frames = queue_frames < (avail_frames - written) ?
1475             queue_frames : avail_frames - written;
1476         copy_bytes = copy_frames * device->bytes_per_frame;
1477
1478         memcpy(data, queue_data + device->ofs_bytes, copy_bytes);
1479
1480         data += copy_bytes;
1481         written += copy_frames;
1482         device->ofs_bytes += copy_bytes;
1483
1484         if(device->ofs_bytes >= queue_bytes){
1485             device->ofs_bytes = 0;
1486
1487             if(!(queue->dwFlags & (WHDR_BEGINLOOP | WHDR_ENDLOOP)))
1488                 device->playing = queue->lpNext;
1489             else{
1490                 if(queue->dwFlags & WHDR_BEGINLOOP){
1491                     device->loop_start = device->playing;
1492                     device->playing = queue->lpNext;
1493                     device->loop_counter = queue->dwLoops;
1494                 }
1495                 if(queue->dwFlags & WHDR_ENDLOOP){
1496                     --device->loop_counter;
1497                     if(device->loop_counter)
1498                         device->playing = device->loop_start;
1499                     else
1500                         device->loop_start = device->playing = queue->lpNext;
1501                 }
1502             }
1503         }
1504     }
1505
1506     hr = IAudioRenderClient_ReleaseBuffer(device->render, avail_frames, 0);
1507     if(FAILED(hr)){
1508         WARN("ReleaseBuffer failed: %08x\n", hr);
1509         goto exit;
1510     }
1511
1512     device->played_frames += avail_frames;
1513
1514 exit:
1515     cb_info = device->cb_info;
1516
1517     LeaveCriticalSection(&device->lock);
1518
1519     while(first){
1520         WAVEHDR *next = first->lpNext;
1521         first->dwFlags &= ~WHDR_INQUEUE;
1522         first->dwFlags |= WHDR_DONE;
1523         WINMM_NotifyClient(&cb_info, WOM_DONE, (DWORD_PTR)first, 0);
1524         first = next;
1525     }
1526 }
1527
1528 static void WID_PullACMData(WINMM_Device *device)
1529 {
1530     UINT32 packet, packet_bytes;
1531     DWORD flags;
1532     BYTE *data;
1533     WAVEHDR *queue;
1534     HRESULT hr;
1535     MMRESULT mr;
1536
1537     if(device->acm_hdr.cbDstLength == 0){
1538         hr = IAudioCaptureClient_GetBuffer(device->capture, &data, &packet,
1539                 &flags, NULL, NULL);
1540         if(hr != S_OK){
1541             if(FAILED(hr))
1542                 WARN("GetBuffer failed: %08x\n", hr);
1543             return;
1544         }
1545
1546         acmStreamSize(device->acm_handle, packet * device->bytes_per_frame,
1547                 &packet_bytes, ACM_STREAMSIZEF_SOURCE);
1548
1549         device->acm_offs = 0;
1550
1551         device->acm_hdr.cbStruct = sizeof(device->acm_hdr);
1552         device->acm_hdr.fdwStatus = 0;
1553         device->acm_hdr.dwUser = 0;
1554         device->acm_hdr.pbSrc = data;
1555         device->acm_hdr.cbSrcLength = packet * device->bytes_per_frame;
1556         device->acm_hdr.cbSrcLengthUsed = 0;
1557         device->acm_hdr.dwSrcUser = 0;
1558         device->acm_hdr.pbDst = HeapAlloc(GetProcessHeap(), 0, packet_bytes);
1559         device->acm_hdr.cbDstLength = packet_bytes;
1560         device->acm_hdr.cbDstLengthUsed = 0;
1561         device->acm_hdr.dwDstUser = 0;
1562
1563         mr = acmStreamPrepareHeader(device->acm_handle, &device->acm_hdr, 0);
1564         if(mr != MMSYSERR_NOERROR){
1565             WARN("acmStreamPrepareHeader failed: %d\n", mr);
1566             return;
1567         }
1568
1569         mr = acmStreamConvert(device->acm_handle, &device->acm_hdr, 0);
1570         if(mr != MMSYSERR_NOERROR){
1571             WARN("acmStreamConvert failed: %d\n", mr);
1572             return;
1573         }
1574
1575         hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet);
1576         if(FAILED(hr))
1577             WARN("ReleaseBuffer failed: %08x\n", hr);
1578
1579         device->played_frames += packet;
1580     }
1581
1582     queue = device->first;
1583     while(queue){
1584         UINT32 to_copy_bytes;
1585
1586         to_copy_bytes = min(queue->dwBufferLength - queue->dwBytesRecorded,
1587                 device->acm_hdr.cbDstLengthUsed - device->acm_offs);
1588
1589         memcpy(queue->lpData + queue->dwBytesRecorded,
1590                 device->acm_hdr.pbDst + device->acm_offs, to_copy_bytes);
1591
1592         queue->dwBytesRecorded += to_copy_bytes;
1593         device->acm_offs += to_copy_bytes;
1594
1595         if(queue->dwBufferLength - queue->dwBytesRecorded <
1596                 device->bytes_per_frame){
1597             queue->dwFlags &= ~WHDR_INQUEUE;
1598             queue->dwFlags |= WHDR_DONE;
1599             device->first = queue = queue->lpNext;
1600         }
1601
1602         if(device->acm_offs >= device->acm_hdr.cbDstLengthUsed){
1603             acmStreamUnprepareHeader(device->acm_handle, &device->acm_hdr, 0);
1604             HeapFree(GetProcessHeap(), 0, device->acm_hdr.pbDst);
1605             device->acm_hdr.cbDstLength = 0;
1606             device->acm_hdr.cbDstLengthUsed = 0;
1607
1608             /* done with this ACM Header, so try to pull more data */
1609             WID_PullACMData(device);
1610             return;
1611         }
1612     }
1613
1614     /* out of WAVEHDRs to write into, so toss the rest of this packet */
1615     acmStreamUnprepareHeader(device->acm_handle, &device->acm_hdr, 0);
1616     HeapFree(GetProcessHeap(), 0, device->acm_hdr.pbDst);
1617     device->acm_hdr.cbDstLength = 0;
1618     device->acm_hdr.cbDstLengthUsed = 0;
1619 }
1620
1621 static void WID_PullData(WINMM_Device *device)
1622 {
1623     WINMM_CBInfo cb_info;
1624     WAVEHDR *queue, *first = NULL, *last = NULL;
1625     HRESULT hr;
1626
1627     TRACE("(%p)\n", device->handle);
1628
1629     EnterCriticalSection(&device->lock);
1630
1631     if(!device->device || !device->first)
1632         goto exit;
1633
1634     first = device->first;
1635
1636     if(device->acm_handle){
1637         WID_PullACMData(device);
1638         goto exit;
1639     }
1640
1641     while(device->first){
1642         BYTE *data;
1643         UINT32 packet_len, packet;
1644         DWORD flags;
1645
1646         hr = IAudioCaptureClient_GetBuffer(device->capture, &data, &packet_len,
1647                 &flags, NULL, NULL);
1648         if(hr != S_OK){
1649             if(FAILED(hr))
1650                 WARN("GetBuffer failed: %08x\n", hr);
1651             else /* AUDCLNT_S_BUFFER_EMPTY success code */
1652                 IAudioCaptureClient_ReleaseBuffer(device->capture, 0);
1653             goto exit;
1654         }
1655
1656         packet = packet_len;
1657         queue = device->first;
1658         while(queue && packet > 0){
1659             UINT32 to_copy_bytes;
1660
1661             to_copy_bytes = min(packet * device->bytes_per_frame,
1662                     queue->dwBufferLength - queue->dwBytesRecorded);
1663
1664             memcpy(queue->lpData + queue->dwBytesRecorded,
1665                     data + (packet_len - packet) * device->bytes_per_frame,
1666                     to_copy_bytes);
1667
1668             queue->dwBytesRecorded += to_copy_bytes;
1669
1670             if(queue->dwBufferLength - queue->dwBytesRecorded <
1671                     device->bytes_per_frame){
1672                 last = queue;
1673                 device->first = queue = queue->lpNext;
1674             }
1675
1676             packet -= to_copy_bytes / device->bytes_per_frame;
1677         }
1678
1679         hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet_len);
1680         if(FAILED(hr))
1681             WARN("ReleaseBuffer failed: %08x\n", hr);
1682
1683         if(packet > 0)
1684             WARN("losing %u frames\n", packet);
1685         device->played_frames += packet_len;
1686     }
1687
1688 exit:
1689     cb_info = device->cb_info;
1690
1691     LeaveCriticalSection(&device->lock);
1692
1693     if(last){
1694         last->lpNext = NULL;
1695         while(first){
1696             WAVEHDR *next = first->lpNext;
1697             first->dwFlags &= ~WHDR_INQUEUE;
1698             first->dwFlags |= WHDR_DONE;
1699             WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)first, 0);
1700             first = next;
1701         }
1702     }
1703 }
1704
1705 static HRESULT WINMM_BeginPlaying(WINMM_Device *device)
1706 {
1707     HRESULT hr;
1708
1709     TRACE("(%p)\n", device->handle);
1710
1711     if(device->render)
1712         /* prebuffer data before starting */
1713         WOD_PushData(device);
1714
1715     if(device->stopped){
1716         device->stopped = FALSE;
1717
1718         hr = IAudioClient_Start(device->client);
1719         if(FAILED(hr) && hr != AUDCLNT_E_NOT_STOPPED){
1720             device->stopped = TRUE;
1721             WARN("Start failed: %08x\n", hr);
1722             return hr;
1723         }
1724     }
1725
1726     return S_OK;
1727 }
1728
1729 static LRESULT WINMM_Pause(HWAVE hwave)
1730 {
1731     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1732     HRESULT hr;
1733
1734     TRACE("(%p)\n", hwave);
1735
1736     if(!WINMM_ValidateAndLock(device))
1737         return MMSYSERR_INVALHANDLE;
1738
1739     hr = IAudioClient_Stop(device->client);
1740     if(FAILED(hr)){
1741         LeaveCriticalSection(&device->lock);
1742         WARN("Stop failed: %08x\n", hr);
1743         return MMSYSERR_ERROR;
1744     }
1745
1746     device->stopped = FALSE;
1747
1748     LeaveCriticalSection(&device->lock);
1749
1750     return MMSYSERR_NOERROR;
1751 }
1752
1753 static LRESULT WINMM_Reset(HWAVE hwave)
1754 {
1755     WINMM_CBInfo cb_info;
1756     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1757     BOOL is_out;
1758     WAVEHDR *first;
1759     HRESULT hr;
1760
1761     TRACE("(%p)\n", hwave);
1762
1763     if(!WINMM_ValidateAndLock(device))
1764         return MMSYSERR_INVALHANDLE;
1765
1766     hr = IAudioClient_Stop(device->client);
1767     if(FAILED(hr)){
1768         LeaveCriticalSection(&device->lock);
1769         WARN("Stop failed: %08x\n", hr);
1770         return MMSYSERR_ERROR;
1771     }
1772     device->stopped = TRUE;
1773
1774     first = device->first;
1775     device->first = device->last = device->playing = NULL;
1776     device->ofs_bytes = 0;
1777     device->played_frames = 0;
1778     device->loop_counter = 0;
1779     device->last_clock_pos = 0;
1780     IAudioClient_Reset(device->client);
1781
1782     cb_info = device->cb_info;
1783     is_out = device->render != NULL;
1784
1785     LeaveCriticalSection(&device->lock);
1786
1787     while(first){
1788         WAVEHDR *next = first->lpNext;
1789         first->dwFlags &= ~WHDR_INQUEUE;
1790         first->dwFlags |= WHDR_DONE;
1791         if(is_out)
1792             WINMM_NotifyClient(&cb_info, WOM_DONE, (DWORD_PTR)first, 0);
1793         else
1794             WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)first, 0);
1795         first = next;
1796     }
1797
1798     return MMSYSERR_NOERROR;
1799 }
1800
1801 static MMRESULT WINMM_FramesToMMTime(MMTIME *time, UINT32 played_frames,
1802         UINT32 sample_rate, UINT32 bytes_per_frame)
1803 {
1804     switch(time->wType){
1805     case TIME_SAMPLES:
1806         time->u.sample = played_frames;
1807         return MMSYSERR_NOERROR;
1808     case TIME_MS:
1809         time->u.ms = (UINT64)played_frames * 1000 / sample_rate;
1810         return MMSYSERR_NOERROR;
1811     case TIME_SMPTE:
1812         time->u.smpte.fps = 30;
1813         played_frames += sample_rate / time->u.smpte.fps - 1; /* round up */
1814         time->u.smpte.frame = (played_frames % sample_rate) * time->u.smpte.fps / sample_rate;
1815         played_frames /= sample_rate; /* yields seconds */
1816         time->u.smpte.sec = played_frames % 60;
1817         played_frames /= 60;
1818         time->u.smpte.min = played_frames % 60;
1819         time->u.smpte.hour= played_frames / 60;
1820         return MMSYSERR_NOERROR;
1821     default:
1822         time->wType = TIME_BYTES;
1823         /* fall through */
1824     case TIME_BYTES:
1825         time->u.cb = played_frames * bytes_per_frame;
1826         return MMSYSERR_NOERROR;
1827     }
1828 }
1829
1830 static LRESULT WINMM_GetPosition(HWAVE hwave, MMTIME *time)
1831 {
1832     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1833     UINT32 played_frames, sample_rate, bytes_per_frame;
1834
1835     TRACE("(%p, %p)\n", hwave, time);
1836
1837     if(!WINMM_ValidateAndLock(device))
1838         return MMSYSERR_INVALHANDLE;
1839
1840     played_frames = device->played_frames;
1841     sample_rate = device->samples_per_sec;
1842     bytes_per_frame = device->bytes_per_frame;
1843
1844     LeaveCriticalSection(&device->lock);
1845
1846     return WINMM_FramesToMMTime(time, played_frames, sample_rate,
1847             bytes_per_frame);
1848 }
1849
1850 static WINMM_MMDevice *WINMM_GetMixerMMDevice(HMIXEROBJ hmix, DWORD flags,
1851         UINT *mmdev_index)
1852 {
1853     UINT mmdev, dev, junk, *out;
1854     BOOL is_out;
1855
1856     if(!mmdev_index)
1857         out = &mmdev;
1858     else
1859         out = mmdev_index;
1860
1861     switch(flags & 0xF0000000){
1862     case MIXER_OBJECTF_MIXER: /* == 0 */
1863         *out = HandleToULong(hmix);
1864         if(*out < g_outmmdevices_count)
1865             return &g_out_mmdevices[*out];
1866         if(*out - g_outmmdevices_count < g_inmmdevices_count){
1867             *out -= g_outmmdevices_count;
1868             return &g_in_mmdevices[*out];
1869         }
1870         /* fall through -- if it's not a valid mixer device, then
1871          * it could be a valid mixer handle. windows seems to do
1872          * this as well. */
1873     case MIXER_OBJECTF_HMIXER:
1874     case MIXER_OBJECTF_HWAVEOUT:
1875     case MIXER_OBJECTF_HWAVEIN:
1876         WINMM_DecomposeHWAVE((HWAVE)hmix, out, &is_out, &dev, &junk);
1877         if(junk != 0x1 || (is_out && *out >= g_outmmdevices_count) ||
1878                (!is_out && *out >= g_inmmdevices_count))
1879             return NULL;
1880         if(is_out)
1881             return &g_out_mmdevices[*out];
1882         return &g_in_mmdevices[*out];
1883     case MIXER_OBJECTF_WAVEOUT:
1884         *out = HandleToULong(hmix);
1885         if(*out < g_outmmdevices_count)
1886             return &g_out_mmdevices[*out];
1887         return NULL;
1888     case MIXER_OBJECTF_WAVEIN:
1889         *out = HandleToULong(hmix);
1890         if(*out < g_inmmdevices_count)
1891             return &g_in_mmdevices[*out];
1892         return NULL;
1893     }
1894
1895     return NULL;
1896 }
1897
1898 static MMRESULT WINMM_SetupMMDeviceVolume(WINMM_MMDevice *mmdevice)
1899 {
1900     IAudioSessionManager *sesman;
1901     IMMDevice *device;
1902     HRESULT hr;
1903
1904     hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id, &device);
1905     if(FAILED(hr)){
1906         WARN("Device %s (%s) unavailable: %08x\n",
1907                 wine_dbgstr_w(mmdevice->dev_id),
1908                 wine_dbgstr_w(mmdevice->out_caps.szPname), hr);
1909         return MMSYSERR_ERROR;
1910     }
1911
1912     hr = IMMDevice_Activate(device, &IID_IAudioSessionManager,
1913             CLSCTX_INPROC_SERVER, NULL, (void**)&sesman);
1914     if(FAILED(hr)){
1915         WARN("Activate failed: %08x\n", hr);
1916         IMMDevice_Release(device);
1917         return MMSYSERR_ERROR;
1918     }
1919
1920     IMMDevice_Release(device);
1921
1922     hr = IAudioSessionManager_GetSimpleAudioVolume(sesman, &mmdevice->session,
1923             FALSE, &mmdevice->volume);
1924     IAudioSessionManager_Release(sesman);
1925     if(FAILED(hr)){
1926         WARN("GetSimpleAudioVolume failed: %08x\n", hr);
1927         return MMSYSERR_ERROR;
1928     }
1929
1930     return MMSYSERR_NOERROR;
1931 }
1932
1933 static LRESULT MXD_GetControlDetails(WINMM_ControlDetails *details)
1934 {
1935     WINMM_MMDevice *mmdevice;
1936     MIXERCONTROLDETAILS *control = details->details;
1937     HRESULT hr;
1938
1939     TRACE("(%p)\n", details->hmix);
1940
1941     mmdevice = WINMM_GetMixerMMDevice(details->hmix, details->flags, NULL);
1942     if(!mmdevice)
1943         return MMSYSERR_INVALHANDLE;
1944
1945     EnterCriticalSection(&mmdevice->lock);
1946
1947     if(!mmdevice->volume){
1948         MMRESULT mr;
1949
1950         mr = WINMM_SetupMMDeviceVolume(mmdevice);
1951         if(mr != MMSYSERR_NOERROR){
1952             LeaveCriticalSection(&mmdevice->lock);
1953             return mr;
1954         }
1955     }
1956
1957     if(control->dwControlID == 0){
1958         float vol;
1959         MIXERCONTROLDETAILS_UNSIGNED *udet;
1960
1961         if(!control->paDetails ||
1962                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)){
1963             LeaveCriticalSection(&mmdevice->lock);
1964             return MMSYSERR_INVALPARAM;
1965         }
1966
1967         hr = ISimpleAudioVolume_GetMasterVolume(mmdevice->volume, &vol);
1968         if(FAILED(hr)){
1969             WARN("GetMasterVolume failed: %08x\n", hr);
1970             LeaveCriticalSection(&mmdevice->lock);
1971             return MMSYSERR_ERROR;
1972         }
1973
1974         udet = (MIXERCONTROLDETAILS_UNSIGNED*)control->paDetails;
1975         udet->dwValue = vol * ((unsigned int)0xFFFF);
1976     }else if(control->dwControlID == 1){
1977         BOOL mute;
1978         MIXERCONTROLDETAILS_BOOLEAN *bdet;
1979
1980         if(!control->paDetails ||
1981                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_BOOLEAN)){
1982             LeaveCriticalSection(&mmdevice->lock);
1983             return MMSYSERR_INVALPARAM;
1984         }
1985
1986         hr = ISimpleAudioVolume_GetMute(mmdevice->volume, &mute);
1987         if(FAILED(hr)){
1988             WARN("GetMute failed: %08x\n", hr);
1989             LeaveCriticalSection(&mmdevice->lock);
1990             return MMSYSERR_ERROR;
1991         }
1992
1993         bdet = (MIXERCONTROLDETAILS_BOOLEAN*)control->paDetails;
1994         bdet->fValue = mute;
1995     }else if(control->dwControlID == 2 || control->dwControlID == 3){
1996         FIXME("What should the sw-side mixer controls map to?\n");
1997     }else{
1998         LeaveCriticalSection(&mmdevice->lock);
1999         return MIXERR_INVALCONTROL;
2000     }
2001
2002     LeaveCriticalSection(&mmdevice->lock);
2003
2004     return MMSYSERR_NOERROR;
2005 }
2006
2007 static LRESULT MXD_SetControlDetails(WINMM_ControlDetails *details)
2008 {
2009     WINMM_MMDevice *mmdevice;
2010     MIXERCONTROLDETAILS *control = details->details;
2011     HRESULT hr;
2012
2013     TRACE("(%p)\n", details->hmix);
2014
2015     mmdevice = WINMM_GetMixerMMDevice(details->hmix, details->flags, NULL);
2016     if(!mmdevice)
2017         return MMSYSERR_INVALHANDLE;
2018
2019     EnterCriticalSection(&mmdevice->lock);
2020
2021     if(!mmdevice->volume){
2022         MMRESULT mr;
2023
2024         mr = WINMM_SetupMMDeviceVolume(mmdevice);
2025         if(mr != MMSYSERR_NOERROR){
2026             LeaveCriticalSection(&mmdevice->lock);
2027             return mr;
2028         }
2029     }
2030
2031     if(control->dwControlID == 0){
2032         float vol;
2033         MIXERCONTROLDETAILS_UNSIGNED *udet;
2034
2035         if(!control->paDetails ||
2036                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)){
2037             LeaveCriticalSection(&mmdevice->lock);
2038             return MMSYSERR_INVALPARAM;
2039         }
2040
2041         udet = (MIXERCONTROLDETAILS_UNSIGNED*)control->paDetails;
2042
2043         if(udet->dwValue > 65535){
2044             LeaveCriticalSection(&mmdevice->lock);
2045             return MMSYSERR_INVALPARAM;
2046         }
2047
2048         vol = udet->dwValue / 65535.f;
2049
2050         hr = ISimpleAudioVolume_SetMasterVolume(mmdevice->volume, vol, NULL);
2051         if(FAILED(hr)){
2052             WARN("SetMasterVolume failed: %08x\n", hr);
2053             LeaveCriticalSection(&mmdevice->lock);
2054             return MMSYSERR_ERROR;
2055         }
2056     }else if(control->dwControlID == 1){
2057         BOOL mute;
2058         MIXERCONTROLDETAILS_BOOLEAN *bdet;
2059
2060         if(!control->paDetails ||
2061                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_BOOLEAN)){
2062             LeaveCriticalSection(&mmdevice->lock);
2063             return MMSYSERR_INVALPARAM;
2064         }
2065
2066         bdet = (MIXERCONTROLDETAILS_BOOLEAN*)control->paDetails;
2067         mute = bdet->fValue;
2068
2069         hr = ISimpleAudioVolume_SetMute(mmdevice->volume, mute, NULL);
2070         if(FAILED(hr)){
2071             WARN("SetMute failed: %08x\n", hr);
2072             LeaveCriticalSection(&mmdevice->lock);
2073             return MMSYSERR_ERROR;
2074         }
2075     }else if(control->dwControlID == 2 || control->dwControlID == 3){
2076         FIXME("What should the sw-side mixer controls map to?\n");
2077     }else{
2078         LeaveCriticalSection(&mmdevice->lock);
2079         return MIXERR_INVALCONTROL;
2080     }
2081
2082     LeaveCriticalSection(&mmdevice->lock);
2083
2084     return MMSYSERR_NOERROR;
2085 }
2086
2087 static LRESULT DRV_QueryDeviceInterface(WINMM_QueryInterfaceInfo *info)
2088 {
2089     WINMM_MMDevice *mmdevice;
2090     IMMDevice *device;
2091     IPropertyStore *ps;
2092     PROPVARIANT pv;
2093     DWORD len_bytes;
2094     HRESULT hr;
2095
2096     static const PROPERTYKEY deviceinterface_key = {
2097         {0x233164c8, 0x1b2c, 0x4c7d, {0xbc, 0x68, 0xb6, 0x71, 0x68, 0x7a, 0x25, 0x67}}, 1
2098     };
2099
2100     if(WINMM_IsMapper(info->index)){
2101         if(info->str){
2102             if(*info->len_bytes < sizeof(WCHAR))
2103                 return MMSYSERR_INVALPARAM;
2104             *info->str = 0;
2105         }else
2106             *info->len_bytes = sizeof(WCHAR);
2107         return MMSYSERR_NOERROR;
2108     }
2109
2110     if(info->is_out){
2111         if(info->index >= g_outmmdevices_count)
2112             return MMSYSERR_INVALHANDLE;
2113
2114         mmdevice = &g_out_mmdevices[info->index];
2115     }else{
2116         if(info->index >= g_inmmdevices_count)
2117             return MMSYSERR_INVALHANDLE;
2118
2119         mmdevice = &g_in_mmdevices[info->index];
2120     }
2121
2122     hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id,
2123             &device);
2124     if(FAILED(hr)){
2125         WARN("Device %s unavailable: %08x\n", wine_dbgstr_w(mmdevice->dev_id), hr);
2126         return MMSYSERR_ERROR;
2127     }
2128
2129     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
2130     if(FAILED(hr)){
2131         WARN("OpenPropertyStore failed: %08x\n", hr);
2132         IMMDevice_Release(device);
2133         return MMSYSERR_ERROR;
2134     }
2135
2136     PropVariantInit(&pv);
2137     hr = IPropertyStore_GetValue(ps, &deviceinterface_key, &pv);
2138     if(FAILED(hr)){
2139         WARN("GetValue failed: %08x\n", hr);
2140         IPropertyStore_Release(ps);
2141         IMMDevice_Release(device);
2142         return MMSYSERR_ERROR;
2143     }
2144     if(pv.vt != VT_LPWSTR){
2145         WARN("Got unexpected property type: %u\n", pv.vt);
2146         PropVariantClear(&pv);
2147         IPropertyStore_Release(ps);
2148         IMMDevice_Release(device);
2149         return MMSYSERR_ERROR;
2150     }
2151
2152     len_bytes = (lstrlenW(pv.u.pwszVal) + 1) * sizeof(WCHAR);
2153
2154     if(info->str){
2155         if(len_bytes > *info->len_bytes){
2156             PropVariantClear(&pv);
2157             IPropertyStore_Release(ps);
2158             IMMDevice_Release(device);
2159             return MMSYSERR_INVALPARAM;
2160         }
2161
2162         memcpy(info->str, pv.u.pwszVal, len_bytes);
2163     }else
2164         *info->len_bytes = len_bytes;
2165
2166     PropVariantClear(&pv);
2167     IPropertyStore_Release(ps);
2168     IMMDevice_Release(device);
2169
2170     return MMSYSERR_NOERROR;
2171 }
2172
2173 static LRESULT CALLBACK WINMM_DevicesMsgProc(HWND hwnd, UINT msg, WPARAM wparam,
2174         LPARAM lparam)
2175 {
2176     switch(msg){
2177     case WODM_OPEN:
2178         return WOD_Open((WINMM_OpenInfo*)wparam);
2179     case WODM_CLOSE:
2180         return WOD_Close((HWAVEOUT)wparam);
2181     case WIDM_OPEN:
2182         return WID_Open((WINMM_OpenInfo*)wparam);
2183     case WIDM_CLOSE:
2184         return WID_Close((HWAVEIN)wparam);
2185     case MXDM_GETCONTROLDETAILS:
2186         return MXD_GetControlDetails((WINMM_ControlDetails*)wparam);
2187     case MXDM_SETCONTROLDETAILS:
2188         return MXD_SetControlDetails((WINMM_ControlDetails*)wparam);
2189     case DRV_QUERYDEVICEINTERFACESIZE:
2190     case DRV_QUERYDEVICEINTERFACE:
2191         return DRV_QueryDeviceInterface((WINMM_QueryInterfaceInfo*)wparam);
2192     case WINMM_WM_QUIT:
2193         TRACE("QUIT message received\n");
2194         DestroyWindow(g_devices_hwnd);
2195         g_devices_hwnd = NULL;
2196         IMMDeviceEnumerator_Release(g_devenum);
2197         CoUninitialize();
2198         return 0;
2199     }
2200     return DefWindowProcW(hwnd, msg, wparam, lparam);
2201 }
2202
2203 static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
2204 {
2205     HANDLE evt = arg;
2206     HRESULT hr;
2207     static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
2208
2209     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
2210     if(FAILED(hr)){
2211         WARN("CoInitializeEx failed: %08x\n", hr);
2212         return 1;
2213     }
2214
2215     hr = WINMM_InitMMDevices();
2216     if(FAILED(hr)){
2217         CoUninitialize();
2218         return 1;
2219     }
2220
2221     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
2222             CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&g_devenum);
2223     if(FAILED(hr)){
2224         WARN("CoCreateInstance failed: %08x\n", hr);
2225         CoUninitialize();
2226         return 1;
2227     }
2228
2229     g_devices_hwnd = CreateWindowW(messageW, NULL, 0, 0, 0, 0, 0,
2230             HWND_MESSAGE, NULL, NULL, NULL);
2231     if(!g_devices_hwnd){
2232         WARN("CreateWindow failed: %d\n", GetLastError());
2233         IMMDeviceEnumerator_Release(g_devenum);
2234         CoUninitialize();
2235         return 1;
2236     }
2237
2238     SetWindowLongPtrW(g_devices_hwnd, GWLP_WNDPROC,
2239             (LONG_PTR)WINMM_DevicesMsgProc);
2240
2241     /* inform caller that the thread is ready to process messages */
2242     SetEvent(evt);
2243     evt = NULL; /* do not use after this point */
2244
2245     while(1){
2246         DWORD wait;
2247         wait = MsgWaitForMultipleObjects(g_devhandle_count, g_device_handles,
2248                 FALSE, INFINITE, QS_ALLINPUT);
2249         if(wait == g_devhandle_count + WAIT_OBJECT_0){
2250             MSG msg;
2251             if(PeekMessageW(&msg, g_devices_hwnd, 0, 0, PM_REMOVE))
2252                 WARN("Unexpected message: 0x%x\n", msg.message);
2253             if(!g_devices_hwnd)
2254                 break;
2255         }else if(wait < g_devhandle_count + WAIT_OBJECT_0){
2256             WINMM_Device *device = g_handle_devices[wait - WAIT_OBJECT_0];
2257             if(device->render)
2258                 WOD_PushData(device);
2259             else
2260                 WID_PullData(device);
2261         }else
2262             WARN("Unexpected MsgWait result 0x%x, GLE: %d\n", wait,
2263                     GetLastError());
2264     }
2265
2266     return 0;
2267 }
2268
2269 static BOOL WINMM_StartDevicesThread(void)
2270 {
2271     HANDLE events[2];
2272     DWORD wait;
2273
2274     EnterCriticalSection(&g_devthread_lock);
2275
2276     if(g_devices_thread){
2277         DWORD wait;
2278
2279         wait = WaitForSingleObject(g_devices_thread, 0);
2280         if(wait == WAIT_TIMEOUT){
2281             LeaveCriticalSection(&g_devthread_lock);
2282             return TRUE;
2283         }
2284         if(wait != WAIT_OBJECT_0){
2285             LeaveCriticalSection(&g_devthread_lock);
2286             return FALSE;
2287         }
2288
2289         g_devices_thread = NULL;
2290         g_devices_hwnd = NULL;
2291     }
2292
2293     TRACE("Starting up devices thread\n");
2294
2295     events[0] = CreateEventW(NULL, FALSE, FALSE, NULL);
2296
2297     g_devices_thread = CreateThread(NULL, 0, WINMM_DevicesThreadProc,
2298             events[0], 0, NULL);
2299     if(!g_devices_thread){
2300         LeaveCriticalSection(&g_devthread_lock);
2301         CloseHandle(events[0]);
2302         return FALSE;
2303     }
2304
2305     events[1] = g_devices_thread;
2306     wait = WaitForMultipleObjects(2, events, FALSE, INFINITE);
2307     CloseHandle(events[0]);
2308     if(wait != WAIT_OBJECT_0){
2309         if(wait == 1 + WAIT_OBJECT_0){
2310             CloseHandle(g_devices_thread);
2311             g_devices_thread = NULL;
2312             g_devices_hwnd = NULL;
2313         }
2314         LeaveCriticalSection(&g_devthread_lock);
2315         return FALSE;
2316     }
2317
2318     LeaveCriticalSection(&g_devthread_lock);
2319
2320     return TRUE;
2321 }
2322
2323 /**************************************************************************
2324  *                              waveOutGetNumDevs               [WINMM.@]
2325  */
2326 UINT WINAPI waveOutGetNumDevs(void)
2327 {
2328     HRESULT hr = WINMM_InitMMDevices();
2329     if(FAILED(hr))
2330         return 0;
2331
2332     TRACE("count: %u\n", g_outmmdevices_count);
2333
2334     return g_outmmdevices_count;
2335 }
2336
2337 /**************************************************************************
2338  *                              waveOutGetDevCapsA              [WINMM.@]
2339  */
2340 UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
2341                                UINT uSize)
2342 {
2343     WAVEOUTCAPSW        wocW;
2344     UINT                ret;
2345
2346     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2347
2348     if(!lpCaps)
2349         return MMSYSERR_INVALPARAM;
2350
2351     ret = waveOutGetDevCapsW(uDeviceID, &wocW, sizeof(wocW));
2352
2353     if (ret == MMSYSERR_NOERROR) {
2354         WAVEOUTCAPSA wocA;
2355         wocA.wMid           = wocW.wMid;
2356         wocA.wPid           = wocW.wPid;
2357         wocA.vDriverVersion = wocW.vDriverVersion;
2358         WideCharToMultiByte( CP_ACP, 0, wocW.szPname, -1, wocA.szPname,
2359                              sizeof(wocA.szPname), NULL, NULL );
2360         wocA.dwFormats      = wocW.dwFormats;
2361         wocA.wChannels      = wocW.wChannels;
2362         wocA.dwSupport      = wocW.dwSupport;
2363         memcpy(lpCaps, &wocA, min(uSize, sizeof(wocA)));
2364     }
2365     return ret;
2366 }
2367
2368 /**************************************************************************
2369  *                              waveOutGetDevCapsW              [WINMM.@]
2370  */
2371 UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
2372                                UINT uSize)
2373 {
2374     WAVEOUTCAPSW mapper_caps, *caps;
2375     HRESULT hr;
2376
2377     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2378
2379     hr = WINMM_InitMMDevices();
2380     if(FAILED(hr))
2381         return MMSYSERR_ERROR;
2382
2383     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
2384
2385     if(WINMM_IsMapper(uDeviceID)){
2386         /* FIXME: Should be localized */
2387         static const WCHAR mapper_pnameW[] = {'W','i','n','e',' ','S','o','u',
2388             'n','d',' ','M','a','p','p','e','r',0};
2389
2390         mapper_caps.wMid = 0xFF;
2391         mapper_caps.wPid = 0xFF;
2392         mapper_caps.vDriverVersion = 0x00010001;
2393         mapper_caps.dwFormats = 0xFFFFFFFF;
2394         mapper_caps.wReserved1 = 0;
2395         mapper_caps.dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME |
2396             WAVECAPS_SAMPLEACCURATE;
2397         mapper_caps.wChannels = 2;
2398         lstrcpyW(mapper_caps.szPname, mapper_pnameW);
2399
2400         caps = &mapper_caps;
2401     }else{
2402         if(uDeviceID >= g_outmmdevices_count)
2403             return MMSYSERR_BADDEVICEID;
2404
2405         caps = &g_out_mmdevices[uDeviceID].out_caps;
2406     }
2407
2408     memcpy(lpCaps, caps, min(uSize, sizeof(*lpCaps)));
2409
2410     return MMSYSERR_NOERROR;
2411 }
2412
2413 /**************************************************************************
2414  *                              waveOutGetErrorTextA    [WINMM.@]
2415  *                              waveInGetErrorTextA     [WINMM.@]
2416  */
2417 UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2418 {
2419     UINT        ret;
2420
2421     if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
2422     else if (uSize == 0) ret = MMSYSERR_NOERROR;
2423     else
2424     {
2425         LPWSTR  xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR));
2426         if (!xstr) ret = MMSYSERR_NOMEM;
2427         else
2428         {
2429             ret = waveOutGetErrorTextW(uError, xstr, uSize);
2430             if (ret == MMSYSERR_NOERROR)
2431                 WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL);
2432             HeapFree(GetProcessHeap(), 0, xstr);
2433         }
2434     }
2435     return ret;
2436 }
2437
2438 /**************************************************************************
2439  *                              waveOutGetErrorTextW    [WINMM.@]
2440  *                              waveInGetErrorTextW     [WINMM.@]
2441  */
2442 UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2443 {
2444     UINT        ret = MMSYSERR_BADERRNUM;
2445
2446     if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
2447     else if (uSize == 0) ret = MMSYSERR_NOERROR;
2448     else if (
2449                /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2450                 * a warning for the test was always true */
2451                (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
2452                (uError >= WAVERR_BASE  && uError <= WAVERR_LASTERROR)) {
2453         if (LoadStringW(hWinMM32Instance,
2454                         uError, lpText, uSize) > 0) {
2455             ret = MMSYSERR_NOERROR;
2456         }
2457     }
2458     return ret;
2459 }
2460
2461 /**************************************************************************
2462  *                      waveOutOpen                     [WINMM.@]
2463  * All the args/structs have the same layout as the win16 equivalents
2464  */
2465 MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
2466                        LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
2467                        DWORD_PTR dwInstance, DWORD dwFlags)
2468 {
2469     LRESULT res;
2470     WINMM_OpenInfo info;
2471     WINMM_CBInfo cb_info;
2472
2473     TRACE("(%p, %u, %p, %lx, %lx, %08x)\n", lphWaveOut, uDeviceID, lpFormat,
2474             dwCallback, dwInstance, dwFlags);
2475
2476     if(!WINMM_StartDevicesThread())
2477         return MMSYSERR_ERROR;
2478
2479     if(!lphWaveOut && !(dwFlags & WAVE_FORMAT_QUERY))
2480         return MMSYSERR_INVALPARAM;
2481
2482     res = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
2483     if(res != MMSYSERR_NOERROR)
2484         return res;
2485
2486     info.format = (WAVEFORMATEX*)lpFormat;
2487     info.callback = dwCallback;
2488     info.cb_user = dwInstance;
2489     info.req_device = uDeviceID;
2490     info.flags = dwFlags;
2491
2492     res = SendMessageW(g_devices_hwnd, WODM_OPEN, (DWORD_PTR)&info, 0);
2493     if(res != MMSYSERR_NOERROR)
2494         return res;
2495
2496     if(lphWaveOut)
2497         *lphWaveOut = (HWAVEOUT)info.handle;
2498
2499     cb_info.flags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2500     cb_info.callback = dwCallback;
2501     cb_info.user = dwInstance;
2502     cb_info.hwave = info.handle;
2503
2504     WINMM_NotifyClient(&cb_info, WOM_OPEN, 0, 0);
2505
2506     return res;
2507 }
2508
2509 /**************************************************************************
2510  *                              waveOutClose            [WINMM.@]
2511  */
2512 UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
2513 {
2514     UINT res;
2515     WINMM_Device *device;
2516     WINMM_CBInfo cb_info;
2517
2518     TRACE("(%p)\n", hWaveOut);
2519
2520     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2521
2522     if(!WINMM_ValidateAndLock(device))
2523         return MMSYSERR_INVALHANDLE;
2524
2525     cb_info = device->cb_info;
2526
2527     LeaveCriticalSection(&device->lock);
2528
2529     res = SendMessageW(g_devices_hwnd, WODM_CLOSE, (WPARAM)hWaveOut, 0);
2530
2531     if(res == MMSYSERR_NOERROR)
2532         WINMM_NotifyClient(&cb_info, WOM_CLOSE, 0, 0);
2533
2534     return res;
2535 }
2536
2537 /**************************************************************************
2538  *                              waveOutPrepareHeader    [WINMM.@]
2539  */
2540 UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
2541                                  WAVEHDR* lpWaveOutHdr, UINT uSize)
2542 {
2543     TRACE("(%p, %p, %u)\n", hWaveOut, lpWaveOutHdr, uSize);
2544
2545     if(!lpWaveOutHdr || uSize < sizeof(WAVEHDR))
2546         return MMSYSERR_INVALPARAM;
2547
2548     if(lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2549         return WAVERR_STILLPLAYING;
2550
2551     return WINMM_PrepareHeader((HWAVE)hWaveOut, lpWaveOutHdr);
2552 }
2553
2554 /**************************************************************************
2555  *                              waveOutUnprepareHeader  [WINMM.@]
2556  */
2557 UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
2558                                    LPWAVEHDR lpWaveOutHdr, UINT uSize)
2559 {
2560     TRACE("(%p, %p, %u)\n", hWaveOut, lpWaveOutHdr, uSize);
2561
2562     if(!lpWaveOutHdr || uSize < sizeof(WAVEHDR))
2563         return MMSYSERR_INVALPARAM;
2564
2565     if(!(lpWaveOutHdr->dwFlags & WHDR_PREPARED))
2566         return MMSYSERR_NOERROR;
2567
2568     if(lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2569         return WAVERR_STILLPLAYING;
2570
2571     return WINMM_UnprepareHeader((HWAVE)hWaveOut, lpWaveOutHdr);
2572 }
2573
2574 /**************************************************************************
2575  *                              waveOutWrite            [WINMM.@]
2576  */
2577 UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR *header, UINT uSize)
2578 {
2579     WINMM_Device *device;
2580     HRESULT hr;
2581
2582     TRACE("(%p, %p, %u)\n", hWaveOut, header, uSize);
2583
2584     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2585
2586     if(!WINMM_ValidateAndLock(device))
2587         return MMSYSERR_INVALHANDLE;
2588
2589     if(!header->lpData || !(header->dwFlags & WHDR_PREPARED)){
2590         LeaveCriticalSection(&device->lock);
2591         return WAVERR_UNPREPARED;
2592     }
2593
2594     if(header->dwFlags & WHDR_INQUEUE){
2595         LeaveCriticalSection(&device->lock);
2596         return WAVERR_STILLPLAYING;
2597     }
2598
2599     if(device->acm_handle){
2600         ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
2601         MMRESULT mr;
2602
2603         ash->cbSrcLength = header->dwBufferLength;
2604         mr = acmStreamConvert(device->acm_handle, ash, 0);
2605         if(mr != MMSYSERR_NOERROR){
2606             LeaveCriticalSection(&device->lock);
2607             return mr;
2608         }
2609     }
2610
2611     if(device->first){
2612         device->last->lpNext = header;
2613         device->last = header;
2614         if(!device->playing)
2615             device->playing = header;
2616     }else{
2617         device->playing = device->first = device->last = header;
2618         if(header->dwFlags & WHDR_BEGINLOOP){
2619             device->loop_counter = header->dwLoops;
2620             device->loop_start = header;
2621         }
2622     }
2623
2624     header->lpNext = NULL;
2625     header->dwFlags &= ~WHDR_DONE;
2626     header->dwFlags |= WHDR_INQUEUE;
2627
2628     hr = WINMM_BeginPlaying(device);
2629     if(FAILED(hr)){
2630         LeaveCriticalSection(&device->lock);
2631         return MMSYSERR_ERROR;
2632     }
2633
2634     LeaveCriticalSection(&device->lock);
2635
2636     return MMSYSERR_NOERROR;
2637 }
2638
2639 /**************************************************************************
2640  *                              waveOutBreakLoop        [WINMM.@]
2641  */
2642 UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
2643 {
2644     WINMM_Device *device;
2645
2646     TRACE("(%p)\n", hWaveOut);
2647
2648     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2649
2650     if(!WINMM_ValidateAndLock(device))
2651         return MMSYSERR_INVALHANDLE;
2652
2653     device->loop_counter = 0;
2654
2655     LeaveCriticalSection(&device->lock);
2656
2657     return MMSYSERR_NOERROR;
2658 }
2659
2660 /**************************************************************************
2661  *                              waveOutPause            [WINMM.@]
2662  */
2663 UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
2664 {
2665     TRACE("(%p)\n", hWaveOut);
2666
2667     return WINMM_Pause((HWAVE)hWaveOut);
2668 }
2669
2670 /**************************************************************************
2671  *                              waveOutReset            [WINMM.@]
2672  */
2673 UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
2674 {
2675     TRACE("(%p)\n", hWaveOut);
2676
2677     return WINMM_Reset((HWAVE)hWaveOut);
2678 }
2679
2680 /**************************************************************************
2681  *                              waveOutRestart          [WINMM.@]
2682  */
2683 UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
2684 {
2685     WINMM_Device *device;
2686     HRESULT hr;
2687
2688     TRACE("(%p)\n", hWaveOut);
2689
2690     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2691
2692     if(!WINMM_ValidateAndLock(device))
2693         return MMSYSERR_INVALHANDLE;
2694
2695     device->stopped = TRUE;
2696
2697     hr = WINMM_BeginPlaying(device);
2698     if(FAILED(hr)){
2699         LeaveCriticalSection(&device->lock);
2700         return MMSYSERR_ERROR;
2701     }
2702
2703     LeaveCriticalSection(&device->lock);
2704
2705     return MMSYSERR_NOERROR;
2706 }
2707
2708 /**************************************************************************
2709  *                              waveOutGetPosition      [WINMM.@]
2710  */
2711 UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
2712                                UINT uSize)
2713 {
2714     TRACE("(%p, %p, %u)\n", hWaveOut, lpTime, uSize);
2715
2716     if(!uSize || !lpTime || uSize != sizeof(MMTIME))
2717         return MMSYSERR_INVALPARAM;
2718
2719     return WINMM_GetPosition((HWAVE)hWaveOut, lpTime);
2720 }
2721
2722 /**************************************************************************
2723  *                              waveOutGetPitch         [WINMM.@]
2724  */
2725 UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
2726 {
2727     TRACE("(%p, %p)\n", hWaveOut, lpdw);
2728     return MMSYSERR_NOTSUPPORTED;
2729 }
2730
2731 /**************************************************************************
2732  *                              waveOutSetPitch         [WINMM.@]
2733  */
2734 UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
2735 {
2736     TRACE("(%p, %08x)\n", hWaveOut, dw);
2737
2738     return MMSYSERR_NOTSUPPORTED;
2739 }
2740
2741 /**************************************************************************
2742  *                              waveOutGetPlaybackRate  [WINMM.@]
2743  */
2744 UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
2745 {
2746     TRACE("(%p, %p)\n", hWaveOut, lpdw);
2747
2748     return MMSYSERR_NOTSUPPORTED;
2749 }
2750
2751 /**************************************************************************
2752  *                              waveOutSetPlaybackRate  [WINMM.@]
2753  */
2754 UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
2755 {
2756     TRACE("(%p, %08x)\n", hWaveOut, dw);
2757
2758     return MMSYSERR_NOTSUPPORTED;
2759 }
2760
2761 /**************************************************************************
2762  *                              waveOutGetVolume        [WINMM.@]
2763  */
2764 UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, DWORD *out)
2765 {
2766     WINMM_Device *device;
2767     UINT32 channels;
2768     float *vols;
2769     HRESULT hr;
2770
2771     TRACE("(%p, %p)\n", hWaveOut, out);
2772
2773     if(!out)
2774         return MMSYSERR_INVALPARAM;
2775
2776     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2777
2778     if(!WINMM_ValidateAndLock(device))
2779         return MMSYSERR_INVALHANDLE;
2780
2781     hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
2782     if(FAILED(hr)){
2783         LeaveCriticalSection(&device->lock);
2784         WARN("GetChannelCount failed: %08x\n", hr);
2785         return MMSYSERR_ERROR;
2786     }
2787
2788     vols = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels);
2789     if(!vols){
2790         LeaveCriticalSection(&device->lock);
2791         return MMSYSERR_NOMEM;
2792     }
2793
2794     hr = IAudioStreamVolume_GetAllVolumes(device->volume, channels, vols);
2795     if(FAILED(hr)){
2796         LeaveCriticalSection(&device->lock);
2797         HeapFree(GetProcessHeap(), 0, vols);
2798         WARN("GetAllVolumes failed: %08x\n", hr);
2799         return MMSYSERR_ERROR;
2800     }
2801
2802     LeaveCriticalSection(&device->lock);
2803
2804     *out = ((UINT16)(vols[0] * (DWORD)0xFFFF));
2805     if(channels > 1)
2806         *out |= ((UINT16)(vols[1] * (DWORD)0xFFFF)) << 16;
2807
2808     HeapFree(GetProcessHeap(), 0, vols);
2809
2810     return MMSYSERR_NOERROR;
2811 }
2812
2813 /**************************************************************************
2814  *                              waveOutSetVolume        [WINMM.@]
2815  */
2816 UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
2817 {
2818     WINMM_Device *device;
2819     UINT32 channels;
2820     float *vols;
2821     HRESULT hr;
2822
2823     TRACE("(%p, %08x)\n", hWaveOut, in);
2824
2825     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2826
2827     if(!WINMM_ValidateAndLock(device))
2828         return MMSYSERR_INVALHANDLE;
2829
2830     hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
2831     if(FAILED(hr)){
2832         LeaveCriticalSection(&device->lock);
2833         WARN("GetChannelCount failed: %08x\n", hr);
2834         return MMSYSERR_ERROR;
2835     }
2836
2837     vols = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels);
2838     if(!vols){
2839         LeaveCriticalSection(&device->lock);
2840         return MMSYSERR_NOMEM;
2841     }
2842
2843     hr = IAudioStreamVolume_GetAllVolumes(device->volume, channels, vols);
2844     if(FAILED(hr)){
2845         LeaveCriticalSection(&device->lock);
2846         HeapFree(GetProcessHeap(), 0, vols);
2847         WARN("GetAllVolumes failed: %08x\n", hr);
2848         return MMSYSERR_ERROR;
2849     }
2850
2851     vols[0] = (float)((DWORD)(in & 0xFFFF) / (float)0xFFFF);
2852     if(channels > 1)
2853         vols[1] = (float)((DWORD)(in >> 16) / (float)0xFFFF);
2854
2855     hr = IAudioStreamVolume_SetAllVolumes(device->volume, channels, vols);
2856     if(FAILED(hr)){
2857         LeaveCriticalSection(&device->lock);
2858         HeapFree(GetProcessHeap(), 0, vols);
2859         WARN("SetAllVolumes failed: %08x\n", hr);
2860         return MMSYSERR_ERROR;
2861     }
2862
2863     LeaveCriticalSection(&device->lock);
2864
2865     HeapFree(GetProcessHeap(), 0, vols);
2866
2867     return MMSYSERR_NOERROR;
2868 }
2869
2870 /**************************************************************************
2871  *                              waveOutGetID            [WINMM.@]
2872  */
2873 UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
2874 {
2875     WINMM_Device *device;
2876     UINT dev, junk;
2877     BOOL is_out;
2878
2879     TRACE("(%p, %p)\n", hWaveOut, lpuDeviceID);
2880
2881     if(!lpuDeviceID)
2882         return MMSYSERR_INVALPARAM;
2883
2884     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2885     if(!WINMM_ValidateAndLock(device))
2886         return MMSYSERR_INVALHANDLE;
2887
2888     LeaveCriticalSection(&device->lock);
2889
2890     WINMM_DecomposeHWAVE((HWAVE)hWaveOut, lpuDeviceID, &is_out, &dev, &junk);
2891
2892     return MMSYSERR_NOERROR;
2893 }
2894
2895 static UINT WINMM_QueryInstanceIDSize(UINT device, DWORD_PTR *len, BOOL is_out)
2896 {
2897     UINT count;
2898     WINMM_MMDevice *devices;
2899
2900     TRACE("(%u, %p, %d)\n", device, len, is_out);
2901
2902     if(is_out){
2903         count = g_outmmdevices_count;
2904         devices = g_out_mmdevices;
2905     }else{
2906         count = g_inmmdevices_count;
2907         devices = g_in_mmdevices;
2908     }
2909
2910     if(device >= count)
2911         return MMSYSERR_INVALHANDLE;
2912
2913     *len = (lstrlenW(devices[device].dev_id) + 1) * sizeof(WCHAR);
2914
2915     return MMSYSERR_NOERROR;
2916 }
2917
2918 static UINT WINMM_QueryInstanceID(UINT device, WCHAR *str, DWORD_PTR len,
2919         BOOL is_out)
2920 {
2921     UINT count, id_len;
2922     WINMM_MMDevice *devices;
2923
2924     TRACE("(%u, %p, %d)\n", device, str, is_out);
2925
2926     if(is_out){
2927         count = g_outmmdevices_count;
2928         devices = g_out_mmdevices;
2929     }else{
2930         count = g_inmmdevices_count;
2931         devices = g_in_mmdevices;
2932     }
2933
2934     if(device >= count)
2935         return MMSYSERR_INVALHANDLE;
2936
2937     id_len = (lstrlenW(devices[device].dev_id) + 1) * sizeof(WCHAR);
2938     if(len < id_len)
2939         return MMSYSERR_ERROR;
2940
2941     memcpy(str, devices[device].dev_id, id_len);
2942
2943     return MMSYSERR_NOERROR;
2944 }
2945
2946 static UINT get_device_interface(UINT msg, BOOL is_out, UINT index, WCHAR *out, ULONG *out_len)
2947 {
2948     WINMM_QueryInterfaceInfo info;
2949
2950     if(!WINMM_StartDevicesThread())
2951         return MMSYSERR_ERROR;
2952
2953     info.is_out = is_out;
2954     info.index = index;
2955     info.str = out;
2956     info.len_bytes = out_len;
2957
2958     return SendMessageW(g_devices_hwnd, msg, (DWORD_PTR)&info, 0);
2959 }
2960
2961 /**************************************************************************
2962  *                              waveOutMessage          [WINMM.@]
2963  */
2964 UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
2965                            DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2966 {
2967     TRACE("(%p, %u, %lx, %lx)\n", hWaveOut, uMessage, dwParam1, dwParam2);
2968
2969     switch(uMessage){
2970     case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
2971         return WINMM_QueryInstanceIDSize(HandleToULong(hWaveOut),
2972                 (DWORD_PTR*)dwParam1, TRUE);
2973     case DRV_QUERYFUNCTIONINSTANCEID:
2974         return WINMM_QueryInstanceID(HandleToULong(hWaveOut), (WCHAR*)dwParam1, dwParam2, TRUE);
2975     case DRV_QUERYDEVICEINTERFACESIZE:
2976         return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE, TRUE, HandleToULong(hWaveOut),
2977                 NULL, (ULONG*)dwParam1);
2978     case DRV_QUERYDEVICEINTERFACE:
2979         {
2980             ULONG size = dwParam2;
2981             return get_device_interface(DRV_QUERYDEVICEINTERFACE, TRUE, HandleToULong(hWaveOut),
2982                     (WCHAR*)dwParam1, &size);
2983         }
2984     case DRV_QUERYMAPPABLE:
2985         return MMSYSERR_NOERROR;
2986     case DRVM_MAPPER_PREFERRED_GET:
2987         if(dwParam1) {
2988             if(g_outmmdevices_count > 0)
2989                 /* Device 0 is always the default device */
2990                 *(DWORD *)dwParam1 = 0;
2991             else
2992                 *(DWORD *)dwParam1 = -1;
2993         }
2994
2995         if(dwParam2)
2996             /* Status flags */
2997             *(DWORD *)dwParam2 = 0;
2998
2999         return MMSYSERR_NOERROR;
3000     }
3001
3002     TRACE("Message not supported: %u\n", uMessage);
3003
3004     return MMSYSERR_NOTSUPPORTED;
3005 }
3006
3007 /**************************************************************************
3008  *                              waveInGetNumDevs                [WINMM.@]
3009  */
3010 UINT WINAPI waveInGetNumDevs(void)
3011 {
3012     HRESULT hr = WINMM_InitMMDevices();
3013     if(FAILED(hr))
3014         return 0;
3015
3016     TRACE("count: %u\n", g_inmmdevices_count);
3017
3018     return g_inmmdevices_count;
3019 }
3020
3021 /**************************************************************************
3022  *                              waveInGetDevCapsW               [WINMM.@]
3023  */
3024 UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
3025 {
3026     WAVEINCAPSW mapper_caps, *caps;
3027     HRESULT hr;
3028
3029     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3030
3031     hr = WINMM_InitMMDevices();
3032     if(FAILED(hr))
3033         return MMSYSERR_ERROR;
3034
3035     if(!lpCaps)
3036         return MMSYSERR_INVALPARAM;
3037
3038     if(WINMM_IsMapper(uDeviceID)){
3039         /* FIXME: Should be localized */
3040         static const WCHAR mapper_pnameW[] = {'W','i','n','e',' ','S','o','u',
3041             'n','d',' ','M','a','p','p','e','r',0};
3042
3043         mapper_caps.wMid = 0xFF;
3044         mapper_caps.wPid = 0xFF;
3045         mapper_caps.vDriverVersion = 0x00010001;
3046         mapper_caps.dwFormats = 0xFFFFFFFF;
3047         mapper_caps.wReserved1 = 0;
3048         mapper_caps.wChannels = 2;
3049         lstrcpyW(mapper_caps.szPname, mapper_pnameW);
3050
3051         caps = &mapper_caps;
3052     }else{
3053         if(uDeviceID >= g_inmmdevices_count)
3054             return MMSYSERR_BADDEVICEID;
3055
3056         caps = &g_in_mmdevices[uDeviceID].in_caps;
3057     }
3058
3059     memcpy(lpCaps, caps, min(uSize, sizeof(*lpCaps)));
3060
3061     return MMSYSERR_NOERROR;
3062 }
3063
3064 /**************************************************************************
3065  *                              waveInGetDevCapsA               [WINMM.@]
3066  */
3067 UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
3068 {
3069     UINT ret;
3070     WAVEINCAPSW wicW;
3071
3072     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3073
3074     if(!lpCaps)
3075         return MMSYSERR_INVALPARAM;
3076
3077     ret = waveInGetDevCapsW(uDeviceID, &wicW, sizeof(wicW));
3078
3079     if (ret == MMSYSERR_NOERROR) {
3080         WAVEINCAPSA wicA;
3081         wicA.wMid           = wicW.wMid;
3082         wicA.wPid           = wicW.wPid;
3083         wicA.vDriverVersion = wicW.vDriverVersion;
3084         WideCharToMultiByte( CP_ACP, 0, wicW.szPname, -1, wicA.szPname,
3085                              sizeof(wicA.szPname), NULL, NULL );
3086         wicA.dwFormats      = wicW.dwFormats;
3087         wicA.wChannels      = wicW.wChannels;
3088         memcpy(lpCaps, &wicA, min(uSize, sizeof(wicA)));
3089     }
3090     return ret;
3091 }
3092
3093 /**************************************************************************
3094  *                              waveInOpen                      [WINMM.@]
3095  */
3096 MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
3097                            LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
3098                            DWORD_PTR dwInstance, DWORD dwFlags)
3099 {
3100     LRESULT res;
3101     WINMM_OpenInfo info;
3102     WINMM_CBInfo cb_info;
3103
3104     TRACE("(%p, %x, %p, %lx, %lx, %08x)\n", lphWaveIn, uDeviceID, lpFormat,
3105             dwCallback, dwInstance, dwFlags);
3106
3107     if(!WINMM_StartDevicesThread())
3108         return MMSYSERR_ERROR;
3109
3110     if(!lphWaveIn && !(dwFlags & WAVE_FORMAT_QUERY))
3111         return MMSYSERR_INVALPARAM;
3112
3113     res = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
3114     if(res != MMSYSERR_NOERROR)
3115         return res;
3116
3117     info.format = (WAVEFORMATEX*)lpFormat;
3118     info.callback = dwCallback;
3119     info.cb_user = dwInstance;
3120     info.req_device = uDeviceID;
3121     info.flags = dwFlags;
3122
3123     res = SendMessageW(g_devices_hwnd, WIDM_OPEN, (DWORD_PTR)&info, 0);
3124     if(res != MMSYSERR_NOERROR)
3125         return res;
3126
3127     if(lphWaveIn)
3128         *lphWaveIn = (HWAVEIN)info.handle;
3129
3130     cb_info.flags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
3131     cb_info.callback = dwCallback;
3132     cb_info.user = dwInstance;
3133     cb_info.hwave = info.handle;
3134
3135     WINMM_NotifyClient(&cb_info, WIM_OPEN, 0, 0);
3136
3137     return res;
3138 }
3139
3140 /**************************************************************************
3141  *                              waveInClose                     [WINMM.@]
3142  */
3143 UINT WINAPI waveInClose(HWAVEIN hWaveIn)
3144 {
3145     WINMM_Device *device;
3146     WINMM_CBInfo cb_info;
3147     UINT res;
3148
3149     TRACE("(%p)\n", hWaveIn);
3150
3151     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3152
3153     if(!WINMM_ValidateAndLock(device))
3154         return MMSYSERR_INVALHANDLE;
3155
3156     cb_info = device->cb_info;
3157
3158     LeaveCriticalSection(&device->lock);
3159
3160     res = SendMessageW(g_devices_hwnd, WIDM_CLOSE, (WPARAM)hWaveIn, 0);
3161
3162     if(res == MMSYSERR_NOERROR)
3163         WINMM_NotifyClient(&cb_info, WIM_CLOSE, 0, 0);
3164
3165     return res;
3166 }
3167
3168 /**************************************************************************
3169  *                              waveInPrepareHeader             [WINMM.@]
3170  */
3171 UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
3172                                 UINT uSize)
3173 {
3174     TRACE("(%p, %p, %u)\n", hWaveIn, lpWaveInHdr, uSize);
3175
3176     if(!lpWaveInHdr || uSize < sizeof(WAVEHDR))
3177         return MMSYSERR_INVALPARAM;
3178
3179     if(lpWaveInHdr->dwFlags & WHDR_INQUEUE)
3180         return WAVERR_STILLPLAYING;
3181
3182     return WINMM_PrepareHeader((HWAVE)hWaveIn, lpWaveInHdr);
3183 }
3184
3185 /**************************************************************************
3186  *                              waveInUnprepareHeader   [WINMM.@]
3187  */
3188 UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
3189                                   UINT uSize)
3190 {
3191     TRACE("(%p, %p, %u)\n", hWaveIn, lpWaveInHdr, uSize);
3192
3193     if(!lpWaveInHdr || uSize < sizeof(WAVEHDR))
3194         return MMSYSERR_INVALPARAM;
3195
3196     if(!(lpWaveInHdr->dwFlags & WHDR_PREPARED))
3197         return MMSYSERR_NOERROR;
3198
3199     if(lpWaveInHdr->dwFlags & WHDR_INQUEUE)
3200         return WAVERR_STILLPLAYING;
3201
3202     return WINMM_UnprepareHeader((HWAVE)hWaveIn, lpWaveInHdr);
3203 }
3204
3205 /**************************************************************************
3206  *                              waveInAddBuffer         [WINMM.@]
3207  */
3208 UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn, WAVEHDR *header, UINT uSize)
3209 {
3210     WINMM_Device *device;
3211
3212     TRACE("(%p, %p, %u)\n", hWaveIn, header, uSize);
3213
3214     if(!header || uSize < sizeof(WAVEHDR))
3215         return MMSYSERR_INVALPARAM;
3216
3217     if(!(header->dwFlags & WHDR_PREPARED))
3218         return WAVERR_UNPREPARED;
3219
3220     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3221
3222     if(!WINMM_ValidateAndLock(device))
3223         return MMSYSERR_INVALHANDLE;
3224
3225     if(!device->first)
3226         device->first = device->last = header;
3227     else{
3228         device->last->lpNext = header;
3229         device->last = header;
3230     }
3231
3232     header->dwBytesRecorded = 0;
3233     header->lpNext = NULL;
3234     header->dwFlags &= ~WHDR_DONE;
3235     header->dwFlags |= WHDR_INQUEUE;
3236
3237     LeaveCriticalSection(&device->lock);
3238
3239     return MMSYSERR_NOERROR;
3240 }
3241
3242 /**************************************************************************
3243  *                              waveInReset             [WINMM.@]
3244  */
3245 UINT WINAPI waveInReset(HWAVEIN hWaveIn)
3246 {
3247     TRACE("(%p)\n", hWaveIn);
3248
3249     return WINMM_Reset((HWAVE)hWaveIn);
3250 }
3251
3252 /**************************************************************************
3253  *                              waveInStart             [WINMM.@]
3254  */
3255 UINT WINAPI waveInStart(HWAVEIN hWaveIn)
3256 {
3257     WINMM_Device *device;
3258     HRESULT hr;
3259
3260     TRACE("(%p)\n", hWaveIn);
3261
3262     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3263
3264     if(!WINMM_ValidateAndLock(device))
3265         return MMSYSERR_INVALHANDLE;
3266
3267     hr = WINMM_BeginPlaying(device);
3268     if(FAILED(hr)){
3269         LeaveCriticalSection(&device->lock);
3270         return MMSYSERR_ERROR;
3271     }
3272
3273     LeaveCriticalSection(&device->lock);
3274
3275     return MMSYSERR_NOERROR;
3276 }
3277
3278 /**************************************************************************
3279  *                              waveInStop              [WINMM.@]
3280  */
3281 UINT WINAPI waveInStop(HWAVEIN hWaveIn)
3282 {
3283     WINMM_CBInfo cb_info;
3284     WINMM_Device *device;
3285     WAVEHDR *buf;
3286     HRESULT hr;
3287
3288     TRACE("(%p)\n", hWaveIn);
3289
3290     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3291
3292     if(!WINMM_ValidateAndLock(device))
3293         return MMSYSERR_INVALHANDLE;
3294
3295     hr = WINMM_Pause((HWAVE)hWaveIn);
3296     if(FAILED(hr)){
3297         LeaveCriticalSection(&device->lock);
3298         return MMSYSERR_ERROR;
3299     }
3300     device->stopped = TRUE;
3301
3302     buf = device->first;
3303     if(buf && buf->dwBytesRecorded > 0){
3304         device->first = buf->lpNext;
3305     }else
3306         buf = NULL;
3307
3308     cb_info = device->cb_info;
3309
3310     LeaveCriticalSection(&device->lock);
3311
3312     if(buf){
3313         buf->dwFlags &= ~WHDR_INQUEUE;
3314         buf->dwFlags |= WHDR_DONE;
3315         WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)buf, 0);
3316     }
3317
3318     return MMSYSERR_NOERROR;
3319 }
3320
3321 /**************************************************************************
3322  *                              waveInGetPosition       [WINMM.@]
3323  */
3324 UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
3325                               UINT uSize)
3326 {
3327     TRACE("(%p, %p, %u)\n", hWaveIn, lpTime, uSize);
3328
3329     if(!uSize || !lpTime || uSize != sizeof(MMTIME))
3330         return MMSYSERR_INVALPARAM;
3331
3332     return WINMM_GetPosition((HWAVE)hWaveIn, lpTime);
3333 }
3334
3335 /**************************************************************************
3336  *                              waveInGetID                     [WINMM.@]
3337  */
3338 UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
3339 {
3340     UINT dev, junk;
3341     BOOL is_out;
3342     WINMM_Device *device;
3343
3344     TRACE("(%p, %p)\n", hWaveIn, lpuDeviceID);
3345
3346     if(!lpuDeviceID)
3347         return MMSYSERR_INVALPARAM;
3348
3349     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3350     if(!WINMM_ValidateAndLock(device))
3351         return MMSYSERR_INVALHANDLE;
3352
3353     LeaveCriticalSection(&device->lock);
3354
3355     WINMM_DecomposeHWAVE((HWAVE)hWaveIn, lpuDeviceID, &is_out, &dev, &junk);
3356
3357     return MMSYSERR_NOERROR;
3358 }
3359
3360 /**************************************************************************
3361  *                              waveInMessage           [WINMM.@]
3362  */
3363 UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
3364                           DWORD_PTR dwParam1, DWORD_PTR dwParam2)
3365 {
3366     TRACE("(%p, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
3367
3368     switch(uMessage){
3369     case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
3370         return WINMM_QueryInstanceIDSize(HandleToULong(hWaveIn),
3371                 (DWORD_PTR*)dwParam1, FALSE);
3372     case DRV_QUERYFUNCTIONINSTANCEID:
3373         return WINMM_QueryInstanceID(HandleToULong(hWaveIn), (WCHAR*)dwParam1, dwParam2, FALSE);
3374     case DRV_QUERYDEVICEINTERFACESIZE:
3375         return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE, FALSE, HandleToULong(hWaveIn),
3376                 NULL, (ULONG*)dwParam1);
3377     case DRV_QUERYDEVICEINTERFACE:
3378         {
3379             ULONG size = dwParam2;
3380             return get_device_interface(DRV_QUERYDEVICEINTERFACE, FALSE, HandleToULong(hWaveIn),
3381                     (WCHAR*)dwParam1, &size);
3382         }
3383     case DRV_QUERYMAPPABLE:
3384         return MMSYSERR_NOERROR;
3385     case DRVM_MAPPER_PREFERRED_GET:
3386         if(dwParam1) {
3387             if(g_inmmdevices_count > 0)
3388                 /* Device 0 is always the default device */
3389                 *(DWORD *)dwParam1 = 0;
3390             else
3391                 *(DWORD *)dwParam1 = -1;
3392         }
3393
3394         if(dwParam2)
3395             /* Status flags */
3396             *(DWORD *)dwParam2 = 0;
3397
3398         return MMSYSERR_NOERROR;
3399     }
3400
3401     TRACE("Message not supported: %u\n", uMessage);
3402
3403     return MMSYSERR_NOTSUPPORTED;
3404 }
3405
3406 UINT WINAPI mixerGetNumDevs(void)
3407 {
3408     HRESULT hr;
3409
3410     TRACE("\n");
3411
3412     hr = WINMM_InitMMDevices();
3413     if(FAILED(hr))
3414         return 0;
3415
3416     return g_outmmdevices_count + g_inmmdevices_count;
3417 }
3418
3419 /**************************************************************************
3420  *                              mixerGetDevCapsA                [WINMM.@]
3421  */
3422 UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
3423 {
3424     MIXERCAPSW micW;
3425     UINT       ret;
3426
3427     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3428
3429     if(!lpCaps)
3430         return MMSYSERR_INVALPARAM;
3431
3432     ret = mixerGetDevCapsW(uDeviceID, &micW, sizeof(micW));
3433
3434     if (ret == MMSYSERR_NOERROR) {
3435         MIXERCAPSA micA;
3436         micA.wMid           = micW.wMid;
3437         micA.wPid           = micW.wPid;
3438         micA.vDriverVersion = micW.vDriverVersion;
3439         WideCharToMultiByte( CP_ACP, 0, micW.szPname, -1, micA.szPname,
3440                              sizeof(micA.szPname), NULL, NULL );
3441         micA.fdwSupport     = micW.fdwSupport;
3442         micA.cDestinations  = micW.cDestinations;
3443         memcpy(lpCaps, &micA, min(uSize, sizeof(micA)));
3444     }
3445     return ret;
3446 }
3447
3448 /**************************************************************************
3449  *                              mixerGetDevCapsW                [WINMM.@]
3450  */
3451 UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
3452 {
3453     WINMM_MMDevice *mmdevice;
3454     MIXERCAPSW caps;
3455     HRESULT hr;
3456
3457     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3458
3459     hr = WINMM_InitMMDevices();
3460     if(FAILED(hr))
3461         return MMSYSERR_ERROR;
3462
3463     if(!lpCaps)
3464         return MMSYSERR_INVALPARAM;
3465
3466     if(!uSize)
3467         return MMSYSERR_NOERROR;
3468
3469     if(uDeviceID >= g_outmmdevices_count + g_inmmdevices_count)
3470         return MMSYSERR_BADDEVICEID;
3471
3472     if(uDeviceID < g_outmmdevices_count){
3473         mmdevice = &g_out_mmdevices[uDeviceID];
3474         memcpy(caps.szPname, mmdevice->out_caps.szPname, sizeof(caps.szPname));
3475     }else{
3476         mmdevice = &g_in_mmdevices[uDeviceID - g_outmmdevices_count];
3477         memcpy(caps.szPname, mmdevice->in_caps.szPname, sizeof(caps.szPname));
3478     }
3479
3480     caps.wMid = 0xFF;
3481     caps.wPid = 0xFF;
3482     caps.vDriverVersion = 0x00010001;
3483     caps.fdwSupport = 0;
3484     caps.cDestinations = 1;
3485
3486     memcpy(lpCaps, &caps, uSize);
3487
3488     return MMSYSERR_NOERROR;
3489 }
3490
3491 /**************************************************************************
3492  *                              mixerOpen                       [WINMM.@]
3493  */
3494 UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
3495                       DWORD_PTR dwInstance, DWORD fdwOpen)
3496 {
3497     WINMM_MMDevice *mmdevice;
3498     MMRESULT mr;
3499     HRESULT hr;
3500
3501     TRACE("(%p, %d, %lx, %lx, %x)\n", lphMix, uDeviceID, dwCallback,
3502             dwInstance, fdwOpen);
3503
3504     hr = WINMM_InitMMDevices();
3505     if(FAILED(hr))
3506         return MMSYSERR_ERROR;
3507
3508     if(!lphMix)
3509         return MMSYSERR_INVALPARAM;
3510
3511     mr = WINMM_CheckCallback(dwCallback, fdwOpen, TRUE);
3512     if(mr != MMSYSERR_NOERROR)
3513         return mr;
3514
3515     if(uDeviceID >= g_outmmdevices_count + g_inmmdevices_count)
3516         return MMSYSERR_BADDEVICEID;
3517
3518     if(uDeviceID < g_outmmdevices_count){
3519         mmdevice = &g_out_mmdevices[uDeviceID];
3520         *lphMix = (HMIXER)WINMM_MakeHWAVE(uDeviceID, TRUE,
3521                 mmdevice->mixer_count);
3522     }else{
3523         mmdevice = &g_in_mmdevices[uDeviceID - g_outmmdevices_count];
3524         *lphMix = (HMIXER)WINMM_MakeHWAVE(uDeviceID - g_outmmdevices_count,
3525                 FALSE, mmdevice->mixer_count);
3526     }
3527
3528     ++mmdevice->mixer_count;
3529
3530     return MMSYSERR_NOERROR;
3531 }
3532
3533 /**************************************************************************
3534  *                              mixerClose                      [WINMM.@]
3535  */
3536 UINT WINAPI mixerClose(HMIXER hMix)
3537 {
3538     TRACE("(%p)\n", hMix);
3539
3540     return MMSYSERR_NOERROR;
3541 }
3542
3543 /**************************************************************************
3544  *                              mixerGetID                      [WINMM.@]
3545  */
3546 UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
3547 {
3548     WINMM_MMDevice *mmdevice;
3549     HRESULT hr;
3550
3551     TRACE("(%p, %p, %x)\n", hmix, lpid, fdwID);
3552
3553     hr = WINMM_InitMMDevices();
3554     if(FAILED(hr))
3555         return MMSYSERR_ERROR;
3556
3557     if(!lpid)
3558         return MMSYSERR_INVALPARAM;
3559
3560     mmdevice = WINMM_GetMixerMMDevice(hmix, fdwID, lpid);
3561     if(!mmdevice)
3562         return MMSYSERR_INVALHANDLE;
3563
3564     if(mmdevice->in_caps.szPname[0] != '\0')
3565         *lpid += g_outmmdevices_count;
3566
3567     return MMSYSERR_NOERROR;
3568 }
3569
3570 /**************************************************************************
3571  *                              mixerGetControlDetailsW         [WINMM.@]
3572  */
3573 UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW,
3574                                     DWORD fdwDetails)
3575 {
3576     WINMM_ControlDetails details;
3577     HRESULT hr;
3578
3579     TRACE("(%p, %p, %x)\n", hmix, lpmcdW, fdwDetails);
3580
3581     hr = WINMM_InitMMDevices();
3582     if(FAILED(hr))
3583         return MMSYSERR_ERROR;
3584
3585     if(!lpmcdW)
3586         return MMSYSERR_INVALPARAM;
3587
3588     TRACE("dwControlID: %u\n", lpmcdW->dwControlID);
3589
3590     details.hmix = hmix;
3591     details.details = lpmcdW;
3592     details.flags = fdwDetails;
3593
3594     return SendMessageW(g_devices_hwnd, MXDM_GETCONTROLDETAILS,
3595             (DWORD_PTR)&details, 0);
3596 }
3597
3598 /**************************************************************************
3599  *                              mixerGetControlDetailsA [WINMM.@]
3600  */
3601 UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
3602                                     DWORD fdwDetails)
3603 {
3604     UINT ret = MMSYSERR_NOTSUPPORTED;
3605
3606     TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails);
3607
3608     if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
3609         return MMSYSERR_INVALPARAM;
3610
3611     switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
3612     case MIXER_GETCONTROLDETAILSF_VALUE:
3613         /* can safely use A structure as it is, no string inside */
3614         ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
3615         break;
3616     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
3617         {
3618             MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = lpmcdA->paDetails;
3619             MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW;
3620             int size = max(1, lpmcdA->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
3621             unsigned int i;
3622
3623             if (lpmcdA->u.cMultipleItems != 0) {
3624                 size *= lpmcdA->u.cMultipleItems;
3625             }
3626             pDetailsW = HeapAlloc(GetProcessHeap(), 0, size);
3627             lpmcdA->paDetails = pDetailsW;
3628             lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
3629             /* set up lpmcd->paDetails */
3630             ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
3631             /* copy from lpmcd->paDetails back to paDetailsW; */
3632             if (ret == MMSYSERR_NOERROR) {
3633                 for (i = 0; i < lpmcdA->u.cMultipleItems * lpmcdA->cChannels; i++) {
3634                     pDetailsA->dwParam1 = pDetailsW->dwParam1;
3635                     pDetailsA->dwParam2 = pDetailsW->dwParam2;
3636                     WideCharToMultiByte( CP_ACP, 0, pDetailsW->szName, -1,
3637                                          pDetailsA->szName,
3638                                          sizeof(pDetailsA->szName), NULL, NULL );
3639                     pDetailsA++;
3640                     pDetailsW++;
3641                 }
3642                 pDetailsA -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
3643                 pDetailsW -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
3644             }
3645             HeapFree(GetProcessHeap(), 0, pDetailsW);
3646             lpmcdA->paDetails = pDetailsA;
3647             lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
3648         }
3649         break;
3650     default:
3651         WARN("Unsupported fdwDetails=0x%08x\n", fdwDetails);
3652     }
3653
3654     return ret;
3655 }
3656
3657 /**************************************************************************
3658  *                              mixerGetLineControlsA   [WINMM.@]
3659  */
3660 UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
3661                                   DWORD fdwControls)
3662 {
3663     MIXERLINECONTROLSW  mlcW;
3664     DWORD               ret;
3665     unsigned int        i;
3666
3667     TRACE("(%p, %p, %x)\n", hmix, lpmlcA, fdwControls);
3668
3669     if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
3670         lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
3671         return MMSYSERR_INVALPARAM;
3672
3673     mlcW.cbStruct = sizeof(mlcW);
3674     mlcW.dwLineID = lpmlcA->dwLineID;
3675     mlcW.u.dwControlID = lpmlcA->u.dwControlID;
3676     mlcW.u.dwControlType = lpmlcA->u.dwControlType;
3677
3678     /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
3679        the control count is assumed to be 1 - This is relied upon by a game,
3680        "Dynomite Deluze"                                                    */
3681     if (MIXER_GETLINECONTROLSF_ONEBYTYPE == (fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)) {
3682         mlcW.cControls = 1;
3683     } else {
3684         mlcW.cControls = lpmlcA->cControls;
3685     }
3686     mlcW.cbmxctrl = sizeof(MIXERCONTROLW);
3687     mlcW.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
3688                               mlcW.cControls * mlcW.cbmxctrl);
3689
3690     ret = mixerGetLineControlsW(hmix, &mlcW, fdwControls);
3691
3692     if (ret == MMSYSERR_NOERROR) {
3693         lpmlcA->dwLineID = mlcW.dwLineID;
3694         lpmlcA->u.dwControlID = mlcW.u.dwControlID;
3695         lpmlcA->u.dwControlType = mlcW.u.dwControlType;
3696
3697         for (i = 0; i < mlcW.cControls; i++) {
3698             lpmlcA->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLA);
3699             lpmlcA->pamxctrl[i].dwControlID = mlcW.pamxctrl[i].dwControlID;
3700             lpmlcA->pamxctrl[i].dwControlType = mlcW.pamxctrl[i].dwControlType;
3701             lpmlcA->pamxctrl[i].fdwControl = mlcW.pamxctrl[i].fdwControl;
3702             lpmlcA->pamxctrl[i].cMultipleItems = mlcW.pamxctrl[i].cMultipleItems;
3703             WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szShortName, -1,
3704                                  lpmlcA->pamxctrl[i].szShortName,
3705                                  sizeof(lpmlcA->pamxctrl[i].szShortName), NULL, NULL );
3706             WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szName, -1,
3707                                  lpmlcA->pamxctrl[i].szName,
3708                                  sizeof(lpmlcA->pamxctrl[i].szName), NULL, NULL );
3709             /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
3710              * sizeof(mlcW.pamxctrl[i].Bounds) */
3711             memcpy(&lpmlcA->pamxctrl[i].Bounds, &mlcW.pamxctrl[i].Bounds,
3712                    sizeof(mlcW.pamxctrl[i].Bounds));
3713             /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
3714              * sizeof(mlcW.pamxctrl[i].Metrics) */
3715             memcpy(&lpmlcA->pamxctrl[i].Metrics, &mlcW.pamxctrl[i].Metrics,
3716                    sizeof(mlcW.pamxctrl[i].Metrics));
3717         }
3718     }
3719
3720     HeapFree(GetProcessHeap(), 0, mlcW.pamxctrl);
3721
3722     return ret;
3723 }
3724
3725 static UINT WINMM_GetVolumeLineControl(WINMM_MMDevice *mmdevice, DWORD line,
3726         MIXERCONTROLW *ctl, DWORD flags)
3727 {
3728     ctl->dwControlID = (line == 0xFFFF0000) ? 0 : 2;
3729     ctl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
3730     ctl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
3731     ctl->cMultipleItems = 0;
3732     lstrcpyW(ctl->szShortName, volumeW);
3733     lstrcpyW(ctl->szName, volumeW);
3734     ctl->Bounds.s1.dwMinimum = 0;
3735     ctl->Bounds.s1.dwMaximum = 0xFFFF;
3736     ctl->Metrics.cSteps = 192;
3737
3738     return MMSYSERR_NOERROR;
3739 }
3740
3741 static UINT WINMM_GetMuteLineControl(WINMM_MMDevice *mmdevice, DWORD line,
3742         MIXERCONTROLW *ctl, DWORD flags)
3743 {
3744     ctl->dwControlID = (line == 0xFFFF0000) ? 1 : 3;
3745     ctl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
3746     ctl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
3747     ctl->cMultipleItems = 0;
3748     lstrcpyW(ctl->szShortName, muteW);
3749     lstrcpyW(ctl->szName, muteW);
3750     ctl->Bounds.s1.dwMinimum = 0;
3751     ctl->Bounds.s1.dwMaximum = 1;
3752     ctl->Metrics.cSteps = 0;
3753
3754     return MMSYSERR_NOERROR;
3755 }
3756
3757 /**************************************************************************
3758  *                              mixerGetLineControlsW           [WINMM.@]
3759  */
3760 UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
3761                                   DWORD fdwControls)
3762 {
3763     WINMM_MMDevice *mmdevice;
3764     HRESULT hr;
3765
3766     TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls);
3767
3768     hr = WINMM_InitMMDevices();
3769     if(FAILED(hr))
3770         return MMSYSERR_ERROR;
3771
3772     if(fdwControls & ~(MIXER_GETLINECONTROLSF_ALL |
3773                 MIXER_GETLINECONTROLSF_ONEBYID |
3774                 MIXER_GETLINECONTROLSF_ONEBYTYPE |
3775                 MIXER_OBJECTF_HMIXER |
3776                 MIXER_OBJECTF_MIXER)){
3777         WARN("Unknown GetLineControls flag: %x\n", fdwControls);
3778         return MMSYSERR_INVALFLAG;
3779     }
3780
3781     if(!lpmlcW || lpmlcW->cbStruct < sizeof(*lpmlcW) || !lpmlcW->pamxctrl)
3782         return MMSYSERR_INVALPARAM;
3783
3784     TRACE("dwLineID: %u\n", lpmlcW->dwLineID);
3785     TRACE("dwControl: %x\n", lpmlcW->u.dwControlID);
3786     TRACE("cControls: %u\n", lpmlcW->cControls);
3787
3788     mmdevice = WINMM_GetMixerMMDevice(hmix, fdwControls, NULL);
3789     if(!mmdevice)
3790         return MMSYSERR_INVALHANDLE;
3791
3792     switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK){
3793     case MIXER_GETLINECONTROLSF_ALL:
3794         if(lpmlcW->cControls != 2)
3795             return MMSYSERR_INVALPARAM;
3796         if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
3797             return MMSYSERR_INVALPARAM;
3798         if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
3799             return MIXERR_INVALLINE;
3800         WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
3801                 &lpmlcW->pamxctrl[0], fdwControls);
3802         WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
3803                 &lpmlcW->pamxctrl[1], fdwControls);
3804         return MMSYSERR_NOERROR;
3805     case MIXER_GETLINECONTROLSF_ONEBYID:
3806         if(lpmlcW->cControls != 1)
3807             return MMSYSERR_INVALPARAM;
3808         if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
3809             return MMSYSERR_INVALPARAM;
3810         if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
3811             return MIXERR_INVALLINE;
3812         if(lpmlcW->u.dwControlID == 0)
3813             return WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
3814                     lpmlcW->pamxctrl, fdwControls);
3815         if(lpmlcW->u.dwControlID == 1)
3816             return WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
3817                     lpmlcW->pamxctrl, fdwControls);
3818         return MMSYSERR_NOTSUPPORTED;
3819     case MIXER_GETLINECONTROLSF_ONEBYTYPE:
3820         if(lpmlcW->cControls != 1)
3821             return MMSYSERR_INVALPARAM;
3822         if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
3823             return MMSYSERR_INVALPARAM;
3824         if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
3825             return MIXERR_INVALLINE;
3826         if(lpmlcW->u.dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
3827             return WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
3828                     lpmlcW->pamxctrl, fdwControls);
3829         if(lpmlcW->u.dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
3830             return WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
3831                     lpmlcW->pamxctrl, fdwControls);
3832         return MMSYSERR_NOTSUPPORTED;
3833     }
3834
3835     return MMSYSERR_NOTSUPPORTED;
3836 }
3837
3838 static UINT WINMM_GetSourceLineInfo(WINMM_MMDevice *mmdevice, UINT mmdev_index,
3839         MIXERLINEW *info, DWORD flags)
3840 {
3841     BOOL is_out = TRUE;
3842     if(mmdevice->in_caps.szPname[0] != '\0')
3843         is_out = FALSE;
3844
3845     if(info->dwSource != 0)
3846         return MIXERR_INVALLINE;
3847
3848     info->dwDestination = 0;
3849     info->dwLineID = 0;
3850     info->fdwLine = MIXERLINE_LINEF_ACTIVE | MIXERLINE_LINEF_SOURCE;
3851     info->cConnections = 0;
3852     info->cControls = 2;
3853     /* volume & mute always affect all channels, so claim 1 channel */
3854     info->cChannels = 1;
3855     info->Target.dwDeviceID = mmdev_index;
3856     info->Target.wMid = ~0;
3857     info->Target.wPid = ~0;
3858     info->Target.vDriverVersion = 0;
3859
3860     lstrcpyW(info->szShortName, volumeW);
3861     lstrcpyW(info->szName, mastervolumeW);
3862
3863     if(is_out){
3864         info->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
3865         info->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
3866         memcpy(info->Target.szPname, mmdevice->out_caps.szPname,
3867                 sizeof(info->Target.szPname));
3868     }else{
3869         info->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
3870         info->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
3871         info->Target.szPname[0] = '\0';
3872     }
3873
3874     return MMSYSERR_NOERROR;
3875 }
3876
3877 static UINT WINMM_GetDestinationLineInfo(WINMM_MMDevice *mmdevice,
3878         UINT mmdev_index, MIXERLINEW *info, DWORD flags)
3879 {
3880     BOOL is_out = TRUE;
3881     if(mmdevice->in_caps.szPname[0] != '\0')
3882         is_out = FALSE;
3883
3884     if(info->dwDestination != 0)
3885         return MIXERR_INVALLINE;
3886
3887     info->dwSource = 0xFFFFFFFF;
3888     info->dwLineID = 0xFFFF0000;
3889     info->fdwLine = MIXERLINE_LINEF_ACTIVE;
3890     info->cConnections = 1;
3891     info->cControls = 2;
3892
3893     lstrcpyW(info->szShortName, volumeW);
3894     lstrcpyW(info->szName, mastervolumeW);
3895
3896     info->Target.dwDeviceID = mmdev_index;
3897     info->Target.wMid = ~0;
3898     info->Target.wPid = ~0;
3899     info->Target.vDriverVersion = 0;
3900
3901     if(is_out){
3902         info->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
3903         info->cChannels = mmdevice->out_caps.wChannels;
3904         info->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
3905         info->Target.szPname[0] = '\0';
3906     }else{
3907         info->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
3908         info->cChannels = mmdevice->in_caps.wChannels;
3909         info->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
3910         memcpy(info->Target.szPname, mmdevice->in_caps.szPname,
3911                 sizeof(info->Target.szPname));
3912     }
3913
3914     return MMSYSERR_NOERROR;
3915 }
3916
3917 static UINT WINMM_GetComponentTypeLineInfo(WINMM_MMDevice *mmdevice,
3918         UINT mmdev_index, MIXERLINEW *info, DWORD flags)
3919 {
3920     BOOL is_out = TRUE;
3921     if(mmdevice->in_caps.szPname[0] != '\0')
3922         is_out = FALSE;
3923
3924     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN){
3925         if(is_out)
3926             return MIXERR_INVALLINE;
3927         info->dwDestination = 0;
3928         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
3929     }
3930
3931     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_DST_SPEAKERS){
3932         if(!is_out)
3933             return MIXERR_INVALLINE;
3934         info->dwDestination = 0;
3935         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
3936     }
3937
3938     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE){
3939         if(is_out)
3940             return MIXERR_INVALLINE;
3941         info->dwSource = 0;
3942         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
3943     }
3944
3945     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT){
3946         if(!is_out)
3947             return MIXERR_INVALLINE;
3948         info->dwSource = 0;
3949         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
3950     }
3951
3952     TRACE("Returning INVALLINE on this component type: %u\n",
3953             info->dwComponentType);
3954
3955     return MIXERR_INVALLINE;
3956 }
3957
3958 static UINT WINMM_GetLineIDLineInfo(WINMM_MMDevice *mmdevice,
3959         UINT mmdev_index, MIXERLINEW *info, DWORD flags)
3960 {
3961     if(info->dwLineID == 0xFFFF0000){
3962         info->dwDestination = 0;
3963         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
3964     }
3965
3966     if(info->dwLineID == 0){
3967         info->dwSource = 0;
3968         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
3969     }
3970
3971     TRACE("Returning INVALLINE on this dwLineID: %u\n", info->dwLineID);
3972     return MIXERR_INVALLINE;
3973 }
3974
3975 /**************************************************************************
3976  *                              mixerGetLineInfoW               [WINMM.@]
3977  */
3978 UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo)
3979 {
3980     UINT mmdev_index;
3981     WINMM_MMDevice *mmdevice;
3982     HRESULT hr;
3983
3984     TRACE("(%p, %p, %x)\n", hmix, lpmliW, fdwInfo);
3985
3986     hr = WINMM_InitMMDevices();
3987     if(FAILED(hr))
3988         return MMSYSERR_ERROR;
3989
3990     if(!lpmliW || lpmliW->cbStruct < sizeof(MIXERLINEW))
3991         return MMSYSERR_INVALPARAM;
3992
3993     TRACE("dwDestination: %u\n", lpmliW->dwDestination);
3994     TRACE("dwSource: %u\n", lpmliW->dwSource);
3995     TRACE("dwLineID: %u\n", lpmliW->dwLineID);
3996     TRACE("fdwLine: 0x%x\n", lpmliW->fdwLine);
3997     TRACE("dwComponentType: 0x%x\n", lpmliW->dwComponentType);
3998
3999     if(fdwInfo & ~(MIXER_GETLINEINFOF_COMPONENTTYPE |
4000                 MIXER_GETLINEINFOF_DESTINATION |
4001                 MIXER_GETLINEINFOF_LINEID |
4002                 MIXER_GETLINEINFOF_SOURCE |
4003                 MIXER_GETLINEINFOF_TARGETTYPE |
4004                 MIXER_OBJECTF_HMIXER |
4005                 MIXER_OBJECTF_MIXER)){
4006         WARN("Unknown GetLineInfo flag: %x\n", fdwInfo);
4007         return MMSYSERR_INVALFLAG;
4008     }
4009
4010     mmdevice = WINMM_GetMixerMMDevice(hmix, fdwInfo, &mmdev_index);
4011     if(!mmdevice)
4012         return MMSYSERR_INVALHANDLE;
4013
4014     switch(fdwInfo & MIXER_GETLINEINFOF_QUERYMASK){
4015     case MIXER_GETLINEINFOF_DESTINATION:
4016         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, lpmliW,
4017                 fdwInfo);
4018     case MIXER_GETLINEINFOF_SOURCE:
4019         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, lpmliW, fdwInfo);
4020     case MIXER_GETLINEINFOF_COMPONENTTYPE:
4021         return WINMM_GetComponentTypeLineInfo(mmdevice, mmdev_index, lpmliW,
4022                 fdwInfo);
4023     case MIXER_GETLINEINFOF_LINEID:
4024         return WINMM_GetLineIDLineInfo(mmdevice, mmdev_index, lpmliW, fdwInfo);
4025     case MIXER_GETLINEINFOF_TARGETTYPE:
4026         FIXME("TARGETTYPE flag not implemented!\n");
4027         return MIXERR_INVALLINE;
4028     }
4029
4030     TRACE("Returning INVALFLAG on these flags: %x\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
4031     return MMSYSERR_INVALFLAG;
4032 }
4033
4034 /**************************************************************************
4035  *                              mixerGetLineInfoA               [WINMM.@]
4036  */
4037 UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
4038                               DWORD fdwInfo)
4039 {
4040     MIXERLINEW          mliW;
4041     UINT                ret;
4042
4043     TRACE("(%p, %p, %x)\n", hmix, lpmliA, fdwInfo);
4044
4045     if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
4046         return MMSYSERR_INVALPARAM;
4047
4048     mliW.cbStruct = sizeof(mliW);
4049     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
4050     case MIXER_GETLINEINFOF_COMPONENTTYPE:
4051         mliW.dwComponentType = lpmliA->dwComponentType;
4052         break;
4053     case MIXER_GETLINEINFOF_DESTINATION:
4054         mliW.dwDestination = lpmliA->dwDestination;
4055         break;
4056     case MIXER_GETLINEINFOF_LINEID:
4057         mliW.dwLineID = lpmliA->dwLineID;
4058         break;
4059     case MIXER_GETLINEINFOF_SOURCE:
4060         mliW.dwDestination = lpmliA->dwDestination;
4061         mliW.dwSource = lpmliA->dwSource;
4062         break;
4063     case MIXER_GETLINEINFOF_TARGETTYPE:
4064         mliW.Target.dwType = lpmliA->Target.dwType;
4065         mliW.Target.wMid = lpmliA->Target.wMid;
4066         mliW.Target.wPid = lpmliA->Target.wPid;
4067         mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion;
4068         MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR));
4069         break;
4070     default:
4071         WARN("Unsupported fdwControls=0x%08x\n", fdwInfo);
4072         return MMSYSERR_INVALFLAG;
4073     }
4074
4075     ret = mixerGetLineInfoW(hmix, &mliW, fdwInfo);
4076
4077     if(ret == MMSYSERR_NOERROR)
4078     {
4079         lpmliA->dwDestination = mliW.dwDestination;
4080         lpmliA->dwSource = mliW.dwSource;
4081         lpmliA->dwLineID = mliW.dwLineID;
4082         lpmliA->fdwLine = mliW.fdwLine;
4083         lpmliA->dwUser = mliW.dwUser;
4084         lpmliA->dwComponentType = mliW.dwComponentType;
4085         lpmliA->cChannels = mliW.cChannels;
4086         lpmliA->cConnections = mliW.cConnections;
4087         lpmliA->cControls = mliW.cControls;
4088         WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName,
4089                              sizeof(lpmliA->szShortName), NULL, NULL);
4090         WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName,
4091                              sizeof(lpmliA->szName), NULL, NULL );
4092         lpmliA->Target.dwType = mliW.Target.dwType;
4093         lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID;
4094         lpmliA->Target.wMid = mliW.Target.wMid;
4095         lpmliA->Target.wPid = mliW.Target.wPid;
4096         lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion;
4097         WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname,
4098                              sizeof(lpmliA->Target.szPname), NULL, NULL );
4099     }
4100     return ret;
4101 }
4102
4103 /**************************************************************************
4104  *                              mixerSetControlDetails  [WINMM.@]
4105  */
4106 UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
4107                                    DWORD fdwDetails)
4108 {
4109     WINMM_ControlDetails details;
4110
4111     TRACE("(%p, %p, %x)\n", hmix, lpmcd, fdwDetails);
4112
4113     if(!WINMM_StartDevicesThread())
4114         return MMSYSERR_ERROR;
4115
4116     if((fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK) ==
4117             MIXER_SETCONTROLDETAILSF_CUSTOM)
4118         return MMSYSERR_NOTSUPPORTED;
4119
4120     if(!lpmcd)
4121         return MMSYSERR_INVALPARAM;
4122
4123     TRACE("dwControlID: %u\n", lpmcd->dwControlID);
4124
4125     details.hmix = hmix;
4126     details.details = lpmcd;
4127     details.flags = fdwDetails;
4128
4129     return SendMessageW(g_devices_hwnd, MXDM_SETCONTROLDETAILS,
4130             (DWORD_PTR)&details, 0);
4131 }
4132
4133 /**************************************************************************
4134  *                              mixerMessage            [WINMM.@]
4135  */
4136 DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
4137 {
4138     TRACE("(%p, %d, %lx, %lx)\n", hmix, uMsg, dwParam1, dwParam2);
4139
4140     return MMSYSERR_NOTSUPPORTED;
4141 }