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 * device->samples_per_sec) / clock_freq;
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(queue_frames < avail_frames)
1340         avail_frames = queue_frames;
1341     if(avail_frames == 0)
1342         goto exit;
1343
1344     hr = IAudioRenderClient_GetBuffer(device->render, avail_frames, &data);
1345     if(FAILED(hr)){
1346         ERR("GetBuffer failed: %08x\n", hr);
1347         goto exit;
1348     }
1349
1350     written = 0;
1351     while(device->playing && written < avail_frames){
1352         UINT32 copy_frames, copy_bytes;
1353         BYTE *queue_data;
1354
1355         queue = device->playing;
1356
1357         if(device->acm_handle){
1358             ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)queue->reserved;
1359             queue_bytes = ash->cbDstLengthUsed;
1360             queue_data = ash->pbDst;
1361         }else{
1362             queue_bytes = queue->dwBufferLength;
1363             queue_data = (BYTE*)queue->lpData;
1364         }
1365
1366         queue_frames = (queue_bytes - device->ofs_bytes) /
1367             device->bytes_per_frame;
1368
1369         copy_frames = queue_frames < (avail_frames - written) ?
1370             queue_frames : avail_frames - written;
1371         copy_bytes = copy_frames * device->bytes_per_frame;
1372
1373         memcpy(data, queue_data + device->ofs_bytes, copy_bytes);
1374
1375         data += copy_bytes;
1376         written += copy_frames;
1377         device->ofs_bytes += copy_bytes;
1378
1379         if(device->ofs_bytes >= queue_bytes){
1380             device->ofs_bytes = 0;
1381
1382             if(!(queue->dwFlags & (WHDR_BEGINLOOP | WHDR_ENDLOOP)))
1383                 device->playing = queue->lpNext;
1384             else{
1385                 if(queue->dwFlags & WHDR_BEGINLOOP){
1386                     device->loop_start = device->playing;
1387                     device->playing = queue->lpNext;
1388                     device->loop_counter = queue->dwLoops;
1389                 }
1390                 if(queue->dwFlags & WHDR_ENDLOOP){
1391                     --device->loop_counter;
1392                     if(device->loop_counter)
1393                         device->playing = device->loop_start;
1394                     else
1395                         device->loop_start = device->playing = queue->lpNext;
1396                 }
1397             }
1398         }
1399     }
1400
1401     hr = IAudioRenderClient_ReleaseBuffer(device->render, avail_frames, 0);
1402     if(FAILED(hr)){
1403         ERR("ReleaseBuffer failed: %08x\n", hr);
1404         goto exit;
1405     }
1406
1407     device->played_frames += avail_frames;
1408
1409 exit:
1410     cb_info = device->cb_info;
1411
1412     LeaveCriticalSection(&device->lock);
1413
1414     while(first){
1415         WAVEHDR *next = first->lpNext;
1416         first->dwFlags &= ~WHDR_INQUEUE;
1417         first->dwFlags |= WHDR_DONE;
1418         WINMM_NotifyClient(&cb_info, WOM_DONE, (DWORD_PTR)first, 0);
1419         first = next;
1420     }
1421 }
1422
1423 static void WID_PullACMData(WINMM_Device *device)
1424 {
1425     UINT32 packet, packet_bytes;
1426     DWORD flags;
1427     BYTE *data;
1428     WAVEHDR *queue;
1429     HRESULT hr;
1430     MMRESULT mr;
1431
1432     if(device->acm_hdr.cbDstLength == 0){
1433         hr = IAudioClient_GetCurrentPadding(device->client, &packet);
1434         if(FAILED(hr)){
1435             ERR("GetCurrentPadding failed: %08x\n", hr);
1436             return;
1437         }
1438
1439         if(packet == 0)
1440             return;
1441
1442         hr = IAudioCaptureClient_GetBuffer(device->capture, &data, &packet,
1443                 &flags, NULL, NULL);
1444         if(FAILED(hr)){
1445             ERR("GetBuffer failed: %08x\n", hr);
1446             return;
1447         }
1448
1449         acmStreamSize(device->acm_handle, packet * device->bytes_per_frame,
1450                 &packet_bytes, ACM_STREAMSIZEF_SOURCE);
1451
1452         device->acm_offs = 0;
1453
1454         device->acm_hdr.cbStruct = sizeof(device->acm_hdr);
1455         device->acm_hdr.fdwStatus = 0;
1456         device->acm_hdr.dwUser = 0;
1457         device->acm_hdr.pbSrc = data;
1458         device->acm_hdr.cbSrcLength = packet * device->bytes_per_frame;
1459         device->acm_hdr.cbSrcLengthUsed = 0;
1460         device->acm_hdr.dwSrcUser = 0;
1461         device->acm_hdr.pbDst = HeapAlloc(GetProcessHeap(), 0, packet_bytes);
1462         device->acm_hdr.cbDstLength = packet_bytes;
1463         device->acm_hdr.cbDstLengthUsed = 0;
1464         device->acm_hdr.dwDstUser = 0;
1465
1466         mr = acmStreamPrepareHeader(device->acm_handle, &device->acm_hdr, 0);
1467         if(mr != MMSYSERR_NOERROR){
1468             ERR("acmStreamPrepareHeader failed: %d\n", mr);
1469             return;
1470         }
1471
1472         mr = acmStreamConvert(device->acm_handle, &device->acm_hdr, 0);
1473         if(mr != MMSYSERR_NOERROR){
1474             ERR("acmStreamConvert failed: %d\n", mr);
1475             return;
1476         }
1477
1478         hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet);
1479         if(FAILED(hr))
1480             ERR("ReleaseBuffer failed: %08x\n", hr);
1481
1482         device->played_frames += packet;
1483     }
1484
1485     queue = device->first;
1486     while(queue){
1487         UINT32 to_copy_bytes;
1488
1489         to_copy_bytes = min(queue->dwBufferLength - queue->dwBytesRecorded,
1490                 device->acm_hdr.cbDstLengthUsed - device->acm_offs);
1491
1492         memcpy(queue->lpData + queue->dwBytesRecorded,
1493                 device->acm_hdr.pbDst + device->acm_offs, to_copy_bytes);
1494
1495         queue->dwBytesRecorded += to_copy_bytes;
1496         device->acm_offs += to_copy_bytes;
1497
1498         if(queue->dwBufferLength - queue->dwBytesRecorded <
1499                 device->bytes_per_frame){
1500             queue->dwFlags &= ~WHDR_INQUEUE;
1501             queue->dwFlags |= WHDR_DONE;
1502             device->first = queue = queue->lpNext;
1503         }
1504
1505         if(device->acm_offs >= device->acm_hdr.cbDstLengthUsed){
1506             acmStreamUnprepareHeader(device->acm_handle, &device->acm_hdr, 0);
1507             HeapFree(GetProcessHeap(), 0, device->acm_hdr.pbDst);
1508             device->acm_hdr.cbDstLength = 0;
1509             device->acm_hdr.cbDstLengthUsed = 0;
1510
1511             /* done with this ACM Header, so try to pull more data */
1512             WID_PullACMData(device);
1513             return;
1514         }
1515     }
1516
1517     /* out of WAVEHDRs to write into, so toss the rest of this packet */
1518     acmStreamUnprepareHeader(device->acm_handle, &device->acm_hdr, 0);
1519     HeapFree(GetProcessHeap(), 0, device->acm_hdr.pbDst);
1520     device->acm_hdr.cbDstLength = 0;
1521     device->acm_hdr.cbDstLengthUsed = 0;
1522 }
1523
1524 static void WID_PullData(WINMM_Device *device)
1525 {
1526     WINMM_CBInfo cb_info;
1527     WAVEHDR *queue, *first = NULL, *last = NULL;
1528     HRESULT hr;
1529
1530     TRACE("(%p)\n", device->handle);
1531
1532     EnterCriticalSection(&device->lock);
1533
1534     if(!device->device || !device->first)
1535         goto exit;
1536
1537     first = device->first;
1538
1539     if(device->acm_handle){
1540         WID_PullACMData(device);
1541         goto exit;
1542     }
1543
1544     while(device->first){
1545         BYTE *data;
1546         UINT32 pad, packet_len, packet;
1547         DWORD flags;
1548
1549         hr = IAudioClient_GetCurrentPadding(device->client, &pad);
1550         if(FAILED(hr)){
1551             ERR("GetCurrentPadding failed: %08x\n", hr);
1552             goto exit;
1553         }
1554
1555         if(pad == 0)
1556             goto exit;
1557
1558         hr = IAudioCaptureClient_GetBuffer(device->capture, &data, &packet,
1559                 &flags, NULL, NULL);
1560         if(FAILED(hr)){
1561             ERR("GetBuffer failed: %08x\n", hr);
1562             goto exit;
1563         }
1564
1565         packet_len = packet;
1566         queue = device->first;
1567         while(queue && packet > 0){
1568             UINT32 to_copy_bytes;
1569
1570             to_copy_bytes = min(packet * device->bytes_per_frame,
1571                     queue->dwBufferLength - queue->dwBytesRecorded);
1572
1573             memcpy(queue->lpData + queue->dwBytesRecorded,
1574                     data + (packet_len - packet) * device->bytes_per_frame,
1575                     to_copy_bytes);
1576
1577             queue->dwBytesRecorded += to_copy_bytes;
1578
1579             if(queue->dwBufferLength - queue->dwBytesRecorded <
1580                     device->bytes_per_frame){
1581                 last = queue;
1582                 device->first = queue = queue->lpNext;
1583             }
1584
1585             packet -= to_copy_bytes / device->bytes_per_frame;
1586         }
1587
1588         hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet_len);
1589         if(FAILED(hr))
1590             ERR("ReleaseBuffer failed: %08x\n", hr);
1591
1592         device->played_frames += packet_len;
1593     }
1594
1595 exit:
1596     cb_info = device->cb_info;
1597
1598     LeaveCriticalSection(&device->lock);
1599
1600     if(last){
1601         last->lpNext = NULL;
1602         while(first){
1603             WAVEHDR *next = first->lpNext;
1604             first->dwFlags &= ~WHDR_INQUEUE;
1605             first->dwFlags |= WHDR_DONE;
1606             WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)first, 0);
1607             first = next;
1608         }
1609     }
1610 }
1611
1612 static HRESULT WINMM_BeginPlaying(WINMM_Device *device)
1613 {
1614     HRESULT hr;
1615
1616     TRACE("(%p)\n", device->handle);
1617
1618     if(device->render)
1619         /* prebuffer data before starting */
1620         WOD_PushData(device);
1621
1622     if(device->stopped){
1623         device->stopped = FALSE;
1624
1625         hr = IAudioClient_Start(device->client);
1626         if(FAILED(hr) && hr != AUDCLNT_E_NOT_STOPPED){
1627             device->stopped = TRUE;
1628             ERR("Start failed: %08x\n", hr);
1629             return hr;
1630         }
1631     }
1632
1633     return S_OK;
1634 }
1635
1636 static LRESULT WINMM_Pause(HWAVE hwave)
1637 {
1638     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1639     HRESULT hr;
1640
1641     TRACE("(%p)\n", hwave);
1642
1643     if(!WINMM_ValidateAndLock(device))
1644         return MMSYSERR_INVALHANDLE;
1645
1646     hr = IAudioClient_Stop(device->client);
1647     if(FAILED(hr)){
1648         LeaveCriticalSection(&device->lock);
1649         ERR("Stop failed: %08x\n", hr);
1650         return MMSYSERR_ERROR;
1651     }
1652
1653     device->stopped = FALSE;
1654
1655     LeaveCriticalSection(&device->lock);
1656
1657     return MMSYSERR_NOERROR;
1658 }
1659
1660 static LRESULT WINMM_Reset(HWAVE hwave)
1661 {
1662     WINMM_CBInfo cb_info;
1663     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1664     BOOL is_out;
1665     WAVEHDR *first;
1666     HRESULT hr;
1667
1668     TRACE("(%p)\n", hwave);
1669
1670     if(!WINMM_ValidateAndLock(device))
1671         return MMSYSERR_INVALHANDLE;
1672
1673     hr = IAudioClient_Stop(device->client);
1674     if(FAILED(hr)){
1675         LeaveCriticalSection(&device->lock);
1676         ERR("Stop failed: %08x\n", hr);
1677         return MMSYSERR_ERROR;
1678     }
1679     device->stopped = TRUE;
1680
1681     first = device->first;
1682     device->first = device->last = device->playing = NULL;
1683     device->ofs_bytes = 0;
1684     device->played_frames = 0;
1685     device->loop_counter = 0;
1686     device->last_clock_pos = 0;
1687     IAudioClient_Reset(device->client);
1688
1689     cb_info = device->cb_info;
1690     is_out = device->render ? TRUE : FALSE;
1691
1692     LeaveCriticalSection(&device->lock);
1693
1694     while(first){
1695         WAVEHDR *next = first->lpNext;
1696         first->dwFlags &= ~WHDR_INQUEUE;
1697         first->dwFlags |= WHDR_DONE;
1698         if(is_out)
1699             WINMM_NotifyClient(&cb_info, WOM_DONE, (DWORD_PTR)first, 0);
1700         else
1701             WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)first, 0);
1702         first = next;
1703     }
1704
1705     return MMSYSERR_NOERROR;
1706 }
1707
1708 static MMRESULT WINMM_FramesToMMTime(MMTIME *time, UINT32 played_frames,
1709         UINT32 sample_rate, UINT32 bytes_per_frame)
1710 {
1711     switch(time->wType){
1712     case TIME_SAMPLES:
1713         time->u.sample = played_frames;
1714         return MMSYSERR_NOERROR;
1715     case TIME_MS:
1716         time->u.ms = (DWORD)((played_frames / (double)sample_rate) * 1000);
1717         return MMSYSERR_NOERROR;
1718     case TIME_SMPTE:
1719         time->u.smpte.fps = 30;
1720         if(played_frames >= sample_rate){
1721             time->u.smpte.sec = played_frames / (double)sample_rate;
1722             time->u.smpte.min = time->u.smpte.sec / 60;
1723             time->u.smpte.hour = time->u.smpte.min / 60;
1724             time->u.smpte.sec %= 60;
1725             time->u.smpte.min %= 60;
1726             played_frames %= sample_rate;
1727         }else{
1728             time->u.smpte.sec = 0;
1729             time->u.smpte.min = 0;
1730             time->u.smpte.hour = 0;
1731         }
1732         time->u.smpte.frame = (played_frames / (double)sample_rate) * 30;
1733         return MMSYSERR_NOERROR;
1734     case TIME_BYTES:
1735     default:
1736         time->wType = TIME_BYTES;
1737         time->u.cb = played_frames * bytes_per_frame;
1738         return MMSYSERR_NOERROR;
1739     }
1740
1741     return MMSYSERR_ERROR;
1742 }
1743
1744 static LRESULT WINMM_GetPosition(HWAVE hwave, MMTIME *time)
1745 {
1746     WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1747     UINT32 played_frames, sample_rate, bytes_per_frame;
1748
1749     TRACE("(%p, %p)\n", hwave, time);
1750
1751     if(!WINMM_ValidateAndLock(device))
1752         return MMSYSERR_INVALHANDLE;
1753
1754     played_frames = device->played_frames;
1755     sample_rate = device->samples_per_sec;
1756     bytes_per_frame = device->bytes_per_frame;
1757
1758     LeaveCriticalSection(&device->lock);
1759
1760     return WINMM_FramesToMMTime(time, played_frames, sample_rate,
1761             bytes_per_frame);
1762 }
1763
1764 static WINMM_MMDevice *WINMM_GetMixerMMDevice(HMIXEROBJ hmix, DWORD flags,
1765         UINT *mmdev_index)
1766 {
1767     UINT mmdev, dev, junk, *out;
1768     BOOL is_out;
1769
1770     if(!mmdev_index)
1771         out = &mmdev;
1772     else
1773         out = mmdev_index;
1774
1775     switch(flags & 0xF0000000){
1776     case MIXER_OBJECTF_MIXER: /* == 0 */
1777         *out = HandleToULong(hmix);
1778         if(*out < g_outmmdevices_count)
1779             return &g_out_mmdevices[*out];
1780         if(*out - g_outmmdevices_count < g_inmmdevices_count){
1781             *out -= g_outmmdevices_count;
1782             return &g_in_mmdevices[*out];
1783         }
1784         /* fall through -- if it's not a valid mixer device, then
1785          * it could be a valid mixer handle. windows seems to do
1786          * this as well. */
1787     case MIXER_OBJECTF_HMIXER:
1788     case MIXER_OBJECTF_HWAVEOUT:
1789     case MIXER_OBJECTF_HWAVEIN:
1790         WINMM_DecomposeHWAVE((HWAVE)hmix, out, &is_out, &dev, &junk);
1791         if(junk != 0x1 || (is_out && *out >= g_outmmdevices_count) ||
1792                (!is_out && *out >= g_inmmdevices_count))
1793             return NULL;
1794         if(is_out)
1795             return &g_out_mmdevices[*out];
1796         return &g_in_mmdevices[*out];
1797     case MIXER_OBJECTF_WAVEOUT:
1798         *out = HandleToULong(hmix);
1799         if(*out < g_outmmdevices_count)
1800             return &g_out_mmdevices[*out];
1801         return NULL;
1802     case MIXER_OBJECTF_WAVEIN:
1803         *out = HandleToULong(hmix);
1804         if(*out < g_inmmdevices_count)
1805             return &g_in_mmdevices[*out];
1806         return NULL;
1807     }
1808
1809     return NULL;
1810 }
1811
1812 static MMRESULT WINMM_SetupMMDeviceVolume(WINMM_MMDevice *mmdevice)
1813 {
1814     IAudioSessionManager *sesman;
1815     IMMDevice *device;
1816     HRESULT hr;
1817
1818     hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id, &device);
1819     if(FAILED(hr)){
1820         ERR("Device %s (%s) unavailable: %08x\n",
1821                 wine_dbgstr_w(mmdevice->dev_id),
1822                 wine_dbgstr_w(mmdevice->out_caps.szPname), hr);
1823         return MMSYSERR_ERROR;
1824     }
1825
1826     hr = IMMDevice_Activate(device, &IID_IAudioSessionManager,
1827             CLSCTX_INPROC_SERVER, NULL, (void**)&sesman);
1828     if(FAILED(hr)){
1829         ERR("Activate failed: %08x\n", hr);
1830         IMMDevice_Release(device);
1831         return MMSYSERR_ERROR;
1832     }
1833
1834     IMMDevice_Release(device);
1835
1836     hr = IAudioSessionManager_GetSimpleAudioVolume(sesman, &mmdevice->session,
1837             FALSE, &mmdevice->volume);
1838     IAudioSessionManager_Release(sesman);
1839     if(FAILED(hr)){
1840         ERR("GetSimpleAudioVolume failed: %08x\n", hr);
1841         return MMSYSERR_ERROR;
1842     }
1843
1844     return MMSYSERR_NOERROR;
1845 }
1846
1847 static LRESULT MXD_GetControlDetails(WINMM_ControlDetails *details)
1848 {
1849     WINMM_MMDevice *mmdevice;
1850     MIXERCONTROLDETAILS *control = details->details;
1851     HRESULT hr;
1852
1853     TRACE("(%p)\n", details->hmix);
1854
1855     mmdevice = WINMM_GetMixerMMDevice(details->hmix, details->flags, NULL);
1856     if(!mmdevice)
1857         return MMSYSERR_INVALHANDLE;
1858
1859     EnterCriticalSection(&mmdevice->lock);
1860
1861     if(!mmdevice->volume){
1862         MMRESULT mr;
1863
1864         mr = WINMM_SetupMMDeviceVolume(mmdevice);
1865         if(mr != MMSYSERR_NOERROR){
1866             LeaveCriticalSection(&mmdevice->lock);
1867             return mr;
1868         }
1869     }
1870
1871     if(control->dwControlID == 0){
1872         float vol;
1873         MIXERCONTROLDETAILS_UNSIGNED *udet;
1874
1875         if(!control->paDetails ||
1876                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)){
1877             LeaveCriticalSection(&mmdevice->lock);
1878             return MMSYSERR_INVALPARAM;
1879         }
1880
1881         hr = ISimpleAudioVolume_GetMasterVolume(mmdevice->volume, &vol);
1882         if(FAILED(hr)){
1883             ERR("GetMasterVolume failed: %08x\n", hr);
1884             LeaveCriticalSection(&mmdevice->lock);
1885             return MMSYSERR_ERROR;
1886         }
1887
1888         udet = (MIXERCONTROLDETAILS_UNSIGNED*)control->paDetails;
1889         udet->dwValue = vol * ((unsigned int)0xFFFF);
1890     }else if(control->dwControlID == 1){
1891         BOOL mute;
1892         MIXERCONTROLDETAILS_BOOLEAN *bdet;
1893
1894         if(!control->paDetails ||
1895                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_BOOLEAN)){
1896             LeaveCriticalSection(&mmdevice->lock);
1897             return MMSYSERR_INVALPARAM;
1898         }
1899
1900         hr = ISimpleAudioVolume_GetMute(mmdevice->volume, &mute);
1901         if(FAILED(hr)){
1902             ERR("GetMute failed: %08x\n", hr);
1903             LeaveCriticalSection(&mmdevice->lock);
1904             return MMSYSERR_ERROR;
1905         }
1906
1907         bdet = (MIXERCONTROLDETAILS_BOOLEAN*)control->paDetails;
1908         bdet->fValue = mute;
1909     }else if(control->dwControlID == 2 || control->dwControlID == 3){
1910         FIXME("What should the sw-side mixer controls map to?\n");
1911     }else{
1912         LeaveCriticalSection(&mmdevice->lock);
1913         return MIXERR_INVALCONTROL;
1914     }
1915
1916     LeaveCriticalSection(&mmdevice->lock);
1917
1918     return MMSYSERR_NOERROR;
1919 }
1920
1921 static LRESULT MXD_SetControlDetails(WINMM_ControlDetails *details)
1922 {
1923     WINMM_MMDevice *mmdevice;
1924     MIXERCONTROLDETAILS *control = details->details;
1925     HRESULT hr;
1926
1927     TRACE("(%p)\n", details->hmix);
1928
1929     mmdevice = WINMM_GetMixerMMDevice(details->hmix, details->flags, NULL);
1930     if(!mmdevice)
1931         return MMSYSERR_INVALHANDLE;
1932
1933     EnterCriticalSection(&mmdevice->lock);
1934
1935     if(!mmdevice->volume){
1936         MMRESULT mr;
1937
1938         mr = WINMM_SetupMMDeviceVolume(mmdevice);
1939         if(mr != MMSYSERR_NOERROR){
1940             LeaveCriticalSection(&mmdevice->lock);
1941             return mr;
1942         }
1943     }
1944
1945     if(control->dwControlID == 0){
1946         float vol;
1947         MIXERCONTROLDETAILS_UNSIGNED *udet;
1948
1949         if(!control->paDetails ||
1950                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)){
1951             LeaveCriticalSection(&mmdevice->lock);
1952             return MMSYSERR_INVALPARAM;
1953         }
1954
1955         udet = (MIXERCONTROLDETAILS_UNSIGNED*)control->paDetails;
1956
1957         if(udet->dwValue > 65535){
1958             LeaveCriticalSection(&mmdevice->lock);
1959             return MMSYSERR_INVALPARAM;
1960         }
1961
1962         vol = udet->dwValue / 65535.f;
1963
1964         hr = ISimpleAudioVolume_SetMasterVolume(mmdevice->volume, vol, NULL);
1965         if(FAILED(hr)){
1966             ERR("SetMasterVolume failed: %08x\n", hr);
1967             LeaveCriticalSection(&mmdevice->lock);
1968             return MMSYSERR_ERROR;
1969         }
1970     }else if(control->dwControlID == 1){
1971         BOOL mute;
1972         MIXERCONTROLDETAILS_BOOLEAN *bdet;
1973
1974         if(!control->paDetails ||
1975                 control->cbDetails < sizeof(MIXERCONTROLDETAILS_BOOLEAN)){
1976             LeaveCriticalSection(&mmdevice->lock);
1977             return MMSYSERR_INVALPARAM;
1978         }
1979
1980         bdet = (MIXERCONTROLDETAILS_BOOLEAN*)control->paDetails;
1981         mute = bdet->fValue;
1982
1983         hr = ISimpleAudioVolume_SetMute(mmdevice->volume, mute, NULL);
1984         if(FAILED(hr)){
1985             ERR("SetMute failed: %08x\n", hr);
1986             LeaveCriticalSection(&mmdevice->lock);
1987             return MMSYSERR_ERROR;
1988         }
1989     }else if(control->dwControlID == 2 || control->dwControlID == 3){
1990         FIXME("What should the sw-side mixer controls map to?\n");
1991     }else{
1992         LeaveCriticalSection(&mmdevice->lock);
1993         return MIXERR_INVALCONTROL;
1994     }
1995
1996     LeaveCriticalSection(&mmdevice->lock);
1997
1998     return MMSYSERR_NOERROR;
1999 }
2000
2001 static LRESULT CALLBACK WINMM_DevicesMsgProc(HWND hwnd, UINT msg, WPARAM wparam,
2002         LPARAM lparam)
2003 {
2004     switch(msg){
2005     case WODM_OPEN:
2006         return WOD_Open((WINMM_OpenInfo*)wparam);
2007     case WODM_CLOSE:
2008         return WOD_Close((HWAVEOUT)wparam);
2009     case WIDM_OPEN:
2010         return WID_Open((WINMM_OpenInfo*)wparam);
2011     case WIDM_CLOSE:
2012         return WID_Close((HWAVEIN)wparam);
2013     case MXDM_GETCONTROLDETAILS:
2014         return MXD_GetControlDetails((WINMM_ControlDetails*)wparam);
2015     case MXDM_SETCONTROLDETAILS:
2016         return MXD_SetControlDetails((WINMM_ControlDetails*)wparam);
2017     }
2018     return DefWindowProcW(hwnd, msg, wparam, lparam);
2019 }
2020
2021 static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
2022 {
2023     HANDLE evt = arg;
2024     HRESULT hr;
2025     static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
2026
2027     hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
2028     if(FAILED(hr)){
2029         ERR("CoInitializeEx failed: %08x\n", hr);
2030         return 1;
2031     }
2032
2033     hr = WINMM_InitMMDevices();
2034     if(FAILED(hr)){
2035         CoUninitialize();
2036         return 1;
2037     }
2038
2039     g_devices_hwnd = CreateWindowW(messageW, NULL, 0, 0, 0, 0, 0,
2040             HWND_MESSAGE, NULL, NULL, NULL);
2041     if(!g_devices_hwnd){
2042         ERR("CreateWindow failed: %d\n", GetLastError());
2043         CoUninitialize();
2044         return 1;
2045     }
2046
2047     SetWindowLongPtrW(g_devices_hwnd, GWLP_WNDPROC,
2048             (LONG_PTR)WINMM_DevicesMsgProc);
2049
2050     /* inform caller that the thread is ready to process messages */
2051     SetEvent(evt);
2052     evt = NULL; /* do not use after this point */
2053
2054     while(1){
2055         DWORD wait;
2056         wait = MsgWaitForMultipleObjects(g_devhandle_count, g_device_handles,
2057                 FALSE, INFINITE, QS_ALLINPUT);
2058         if(wait == g_devhandle_count + WAIT_OBJECT_0){
2059             MSG msg;
2060             if(PeekMessageW(&msg, g_devices_hwnd, 0, 0, PM_REMOVE))
2061                 ERR("Unexpected message: 0x%x\n", msg.message);
2062         }else if(wait < g_devhandle_count + WAIT_OBJECT_0){
2063             WINMM_Device *device = g_handle_devices[wait - WAIT_OBJECT_0];
2064             if(device->render)
2065                 WOD_PushData(device);
2066             else
2067                 WID_PullData(device);
2068         }else
2069             ERR("Unexpected MsgWait result 0x%x, GLE: %d\n", wait,
2070                     GetLastError());
2071     }
2072
2073     DestroyWindow(g_devices_hwnd);
2074
2075     CoUninitialize();
2076
2077     return 0;
2078 }
2079
2080 static BOOL WINMM_StartDevicesThread(void)
2081 {
2082     HANDLE events[2];
2083     DWORD wait;
2084
2085     EnterCriticalSection(&g_devthread_lock);
2086
2087     if(g_devices_thread){
2088         DWORD wait;
2089
2090         wait = WaitForSingleObject(g_devices_thread, 0);
2091         if(wait == WAIT_TIMEOUT){
2092             LeaveCriticalSection(&g_devthread_lock);
2093             return TRUE;
2094         }
2095         if(wait != WAIT_OBJECT_0){
2096             LeaveCriticalSection(&g_devthread_lock);
2097             return FALSE;
2098         }
2099
2100         g_devices_thread = NULL;
2101         g_devices_hwnd = NULL;
2102     }
2103
2104     TRACE("Starting up devices thread\n");
2105
2106     events[0] = CreateEventW(NULL, FALSE, FALSE, NULL);
2107
2108     g_devices_thread = CreateThread(NULL, 0, WINMM_DevicesThreadProc,
2109             events[0], 0, NULL);
2110     if(!g_devices_thread){
2111         LeaveCriticalSection(&g_devthread_lock);
2112         CloseHandle(events[0]);
2113         return FALSE;
2114     }
2115
2116     events[1] = g_devices_thread;
2117     wait = WaitForMultipleObjects(2, events, FALSE, INFINITE);
2118     CloseHandle(events[0]);
2119     if(wait != WAIT_OBJECT_0){
2120         if(wait == 1 + WAIT_OBJECT_0){
2121             CloseHandle(g_devices_thread);
2122             g_devices_thread = NULL;
2123             g_devices_hwnd = NULL;
2124         }
2125         LeaveCriticalSection(&g_devthread_lock);
2126         return FALSE;
2127     }
2128
2129     LeaveCriticalSection(&g_devthread_lock);
2130
2131     return TRUE;
2132 }
2133
2134 /**************************************************************************
2135  *                              waveOutGetNumDevs               [WINMM.@]
2136  */
2137 UINT WINAPI waveOutGetNumDevs(void)
2138 {
2139     if(!WINMM_StartDevicesThread())
2140         return 0;
2141
2142     TRACE("count: %u\n", g_outmmdevices_count);
2143
2144     return g_outmmdevices_count;
2145 }
2146
2147 /**************************************************************************
2148  *                              waveOutGetDevCapsA              [WINMM.@]
2149  */
2150 UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
2151                                UINT uSize)
2152 {
2153     WAVEOUTCAPSW        wocW;
2154     UINT                ret;
2155
2156     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2157
2158     if(!WINMM_StartDevicesThread())
2159         return MMSYSERR_ERROR;
2160
2161     if(!lpCaps)
2162         return MMSYSERR_INVALPARAM;
2163
2164     ret = waveOutGetDevCapsW(uDeviceID, &wocW, sizeof(wocW));
2165
2166     if (ret == MMSYSERR_NOERROR) {
2167         WAVEOUTCAPSA wocA;
2168         wocA.wMid           = wocW.wMid;
2169         wocA.wPid           = wocW.wPid;
2170         wocA.vDriverVersion = wocW.vDriverVersion;
2171         WideCharToMultiByte( CP_ACP, 0, wocW.szPname, -1, wocA.szPname,
2172                              sizeof(wocA.szPname), NULL, NULL );
2173         wocA.dwFormats      = wocW.dwFormats;
2174         wocA.wChannels      = wocW.wChannels;
2175         wocA.dwSupport      = wocW.dwSupport;
2176         memcpy(lpCaps, &wocA, min(uSize, sizeof(wocA)));
2177     }
2178     return ret;
2179 }
2180
2181 /**************************************************************************
2182  *                              waveOutGetDevCapsW              [WINMM.@]
2183  */
2184 UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
2185                                UINT uSize)
2186 {
2187     WAVEOUTCAPSW mapper_caps, *caps;
2188
2189     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2190
2191     if(!WINMM_StartDevicesThread())
2192         return MMSYSERR_ERROR;
2193
2194     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
2195
2196     if(WINMM_IsMapper(uDeviceID)){
2197         /* FIXME: Should be localized */
2198         static const WCHAR mapper_pnameW[] = {'W','i','n','e',' ','S','o','u',
2199             'n','d',' ','M','a','p','p','e','r',0};
2200
2201         mapper_caps.wMid = 0xFF;
2202         mapper_caps.wPid = 0xFF;
2203         mapper_caps.vDriverVersion = 0x00010001;
2204         mapper_caps.dwFormats = 0xFFFFFFFF;
2205         mapper_caps.wReserved1 = 0;
2206         mapper_caps.dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME |
2207             WAVECAPS_SAMPLEACCURATE;
2208         mapper_caps.wChannels = 2;
2209         lstrcpyW(mapper_caps.szPname, mapper_pnameW);
2210
2211         caps = &mapper_caps;
2212     }else{
2213         if(uDeviceID >= g_outmmdevices_count)
2214             return MMSYSERR_BADDEVICEID;
2215
2216         caps = &g_out_mmdevices[uDeviceID].out_caps;
2217     }
2218
2219     memcpy(lpCaps, caps, min(uSize, sizeof(*lpCaps)));
2220
2221     return MMSYSERR_NOERROR;
2222 }
2223
2224 /**************************************************************************
2225  *                              waveOutGetErrorTextA    [WINMM.@]
2226  *                              waveInGetErrorTextA     [WINMM.@]
2227  */
2228 UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2229 {
2230     UINT        ret;
2231
2232     if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
2233     else if (uSize == 0) ret = MMSYSERR_NOERROR;
2234     else
2235     {
2236         LPWSTR  xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR));
2237         if (!xstr) ret = MMSYSERR_NOMEM;
2238         else
2239         {
2240             ret = waveOutGetErrorTextW(uError, xstr, uSize);
2241             if (ret == MMSYSERR_NOERROR)
2242                 WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL);
2243             HeapFree(GetProcessHeap(), 0, xstr);
2244         }
2245     }
2246     return ret;
2247 }
2248
2249 /**************************************************************************
2250  *                              waveOutGetErrorTextW    [WINMM.@]
2251  *                              waveInGetErrorTextW     [WINMM.@]
2252  */
2253 UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2254 {
2255     UINT        ret = MMSYSERR_BADERRNUM;
2256
2257     if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
2258     else if (uSize == 0) ret = MMSYSERR_NOERROR;
2259     else if (
2260                /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2261                 * a warning for the test was always true */
2262                (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
2263                (uError >= WAVERR_BASE  && uError <= WAVERR_LASTERROR)) {
2264         if (LoadStringW(hWinMM32Instance,
2265                         uError, lpText, uSize) > 0) {
2266             ret = MMSYSERR_NOERROR;
2267         }
2268     }
2269     return ret;
2270 }
2271
2272 /**************************************************************************
2273  *                      waveOutOpen                     [WINMM.@]
2274  * All the args/structs have the same layout as the win16 equivalents
2275  */
2276 MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
2277                        LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
2278                        DWORD_PTR dwInstance, DWORD dwFlags)
2279 {
2280     LRESULT res;
2281     WINMM_OpenInfo info;
2282     WINMM_CBInfo cb_info;
2283
2284     TRACE("(%p, %u, %p, %lx, %lx, %08x)\n", lphWaveOut, uDeviceID, lpFormat,
2285             dwCallback, dwInstance, dwFlags);
2286
2287     if(!WINMM_StartDevicesThread())
2288         return MMSYSERR_ERROR;
2289
2290     if(!lphWaveOut && !(dwFlags & WAVE_FORMAT_QUERY))
2291         return MMSYSERR_INVALPARAM;
2292
2293     res = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
2294     if(res != MMSYSERR_NOERROR)
2295         return res;
2296
2297     info.format = (WAVEFORMATEX*)lpFormat;
2298     info.callback = dwCallback;
2299     info.cb_user = dwInstance;
2300     info.req_device = uDeviceID;
2301     info.flags = dwFlags;
2302
2303     res = SendMessageW(g_devices_hwnd, WODM_OPEN, (DWORD_PTR)&info, 0);
2304     if(res != MMSYSERR_NOERROR)
2305         return res;
2306
2307     if(lphWaveOut)
2308         *lphWaveOut = (HWAVEOUT)info.handle;
2309
2310     cb_info.flags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2311     cb_info.callback = dwCallback;
2312     cb_info.user = dwInstance;
2313     cb_info.hwave = info.handle;
2314
2315     WINMM_NotifyClient(&cb_info, WOM_OPEN, 0, 0);
2316
2317     return res;
2318 }
2319
2320 /**************************************************************************
2321  *                              waveOutClose            [WINMM.@]
2322  */
2323 UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
2324 {
2325     UINT res;
2326     WINMM_Device *device;
2327     WINMM_CBInfo cb_info;
2328
2329     TRACE("(%p)\n", hWaveOut);
2330
2331     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2332
2333     if(!WINMM_ValidateAndLock(device))
2334         return MMSYSERR_INVALHANDLE;
2335
2336     cb_info = device->cb_info;
2337
2338     LeaveCriticalSection(&device->lock);
2339
2340     res = SendMessageW(g_devices_hwnd, WODM_CLOSE, (WPARAM)hWaveOut, 0);
2341
2342     if(res == MMSYSERR_NOERROR)
2343         WINMM_NotifyClient(&cb_info, WOM_CLOSE, 0, 0);
2344
2345     return res;
2346 }
2347
2348 /**************************************************************************
2349  *                              waveOutPrepareHeader    [WINMM.@]
2350  */
2351 UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
2352                                  WAVEHDR* lpWaveOutHdr, UINT uSize)
2353 {
2354     TRACE("(%p, %p, %u)\n", hWaveOut, lpWaveOutHdr, uSize);
2355
2356     if(!lpWaveOutHdr || uSize < sizeof(WAVEHDR))
2357         return MMSYSERR_INVALPARAM;
2358
2359     if(lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2360         return WAVERR_STILLPLAYING;
2361
2362     return WINMM_PrepareHeader((HWAVE)hWaveOut, lpWaveOutHdr);
2363 }
2364
2365 /**************************************************************************
2366  *                              waveOutUnprepareHeader  [WINMM.@]
2367  */
2368 UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
2369                                    LPWAVEHDR lpWaveOutHdr, UINT uSize)
2370 {
2371     TRACE("(%p, %p, %u)\n", hWaveOut, lpWaveOutHdr, uSize);
2372
2373     if(!lpWaveOutHdr || uSize < sizeof(WAVEHDR))
2374         return MMSYSERR_INVALPARAM;
2375
2376     if(!(lpWaveOutHdr->dwFlags & WHDR_PREPARED))
2377         return MMSYSERR_NOERROR;
2378
2379     if(lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2380         return WAVERR_STILLPLAYING;
2381
2382     return WINMM_UnprepareHeader((HWAVE)hWaveOut, lpWaveOutHdr);
2383 }
2384
2385 /**************************************************************************
2386  *                              waveOutWrite            [WINMM.@]
2387  */
2388 UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR *header, UINT uSize)
2389 {
2390     WINMM_Device *device;
2391     HRESULT hr;
2392
2393     TRACE("(%p, %p, %u)\n", hWaveOut, header, uSize);
2394
2395     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2396
2397     if(!WINMM_ValidateAndLock(device))
2398         return MMSYSERR_INVALHANDLE;
2399
2400     if(!header->lpData || !(header->dwFlags & WHDR_PREPARED)){
2401         LeaveCriticalSection(&device->lock);
2402         return WAVERR_UNPREPARED;
2403     }
2404
2405     if(header->dwFlags & WHDR_INQUEUE){
2406         LeaveCriticalSection(&device->lock);
2407         return WAVERR_STILLPLAYING;
2408     }
2409
2410     if(device->acm_handle){
2411         ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
2412         MMRESULT mr;
2413
2414         ash->cbSrcLength = header->dwBufferLength;
2415         mr = acmStreamConvert(device->acm_handle, ash, 0);
2416         if(mr != MMSYSERR_NOERROR){
2417             LeaveCriticalSection(&device->lock);
2418             return mr;
2419         }
2420     }
2421
2422     if(device->first){
2423         device->last->lpNext = header;
2424         device->last = header;
2425         if(!device->playing)
2426             device->playing = header;
2427     }else{
2428         device->playing = device->first = device->last = header;
2429         if(header->dwFlags & WHDR_BEGINLOOP){
2430             device->loop_counter = header->dwLoops;
2431             device->loop_start = header;
2432         }
2433     }
2434
2435     header->lpNext = NULL;
2436     header->dwFlags &= ~WHDR_DONE;
2437     header->dwFlags |= WHDR_INQUEUE;
2438
2439     hr = WINMM_BeginPlaying(device);
2440     if(FAILED(hr)){
2441         LeaveCriticalSection(&device->lock);
2442         return MMSYSERR_ERROR;
2443     }
2444
2445     LeaveCriticalSection(&device->lock);
2446
2447     return MMSYSERR_NOERROR;
2448 }
2449
2450 /**************************************************************************
2451  *                              waveOutBreakLoop        [WINMM.@]
2452  */
2453 UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
2454 {
2455     WINMM_Device *device;
2456
2457     TRACE("(%p)\n", hWaveOut);
2458
2459     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2460
2461     if(!WINMM_ValidateAndLock(device))
2462         return MMSYSERR_INVALHANDLE;
2463
2464     device->loop_counter = 0;
2465
2466     LeaveCriticalSection(&device->lock);
2467
2468     return MMSYSERR_NOERROR;
2469 }
2470
2471 /**************************************************************************
2472  *                              waveOutPause            [WINMM.@]
2473  */
2474 UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
2475 {
2476     TRACE("(%p)\n", hWaveOut);
2477
2478     return WINMM_Pause((HWAVE)hWaveOut);
2479 }
2480
2481 /**************************************************************************
2482  *                              waveOutReset            [WINMM.@]
2483  */
2484 UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
2485 {
2486     TRACE("(%p)\n", hWaveOut);
2487
2488     return WINMM_Reset((HWAVE)hWaveOut);
2489 }
2490
2491 /**************************************************************************
2492  *                              waveOutRestart          [WINMM.@]
2493  */
2494 UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
2495 {
2496     WINMM_Device *device;
2497     HRESULT hr;
2498
2499     TRACE("(%p)\n", hWaveOut);
2500
2501     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2502
2503     if(!WINMM_ValidateAndLock(device))
2504         return MMSYSERR_INVALHANDLE;
2505
2506     device->stopped = TRUE;
2507
2508     hr = WINMM_BeginPlaying(device);
2509     if(FAILED(hr)){
2510         LeaveCriticalSection(&device->lock);
2511         return MMSYSERR_ERROR;
2512     }
2513
2514     LeaveCriticalSection(&device->lock);
2515
2516     return MMSYSERR_NOERROR;
2517 }
2518
2519 /**************************************************************************
2520  *                              waveOutGetPosition      [WINMM.@]
2521  */
2522 UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
2523                                UINT uSize)
2524 {
2525     TRACE("(%p, %p, %u)\n", hWaveOut, lpTime, uSize);
2526
2527     if(!uSize || !lpTime || uSize != sizeof(MMTIME))
2528         return MMSYSERR_INVALPARAM;
2529
2530     return WINMM_GetPosition((HWAVE)hWaveOut, lpTime);
2531 }
2532
2533 /**************************************************************************
2534  *                              waveOutGetPitch         [WINMM.@]
2535  */
2536 UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
2537 {
2538     TRACE("(%p, %p)\n", hWaveOut, lpdw);
2539     return MMSYSERR_NOTSUPPORTED;
2540 }
2541
2542 /**************************************************************************
2543  *                              waveOutSetPitch         [WINMM.@]
2544  */
2545 UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
2546 {
2547     TRACE("(%p, %08x)\n", hWaveOut, dw);
2548
2549     return MMSYSERR_NOTSUPPORTED;
2550 }
2551
2552 /**************************************************************************
2553  *                              waveOutGetPlaybackRate  [WINMM.@]
2554  */
2555 UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
2556 {
2557     TRACE("(%p, %p)\n", hWaveOut, lpdw);
2558
2559     return MMSYSERR_NOTSUPPORTED;
2560 }
2561
2562 /**************************************************************************
2563  *                              waveOutSetPlaybackRate  [WINMM.@]
2564  */
2565 UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
2566 {
2567     TRACE("(%p, %08x)\n", hWaveOut, dw);
2568
2569     return MMSYSERR_NOTSUPPORTED;
2570 }
2571
2572 /**************************************************************************
2573  *                              waveOutGetVolume        [WINMM.@]
2574  */
2575 UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, DWORD *out)
2576 {
2577     WINMM_Device *device;
2578     UINT32 channels;
2579     float *vols;
2580     HRESULT hr;
2581
2582     TRACE("(%p, %p)\n", hWaveOut, out);
2583
2584     if(!out)
2585         return MMSYSERR_INVALPARAM;
2586
2587     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2588
2589     if(!WINMM_ValidateAndLock(device))
2590         return MMSYSERR_INVALHANDLE;
2591
2592     hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
2593     if(FAILED(hr)){
2594         LeaveCriticalSection(&device->lock);
2595         ERR("GetChannelCount failed: %08x\n", hr);
2596         return MMSYSERR_ERROR;
2597     }
2598
2599     vols = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels);
2600     if(!vols){
2601         LeaveCriticalSection(&device->lock);
2602         return MMSYSERR_NOMEM;
2603     }
2604
2605     hr = IAudioStreamVolume_GetAllVolumes(device->volume, channels, vols);
2606     if(FAILED(hr)){
2607         LeaveCriticalSection(&device->lock);
2608         HeapFree(GetProcessHeap(), 0, vols);
2609         ERR("GetAllVolumes failed: %08x\n", hr);
2610         return MMSYSERR_ERROR;
2611     }
2612
2613     LeaveCriticalSection(&device->lock);
2614
2615     *out = ((UINT16)(vols[0] * (DWORD)0xFFFF));
2616     if(channels > 1)
2617         *out |= ((UINT16)(vols[1] * (DWORD)0xFFFF)) << 16;
2618
2619     HeapFree(GetProcessHeap(), 0, vols);
2620
2621     return MMSYSERR_NOERROR;
2622 }
2623
2624 /**************************************************************************
2625  *                              waveOutSetVolume        [WINMM.@]
2626  */
2627 UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
2628 {
2629     WINMM_Device *device;
2630     UINT32 channels;
2631     float *vols;
2632     HRESULT hr;
2633
2634     TRACE("(%p, %08x)\n", hWaveOut, in);
2635
2636     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2637
2638     if(!WINMM_ValidateAndLock(device))
2639         return MMSYSERR_INVALHANDLE;
2640
2641     hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
2642     if(FAILED(hr)){
2643         LeaveCriticalSection(&device->lock);
2644         ERR("GetChannelCount failed: %08x\n", hr);
2645         return MMSYSERR_ERROR;
2646     }
2647
2648     vols = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels);
2649     if(!vols){
2650         LeaveCriticalSection(&device->lock);
2651         return MMSYSERR_NOMEM;
2652     }
2653
2654     hr = IAudioStreamVolume_GetAllVolumes(device->volume, channels, vols);
2655     if(FAILED(hr)){
2656         LeaveCriticalSection(&device->lock);
2657         HeapFree(GetProcessHeap(), 0, vols);
2658         ERR("GetAllVolumes failed: %08x\n", hr);
2659         return MMSYSERR_ERROR;
2660     }
2661
2662     vols[0] = (float)((DWORD)(in & 0xFFFF) / (float)0xFFFF);
2663     if(channels > 1)
2664         vols[1] = (float)((DWORD)(in >> 16) / (float)0xFFFF);
2665
2666     hr = IAudioStreamVolume_SetAllVolumes(device->volume, channels, vols);
2667     if(FAILED(hr)){
2668         LeaveCriticalSection(&device->lock);
2669         HeapFree(GetProcessHeap(), 0, vols);
2670         ERR("SetAllVolumes failed: %08x\n", hr);
2671         return MMSYSERR_ERROR;
2672     }
2673
2674     LeaveCriticalSection(&device->lock);
2675
2676     HeapFree(GetProcessHeap(), 0, vols);
2677
2678     return MMSYSERR_NOERROR;
2679 }
2680
2681 /**************************************************************************
2682  *                              waveOutGetID            [WINMM.@]
2683  */
2684 UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
2685 {
2686     WINMM_Device *device;
2687     UINT dev, junk;
2688     BOOL is_out;
2689
2690     TRACE("(%p, %p)\n", hWaveOut, lpuDeviceID);
2691
2692     if(!lpuDeviceID)
2693         return MMSYSERR_INVALPARAM;
2694
2695     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2696     if(!WINMM_ValidateAndLock(device))
2697         return MMSYSERR_INVALHANDLE;
2698
2699     LeaveCriticalSection(&device->lock);
2700
2701     WINMM_DecomposeHWAVE((HWAVE)hWaveOut, lpuDeviceID, &is_out, &dev, &junk);
2702
2703     return MMSYSERR_NOERROR;
2704 }
2705
2706 static UINT WINMM_QueryInstanceIDSize(UINT device, DWORD_PTR *len, BOOL is_out)
2707 {
2708     UINT count;
2709     WINMM_MMDevice *devices;
2710
2711     TRACE("(%u, %p, %d)\n", device, len, is_out);
2712
2713     if(is_out){
2714         count = g_outmmdevices_count;
2715         devices = g_out_mmdevices;
2716     }else{
2717         count = g_inmmdevices_count;
2718         devices = g_in_mmdevices;
2719     }
2720
2721     if(device >= count)
2722         return MMSYSERR_INVALHANDLE;
2723
2724     *len = (lstrlenW(devices[device].dev_id) + 1) * sizeof(WCHAR);
2725
2726     return MMSYSERR_NOERROR;
2727 }
2728
2729 static UINT WINMM_QueryInstanceID(UINT device, WCHAR *str, DWORD_PTR len,
2730         BOOL is_out)
2731 {
2732     UINT count, id_len;
2733     WINMM_MMDevice *devices;
2734
2735     TRACE("(%u, %p, %d)\n", device, str, is_out);
2736
2737     if(is_out){
2738         count = g_outmmdevices_count;
2739         devices = g_out_mmdevices;
2740     }else{
2741         count = g_inmmdevices_count;
2742         devices = g_in_mmdevices;
2743     }
2744
2745     if(device >= count)
2746         return MMSYSERR_INVALHANDLE;
2747
2748     id_len = (lstrlenW(devices[device].dev_id) + 1) * sizeof(WCHAR);
2749     if(len < id_len)
2750         return MMSYSERR_ERROR;
2751
2752     memcpy(str, devices[device].dev_id, id_len);
2753
2754     return MMSYSERR_NOERROR;
2755 }
2756
2757 /**************************************************************************
2758  *                              waveOutMessage          [WINMM.@]
2759  */
2760 UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
2761                            DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2762 {
2763     TRACE("(%p, %u, %lx, %lx)\n", hWaveOut, uMessage, dwParam1, dwParam2);
2764
2765     switch(uMessage){
2766     case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
2767         return WINMM_QueryInstanceIDSize(HandleToULong(hWaveOut),
2768                 (DWORD_PTR*)dwParam1, TRUE);
2769     case DRV_QUERYFUNCTIONINSTANCEID:
2770         return WINMM_QueryInstanceID(HandleToULong(hWaveOut), (WCHAR*)dwParam1, dwParam2, TRUE);
2771     case DRV_QUERYMAPPABLE:
2772         return MMSYSERR_NOERROR;
2773     }
2774
2775     return MMSYSERR_NOTSUPPORTED;
2776 }
2777
2778 /**************************************************************************
2779  *                              waveInGetNumDevs                [WINMM.@]
2780  */
2781 UINT WINAPI waveInGetNumDevs(void)
2782 {
2783     if(!WINMM_StartDevicesThread())
2784         return 0;
2785
2786     TRACE("count: %u\n", g_inmmdevices_count);
2787
2788     return g_inmmdevices_count;
2789 }
2790
2791 /**************************************************************************
2792  *                              waveInGetDevCapsW               [WINMM.@]
2793  */
2794 UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
2795 {
2796     WAVEINCAPSW mapper_caps, *caps;
2797
2798     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2799
2800     if(!WINMM_StartDevicesThread())
2801         return MMSYSERR_ERROR;
2802
2803     if(!lpCaps)
2804         return MMSYSERR_INVALPARAM;
2805
2806     if(WINMM_IsMapper(uDeviceID)){
2807         /* FIXME: Should be localized */
2808         static const WCHAR mapper_pnameW[] = {'W','i','n','e',' ','S','o','u',
2809             'n','d',' ','M','a','p','p','e','r',0};
2810
2811         mapper_caps.wMid = 0xFF;
2812         mapper_caps.wPid = 0xFF;
2813         mapper_caps.vDriverVersion = 0x00010001;
2814         mapper_caps.dwFormats = 0xFFFFFFFF;
2815         mapper_caps.wReserved1 = 0;
2816         mapper_caps.wChannels = 2;
2817         lstrcpyW(mapper_caps.szPname, mapper_pnameW);
2818
2819         caps = &mapper_caps;
2820     }else{
2821         if(uDeviceID >= g_inmmdevices_count)
2822             return MMSYSERR_BADDEVICEID;
2823
2824         caps = &g_in_mmdevices[uDeviceID].in_caps;
2825     }
2826
2827     memcpy(lpCaps, caps, min(uSize, sizeof(*lpCaps)));
2828
2829     return MMSYSERR_NOERROR;
2830 }
2831
2832 /**************************************************************************
2833  *                              waveInGetDevCapsA               [WINMM.@]
2834  */
2835 UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
2836 {
2837     UINT ret;
2838     WAVEINCAPSW wicW;
2839
2840     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2841
2842     if(!WINMM_StartDevicesThread())
2843         return MMSYSERR_ERROR;
2844
2845     if(!lpCaps)
2846         return MMSYSERR_INVALPARAM;
2847
2848     ret = waveInGetDevCapsW(uDeviceID, &wicW, sizeof(wicW));
2849
2850     if (ret == MMSYSERR_NOERROR) {
2851         WAVEINCAPSA wicA;
2852         wicA.wMid           = wicW.wMid;
2853         wicA.wPid           = wicW.wPid;
2854         wicA.vDriverVersion = wicW.vDriverVersion;
2855         WideCharToMultiByte( CP_ACP, 0, wicW.szPname, -1, wicA.szPname,
2856                              sizeof(wicA.szPname), NULL, NULL );
2857         wicA.dwFormats      = wicW.dwFormats;
2858         wicA.wChannels      = wicW.wChannels;
2859         memcpy(lpCaps, &wicA, min(uSize, sizeof(wicA)));
2860     }
2861     return ret;
2862 }
2863
2864 /**************************************************************************
2865  *                              waveInOpen                      [WINMM.@]
2866  */
2867 MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
2868                            LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
2869                            DWORD_PTR dwInstance, DWORD dwFlags)
2870 {
2871     LRESULT res;
2872     WINMM_OpenInfo info;
2873     WINMM_CBInfo cb_info;
2874
2875     TRACE("(%p, %x, %p, %lx, %lx, %08x)\n", lphWaveIn, uDeviceID, lpFormat,
2876             dwCallback, dwInstance, dwFlags);
2877
2878     if(!WINMM_StartDevicesThread())
2879         return MMSYSERR_ERROR;
2880
2881     if(!lphWaveIn && !(dwFlags & WAVE_FORMAT_QUERY))
2882         return MMSYSERR_INVALPARAM;
2883
2884     res = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
2885     if(res != MMSYSERR_NOERROR)
2886         return res;
2887
2888     info.format = (WAVEFORMATEX*)lpFormat;
2889     info.callback = dwCallback;
2890     info.cb_user = dwInstance;
2891     info.req_device = uDeviceID;
2892     info.flags = dwFlags;
2893
2894     res = SendMessageW(g_devices_hwnd, WIDM_OPEN, (DWORD_PTR)&info, 0);
2895     if(res != MMSYSERR_NOERROR)
2896         return res;
2897
2898     if(lphWaveIn)
2899         *lphWaveIn = (HWAVEIN)info.handle;
2900
2901     cb_info.flags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2902     cb_info.callback = dwCallback;
2903     cb_info.user = dwInstance;
2904     cb_info.hwave = info.handle;
2905
2906     WINMM_NotifyClient(&cb_info, WIM_OPEN, 0, 0);
2907
2908     return res;
2909 }
2910
2911 /**************************************************************************
2912  *                              waveInClose                     [WINMM.@]
2913  */
2914 UINT WINAPI waveInClose(HWAVEIN hWaveIn)
2915 {
2916     WINMM_Device *device;
2917     WINMM_CBInfo cb_info;
2918     UINT res;
2919
2920     TRACE("(%p)\n", hWaveIn);
2921
2922     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
2923
2924     if(!WINMM_ValidateAndLock(device))
2925         return MMSYSERR_INVALHANDLE;
2926
2927     cb_info = device->cb_info;
2928
2929     LeaveCriticalSection(&device->lock);
2930
2931     res = SendMessageW(g_devices_hwnd, WIDM_CLOSE, (WPARAM)hWaveIn, 0);
2932
2933     if(res == MMSYSERR_NOERROR)
2934         WINMM_NotifyClient(&cb_info, WIM_CLOSE, 0, 0);
2935
2936     return res;
2937 }
2938
2939 /**************************************************************************
2940  *                              waveInPrepareHeader             [WINMM.@]
2941  */
2942 UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
2943                                 UINT uSize)
2944 {
2945     TRACE("(%p, %p, %u)\n", hWaveIn, lpWaveInHdr, uSize);
2946
2947     if(!lpWaveInHdr || uSize < sizeof(WAVEHDR))
2948         return MMSYSERR_INVALPARAM;
2949
2950     if(lpWaveInHdr->dwFlags & WHDR_INQUEUE)
2951         return WAVERR_STILLPLAYING;
2952
2953     return WINMM_PrepareHeader((HWAVE)hWaveIn, lpWaveInHdr);
2954 }
2955
2956 /**************************************************************************
2957  *                              waveInUnprepareHeader   [WINMM.@]
2958  */
2959 UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
2960                                   UINT uSize)
2961 {
2962     TRACE("(%p, %p, %u)\n", hWaveIn, lpWaveInHdr, uSize);
2963
2964     if(!lpWaveInHdr || uSize < sizeof(WAVEHDR))
2965         return MMSYSERR_INVALPARAM;
2966
2967     if(!(lpWaveInHdr->dwFlags & WHDR_PREPARED))
2968         return MMSYSERR_NOERROR;
2969
2970     if(lpWaveInHdr->dwFlags & WHDR_INQUEUE)
2971         return WAVERR_STILLPLAYING;
2972
2973     return WINMM_UnprepareHeader((HWAVE)hWaveIn, lpWaveInHdr);
2974 }
2975
2976 /**************************************************************************
2977  *                              waveInAddBuffer         [WINMM.@]
2978  */
2979 UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn, WAVEHDR *header, UINT uSize)
2980 {
2981     WINMM_Device *device;
2982
2983     TRACE("(%p, %p, %u)\n", hWaveIn, header, uSize);
2984
2985     if(!header || uSize < sizeof(WAVEHDR))
2986         return MMSYSERR_INVALPARAM;
2987
2988     if(!(header->dwFlags & WHDR_PREPARED))
2989         return WAVERR_UNPREPARED;
2990
2991     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
2992
2993     if(!WINMM_ValidateAndLock(device))
2994         return MMSYSERR_INVALHANDLE;
2995
2996     if(!device->first)
2997         device->first = device->last = header;
2998     else{
2999         device->last->lpNext = header;
3000         device->last = header;
3001     }
3002
3003     header->dwBytesRecorded = 0;
3004     header->lpNext = NULL;
3005     header->dwFlags &= ~WHDR_DONE;
3006     header->dwFlags |= WHDR_INQUEUE;
3007
3008     LeaveCriticalSection(&device->lock);
3009
3010     return MMSYSERR_NOERROR;
3011 }
3012
3013 /**************************************************************************
3014  *                              waveInReset             [WINMM.@]
3015  */
3016 UINT WINAPI waveInReset(HWAVEIN hWaveIn)
3017 {
3018     TRACE("(%p)\n", hWaveIn);
3019
3020     return WINMM_Reset((HWAVE)hWaveIn);
3021 }
3022
3023 /**************************************************************************
3024  *                              waveInStart             [WINMM.@]
3025  */
3026 UINT WINAPI waveInStart(HWAVEIN hWaveIn)
3027 {
3028     WINMM_Device *device;
3029     HRESULT hr;
3030
3031     TRACE("(%p)\n", hWaveIn);
3032
3033     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3034
3035     if(!WINMM_ValidateAndLock(device))
3036         return MMSYSERR_INVALHANDLE;
3037
3038     hr = WINMM_BeginPlaying(device);
3039     if(FAILED(hr)){
3040         LeaveCriticalSection(&device->lock);
3041         return MMSYSERR_ERROR;
3042     }
3043
3044     LeaveCriticalSection(&device->lock);
3045
3046     return MMSYSERR_NOERROR;
3047 }
3048
3049 /**************************************************************************
3050  *                              waveInStop              [WINMM.@]
3051  */
3052 UINT WINAPI waveInStop(HWAVEIN hWaveIn)
3053 {
3054     WINMM_CBInfo cb_info;
3055     WINMM_Device *device;
3056     WAVEHDR *buf;
3057     HRESULT hr;
3058
3059     TRACE("(%p)\n", hWaveIn);
3060
3061     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3062
3063     if(!WINMM_ValidateAndLock(device))
3064         return MMSYSERR_INVALHANDLE;
3065
3066     hr = WINMM_Pause((HWAVE)hWaveIn);
3067     if(FAILED(hr)){
3068         LeaveCriticalSection(&device->lock);
3069         return MMSYSERR_ERROR;
3070     }
3071     device->stopped = TRUE;
3072
3073     buf = device->first;
3074     if(buf && buf->dwBytesRecorded > 0){
3075         device->first = buf->lpNext;
3076     }else
3077         buf = NULL;
3078
3079     cb_info = device->cb_info;
3080
3081     LeaveCriticalSection(&device->lock);
3082
3083     if(buf){
3084         buf->dwFlags &= ~WHDR_INQUEUE;
3085         buf->dwFlags |= WHDR_DONE;
3086         WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)buf, 0);
3087     }
3088
3089     return MMSYSERR_NOERROR;
3090 }
3091
3092 /**************************************************************************
3093  *                              waveInGetPosition       [WINMM.@]
3094  */
3095 UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
3096                               UINT uSize)
3097 {
3098     TRACE("(%p, %p, %u)\n", hWaveIn, lpTime, uSize);
3099
3100     if(!uSize || !lpTime || uSize != sizeof(MMTIME))
3101         return MMSYSERR_INVALPARAM;
3102
3103     return WINMM_GetPosition((HWAVE)hWaveIn, lpTime);
3104 }
3105
3106 /**************************************************************************
3107  *                              waveInGetID                     [WINMM.@]
3108  */
3109 UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
3110 {
3111     UINT dev, junk;
3112     BOOL is_out;
3113     WINMM_Device *device;
3114
3115     TRACE("(%p, %p)\n", hWaveIn, lpuDeviceID);
3116
3117     if(!lpuDeviceID)
3118         return MMSYSERR_INVALPARAM;
3119
3120     device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3121     if(!WINMM_ValidateAndLock(device))
3122         return MMSYSERR_INVALHANDLE;
3123
3124     LeaveCriticalSection(&device->lock);
3125
3126     WINMM_DecomposeHWAVE((HWAVE)hWaveIn, lpuDeviceID, &is_out, &dev, &junk);
3127
3128     return MMSYSERR_NOERROR;
3129 }
3130
3131 /**************************************************************************
3132  *                              waveInMessage           [WINMM.@]
3133  */
3134 UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
3135                           DWORD_PTR dwParam1, DWORD_PTR dwParam2)
3136 {
3137     TRACE("(%p, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
3138
3139     switch(uMessage){
3140     case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
3141         return WINMM_QueryInstanceIDSize(HandleToULong(hWaveIn),
3142                 (DWORD_PTR*)dwParam1, FALSE);
3143     case DRV_QUERYFUNCTIONINSTANCEID:
3144         return WINMM_QueryInstanceID(HandleToULong(hWaveIn), (WCHAR*)dwParam1, dwParam2, FALSE);
3145     case DRV_QUERYMAPPABLE:
3146         return MMSYSERR_NOERROR;
3147     }
3148
3149     return MMSYSERR_NOTSUPPORTED;
3150 }
3151
3152 UINT WINAPI mixerGetNumDevs(void)
3153 {
3154     TRACE("\n");
3155
3156     if(!WINMM_StartDevicesThread())
3157         return 0;
3158
3159     return g_outmmdevices_count + g_inmmdevices_count;
3160 }
3161
3162 /**************************************************************************
3163  *                              mixerGetDevCapsA                [WINMM.@]
3164  */
3165 UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
3166 {
3167     MIXERCAPSW micW;
3168     UINT       ret;
3169
3170     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3171
3172     if(!lpCaps)
3173         return MMSYSERR_INVALPARAM;
3174
3175     ret = mixerGetDevCapsW(uDeviceID, &micW, sizeof(micW));
3176
3177     if (ret == MMSYSERR_NOERROR) {
3178         MIXERCAPSA micA;
3179         micA.wMid           = micW.wMid;
3180         micA.wPid           = micW.wPid;
3181         micA.vDriverVersion = micW.vDriverVersion;
3182         WideCharToMultiByte( CP_ACP, 0, micW.szPname, -1, micA.szPname,
3183                              sizeof(micA.szPname), NULL, NULL );
3184         micA.fdwSupport     = micW.fdwSupport;
3185         micA.cDestinations  = micW.cDestinations;
3186         memcpy(lpCaps, &micA, min(uSize, sizeof(micA)));
3187     }
3188     return ret;
3189 }
3190
3191 /**************************************************************************
3192  *                              mixerGetDevCapsW                [WINMM.@]
3193  */
3194 UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
3195 {
3196     WINMM_MMDevice *mmdevice;
3197     MIXERCAPSW caps;
3198
3199     TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3200
3201     if(!WINMM_StartDevicesThread())
3202         return MMSYSERR_ERROR;
3203
3204     if(!lpCaps)
3205         return MMSYSERR_INVALPARAM;
3206
3207     if(!uSize)
3208         return MMSYSERR_NOERROR;
3209
3210     if(uDeviceID >= g_outmmdevices_count + g_inmmdevices_count)
3211         return MMSYSERR_BADDEVICEID;
3212
3213     if(uDeviceID < g_outmmdevices_count){
3214         mmdevice = &g_out_mmdevices[uDeviceID];
3215         memcpy(caps.szPname, mmdevice->out_caps.szPname, sizeof(caps.szPname));
3216     }else{
3217         mmdevice = &g_in_mmdevices[uDeviceID - g_outmmdevices_count];
3218         memcpy(caps.szPname, mmdevice->in_caps.szPname, sizeof(caps.szPname));
3219     }
3220
3221     caps.wMid = 0xFF;
3222     caps.wPid = 0xFF;
3223     caps.vDriverVersion = 0x00010001;
3224     caps.fdwSupport = 0;
3225     caps.cDestinations = 1;
3226
3227     memcpy(lpCaps, &caps, uSize);
3228
3229     return MMSYSERR_NOERROR;
3230 }
3231
3232 /**************************************************************************
3233  *                              mixerOpen                       [WINMM.@]
3234  */
3235 UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
3236                       DWORD_PTR dwInstance, DWORD fdwOpen)
3237 {
3238     WINMM_MMDevice *mmdevice;
3239     MMRESULT mr;
3240
3241     TRACE("(%p, %d, %lx, %lx, %x)\n", lphMix, uDeviceID, dwCallback,
3242             dwInstance, fdwOpen);
3243
3244     if(!WINMM_StartDevicesThread())
3245         return MMSYSERR_ERROR;
3246
3247     if(!lphMix)
3248         return MMSYSERR_INVALPARAM;
3249
3250     mr = WINMM_CheckCallback(dwCallback, fdwOpen, TRUE);
3251     if(mr != MMSYSERR_NOERROR)
3252         return mr;
3253
3254     if(uDeviceID >= g_outmmdevices_count + g_inmmdevices_count)
3255         return MMSYSERR_BADDEVICEID;
3256
3257     if(uDeviceID < g_outmmdevices_count){
3258         mmdevice = &g_out_mmdevices[uDeviceID];
3259         *lphMix = (HMIXER)WINMM_MakeHWAVE(uDeviceID, TRUE,
3260                 mmdevice->mixer_count);
3261     }else{
3262         mmdevice = &g_in_mmdevices[uDeviceID - g_outmmdevices_count];
3263         *lphMix = (HMIXER)WINMM_MakeHWAVE(uDeviceID - g_outmmdevices_count,
3264                 FALSE, mmdevice->mixer_count);
3265     }
3266
3267     ++mmdevice->mixer_count;
3268
3269     return MMSYSERR_NOERROR;
3270 }
3271
3272 /**************************************************************************
3273  *                              mixerClose                      [WINMM.@]
3274  */
3275 UINT WINAPI mixerClose(HMIXER hMix)
3276 {
3277     TRACE("(%p)\n", hMix);
3278
3279     return MMSYSERR_NOERROR;
3280 }
3281
3282 /**************************************************************************
3283  *                              mixerGetID                      [WINMM.@]
3284  */
3285 UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
3286 {
3287     WINMM_MMDevice *mmdevice;
3288
3289     TRACE("(%p, %p, %x)\n", hmix, lpid, fdwID);
3290
3291     if(!WINMM_StartDevicesThread())
3292         return MMSYSERR_ERROR;
3293
3294     if(!lpid)
3295         return MMSYSERR_INVALPARAM;
3296
3297     mmdevice = WINMM_GetMixerMMDevice(hmix, fdwID, lpid);
3298     if(!mmdevice)
3299         return MMSYSERR_INVALHANDLE;
3300
3301     if(mmdevice->in_caps.szPname[0] != '\0')
3302         *lpid += g_outmmdevices_count;
3303
3304     return MMSYSERR_NOERROR;
3305 }
3306
3307 /**************************************************************************
3308  *                              mixerGetControlDetailsW         [WINMM.@]
3309  */
3310 UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW,
3311                                     DWORD fdwDetails)
3312 {
3313     WINMM_ControlDetails details;
3314
3315     TRACE("(%p, %p, %x)\n", hmix, lpmcdW, fdwDetails);
3316
3317     if(!WINMM_StartDevicesThread())
3318         return MMSYSERR_ERROR;
3319
3320     if(!lpmcdW)
3321         return MMSYSERR_INVALPARAM;
3322
3323     TRACE("dwControlID: %u\n", lpmcdW->dwControlID);
3324
3325     details.hmix = hmix;
3326     details.details = lpmcdW;
3327     details.flags = fdwDetails;
3328
3329     return SendMessageW(g_devices_hwnd, MXDM_GETCONTROLDETAILS,
3330             (DWORD_PTR)&details, 0);
3331 }
3332
3333 /**************************************************************************
3334  *                              mixerGetControlDetailsA [WINMM.@]
3335  */
3336 UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
3337                                     DWORD fdwDetails)
3338 {
3339     UINT ret = MMSYSERR_NOTSUPPORTED;
3340
3341     TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails);
3342
3343     if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
3344         return MMSYSERR_INVALPARAM;
3345
3346     switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
3347     case MIXER_GETCONTROLDETAILSF_VALUE:
3348         /* can safely use A structure as it is, no string inside */
3349         ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
3350         break;
3351     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
3352         {
3353             MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = lpmcdA->paDetails;
3354             MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW;
3355             int size = max(1, lpmcdA->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
3356             unsigned int i;
3357
3358             if (lpmcdA->u.cMultipleItems != 0) {
3359                 size *= lpmcdA->u.cMultipleItems;
3360             }
3361             pDetailsW = HeapAlloc(GetProcessHeap(), 0, size);
3362             lpmcdA->paDetails = pDetailsW;
3363             lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
3364             /* set up lpmcd->paDetails */
3365             ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
3366             /* copy from lpmcd->paDetails back to paDetailsW; */
3367             if (ret == MMSYSERR_NOERROR) {
3368                 for (i = 0; i < lpmcdA->u.cMultipleItems * lpmcdA->cChannels; i++) {
3369                     pDetailsA->dwParam1 = pDetailsW->dwParam1;
3370                     pDetailsA->dwParam2 = pDetailsW->dwParam2;
3371                     WideCharToMultiByte( CP_ACP, 0, pDetailsW->szName, -1,
3372                                          pDetailsA->szName,
3373                                          sizeof(pDetailsA->szName), NULL, NULL );
3374                     pDetailsA++;
3375                     pDetailsW++;
3376                 }
3377                 pDetailsA -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
3378                 pDetailsW -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
3379             }
3380             HeapFree(GetProcessHeap(), 0, pDetailsW);
3381             lpmcdA->paDetails = pDetailsA;
3382             lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
3383         }
3384         break;
3385     default:
3386         ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails);
3387     }
3388
3389     return ret;
3390 }
3391
3392 /**************************************************************************
3393  *                              mixerGetLineControlsA   [WINMM.@]
3394  */
3395 UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
3396                                   DWORD fdwControls)
3397 {
3398     MIXERLINECONTROLSW  mlcW;
3399     DWORD               ret;
3400     unsigned int        i;
3401
3402     TRACE("(%p, %p, %x)\n", hmix, lpmlcA, fdwControls);
3403
3404     if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
3405         lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
3406         return MMSYSERR_INVALPARAM;
3407
3408     mlcW.cbStruct = sizeof(mlcW);
3409     mlcW.dwLineID = lpmlcA->dwLineID;
3410     mlcW.u.dwControlID = lpmlcA->u.dwControlID;
3411     mlcW.u.dwControlType = lpmlcA->u.dwControlType;
3412
3413     /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
3414        the control count is assumed to be 1 - This is relied upon by a game,
3415        "Dynomite Deluze"                                                    */
3416     if (MIXER_GETLINECONTROLSF_ONEBYTYPE == (fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)) {
3417         mlcW.cControls = 1;
3418     } else {
3419         mlcW.cControls = lpmlcA->cControls;
3420     }
3421     mlcW.cbmxctrl = sizeof(MIXERCONTROLW);
3422     mlcW.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
3423                               mlcW.cControls * mlcW.cbmxctrl);
3424
3425     ret = mixerGetLineControlsW(hmix, &mlcW, fdwControls);
3426
3427     if (ret == MMSYSERR_NOERROR) {
3428         lpmlcA->dwLineID = mlcW.dwLineID;
3429         lpmlcA->u.dwControlID = mlcW.u.dwControlID;
3430         lpmlcA->u.dwControlType = mlcW.u.dwControlType;
3431
3432         for (i = 0; i < mlcW.cControls; i++) {
3433             lpmlcA->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLA);
3434             lpmlcA->pamxctrl[i].dwControlID = mlcW.pamxctrl[i].dwControlID;
3435             lpmlcA->pamxctrl[i].dwControlType = mlcW.pamxctrl[i].dwControlType;
3436             lpmlcA->pamxctrl[i].fdwControl = mlcW.pamxctrl[i].fdwControl;
3437             lpmlcA->pamxctrl[i].cMultipleItems = mlcW.pamxctrl[i].cMultipleItems;
3438             WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szShortName, -1,
3439                                  lpmlcA->pamxctrl[i].szShortName,
3440                                  sizeof(lpmlcA->pamxctrl[i].szShortName), NULL, NULL );
3441             WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szName, -1,
3442                                  lpmlcA->pamxctrl[i].szName,
3443                                  sizeof(lpmlcA->pamxctrl[i].szName), NULL, NULL );
3444             /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
3445              * sizeof(mlcW.pamxctrl[i].Bounds) */
3446             memcpy(&lpmlcA->pamxctrl[i].Bounds, &mlcW.pamxctrl[i].Bounds,
3447                    sizeof(mlcW.pamxctrl[i].Bounds));
3448             /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
3449              * sizeof(mlcW.pamxctrl[i].Metrics) */
3450             memcpy(&lpmlcA->pamxctrl[i].Metrics, &mlcW.pamxctrl[i].Metrics,
3451                    sizeof(mlcW.pamxctrl[i].Metrics));
3452         }
3453     }
3454
3455     HeapFree(GetProcessHeap(), 0, mlcW.pamxctrl);
3456
3457     return ret;
3458 }
3459
3460 static UINT WINMM_GetVolumeLineControl(WINMM_MMDevice *mmdevice, DWORD line,
3461         MIXERCONTROLW *ctl, DWORD flags)
3462 {
3463     ctl->dwControlID = (line == 0xFFFF0000) ? 0 : 2;
3464     ctl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
3465     ctl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
3466     ctl->cMultipleItems = 0;
3467     lstrcpyW(ctl->szShortName, volumeW);
3468     lstrcpyW(ctl->szName, volumeW);
3469     ctl->Bounds.s1.dwMinimum = 0;
3470     ctl->Bounds.s1.dwMaximum = 0xFFFF;
3471     ctl->Metrics.cSteps = 192;
3472
3473     return MMSYSERR_NOERROR;
3474 }
3475
3476 static UINT WINMM_GetMuteLineControl(WINMM_MMDevice *mmdevice, DWORD line,
3477         MIXERCONTROLW *ctl, DWORD flags)
3478 {
3479     ctl->dwControlID = (line == 0xFFFF0000) ? 1 : 3;
3480     ctl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
3481     ctl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
3482     ctl->cMultipleItems = 0;
3483     lstrcpyW(ctl->szShortName, muteW);
3484     lstrcpyW(ctl->szName, muteW);
3485     ctl->Bounds.s1.dwMinimum = 0;
3486     ctl->Bounds.s1.dwMaximum = 1;
3487     ctl->Metrics.cSteps = 0;
3488
3489     return MMSYSERR_NOERROR;
3490 }
3491
3492 /**************************************************************************
3493  *                              mixerGetLineControlsW           [WINMM.@]
3494  */
3495 UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
3496                                   DWORD fdwControls)
3497 {
3498     WINMM_MMDevice *mmdevice;
3499
3500     TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls);
3501
3502     if(!WINMM_StartDevicesThread())
3503         return MMSYSERR_ERROR;
3504
3505     if(fdwControls & ~(MIXER_GETLINECONTROLSF_ALL |
3506                 MIXER_GETLINECONTROLSF_ONEBYID |
3507                 MIXER_GETLINECONTROLSF_ONEBYTYPE |
3508                 MIXER_OBJECTF_HMIXER |
3509                 MIXER_OBJECTF_MIXER)){
3510         WARN("Unknown GetLineControls flag: %x\n", fdwControls);
3511         return MMSYSERR_INVALFLAG;
3512     }
3513
3514     if(!lpmlcW || lpmlcW->cbStruct < sizeof(*lpmlcW) || !lpmlcW->pamxctrl)
3515         return MMSYSERR_INVALPARAM;
3516
3517     TRACE("dwLineID: %u\n", lpmlcW->dwLineID);
3518     TRACE("dwControl: %x\n", lpmlcW->u.dwControlID);
3519     TRACE("cControls: %u\n", lpmlcW->cControls);
3520
3521     mmdevice = WINMM_GetMixerMMDevice(hmix, fdwControls, NULL);
3522     if(!mmdevice)
3523         return MMSYSERR_INVALHANDLE;
3524
3525     switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK){
3526     case MIXER_GETLINECONTROLSF_ALL:
3527         if(lpmlcW->cControls != 2)
3528             return MMSYSERR_INVALPARAM;
3529         if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
3530             return MMSYSERR_INVALPARAM;
3531         if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
3532             return MIXERR_INVALLINE;
3533         WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
3534                 &lpmlcW->pamxctrl[0], fdwControls);
3535         WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
3536                 &lpmlcW->pamxctrl[1], fdwControls);
3537         return MMSYSERR_NOERROR;
3538     case MIXER_GETLINECONTROLSF_ONEBYID:
3539         if(lpmlcW->cControls != 1)
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         if(lpmlcW->u.dwControlID == 0)
3546             return WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
3547                     lpmlcW->pamxctrl, fdwControls);
3548         if(lpmlcW->u.dwControlID == 1)
3549             return WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
3550                     lpmlcW->pamxctrl, fdwControls);
3551         return MMSYSERR_NOTSUPPORTED;
3552     case MIXER_GETLINECONTROLSF_ONEBYTYPE:
3553         if(lpmlcW->cControls != 1)
3554             return MMSYSERR_INVALPARAM;
3555         if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
3556             return MMSYSERR_INVALPARAM;
3557         if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
3558             return MIXERR_INVALLINE;
3559         if(lpmlcW->u.dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
3560             return WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
3561                     lpmlcW->pamxctrl, fdwControls);
3562         if(lpmlcW->u.dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
3563             return WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
3564                     lpmlcW->pamxctrl, fdwControls);
3565         return MMSYSERR_NOTSUPPORTED;
3566     }
3567
3568     return MMSYSERR_NOTSUPPORTED;
3569 }
3570
3571 static UINT WINMM_GetSourceLineInfo(WINMM_MMDevice *mmdevice, UINT mmdev_index,
3572         MIXERLINEW *info, DWORD flags)
3573 {
3574     BOOL is_out = TRUE;
3575     if(mmdevice->in_caps.szPname[0] != '\0')
3576         is_out = FALSE;
3577
3578     if(info->dwSource != 0)
3579         return MIXERR_INVALLINE;
3580
3581     info->dwDestination = 0;
3582     info->dwLineID = 0;
3583     info->fdwLine = MIXERLINE_LINEF_ACTIVE | MIXERLINE_LINEF_SOURCE;
3584     info->cConnections = 0;
3585     info->cControls = 2;
3586     /* volume & mute always affect all channels, so claim 1 channel */
3587     info->cChannels = 1;
3588     info->Target.dwDeviceID = mmdev_index;
3589     info->Target.wMid = ~0;
3590     info->Target.wPid = ~0;
3591     info->Target.vDriverVersion = 0;
3592
3593     lstrcpyW(info->szShortName, volumeW);
3594     lstrcpyW(info->szName, mastervolumeW);
3595
3596     if(is_out){
3597         info->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
3598         info->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
3599         memcpy(info->Target.szPname, mmdevice->out_caps.szPname,
3600                 sizeof(info->Target.szPname));
3601     }else{
3602         info->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
3603         info->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
3604         info->Target.szPname[0] = '\0';
3605     }
3606
3607     return MMSYSERR_NOERROR;
3608 }
3609
3610 static UINT WINMM_GetDestinationLineInfo(WINMM_MMDevice *mmdevice,
3611         UINT mmdev_index, MIXERLINEW *info, DWORD flags)
3612 {
3613     BOOL is_out = TRUE;
3614     if(mmdevice->in_caps.szPname[0] != '\0')
3615         is_out = FALSE;
3616
3617     if(info->dwDestination != 0)
3618         return MIXERR_INVALLINE;
3619
3620     info->dwSource = 0xFFFFFFFF;
3621     info->dwLineID = 0xFFFF0000;
3622     info->fdwLine = MIXERLINE_LINEF_ACTIVE;
3623     info->cConnections = 1;
3624     info->cControls = 2;
3625
3626     lstrcpyW(info->szShortName, volumeW);
3627     lstrcpyW(info->szName, mastervolumeW);
3628
3629     info->Target.dwDeviceID = mmdev_index;
3630     info->Target.wMid = ~0;
3631     info->Target.wPid = ~0;
3632     info->Target.vDriverVersion = 0;
3633
3634     if(is_out){
3635         info->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
3636         info->cChannels = mmdevice->out_caps.wChannels;
3637         info->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
3638         info->Target.szPname[0] = '\0';
3639     }else{
3640         info->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
3641         info->cChannels = mmdevice->in_caps.wChannels;
3642         info->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
3643         memcpy(info->Target.szPname, mmdevice->in_caps.szPname,
3644                 sizeof(info->Target.szPname));
3645     }
3646
3647     return MMSYSERR_NOERROR;
3648 }
3649
3650 static UINT WINMM_GetComponentTypeLineInfo(WINMM_MMDevice *mmdevice,
3651         UINT mmdev_index, MIXERLINEW *info, DWORD flags)
3652 {
3653     BOOL is_out = TRUE;
3654     if(mmdevice->in_caps.szPname[0] != '\0')
3655         is_out = FALSE;
3656
3657     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN){
3658         if(is_out)
3659             return MIXERR_INVALLINE;
3660         info->dwDestination = 0;
3661         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
3662     }
3663
3664     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_DST_SPEAKERS){
3665         if(!is_out)
3666             return MIXERR_INVALLINE;
3667         info->dwDestination = 0;
3668         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
3669     }
3670
3671     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_LINE){
3672         if(is_out)
3673             return MIXERR_INVALLINE;
3674         info->dwSource = 0;
3675         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
3676     }
3677
3678     if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT){
3679         if(!is_out)
3680             return MIXERR_INVALLINE;
3681         info->dwSource = 0;
3682         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
3683     }
3684
3685     TRACE("Returning INVALLINE on this component type: %u\n",
3686             info->dwComponentType);
3687
3688     return MIXERR_INVALLINE;
3689 }
3690
3691 static UINT WINMM_GetLineIDLineInfo(WINMM_MMDevice *mmdevice,
3692         UINT mmdev_index, MIXERLINEW *info, DWORD flags)
3693 {
3694     if(info->dwLineID == 0xFFFF0000){
3695         info->dwDestination = 0;
3696         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
3697     }
3698
3699     if(info->dwLineID == 0){
3700         info->dwSource = 0;
3701         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
3702     }
3703
3704     TRACE("Returning INVALLINE on this dwLineID: %u\n", info->dwLineID);
3705     return MIXERR_INVALLINE;
3706 }
3707
3708 /**************************************************************************
3709  *                              mixerGetLineInfoW               [WINMM.@]
3710  */
3711 UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo)
3712 {
3713     UINT mmdev_index;
3714     WINMM_MMDevice *mmdevice;
3715
3716     TRACE("(%p, %p, %x)\n", hmix, lpmliW, fdwInfo);
3717
3718     if(!WINMM_StartDevicesThread())
3719         return MMSYSERR_ERROR;
3720
3721     if(!lpmliW || lpmliW->cbStruct < sizeof(MIXERLINEW))
3722         return MMSYSERR_INVALPARAM;
3723
3724     TRACE("dwDestination: %u\n", lpmliW->dwDestination);
3725     TRACE("dwSource: %u\n", lpmliW->dwSource);
3726     TRACE("dwLineID: %u\n", lpmliW->dwLineID);
3727     TRACE("fdwLine: 0x%x\n", lpmliW->fdwLine);
3728     TRACE("dwComponentType: 0x%x\n", lpmliW->dwComponentType);
3729
3730     if(fdwInfo & ~(MIXER_GETLINEINFOF_COMPONENTTYPE |
3731                 MIXER_GETLINEINFOF_DESTINATION |
3732                 MIXER_GETLINEINFOF_LINEID |
3733                 MIXER_GETLINEINFOF_SOURCE |
3734                 MIXER_GETLINEINFOF_TARGETTYPE |
3735                 MIXER_OBJECTF_HMIXER |
3736                 MIXER_OBJECTF_MIXER)){
3737         WARN("Unknown GetLineInfo flag: %x\n", fdwInfo);
3738         return MMSYSERR_INVALFLAG;
3739     }
3740
3741     mmdevice = WINMM_GetMixerMMDevice(hmix, fdwInfo, &mmdev_index);
3742     if(!mmdevice)
3743         return MMSYSERR_INVALHANDLE;
3744
3745     switch(fdwInfo & MIXER_GETLINEINFOF_QUERYMASK){
3746     case MIXER_GETLINEINFOF_DESTINATION:
3747         return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, lpmliW,
3748                 fdwInfo);
3749     case MIXER_GETLINEINFOF_SOURCE:
3750         return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, lpmliW, fdwInfo);
3751     case MIXER_GETLINEINFOF_COMPONENTTYPE:
3752         return WINMM_GetComponentTypeLineInfo(mmdevice, mmdev_index, lpmliW,
3753                 fdwInfo);
3754     case MIXER_GETLINEINFOF_LINEID:
3755         return WINMM_GetLineIDLineInfo(mmdevice, mmdev_index, lpmliW, fdwInfo);
3756     case MIXER_GETLINEINFOF_TARGETTYPE:
3757         FIXME("TARGETTYPE flag not implemented!\n");
3758         return MIXERR_INVALLINE;
3759     }
3760
3761     TRACE("Returning INVALFLAG on these flags: %x\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
3762     return MMSYSERR_INVALFLAG;
3763 }
3764
3765 /**************************************************************************
3766  *                              mixerGetLineInfoA               [WINMM.@]
3767  */
3768 UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
3769                               DWORD fdwInfo)
3770 {
3771     MIXERLINEW          mliW;
3772     UINT                ret;
3773
3774     TRACE("(%p, %p, %x)\n", hmix, lpmliA, fdwInfo);
3775
3776     if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
3777         return MMSYSERR_INVALPARAM;
3778
3779     mliW.cbStruct = sizeof(mliW);
3780     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
3781     case MIXER_GETLINEINFOF_COMPONENTTYPE:
3782         mliW.dwComponentType = lpmliA->dwComponentType;
3783         break;
3784     case MIXER_GETLINEINFOF_DESTINATION:
3785         mliW.dwDestination = lpmliA->dwDestination;
3786         break;
3787     case MIXER_GETLINEINFOF_LINEID:
3788         mliW.dwLineID = lpmliA->dwLineID;
3789         break;
3790     case MIXER_GETLINEINFOF_SOURCE:
3791         mliW.dwDestination = lpmliA->dwDestination;
3792         mliW.dwSource = lpmliA->dwSource;
3793         break;
3794     case MIXER_GETLINEINFOF_TARGETTYPE:
3795         mliW.Target.dwType = lpmliA->Target.dwType;
3796         mliW.Target.wMid = lpmliA->Target.wMid;
3797         mliW.Target.wPid = lpmliA->Target.wPid;
3798         mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion;
3799         MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR));
3800         break;
3801     default:
3802         WARN("Unsupported fdwControls=0x%08x\n", fdwInfo);
3803         return MMSYSERR_INVALFLAG;
3804     }
3805
3806     ret = mixerGetLineInfoW(hmix, &mliW, fdwInfo);
3807
3808     if(ret == MMSYSERR_NOERROR)
3809     {
3810         lpmliA->dwDestination = mliW.dwDestination;
3811         lpmliA->dwSource = mliW.dwSource;
3812         lpmliA->dwLineID = mliW.dwLineID;
3813         lpmliA->fdwLine = mliW.fdwLine;
3814         lpmliA->dwUser = mliW.dwUser;
3815         lpmliA->dwComponentType = mliW.dwComponentType;
3816         lpmliA->cChannels = mliW.cChannels;
3817         lpmliA->cConnections = mliW.cConnections;
3818         lpmliA->cControls = mliW.cControls;
3819         WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName,
3820                              sizeof(lpmliA->szShortName), NULL, NULL);
3821         WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName,
3822                              sizeof(lpmliA->szName), NULL, NULL );
3823         lpmliA->Target.dwType = mliW.Target.dwType;
3824         lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID;
3825         lpmliA->Target.wMid = mliW.Target.wMid;
3826         lpmliA->Target.wPid = mliW.Target.wPid;
3827         lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion;
3828         WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname,
3829                              sizeof(lpmliA->Target.szPname), NULL, NULL );
3830     }
3831     return ret;
3832 }
3833
3834 /**************************************************************************
3835  *                              mixerSetControlDetails  [WINMM.@]
3836  */
3837 UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
3838                                    DWORD fdwDetails)
3839 {
3840     WINMM_ControlDetails details;
3841
3842     TRACE("(%p, %p, %x)\n", hmix, lpmcd, fdwDetails);
3843
3844     if(!WINMM_StartDevicesThread())
3845         return MMSYSERR_ERROR;
3846
3847     if((fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK) ==
3848             MIXER_SETCONTROLDETAILSF_CUSTOM)
3849         return MMSYSERR_NOTSUPPORTED;
3850
3851     if(!lpmcd)
3852         return MMSYSERR_INVALPARAM;
3853
3854     TRACE("dwControlID: %u\n", lpmcd->dwControlID);
3855
3856     details.hmix = hmix;
3857     details.details = lpmcd;
3858     details.flags = fdwDetails;
3859
3860     return SendMessageW(g_devices_hwnd, MXDM_SETCONTROLDETAILS,
3861             (DWORD_PTR)&details, 0);
3862 }
3863
3864 /**************************************************************************
3865  *                              mixerMessage            [WINMM.@]
3866  */
3867 DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
3868 {
3869     TRACE("(%p, %d, %lx, %lx)\n", hmix, uMsg, dwParam1, dwParam2);
3870
3871     return MMSYSERR_NOTSUPPORTED;
3872 }