ReactOS  0.4.15-dev-1386-g5cb9f87
msgsm32.c File Reference
#include "config.h"
#include <wine/port.h>
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "mmsystem.h"
#include "mmreg.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wine/library.h"
#include "wine/debug.h"
Include dependency graph for msgsm32.c:

Go to the source code of this file.

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (gsm)
 
static LRESULT GSM_drvFree (void)
 
static LRESULT GSM_DriverDetails (PACMDRIVERDETAILSW add)
 
static BOOL GSM_FormatValidate (const WAVEFORMATEX *wfx)
 
static LRESULT GSM_FormatTagDetails (PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
 
static LRESULT GSM_FormatDetails (PACMFORMATDETAILSW afd, DWORD dwQuery)
 
static LRESULT GSM_FormatSuggest (PACMDRVFORMATSUGGEST adfs)
 
LRESULT CALLBACK GSM_DriverProc (DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, LPARAM dwParam1, LPARAM dwParam2)
 

Variables

static const DWORD gsm_rates [] = { 8000, 11025, 22050, 44100, 48000, 96000 }
 

Function Documentation

◆ GSM_DriverDetails()

static LRESULT GSM_DriverDetails ( PACMDRIVERDETAILSW  add)
static

Definition at line 114 of file msgsm32.c.

115 {
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;
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 }
#define MM_MSFT_ACM_GSM610
Definition: mmreg.h:148
WCHAR szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS]
Definition: msacm.h:316
DWORD cFormatTags
Definition: msacm.h:310
#define CP_ACP
Definition: compat.h:109
DWORD cFilterTags
Definition: msacm.h:311
#define ACMDRIVERDETAILS_SUPPORTF_CODEC
Definition: msacm.h:61
WCHAR szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS]
Definition: msacm.h:319
#define ACMDRIVERDETAILS_FCCCOMP_UNDEFINED
Definition: msacm.h:59
DWORD fdwSupport
Definition: msacm.h:309
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
WCHAR szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS]
Definition: msacm.h:315
DWORD vdwDriver
Definition: msacm.h:307
#define MM_MICROSOFT
Definition: mmreg.h:144
FOURCC fccType
Definition: msacm.h:300
#define ARRAY_SIZE(a)
Definition: main.h:24
#define NULL
Definition: types.h:112
FOURCC fccComp
Definition: msacm.h:301
#define MultiByteToWideChar
Definition: compat.h:110
WCHAR szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS]
Definition: msacm.h:318
WCHAR szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS]
Definition: msacm.h:317
#define ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC
Definition: msacm.h:58

Referenced by GSM_DriverProc().

◆ GSM_DriverProc()

LRESULT CALLBACK GSM_DriverProc ( DWORD_PTR  dwDevID,
HDRVR  hDriv,
UINT  wMsg,
LPARAM  dwParam1,
LPARAM  dwParam2 
)

Definition at line 572 of file msgsm32.c.

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 
596  return GSM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
597 
599  return GSM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
600 
602  return GSM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
603 
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 
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:
624  return MMSYSERR_NOTSUPPORTED;
625 #endif
626 
629  /* this converter is not a hardware driver */
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;
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 }
#define DRV_DISABLE
Definition: mmsystem.h:123
#define WARN(fmt,...)
Definition: debug.h:112
#define ACMDM_STREAM_RESET
Definition: msacmdrv.h:62
#define DRV_CLOSE
Definition: mmsystem.h:122
static LRESULT GSM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
Definition: msgsm32.c:260
#define ACMDM_STREAM_OPEN
Definition: msacmdrv.h:58
#define ACMDM_FORMATTAG_DETAILS
Definition: msacmdrv.h:51
#define ACMDM_STREAM_PREPARE
Definition: msacmdrv.h:63
static LRESULT GSM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
Definition: msgsm32.c:308
#define ACMDM_STREAM_CLOSE
Definition: msacmdrv.h:59
#define DRV_QUERYCONFIGURE
Definition: mmsystem.h:126
#define DRV_OPEN
Definition: mmsystem.h:121
int WINAPI MessageBoxA(_In_opt_ HWND, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ UINT)
#define ACMDM_DRIVER_NOTIFY
Definition: msacmdrv.h:45
#define ACMDM_FORMAT_SUGGEST
Definition: msacmdrv.h:53
#define ACMDM_DRIVER_DETAILS
Definition: msacmdrv.h:46
#define ACMDM_STREAM_CONVERT
Definition: msacmdrv.h:61
#define DRV_LOAD(x)
static LRESULT GSM_DriverDetails(PACMDRIVERDETAILSW add)
Definition: msgsm32.c:114
#define DRVCNF_RESTART
Definition: mmsystem.h:135
#define DRV_REMOVE
Definition: mmsystem.h:128
#define ACMDM_HARDWARE_WAVE_CAPS_OUTPUT
Definition: msacmdrv.h:49
#define ACMDM_HARDWARE_WAVE_CAPS_INPUT
Definition: msacmdrv.h:48
#define TRACE(s)
Definition: solgame.cpp:4
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
#define DRV_CONFIGURE
Definition: mmsystem.h:125
#define DRV_FREE
Definition: mmsystem.h:124
#define MMSYSERR_NOTSUPPORTED
Definition: mmsystem.h:104
static LRESULT GSM_drvFree(void)
Definition: msgsm32.c:103
#define ACMDM_FILTERTAG_DETAILS
Definition: msacmdrv.h:55
#define ACMDM_STREAM_UNPREPARE
Definition: msacmdrv.h:64
#define DRV_ENABLE
Definition: mmsystem.h:120
#define MB_OK
Definition: winuser.h:784
#define DRV_INSTALL
Definition: mmsystem.h:127
LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv, UINT Msg, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:554
static LRESULT GSM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
Definition: msgsm32.c:207
#define ACMDM_FORMAT_DETAILS
Definition: msacmdrv.h:52
#define ACMDM_STREAM_SIZE
Definition: msacmdrv.h:60
#define ACMDM_FILTER_DETAILS
Definition: msacmdrv.h:56

