dlls/msgsm32.acm/msgsm32.c

   1 /*
   2  * GSM 06.10 codec handling
   3  * Copyright (C) 2009 Maarten Lankhorst
   4  *
   5  * Based on msg711.acm
   6  * Copyright (C) 2002 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include <wine/port.h>
  25
  26 #include <assert.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29
  30 #ifdef HAVE_GSM_GSM_H
  31 #include <gsm/gsm.h>
  32 #elif defined(HAVE_GSM_H)
  33 #include <gsm.h>
  34 #endif
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "wingdi.h"
  39 #include "winuser.h"
  40 #include "winnls.h"
  41 #include "mmsystem.h"
  42 #include "mmreg.h"
  43 #include "msacm.h"
  44 #include "msacmdrv.h"
  45 #include "wine/library.h"
  46 #include "wine/debug.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(gsm);
  49
  50 #ifdef SONAME_LIBGSM
  51
  52 static void *libgsm_handle;
  53 #define FUNCPTR(f) static typeof(f) * p##f
  54 FUNCPTR(gsm_create);
  55 FUNCPTR(gsm_destroy);
  56 FUNCPTR(gsm_option);
  57 FUNCPTR(gsm_encode);
  58 FUNCPTR(gsm_decode);
  59
  60 #define LOAD_FUNCPTR(f) \
  61     if((p##f = wine_dlsym(libgsm_handle, #f, NULL, 0)) == NULL) { \
  62         wine_dlclose(libgsm_handle, NULL, 0); \
  63         libgsm_handle = NULL; \
  64         return FALSE; \
  65     }
  66
  67 /***********************************************************************
  68  *           GSM_drvLoad
  69  */
  70 static BOOL GSM_drvLoad(void)
  71 {
  72     char error[128];
  73
  74     libgsm_handle = wine_dlopen(SONAME_LIBGSM, RTLD_NOW, error, sizeof(error));
  75     if (libgsm_handle)
  76     {
  77         LOAD_FUNCPTR(gsm_create);
  78         LOAD_FUNCPTR(gsm_destroy);
  79         LOAD_FUNCPTR(gsm_option);
  80         LOAD_FUNCPTR(gsm_encode);
  81         LOAD_FUNCPTR(gsm_decode);
  82         return TRUE;
  83     }
  84     else
  85     {
  86         ERR("Couldn't load " SONAME_LIBGSM ": %s\n", error);
  87         return FALSE;
  88     }
  89 }
  90
  91 /***********************************************************************
  92  *           GSM_drvFree
  93  */
  94 static LRESULT GSM_drvFree(void)
  95 {
  96     if (libgsm_handle)
  97         wine_dlclose(libgsm_handle, NULL, 0);
  98     return 1;
  99 }
 100
 101 #else
 102
 103 static LRESULT GSM_drvFree(void)
 104 {
 105     return 1;
 106 }
 107
 108 #endif
 109
 110 /***********************************************************************
 111  *           GSM_DriverDetails
 112  *
 113  */
 114 static  LRESULT GSM_DriverDetails(PACMDRIVERDETAILSW add)
 115 {
 116     add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
 117     add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
 118     /* Details found from probing native msgsm32.acm */
 119     add->wMid = MM_MICROSOFT;
 120     add->wPid = MM_MSFT_ACM_GSM610;
 121     add->vdwACM = 0x3320000;
 122     add->vdwDriver = 0x4000000;
 123     add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
 124     add->cFormatTags = 2;
 125     add->cFilterTags = 0;
 126     add->hicon = NULL;
 127     MultiByteToWideChar( CP_ACP, 0, "Microsoft GSM 6.10", -1,
 128                          add->szShortName, ARRAY_SIZE( add->szShortName ));
 129     MultiByteToWideChar( CP_ACP, 0, "Wine GSM 6.10 libgsm codec", -1,
 130                          add->szLongName, ARRAY_SIZE( add->szLongName ));
 131     MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
 132                          add->szCopyright, ARRAY_SIZE( add->szCopyright ));
 133     MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
 134                          add->szLicensing, ARRAY_SIZE( add->szLicensing ));
 135     add->szFeatures[0] = 0;
 136     return MMSYSERR_NOERROR;
 137 }
 138
 139 /* Validate a WAVEFORMATEX structure */
 140 static BOOL GSM_FormatValidate(const WAVEFORMATEX *wfx)
 141 {
 142     if (wfx->nChannels != 1)
 143         return FALSE;
 144
 145     switch (wfx->wFormatTag)
 146     {
 147     case WAVE_FORMAT_PCM:
 148         if (wfx->wBitsPerSample != 16)
 149         {
 150             WARN("PCM wBitsPerSample %u\n", wfx->wBitsPerSample);
 151             return FALSE;
 152         }
 153         if (wfx->nBlockAlign != 2)
 154         {
 155             WARN("PCM nBlockAlign %u\n", wfx->nBlockAlign);
 156             return FALSE;
 157         }
 158         if (wfx->nAvgBytesPerSec != wfx->nBlockAlign * wfx->nSamplesPerSec)
 159         {
 160             WARN("PCM nAvgBytesPerSec %u/%u\n",
 161                  wfx->nAvgBytesPerSec,
 162                  wfx->nBlockAlign * wfx->nSamplesPerSec);
 163             return FALSE;
 164         }
 165         return TRUE;
 166     case WAVE_FORMAT_GSM610:
 167         if (wfx->cbSize < sizeof(WORD))
 168         {
 169             WARN("GSM cbSize %u\n", wfx->cbSize);
 170             return FALSE;
 171         }
 172         if (wfx->wBitsPerSample != 0)
 173         {
 174             WARN("GSM wBitsPerSample %u\n", wfx->wBitsPerSample);
 175             return FALSE;
 176         }
 177         if (wfx->nBlockAlign != 65)
 178         {
 179             WARN("GSM nBlockAlign %u\n", wfx->nBlockAlign);
 180             return FALSE;
 181         }
 182         if (((const GSM610WAVEFORMAT*)wfx)->wSamplesPerBlock != 320)
 183         {
 184             WARN("GSM wSamplesPerBlock %u\n",
 185                  ((const GSM610WAVEFORMAT*)wfx)->wSamplesPerBlock);
 186             return FALSE;
 187         }
 188         if (wfx->nAvgBytesPerSec != wfx->nSamplesPerSec * 65 / 320)
 189         {
 190             WARN("GSM nAvgBytesPerSec %d / %d\n",
 191                  wfx->nAvgBytesPerSec, wfx->nSamplesPerSec * 65 / 320);
 192             return FALSE;
 193         }
 194         return TRUE;
 195     default:
 196         return FALSE;
 197     }
 198     return FALSE;
 199 }
 200
 201 static const DWORD gsm_rates[] = { 8000, 11025, 22050, 44100, 48000, 96000 };
 202
 203 /***********************************************************************
 204  *           GSM_FormatTagDetails
 205  *
 206  */
 207 static  LRESULT GSM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
 208 {
 209     static const WCHAR szPcm[]={'P','C','M',0};
 210     static const WCHAR szGsm[]={'G','S','M',' ','6','.','1','0',0};
 211
 212     switch (dwQuery)
 213     {
 214     case ACM_FORMATTAGDETAILSF_INDEX:
 215         if (aftd->dwFormatTagIndex > 1) return ACMERR_NOTPOSSIBLE;
 216         break;
 217     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
 218         if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
 219         {
 220             aftd->dwFormatTagIndex = 1;
 221             break;
 222         }
 223         /* fall through */
 224     case ACM_FORMATTAGDETAILSF_FORMATTAG:
 225         switch (aftd->dwFormatTag)
 226         {
 227         case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break;
 228         case WAVE_FORMAT_GSM610: aftd->dwFormatTagIndex = 1; break;
 229         default: return ACMERR_NOTPOSSIBLE;
 230         }
 231         break;
 232     default:
 233         WARN("Unsupported query %08x\n", dwQuery);
 234         return MMSYSERR_NOTSUPPORTED;
 235     }
 236
 237     aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
 238     switch (aftd->dwFormatTagIndex)
 239     {
 240     case 0:
 241         aftd->dwFormatTag = WAVE_FORMAT_PCM;
 242         aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
 243         aftd->cStandardFormats = ARRAY_SIZE(gsm_rates);
 244         lstrcpyW(aftd->szFormatTag, szPcm);
 245         break;
 246     case 1:
 247         aftd->dwFormatTag = WAVE_FORMAT_GSM610;
 248         aftd->cbFormatSize = sizeof(GSM610WAVEFORMAT);
 249         aftd->cStandardFormats = ARRAY_SIZE(gsm_rates);
 250         lstrcpyW(aftd->szFormatTag, szGsm);
 251         break;
 252     }
 253     return MMSYSERR_NOERROR;
 254 }
 255
 256 /***********************************************************************
 257  *           GSM_FormatDetails
 258  *
 259  */
 260 static  LRESULT GSM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
 261 {
 262     switch (dwQuery)
 263     {
 264     case ACM_FORMATDETAILSF_FORMAT:
 265         if (!GSM_FormatValidate(afd->pwfx)) return ACMERR_NOTPOSSIBLE;
 266         break;
 267     case ACM_FORMATDETAILSF_INDEX:
 268         afd->pwfx->wFormatTag = afd->dwFormatTag;
 269         switch (afd->dwFormatTag)
 270         {
 271         case WAVE_FORMAT_PCM:
 272             if (afd->dwFormatIndex >= ARRAY_SIZE(gsm_rates)) return ACMERR_NOTPOSSIBLE;
 273             afd->pwfx->nChannels = 1;
 274             afd->pwfx->nSamplesPerSec = gsm_rates[afd->dwFormatIndex];
 275             afd->pwfx->wBitsPerSample = 16;
 276             afd->pwfx->nBlockAlign = 2;
 277             afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
 278             break;
 279         case WAVE_FORMAT_GSM610:
 280             if (afd->dwFormatIndex >= ARRAY_SIZE(gsm_rates)) return ACMERR_NOTPOSSIBLE;
 281             afd->pwfx->nChannels = 1;
 282             afd->pwfx->nSamplesPerSec = gsm_rates[afd->dwFormatIndex];
 283             afd->pwfx->wBitsPerSample = 0;
 284             afd->pwfx->nBlockAlign = 65;
 285             afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * 65 / 320;
 286             afd->pwfx->cbSize = sizeof(WORD);
 287             ((GSM610WAVEFORMAT*)afd->pwfx)->wSamplesPerBlock = 320;
 288             break;
 289         default:
 290             WARN("Unsupported tag %08x\n", afd->dwFormatTag);
 291             return MMSYSERR_INVALPARAM;
 292         }
 293         break;
 294     default:
 295         WARN("Unsupported query %08x\n", dwQuery);
 296         return MMSYSERR_NOTSUPPORTED;
 297     }
 298     afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
 299     afd->szFormat[0] = 0; /* let MSACM format this for us... */
 300
 301     return MMSYSERR_NOERROR;
 302 }
 303
 304 /***********************************************************************
 305  *           GSM_FormatSuggest
 306  *
 307  */
 308 static  LRESULT GSM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
 309 {
 310     /* some tests ... */
 311     if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
 312         adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
 313         !GSM_FormatValidate(adfs->pwfxSrc)) return ACMERR_NOTPOSSIBLE;
 314     /* FIXME: should do those tests against the real size (according to format tag */
 315
 316     /* If no suggestion for destination, then copy source value */
 317     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS))
 318         adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
 319     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC))
 320         adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
 321
 322     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE))
 323     {
 324         if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
 325             adfs->pwfxDst->wBitsPerSample = 0;
 326         else
 327             adfs->pwfxDst->wBitsPerSample = 16;
 328     }
 329     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
 330     {
 331         switch (adfs->pwfxSrc->wFormatTag)
 332         {
 333         case WAVE_FORMAT_PCM: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_GSM610; break;
 334         case WAVE_FORMAT_GSM610: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break;
 335         }
 336     }
 337
 338     /* recompute other values */
 339     switch (adfs->pwfxDst->wFormatTag)
 340     {
 341     case WAVE_FORMAT_PCM:
 342         adfs->pwfxDst->nBlockAlign = 2;
 343         adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * 2;
 344         break;
 345     case WAVE_FORMAT_GSM610:
 346         if (adfs->pwfxDst->cbSize < sizeof(WORD))
 347             return ACMERR_NOTPOSSIBLE;
 348         adfs->pwfxDst->nBlockAlign = 65;
 349         adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * 65 / 320;
 350         ((GSM610WAVEFORMAT*)adfs->pwfxDst)->wSamplesPerBlock = 320;
 351         break;
 352     default:
 353         return ACMERR_NOTPOSSIBLE;
 354     }
 355
 356     /* check if result is ok */
 357     if (!GSM_FormatValidate(adfs->pwfxDst)) return ACMERR_NOTPOSSIBLE;
 358     return MMSYSERR_NOERROR;
 359 }
 360
 361 #ifdef SONAME_LIBGSM
 362 /***********************************************************************
 363  *           GSM_StreamOpen
 364  *
 365  */
 366 static  LRESULT GSM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
 367 {
 368     int used = 1;
 369     gsm r;
 370     if (!GSM_FormatValidate(adsi->pwfxSrc) || !GSM_FormatValidate(adsi->pwfxDst))
 371         return MMSYSERR_NOTSUPPORTED;
 372
 373     if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec)
 374         return MMSYSERR_NOTSUPPORTED;
 375
 376     if (!GSM_drvLoad()) return MMSYSERR_NOTSUPPORTED;
 377
 378     r = pgsm_create();
 379     if (!r)
 380         return MMSYSERR_NOMEM;
 381     if (pgsm_option(r, GSM_OPT_WAV49, &used) < 0)
 382     {
 383         FIXME("Your libgsm library doesn't support GSM_OPT_WAV49\n");
 384         FIXME("Please recompile libgsm with WAV49 support\n");
 385         pgsm_destroy(r);
 386         return MMSYSERR_NOTSUPPORTED;
 387     }
 388     adsi->dwDriver = (DWORD_PTR)r;
 389     return MMSYSERR_NOERROR;
 390 }
 391
 392 /***********************************************************************
 393  *           GSM_StreamClose
 394  *
 395  */
 396 static  LRESULT GSM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
 397 {
 398     pgsm_destroy((gsm)adsi->dwDriver);
 399     return MMSYSERR_NOERROR;
 400 }
 401
 402 /***********************************************************************
 403  *           GSM_StreamSize
 404  *
 405  */
 406 static  LRESULT GSM_StreamSize(const ACMDRVSTREAMINSTANCE *adsi, PACMDRVSTREAMSIZE adss)
 407 {
 408     switch (adss->fdwSize)
 409     {
 410     case ACM_STREAMSIZEF_DESTINATION:
 411         /* cbDstLength => cbSrcLength */
 412         if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
 413              adsi->pwfxDst->wFormatTag == WAVE_FORMAT_GSM610)
 414         {
 415             adss->cbSrcLength = adss->cbDstLength / 65 * 640;
 416         }
 417         else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_GSM610 &&
 418                  adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
 419         {
 420             adss->cbSrcLength = adss->cbDstLength / 640 * 65;
 421         }
 422         else
 423         {
 424             return MMSYSERR_NOTSUPPORTED;
 425         }
 426         return MMSYSERR_NOERROR;
 427     case ACM_STREAMSIZEF_SOURCE:
 428         /* cbSrcLength => cbDstLength */
 429         if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
 430              adsi->pwfxDst->wFormatTag == WAVE_FORMAT_GSM610)
 431         {
 432             adss->cbDstLength = (adss->cbSrcLength + 639) / 640 * 65;
 433         }
 434         else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_GSM610 &&
 435                  adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
 436         {
 437             adss->cbDstLength = adss->cbSrcLength / 65 * 640;
 438         }
 439         else
 440         {
 441             return MMSYSERR_NOTSUPPORTED;
 442         }
 443         return MMSYSERR_NOERROR;
 444     default:
 445         WARN("Unsupported query %08x\n", adss->fdwSize);
 446         return MMSYSERR_NOTSUPPORTED;
 447     }
 448 }
 449
 450 /***********************************************************************
 451  *           GSM_StreamConvert
 452  *
 453  */
 454 static LRESULT GSM_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
 455 {
 456     gsm r = (gsm)adsi->dwDriver;
 457     DWORD nsrc = 0;
 458     DWORD ndst = 0;
 459     BYTE *src = adsh->pbSrc;
 460     BYTE *dst = adsh->pbDst;
 461     int odd = 0;
 462
 463     if (adsh->fdwConvert &
 464         ~(ACM_STREAMCONVERTF_BLOCKALIGN|
 465           ACM_STREAMCONVERTF_END|
 466           ACM_STREAMCONVERTF_START))
 467     {
 468         FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert);
 469     }
 470
 471     /* Reset the index to 0, just to be sure */
 472     pgsm_option(r, GSM_OPT_FRAME_INDEX, &odd);
 473
 474     /* The native ms codec writes 65 bytes, and this requires 2 libgsm calls.
 475      * First 32 bytes are written, or 33 bytes read
 476      * Second 33 bytes are written, or 32 bytes read
 477      */
 478
 479     /* Decode */
 480     if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_GSM610)
 481     {
 482         if (adsh->cbSrcLength / 65 * 640 > adsh->cbDstLength)
 483         {
 484              return ACMERR_NOTPOSSIBLE;
 485         }
 486
 487         while (nsrc + 65 <= adsh->cbSrcLength)
 488         {
 489             /* Decode data */
 490             if (pgsm_decode(r, src + nsrc, (gsm_signal*)(dst + ndst)) < 0)
 491                 FIXME("Couldn't decode data\n");
 492             ndst += 320;
 493             nsrc += 33;
 494
 495             if (pgsm_decode(r, src + nsrc, (gsm_signal*)(dst + ndst)) < 0)
 496                 FIXME("Couldn't decode data\n");
 497             ndst += 320;
 498             nsrc += 32;
 499         }
 500     }
 501     else
 502     {
 503         /* Testing a little seems to reveal that despite being able to fit
 504          * inside the buffer if ACM_STREAMCONVERTF_BLOCKALIGN is set
 505          * it still rounds up
 506          */
 507         if ((adsh->cbSrcLength + 639) / 640 * 65 > adsh->cbDstLength)
 508         {
 509             return ACMERR_NOTPOSSIBLE;
 510         }
 511
 512         /* The packing algorithm writes 32 bytes, then 33 bytes,
 513          * and it seems to pad to align to 65 bytes always
 514          * adding extra data where necessary
 515          */
 516         while (nsrc + 640 <= adsh->cbSrcLength)
 517         {
 518             /* Encode data */
 519             pgsm_encode(r, (gsm_signal*)(src+nsrc), dst+ndst);
 520             nsrc += 320;
 521             ndst += 32;
 522             pgsm_encode(r, (gsm_signal*)(src+nsrc), dst+ndst);
 523             nsrc += 320;
 524             ndst += 33;
 525         }
 526
 527         /* If ACM_STREAMCONVERTF_BLOCKALIGN isn't set pad with zeros */
 528         if (!(adsh->fdwConvert & ACM_STREAMCONVERTF_BLOCKALIGN) &&
 529             nsrc < adsh->cbSrcLength)
 530         {
 531             char emptiness[320];
 532             int todo = adsh->cbSrcLength - nsrc;
 533
 534             if (todo > 320)
 535             {
 536                 pgsm_encode(r, (gsm_signal*)(src+nsrc), dst+ndst);
 537                 ndst += 32;
 538                 todo -= 320;
 539                 nsrc += 320;
 540
 541                 memcpy(emptiness, src+nsrc, todo);
 542                 memset(emptiness + todo, 0, 320 - todo);
 543                 pgsm_encode(r, (gsm_signal*)emptiness, dst+ndst);
 544                 ndst += 33;
 545             }
 546             else
 547             {
 548                 memcpy(emptiness, src+nsrc, todo);
 549                 memset(emptiness + todo, 0, 320 - todo);
 550                 pgsm_encode(r, (gsm_signal*)emptiness, dst+ndst);
 551                 ndst += 32;
 552
 553                 memset(emptiness, 0, todo);
 554                 pgsm_encode(r, (gsm_signal*)emptiness, dst+ndst);
 555                 ndst += 33;
 556             }
 557             nsrc = adsh->cbSrcLength;
 558         }
 559     }
 560
 561     adsh->cbSrcLengthUsed = nsrc;
 562     adsh->cbDstLengthUsed = ndst;
 563     TRACE("%d(%d) -> %d(%d)\n", nsrc, adsh->cbSrcLength, ndst, adsh->cbDstLength);
 564     return MMSYSERR_NOERROR;
 565 }
 566
 567 #endif
 568
 569 /**************************************************************************
 570  *                      GSM_DriverProc                  [exported]
 571  */
 572 LRESULT CALLBACK GSM_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 573                                          LPARAM dwParam1, LPARAM dwParam2)
 574 {
 575     TRACE("(%08lx %p %04x %08lx %08lx);\n",
 576           dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 577
 578     switch (wMsg)
 579     {
 580     case DRV_LOAD:              return 1;
 581     case DRV_FREE:              return GSM_drvFree();
 582     case DRV_OPEN:              return 1;
 583     case DRV_CLOSE:             return 1;
 584     case DRV_ENABLE:            return 1;
 585     case DRV_DISABLE:           return 1;
 586     case DRV_QUERYCONFIGURE:    return 1;
 587     case DRV_CONFIGURE:         MessageBoxA(0, "GSM 06.10 codec", "Wine Driver", MB_OK); return 1;
 588     case DRV_INSTALL:           return DRVCNF_RESTART;
 589     case DRV_REMOVE:            return DRVCNF_RESTART;
 590
 591     case ACMDM_DRIVER_NOTIFY:
 592         /* no caching from other ACM drivers is done so far */
 593         return MMSYSERR_NOERROR;
 594
 595     case ACMDM_DRIVER_DETAILS:
 596         return GSM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
 597
 598     case ACMDM_FORMATTAG_DETAILS:
 599         return GSM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
 600
 601     case ACMDM_FORMAT_DETAILS:
 602         return GSM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
 603
 604     case ACMDM_FORMAT_SUGGEST:
 605         return GSM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
 606
 607 #ifdef SONAME_LIBGSM
 608     case ACMDM_STREAM_OPEN:
 609         return GSM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
 610
 611     case ACMDM_STREAM_CLOSE:
 612         return GSM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
 613
 614     case ACMDM_STREAM_SIZE:
 615         return GSM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
 616
 617     case ACMDM_STREAM_CONVERT:
 618         return GSM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
 619 #else
 620     case ACMDM_STREAM_OPEN: WARN("libgsm support not compiled in!\n");
 621     case ACMDM_STREAM_CLOSE:
 622     case ACMDM_STREAM_SIZE:
 623     case ACMDM_STREAM_CONVERT:
 624         return MMSYSERR_NOTSUPPORTED;
 625 #endif
 626
 627     case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
 628     case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
 629         /* this converter is not a hardware driver */
 630     case ACMDM_FILTERTAG_DETAILS:
 631     case ACMDM_FILTER_DETAILS:
 632         /* this converter is not a filter */
 633     case ACMDM_STREAM_RESET:
 634         /* only needed for asynchronous driver... we aren't, so just say it */
 635         return MMSYSERR_NOTSUPPORTED;
 636     case ACMDM_STREAM_PREPARE:
 637     case ACMDM_STREAM_UNPREPARE:
 638         /* nothing special to do here... so don't do anything */
 639         return MMSYSERR_NOERROR;
 640
 641     default:
 642         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 643     }
 644 }