git.oblomov.eu Git - wine/blob - dlls/msacm32.drv/wavemap.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * Wine Wave mapper driver
   4  *
   5  * Copyright    1999,2001 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /* TODOs
  23  *      + better protection against evilish dwUser parameters
  24  *      + use asynchronous ACM conversion
  25  *      + don't use callback functions when none is required in open
  26  *      + the buffer sizes may not be accurate, so there may be some
  27  *        remaining bytes in src and dst buffers after ACM conversions...
  28  *              those should be taken care of...
  29  */
  30
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "wingdi.h"
  36 #include "winuser.h"
  37 #include "mmddk.h"
  38 #include "mmreg.h"
  39 #include "msacm.h"
  40 #include "wine/unicode.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(wavemap);
  44
  45 typedef struct tagWAVEMAPDATA {
  46     struct tagWAVEMAPDATA*      self;
  47     union {
  48         struct {
  49             HWAVEOUT    hOuterWave;
  50             HWAVEOUT    hInnerWave;
  51         } out;
  52         struct {
  53             HWAVEIN     hOuterWave;
  54             HWAVEIN     hInnerWave;
  55         } in;
  56     } u;
  57     HACMSTREAM  hAcmStream;
  58     /* needed data to filter callbacks. Only needed when hAcmStream is not 0 */
  59     DWORD_PTR   dwCallback;
  60     DWORD_PTR   dwClientInstance;
  61     DWORD       dwFlags;
  62     /* ratio to compute position from a PCM playback to any format */
  63     DWORD       avgSpeedOuter;
  64     DWORD       avgSpeedInner;
  65     /* channel size of inner and outer */
  66     DWORD       nSamplesPerSecOuter;
  67     DWORD       nSamplesPerSecInner;
  68 } WAVEMAPDATA;
  69
  70 static  BOOL    WAVEMAP_IsData(const WAVEMAPDATA* wm)
  71 {
  72     return (!IsBadReadPtr(wm, sizeof(WAVEMAPDATA)) && wm->self == wm);
  73 }
  74
  75 /*======================================================================*
  76  *                  WAVE OUT part                                       *
  77  *======================================================================*/
  78
  79 static void CALLBACK wodCallback(HWAVEOUT hWave, UINT uMsg, DWORD_PTR dwInstance,
  80                                  DWORD_PTR dwParam1, DWORD_PTR dwParam2)
  81 {
  82     WAVEMAPDATA*        wom = (WAVEMAPDATA*)dwInstance;
  83
  84     TRACE("(%p %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
  85
  86     if (!WAVEMAP_IsData(wom)) {
  87         ERR("Bad data\n");
  88         return;
  89     }
  90
  91     if (uMsg != WOM_OPEN && hWave != wom->u.out.hInnerWave)
  92         ERR("Shouldn't happen (%p %p)\n", hWave, wom->u.out.hInnerWave);
  93
  94     switch (uMsg) {
  95     case WOM_OPEN:
  96     case WOM_CLOSE:
  97         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
  98         break;
  99     case WOM_DONE:
 100         if (wom->hAcmStream) {
 101             LPWAVEHDR           lpWaveHdrDst = (LPWAVEHDR)dwParam1;
 102             PACMSTREAMHEADER    ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrDst - sizeof(ACMSTREAMHEADER));
 103             LPWAVEHDR           lpWaveHdrSrc = (LPWAVEHDR)ash->dwUser;
 104
 105             lpWaveHdrSrc->dwFlags &= ~WHDR_INQUEUE;
 106             lpWaveHdrSrc->dwFlags |= WHDR_DONE;
 107             dwParam1 = (DWORD_PTR)lpWaveHdrSrc;
 108         }
 109         break;
 110     default:
 111         ERR("Unknown msg %u\n", uMsg);
 112     }
 113
 114     DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags), (HDRVR)wom->u.out.hOuterWave,
 115                    uMsg, wom->dwClientInstance, dwParam1, dwParam2);
 116 }
 117
 118 /******************************************************************
 119  *              wodOpenHelper
 120  *
 121  *
 122  */
 123 static  DWORD   wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
 124                               LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
 125                               DWORD dwFlags)
 126 {
 127     DWORD       ret;
 128
 129     TRACE("(%p %04x %p %p %08x)\n", wom, idx, lpDesc, lpwfx, dwFlags);
 130
 131     /* destination is always PCM, so the formulas below apply */
 132     lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
 133     lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
 134     if (dwFlags & WAVE_FORMAT_QUERY) {
 135         ret = acmStreamOpen(NULL, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L, ACM_STREAMOPENF_QUERY);
 136     } else {
 137         ret = acmStreamOpen(&wom->hAcmStream, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L, 0L);
 138     }
 139     if (ret == MMSYSERR_NOERROR) {
 140         ret = waveOutOpen(&wom->u.out.hInnerWave, idx, lpwfx,
 141                           (DWORD_PTR)wodCallback, (DWORD_PTR)wom,
 142                           (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
 143         if (ret != MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY)) {
 144             acmStreamClose(wom->hAcmStream, 0);
 145             wom->hAcmStream = 0;
 146         }
 147     }
 148     TRACE("ret = %08x\n", ret);
 149     return ret;
 150 }
 151
 152 static  DWORD   wodOpen(DWORD_PTR *lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
 153 {
 154     UINT                ndlo, ndhi;
 155     UINT                i;
 156     WAVEMAPDATA*        wom = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
 157     DWORD               res;
 158
 159     TRACE("(%p %p %08x)\n", lpdwUser, lpDesc, dwFlags);
 160
 161     if (!wom) {
 162         WARN("no memory\n");
 163         return MMSYSERR_NOMEM;
 164     }
 165
 166     ndhi = waveOutGetNumDevs();
 167     if (dwFlags & WAVE_MAPPED) {
 168         if (lpDesc->uMappedDeviceID >= ndhi) {
 169             WARN("invalid parameter: dwFlags WAVE_MAPPED\n");
 170             HeapFree(GetProcessHeap(), 0, wom);
 171             return MMSYSERR_INVALPARAM;
 172         }
 173         ndlo = lpDesc->uMappedDeviceID;
 174         ndhi = ndlo + 1;
 175         dwFlags &= ~WAVE_MAPPED;
 176     } else {
 177         ndlo = 0;
 178     }
 179     wom->self = wom;
 180     wom->dwCallback = lpDesc->dwCallback;
 181     wom->dwFlags = dwFlags;
 182     wom->dwClientInstance = lpDesc->dwInstance;
 183     wom->u.out.hOuterWave = (HWAVEOUT)lpDesc->hWave;
 184     wom->avgSpeedOuter = wom->avgSpeedInner = lpDesc->lpFormat->nAvgBytesPerSec;
 185     wom->nSamplesPerSecOuter = wom->nSamplesPerSecInner = lpDesc->lpFormat->nSamplesPerSec;
 186
 187     for (i = ndlo; i < ndhi; i++) {
 188         /* if no ACM stuff is involved, no need to handle callbacks at this
 189          * level, this will be done transparently
 190          */
 191         if (waveOutOpen(&wom->u.out.hInnerWave, i, lpDesc->lpFormat,
 192                         (DWORD_PTR)wodCallback, (DWORD_PTR)wom,
 193                         (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
 194             wom->hAcmStream = 0;
 195             goto found;
 196         }
 197     }
 198
 199     if ((dwFlags & WAVE_FORMAT_DIRECT) == 0) {
 200         WAVEFORMATEX    wfx;
 201
 202         wfx.wFormatTag = WAVE_FORMAT_PCM;
 203         wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
 204         /* try some ACM stuff */
 205
 206 #define TRY(sps,bps)    wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
 207                         switch (res=wodOpenHelper(wom, i, lpDesc, &wfx, dwFlags | WAVE_FORMAT_DIRECT)) { \
 208                             case MMSYSERR_NOERROR: wom->avgSpeedInner = wfx.nAvgBytesPerSec; wom->nSamplesPerSecInner = wfx.nSamplesPerSec; goto found; \
 209                             case WAVERR_BADFORMAT: break; \
 210                             default: goto error; \
 211                         }
 212
 213         if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
 214             /* Format changed so keep sample rate and number of channels
 215              * the same and just change the bit depth
 216              */
 217             for (i = ndlo; i < ndhi; i++) {
 218                 wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
 219                 wfx.nChannels = lpDesc->lpFormat->nChannels;
 220                 TRY(wfx.nSamplesPerSec, 16);
 221                 TRY(wfx.nSamplesPerSec, 8);
 222             }
 223         } else {
 224             /* Our resampling algorithm is quite primitive so first try
 225              * to just change the bit depth and number of channels
 226              */
 227             for (i = ndlo; i < ndhi; i++) {
 228                 wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
 229                 wfx.nChannels = lpDesc->lpFormat->nChannels;
 230                 TRY(wfx.nSamplesPerSec, 16);
 231                 TRY(wfx.nSamplesPerSec, 8);
 232                 wfx.nChannels ^= 3;
 233                 TRY(wfx.nSamplesPerSec, 16);
 234                 TRY(wfx.nSamplesPerSec, 8);
 235             }
 236
 237             for (i = ndlo; i < ndhi; i++) {
 238                 /* first try with same stereo/mono option as source */
 239                 wfx.nChannels = lpDesc->lpFormat->nChannels;
 240                 TRY(96000, 16);
 241                 TRY(48000, 16);
 242                 TRY(44100, 16);
 243                 TRY(22050, 16);
 244                 TRY(11025, 16);
 245
 246                 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
 247                 wfx.nChannels ^= 3;
 248                 TRY(96000, 16);
 249                 TRY(48000, 16);
 250                 TRY(44100, 16);
 251                 TRY(22050, 16);
 252                 TRY(11025, 16);
 253
 254                 /* first try with same stereo/mono option as source */
 255                 wfx.nChannels = lpDesc->lpFormat->nChannels;
 256                 TRY(96000, 8);
 257                 TRY(48000, 8);
 258                 TRY(44100, 8);
 259                 TRY(22050, 8);
 260                 TRY(11025, 8);
 261
 262                 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
 263                 wfx.nChannels ^= 3;
 264                 TRY(96000, 8);
 265                 TRY(48000, 8);
 266                 TRY(44100, 8);
 267                 TRY(22050, 8);
 268                 TRY(11025, 8);
 269             }
 270         }
 271 #undef TRY
 272     }
 273
 274     HeapFree(GetProcessHeap(), 0, wom);
 275     WARN("ret = WAVERR_BADFORMAT\n");
 276     return WAVERR_BADFORMAT;
 277
 278 found:
 279     if (dwFlags & WAVE_FORMAT_QUERY) {
 280         *lpdwUser = 0L;
 281         HeapFree(GetProcessHeap(), 0, wom);
 282     } else {
 283         *lpdwUser = (DWORD_PTR)wom;
 284     }
 285     return MMSYSERR_NOERROR;
 286 error:
 287     HeapFree(GetProcessHeap(), 0, wom);
 288     if (res==ACMERR_NOTPOSSIBLE) {
 289         WARN("ret = WAVERR_BADFORMAT\n");
 290         return WAVERR_BADFORMAT;
 291     }
 292     WARN("ret = 0x%08x\n", res);
 293     return res;
 294 }
 295
 296 static  DWORD   wodClose(WAVEMAPDATA* wom)
 297 {
 298     DWORD ret;
 299
 300     TRACE("(%p)\n", wom);
 301
 302     ret = waveOutClose(wom->u.out.hInnerWave);
 303     if (ret == MMSYSERR_NOERROR) {
 304         if (wom->hAcmStream) {
 305             ret = acmStreamClose(wom->hAcmStream, 0);
 306         }
 307         if (ret == MMSYSERR_NOERROR) {
 308             HeapFree(GetProcessHeap(), 0, wom);
 309         }
 310     }
 311     return ret;
 312 }
 313
 314 static  DWORD   wodWrite(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
 315 {
 316     PACMSTREAMHEADER    ash;
 317     LPWAVEHDR           lpWaveHdrDst;
 318
 319     TRACE("(%p %p %08x)\n", wom, lpWaveHdrSrc, dwParam2);
 320
 321     if (!wom->hAcmStream) {
 322         return waveOutWrite(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
 323     }
 324
 325     lpWaveHdrSrc->dwFlags |= WHDR_INQUEUE;
 326     ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
 327     /* acmStreamConvert will actually check that the new size is less than initial size */
 328     ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
 329     if (acmStreamConvert(wom->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
 330         WARN("acmStreamConvert failed\n");
 331         return MMSYSERR_ERROR;
 332     }
 333
 334     lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
 335     if (ash->cbSrcLength > ash->cbSrcLengthUsed)
 336         FIXME("Not all src buffer has been written, expect bogus sound\n");
 337     else if (ash->cbSrcLength < ash->cbSrcLengthUsed)
 338         ERR("Codec has read more data than it is allowed to\n");
 339
 340     if (ash->cbDstLengthUsed == 0) {
 341         /* something went wrong in decoding */
 342         FIXME("Got 0 length\n");
 343         return MMSYSERR_ERROR;
 344     }
 345     lpWaveHdrDst->dwBufferLength = ash->cbDstLengthUsed;
 346     return waveOutWrite(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
 347 }
 348
 349 static  DWORD   wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
 350 {
 351     PACMSTREAMHEADER    ash;
 352     DWORD               size;
 353     DWORD               dwRet;
 354     LPWAVEHDR           lpWaveHdrDst;
 355
 356     TRACE("(%p %p %08x)\n", wom, lpWaveHdrSrc, dwParam2);
 357
 358     if (!wom->hAcmStream)
 359         return waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
 360
 361     if (acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size, ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR) {
 362         WARN("acmStreamSize failed\n");
 363         return MMSYSERR_ERROR;
 364     }
 365
 366     ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
 367     if (ash == NULL) {
 368         WARN("no memory\n");
 369         return MMSYSERR_NOMEM;
 370     }
 371
 372     ash->cbStruct = sizeof(*ash);
 373     ash->fdwStatus = 0L;
 374     ash->dwUser = (DWORD_PTR)lpWaveHdrSrc;
 375     ash->pbSrc = (LPBYTE)lpWaveHdrSrc->lpData;
 376     ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
 377     /* ash->cbSrcLengthUsed */
 378     ash->dwSrcUser = lpWaveHdrSrc->dwUser; /* FIXME ? */
 379     ash->pbDst = (LPBYTE)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
 380     ash->cbDstLength = size;
 381     /* ash->cbDstLengthUsed */
 382     ash->dwDstUser = 0; /* FIXME ? */
 383     dwRet = acmStreamPrepareHeader(wom->hAcmStream, ash, 0L);
 384     if (dwRet != MMSYSERR_NOERROR) {
 385         WARN("acmStreamPrepareHeader failed\n");
 386         goto errCleanUp;
 387     }
 388
 389     lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
 390     lpWaveHdrDst->lpData = (LPSTR)ash->pbDst;
 391     lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */
 392     lpWaveHdrDst->dwFlags = 0;
 393     lpWaveHdrDst->dwLoops = 0;
 394     dwRet = waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
 395     if (dwRet != MMSYSERR_NOERROR) {
 396         WARN("waveOutPrepareHeader failed\n");
 397         goto errCleanUp;
 398     }
 399
 400     lpWaveHdrSrc->reserved = (DWORD_PTR)ash;
 401     lpWaveHdrSrc->dwFlags = WHDR_PREPARED;
 402     TRACE("=> (0)\n");
 403     return MMSYSERR_NOERROR;
 404 errCleanUp:
 405     TRACE("=> (%d)\n", dwRet);
 406     HeapFree(GetProcessHeap(), 0, ash);
 407     return dwRet;
 408 }
 409
 410 static  DWORD   wodUnprepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
 411 {
 412     PACMSTREAMHEADER    ash;
 413     LPWAVEHDR           lpWaveHdrDst;
 414     DWORD               dwRet1, dwRet2;
 415
 416     TRACE("(%p %p %08x)\n", wom, lpWaveHdrSrc, dwParam2);
 417
 418     if (!wom->hAcmStream) {
 419         return waveOutUnprepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
 420     }
 421     ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
 422     dwRet1 = acmStreamUnprepareHeader(wom->hAcmStream, ash, 0L);
 423
 424     lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
 425     dwRet2 = waveOutUnprepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
 426
 427     HeapFree(GetProcessHeap(), 0, ash);
 428
 429     lpWaveHdrSrc->dwFlags &= ~WHDR_PREPARED;
 430     return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
 431 }
 432
 433 static  DWORD   wodGetPosition(WAVEMAPDATA* wom, LPMMTIME lpTime, DWORD dwParam2)
 434 {
 435     DWORD       val;
 436     MMTIME      timepos;
 437     TRACE("(%p %p %08x)\n", wom, lpTime, dwParam2);
 438
 439     timepos = *lpTime;
 440
 441     /* For TIME_MS, we're going to recalculate using TIME_BYTES */
 442     if (lpTime->wType == TIME_MS)
 443         timepos.wType = TIME_BYTES;
 444
 445     /* This can change timepos.wType if the requested type is not supported */
 446     val = waveOutGetPosition(wom->u.out.hInnerWave, &timepos, dwParam2);
 447
 448     if (timepos.wType == TIME_BYTES)
 449     {
 450         DWORD dwInnerSamplesPerOuter = wom->nSamplesPerSecInner / wom->nSamplesPerSecOuter;
 451         if (dwInnerSamplesPerOuter > 0)
 452         {
 453             DWORD dwInnerBytesPerSample = wom->avgSpeedInner / wom->nSamplesPerSecInner;
 454             DWORD dwInnerBytesPerOuterSample = dwInnerBytesPerSample * dwInnerSamplesPerOuter;
 455             DWORD remainder = 0;
 456
 457             /* If we are up sampling (going from lower sample rate to higher),
 458             **   we need to make a special accommodation for times when we've
 459             **   written a partial output sample.  This happens frequently
 460             **   to us because we use msacm to do our up sampling, and it
 461             **   will up sample on an unaligned basis.
 462             ** For example, if you convert a 2 byte wide 8,000 'outer'
 463             **   buffer to a 2 byte wide 48,000 inner device, you would
 464             **   expect 2 bytes of input to produce 12 bytes of output.
 465             **   Instead, msacm will produce 8 bytes of output.
 466             **   But reporting our position as 1 byte of output is
 467             **   nonsensical; the output buffer position needs to be
 468             **   aligned on outer sample size, and aggressively rounded up.
 469             */
 470             remainder = timepos.u.cb % dwInnerBytesPerOuterSample;
 471             if (remainder > 0)
 472             {
 473                 timepos.u.cb -= remainder;
 474                 timepos.u.cb += dwInnerBytesPerOuterSample;
 475             }
 476         }
 477
 478         lpTime->u.cb = MulDiv(timepos.u.cb, wom->avgSpeedOuter, wom->avgSpeedInner);
 479
 480         /* Once we have the TIME_BYTES right, we can easily convert to TIME_MS */
 481         if (lpTime->wType == TIME_MS)
 482             lpTime->u.ms = MulDiv(lpTime->u.cb, 1000, wom->avgSpeedOuter);
 483         else
 484             lpTime->wType = TIME_BYTES;
 485     }
 486     else if (lpTime->wType == TIME_SAMPLES && timepos.wType == TIME_SAMPLES)
 487         lpTime->u.sample = MulDiv(timepos.u.sample, wom->nSamplesPerSecOuter, wom->nSamplesPerSecInner);
 488     else
 489         /* other time types don't require conversion */
 490         lpTime->u = timepos.u;
 491
 492     return val;
 493 }
 494
 495 static  DWORD   wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSW lpWaveCaps, DWORD dwParam2)
 496 {
 497     static const WCHAR name[] = {'W','i','n','e',' ','w','a','v','e',' ','o','u','t',' ','m','a','p','p','e','r',0};
 498
 499     TRACE("(%04x %p %p %08x)\n",wDevID, wom, lpWaveCaps, dwParam2);
 500
 501     /* if opened low driver, forward message */
 502     if (WAVEMAP_IsData(wom))
 503         return waveOutGetDevCapsW((UINT_PTR)wom->u.out.hInnerWave, lpWaveCaps, dwParam2);
 504     /* else if no drivers, nothing to map so return bad device */
 505     if (waveOutGetNumDevs() == 0) {
 506         WARN("bad device id\n");
 507         return MMSYSERR_BADDEVICEID;
 508     }
 509     /* otherwise, return caps of mapper itself */
 510     if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
 511         WAVEOUTCAPSW woc;
 512         woc.wMid = 0x00FF;
 513         woc.wPid = 0x0001;
 514         woc.vDriverVersion = 0x0332;
 515         lstrcpyW(woc.szPname, name);
 516         woc.dwFormats =
 517             WAVE_FORMAT_96M08 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16 |
 518             WAVE_FORMAT_48M08 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16 |
 519             WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
 520             WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
 521             WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
 522         woc.wChannels = 2;
 523         woc.dwSupport = WAVECAPS_VOLUME | WAVECAPS_LRVOLUME;
 524         memcpy(lpWaveCaps, &woc, min(dwParam2, sizeof(woc)));
 525
 526         return MMSYSERR_NOERROR;
 527     }
 528     ERR("This shouldn't happen\n");
 529     return MMSYSERR_ERROR;
 530 }
 531
 532 static  DWORD   wodGetVolume(UINT wDevID, WAVEMAPDATA* wom, LPDWORD lpVol)
 533 {
 534     TRACE("(%04x %p %p)\n",wDevID, wom, lpVol);
 535
 536     if (WAVEMAP_IsData(wom))
 537         return waveOutGetVolume(wom->u.out.hInnerWave, lpVol);
 538     return MMSYSERR_NOERROR;
 539 }
 540
 541 static  DWORD   wodSetVolume(UINT wDevID, WAVEMAPDATA* wom, DWORD vol)
 542 {
 543     TRACE("(%04x %p %08x)\n",wDevID, wom, vol);
 544
 545     if (WAVEMAP_IsData(wom))
 546         return waveOutSetVolume(wom->u.out.hInnerWave, vol);
 547     return MMSYSERR_NOERROR;
 548 }
 549
 550 static  DWORD   wodPause(WAVEMAPDATA* wom)
 551 {
 552     TRACE("(%p)\n",wom);
 553
 554     return waveOutPause(wom->u.out.hInnerWave);
 555 }
 556
 557 static  DWORD   wodRestart(WAVEMAPDATA* wom)
 558 {
 559     TRACE("(%p)\n",wom);
 560
 561     return waveOutRestart(wom->u.out.hInnerWave);
 562 }
 563
 564 static  DWORD   wodReset(WAVEMAPDATA* wom)
 565 {
 566     TRACE("(%p)\n",wom);
 567
 568     return waveOutReset(wom->u.out.hInnerWave);
 569 }
 570
 571 static  DWORD   wodBreakLoop(WAVEMAPDATA* wom)
 572 {
 573     TRACE("(%p)\n",wom);
 574
 575     return waveOutBreakLoop(wom->u.out.hInnerWave);
 576 }
 577
 578 static  DWORD   wodMapperStatus(WAVEMAPDATA* wom, DWORD flags, LPVOID ptr)
 579 {
 580     UINT        id;
 581     DWORD       ret = MMSYSERR_NOTSUPPORTED;
 582
 583     TRACE("(%p %08x %p)\n",wom, flags, ptr);
 584
 585     switch (flags) {
 586     case WAVEOUT_MAPPER_STATUS_DEVICE:
 587         ret = waveOutGetID(wom->u.out.hInnerWave, &id);
 588         *(LPDWORD)ptr = id;
 589         break;
 590     case WAVEOUT_MAPPER_STATUS_MAPPED:
 591         FIXME("Unsupported flag=%d\n", flags);
 592         *(LPDWORD)ptr = 0; /* FIXME ?? */
 593         break;
 594     case WAVEOUT_MAPPER_STATUS_FORMAT:
 595         FIXME("Unsupported flag=%d\n", flags);
 596         /* ptr points to a WAVEFORMATEX struct - before or after streaming ? */
 597         *(LPDWORD)ptr = 0;
 598         break;
 599     default:
 600         FIXME("Unsupported flag=%d\n", flags);
 601         *(LPDWORD)ptr = 0;
 602         break;
 603     }
 604     return ret;
 605 }
 606
 607 static  DWORD   wodMapperReconfigure(WAVEMAPDATA* wom, DWORD dwParam1, DWORD dwParam2)
 608 {
 609     FIXME("(%p %08x %08x) stub!\n", wom, dwParam1, dwParam2);
 610
 611     return MMSYSERR_NOERROR;
 612 }
 613
 614 /**************************************************************************
 615  *                              wodMessage (MSACM.@)
 616  */
 617 DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 618                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 619 {
 620     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
 621           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 622
 623     switch (wMsg) {
 624     case DRVM_INIT:
 625     case DRVM_EXIT:
 626     case DRVM_ENABLE:
 627     case DRVM_DISABLE:
 628         /* FIXME: Pretend this is supported */
 629         return 0;
 630     case WODM_OPEN:             return wodOpen          ((DWORD_PTR*)dwUser,      (LPWAVEOPENDESC)dwParam1,dwParam2);
 631     case WODM_CLOSE:            return wodClose         ((WAVEMAPDATA*)dwUser);
 632     case WODM_WRITE:            return wodWrite         ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,     dwParam2);
 633     case WODM_PAUSE:            return wodPause         ((WAVEMAPDATA*)dwUser);
 634     case WODM_GETPOS:           return wodGetPosition   ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1,      dwParam2);
 635     case WODM_BREAKLOOP:        return wodBreakLoop     ((WAVEMAPDATA*)dwUser);
 636     case WODM_PREPARE:          return wodPrepare       ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,     dwParam2);
 637     case WODM_UNPREPARE:        return wodUnprepare     ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,     dwParam2);
 638     case WODM_GETDEVCAPS:       return wodGetDevCaps    (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEOUTCAPSW)dwParam1,dwParam2);
 639     case WODM_GETNUMDEVS:       return 1;
 640     case WODM_GETPITCH:         return MMSYSERR_NOTSUPPORTED;
 641     case WODM_SETPITCH:         return MMSYSERR_NOTSUPPORTED;
 642     case WODM_GETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
 643     case WODM_SETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
 644     case WODM_GETVOLUME:        return wodGetVolume     (wDevID, (WAVEMAPDATA*)dwUser, (LPDWORD)dwParam1);
 645     case WODM_SETVOLUME:        return wodSetVolume     (wDevID, (WAVEMAPDATA*)dwUser, dwParam1);
 646     case WODM_RESTART:          return wodRestart       ((WAVEMAPDATA*)dwUser);
 647     case WODM_RESET:            return wodReset         ((WAVEMAPDATA*)dwUser);
 648     case WODM_MAPPER_STATUS:    return wodMapperStatus  ((WAVEMAPDATA*)dwUser, dwParam1, (LPVOID)dwParam2);
 649     case DRVM_MAPPER_RECONFIGURE: return wodMapperReconfigure((WAVEMAPDATA*)dwUser, dwParam1, dwParam2);
 650     /* known but not supported */
 651     case DRV_QUERYDEVICEINTERFACESIZE:
 652     case DRV_QUERYDEVICEINTERFACE:
 653         return MMSYSERR_NOTSUPPORTED;
 654     default:
 655         FIXME("unknown message %d!\n", wMsg);
 656     }
 657     return MMSYSERR_NOTSUPPORTED;
 658 }
 659
 660 /*======================================================================*
 661  *                  WAVE IN part                                        *
 662  *======================================================================*/
 663
 664 static void CALLBACK widCallback(HWAVEIN hWave, UINT uMsg, DWORD_PTR dwInstance,
 665                                  DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 666 {
 667     WAVEMAPDATA* wim = (WAVEMAPDATA*)dwInstance;
 668
 669     TRACE("(%p %u %lx %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
 670
 671     if (!WAVEMAP_IsData(wim)) {
 672         ERR("Bad data\n");
 673         return;
 674     }
 675
 676     if (uMsg != WIM_OPEN && hWave != wim->u.in.hInnerWave)
 677         ERR("Shouldn't happen (%p %p)\n", hWave, wim->u.in.hInnerWave);
 678
 679     switch (uMsg) {
 680     case WIM_OPEN:
 681     case WIM_CLOSE:
 682         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 683         break;
 684     case WIM_DATA:
 685         if (wim->hAcmStream) {
 686             LPWAVEHDR           lpWaveHdrSrc = (LPWAVEHDR)dwParam1;
 687             PACMSTREAMHEADER    ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrSrc - sizeof(ACMSTREAMHEADER));
 688             LPWAVEHDR           lpWaveHdrDst = (LPWAVEHDR)ash->dwUser;
 689
 690             /* convert data just gotten from waveIn into requested format */
 691             if (acmStreamConvert(wim->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
 692                 ERR("ACM conversion failed\n");
 693                 return;
 694             } else {
 695                 TRACE("Converted %d bytes into %d\n", ash->cbSrcLengthUsed, ash->cbDstLengthUsed);
 696             }
 697             /* and setup the wavehdr to return accordingly */
 698             lpWaveHdrDst->dwFlags &= ~WHDR_INQUEUE;
 699             lpWaveHdrDst->dwFlags |= WHDR_DONE;
 700             lpWaveHdrDst->dwBytesRecorded = ash->cbDstLengthUsed;
 701             dwParam1 = (DWORD_PTR)lpWaveHdrDst;
 702         }
 703         break;
 704     default:
 705         ERR("Unknown msg %u\n", uMsg);
 706     }
 707
 708     DriverCallback(wim->dwCallback, HIWORD(wim->dwFlags), (HDRVR)wim->u.in.hOuterWave,
 709                    uMsg, wim->dwClientInstance, dwParam1, dwParam2);
 710 }
 711
 712 static  DWORD   widOpenHelper(WAVEMAPDATA* wim, UINT idx,
 713                               LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
 714                               DWORD dwFlags)
 715 {
 716     DWORD       ret;
 717
 718     TRACE("(%p %04x %p %p %08x)\n", wim, idx, lpDesc, lpwfx, dwFlags);
 719
 720     /* source is always PCM, so the formulas below apply */
 721     lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
 722     lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
 723     if (dwFlags & WAVE_FORMAT_QUERY) {
 724         ret = acmStreamOpen(NULL, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L, ACM_STREAMOPENF_QUERY);
 725     } else {
 726         ret = acmStreamOpen(&wim->hAcmStream, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L, 0L);
 727     }
 728     if (ret == MMSYSERR_NOERROR) {
 729         ret = waveInOpen(&wim->u.in.hInnerWave, idx, lpwfx,
 730                          (DWORD_PTR)widCallback, (DWORD_PTR)wim,
 731                          (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
 732         if (ret != MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY)) {
 733             acmStreamClose(wim->hAcmStream, 0);
 734             wim->hAcmStream = 0;
 735         }
 736     }
 737     TRACE("ret = %08x\n", ret);
 738     return ret;
 739 }
 740
 741 static  DWORD   widOpen(DWORD_PTR *lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
 742 {
 743     UINT                ndlo, ndhi;
 744     UINT                i;
 745     WAVEMAPDATA*        wim = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
 746     DWORD               res;
 747
 748     TRACE("(%p %p %08x)\n", lpdwUser, lpDesc, dwFlags);
 749
 750     if (!wim) {
 751         WARN("no memory\n");
 752         return MMSYSERR_NOMEM;
 753     }
 754
 755     wim->self = wim;
 756     wim->dwCallback = lpDesc->dwCallback;
 757     wim->dwFlags = dwFlags;
 758     wim->dwClientInstance = lpDesc->dwInstance;
 759     wim->u.in.hOuterWave = (HWAVEIN)lpDesc->hWave;
 760
 761     ndhi = waveInGetNumDevs();
 762     if (dwFlags & WAVE_MAPPED) {
 763         if (lpDesc->uMappedDeviceID >= ndhi) return MMSYSERR_INVALPARAM;
 764         ndlo = lpDesc->uMappedDeviceID;
 765         ndhi = ndlo + 1;
 766         dwFlags &= ~WAVE_MAPPED;
 767     } else {
 768         ndlo = 0;
 769     }
 770
 771     wim->avgSpeedOuter = wim->avgSpeedInner = lpDesc->lpFormat->nAvgBytesPerSec;
 772     wim->nSamplesPerSecOuter = wim->nSamplesPerSecInner = lpDesc->lpFormat->nSamplesPerSec;
 773
 774     for (i = ndlo; i < ndhi; i++) {
 775         if (waveInOpen(&wim->u.in.hInnerWave, i, lpDesc->lpFormat,
 776                        (DWORD_PTR)widCallback, (DWORD_PTR)wim,
 777                        (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
 778             wim->hAcmStream = 0;
 779             goto found;
 780         }
 781     }
 782
 783     if ((dwFlags & WAVE_FORMAT_DIRECT) == 0)
 784     {
 785         WAVEFORMATEX    wfx;
 786
 787         wfx.wFormatTag = WAVE_FORMAT_PCM;
 788         wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
 789         /* try some ACM stuff */
 790
 791 #define TRY(sps,bps)    wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
 792                         switch (res=widOpenHelper(wim, i, lpDesc, &wfx, dwFlags | WAVE_FORMAT_DIRECT)) { \
 793                         case MMSYSERR_NOERROR: wim->avgSpeedInner = wfx.nAvgBytesPerSec; wim->nSamplesPerSecInner = wfx.nSamplesPerSec; goto found; \
 794                         case WAVERR_BADFORMAT: break; \
 795                         default: goto error; \
 796                         }
 797
 798         for (i = ndlo; i < ndhi; i++) {
 799             wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
 800             /* first try with same stereo/mono option as source */
 801             wfx.nChannels = lpDesc->lpFormat->nChannels;
 802                         TRY(wfx.nSamplesPerSec, 16);
 803                         TRY(wfx.nSamplesPerSec, 8);
 804                         wfx.nChannels ^= 3;
 805                         TRY(wfx.nSamplesPerSec, 16);
 806                         TRY(wfx.nSamplesPerSec, 8);
 807         }
 808
 809         for (i = ndlo; i < ndhi; i++) {
 810             wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
 811             /* first try with same stereo/mono option as source */
 812             wfx.nChannels = lpDesc->lpFormat->nChannels;
 813             TRY(96000, 16);
 814             TRY(48000, 16);
 815             TRY(44100, 16);
 816             TRY(22050, 16);
 817             TRY(11025, 16);
 818
 819             /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
 820             wfx.nChannels ^= 3;
 821             TRY(96000, 16);
 822             TRY(48000, 16);
 823             TRY(44100, 16);
 824             TRY(22050, 16);
 825             TRY(11025, 16);
 826
 827             /* first try with same stereo/mono option as source */
 828             wfx.nChannels = lpDesc->lpFormat->nChannels;
 829             TRY(96000, 8);
 830             TRY(48000, 8);
 831             TRY(44100, 8);
 832             TRY(22050, 8);
 833             TRY(11025, 8);
 834
 835             /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
 836             wfx.nChannels ^= 3;
 837             TRY(96000, 8);
 838             TRY(48000, 8);
 839             TRY(44100, 8);
 840             TRY(22050, 8);
 841             TRY(11025, 8);
 842         }
 843 #undef TRY
 844     }
 845
 846     HeapFree(GetProcessHeap(), 0, wim);
 847     WARN("ret = WAVERR_BADFORMAT\n");
 848     return WAVERR_BADFORMAT;
 849 found:
 850     if (dwFlags & WAVE_FORMAT_QUERY) {
 851         *lpdwUser = 0L;
 852         HeapFree(GetProcessHeap(), 0, wim);
 853     } else {
 854         *lpdwUser = (DWORD_PTR)wim;
 855     }
 856     TRACE("Ok (stream=%p)\n", wim->hAcmStream);
 857     return MMSYSERR_NOERROR;
 858 error:
 859     HeapFree(GetProcessHeap(), 0, wim);
 860     if (res==ACMERR_NOTPOSSIBLE) {
 861         WARN("ret = WAVERR_BADFORMAT\n");
 862         return WAVERR_BADFORMAT;
 863     }
 864     WARN("ret = 0x%08x\n", res);
 865     return res;
 866 }
 867
 868 static  DWORD   widClose(WAVEMAPDATA* wim)
 869 {
 870     DWORD ret;
 871
 872     TRACE("(%p)\n", wim);
 873
 874     ret = waveInClose(wim->u.in.hInnerWave);
 875     if (ret == MMSYSERR_NOERROR) {
 876         if (wim->hAcmStream) {
 877             ret = acmStreamClose(wim->hAcmStream, 0);
 878         }
 879         if (ret == MMSYSERR_NOERROR) {
 880             HeapFree(GetProcessHeap(), 0, wim);
 881         }
 882     }
 883     return ret;
 884 }
 885
 886 static  DWORD   widAddBuffer(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
 887 {
 888     PACMSTREAMHEADER    ash;
 889     LPWAVEHDR           lpWaveHdrSrc;
 890
 891     TRACE("(%p %p %08x)\n", wim, lpWaveHdrDst, dwParam2);
 892
 893     if (!wim->hAcmStream) {
 894         return waveInAddBuffer(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
 895     }
 896
 897     lpWaveHdrDst->dwFlags |= WHDR_INQUEUE;
 898     ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
 899
 900     lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
 901     return waveInAddBuffer(wim->u.in.hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
 902 }
 903
 904 static  DWORD   widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
 905 {
 906     PACMSTREAMHEADER    ash;
 907     DWORD               size;
 908     DWORD               dwRet;
 909     LPWAVEHDR           lpWaveHdrSrc;
 910
 911     TRACE("(%p %p %08x)\n", wim, lpWaveHdrDst, dwParam2);
 912
 913     if (!wim->hAcmStream) {
 914         return waveInPrepareHeader(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
 915     }
 916     if (acmStreamSize(wim->hAcmStream, lpWaveHdrDst->dwBufferLength, &size,
 917                       ACM_STREAMSIZEF_DESTINATION) != MMSYSERR_NOERROR) {
 918         WARN("acmStreamSize failed\n");
 919         return MMSYSERR_ERROR;
 920     }
 921
 922     ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
 923     if (ash == NULL) {
 924         WARN("no memory\n");
 925         return MMSYSERR_NOMEM;
 926     }
 927
 928     ash->cbStruct = sizeof(*ash);
 929     ash->fdwStatus = 0L;
 930     ash->dwUser = (DWORD_PTR)lpWaveHdrDst;
 931     ash->pbSrc = (LPBYTE)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
 932     ash->cbSrcLength = size;
 933     /* ash->cbSrcLengthUsed */
 934     ash->dwSrcUser = 0L; /* FIXME ? */
 935     ash->pbDst = (LPBYTE)lpWaveHdrDst->lpData;
 936     ash->cbDstLength = lpWaveHdrDst->dwBufferLength;
 937     /* ash->cbDstLengthUsed */
 938     ash->dwDstUser = lpWaveHdrDst->dwUser; /* FIXME ? */
 939     dwRet = acmStreamPrepareHeader(wim->hAcmStream, ash, 0L);
 940     if (dwRet != MMSYSERR_NOERROR) {
 941         WARN("acmStreamPrepareHeader failed\n");
 942         goto errCleanUp;
 943     }
 944
 945     lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
 946     lpWaveHdrSrc->lpData = (LPSTR)ash->pbSrc;
 947     lpWaveHdrSrc->dwBufferLength = size; /* conversion is not done yet */
 948     lpWaveHdrSrc->dwFlags = 0;
 949     lpWaveHdrSrc->dwLoops = 0;
 950     dwRet = waveInPrepareHeader(wim->u.in.hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
 951     if (dwRet != MMSYSERR_NOERROR) {
 952         WARN("waveInPrepareHeader failed\n");
 953         goto errCleanUp;
 954     }
 955
 956     lpWaveHdrDst->reserved = (DWORD_PTR)ash;
 957     lpWaveHdrDst->dwFlags = WHDR_PREPARED;
 958     TRACE("=> (0)\n");
 959     return MMSYSERR_NOERROR;
 960 errCleanUp:
 961     TRACE("=> (%d)\n", dwRet);
 962     HeapFree(GetProcessHeap(), 0, ash);
 963     return dwRet;
 964 }
 965
 966 static  DWORD   widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
 967 {
 968     PACMSTREAMHEADER    ash;
 969     LPWAVEHDR           lpWaveHdrSrc;
 970     DWORD               dwRet1, dwRet2;
 971
 972     TRACE("(%p %p %08x)\n", wim, lpWaveHdrDst, dwParam2);
 973
 974     if (!wim->hAcmStream) {
 975         return waveInUnprepareHeader(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
 976     }
 977     ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
 978     dwRet1 = acmStreamUnprepareHeader(wim->hAcmStream, ash, 0L);
 979
 980     lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
 981     dwRet2 = waveInUnprepareHeader(wim->u.in.hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
 982
 983     HeapFree(GetProcessHeap(), 0, ash);
 984
 985     lpWaveHdrDst->dwFlags &= ~WHDR_PREPARED;
 986     return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
 987 }
 988
 989 static  DWORD   widGetPosition(WAVEMAPDATA* wim, LPMMTIME lpTime, DWORD dwParam2)
 990 {
 991     DWORD       val;
 992     MMTIME      timepos;
 993     TRACE("(%p %p %08x)\n", wim, lpTime, dwParam2);
 994
 995     timepos = *lpTime;
 996
 997     /* For TIME_MS, we're going to recalculate using TIME_BYTES */
 998     if (lpTime->wType == TIME_MS)
 999         timepos.wType = TIME_BYTES;
1000
1001     /* This can change timepos.wType if the requested type is not supported */
1002     val = waveInGetPosition(wim->u.in.hInnerWave, &timepos, dwParam2);
1003
1004     if (timepos.wType == TIME_BYTES)
1005     {
1006         DWORD dwInnerSamplesPerOuter = wim->nSamplesPerSecInner / wim->nSamplesPerSecOuter;
1007         if (dwInnerSamplesPerOuter > 0)
1008         {
1009             DWORD dwInnerBytesPerSample = wim->avgSpeedInner / wim->nSamplesPerSecInner;
1010             DWORD dwInnerBytesPerOuterSample = dwInnerBytesPerSample * dwInnerSamplesPerOuter;
1011             DWORD remainder = 0;
1012
1013             /* If we are up sampling (going from lower sample rate to higher),
1014             **   we need to make a special accommodation for times when we've
1015             **   written a partial output sample.  This happens frequently
1016             **   to us because we use msacm to do our up sampling, and it
1017             **   will up sample on an unaligned basis.
1018             ** For example, if you convert a 2 byte wide 8,000 'outer'
1019             **   buffer to a 2 byte wide 48,000 inner device, you would
1020             **   expect 2 bytes of input to produce 12 bytes of output.
1021             **   Instead, msacm will produce 8 bytes of output.
1022             **   But reporting our position as 1 byte of output is
1023             **   nonsensical; the output buffer position needs to be
1024             **   aligned on outer sample size, and aggressively rounded up.
1025             */
1026             remainder = timepos.u.cb % dwInnerBytesPerOuterSample;
1027             if (remainder > 0)
1028             {
1029                 timepos.u.cb -= remainder;
1030                 timepos.u.cb += dwInnerBytesPerOuterSample;
1031             }
1032         }
1033
1034         lpTime->u.cb = MulDiv(timepos.u.cb, wim->avgSpeedOuter, wim->avgSpeedInner);
1035
1036         /* Once we have the TIME_BYTES right, we can easily convert to TIME_MS */
1037         if (lpTime->wType == TIME_MS)
1038             lpTime->u.ms = MulDiv(lpTime->u.cb, 1000, wim->avgSpeedOuter);
1039         else
1040             lpTime->wType = TIME_BYTES;
1041     }
1042     else if (lpTime->wType == TIME_SAMPLES && timepos.wType == TIME_SAMPLES)
1043         lpTime->u.sample = MulDiv(timepos.u.sample, wim->nSamplesPerSecOuter, wim->nSamplesPerSecInner);
1044     else
1045         /* other time types don't require conversion */
1046         lpTime->u = timepos.u;
1047
1048     return val;
1049 }
1050
1051 static  DWORD   widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSW lpWaveCaps, DWORD dwParam2)
1052 {
1053     TRACE("(%04x, %p %p %08x)\n", wDevID, wim, lpWaveCaps, dwParam2);
1054
1055     /* if opened low driver, forward message */
1056     if (WAVEMAP_IsData(wim))
1057         return waveInGetDevCapsW((UINT_PTR)wim->u.in.hInnerWave, lpWaveCaps, dwParam2);
1058     /* else if no drivers, nothing to map so return bad device */
1059     if (waveInGetNumDevs() == 0) {
1060         WARN("bad device id\n");
1061         return MMSYSERR_BADDEVICEID;
1062     }
1063     /* otherwise, return caps of mapper itself */
1064     if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
1065         WAVEINCAPSW wic;
1066         static const WCHAR init[] = {'W','i','n','e',' ','w','a','v','e',' ','i','n',' ','m','a','p','p','e','r',0};
1067         wic.wMid = 0x00FF;
1068         wic.wPid = 0x0001;
1069         wic.vDriverVersion = 0x0001;
1070         strcpyW(wic.szPname, init);
1071         wic.dwFormats =
1072             WAVE_FORMAT_96M08 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16 |
1073             WAVE_FORMAT_48M08 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16 |
1074             WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
1075             WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
1076             WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
1077         wic.wChannels = 2;
1078         memcpy(lpWaveCaps, &wic, min(dwParam2, sizeof(wic)));
1079
1080         return MMSYSERR_NOERROR;
1081     }
1082     ERR("This shouldn't happen\n");
1083     return MMSYSERR_ERROR;
1084 }
1085
1086 static  DWORD   widStop(WAVEMAPDATA* wim)
1087 {
1088     TRACE("(%p)\n", wim);
1089
1090     return waveInStop(wim->u.in.hInnerWave);
1091 }
1092
1093 static  DWORD   widStart(WAVEMAPDATA* wim)
1094 {
1095     TRACE("(%p)\n", wim);
1096
1097     return waveInStart(wim->u.in.hInnerWave);
1098 }
1099
1100 static  DWORD   widReset(WAVEMAPDATA* wim)
1101 {
1102     TRACE("(%p)\n", wim);
1103
1104     return waveInReset(wim->u.in.hInnerWave);
1105 }
1106
1107 static  DWORD   widMapperStatus(WAVEMAPDATA* wim, DWORD flags, LPVOID ptr)
1108 {
1109     UINT        id;
1110     DWORD       ret = MMSYSERR_NOTSUPPORTED;
1111
1112     TRACE("(%p %08x %p)\n", wim, flags, ptr);
1113
1114     switch (flags) {
1115     case WAVEIN_MAPPER_STATUS_DEVICE:
1116         ret = waveInGetID(wim->u.in.hInnerWave, &id);
1117         *(LPDWORD)ptr = id;
1118         break;
1119     case WAVEIN_MAPPER_STATUS_MAPPED:
1120         FIXME("Unsupported yet flag=%d\n", flags);
1121         *(LPDWORD)ptr = 0; /* FIXME ?? */
1122         break;
1123     case WAVEIN_MAPPER_STATUS_FORMAT:
1124         FIXME("Unsupported flag=%d\n", flags);
1125         /* ptr points to a WAVEFORMATEX struct  - before or after streaming ? */
1126         *(LPDWORD)ptr = 0; /* FIXME ?? */
1127         break;
1128     default:
1129         FIXME("Unsupported flag=%d\n", flags);
1130         *(LPDWORD)ptr = 0;
1131         break;
1132     }
1133     return ret;
1134 }
1135
1136 static  DWORD   widMapperReconfigure(WAVEMAPDATA* wim, DWORD dwParam1, DWORD dwParam2)
1137 {
1138     FIXME("(%p %08x %08x) stub!\n", wim, dwParam1, dwParam2);
1139
1140     return MMSYSERR_NOERROR;
1141 }
1142
1143 /**************************************************************************
1144  *                              widMessage (MSACM.@)
1145  */
1146 DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD_PTR dwUser,
1147                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1148 {
1149     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
1150           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1151
1152     switch (wMsg) {
1153     case DRVM_INIT:
1154     case DRVM_EXIT:
1155     case DRVM_ENABLE:
1156     case DRVM_DISABLE:
1157         /* FIXME: Pretend this is supported */
1158         return 0;
1159
1160     case WIDM_OPEN:             return widOpen          ((DWORD_PTR*)dwUser,     (LPWAVEOPENDESC)dwParam1, dwParam2);
1161     case WIDM_CLOSE:            return widClose         ((WAVEMAPDATA*)dwUser);
1162
1163     case WIDM_ADDBUFFER:        return widAddBuffer     ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,     dwParam2);
1164     case WIDM_PREPARE:          return widPrepare       ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,     dwParam2);
1165     case WIDM_UNPREPARE:        return widUnprepare     ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,     dwParam2);
1166     case WIDM_GETDEVCAPS:       return widGetDevCaps    (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEINCAPSW)dwParam1, dwParam2);
1167     case WIDM_GETNUMDEVS:       return 1;
1168     case WIDM_GETPOS:           return widGetPosition   ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1,      dwParam2);
1169     case WIDM_RESET:            return widReset         ((WAVEMAPDATA*)dwUser);
1170     case WIDM_START:            return widStart         ((WAVEMAPDATA*)dwUser);
1171     case WIDM_STOP:             return widStop          ((WAVEMAPDATA*)dwUser);
1172     case WIDM_MAPPER_STATUS:    return widMapperStatus  ((WAVEMAPDATA*)dwUser, dwParam1, (LPVOID)dwParam2);
1173     case DRVM_MAPPER_RECONFIGURE: return widMapperReconfigure((WAVEMAPDATA*)dwUser, dwParam1, dwParam2);
1174     /* known but not supported */
1175     case DRV_QUERYDEVICEINTERFACESIZE:
1176     case DRV_QUERYDEVICEINTERFACE:
1177         return MMSYSERR_NOTSUPPORTED;
1178     default:
1179         FIXME("unknown message %u!\n", wMsg);
1180     }
1181     return MMSYSERR_NOTSUPPORTED;
1182 }
1183
1184 /*======================================================================*
1185  *                  Driver part                                         *
1186  *======================================================================*/
1187
1188 static  struct WINE_WAVEMAP* oss = NULL;
1189
1190 /**************************************************************************
1191  *                              WAVEMAP_drvOpen                 [internal]
1192  */
1193 static LRESULT WAVEMAP_drvOpen(LPSTR str)
1194 {
1195     TRACE("(%p)\n", str);
1196
1197     if (oss)
1198         return 0;
1199
1200     /* I know, this is ugly, but who cares... */
1201     oss = (struct WINE_WAVEMAP*)1;
1202     return 1;
1203 }
1204
1205 /**************************************************************************
1206  *                              WAVEMAP_drvClose                [internal]
1207  */
1208 static LRESULT WAVEMAP_drvClose(DWORD_PTR dwDevID)
1209 {
1210     TRACE("(%08lx)\n", dwDevID);
1211
1212     if (oss) {
1213         oss = NULL;
1214         return 1;
1215     }
1216     return 0;
1217 }
1218
1219 /**************************************************************************
1220  *                              DriverProc (MSACM.@)
1221  */
1222 LRESULT CALLBACK WAVEMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1223                                     LPARAM dwParam1, LPARAM dwParam2)
1224 {
1225     TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1226           dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1227
1228     switch(wMsg) {
1229     case DRV_LOAD:              return 1;
1230     case DRV_FREE:              return 1;
1231     case DRV_OPEN:              return WAVEMAP_drvOpen((LPSTR)dwParam1);
1232     case DRV_CLOSE:             return WAVEMAP_drvClose(dwDevID);
1233     case DRV_ENABLE:            return 1;
1234     case DRV_DISABLE:           return 1;
1235     case DRV_QUERYCONFIGURE:    return 1;
1236     case DRV_CONFIGURE:         MessageBoxA(0, "WAVEMAP MultiMedia Driver !", "Wave mapper Driver", MB_OK);     return 1;
1237     case DRV_INSTALL:           return DRVCNF_RESTART;
1238     case DRV_REMOVE:            return DRVCNF_RESTART;
1239     default:
1240         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1241     }
1242 }