◆ GSM_drvFree()

static LRESULT GSM_drvFree ( void  )
static

Definition at line 103 of file msgsm32.c.

104 {
105  return 1;
106 }

Referenced by GSM_DriverProc().

◆ GSM_FormatDetails()

static LRESULT GSM_FormatDetails ( PACMFORMATDETAILSW  afd,
DWORD  dwQuery 
)
static

Definition at line 260 of file msgsm32.c.

261 {
262  switch (dwQuery)
263  {
265  if (!GSM_FormatValidate(afd->pwfx)) return ACMERR_NOTPOSSIBLE;
266  break;
268  afd->pwfx->wFormatTag = afd->dwFormatTag;
269  switch (afd->dwFormatTag)
270  {
271  case WAVE_FORMAT_PCM:
273  afd->pwfx->nChannels = 1;
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:
281  afd->pwfx->nChannels = 1;
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  }
299  afd->szFormat[0] = 0; /* let MSACM format this for us... */
300 
301  return MMSYSERR_NOERROR;
302 }
PWAVEFORMATEX pwfx
Definition: msacm.h:507
DWORD nAvgBytesPerSec
Definition: mmreg.h:81
WORD nChannels
Definition: mmreg.h:79
#define WARN(fmt,...)
Definition: debug.h:112
#define ACMDRIVERDETAILS_SUPPORTF_CODEC
Definition: msacm.h:61
static BOOL GSM_FormatValidate(const WAVEFORMATEX *wfx)
Definition: msgsm32.c:140
#define WAVE_FORMAT_PCM
Definition: constants.h:425
#define ACM_FORMATDETAILSF_FORMAT
Definition: msacm.h:161
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
unsigned short WORD
Definition: ntddk_ex.h:93
WCHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]
Definition: msacm.h:509
#define MMSYSERR_NOTSUPPORTED
Definition: mmsystem.h:104
WORD wFormatTag
Definition: mmreg.h:78
DWORD dwFormatIndex
Definition: msacm.h:504
#define ACMERR_NOTPOSSIBLE
Definition: msacm.h:36
static const DWORD gsm_rates[]
Definition: msgsm32.c:201
#define MMSYSERR_INVALPARAM
Definition: mmsystem.h:107
#define ARRAY_SIZE(a)
Definition: main.h:24
DWORD fdwSupport
Definition: msacm.h:506
WORD cbSize
Definition: mmreg.h:84
DWORD nSamplesPerSec
Definition: mmreg.h:80
WORD nBlockAlign
Definition: mmreg.h:82
#define ACM_FORMATDETAILSF_INDEX
Definition: msacm.h:160
WORD wBitsPerSample
Definition: mmreg.h:83
#define WAVE_FORMAT_GSM610
Definition: mmreg.h:118
DWORD dwFormatTag
Definition: msacm.h:505

Referenced by GSM_DriverProc().

◆ GSM_FormatSuggest()

static LRESULT GSM_FormatSuggest ( PACMDRVFORMATSUGGEST  adfs)
static

Definition at line 308 of file msgsm32.c.

