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, sizeof(add->szShortName)/sizeof(WCHAR) ); 129 MultiByteToWideChar( CP_ACP, 0, "Wine GSM 6.10 libgsm codec", -1, 130 add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) ); 131 MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1, 132 add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) ); 133 MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1, 134 add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) ); 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 #define NUM_RATES (sizeof(gsm_rates)/sizeof(*gsm_rates)) 203 204 /*********************************************************************** 205 * GSM_FormatTagDetails 206 * 207 */ 208 static LRESULT GSM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery) 209 { 210 static const WCHAR szPcm[]={'P','C','M',0}; 211 static const WCHAR szGsm[]={'G','S','M',' ','6','.','1','0',0}; 212 213 switch (dwQuery) 214 { 215 case ACM_FORMATTAGDETAILSF_INDEX: 216 if (aftd->dwFormatTagIndex > 1) return ACMERR_NOTPOSSIBLE; 217 break; 218 case ACM_FORMATTAGDETAILSF_LARGESTSIZE: 219 if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN) 220 { 221 aftd->dwFormatTagIndex = 1; 222 break; 223 } 224 /* fall through */ 225 case ACM_FORMATTAGDETAILSF_FORMATTAG: 226 switch (aftd->dwFormatTag) 227 { 228 case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break; 229 case WAVE_FORMAT_GSM610: aftd->dwFormatTagIndex = 1; break; 230 default: return ACMERR_NOTPOSSIBLE; 231 } 232 break; 233 default: 234 WARN("Unsupported query %08x\n", dwQuery); 235 return MMSYSERR_NOTSUPPORTED; 236 } 237 238 aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC; 239 switch (aftd->dwFormatTagIndex) 240 { 241 case 0: 242 aftd->dwFormatTag = WAVE_FORMAT_PCM; 243 aftd->cbFormatSize = sizeof(PCMWAVEFORMAT); 244 aftd->cStandardFormats = NUM_RATES; 245 lstrcpyW(aftd->szFormatTag, szPcm); 246 break; 247 case 1: 248 aftd->dwFormatTag = WAVE_FORMAT_GSM610; 249 aftd->cbFormatSize = sizeof(GSM610WAVEFORMAT); 250 aftd->cStandardFormats = NUM_RATES; 251 lstrcpyW(aftd->szFormatTag, szGsm); 252 break; 253 } 254 return MMSYSERR_NOERROR; 255 } 256 257 /*********************************************************************** 258 * GSM_FormatDetails 259 * 260 */ 261 static LRESULT GSM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery) 262 { 263 switch (dwQuery) 264 { 265 case ACM_FORMATDETAILSF_FORMAT: 266 if (!GSM_FormatValidate(afd->pwfx)) return ACMERR_NOTPOSSIBLE; 267 break; 268 case ACM_FORMATDETAILSF_INDEX: 269 afd->pwfx->wFormatTag = afd->dwFormatTag; 270 switch (afd->dwFormatTag) 271 { 272 case WAVE_FORMAT_PCM: 273 if (afd->dwFormatIndex >= NUM_RATES) return ACMERR_NOTPOSSIBLE; 274 afd->pwfx->nChannels = 1; 275 afd->pwfx->nSamplesPerSec = gsm_rates[afd->dwFormatIndex]; 276 afd->pwfx->wBitsPerSample = 16; 277 afd->pwfx->nBlockAlign = 2; 278 afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign; 279 break; 280 case WAVE_FORMAT_GSM610: 281 if (afd->dwFormatIndex >= NUM_RATES) return ACMERR_NOTPOSSIBLE; 282 afd->pwfx->nChannels = 1; 283 afd->pwfx->nSamplesPerSec = gsm_rates[afd->dwFormatIndex]; 284 afd->pwfx->wBitsPerSample = 0; 285 afd->pwfx->nBlockAlign = 65; 286 afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * 65 / 320; 287 afd->pwfx->cbSize = sizeof(WORD); 288 ((GSM610WAVEFORMAT*)afd->pwfx)->wSamplesPerBlock = 320; 289 break; 290 default: 291 WARN("Unsupported tag %08x\n", afd->dwFormatTag); 292 return MMSYSERR_INVALPARAM; 293 } 294 break; 295 default: 296 WARN("Unsupported query %08x\n", dwQuery); 297 return MMSYSERR_NOTSUPPORTED; 298 } 299 afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC; 300 afd->szFormat[0] = 0; /* let MSACM format this for us... */ 301 302 return MMSYSERR_NOERROR; 303 } 304 305 /*********************************************************************** 306 * GSM_FormatSuggest 307 * 308 */ 309 static LRESULT GSM_FormatSuggest(PACMDRVFORMATSUGGEST adfs) 310 { 311 /* some tests ... */ 312 if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) || 313 adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) || 314 !GSM_FormatValidate(adfs->pwfxSrc)) return ACMERR_NOTPOSSIBLE; 315 /* FIXME: should do those tests against the real size (according to format tag */ 316 317 /* If no suggestion for destination, then copy source value */ 318 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS)) 319 adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels; 320 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC)) 321 adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec; 322 323 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE)) 324 { 325 if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) 326 adfs->pwfxDst->wBitsPerSample = 0; 327 else 328 adfs->pwfxDst->wBitsPerSample = 16; 329 } 330 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG)) 331 { 332 switch (adfs->pwfxSrc->wFormatTag) 333 { 334 case WAVE_FORMAT_PCM: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_GSM610; break; 335 case WAVE_FORMAT_GSM610: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break; 336 } 337 } 338 339 /* recompute other values */ 340 switch (adfs->pwfxDst->wFormatTag) 341 { 342 case WAVE_FORMAT_PCM: 343 adfs->pwfxDst->nBlockAlign = 2; 344 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * 2; 345 break; 346 case WAVE_FORMAT_GSM610: 347 if (adfs->pwfxDst->cbSize < sizeof(WORD)) 348 return ACMERR_NOTPOSSIBLE; 349 adfs->pwfxDst->nBlockAlign = 65; 350 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * 65 / 320; 351 ((GSM610WAVEFORMAT*)adfs->pwfxDst)->wSamplesPerBlock = 320; 352 break; 353 default: 354 return ACMERR_NOTPOSSIBLE; 355 } 356 357 /* check if result is ok */ 358 if (!GSM_FormatValidate(adfs->pwfxDst)) return ACMERR_NOTPOSSIBLE; 359 return MMSYSERR_NOERROR; 360 } 361 362 #ifdef SONAME_LIBGSM 363 /*********************************************************************** 364 * GSM_StreamOpen 365 * 366 */ 367 static LRESULT GSM_StreamOpen(PACMDRVSTREAMINSTANCE adsi) 368 { 369 int used = 1; 370 gsm r; 371 if (!GSM_FormatValidate(adsi->pwfxSrc) || !GSM_FormatValidate(adsi->pwfxDst)) 372 return MMSYSERR_NOTSUPPORTED; 373 374 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec) 375 return MMSYSERR_NOTSUPPORTED; 376 377 if (!GSM_drvLoad()) return MMSYSERR_NOTSUPPORTED; 378 379 r = pgsm_create(); 380 if (!r) 381 return MMSYSERR_NOMEM; 382 if (pgsm_option(r, GSM_OPT_WAV49, &used) < 0) 383 { 384 FIXME("Your libgsm library doesn't support GSM_OPT_WAV49\n"); 385 FIXME("Please recompile libgsm with WAV49 support\n"); 386 pgsm_destroy(r); 387 return MMSYSERR_NOTSUPPORTED; 388 } 389 adsi->dwDriver = (DWORD_PTR)r; 390 return MMSYSERR_NOERROR; 391 } 392 393 /*********************************************************************** 394 * GSM_StreamClose 395 * 396 */ 397 static LRESULT GSM_StreamClose(PACMDRVSTREAMINSTANCE adsi) 398 { 399 pgsm_destroy((gsm)adsi->dwDriver); 400 return MMSYSERR_NOERROR; 401 } 402 403 /*********************************************************************** 404 * GSM_StreamSize 405 * 406 */ 407 static LRESULT GSM_StreamSize(const ACMDRVSTREAMINSTANCE *adsi, PACMDRVSTREAMSIZE adss) 408 { 409 switch (adss->fdwSize) 410 { 411 case ACM_STREAMSIZEF_DESTINATION: 412 /* cbDstLength => cbSrcLength */ 413 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 414 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_GSM610) 415 { 416 adss->cbSrcLength = adss->cbDstLength / 65 * 640; 417 } 418 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_GSM610 && 419 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 420 { 421 adss->cbSrcLength = adss->cbDstLength / 640 * 65; 422 } 423 else 424 { 425 return MMSYSERR_NOTSUPPORTED; 426 } 427 return MMSYSERR_NOERROR; 428 case ACM_STREAMSIZEF_SOURCE: 429 /* cbSrcLength => cbDstLength */ 430 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 431 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_GSM610) 432 { 433 adss->cbDstLength = (adss->cbSrcLength + 639) / 640 * 65; 434 } 435 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_GSM610 && 436 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 437 { 438 adss->cbDstLength = adss->cbSrcLength / 65 * 640; 439 } 440 else 441 { 442 return MMSYSERR_NOTSUPPORTED; 443 } 444 return MMSYSERR_NOERROR; 445 default: 446 WARN("Unsupported query %08x\n", adss->fdwSize); 447 return MMSYSERR_NOTSUPPORTED; 448 } 449 } 450 451 /*********************************************************************** 452 * GSM_StreamConvert 453 * 454 */ 455 static LRESULT GSM_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh) 456 { 457 gsm r = (gsm)adsi->dwDriver; 458 DWORD nsrc = 0; 459 DWORD ndst = 0; 460 BYTE *src = adsh->pbSrc; 461 BYTE *dst = adsh->pbDst; 462 int odd = 0; 463 464 if (adsh->fdwConvert & 465 ~(ACM_STREAMCONVERTF_BLOCKALIGN| 466 ACM_STREAMCONVERTF_END| 467 ACM_STREAMCONVERTF_START)) 468 { 469 FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert); 470 } 471 472 /* Reset the index to 0, just to be sure */ 473 pgsm_option(r, GSM_OPT_FRAME_INDEX, &odd); 474 475 /* The native ms codec writes 65 bytes, and this requires 2 libgsm calls. 476 * First 32 bytes are written, or 33 bytes read 477 * Second 33 bytes are written, or 32 bytes read 478 */ 479 480 /* Decode */ 481 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_GSM610) 482 { 483 if (adsh->cbSrcLength / 65 * 640 > adsh->cbDstLength) 484 { 485 return ACMERR_NOTPOSSIBLE; 486 } 487 488 while (nsrc + 65 <= adsh->cbSrcLength) 489 { 490 /* Decode data */ 491 if (pgsm_decode(r, src + nsrc, (gsm_signal*)(dst + ndst)) < 0) 492 FIXME("Couldn't decode data\n"); 493 ndst += 320; 494 nsrc += 33; 495 496 if (pgsm_decode(r, src + nsrc, (gsm_signal*)(dst + ndst)) < 0) 497 FIXME("Couldn't decode data\n"); 498 ndst += 320; 499 nsrc += 32; 500 } 501 } 502 else 503 { 504 /* Testing a little seems to reveal that despite being able to fit 505 * inside the buffer if ACM_STREAMCONVERTF_BLOCKALIGN is set 506 * it still rounds up 507 */ 508 if ((adsh->cbSrcLength + 639) / 640 * 65 > adsh->cbDstLength) 509 { 510 return ACMERR_NOTPOSSIBLE; 511 } 512 513 /* The packing algorithm writes 32 bytes, then 33 bytes, 514 * and it seems to pad to align to 65 bytes always 515 * adding extra data where necessary 516 */ 517 while (nsrc + 640 <= adsh->cbSrcLength) 518 { 519 /* Encode data */ 520 pgsm_encode(r, (gsm_signal*)(src+nsrc), dst+ndst); 521 nsrc += 320; 522 ndst += 32; 523 pgsm_encode(r, (gsm_signal*)(src+nsrc), dst+ndst); 524 nsrc += 320; 525 ndst += 33; 526 } 527 528 /* If ACM_STREAMCONVERTF_BLOCKALIGN isn't set pad with zeros */ 529 if (!(adsh->fdwConvert & ACM_STREAMCONVERTF_BLOCKALIGN) && 530 nsrc < adsh->cbSrcLength) 531 { 532 char emptiness[320]; 533 int todo = adsh->cbSrcLength - nsrc; 534 535 if (todo > 320) 536 { 537 pgsm_encode(r, (gsm_signal*)(src+nsrc), dst+ndst); 538 ndst += 32; 539 todo -= 320; 540 nsrc += 320; 541 542 memcpy(emptiness, src+nsrc, todo); 543 memset(emptiness + todo, 0, 320 - todo); 544 pgsm_encode(r, (gsm_signal*)emptiness, dst+ndst); 545 ndst += 33; 546 } 547 else 548 { 549 memcpy(emptiness, src+nsrc, todo); 550 memset(emptiness + todo, 0, 320 - todo); 551 pgsm_encode(r, (gsm_signal*)emptiness, dst+ndst); 552 ndst += 32; 553 554 memset(emptiness, 0, todo); 555 pgsm_encode(r, (gsm_signal*)emptiness, dst+ndst); 556 ndst += 33; 557 } 558 nsrc = adsh->cbSrcLength; 559 } 560 } 561 562 adsh->cbSrcLengthUsed = nsrc; 563 adsh->cbDstLengthUsed = ndst; 564 TRACE("%d(%d) -> %d(%d)\n", nsrc, adsh->cbSrcLength, ndst, adsh->cbDstLength); 565 return MMSYSERR_NOERROR; 566 } 567 568 #endif 569 570 /************************************************************************** 571 * GSM_DriverProc [exported] 572 */ 573 LRESULT CALLBACK GSM_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, 574 LPARAM dwParam1, LPARAM dwParam2) 575 { 576 TRACE("(%08lx %p %04x %08lx %08lx);\n", 577 dwDevID, hDriv, wMsg, dwParam1, dwParam2); 578 579 switch (wMsg) 580 { 581 case DRV_LOAD: return 1; 582 case DRV_FREE: return GSM_drvFree(); 583 case DRV_OPEN: return 1; 584 case DRV_CLOSE: return 1; 585 case DRV_ENABLE: return 1; 586 case DRV_DISABLE: return 1; 587 case DRV_QUERYCONFIGURE: return 1; 588 case DRV_CONFIGURE: MessageBoxA(0, "GSM 06.10 codec", "Wine Driver", MB_OK); return 1; 589 case DRV_INSTALL: return DRVCNF_RESTART; 590 case DRV_REMOVE: return DRVCNF_RESTART; 591 592 case ACMDM_DRIVER_NOTIFY: 593 /* no caching from other ACM drivers is done so far */ 594 return MMSYSERR_NOERROR; 595 596 case ACMDM_DRIVER_DETAILS: 597 return GSM_DriverDetails((PACMDRIVERDETAILSW)dwParam1); 598 599 case ACMDM_FORMATTAG_DETAILS: 600 return GSM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2); 601 602 case ACMDM_FORMAT_DETAILS: 603 return GSM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2); 604 605 case ACMDM_FORMAT_SUGGEST: 606 return GSM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1); 607 608 #ifdef SONAME_LIBGSM 609 case ACMDM_STREAM_OPEN: 610 return GSM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1); 611 612 case ACMDM_STREAM_CLOSE: 613 return GSM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1); 614 615 case ACMDM_STREAM_SIZE: 616 return GSM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2); 617 618 case ACMDM_STREAM_CONVERT: 619 return GSM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2); 620 #else 621 case ACMDM_STREAM_OPEN: WARN("libgsm support not compiled in!\n"); 622 case ACMDM_STREAM_CLOSE: 623 case ACMDM_STREAM_SIZE: 624 case ACMDM_STREAM_CONVERT: 625 return MMSYSERR_NOTSUPPORTED; 626 #endif 627 628 case ACMDM_HARDWARE_WAVE_CAPS_INPUT: 629 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT: 630 /* this converter is not a hardware driver */ 631 case ACMDM_FILTERTAG_DETAILS: 632 case ACMDM_FILTER_DETAILS: 633 /* this converter is not a filter */ 634 case ACMDM_STREAM_RESET: 635 /* only needed for asynchronous driver... we aren't, so just say it */ 636 return MMSYSERR_NOTSUPPORTED; 637 case ACMDM_STREAM_PREPARE: 638 case ACMDM_STREAM_UNPREPARE: 639 /* nothing special to do here... so don't do anything */ 640 return MMSYSERR_NOERROR; 641 642 default: 643 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2); 644 } 645 } 646