dlls/winmm/tests/capture.c

   1 /*
   2  * Test winmm sound capture in each sound format
   3  *
   4  * Copyright (c) 2002 Francois Gouget
   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 <stdarg.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <math.h>
  25
  26 #include "wine/test.h"
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winnls.h"
  30 #include "mmddk.h"
  31 #include "mmsystem.h"
  32 #define NOBITMAP
  33 #include "mmreg.h"
  34
  35 extern GUID KSDATAFORMAT_SUBTYPE_PCM;
  36 extern GUID KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
  37
  38 #include "winmm_test.h"
  39
  40 static const char * wave_in_error(MMRESULT error)
  41 {
  42     static char msg[1024];
  43     static char long_msg[1100];
  44     MMRESULT rc;
  45
  46     rc = waveInGetErrorTextA(error, msg, sizeof(msg));
  47     if (rc != MMSYSERR_NOERROR)
  48         sprintf(long_msg, "waveInGetErrorTextA(%x) failed with error %x", error, rc);
  49     else
  50         sprintf(long_msg, "%s(%s)", mmsys_error(error), msg);
  51     return long_msg;
  52 }
  53
  54 static void check_position(int device, HWAVEIN win, DWORD bytes,
  55                            LPWAVEFORMATEX pwfx )
  56 {
  57     MMTIME mmtime;
  58     MMRESULT rc;
  59     DWORD returned;
  60
  61     mmtime.wType = TIME_BYTES;
  62     rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
  63     ok(rc==MMSYSERR_NOERROR,
  64        "waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
  65     if (mmtime.wType != TIME_BYTES && winetest_debug > 1)
  66         trace("waveInGetPosition(%s): TIME_BYTES not supported, returned %s\n",
  67               dev_name(device),wave_time_format(mmtime.wType));
  68     returned = time_to_bytes(&mmtime, pwfx);
  69     ok(returned == bytes, "waveInGetPosition(%s): returned %d bytes, "
  70        "should be %d\n", dev_name(device), returned, bytes);
  71
  72     mmtime.wType = TIME_SAMPLES;
  73     rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
  74     ok(rc==MMSYSERR_NOERROR,
  75        "waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
  76     if (mmtime.wType != TIME_SAMPLES && winetest_debug > 1)
  77         trace("waveInGetPosition(%s): TIME_SAMPLES not supported, "
  78               "returned %s\n",dev_name(device),wave_time_format(mmtime.wType));
  79     returned = time_to_bytes(&mmtime, pwfx);
  80     ok(returned == bytes, "waveInGetPosition(%s): returned %d samples, "
  81        "should be %d\n", dev_name(device), bytes_to_samples(returned, pwfx),
  82        bytes_to_samples(bytes, pwfx));
  83
  84     mmtime.wType = TIME_MS;
  85     rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
  86     ok(rc==MMSYSERR_NOERROR,
  87        "waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
  88     if (mmtime.wType != TIME_MS && winetest_debug > 1)
  89         trace("waveInGetPosition(%s): TIME_MS not supported, returned %s\n",
  90               dev_name(device), wave_time_format(mmtime.wType));
  91     returned = time_to_bytes(&mmtime, pwfx);
  92     ok(returned == bytes, "waveInGetPosition(%s): returned %d ms, "
  93        "should be %d\n", dev_name(device), bytes_to_ms(returned, pwfx),
  94        bytes_to_ms(bytes, pwfx));
  95
  96     mmtime.wType = TIME_SMPTE;
  97     rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
  98     ok(rc==MMSYSERR_NOERROR,
  99        "waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
 100     if (mmtime.wType != TIME_SMPTE && winetest_debug > 1)
 101         trace("waveInGetPosition(%s): TIME_SMPTE not supported, returned %s\n",
 102               dev_name(device),wave_time_format(mmtime.wType));
 103     returned = time_to_bytes(&mmtime, pwfx);
 104     ok(returned == bytes, "waveInGetPosition(%s): SMPTE test failed\n",
 105        dev_name(device));
 106
 107     mmtime.wType = TIME_MIDI;
 108     rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
 109     ok(rc==MMSYSERR_NOERROR,
 110        "waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
 111     if (mmtime.wType != TIME_MIDI && winetest_debug > 1)
 112         trace("waveInGetPosition(%s): TIME_MIDI not supported, returned %s\n",
 113               dev_name(device),wave_time_format(mmtime.wType));
 114     returned = time_to_bytes(&mmtime, pwfx);
 115     ok(returned == bytes, "waveInGetPosition(%s): MIDI test failed\n",
 116        dev_name(device));
 117
 118     mmtime.wType = TIME_TICKS;
 119     rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
 120     ok(rc==MMSYSERR_NOERROR,
 121        "waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
 122     if (mmtime.wType != TIME_TICKS && winetest_debug > 1)
 123         trace("waveInGetPosition(%s): TIME_TICKS not supported, returned %s\n",
 124               dev_name(device),wave_time_format(mmtime.wType));
 125     returned = time_to_bytes(&mmtime, pwfx);
 126     ok(returned == bytes, "waveInGetPosition(%s): TICKS test failed\n",
 127        dev_name(device));
 128 }
 129
 130 static void wave_in_test_deviceIn(int device, WAVEFORMATEX *pwfx, DWORD format, DWORD flags,
 131         WAVEINCAPSA *pcaps)
 132 {
 133     HWAVEIN win, win2;
 134     HANDLE hevent = CreateEventW(NULL, FALSE, FALSE, NULL);
 135     WAVEHDR frag;
 136     MMRESULT rc;
 137     DWORD res;
 138     MMTIME mmt;
 139     WORD nChannels = pwfx->nChannels;
 140     WORD wBitsPerSample = pwfx->wBitsPerSample;
 141     DWORD nSamplesPerSec = pwfx->nSamplesPerSec;
 142     WAVEINCAPSW capsW;
 143
 144     win=NULL;
 145     flags |= CALLBACK_EVENT;
 146     rc=waveInOpen(&win,device,pwfx,(DWORD_PTR)hevent,0,flags);
 147     /* Note: Win9x doesn't know WAVE_FORMAT_DIRECT */
 148     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID ||
 149        rc==MMSYSERR_NOTENABLED || rc==MMSYSERR_NODRIVER ||
 150        rc==MMSYSERR_ALLOCATED ||
 151        ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
 152        (flags & WAVE_FORMAT_DIRECT) && !(pcaps->dwFormats & format)) ||
 153        ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
 154        (!(flags & WAVE_FORMAT_DIRECT) || (flags & WAVE_MAPPED)) &&
 155        !(pcaps->dwFormats & format)) ||
 156        (rc==MMSYSERR_INVALFLAG && (flags & WAVE_FORMAT_DIRECT)),
 157        "waveInOpen(%s): format=%dx%2dx%d flags=%x(%s) rc=%s\n",
 158        dev_name(device),pwfx->nSamplesPerSec,pwfx->wBitsPerSample,
 159        pwfx->nChannels,flags,wave_open_flags(flags),wave_in_error(rc));
 160     if ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
 161        (flags & WAVE_FORMAT_DIRECT) && (pcaps->dwFormats & format))
 162         trace(" Reason: The device lists this format as supported in its "
 163               "capabilities but opening it failed.\n");
 164     if ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
 165        !(pcaps->dwFormats & format))
 166         trace("waveInOpen(%s): format=%dx%2dx%d %s rc=%s failed but format "
 167               "not supported so OK.\n",dev_name(device),pwfx->nSamplesPerSec,
 168               pwfx->wBitsPerSample,pwfx->nChannels,
 169               flags & WAVE_FORMAT_DIRECT ? "flags=WAVE_FORMAT_DIRECT" :
 170               flags & WAVE_MAPPED ? "flags=WAVE_MAPPED" : "", mmsys_error(rc));
 171     if (rc!=MMSYSERR_NOERROR) {
 172         CloseHandle(hevent);
 173         return;
 174     }
 175     res=WaitForSingleObject(hevent,1000);
 176     ok(res==WAIT_OBJECT_0,"WaitForSingleObject failed for open\n");
 177
 178     ok(pwfx->nChannels==nChannels &&
 179        pwfx->wBitsPerSample==wBitsPerSample &&
 180        pwfx->nSamplesPerSec==nSamplesPerSec,
 181        "got the wrong format: %dx%2dx%d instead of %dx%2dx%d\n",
 182        pwfx->nSamplesPerSec, pwfx->wBitsPerSample,
 183        pwfx->nChannels, nSamplesPerSec, wBitsPerSample, nChannels);
 184
 185     /* waveInGetDevCaps allows an open handle instead of a device id */
 186     rc=waveInGetDevCapsW(HandleToUlong(win),&capsW,sizeof(capsW));
 187     ok(rc==MMSYSERR_NOERROR,
 188        "waveInGetDevCapsW(%s): MMSYSERR_NOERROR "
 189        "expected, got %s\n",dev_name(device),wave_in_error(rc));
 190
 191     /* waveInOpen does not allow an open handle instead of a device id */
 192     rc=waveInOpen(&win2,HandleToUlong(win),pwfx,0,0,CALLBACK_NULL);
 193     ok(rc==MMSYSERR_BADDEVICEID,
 194        "waveInOpen(%s): MMSYSERR_BADDEVICEID "
 195        "expected, got %s\n",dev_name(device),wave_in_error(rc));
 196     if(rc==MMSYSERR_NOERROR)
 197         waveInClose(win2);
 198
 199     /* Check that the position is 0 at start */
 200     check_position(device, win, 0, pwfx);
 201
 202     frag.lpData=HeapAlloc(GetProcessHeap(), 0, pwfx->nAvgBytesPerSec);
 203     frag.dwBufferLength=pwfx->nAvgBytesPerSec;
 204     frag.dwBytesRecorded=0;
 205     frag.dwUser=0;
 206     frag.dwFlags=0;
 207     frag.dwLoops=0;
 208     frag.lpNext=0;
 209
 210     rc=waveInPrepareHeader(win, &frag, sizeof(frag));
 211     ok(rc==MMSYSERR_NOERROR, "waveInPrepareHeader(%s): rc=%s\n",
 212        dev_name(device),wave_in_error(rc));
 213     ok(frag.dwFlags&WHDR_PREPARED,"waveInPrepareHeader(%s): prepared flag "
 214        "not set\n",dev_name(device));
 215
 216     if (winetest_interactive && rc==MMSYSERR_NOERROR) {
 217         trace("Recording for 1 second at %5dx%2dx%d %s %s\n",
 218               pwfx->nSamplesPerSec, pwfx->wBitsPerSample,pwfx->nChannels,
 219               get_format_str(pwfx->wFormatTag),
 220               flags & WAVE_FORMAT_DIRECT ? "WAVE_FORMAT_DIRECT" :
 221               flags & WAVE_MAPPED ? "WAVE_MAPPED" : "");
 222         rc=waveInAddBuffer(win, &frag, sizeof(frag));
 223         ok(rc==MMSYSERR_NOERROR,"waveInAddBuffer(%s): rc=%s\n",
 224            dev_name(device),wave_in_error(rc));
 225
 226         /* Check that the position is 0 at start */
 227         check_position(device, win, 0, pwfx);
 228
 229         rc=waveInStart(win);
 230         ok(rc==MMSYSERR_NOERROR,"waveInStart(%s): rc=%s\n",
 231            dev_name(device),wave_in_error(rc));
 232
 233         res = WaitForSingleObject(hevent,1200);
 234         ok(res==WAIT_OBJECT_0,"WaitForSingleObject failed for header\n");
 235         ok(frag.dwFlags&WHDR_DONE,"WHDR_DONE not set in frag.dwFlags\n");
 236         ok(frag.dwBytesRecorded==pwfx->nAvgBytesPerSec,
 237            "frag.dwBytesRecorded=%d, should=%d\n",
 238            frag.dwBytesRecorded,pwfx->nAvgBytesPerSec);
 239
 240         mmt.wType = TIME_BYTES;
 241         rc=waveInGetPosition(win, &mmt, sizeof(mmt));
 242         ok(rc==MMSYSERR_NOERROR,"waveInGetPosition(%s): rc=%s\n",
 243            dev_name(device),wave_in_error(rc));
 244         ok(mmt.wType == TIME_BYTES, "doesn't support TIME_BYTES: %u\n", mmt.wType);
 245         ok(mmt.u.cb == frag.dwBytesRecorded, "Got wrong position: %u\n", mmt.u.cb);
 246
 247         /* stop playing on error */
 248         if (res!=WAIT_OBJECT_0) {
 249             rc=waveInStop(win);
 250             ok(rc==MMSYSERR_NOERROR,
 251                "waveInStop(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
 252         }
 253     }
 254
 255     rc=waveInUnprepareHeader(win, &frag, sizeof(frag));
 256     ok(rc==MMSYSERR_NOERROR,"waveInUnprepareHeader(%s): rc=%s\n",
 257        dev_name(device),wave_in_error(rc));
 258
 259     rc=waveInClose(win);
 260     ok(rc==MMSYSERR_NOERROR,
 261        "waveInClose(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
 262     res=WaitForSingleObject(hevent,1000);
 263     ok(res==WAIT_OBJECT_0,"WaitForSingleObject failed for close\n");
 264
 265     if (winetest_interactive)
 266     {
 267         /*
 268          * Now play back what we recorded
 269          */
 270         HWAVEOUT wout;
 271
 272         trace("Playing back recorded sound\n");
 273         rc=waveOutOpen(&wout,WAVE_MAPPER,pwfx,(DWORD_PTR)hevent,0,CALLBACK_EVENT);
 274         ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID ||
 275            rc==MMSYSERR_NOTENABLED || rc==MMSYSERR_NODRIVER ||
 276            rc==MMSYSERR_ALLOCATED ||
 277            ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
 278             !(pcaps->dwFormats & format)),
 279            "waveOutOpen(%s) format=%dx%2dx%d flags=CALLBACK_EVENT rc=%s\n",
 280            dev_name(device),pwfx->nSamplesPerSec,pwfx->wBitsPerSample,
 281            pwfx->nChannels,wave_out_error(rc));
 282         if (rc==MMSYSERR_NOERROR)
 283         {
 284             rc=waveOutPrepareHeader(wout, &frag, sizeof(frag));
 285             ok(rc==MMSYSERR_NOERROR,"waveOutPrepareHeader(%s): rc=%s\n",
 286                dev_name(device),wave_out_error(rc));
 287
 288             if (rc==MMSYSERR_NOERROR)
 289             {
 290                 WaitForSingleObject(hevent,INFINITE);
 291                 rc=waveOutWrite(wout, &frag, sizeof(frag));
 292                 ok(rc==MMSYSERR_NOERROR,"waveOutWrite(%s): rc=%s\n",
 293                    dev_name(device),wave_out_error(rc));
 294                 WaitForSingleObject(hevent,INFINITE);
 295
 296                 rc=waveOutUnprepareHeader(wout, &frag, sizeof(frag));
 297                 ok(rc==MMSYSERR_NOERROR,"waveOutUnprepareHeader(%s): rc=%s\n",
 298                    dev_name(device),wave_out_error(rc));
 299             }
 300             rc=waveOutClose(wout);
 301             ok(rc==MMSYSERR_NOERROR,"waveOutClose(%s): rc=%s\n",
 302                dev_name(device),wave_out_error(rc));
 303         }
 304         else
 305             trace("Unable to play back the recorded sound\n");
 306     }
 307
 308     HeapFree(GetProcessHeap(), 0, frag.lpData);
 309     CloseHandle(hevent);
 310 }
 311
 312 static void wave_in_test_device(UINT_PTR device)
 313 {
 314     WAVEINCAPSA capsA;
 315     WAVEINCAPSW capsW;
 316     WAVEFORMATEX format;
 317     WAVEFORMATEXTENSIBLE wfex;
 318     HWAVEIN win;
 319     MMRESULT rc;
 320     UINT f;
 321     WCHAR * nameW;
 322     CHAR * nameA;
 323     DWORD size;
 324     DWORD dwPageSize;
 325     BYTE * twoPages;
 326     SYSTEM_INFO sSysInfo;
 327     DWORD flOldProtect;
 328     BOOL res;
 329
 330     GetSystemInfo(&sSysInfo);
 331     dwPageSize = sSysInfo.dwPageSize;
 332
 333     rc=waveInGetDevCapsA(device,&capsA,sizeof(capsA));
 334     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID ||
 335        rc==MMSYSERR_NODRIVER,
 336        "waveInGetDevCapsA(%s): failed to get capabilities: rc=%s\n",
 337        dev_name(device),wave_in_error(rc));
 338     if (rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NODRIVER)
 339         return;
 340
 341     rc=waveInGetDevCapsW(device,&capsW,sizeof(capsW));
 342     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED,
 343        "waveInGetDevCapsW(%s): MMSYSERR_NOERROR or MMSYSERR_NOTSUPPORTED "
 344        "expected, got %s\n",dev_name(device),wave_in_error(rc));
 345
 346     rc=waveInGetDevCapsA(device,NULL,sizeof(capsA));
 347     ok(rc==MMSYSERR_INVALPARAM,
 348        "waveInGetDevCapsA(%s): MMSYSERR_INVALPARAM expected, got %s\n",
 349        dev_name(device),wave_in_error(rc));
 350
 351     rc=waveInGetDevCapsW(device,NULL,sizeof(capsW));
 352     ok(rc==MMSYSERR_INVALPARAM || rc==MMSYSERR_NOTSUPPORTED,
 353        "waveInGetDevCapsW(%s): MMSYSERR_INVALPARAM or MMSYSERR_NOTSUPPORTED "
 354        "expected, got %s\n",dev_name(device),wave_in_error(rc));
 355
 356     if (0)
 357     {
 358     /* FIXME: this works on windows but crashes wine */
 359     rc=waveInGetDevCapsA(device,(LPWAVEINCAPSA)1,sizeof(capsA));
 360     ok(rc==MMSYSERR_INVALPARAM,
 361        "waveInGetDevCapsA(%s): MMSYSERR_INVALPARAM expected, got %s\n",
 362        dev_name(device),wave_in_error(rc));
 363
 364     rc=waveInGetDevCapsW(device,(LPWAVEINCAPSW)1,sizeof(capsW));
 365     ok(rc==MMSYSERR_INVALPARAM ||  rc==MMSYSERR_NOTSUPPORTED,
 366        "waveInGetDevCapsW(%s): MMSYSERR_INVALPARAM or MMSYSERR_NOTSUPPORTED "
 367        "expected, got %s\n",dev_name(device),wave_in_error(rc));
 368     }
 369
 370     rc=waveInGetDevCapsA(device,&capsA,4);
 371     ok(rc==MMSYSERR_NOERROR,
 372        "waveInGetDevCapsA(%s): MMSYSERR_NOERROR expected, got %s\n",
 373        dev_name(device),wave_in_error(rc));
 374
 375     rc=waveInGetDevCapsW(device,&capsW,4);
 376     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED ||
 377        rc==MMSYSERR_INVALPARAM, /* Vista, W2K8 */
 378        "waveInGetDevCapsW(%s): unexpected return value %s\n",
 379        dev_name(device),wave_in_error(rc));
 380
 381     nameA=NULL;
 382     rc=waveInMessage((HWAVEIN)device, DRV_QUERYDEVICEINTERFACESIZE,
 383                      (DWORD_PTR)&size, 0);
 384     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_INVALPARAM ||
 385        rc==MMSYSERR_NOTSUPPORTED,
 386        "waveInMessage(%s): failed to get interface size: rc=%s\n",
 387        dev_name(device),wave_in_error(rc));
 388     if (rc==MMSYSERR_NOERROR) {
 389         nameW = HeapAlloc(GetProcessHeap(), 0, size);
 390         rc=waveInMessage((HWAVEIN)device, DRV_QUERYDEVICEINTERFACE,
 391                          (DWORD_PTR)nameW, size);
 392         ok(rc==MMSYSERR_NOERROR,"waveInMessage(%s): failed to get interface "
 393            "name: rc=%s\n",dev_name(device),wave_in_error(rc));
 394         ok(lstrlenW(nameW)+1==size/sizeof(WCHAR),
 395            "got an incorrect size %d\n", size);
 396         if (rc==MMSYSERR_NOERROR) {
 397             nameA = HeapAlloc(GetProcessHeap(), 0, size/sizeof(WCHAR));
 398             WideCharToMultiByte(CP_ACP, 0, nameW, size/sizeof(WCHAR),
 399                                 nameA, size/sizeof(WCHAR), NULL, NULL);
 400         }
 401         HeapFree(GetProcessHeap(), 0, nameW);
 402     } else if (rc==MMSYSERR_NOTSUPPORTED) {
 403         nameA=HeapAlloc(GetProcessHeap(), 0, sizeof("not supported"));
 404         strcpy(nameA, "not supported");
 405     }
 406
 407     trace("  %s: \"%s\" (%s) %d.%d (%d:%d)\n",dev_name(device),capsA.szPname,
 408           (nameA?nameA:"failed"),capsA.vDriverVersion >> 8,
 409           capsA.vDriverVersion & 0xff,capsA.wMid,capsA.wPid);
 410     trace("     channels=%d formats=%05x\n",
 411           capsA.wChannels,capsA.dwFormats);
 412
 413     HeapFree(GetProcessHeap(), 0, nameA);
 414
 415     for (f = 0; f < ARRAY_SIZE(win_formats); f++) {
 416         format.wFormatTag=WAVE_FORMAT_PCM;
 417         format.nChannels=win_formats[f][3];
 418         format.wBitsPerSample=win_formats[f][2];
 419         format.nSamplesPerSec=win_formats[f][1];
 420         format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
 421         format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
 422         format.cbSize=0;
 423         wave_in_test_deviceIn(device,&format,win_formats[f][0],0, &capsA);
 424         if (device != WAVE_MAPPER) {
 425             wave_in_test_deviceIn(device,&format,win_formats[f][0],
 426                                   WAVE_FORMAT_DIRECT, &capsA);
 427             wave_in_test_deviceIn(device,&format,win_formats[f][0],
 428                                   WAVE_MAPPED, &capsA);
 429         }
 430     }
 431
 432     /* Try a PCMWAVEFORMAT aligned next to an unaccessible page for bounds
 433      * checking */
 434     twoPages = VirtualAlloc(NULL, 2 * dwPageSize, MEM_RESERVE | MEM_COMMIT,
 435                             PAGE_READWRITE);
 436     ok(twoPages!=NULL,"Failed to allocate 2 pages of memory\n");
 437     if (twoPages) {
 438         res = VirtualProtect(twoPages + dwPageSize, dwPageSize, PAGE_NOACCESS,
 439                              &flOldProtect);
 440         ok(res, "Failed to set memory access on second page\n");
 441         if (res) {
 442             LPWAVEFORMATEX pwfx = (LPWAVEFORMATEX)(twoPages + dwPageSize -
 443                 sizeof(PCMWAVEFORMAT));
 444             pwfx->wFormatTag=WAVE_FORMAT_PCM;
 445             pwfx->nChannels=1;
 446             pwfx->wBitsPerSample=8;
 447             pwfx->nSamplesPerSec=22050;
 448             pwfx->nBlockAlign=pwfx->nChannels*pwfx->wBitsPerSample/8;
 449             pwfx->nAvgBytesPerSec=pwfx->nSamplesPerSec*pwfx->nBlockAlign;
 450             wave_in_test_deviceIn(device,pwfx,WAVE_FORMAT_2M08,0, &capsA);
 451             if (device != WAVE_MAPPER) {
 452                 wave_in_test_deviceIn(device,pwfx,WAVE_FORMAT_2M08,
 453                     WAVE_FORMAT_DIRECT, &capsA);
 454                 wave_in_test_deviceIn(device,pwfx,WAVE_FORMAT_2M08,
 455                                       WAVE_MAPPED, &capsA);
 456             }
 457         }
 458         VirtualFree(twoPages, 2 * dwPageSize, MEM_RELEASE);
 459     }
 460
 461     /* test non PCM formats */
 462     format.wFormatTag=WAVE_FORMAT_MULAW;
 463     format.nChannels=1;
 464     format.wBitsPerSample=8;
 465     format.nSamplesPerSec=8000;
 466     format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
 467     format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
 468     format.cbSize=0;
 469     rc=waveInOpen(&win,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 470     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 471        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 472        rc==MMSYSERR_ALLOCATED,
 473        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 474     if (rc==MMSYSERR_NOERROR) {
 475         waveInClose(win);
 476         wave_in_test_deviceIn(device,&format,0,0,&capsA);
 477     } else
 478         trace("waveInOpen(%s): WAVE_FORMAT_MULAW not supported\n",
 479               dev_name(device));
 480
 481     format.wFormatTag=WAVE_FORMAT_ADPCM;
 482     format.nChannels=2;
 483     format.wBitsPerSample=4;
 484     format.nSamplesPerSec=22050;
 485     format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
 486     format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
 487     format.cbSize=0;
 488     rc=waveInOpen(&win,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 489     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 490        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 491        rc==MMSYSERR_ALLOCATED,
 492        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 493     if (rc==MMSYSERR_NOERROR) {
 494         waveInClose(win);
 495         wave_in_test_deviceIn(device,&format,0,0,&capsA);
 496     } else
 497         trace("waveInOpen(%s): WAVE_FORMAT_ADPCM not supported\n",
 498               dev_name(device));
 499
 500     /* test if WAVEFORMATEXTENSIBLE supported */
 501     wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
 502     wfex.Format.nChannels=2;
 503     wfex.Format.wBitsPerSample=16;
 504     wfex.Format.nSamplesPerSec=22050;
 505     wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
 506     wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
 507         wfex.Format.nBlockAlign;
 508     wfex.Format.cbSize=22;
 509     wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
 510     wfex.dwChannelMask=SPEAKER_ALL;
 511     wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
 512     rc=waveInOpen(&win,device,&wfex.Format,0,0,
 513                   CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 514     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 515        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 516        rc==MMSYSERR_ALLOCATED,
 517        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 518     if (rc==MMSYSERR_NOERROR) {
 519         waveInClose(win);
 520         wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA);
 521     } else
 522         trace("waveInOpen(%s): WAVE_FORMAT_EXTENSIBLE not supported\n",
 523               dev_name(device));
 524
 525     /* test if 4 channels supported */
 526     wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
 527     wfex.Format.nChannels=4;
 528     wfex.Format.wBitsPerSample=16;
 529     wfex.Format.nSamplesPerSec=22050;
 530     wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
 531     wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
 532         wfex.Format.nBlockAlign;
 533     wfex.Format.cbSize=22;
 534     wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
 535     wfex.dwChannelMask=SPEAKER_ALL;
 536     wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
 537     rc=waveInOpen(&win,device,&wfex.Format,0,0,
 538                   CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 539     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 540        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 541        rc==MMSYSERR_ALLOCATED,
 542        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 543     if (rc==MMSYSERR_NOERROR) {
 544         waveInClose(win);
 545         wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA);
 546     } else
 547         trace("waveInOpen(%s): 4 channels not supported\n",
 548               dev_name(device));
 549
 550     /* test if 6 channels supported */
 551     wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
 552     wfex.Format.nChannels=6;
 553     wfex.Format.wBitsPerSample=16;
 554     wfex.Format.nSamplesPerSec=22050;
 555     wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
 556     wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
 557         wfex.Format.nBlockAlign;
 558     wfex.Format.cbSize=22;
 559     wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
 560     wfex.dwChannelMask=SPEAKER_ALL;
 561     wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
 562     rc=waveInOpen(&win,device,&wfex.Format,0,0,
 563                   CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 564     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 565        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 566        rc==MMSYSERR_ALLOCATED,
 567        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 568     if (rc==MMSYSERR_NOERROR) {
 569         waveInClose(win);
 570         wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA);
 571     } else
 572         trace("waveInOpen(%s): 6 channels not supported\n",
 573               dev_name(device));
 574
 575     if (0)
 576     {
 577     /* FIXME: ALSA doesn't like this */
 578     /* test if 24 bit samples supported */
 579     wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
 580     wfex.Format.nChannels=2;
 581     wfex.Format.wBitsPerSample=24;
 582     wfex.Format.nSamplesPerSec=22050;
 583     wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
 584     wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
 585         wfex.Format.nBlockAlign;
 586     wfex.Format.cbSize=22;
 587     wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
 588     wfex.dwChannelMask=SPEAKER_ALL;
 589     wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
 590     rc=waveInOpen(&win,device,&wfex.Format,0,0,
 591                   CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 592     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 593        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 594        rc==MMSYSERR_ALLOCATED,
 595        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 596     if (rc==MMSYSERR_NOERROR) {
 597         waveInClose(win);
 598         wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA);
 599     } else
 600         trace("waveInOpen(%s): 24 bit samples not supported\n",
 601               dev_name(device));
 602     }
 603
 604     /* test if 32 bit samples supported */
 605     wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
 606     wfex.Format.nChannels=2;
 607     wfex.Format.wBitsPerSample=32;
 608     wfex.Format.nSamplesPerSec=22050;
 609     wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
 610     wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
 611         wfex.Format.nBlockAlign;
 612     wfex.Format.cbSize=22;
 613     wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
 614     wfex.dwChannelMask=SPEAKER_ALL;
 615     wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
 616     rc=waveInOpen(&win,device,&wfex.Format,0,0,
 617                   CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 618     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 619        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 620        rc==MMSYSERR_ALLOCATED,
 621        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 622     if (rc==MMSYSERR_NOERROR) {
 623         waveInClose(win);
 624         wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA);
 625     } else
 626         trace("waveInOpen(%s): 32 bit samples not supported\n",
 627               dev_name(device));
 628
 629     /* test if 32 bit float samples supported */
 630     wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
 631     wfex.Format.nChannels=2;
 632     wfex.Format.wBitsPerSample=32;
 633     wfex.Format.nSamplesPerSec=22050;
 634     wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
 635     wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
 636         wfex.Format.nBlockAlign;
 637     wfex.Format.cbSize=22;
 638     wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
 639     wfex.dwChannelMask=SPEAKER_ALL;
 640     wfex.SubFormat=KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 641     rc=waveInOpen(&win,device,&wfex.Format,0,0,
 642                   CALLBACK_NULL|WAVE_FORMAT_DIRECT);
 643     ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
 644        rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM ||
 645        rc==MMSYSERR_ALLOCATED,
 646        "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc));
 647     if (rc==MMSYSERR_NOERROR) {
 648         waveInClose(win);
 649         wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA);
 650     } else
 651         trace("waveInOpen(%s): 32 bit float samples not supported\n",
 652               dev_name(device));
 653 }
 654
 655 static void wave_in_tests(void)
 656 {
 657     WAVEINCAPSA capsA;
 658     WAVEINCAPSW capsW;
 659     WAVEFORMATEX format;
 660     HWAVEIN win;
 661     MMRESULT rc;
 662     DWORD preferred, status;
 663     UINT ndev,d;
 664
 665     ndev=waveInGetNumDevs();
 666     trace("found %d WaveIn devices\n",ndev);
 667
 668     rc = waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
 669             (DWORD_PTR)&preferred, (DWORD_PTR)&status);
 670     ok((ndev == 0 && (rc == MMSYSERR_NODRIVER || rc == MMSYSERR_BADDEVICEID)) ||
 671             rc == MMSYSERR_NOTSUPPORTED ||
 672             rc == MMSYSERR_NOERROR, "waveInMessage(DRVM_MAPPER_PREFERRED_GET) failed: %u\n", rc);
 673
 674     if(rc != MMSYSERR_NOTSUPPORTED)
 675         ok((ndev == 0 && (preferred == -1 || broken(preferred != -1))) ||
 676                 preferred < ndev, "Got invalid preferred device: 0x%x\n", preferred);
 677
 678     rc = waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
 679          (DWORD_PTR)-1  , 0);
 680     ok(rc == MMSYSERR_INVALPARAM || rc == MMSYSERR_BADDEVICEID, /* w2008+wvista */
 681        "waveInMessage(DRVM_MAPPER_PREFERRED_GET) failed: %u\n", rc);
 682
 683     rc = waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
 684          0, (DWORD_PTR)&status);
 685     ok(rc == MMSYSERR_INVALPARAM || rc == MMSYSERR_BADDEVICEID, /* w2008+wvista */
 686        "waveInMessage(DRVM_MAPPER_PREFERRED_GET) failed: %u\n", rc);
 687
 688     rc=waveInGetDevCapsA(ndev+1,&capsA,sizeof(capsA));
 689     ok(rc==MMSYSERR_BADDEVICEID,
 690        "waveInGetDevCapsA(%s): MMSYSERR_BADDEVICEID expected, got %s\n",
 691        dev_name(ndev+1),wave_in_error(rc));
 692
 693     rc=waveInGetDevCapsA(WAVE_MAPPER,&capsA,sizeof(capsA));
 694     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NODRIVER || (!ndev && (rc==MMSYSERR_BADDEVICEID)),
 695        "waveInGetDevCapsA(%s): got %s\n",dev_name(WAVE_MAPPER),wave_in_error(rc));
 696
 697     rc=waveInGetDevCapsW(ndev+1,&capsW,sizeof(capsW));
 698     ok(rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NOTSUPPORTED,
 699        "waveInGetDevCapsW(%s): MMSYSERR_BADDEVICEID or MMSYSERR_NOTSUPPORTED "
 700        "expected, got %s\n",dev_name(ndev+1),wave_in_error(rc));
 701
 702     rc=waveInGetDevCapsW(WAVE_MAPPER,&capsW,sizeof(capsW));
 703     ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NODRIVER ||
 704        rc==MMSYSERR_NOTSUPPORTED || (!ndev && (rc==MMSYSERR_BADDEVICEID)),
 705        "waveInGetDevCapsW(%s): got %s\n", dev_name(ndev+1),wave_in_error(rc));
 706
 707     format.wFormatTag=WAVE_FORMAT_PCM;
 708     format.nChannels=2;
 709     format.wBitsPerSample=16;
 710     format.nSamplesPerSec=44100;
 711     format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
 712     format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
 713     format.cbSize=0;
 714     rc=waveInOpen(&win,ndev+1,&format,0,0,CALLBACK_NULL);
 715     ok(rc==MMSYSERR_BADDEVICEID,
 716        "waveInOpen(%s): MMSYSERR_BADDEVICEID expected, got %s\n",
 717        dev_name(ndev+1),wave_in_error(rc));
 718
 719     for (d=0;d<ndev;d++)
 720         wave_in_test_device(d);
 721
 722     if (ndev>0)
 723         wave_in_test_device(WAVE_MAPPER);
 724 }
 725
 726 START_TEST(capture)
 727 {
 728     wave_in_tests();
 729 }