309 {
310  /* some tests ... */
311  if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
312  adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
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 */
318  adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
321 
323  {
324  if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
325  adfs->pwfxDst->wBitsPerSample = 0;
326  else
327  adfs->pwfxDst->wBitsPerSample = 16;
328  }
330  {
331  switch (adfs->pwfxSrc->wFormatTag)
332  {
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 }
#define ACM_FORMATSUGGESTF_NSAMPLESPERSEC
Definition: msacm.h:176
PWAVEFORMATEX pwfxDst
Definition: msacmdrv.h:153
DWORD nAvgBytesPerSec
Definition: mmreg.h:81
WORD nChannels
Definition: mmreg.h:79
#define ACM_FORMATSUGGESTF_WFORMATTAG
Definition: msacm.h:174
static BOOL GSM_FormatValidate(const WAVEFORMATEX *wfx)
Definition: msgsm32.c:140
#define WAVE_FORMAT_PCM
Definition: constants.h:425
#define ACM_FORMATSUGGESTF_NCHANNELS
Definition: msacm.h:175
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
unsigned short WORD
Definition: ntddk_ex.h:93
WORD wFormatTag
Definition: mmreg.h:78
#define ACMERR_NOTPOSSIBLE
Definition: msacm.h:36
PWAVEFORMATEX pwfxSrc
Definition: msacmdrv.h:151
WORD cbSize
Definition: mmreg.h:84
DWORD nSamplesPerSec
Definition: mmreg.h:80
WORD nBlockAlign
Definition: mmreg.h:82
WORD wBitsPerSample
Definition: mmreg.h:83
#define WAVE_FORMAT_GSM610
Definition: mmreg.h:118
#define ACM_FORMATSUGGESTF_WBITSPERSAMPLE
Definition: msacm.h:177

Referenced by GSM_DriverProc().

◆ GSM_FormatTagDetails()

static LRESULT GSM_FormatTagDetails ( PACMFORMATTAGDETAILSW  aftd,
DWORD  dwQuery 
)
static

Definition at line 207 of file msgsm32.c.

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  {
215  if (aftd->dwFormatTagIndex > 1) return ACMERR_NOTPOSSIBLE;
216  break;
218  if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
219  {
220  aftd->dwFormatTagIndex = 1;
221  break;
222  }
223  /* fall through */
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 
238  switch (aftd->dwFormatTagIndex)
239  {
240  case 0:
242  aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
244  lstrcpyW(aftd->szFormatTag, szPcm);
245  break;
246  case 1:
248  aftd->cbFormatSize = sizeof(GSM610WAVEFORMAT);
250  lstrcpyW(aftd->szFormatTag, szGsm);
251  break;
252  }
253  return MMSYSERR_NOERROR;
254 }
#define WAVE_FORMAT_UNKNOWN
Definition: mmreg.h:95
#define WARN(fmt,...)
Definition: debug.h:112
#define ACMDRIVERDETAILS_SUPPORTF_CODEC
Definition: msacm.h:61
struct gsm610waveformat_tag GSM610WAVEFORMAT
struct pcmwaveformat_tag PCMWAVEFORMAT
#define WAVE_FORMAT_PCM
Definition: constants.h:425
DWORD cStandardFormats
Definition: msacm.h:534
#define ACM_FORMATTAGDETAILSF_FORMATTAG
Definition: msacm.h:183
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define ACM_FORMATTAGDETAILSF_INDEX
Definition: msacm.h:182
#define MMSYSERR_NOTSUPPORTED
Definition: mmsystem.h:104
#define ACM_FORMATTAGDETAILSF_LARGESTSIZE
Definition: msacm.h:184
DWORD dwFormatTagIndex
Definition: msacm.h:530
#define ACMERR_NOTPOSSIBLE
Definition: msacm.h:36
static const DWORD gsm_rates[]
Definition: msgsm32.c:201
#define lstrcpyW
Definition: compat.h:608
#define ARRAY_SIZE(a)
Definition: main.h:24
WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]
Definition: msacm.h:535
#define WAVE_FORMAT_GSM610
Definition: mmreg.h:118

Referenced by GSM_DriverProc().

◆ GSM_FormatValidate()

static BOOL GSM_FormatValidate ( const WAVEFORMATEX wfx)
static

Definition at line 140 of file msgsm32.c.

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 }
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
#define WAVE_FORMAT_PCM
Definition: constants.h:425
#define FALSE
Definition: types.h:117
WORD wBitsPerSample
Definition: audioclient.idl:45
DWORD nSamplesPerSec
Definition: audioclient.idl:42
unsigned short WORD
Definition: ntddk_ex.h:93
DWORD nAvgBytesPerSec
Definition: audioclient.idl:43
#define WAVE_FORMAT_GSM610
Definition: mmreg.h:118

Referenced by GSM_FormatDetails(), and GSM_FormatSuggest().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( gsm  )

Variable Documentation

◆ gsm_rates

const DWORD gsm_rates[] = { 8000, 11025, 22050, 44100, 48000, 96000 }
static

Definition at line 201 of file msgsm32.c.

Referenced by GSM_FormatDetails(), and GSM_FormatTagDetails().