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