4 * Copyright (C) 2002 Eric Pouech
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.
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.
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
22 #define WIN32_NO_STATUS
32 //#include "mmsystem.h"
36 #include <wine/debug.h>
38 /* see http://www.pcisys.net/~melanson/codecs/adpcm.txt for the details */
40 WINE_DEFAULT_DEBUG_CHANNEL(adpcm
);
42 /***********************************************************************
45 static LRESULT
ADPCM_drvOpen(LPCSTR str
)
50 /***********************************************************************
53 static LRESULT
ADPCM_drvClose(DWORD_PTR dwDevID
)
58 typedef struct tagAcmAdpcmData
60 void (*convert
)(const ACMDRVSTREAMINSTANCE
*adsi
,
61 const unsigned char*, LPDWORD
, unsigned char*, LPDWORD
);
64 /* table to list all supported formats... those are the basic ones. this
65 * also helps given a unique index to each of the supported formats
74 static const Format PCM_Formats
[] =
76 {1, 8, 8000}, {2, 8, 8000}, {1, 16, 8000}, {2, 16, 8000},
77 {1, 8, 11025}, {2, 8, 11025}, {1, 16, 11025}, {2, 16, 11025},
78 {1, 8, 22050}, {2, 8, 22050}, {1, 16, 22050}, {2, 16, 22050},
79 {1, 8, 44100}, {2, 8, 44100}, {1, 16, 44100}, {2, 16, 44100},
82 static const Format ADPCM_Formats
[] =
84 {1, 4, 8000}, {2, 4, 8000}, {1, 4, 11025}, {2, 4, 11025},
85 {1, 4, 22050}, {2, 4, 22050}, {1, 4, 44100}, {2, 4, 44100},
88 #define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
89 #define NUM_ADPCM_FORMATS (sizeof(ADPCM_Formats) / sizeof(ADPCM_Formats[0]))
91 static int MS_Delta
[] =
93 230, 230, 230, 230, 307, 409, 512, 614,
94 768, 614, 512, 409, 307, 230, 230, 230
98 static ADPCMCOEFSET MSADPCM_CoeffSet
[] =
100 {256, 0}, {512, -256}, {0, 0}, {192, 64}, {240, 0}, {460, -208}, {392, -232}
103 /***********************************************************************
104 * ADPCM_GetFormatIndex
106 static DWORD
ADPCM_GetFormatIndex(const WAVEFORMATEX
* wfx
)
111 switch (wfx
->wFormatTag
)
113 case WAVE_FORMAT_PCM
:
114 hi
= NUM_PCM_FORMATS
;
117 case WAVE_FORMAT_ADPCM
:
118 hi
= NUM_ADPCM_FORMATS
;
119 fmts
= ADPCM_Formats
;
125 for (i
= 0; i
< hi
; i
++)
127 if (wfx
->nChannels
== fmts
[i
].nChannels
&&
128 wfx
->nSamplesPerSec
== fmts
[i
].rate
&&
129 wfx
->wBitsPerSample
== fmts
[i
].nBits
)
133 switch (wfx
->wFormatTag
)
135 case WAVE_FORMAT_PCM
:
136 if(3 > wfx
->nChannels
&&
137 wfx
->nChannels
> 0 &&
138 wfx
->nAvgBytesPerSec
== 2 * wfx
->nSamplesPerSec
* wfx
->nChannels
&&
139 wfx
->nBlockAlign
== 2 * wfx
->nChannels
&&
140 wfx
->wBitsPerSample
== 16)
143 case WAVE_FORMAT_ADPCM
:
144 if(3 > wfx
->nChannels
&&
145 wfx
->nChannels
> 0 &&
146 wfx
->wBitsPerSample
== 4 &&
155 static void init_wfx_adpcm(ADPCMWAVEFORMAT
* awfx
)
157 register WAVEFORMATEX
* pwfx
= &awfx
->wfx
;
159 /* we assume wFormatTag, nChannels, nSamplesPerSec and wBitsPerSample
160 * have been initialized... */
162 if (pwfx
->wFormatTag
!= WAVE_FORMAT_ADPCM
) {FIXME("wrong FT\n"); return;}
163 if (ADPCM_GetFormatIndex(pwfx
) == 0xFFFFFFFF) {FIXME("wrong fmt\n"); return;}
165 switch (pwfx
->nSamplesPerSec
)
167 case 8000: pwfx
->nBlockAlign
= 256 * pwfx
->nChannels
; break;
168 case 11025: pwfx
->nBlockAlign
= 256 * pwfx
->nChannels
; break;
169 case 22050: pwfx
->nBlockAlign
= 512 * pwfx
->nChannels
; break;
170 case 44100: pwfx
->nBlockAlign
= 1024 * pwfx
->nChannels
; break;
173 pwfx
->cbSize
= 2 * sizeof(WORD
) + 7 * sizeof(ADPCMCOEFSET
);
174 /* 7 is the size of the block head (which contains two samples) */
176 awfx
->wSamplesPerBlock
= pwfx
->nBlockAlign
* 2 / pwfx
->nChannels
- 12;
177 pwfx
->nAvgBytesPerSec
= (pwfx
->nSamplesPerSec
* pwfx
->nBlockAlign
) / awfx
->wSamplesPerBlock
;
179 memcpy(awfx
->aCoef
, MSADPCM_CoeffSet
, 7 * sizeof(ADPCMCOEFSET
));
182 /***********************************************************************
185 * Read a 16 bit sample (correctly handles endianness)
187 static inline short R16(const unsigned char* src
)
189 return (short)((unsigned short)src
[0] | ((unsigned short)src
[1] << 8));
192 /***********************************************************************
195 * Write a 16 bit sample (correctly handles endianness)
197 static inline void W16(unsigned char* dst
, short s
)
203 static inline void clamp_sample(int* sample
)
205 if (*sample
< -32768) *sample
= -32768;
206 if (*sample
> 32767) *sample
= 32767;
209 static inline void process_nibble(unsigned nibble
, int* idelta
,
210 int* sample1
, int* sample2
,
211 const ADPCMCOEFSET
* coeff
)
216 /* nibble is in fact a signed 4 bit integer => propagate sign if needed */
217 snibble
= (nibble
& 0x08) ? (nibble
- 16) : nibble
;
218 sample
= ((*sample1
* coeff
->iCoef1
) + (*sample2
* coeff
->iCoef2
)) / 256 +
220 clamp_sample(&sample
);
224 *idelta
= ((MS_Delta
[nibble
] * *idelta
) / 256);
225 if (*idelta
< 16) *idelta
= 16;
228 static inline unsigned char C168(short s
)
230 return HIBYTE(s
) ^ (unsigned char)0x80;
233 static void cvtSSms16K(const ACMDRVSTREAMINSTANCE
*adsi
,
234 const unsigned char* src
, LPDWORD nsrc
,
235 unsigned char* dst
, LPDWORD ndst
)
237 int ideltaL
, ideltaR
;
238 int sample1L
, sample2L
;
239 int sample1R
, sample2R
;
240 ADPCMCOEFSET coeffL
, coeffR
;
242 int nsamp_blk
= ((ADPCMWAVEFORMAT
*)adsi
->pwfxSrc
)->wSamplesPerBlock
;
243 DWORD nblock
= min(*nsrc
/ adsi
->pwfxSrc
->nBlockAlign
,
244 *ndst
/ (nsamp_blk
* adsi
->pwfxDst
->nBlockAlign
));
246 *nsrc
= nblock
* adsi
->pwfxSrc
->nBlockAlign
;
247 *ndst
= nblock
* nsamp_blk
* adsi
->pwfxDst
->nBlockAlign
;
249 nsamp_blk
-= 2; /* see below for samples from block head */
250 for (; nblock
> 0; nblock
--)
252 const unsigned char* in_src
= src
;
255 coeffL
= MSADPCM_CoeffSet
[*src
++];
257 coeffR
= MSADPCM_CoeffSet
[*src
++];
259 ideltaL
= R16(src
); src
+= 2;
260 ideltaR
= R16(src
); src
+= 2;
261 sample1L
= R16(src
); src
+= 2;
262 sample1R
= R16(src
); src
+= 2;
263 sample2L
= R16(src
); src
+= 2;
264 sample2R
= R16(src
); src
+= 2;
266 if(adsi
->pwfxDst
->wBitsPerSample
== 8){
267 /* store samples from block head */
268 *dst
= C168(sample2L
); ++dst
;
269 *dst
= C168(sample2R
); ++dst
;
270 *dst
= C168(sample1L
); ++dst
;
271 *dst
= C168(sample1R
); ++dst
;
273 for (nsamp
= nsamp_blk
; nsamp
> 0; nsamp
--)
275 process_nibble(*src
>> 4, &ideltaL
, &sample1L
, &sample2L
, &coeffL
);
276 *dst
= C168(sample1L
); ++dst
;
277 process_nibble(*src
++ & 0x0F, &ideltaR
, &sample1R
, &sample2R
, &coeffR
);
278 *dst
= C168(sample1R
); ++dst
;
280 }else if(adsi
->pwfxDst
->wBitsPerSample
== 16){
281 /* store samples from block head */
282 W16(dst
, sample2L
); dst
+= 2;
283 W16(dst
, sample2R
); dst
+= 2;
284 W16(dst
, sample1L
); dst
+= 2;
285 W16(dst
, sample1R
); dst
+= 2;
287 for (nsamp
= nsamp_blk
; nsamp
> 0; nsamp
--)
289 process_nibble(*src
>> 4, &ideltaL
, &sample1L
, &sample2L
, &coeffL
);
290 W16(dst
, sample1L
); dst
+= 2;
291 process_nibble(*src
++ & 0x0F, &ideltaR
, &sample1R
, &sample2R
, &coeffR
);
292 W16(dst
, sample1R
); dst
+= 2;
295 src
= in_src
+ adsi
->pwfxSrc
->nBlockAlign
;
299 static void cvtMMms16K(const ACMDRVSTREAMINSTANCE
*adsi
,
300 const unsigned char* src
, LPDWORD nsrc
,
301 unsigned char* dst
, LPDWORD ndst
)
304 int sample1
, sample2
;
307 int nsamp_blk
= ((ADPCMWAVEFORMAT
*)adsi
->pwfxSrc
)->wSamplesPerBlock
;
308 DWORD nblock
= min(*nsrc
/ adsi
->pwfxSrc
->nBlockAlign
,
309 *ndst
/ (nsamp_blk
* adsi
->pwfxDst
->nBlockAlign
));
311 *nsrc
= nblock
* adsi
->pwfxSrc
->nBlockAlign
;
312 *ndst
= nblock
* nsamp_blk
* adsi
->pwfxDst
->nBlockAlign
;
314 nsamp_blk
-= 2; /* see below for samples from block head */
315 for (; nblock
> 0; nblock
--)
317 const unsigned char* in_src
= src
;
320 coeff
= MSADPCM_CoeffSet
[*src
++];
322 idelta
= R16(src
); src
+= 2;
323 sample1
= R16(src
); src
+= 2;
324 sample2
= R16(src
); src
+= 2;
326 /* store samples from block head */
327 if(adsi
->pwfxDst
->wBitsPerSample
== 8){
328 *dst
= C168(sample2
); ++dst
;
329 *dst
= C168(sample1
); ++dst
;
331 for (nsamp
= nsamp_blk
; nsamp
> 0; nsamp
-= 2)
333 process_nibble(*src
>> 4, &idelta
, &sample1
, &sample2
, &coeff
);
334 *dst
= C168(sample1
); ++dst
;
335 process_nibble(*src
++ & 0x0F, &idelta
, &sample1
, &sample2
, &coeff
);
336 *dst
= C168(sample1
); ++dst
;
338 }else if(adsi
->pwfxDst
->wBitsPerSample
== 16){
339 W16(dst
, sample2
); dst
+= 2;
340 W16(dst
, sample1
); dst
+= 2;
342 for (nsamp
= nsamp_blk
; nsamp
> 0; nsamp
-= 2)
344 process_nibble(*src
>> 4, &idelta
, &sample1
, &sample2
, &coeff
);
345 W16(dst
, sample1
); dst
+= 2;
346 process_nibble(*src
++ & 0x0F, &idelta
, &sample1
, &sample2
, &coeff
);
347 W16(dst
, sample1
); dst
+= 2;
351 src
= in_src
+ adsi
->pwfxSrc
->nBlockAlign
;
356 static void cvtSS16msK(PACMDRVSTREAMINSTANCE adsi
,
357 const unsigned char* src
, LPDWORD nsrc
,
358 unsigned char* dst
, LPDWORD ndst
)
362 static void cvtMM16msK(PACMDRVSTREAMINSTANCE adsi
,
363 const unsigned char* src
, LPDWORD nsrc
,
364 unsigned char* dst
, LPDWORD ndst
)
369 /***********************************************************************
370 * ADPCM_DriverDetails
373 static LRESULT
ADPCM_DriverDetails(PACMDRIVERDETAILSW add
)
375 add
->fccType
= ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC
;
376 add
->fccComp
= ACMDRIVERDETAILS_FCCCOMP_UNDEFINED
;
379 add
->vdwACM
= 0x01000000;
380 add
->vdwDriver
= 0x01000000;
381 add
->fdwSupport
= ACMDRIVERDETAILS_SUPPORTF_CODEC
;
382 add
->cFormatTags
= 2; /* PCM, MS ADPCM */
383 add
->cFilterTags
= 0;
385 MultiByteToWideChar( CP_ACP
, 0, "MS-ADPCM", -1,
386 add
->szShortName
, sizeof(add
->szShortName
)/sizeof(WCHAR
) );
387 MultiByteToWideChar( CP_ACP
, 0, "Wine MS ADPCM converter", -1,
388 add
->szLongName
, sizeof(add
->szLongName
)/sizeof(WCHAR
) );
389 MultiByteToWideChar( CP_ACP
, 0, "Brought to you by the Wine team...", -1,
390 add
->szCopyright
, sizeof(add
->szCopyright
)/sizeof(WCHAR
) );
391 MultiByteToWideChar( CP_ACP
, 0, "Refer to LICENSE file", -1,
392 add
->szLicensing
, sizeof(add
->szLicensing
)/sizeof(WCHAR
) );
393 add
->szFeatures
[0] = 0;
395 return MMSYSERR_NOERROR
;
398 /***********************************************************************
399 * ADPCM_FormatTagDetails
402 static LRESULT
ADPCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd
, DWORD dwQuery
)
404 static const WCHAR szPcm
[]={'P','C','M',0};
405 static const WCHAR szMsAdPcm
[]={'M','i','c','r','o','s','o','f','t',' ','A','D','P','C','M',0};
409 case ACM_FORMATTAGDETAILSF_INDEX
:
410 if (aftd
->dwFormatTagIndex
>= 2) return ACMERR_NOTPOSSIBLE
;
412 case ACM_FORMATTAGDETAILSF_LARGESTSIZE
:
413 if (aftd
->dwFormatTag
== WAVE_FORMAT_UNKNOWN
)
415 aftd
->dwFormatTagIndex
= 1; /* WAVE_FORMAT_ADPCM is bigger than PCM */
419 case ACM_FORMATTAGDETAILSF_FORMATTAG
:
420 switch (aftd
->dwFormatTag
)
422 case WAVE_FORMAT_PCM
: aftd
->dwFormatTagIndex
= 0; break;
423 case WAVE_FORMAT_ADPCM
: aftd
->dwFormatTagIndex
= 1; break;
424 default: return ACMERR_NOTPOSSIBLE
;
428 WARN("Unsupported query %08x\n", dwQuery
);
429 return MMSYSERR_NOTSUPPORTED
;
432 aftd
->fdwSupport
= ACMDRIVERDETAILS_SUPPORTF_CODEC
;
433 switch (aftd
->dwFormatTagIndex
)
436 aftd
->dwFormatTag
= WAVE_FORMAT_PCM
;
437 aftd
->cbFormatSize
= sizeof(PCMWAVEFORMAT
);
438 aftd
->cStandardFormats
= NUM_PCM_FORMATS
;
439 lstrcpyW(aftd
->szFormatTag
, szPcm
);
442 aftd
->dwFormatTag
= WAVE_FORMAT_ADPCM
;
443 aftd
->cbFormatSize
= sizeof(ADPCMWAVEFORMAT
) + (7 - 1) * sizeof(ADPCMCOEFSET
);
444 aftd
->cStandardFormats
= NUM_ADPCM_FORMATS
;
445 lstrcpyW(aftd
->szFormatTag
, szMsAdPcm
);
448 return MMSYSERR_NOERROR
;
451 /***********************************************************************
452 * ADPCM_FormatDetails
455 static LRESULT
ADPCM_FormatDetails(PACMFORMATDETAILSW afd
, DWORD dwQuery
)
459 case ACM_FORMATDETAILSF_FORMAT
:
460 if (ADPCM_GetFormatIndex(afd
->pwfx
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
462 case ACM_FORMATDETAILSF_INDEX
:
463 afd
->pwfx
->wFormatTag
= afd
->dwFormatTag
;
464 switch (afd
->dwFormatTag
)
466 case WAVE_FORMAT_PCM
:
467 if (afd
->dwFormatIndex
>= NUM_PCM_FORMATS
) return ACMERR_NOTPOSSIBLE
;
468 afd
->pwfx
->nChannels
= PCM_Formats
[afd
->dwFormatIndex
].nChannels
;
469 afd
->pwfx
->nSamplesPerSec
= PCM_Formats
[afd
->dwFormatIndex
].rate
;
470 afd
->pwfx
->wBitsPerSample
= PCM_Formats
[afd
->dwFormatIndex
].nBits
;
471 /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
472 * afd->pwfx->cbSize = 0;
474 afd
->pwfx
->nBlockAlign
=
475 (afd
->pwfx
->nChannels
* afd
->pwfx
->wBitsPerSample
) / 8;
476 afd
->pwfx
->nAvgBytesPerSec
=
477 afd
->pwfx
->nSamplesPerSec
* afd
->pwfx
->nBlockAlign
;
479 case WAVE_FORMAT_ADPCM
:
480 if (afd
->dwFormatIndex
>= NUM_ADPCM_FORMATS
) return ACMERR_NOTPOSSIBLE
;
481 if (afd
->cbwfx
< sizeof(ADPCMWAVEFORMAT
) + (7 - 1) * sizeof(ADPCMCOEFSET
))
482 return ACMERR_NOTPOSSIBLE
;
483 afd
->pwfx
->nChannels
= ADPCM_Formats
[afd
->dwFormatIndex
].nChannels
;
484 afd
->pwfx
->nSamplesPerSec
= ADPCM_Formats
[afd
->dwFormatIndex
].rate
;
485 afd
->pwfx
->wBitsPerSample
= ADPCM_Formats
[afd
->dwFormatIndex
].nBits
;
486 init_wfx_adpcm((ADPCMWAVEFORMAT
*)afd
->pwfx
);
489 WARN("Unsupported tag %08x\n", afd
->dwFormatTag
);
490 return MMSYSERR_INVALPARAM
;
494 WARN("Unsupported query %08x\n", dwQuery
);
495 return MMSYSERR_NOTSUPPORTED
;
497 afd
->fdwSupport
= ACMDRIVERDETAILS_SUPPORTF_CODEC
;
498 afd
->szFormat
[0] = 0; /* let MSACM format this for us... */
500 return MMSYSERR_NOERROR
;
503 /***********************************************************************
504 * ADPCM_FormatSuggest
507 static LRESULT
ADPCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs
)
510 if (adfs
->cbwfxSrc
< sizeof(PCMWAVEFORMAT
) ||
511 adfs
->cbwfxDst
< sizeof(PCMWAVEFORMAT
) ||
512 adfs
->pwfxSrc
->wFormatTag
== adfs
->pwfxDst
->wFormatTag
||
513 ADPCM_GetFormatIndex(adfs
->pwfxSrc
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
514 /* FIXME: should do those tests against the real size (according to format tag */
516 /* If no suggestion for destination, then copy source value */
517 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_NCHANNELS
))
518 adfs
->pwfxDst
->nChannels
= adfs
->pwfxSrc
->nChannels
;
519 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_NSAMPLESPERSEC
))
520 adfs
->pwfxDst
->nSamplesPerSec
= adfs
->pwfxSrc
->nSamplesPerSec
;
522 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_WBITSPERSAMPLE
))
524 if (adfs
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
)
525 adfs
->pwfxDst
->wBitsPerSample
= 4;
527 adfs
->pwfxDst
->wBitsPerSample
= 16;
529 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_WFORMATTAG
))
531 if (adfs
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
)
532 adfs
->pwfxDst
->wFormatTag
= WAVE_FORMAT_ADPCM
;
534 adfs
->pwfxDst
->wFormatTag
= WAVE_FORMAT_PCM
;
537 /* recompute other values */
538 switch (adfs
->pwfxDst
->wFormatTag
)
540 case WAVE_FORMAT_PCM
:
541 adfs
->pwfxDst
->nBlockAlign
= (adfs
->pwfxDst
->nChannels
* adfs
->pwfxDst
->wBitsPerSample
) / 8;
542 adfs
->pwfxDst
->nAvgBytesPerSec
= adfs
->pwfxDst
->nSamplesPerSec
* adfs
->pwfxDst
->nBlockAlign
;
543 /* check if result is ok */
544 if (ADPCM_GetFormatIndex(adfs
->pwfxDst
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
546 case WAVE_FORMAT_ADPCM
:
547 init_wfx_adpcm((ADPCMWAVEFORMAT
*)adfs
->pwfxDst
);
548 /* check if result is ok */
549 if (ADPCM_GetFormatIndex(adfs
->pwfxDst
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
552 return ACMERR_NOTPOSSIBLE
;
555 return MMSYSERR_NOERROR
;
558 /***********************************************************************
562 static void ADPCM_Reset(PACMDRVSTREAMINSTANCE adsi
, AcmAdpcmData
* aad
)
566 /***********************************************************************
570 static LRESULT
ADPCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi
)
574 assert(!(adsi
->fdwOpen
& ACM_STREAMOPENF_ASYNC
));
576 if (ADPCM_GetFormatIndex(adsi
->pwfxSrc
) == 0xFFFFFFFF ||
577 ADPCM_GetFormatIndex(adsi
->pwfxDst
) == 0xFFFFFFFF)
578 return ACMERR_NOTPOSSIBLE
;
580 aad
= HeapAlloc(GetProcessHeap(), 0, sizeof(AcmAdpcmData
));
581 if (aad
== 0) return MMSYSERR_NOMEM
;
583 adsi
->dwDriver
= (DWORD_PTR
)aad
;
585 if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
586 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
590 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_ADPCM
&&
591 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
593 /* resampling or mono <=> stereo not available */
594 if (adsi
->pwfxSrc
->nSamplesPerSec
!= adsi
->pwfxDst
->nSamplesPerSec
||
595 adsi
->pwfxSrc
->nChannels
!= adsi
->pwfxDst
->nChannels
)
600 unsigned int nspb
= ((IMAADPCMWAVEFORMAT
*)adsi
->pwfxSrc
)->wSamplesPerBlock
;
601 FIXME("spb=%u\n", nspb
);
603 /* we check that in a block, after the header, samples are present on
604 * 4-sample packet pattern
605 * we also check that the block alignment is bigger than the expected size
607 if (((nspb
- 1) & 3) != 0) goto theEnd
;
608 if ((((nspb
- 1) / 2) + 4) * adsi
->pwfxSrc
->nChannels
< adsi
->pwfxSrc
->nBlockAlign
)
613 /* adpcm decoding... */
614 if (adsi
->pwfxDst
->nChannels
== 2)
615 aad
->convert
= cvtSSms16K
;
616 else if (adsi
->pwfxDst
->nChannels
== 1)
617 aad
->convert
= cvtMMms16K
;
619 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
620 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_ADPCM
)
622 if (adsi
->pwfxSrc
->nSamplesPerSec
!= adsi
->pwfxDst
->nSamplesPerSec
||
623 adsi
->pwfxSrc
->nChannels
!= adsi
->pwfxDst
->nChannels
||
624 adsi
->pwfxSrc
->wBitsPerSample
!= 16)
627 nspb
= ((IMAADPCMWAVEFORMAT
*)adsi
->pwfxDst
)->wSamplesPerBlock
;
628 FIXME("spb=%u\n", nspb
);
630 /* we check that in a block, after the header, samples are present on
631 * 4-sample packet pattern
632 * we also check that the block alignment is bigger than the expected size
634 if (((nspb
- 1) & 3) != 0) goto theEnd
;
635 if ((((nspb
- 1) / 2) + 4) * adsi
->pwfxDst
->nChannels
< adsi
->pwfxDst
->nBlockAlign
)
639 /* adpcm coding... */
640 if (adsi
->pwfxSrc
->wBitsPerSample
== 16 && adsi
->pwfxSrc
->nChannels
== 2)
641 aad
->convert
= cvtSS16msK
;
642 if (adsi
->pwfxSrc
->wBitsPerSample
== 16 && adsi
->pwfxSrc
->nChannels
== 1)
643 aad
->convert
= cvtMM16msK
;
645 FIXME("We don't support encoding yet\n");
649 ADPCM_Reset(adsi
, aad
);
651 return MMSYSERR_NOERROR
;
654 HeapFree(GetProcessHeap(), 0, aad
);
656 return MMSYSERR_NOTSUPPORTED
;
659 /***********************************************************************
663 static LRESULT
ADPCM_StreamClose(PACMDRVSTREAMINSTANCE adsi
)
665 HeapFree(GetProcessHeap(), 0, (void*)adsi
->dwDriver
);
666 return MMSYSERR_NOERROR
;
669 /***********************************************************************
673 static LRESULT
ADPCM_StreamSize(const ACMDRVSTREAMINSTANCE
*adsi
, PACMDRVSTREAMSIZE adss
)
676 WORD wSamplesPerBlock
;
677 /* wSamplesPerBlock formula comes from MSDN ADPCMWAVEFORMAT page.*/
678 switch (adss
->fdwSize
)
680 case ACM_STREAMSIZEF_DESTINATION
:
681 /* cbDstLength => cbSrcLength */
682 if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
683 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_ADPCM
)
685 wSamplesPerBlock
= adsi
->pwfxDst
->nBlockAlign
* 2 / adsi
->pwfxDst
->nChannels
- 12;
686 nblocks
= adss
->cbDstLength
/ adsi
->pwfxDst
->nBlockAlign
;
688 return ACMERR_NOTPOSSIBLE
;
689 adss
->cbSrcLength
= nblocks
* adsi
->pwfxSrc
->nBlockAlign
* wSamplesPerBlock
;
691 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_ADPCM
&&
692 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
694 wSamplesPerBlock
= adsi
->pwfxSrc
->nBlockAlign
* 2 / adsi
->pwfxSrc
->nChannels
- 12;
695 nblocks
= adss
->cbDstLength
/ (adsi
->pwfxDst
->nBlockAlign
* wSamplesPerBlock
);
697 return ACMERR_NOTPOSSIBLE
;
698 adss
->cbSrcLength
= nblocks
* adsi
->pwfxSrc
->nBlockAlign
;
702 return MMSYSERR_NOTSUPPORTED
;
705 case ACM_STREAMSIZEF_SOURCE
:
706 /* cbSrcLength => cbDstLength */
707 if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
708 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_ADPCM
)
710 wSamplesPerBlock
= adsi
->pwfxDst
->nBlockAlign
* 2 / adsi
->pwfxDst
->nChannels
- 12;
711 nblocks
= adss
->cbSrcLength
/ (adsi
->pwfxSrc
->nBlockAlign
* wSamplesPerBlock
);
713 return ACMERR_NOTPOSSIBLE
;
714 if (adss
->cbSrcLength
% (adsi
->pwfxSrc
->nBlockAlign
* wSamplesPerBlock
))
715 /* Round block count up. */
717 adss
->cbDstLength
= nblocks
* adsi
->pwfxDst
->nBlockAlign
;
719 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_ADPCM
&&
720 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
722 wSamplesPerBlock
= adsi
->pwfxSrc
->nBlockAlign
* 2 / adsi
->pwfxSrc
->nChannels
- 12;
723 nblocks
= adss
->cbSrcLength
/ adsi
->pwfxSrc
->nBlockAlign
;
725 return ACMERR_NOTPOSSIBLE
;
726 if (adss
->cbSrcLength
% adsi
->pwfxSrc
->nBlockAlign
)
727 /* Round block count up. */
729 adss
->cbDstLength
= nblocks
* adsi
->pwfxDst
->nBlockAlign
* wSamplesPerBlock
;
733 return MMSYSERR_NOTSUPPORTED
;
737 WARN("Unsupported query %08x\n", adss
->fdwSize
);
738 return MMSYSERR_NOTSUPPORTED
;
740 return MMSYSERR_NOERROR
;
743 /***********************************************************************
744 * ADPCM_StreamConvert
747 static LRESULT
ADPCM_StreamConvert(PACMDRVSTREAMINSTANCE adsi
, PACMDRVSTREAMHEADER adsh
)
749 AcmAdpcmData
* aad
= (AcmAdpcmData
*)adsi
->dwDriver
;
750 DWORD nsrc
= adsh
->cbSrcLength
;
751 DWORD ndst
= adsh
->cbDstLength
;
753 if (adsh
->fdwConvert
&
754 ~(ACM_STREAMCONVERTF_BLOCKALIGN
|
755 ACM_STREAMCONVERTF_END
|
756 ACM_STREAMCONVERTF_START
))
758 FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh
->fdwConvert
);
760 /* ACM_STREAMCONVERTF_BLOCKALIGN
761 * currently all conversions are block aligned, so do nothing for this flag
762 * ACM_STREAMCONVERTF_END
763 * no pending data, so do nothing for this flag
765 if ((adsh
->fdwConvert
& ACM_STREAMCONVERTF_START
))
767 ADPCM_Reset(adsi
, aad
);
770 aad
->convert(adsi
, adsh
->pbSrc
, &nsrc
, adsh
->pbDst
, &ndst
);
771 adsh
->cbSrcLengthUsed
= nsrc
;
772 adsh
->cbDstLengthUsed
= ndst
;
774 return MMSYSERR_NOERROR
;
777 /**************************************************************************
778 * ADPCM_DriverProc [exported]
780 LRESULT CALLBACK
ADPCM_DriverProc(DWORD_PTR dwDevID
, HDRVR hDriv
, UINT wMsg
,
781 LPARAM dwParam1
, LPARAM dwParam2
)
783 TRACE("(%08lx %p %04x %08lx %08lx);\n",
784 dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
788 case DRV_LOAD
: return 1;
789 case DRV_FREE
: return 1;
790 case DRV_OPEN
: return ADPCM_drvOpen((LPSTR
)dwParam1
);
791 case DRV_CLOSE
: return ADPCM_drvClose(dwDevID
);
792 case DRV_ENABLE
: return 1;
793 case DRV_DISABLE
: return 1;
794 case DRV_QUERYCONFIGURE
: return 1;
795 case DRV_CONFIGURE
: MessageBoxA(0, "MSACM MS ADPCM filter !", "Wine Driver", MB_OK
); return 1;
796 case DRV_INSTALL
: return DRVCNF_RESTART
;
797 case DRV_REMOVE
: return DRVCNF_RESTART
;
799 case ACMDM_DRIVER_NOTIFY
:
800 /* no caching from other ACM drivers is done so far */
801 return MMSYSERR_NOERROR
;
803 case ACMDM_DRIVER_DETAILS
:
804 return ADPCM_DriverDetails((PACMDRIVERDETAILSW
)dwParam1
);
806 case ACMDM_FORMATTAG_DETAILS
:
807 return ADPCM_FormatTagDetails((PACMFORMATTAGDETAILSW
)dwParam1
, dwParam2
);
809 case ACMDM_FORMAT_DETAILS
:
810 return ADPCM_FormatDetails((PACMFORMATDETAILSW
)dwParam1
, dwParam2
);
812 case ACMDM_FORMAT_SUGGEST
:
813 return ADPCM_FormatSuggest((PACMDRVFORMATSUGGEST
)dwParam1
);
815 case ACMDM_STREAM_OPEN
:
816 return ADPCM_StreamOpen((PACMDRVSTREAMINSTANCE
)dwParam1
);
818 case ACMDM_STREAM_CLOSE
:
819 return ADPCM_StreamClose((PACMDRVSTREAMINSTANCE
)dwParam1
);
821 case ACMDM_STREAM_SIZE
:
822 return ADPCM_StreamSize((PACMDRVSTREAMINSTANCE
)dwParam1
, (PACMDRVSTREAMSIZE
)dwParam2
);
824 case ACMDM_STREAM_CONVERT
:
825 return ADPCM_StreamConvert((PACMDRVSTREAMINSTANCE
)dwParam1
, (PACMDRVSTREAMHEADER
)dwParam2
);
827 case ACMDM_HARDWARE_WAVE_CAPS_INPUT
:
828 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT
:
829 /* this converter is not a hardware driver */
830 case ACMDM_FILTERTAG_DETAILS
:
831 case ACMDM_FILTER_DETAILS
:
832 /* this converter is not a filter */
833 case ACMDM_STREAM_RESET
:
834 /* only needed for asynchronous driver... we aren't, so just say it */
835 return MMSYSERR_NOTSUPPORTED
;
836 case ACMDM_STREAM_PREPARE
:
837 case ACMDM_STREAM_UNPREPARE
:
838 /* nothing special to do here... so don't do anything */
839 return MMSYSERR_NOERROR
;
842 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);