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