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