projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Synchronize up to trunk's revision r57689.
[reactos.git] / dll / win32 / imaadp32.acm / imaadp32.c
1 /*
2 * IMA ADPCM handling
3 *
4 * Copyright (C) 2001,2002 Eric Pouech
5 *
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include <assert.h>
23 #include <stdarg.h>
24 #include <string.h>
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "winnls.h"
30 #include "mmsystem.h"
31 #include "mmreg.h"
32 #include "msacm.h"
33 #include "msacmdrv.h"
34 #include "wine/debug.h"
35
36 /* see http://www.pcisys.net/~melanson/codecs/adpcm.txt for the details */
37
38 WINE_DEFAULT_DEBUG_CHANNEL(adpcm);
39
40 /***********************************************************************
41 * ADPCM_drvClose
42 */
43 static LRESULT ADPCM_drvClose(DWORD_PTR dwDevID)
44 {
45 return 1;
46 }
47
48 typedef struct tagAcmAdpcmData
49 {
50 void (*convert)(PACMDRVSTREAMINSTANCE adsi,
51 const unsigned char*, LPDWORD, unsigned char*, LPDWORD);
52 /* IMA encoding only */
53 BYTE stepIndexL;
54 BYTE stepIndexR;
55 /* short sample; */
56 } AcmAdpcmData;
57
58 /* table to list all supported formats... those are the basic ones. this
59 * also helps given a unique index to each of the supported formats
60 */
61 typedef struct
62 {
63 int nChannels;
64 int nBits;
65 int rate;
66 } Format;
67
68 static const Format PCM_Formats[] =
69 {
70 {1, 8, 8000}, {2, 8, 8000}, {1, 16, 8000}, {2, 16, 8000},
71 {1, 8, 11025}, {2, 8, 11025}, {1, 16, 11025}, {2, 16, 11025},
72 {1, 8, 22050}, {2, 8, 22050}, {1, 16, 22050}, {2, 16, 22050},
73 {1, 8, 44100}, {2, 8, 44100}, {1, 16, 44100}, {2, 16, 44100},
74 };
75
76 static const Format ADPCM_Formats[] =
77 {
78 {1, 4, 8000}, {2, 4, 8000}, {1, 4, 11025}, {2, 4, 11025},
79 {1, 4, 22050}, {2, 4, 22050}, {1, 4, 44100}, {2, 4, 44100},
80 };
81
82 #define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
83 #define NUM_ADPCM_FORMATS (sizeof(ADPCM_Formats) / sizeof(ADPCM_Formats[0]))
84
85 /***********************************************************************
86 * ADPCM_GetFormatIndex
87 */
88 static DWORD ADPCM_GetFormatIndex(const WAVEFORMATEX *wfx)
89 {
90 int i, hi;
91 const Format* fmts;
92
93 switch (wfx->wFormatTag)
94 {
95 case WAVE_FORMAT_PCM:
96 hi = NUM_PCM_FORMATS;
97 fmts = PCM_Formats;
98 break;
99 case WAVE_FORMAT_IMA_ADPCM:
100 hi = NUM_ADPCM_FORMATS;
101 fmts = ADPCM_Formats;
102 break;
103 default:
104 return 0xFFFFFFFF;
105 }
106
107 for (i = 0; i < hi; i++)
108 {
109 if (wfx->nChannels == fmts[i].nChannels &&
110 wfx->nSamplesPerSec == fmts[i].rate &&
111 wfx->wBitsPerSample == fmts[i].nBits)
112 return i;
113 }
114
115 switch (wfx->wFormatTag)
116 {
117 case WAVE_FORMAT_PCM:
118 if(3 > wfx->nChannels &&
119 wfx->nChannels > 0 &&
120 wfx->nAvgBytesPerSec == 2 * wfx->nSamplesPerSec * wfx->nChannels &&
121 wfx->nBlockAlign == 2 * wfx->nChannels &&
122 wfx->wBitsPerSample == 16)
123 return hi;
124 break;
125 case WAVE_FORMAT_IMA_ADPCM:
126 if(3 > wfx->nChannels &&
127 wfx->nChannels > 0 &&
128 wfx->wBitsPerSample == 4 &&
129 wfx->cbSize == 2)
130 return hi;
131 break;
132 }
133
134 return 0xFFFFFFFF;
135 }
136
137 static void init_wfx_ima_adpcm(IMAADPCMWAVEFORMAT* awfx/*, DWORD nba*/)
138 {
139 register WAVEFORMATEX* pwfx = &awfx->wfx;
140
141 /* we assume wFormatTag, nChannels, nSamplesPerSec and wBitsPerSample
142 * have been initialized... */
143
144 if (pwfx->wFormatTag != WAVE_FORMAT_IMA_ADPCM) {FIXME("wrong FT\n"); return;}
145 if (ADPCM_GetFormatIndex(pwfx) == 0xFFFFFFFF) {FIXME("wrong fmt\n"); return;}
146
147 switch (pwfx->nSamplesPerSec)
148 {
149 case 8000: pwfx->nBlockAlign = 256 * pwfx->nChannels; break;
150 case 11025: pwfx->nBlockAlign = 256 * pwfx->nChannels; break;
151 case 22050: pwfx->nBlockAlign = 512 * pwfx->nChannels; break;
152 case 44100: pwfx->nBlockAlign = 1024 * pwfx->nChannels; break;
153 default: /*pwfx->nBlockAlign = nba;*/ break;
154 }
155 pwfx->cbSize = sizeof(WORD);
156
157 awfx->wSamplesPerBlock = (pwfx->nBlockAlign - (4 * pwfx->nChannels) * 2) / pwfx->nChannels + 1;
158 pwfx->nAvgBytesPerSec = (pwfx->nSamplesPerSec * pwfx->nBlockAlign) / awfx->wSamplesPerBlock;
159 }
160
161 /***********************************************************************
162 * R16
163 *
164 * Read a 16 bit sample (correctly handles endianness)
165 */
166 static inline short R16(const unsigned char* src)
167 {
168 return (short)((unsigned short)src[0] | ((unsigned short)src[1] << 8));
169 }
170
171 /***********************************************************************
172 * W16
173 *
174 * Write a 16 bit sample (correctly handles endianness)
175 */
176 static inline void W16(unsigned char* dst, short s)
177 {
178 dst[0] = LOBYTE(s);
179 dst[1] = HIBYTE(s);
180 }
181
182 /* IMA (or DVI) APDCM codec routines */
183
184 static const unsigned IMA_StepTable[89] =
185 {
186 7, 8, 9, 10, 11, 12, 13, 14,
187 16, 17, 19, 21, 23, 25, 28, 31,
188 34, 37, 41, 45, 50, 55, 60, 66,
189 73, 80, 88, 97, 107, 118, 130, 143,
190 157, 173, 190, 209, 230, 253, 279, 307,
191 337, 371, 408, 449, 494, 544, 598, 658,
192 724, 796, 876, 963, 1060, 1166, 1282, 1411,
193 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
194 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
195 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
196 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
197 32767
198 };
199
200 static const int IMA_IndexTable[16] =
201 {
202 -1, -1, -1, -1, 2, 4, 6, 8,
203 -1, -1, -1, -1, 2, 4, 6, 8
204 };
205
206 static inline void clamp_step_index(int* stepIndex)
207 {
208 if (*stepIndex < 0 ) *stepIndex = 0;
209 if (*stepIndex > 88) *stepIndex = 88;
210 }
211
212 static inline void clamp_sample(int* sample)
213 {
214 if (*sample < -32768) *sample = -32768;
215 if (*sample > 32767) *sample = 32767;
216 }
217
218 static inline void process_nibble(unsigned char code, int* stepIndex, int* sample)
219 {
220 unsigned step;
221 int diff;
222
223 code &= 0x0F;
224
225 step = IMA_StepTable[*stepIndex];
226 diff = step >> 3;
227 if (code & 1) diff += step >> 2;
228 if (code & 2) diff += step >> 1;
229 if (code & 4) diff += step;
230 if (code & 8) *sample -= diff;
231 else *sample += diff;
232 clamp_sample(sample);
233 *stepIndex += IMA_IndexTable[code];
234 clamp_step_index(stepIndex);
235 }
236
237 static inline unsigned char generate_nibble(int in, int* stepIndex, int* sample)
238 {
239 int effdiff, diff = in - *sample;
240 unsigned step;
241 unsigned char code;
242
243 if (diff < 0)
244 {
245 diff = -diff;
246 code = 8;
247 }
248 else
249 {
250 code = 0;
251 }
252
253 step = IMA_StepTable[*stepIndex];
254 effdiff = (step >> 3);
255 if (diff >= step)
256 {
257 code |= 4;
258 diff -= step;
259 effdiff += step;
260 }
261 step >>= 1;
262 if (diff >= step)
263 {
264 code |= 2;
265 diff -= step;
266 effdiff += step;
267 }
268 step >>= 1;
269 if (diff >= step)
270 {
271 code |= 1;
272 effdiff += step;
273 }
274 if (code & 8) *sample -= effdiff;
275 else *sample += effdiff;
276 clamp_sample(sample);
277 *stepIndex += IMA_IndexTable[code];
278 clamp_step_index(stepIndex);
279 return code;
280 }
281
282 static void cvtSSima16K(PACMDRVSTREAMINSTANCE adsi,
283 const unsigned char* src, LPDWORD nsrc,
284 unsigned char* dst, LPDWORD ndst)
285 {
286 int i;
287 int sampleL, sampleR;
288 int stepIndexL, stepIndexR;
289 int nsamp_blk = ((LPIMAADPCMWAVEFORMAT)adsi->pwfxSrc)->wSamplesPerBlock;
290 int nsamp;
291 /* compute the number of entire blocks we can decode...
292 * it's the min of the number of entire blocks in source buffer and the number
293 * of entire blocks in destination buffer
294 */
295 DWORD nblock = min(*nsrc / adsi->pwfxSrc->nBlockAlign,
296 *ndst / (nsamp_blk * 2 * 2));
297
298 *nsrc = nblock * adsi->pwfxSrc->nBlockAlign;
299 *ndst = nblock * (nsamp_blk * 2 * 2);
300
301 nsamp_blk--; /* remove the sample in block header */
302 for (; nblock > 0; nblock--)
303 {
304 const unsigned char* in_src = src;
305
306 /* handle headers first */
307 sampleL = R16(src);
308 stepIndexL = (unsigned)*(src + 2);
309 clamp_step_index(&stepIndexL);
310 src += 4;
311 W16(dst, sampleL); dst += 2;
312
313 sampleR = R16(src);
314 stepIndexR = (unsigned)*(src + 2);
315 clamp_step_index(&stepIndexR);
316 src += 4;
317 W16(dst, sampleR); dst += 2;
318
319 for (nsamp = nsamp_blk; nsamp > 0; nsamp -= 8)
320 {
321 for (i = 0; i < 4; i++)
322 {
323 process_nibble(*src, &stepIndexL, &sampleL);
324 W16(dst + (2 * i + 0) * 4 + 0, sampleL);
325 process_nibble(*src++ >> 4, &stepIndexL, &sampleL);
326 W16(dst + (2 * i + 1) * 4 + 0, sampleL);
327 }
328 for (i = 0; i < 4; i++)
329 {
330 process_nibble(*src , &stepIndexR, &sampleR);
331 W16(dst + (2 * i + 0) * 4 + 2, sampleR);
332 process_nibble(*src++ >>4, &stepIndexR, &sampleR);
333 W16(dst + (2 * i + 1) * 4 + 2, sampleR);
334 }
335 dst += 32;
336 }
337 /* we have now to realign the source pointer on block */
338 src = in_src + adsi->pwfxSrc->nBlockAlign;
339 }
340 }
341
342 static void cvtMMima16K(PACMDRVSTREAMINSTANCE adsi,
343 const unsigned char* src, LPDWORD nsrc,
344 unsigned char* dst, LPDWORD ndst)
345 {
346 int sample;
347 int stepIndex;
348 int nsamp_blk = ((LPIMAADPCMWAVEFORMAT)adsi->pwfxSrc)->wSamplesPerBlock;
349 int nsamp;
350 /* compute the number of entire blocks we can decode...
351 * it's the min of the number of entire blocks in source buffer and the number
352 * of entire blocks in destination buffer
353 */
354 DWORD nblock = min(*nsrc / adsi->pwfxSrc->nBlockAlign,
355 *ndst / (nsamp_blk * 2));
356
357 *nsrc = nblock * adsi->pwfxSrc->nBlockAlign;
358 *ndst = nblock * nsamp_blk * 2;
359
360 nsamp_blk--; /* remove the sample in block header */
361 for (; nblock > 0; nblock--)
362 {
363 const unsigned char* in_src = src;
364
365 /* handle header first */
366 sample = R16(src);
367 stepIndex = (unsigned)*(src + 2);
368 clamp_step_index(&stepIndex);
369 src += 4;
370 W16(dst, sample); dst += 2;
371
372 for (nsamp = nsamp_blk; nsamp > 0; nsamp -= 2)
373 {
374 process_nibble(*src, &stepIndex, &sample);
375 W16(dst, sample); dst += 2;
376 process_nibble(*src++ >> 4, &stepIndex, &sample);
377 W16(dst, sample); dst += 2;
378 }
379 /* we have now to realign the source pointer on block */
380 src = in_src + adsi->pwfxSrc->nBlockAlign;
381 }
382 }
383
384 static void cvtSS16imaK(PACMDRVSTREAMINSTANCE adsi,
385 const unsigned char* src, LPDWORD nsrc,
386 unsigned char* dst, LPDWORD ndst)
387 {
388 int stepIndexL, stepIndexR;
389 int sampleL, sampleR;
390 BYTE code1, code2;
391 int nsamp_blk = ((LPIMAADPCMWAVEFORMAT)adsi->pwfxDst)->wSamplesPerBlock;
392 int i, nsamp;
393 /* compute the number of entire blocks we can decode...
394 * it's the min of the number of entire blocks in source buffer and the number
395 * of entire blocks in destination buffer
396 */
397 DWORD nblock = min(*nsrc / (nsamp_blk * 2 * 2),
398 *ndst / adsi->pwfxDst->nBlockAlign);
399
400 *nsrc = nblock * (nsamp_blk * 2 * 2);
401 *ndst = nblock * adsi->pwfxDst->nBlockAlign;
402
403 stepIndexL = ((AcmAdpcmData*)adsi->dwDriver)->stepIndexL;
404 stepIndexR = ((AcmAdpcmData*)adsi->dwDriver)->stepIndexR;
405
406 nsamp_blk--; /* so that we won't count the sample in header while filling the block */
407
408 for (; nblock > 0; nblock--)
409 {
410 unsigned char* in_dst = dst;
411
412 /* generate header */
413 sampleL = R16(src); src += 2;
414 W16(dst, sampleL); dst += 2;
415 *dst = (unsigned char)(unsigned)stepIndexL;
416 dst += 2;
417
418 sampleR = R16(src); src += 2;
419 W16(dst, sampleR); dst += 2;
420 *dst = (unsigned char)(unsigned)stepIndexR;
421 dst += 2;
422
423 for (nsamp = nsamp_blk; nsamp > 0; nsamp -= 8)
424 {
425 for (i = 0; i < 4; i++)
426 {
427 code1 = generate_nibble(R16(src + (2 * i + 0) * 2 + 0),
428 &stepIndexL, &sampleL);
429 code2 = generate_nibble(R16(src + (2 * i + 1) * 2 + 0),
430 &stepIndexL, &sampleL);
431 *dst++ = (code1 << 4) | code2;
432 }
433 for (i = 0; i < 4; i++)
434 {
435 code1 = generate_nibble(R16(src + (2 * i + 0) * 2 + 1),
436 &stepIndexR, &sampleR);
437 code2 = generate_nibble(R16(src + (2 * i + 1) * 2 + 1),
438 &stepIndexR, &sampleR);
439 *dst++ = (code1 << 4) | code2;
440 }
441 src += 32;
442 }
443 dst = in_dst + adsi->pwfxDst->nBlockAlign;
444 }
445 ((AcmAdpcmData*)adsi->dwDriver)->stepIndexL = stepIndexL;
446 ((AcmAdpcmData*)adsi->dwDriver)->stepIndexR = stepIndexR;
447 }
448
449 static void cvtMM16imaK(PACMDRVSTREAMINSTANCE adsi,
450 const unsigned char* src, LPDWORD nsrc,
451 unsigned char* dst, LPDWORD ndst)
452 {
453 int stepIndex;
454 int sample;
455 BYTE code1, code2;
456 int nsamp_blk = ((LPIMAADPCMWAVEFORMAT)adsi->pwfxDst)->wSamplesPerBlock;
457 int nsamp;
458 /* compute the number of entire blocks we can decode...
459 * it's the min of the number of entire blocks in source buffer and the number
460 * of entire blocks in destination buffer
461 */
462 DWORD nblock = min(*nsrc / (nsamp_blk * 2),
463 *ndst / adsi->pwfxDst->nBlockAlign);
464
465 *nsrc = nblock * (nsamp_blk * 2);
466 *ndst = nblock * adsi->pwfxDst->nBlockAlign;
467
468 stepIndex = ((AcmAdpcmData*)adsi->dwDriver)->stepIndexL;
469 nsamp_blk--; /* so that we won't count the sample in header while filling the block */
470
471 for (; nblock > 0; nblock--)
472 {
473 unsigned char* in_dst = dst;
474
475 /* generate header */
476 /* FIXME: what about the last effective sample from previous block ??? */
477 /* perhaps something like:
478 * sample += R16(src);
479 * clamp_sample(sample);
480 * and with :
481 * + saving the sample in adsi->dwDriver when all blocks are done
482 + + reset should set the field in adsi->dwDriver to 0 too
483 */
484 sample = R16(src); src += 2;
485 W16(dst, sample); dst += 2;
486 *dst = (unsigned char)(unsigned)stepIndex;
487 dst += 2;
488
489 for (nsamp = nsamp_blk; nsamp > 0; nsamp -= 2)
490 {
491 code1 = generate_nibble(R16(src), &stepIndex, &sample);
492 src += 2;
493 code2 = generate_nibble(R16(src), &stepIndex, &sample);
494 src += 2;
495 *dst++ = (code1 << 4) | code2;
496 }
497 dst = in_dst + adsi->pwfxDst->nBlockAlign;
498 }
499 ((AcmAdpcmData*)adsi->dwDriver)->stepIndexL = stepIndex;
500 }
501
502 /***********************************************************************
503 * ADPCM_DriverDetails
504 *
505 */
506 static LRESULT ADPCM_DriverDetails(PACMDRIVERDETAILSW add)
507 {
508 add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
509 add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
510 add->wMid = 0x1;
511 add->wPid = 0x22;
512 add->vdwACM = 0x3320000;
513 add->vdwDriver = 0x04000000;
514 add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
515 add->cFormatTags = 2; /* PCM, IMA ADPCM */
516 add->cFilterTags = 0;
517 add->hicon = NULL;
518 MultiByteToWideChar( CP_ACP, 0, "Microsoft IMA ADPCM", -1,
519 add->szShortName, sizeof(add->szShortName)/sizeof(WCHAR) );
520 MultiByteToWideChar( CP_ACP, 0, "Microsoft IMA ADPCM CODEC", -1,
521 add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) );
522 MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
523 add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) );
524 MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
525 add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
526 add->szFeatures[0] = 0;
527
528 return MMSYSERR_NOERROR;
529 }
530
531 /***********************************************************************
532 * ADPCM_FormatTagDetails
533 *
534 */
535 static LRESULT ADPCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
536 {
537 static const WCHAR szPcm[]={'P','C','M',0};
538 static const WCHAR szImaAdPcm[]={'I','M','A',' ','A','D','P','C','M',0};
539
540 switch (dwQuery)
541 {
542 case ACM_FORMATTAGDETAILSF_INDEX:
543 if (aftd->dwFormatTagIndex >= 2) return ACMERR_NOTPOSSIBLE;
544 break;
545 case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
546 if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
547 {
548 aftd->dwFormatTagIndex = 1; /* WAVE_FORMAT_IMA_ADPCM is bigger than PCM */
549 break;
550 }
551 /* fall thru */
552 case ACM_FORMATTAGDETAILSF_FORMATTAG:
553 switch (aftd->dwFormatTag)
554 {
555 case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break;
556 case WAVE_FORMAT_IMA_ADPCM: aftd->dwFormatTagIndex = 1; break;
557 default: return ACMERR_NOTPOSSIBLE;
558 }
559 break;
560 default:
561 WARN("Unsupported query %08x\n", dwQuery);
562 return MMSYSERR_NOTSUPPORTED;
563 }
564
565 aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
566 switch (aftd->dwFormatTagIndex)
567 {
568 case 0:
569 aftd->dwFormatTag = WAVE_FORMAT_PCM;
570 aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
571 aftd->cStandardFormats = NUM_PCM_FORMATS;
572 lstrcpyW(aftd->szFormatTag, szPcm);
573 break;
574 case 1:
575 aftd->dwFormatTag = WAVE_FORMAT_IMA_ADPCM;
576 aftd->cbFormatSize = sizeof(IMAADPCMWAVEFORMAT);
577 aftd->cStandardFormats = NUM_ADPCM_FORMATS;
578 lstrcpyW(aftd->szFormatTag, szImaAdPcm);
579 break;
580 }
581 return MMSYSERR_NOERROR;
582 }
583
584 /***********************************************************************
585 * ADPCM_FormatDetails
586 *
587 */
588 static LRESULT ADPCM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
589 {
590 switch (dwQuery)
591 {
592 case ACM_FORMATDETAILSF_FORMAT:
593 if (ADPCM_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
594 break;
595 case ACM_FORMATDETAILSF_INDEX:
596 afd->pwfx->wFormatTag = afd->dwFormatTag;
597 switch (afd->dwFormatTag)
598 {
599 case WAVE_FORMAT_PCM:
600 if (afd->dwFormatIndex >= NUM_PCM_FORMATS) return ACMERR_NOTPOSSIBLE;
601 afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
602 afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
603 afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
604 /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
605 * afd->pwfx->cbSize = 0;
606 */
607 afd->pwfx->nBlockAlign =
608 (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
609 afd->pwfx->nAvgBytesPerSec =
610 afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
611 break;
612 case WAVE_FORMAT_IMA_ADPCM:
613 if (afd->dwFormatIndex >= NUM_ADPCM_FORMATS) return ACMERR_NOTPOSSIBLE;
614 afd->pwfx->nChannels = ADPCM_Formats[afd->dwFormatIndex].nChannels;
615 afd->pwfx->nSamplesPerSec = ADPCM_Formats[afd->dwFormatIndex].rate;
616 afd->pwfx->wBitsPerSample = ADPCM_Formats[afd->dwFormatIndex].nBits;
617 afd->pwfx->nBlockAlign = 1024;
618 /* we got 4 bits per sample */
619 afd->pwfx->nAvgBytesPerSec =
620 (afd->pwfx->nSamplesPerSec * 4) / 8;
621 if (afd->cbwfx >= sizeof(WAVEFORMATEX))
622 afd->pwfx->cbSize = sizeof(WORD);
623 if (afd->cbwfx >= sizeof(IMAADPCMWAVEFORMAT))
624 ((IMAADPCMWAVEFORMAT*)afd->pwfx)->wSamplesPerBlock = (1024 - 4 * afd->pwfx->nChannels) * (2 / afd->pwfx->nChannels) + 1;
625 break;
626 default:
627 WARN("Unsupported tag %08x\n", afd->dwFormatTag);
628 return MMSYSERR_INVALPARAM;
629 }
630 break;
631 default:
632 WARN("Unsupported query %08x\n", dwQuery);
633 return MMSYSERR_NOTSUPPORTED;
634 }
635 afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
636 afd->szFormat[0] = 0; /* let MSACM format this for us... */
637
638 return MMSYSERR_NOERROR;
639 }
640
641 /***********************************************************************
642 * ADPCM_FormatSuggest
643 *
644 */
645 static LRESULT ADPCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
646 {
647 /* some tests ... */
648 if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
649 adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
650 adfs->pwfxSrc->wFormatTag == adfs->pwfxDst->wFormatTag ||
651 ADPCM_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
652
653 /* If no suggestion for destination, then copy source value */
654 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS))
655 adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
656 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC))
657 adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
658
659 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE))
660 {
661 if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
662 adfs->pwfxDst->wBitsPerSample = 4;
663 else
664 adfs->pwfxDst->wBitsPerSample = 16;
665 }
666 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
667 {
668 if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
669 adfs->pwfxDst->wFormatTag = WAVE_FORMAT_IMA_ADPCM;
670 else
671 adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM;
672 }
673
674 /* recompute other values */
675 switch (adfs->pwfxDst->wFormatTag)
676 {
677 case WAVE_FORMAT_PCM:
678 if (adfs->cbwfxSrc < sizeof(IMAADPCMWAVEFORMAT)) return ACMERR_NOTPOSSIBLE;
679 adfs->pwfxDst->nBlockAlign = (adfs->pwfxDst->nChannels * adfs->pwfxDst->wBitsPerSample) / 8;
680 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxDst->nBlockAlign;
681 /* check if result is ok */
682 if (ADPCM_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
683 break;
684 case WAVE_FORMAT_IMA_ADPCM:
685 if (adfs->cbwfxDst < sizeof(IMAADPCMWAVEFORMAT)) return ACMERR_NOTPOSSIBLE;
686 init_wfx_ima_adpcm((IMAADPCMWAVEFORMAT*)adfs->pwfxDst);
687 /* FIXME: not handling header overhead */
688 TRACE("setting spb=%u\n", ((IMAADPCMWAVEFORMAT*)adfs->pwfxDst)->wSamplesPerBlock);
689 /* check if result is ok */
690 if (ADPCM_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
691 break;
692 default:
693 return ACMERR_NOTPOSSIBLE;
694 }
695
696 return MMSYSERR_NOERROR;
697 }
698
699 /***********************************************************************
700 * ADPCM_Reset
701 *
702 */
703 static void ADPCM_Reset(PACMDRVSTREAMINSTANCE adsi, AcmAdpcmData* aad)
704 {
705 aad->stepIndexL = aad->stepIndexR = 0;
706 }
707
708 /***********************************************************************
709 * ADPCM_StreamOpen
710 *
711 */
712 static LRESULT ADPCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
713 {
714 AcmAdpcmData* aad;
715 unsigned nspb;
716
717 assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
718
719 if (ADPCM_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
720 ADPCM_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
721 return ACMERR_NOTPOSSIBLE;
722
723 aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmAdpcmData));
724 if (aad == 0) return MMSYSERR_NOMEM;
725
726 adsi->dwDriver = (DWORD_PTR)aad;
727
728 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
729 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
730 {
731 goto theEnd;
732 }
733 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_IMA_ADPCM &&
734 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
735 {
736 /* resampling or mono <=> stereo not available
737 * ADPCM algo only define 16 bit per sample output
738 */
739 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
740 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
741 adsi->pwfxDst->wBitsPerSample != 16)
742 goto theEnd;
743
744 nspb = ((LPIMAADPCMWAVEFORMAT)adsi->pwfxSrc)->wSamplesPerBlock;
745 TRACE("spb=%u\n", nspb);
746
747 /* we check that in a block, after the header, samples are present on
748 * 4-sample packet pattern
749 * we also check that the block alignment is bigger than the expected size
750 */
751 if (((nspb - 1) & 3) != 0) goto theEnd;
752 if ((((nspb - 1) / 2) + 4) * adsi->pwfxSrc->nChannels < adsi->pwfxSrc->nBlockAlign)
753 goto theEnd;
754
755 /* adpcm decoding... */
756 if (adsi->pwfxDst->wBitsPerSample == 16 && adsi->pwfxDst->nChannels == 2)
757 aad->convert = cvtSSima16K;
758 if (adsi->pwfxDst->wBitsPerSample == 16 && adsi->pwfxDst->nChannels == 1)
759 aad->convert = cvtMMima16K;
760 }
761 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
762 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_IMA_ADPCM)
763 {
764 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
765 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
766 adsi->pwfxSrc->wBitsPerSample != 16)
767 goto theEnd;
768
769 nspb = ((LPIMAADPCMWAVEFORMAT)adsi->pwfxDst)->wSamplesPerBlock;
770 TRACE("spb=%u\n", nspb);
771
772 /* we check that in a block, after the header, samples are present on
773 * 4-sample packet pattern
774 * we also check that the block alignment is bigger than the expected size
775 */
776 if (((nspb - 1) & 3) != 0) goto theEnd;
777 if ((((nspb - 1) / 2) + 4) * adsi->pwfxDst->nChannels < adsi->pwfxDst->nBlockAlign)
778 goto theEnd;
779
780 /* adpcm coding... */
781 if (adsi->pwfxSrc->wBitsPerSample == 16 && adsi->pwfxSrc->nChannels == 2)
782 aad->convert = cvtSS16imaK;
783 if (adsi->pwfxSrc->wBitsPerSample == 16 && adsi->pwfxSrc->nChannels == 1)
784 aad->convert = cvtMM16imaK;
785 }
786 else goto theEnd;
787 ADPCM_Reset(adsi, aad);
788
789 return MMSYSERR_NOERROR;
790
791 theEnd:
792 HeapFree(GetProcessHeap(), 0, aad);
793 adsi->dwDriver = 0L;
794 return MMSYSERR_NOTSUPPORTED;
795 }
796
797 /***********************************************************************
798 * ADPCM_StreamClose
799 *
800 */
801 static LRESULT ADPCM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
802 {
803 HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
804 return MMSYSERR_NOERROR;
805 }
806
807 /***********************************************************************
808 * ADPCM_StreamSize
809 *
810 */
811 static LRESULT ADPCM_StreamSize(const ACMDRVSTREAMINSTANCE *adsi, PACMDRVSTREAMSIZE adss)
812 {
813 DWORD nblocks;
814
815 switch (adss->fdwSize)
816 {
817 case ACM_STREAMSIZEF_DESTINATION:
818 /* cbDstLength => cbSrcLength */
819 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
820 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_IMA_ADPCM)
821 {
822 nblocks = adss->cbDstLength / adsi->pwfxDst->nBlockAlign;
823 if (nblocks == 0)
824 return ACMERR_NOTPOSSIBLE;
825 adss->cbSrcLength = nblocks * adsi->pwfxSrc->nBlockAlign * ((IMAADPCMWAVEFORMAT*)adsi->pwfxDst)->wSamplesPerBlock;
826 }
827 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_IMA_ADPCM &&
828 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
829 {
830 nblocks = adss->cbDstLength / (adsi->pwfxDst->nBlockAlign * ((IMAADPCMWAVEFORMAT*)adsi->pwfxSrc)->wSamplesPerBlock);
831 if (nblocks == 0)
832 return ACMERR_NOTPOSSIBLE;
833 adss->cbSrcLength = nblocks * adsi->pwfxSrc->nBlockAlign;
834 }
835 else
836 {
837 return MMSYSERR_NOTSUPPORTED;
838 }
839 break;
840 case ACM_STREAMSIZEF_SOURCE:
841 /* cbSrcLength => cbDstLength */
842 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
843 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_IMA_ADPCM)
844 {
845 nblocks = adss->cbSrcLength / (adsi->pwfxSrc->nBlockAlign * ((IMAADPCMWAVEFORMAT*)adsi->pwfxDst)->wSamplesPerBlock);
846 if (nblocks == 0)
847 return ACMERR_NOTPOSSIBLE;
848 if (adss->cbSrcLength % (adsi->pwfxSrc->nBlockAlign * ((IMAADPCMWAVEFORMAT*)adsi->pwfxDst)->wSamplesPerBlock))
849 /* Round block count up. */
850 nblocks++;
851 adss->cbDstLength = nblocks * adsi->pwfxDst->nBlockAlign;
852 }
853 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_IMA_ADPCM &&
854 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
855 {
856 nblocks = adss->cbSrcLength / adsi->pwfxSrc->nBlockAlign;
857 if (nblocks == 0)
858 return ACMERR_NOTPOSSIBLE;
859 if (adss->cbSrcLength % adsi->pwfxSrc->nBlockAlign)
860 /* Round block count up. */
861 nblocks++;
862 adss->cbDstLength = nblocks * adsi->pwfxDst->nBlockAlign * ((IMAADPCMWAVEFORMAT*)adsi->pwfxSrc)->wSamplesPerBlock;
863 }
864 else
865 {
866 return MMSYSERR_NOTSUPPORTED;
867 }
868 break;
869 default:
870 WARN("Unsupported query %08x\n", adss->fdwSize);
871 return MMSYSERR_NOTSUPPORTED;
872 }
873 return MMSYSERR_NOERROR;
874 }
875
876 /***********************************************************************
877 * ADPCM_StreamConvert
878 *
879 */
880 static LRESULT ADPCM_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
881 {
882 AcmAdpcmData* aad = (AcmAdpcmData*)adsi->dwDriver;
883 DWORD nsrc = adsh->cbSrcLength;
884 DWORD ndst = adsh->cbDstLength;
885
886 if (adsh->fdwConvert &
887 ~(ACM_STREAMCONVERTF_BLOCKALIGN|
888 ACM_STREAMCONVERTF_END|
889 ACM_STREAMCONVERTF_START))
890 {
891 FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert);
892 }
893 /* ACM_STREAMCONVERTF_BLOCKALIGN
894 * currently all conversions are block aligned, so do nothing for this flag
895 * ACM_STREAMCONVERTF_END
896 * no pending data, so do nothing for this flag
897 */
898 if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START))
899 {
900 ADPCM_Reset(adsi, aad);
901 }
902
903 aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst);
904 adsh->cbSrcLengthUsed = nsrc;
905 adsh->cbDstLengthUsed = ndst;
906
907 return MMSYSERR_NOERROR;
908 }
909
910 /**************************************************************************
911 * ADPCM_DriverProc [exported]
912 */
913 LRESULT CALLBACK ADPCM_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
914 LPARAM dwParam1, LPARAM dwParam2)
915 {
916 TRACE("(%08lx %p %04x %08lx %08lx);\n",
917 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
918
919 switch (wMsg)
920 {
921 case DRV_LOAD: return 1;
922 case DRV_FREE: return 1;
923 case DRV_OPEN: return 1;
924 case DRV_CLOSE: return ADPCM_drvClose(dwDevID);
925 case DRV_ENABLE: return 1;
926 case DRV_DISABLE: return 1;
927 case DRV_QUERYCONFIGURE: return 1;
928 case DRV_CONFIGURE: MessageBoxA(0, "MSACM IMA ADPCM filter !", "Wine Driver", MB_OK); return 1;
929 case DRV_INSTALL: return DRVCNF_RESTART;
930 case DRV_REMOVE: return DRVCNF_RESTART;
931
932 case ACMDM_DRIVER_NOTIFY:
933 /* no caching from other ACM drivers is done so far */
934 return MMSYSERR_NOERROR;
935
936 case ACMDM_DRIVER_DETAILS:
937 return ADPCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
938
939 case ACMDM_FORMATTAG_DETAILS:
940 return ADPCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
941
942 case ACMDM_FORMAT_DETAILS:
943 return ADPCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
944
945 case ACMDM_FORMAT_SUGGEST:
946 return ADPCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
947
948 case ACMDM_STREAM_OPEN:
949 return ADPCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
950
951 case ACMDM_STREAM_CLOSE:
952 return ADPCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
953
954 case ACMDM_STREAM_SIZE:
955 return ADPCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
956
957 case ACMDM_STREAM_CONVERT:
958 return ADPCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
959
960 case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
961 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
962 /* this converter is not a hardware driver */
963 case ACMDM_FILTERTAG_DETAILS:
964 case ACMDM_FILTER_DETAILS:
965 /* this converter is not a filter */
966 case ACMDM_STREAM_RESET:
967 /* only needed for asynchronous driver... we aren't, so just say it */
968 return MMSYSERR_NOTSUPPORTED;
969 case ACMDM_STREAM_PREPARE:
970 case ACMDM_STREAM_UNPREPARE:
971 /* nothing special to do here... so don't do anything */
972 return MMSYSERR_NOERROR;
973
974 default:
975 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
976 }
977 }
A free Windows-compatible Operating System