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