?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed merge error.
[wine/wine64.git] / dlls / msacm / pcmconverter.c
blobf895a84afc8d470458608fd44a19a68ecf386767
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MSACM32 library
5 *
6 * Copyright 2000 Eric Pouech
7 *
8 * FIXME / TODO list
9 * + most of the computation should be done in fixed point arithmetic
10 * instead of floating point (16 bits for integral part, and 16 bits
11 * for fractional part for example)
12 * + implement PCM_FormatSuggest function
13 * + get rid of hack for PCM_DriverProc (msacm32.dll shouldn't export
14 * a DriverProc, but this would require implementing a generic
15 * embedded driver handling scheme in msacm32.dll which isn't done yet
16 */
17
18 #include "config.h"
19
20 #include <assert.h>
21 #include <string.h>
22
23 #include "msacm.h"
24 #include "winbase.h"
25 #include "wingdi.h"
26 #include "winnls.h"
27 #include "winuser.h"
28
29 #include "msacmdrv.h"
30 #include "wineacm.h"
31
32 #include "debugtools.h"
33
34 DEFAULT_DEBUG_CHANNEL(msacm);
35
36 /***********************************************************************
37 * PCM_drvOpen
38 */
39 static DWORD PCM_drvOpen(LPCSTR str, PACMDRVOPENDESCW adod)
40 {
41 return (adod == NULL) ||
42 (adod->fccType == ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC &&
43 adod->fccComp == ACMDRIVERDETAILS_FCCCOMP_UNDEFINED);
44 }
45
46 /***********************************************************************
47 * PCM_drvClose
48 */
49 static DWORD PCM_drvClose(DWORD dwDevID)
50 {
51 return 1;
52 }
53
54 #define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
55 #define NUM_OF(a,b) (((a)+(b)-1)/(b))
56
57 /* flags for fdwDriver */
58 #define PCM_RESAMPLE 1
59
60 /* data used while converting */
61 typedef struct tagAcmPcmData {
62 /* conversion routine, depending if rate conversion is required */
63 union {
64 void (*cvtKeepRate)(const unsigned char*, int, unsigned char*);
65 void (*cvtChangeRate)(struct tagAcmPcmData*, const unsigned char*,
66 LPDWORD, unsigned char*, LPDWORD);
67 } cvt;
68 /* the following fields are used only with rate conversion) */
69 DWORD srcPos; /* position in source stream */
70 double dstPos; /* position in destination stream */
71 double dstIncr; /* value to increment dst stream when src stream
72 is incremented by 1 */
73 /* last source stream value read */
74 union {
75 unsigned char b; /* 8 bit value */
76 short s; /* 16 bit value */
77 } last[2]; /* two channels max (stereo) */
78 } AcmPcmData;
79
80 /* table to list all supported formats... those are the basic ones. this
81 * also helps given a unique index to each of the supported formats
82 */
83 static struct {
84 int nChannels;
85 int nBits;
86 int rate;
87 } PCM_Formats[] = {
88 {1, 8, 8000}, {2, 8, 8000}, {1, 16, 8000}, {2, 16, 8000},
89 {1, 8, 11025}, {2, 8, 11025}, {1, 16, 11025}, {2, 16, 11025},
90 {1, 8, 22050}, {2, 8, 22050}, {1, 16, 22050}, {2, 16, 22050},
91 {1, 8, 44100}, {2, 8, 44100}, {1, 16, 44100}, {2, 16, 44100},
92 };
93
94 /***********************************************************************
95 * PCM_GetFormatIndex
96 */
97 static DWORD PCM_GetFormatIndex(LPWAVEFORMATEX wfx)
98 {
99 int i;
100
101 for (i = 0; i < NUM_PCM_FORMATS; i++) {
102 if (wfx->nChannels == PCM_Formats[i].nChannels &&
103 wfx->nSamplesPerSec == PCM_Formats[i].rate &&
104 wfx->wBitsPerSample == PCM_Formats[i].nBits)
105 return i;
106 }
107 return 0xFFFFFFFF;
108 }
109
110 /* PCM Conversions:
111 *
112 * parameters:
113 * + 8 bit unsigned vs 16 bit signed
114 * + mono vs stereo (1 or 2 channels)
115 * + sampling rate (8.0, 11.025, 22.05, 44.1 kHz are defined, but algo shall work
116 * in all cases)
117 *
118 * mono => stereo: copy the same sample on Left & Right channels
119 * stereo =) mono: use the average value of samples from Left & Right channels
120 * resampling; we lookup for each destination sample the two source adjacent samples
121 * were src <= dst < src+1 (dst is increased by a fractional value which is
122 * equivalent to the increment by one on src); then we use a linear
123 * interpolation between src and src+1
124 */
125
126 /***********************************************************************
127 * C816
128 *
129 * Converts a 8 bit sample to a 16 bit one
130 */
131 static inline short C816(unsigned char b)
132 {
133 return (short)(b ^ 0x80) * 256;
134 }
135
136 /***********************************************************************
137 * C168
138 *
139 * Converts a 16 bit sample to a 8 bit one (data loss !!)
140 */
141 static inline unsigned char C168(short s)
142 {
143 return HIBYTE(s) ^ (unsigned char)0x80;
144 }
145
146 /***********************************************************************
147 * R16
148 *
149 * Read a 16 bit sample (correctly handles endianess)
150 */
151 static inline short R16(const unsigned char* src)
152 {
153 return (short)((unsigned short)src[0] | ((unsigned short)src[1] << 8));
154 }
155
156 /***********************************************************************
157 * W16
158 *
159 * Write a 16 bit sample (correctly handles endianess)
160 */
161 static inline void W16(unsigned char* dst, short s)
162 {
163 dst[0] = LOBYTE(s);
164 dst[1] = HIBYTE(s);
165 }
166
167 /***********************************************************************
168 * M16
169 *
170 * Convert the (l,r) 16 bit stereo sample into a 16 bit mono
171 * (takes the mid-point of the two values)
172 */
173 static inline short M16(short l, short r)
174 {
175 return (l + r) / 2;
176 }
177
178 /***********************************************************************
179 * M8
180 *
181 * Convert the (l,r) 8 bit stereo sample into a 8 bit mono
182 * (takes the mid-point of the two values)
183 */
184 static inline unsigned char M8(unsigned char a, unsigned char b)
185 {
186 return (unsigned char)((a + b) / 2);
187 }
188
189 /* the conversion routines without rate conversion are labelled cvt<X><Y><N><M>K
190 * where :
191 * <X> is the (M)ono/(S)tereo configuration of input channel
192 * <Y> is the (M)ono/(S)tereo configuration of output channel
193 * <N> is the number of bits of input channel (8 or 16)
194 * <M> is the number of bits of output channel (8 or 16)
195 *
196 * in the parameters, ns is always the number of samples, so the size of input
197 * buffer (resp output buffer) is ns * (<X> == 'Mono' ? 1:2) * (<N> == 8 ? 1:2)
198 */
199
200 static void cvtMM88K(const unsigned char* src, int ns, unsigned char* dst)
201 {
202 memcpy(dst, src, ns);
203 }
204
205 static void cvtSS88K(const unsigned char* src, int ns, unsigned char* dst)
206 {
207 memcpy(dst, src, ns * 2);
208 }
209
210 static void cvtMM1616K(const unsigned char* src, int ns, unsigned char* dst)
211 {
212 memcpy(dst, src, ns * 2);
213 }
214
215 static void cvtSS1616K(const unsigned char* src, int ns, unsigned char* dst)
216 {
217 memcpy(dst, src, ns * 4);
218 }
219
220 static void cvtMS88K(const unsigned char* src, int ns, unsigned char* dst)
221 {
222 while (ns--) {
223 *dst++ = *src;
224 *dst++ = *src++;
225 }
226 }
227
228 static void cvtMS816K(const unsigned char* src, int ns, unsigned char* dst)
229 {
230 short v;
231
232 while (ns--) {
233 v = C816(*src++);
234 W16(dst, v); dst += 2;
235 W16(dst, v); dst += 2;
236 }
237 }
238
239 static void cvtMS168K(const unsigned char* src, int ns, unsigned char* dst)
240 {
241 unsigned char v;
242
243 while (ns--) {
244 v = C168(R16(src)); src += 2;
245 *dst++ = v;
246 *dst++ = v;
247 }
248 }
249
250 static void cvtMS1616K(const unsigned char* src, int ns, unsigned char* dst)
251 {
252 short v;
253
254 while (ns--) {
255 v = R16(src); src += 2;
256 W16(dst, v); dst += 2;
257 W16(dst, v); dst += 2;
258 }
259 }
260
261 static void cvtSM88K(const unsigned char* src, int ns, unsigned char* dst)
262 {
263 while (ns--) {
264 *dst++ = M8(src[0], src[1]);
265 src += 2;
266 }
267 }
268
269 static void cvtSM816K(const unsigned char* src, int ns, unsigned char* dst)
270 {
271 short v;
272
273 while (ns--) {
274 v = M16(C816(src[0]), C816(src[1]));
275 src += 2;
276 W16(dst, v); dst += 2;
277 }
278 }
279
280 static void cvtSM168K(const unsigned char* src, int ns, unsigned char* dst)
281 {
282 while (ns--) {
283 *dst++ = C168(M16(R16(src), R16(src + 2)));
284 src += 4;
285 }
286 }
287
288 static void cvtSM1616K(const unsigned char* src, int ns, unsigned char* dst)
289 {
290 while (ns--) {
291 W16(dst, M16(R16(src),R16(src+2))); dst += 2;
292 src += 4;
293 }
294 }
295
296 static void cvtMM816K(const unsigned char* src, int ns, unsigned char* dst)
297 {
298 while (ns--) {
299 W16(dst, C816(*src++)); dst += 2;
300 }
301 }
302
303 static void cvtSS816K(const unsigned char* src, int ns, unsigned char* dst)
304 {
305 while (ns--) {
306 W16(dst, C816(*src++)); dst += 2;
307 W16(dst, C816(*src++)); dst += 2;
308 }
309 }
310
311 static void cvtMM168K(const unsigned char* src, int ns, unsigned char* dst)
312 {
313 while (ns--) {
314 *dst++ = C168(R16(src)); src += 2;
315 }
316 }
317
318 static void cvtSS168K(const unsigned char* src, int ns, unsigned char* dst)
319 {
320 while (ns--) {
321 *dst++ = C168(R16(src)); src += 2;
322 *dst++ = C168(R16(src)); src += 2;
323 }
324 }
325
326 static void (*PCM_ConvertKeepRate[16])(const unsigned char*, int, unsigned char*) = {
327 cvtSS88K, cvtSM88K, cvtMS88K, cvtMM88K,
328 cvtSS816K, cvtSM816K, cvtMS816K, cvtMM816K,
329 cvtSS168K, cvtSM168K, cvtMS168K, cvtMM168K,
330 cvtSS1616K, cvtSM1616K, cvtMS1616K, cvtMM1616K,
331 };
332
333 /***********************************************************************
334 * I
335 *
336 * Interpolate the value at r (r in ]0, 1]) between the two points v1 and v2
337 * Linear interpolation is used
338 */
339 static inline double I(double v1, double v2, double r)
340 {
341 if (0.0 >= r || r > 1.0) FIXME("r!! %f\n", r);
342 return (1.0 - r) * v1 + r * v2;
343 }
344
345 static void cvtSS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
346 unsigned char* dst, LPDWORD ndst)
347 {
348 double r;
349
350 while (*nsrc != 0 && *ndst != 0) {
351 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
352 if (*nsrc == 0) return;
353 apd->last[0].b = *src++;
354 apd->last[1].b = *src++;
355 apd->srcPos++;
356 (*nsrc)--;
357 }
358 /* now do the interpolation */
359 *dst++ = I(apd->last[0].b, src[0], r);
360 *dst++ = I(apd->last[1].b, src[1], r);
361 apd->dstPos += apd->dstIncr;
362 (*ndst)--;
363 }
364 }
365
366 /* the conversion routines with rate conversion are labelled cvt<X><Y><N><M>C
367 * where :
368 * <X> is the (M)ono/(S)tereo configuration of input channel
369 * <Y> is the (M)ono/(S)tereo configuration of output channel
370 * <N> is the number of bits of input channel (8 or 16)
371 * <M> is the number of bits of output channel (8 or 16)
372 *
373 */
374 static void cvtSM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
375 unsigned char* dst, LPDWORD ndst)
376 {
377 double r;
378
379 while (*nsrc != 0 && *ndst != 0) {
380 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
381 if (*nsrc == 0) return;
382 apd->last[0].b = *src++;
383 apd->last[1].b = *src++;
384 apd->srcPos++;
385 (*nsrc)--;
386 }
387 /* now do the interpolation */
388 *dst++ = I(M8(apd->last[0].b, apd->last[1].b), M8(src[0], src[1]), r);
389 apd->dstPos += apd->dstIncr;
390 (*ndst)--;
391 }
392 }
393
394 static void cvtMS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
395 unsigned char* dst, LPDWORD ndst)
396 {
397 double r;
398
399 while (*nsrc != 0 && *ndst != 0) {
400 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
401 if (*nsrc == 0) return;
402 apd->last[0].b = *src++;
403 apd->srcPos++;
404 (*nsrc)--;
405 }
406 /* now do the interpolation */
407 dst[0] = dst[1] = I(apd->last[0].b, src[0], r);
408 dst += 2;
409 apd->dstPos += apd->dstIncr;
410 (*ndst)--;
411 }
412 }
413
414 static void cvtMM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
415 unsigned char* dst, LPDWORD ndst)
416 {
417 double r;
418
419 while (*nsrc != 0 && *ndst != 0) {
420 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
421 if (*nsrc == 0) return;
422 apd->last[0].b = *src++;
423 apd->srcPos++;
424 (*nsrc)--;
425 }
426 /* now do the interpolation */
427 *dst++ = I(apd->last[0].b, src[0], r);
428 apd->dstPos += apd->dstIncr;
429 (*ndst)--;
430 }
431 }
432
433 static void cvtSS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
434 unsigned char* dst, LPDWORD ndst)
435 {
436 double r;
437
438 while (*nsrc != 0 && *ndst != 0) {
439 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
440 if (*nsrc == 0) return;
441 apd->last[0].b = *src++;
442 apd->last[1].b = *src++;
443 apd->srcPos++;
444 (*nsrc)--;
445 }
446 /* now do the interpolation */
447 W16(dst, I(C816(apd->last[0].b), C816(src[0]), r)); dst += 2;
448 W16(dst, I(C816(apd->last[1].b), C816(src[1]), r)); dst += 2;
449 apd->dstPos += apd->dstIncr;
450 (*ndst)--;
451 }
452 }
453
454 static void cvtSM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
455 unsigned char* dst, LPDWORD ndst)
456 {
457 double r;
458
459 while (*nsrc != 0 && *ndst != 0) {
460 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
461 if (*nsrc == 0) return;
462 apd->last[0].b = *src++;
463 apd->last[1].b = *src++;
464 apd->srcPos++;
465 (*nsrc)--;
466 }
467 /* now do the interpolation */
468 W16(dst, I(M16(C816(apd->last[0].b), C816(apd->last[1].b)),
469 M16(C816(src[0]), C816(src[1])), r));
470 dst += 2;
471 apd->dstPos += apd->dstIncr;
472 (*ndst)--;
473 }
474 }
475
476 static void cvtMS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
477 unsigned char* dst, LPDWORD ndst)
478 {
479 double r;
480 short v;
481
482 while (*nsrc != 0 && *ndst != 0) {
483 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
484 if (*nsrc == 0) return;
485 apd->last[0].b = *src++;
486 apd->srcPos++;
487 (*nsrc)--;
488 }
489 /* now do the interpolation */
490 v = I(C816(apd->last[0].b), C816(src[0]), r);
491 W16(dst, v); dst += 2;
492 W16(dst, v); dst += 2;
493 apd->dstPos += apd->dstIncr;
494 (*ndst)--;
495 }
496 }
497
498 static void cvtMM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
499 unsigned char* dst, LPDWORD ndst)
500 {
501 double r;
502
503 while (*nsrc != 0 && *ndst != 0) {
504 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
505 if (*nsrc == 0) return;
506 apd->last[0].b = *src++;
507 apd->srcPos++;
508 (*nsrc)--;
509 }
510 /* now do the interpolation */
511 W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));
512 dst += 2;
513 apd->dstPos += apd->dstIncr;
514 (*ndst)--;
515 }
516 }
517
518 static void cvtSS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
519 unsigned char* dst, LPDWORD ndst)
520 {
521 double r;
522
523 while (*nsrc != 0 && *ndst != 0) {
524 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
525 if (*nsrc == 0) return;
526 apd->last[0].s = R16(src); src += 2;
527 apd->last[1].s = R16(src); src += 2;
528 apd->srcPos++;
529 (*nsrc)--;
530 }
531 /* now do the interpolation */
532 *dst++ = C168(I(apd->last[0].s, R16(src) , r));
533 *dst++ = C168(I(apd->last[1].s, R16(src+2), r));
534 apd->dstPos += apd->dstIncr;
535 (*ndst)--;
536 }
537 }
538
539 static void cvtSM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
540 unsigned char* dst, LPDWORD ndst)
541 {
542 double r;
543
544 while (*nsrc != 0 && *ndst != 0) {
545 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
546 if (*nsrc == 0) return;
547 apd->last[0].s = R16(src); src += 2;
548 apd->last[1].s = R16(src); src += 2;
549 apd->srcPos++;
550 (*nsrc)--;
551 }
552 /* now do the interpolation */
553 *dst++ = C168(I(M16(apd->last[0].s, apd->last[1].s),
554 M16(R16(src), R16(src + 2)), r));
555 apd->dstPos += apd->dstIncr;
556 (*ndst)--;
557 }
558 }
559
560
561 static void cvtMS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
562 unsigned char* dst, LPDWORD ndst)
563 {
564 double r;
565
566 while (*nsrc != 0 && *ndst != 0) {
567 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
568 if (*nsrc == 0) return;
569 apd->last[0].s = R16(src); src += 2;
570 apd->srcPos++;
571 (*nsrc)--;
572 }
573 /* now do the interpolation */
574 dst[0] = dst[1] = C168(I(apd->last[0].s, R16(src), r)); dst += 2;
575 apd->dstPos += apd->dstIncr;
576 (*ndst)--;
577 }
578 }
579
580
581 static void cvtMM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
582 unsigned char* dst, LPDWORD ndst)
583 {
584 double r;
585
586 while (*nsrc != 0 && *ndst != 0) {
587 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
588 if (*nsrc == 0) return;
589 apd->last[0].s = R16(src); src += 2;
590 apd->srcPos++;
591 (*nsrc)--;
592 }
593 /* now do the interpolation */
594 *dst++ = C168(I(apd->last[0].s, R16(src), r));
595 apd->dstPos += apd->dstIncr;
596 (*ndst)--;
597 }
598 }
599
600 static void cvtSS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
601 unsigned char* dst, LPDWORD ndst)
602 {
603 double r;
604
605 while (*nsrc != 0 && *ndst != 0) {
606 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
607 if (*nsrc == 0) return;
608 apd->last[0].s = R16(src); src += 2;
609 apd->last[1].s = R16(src); src += 2;
610 apd->srcPos++;
611 (*nsrc)--;
612 }
613 /* now do the interpolation */
614 W16(dst, I(apd->last[0].s, R16(src) , r)); dst += 2;
615 W16(dst, I(apd->last[1].s, R16(src+2), r)); dst += 2;
616 apd->dstPos += apd->dstIncr;
617 (*ndst)--;
618 }
619 }
620
621 static void cvtSM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
622 unsigned char* dst, LPDWORD ndst)
623 {
624 double r;
625
626 while (*nsrc != 0 && *ndst != 0) {
627 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
628 if (*nsrc == 0) return;
629 apd->last[0].s = R16(src); src += 2;
630 apd->last[1].s = R16(src); src += 2;
631 apd->srcPos++;
632 (*nsrc)--;
633 }
634 /* now do the interpolation */
635 W16(dst, I(M16(apd->last[0].s, apd->last[1].s),
636 M16(R16(src), R16(src+2)), r));
637 dst += 2;
638 apd->dstPos += apd->dstIncr;
639 (*ndst)--;
640 }
641 }
642
643 static void cvtMS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
644 unsigned char* dst, LPDWORD ndst)
645 {
646 double r;
647 short v;
648
649 while (*nsrc != 0 && *ndst != 0) {
650 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
651 if (*nsrc == 0) return;
652 apd->last[0].s = R16(src); src += 2;
653 apd->srcPos++;
654 (*nsrc)--;
655 }
656 /* now do the interpolation */
657 v = I(apd->last[0].s, R16(src), r);
658 W16(dst, v); dst += 2;
659 W16(dst, v); dst += 2;
660 apd->dstPos += apd->dstIncr;
661 (*ndst)--;
662 }
663 }
664
665 static void cvtMM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
666 unsigned char* dst, LPDWORD ndst)
667 {
668 double r;
669
670 while (*nsrc != 0 && *ndst != 0) {
671 while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
672 if (*nsrc == 0) return;
673 apd->last[0].s = R16(src); src += 2;
674 apd->srcPos++;
675 (*nsrc)--;
676 }
677 /* now do the interpolation */
678 W16(dst, I(apd->last[0].s, R16(src), r)); dst += 2;
679 apd->dstPos += apd->dstIncr;
680 (*ndst)--;
681 }
682 }
683
684 static void (*PCM_ConvertChangeRate[16])(AcmPcmData* apd,
685 const unsigned char* src, LPDWORD nsrc,
686 unsigned char* dst, LPDWORD ndst) = {
687 cvtSS88C, cvtSM88C, cvtMS88C, cvtMM88C,
688 cvtSS816C, cvtSM816C, cvtMS816C, cvtMM816C,
689 cvtSS168C, cvtSM168C, cvtMS168C, cvtMM168C,
690 cvtSS1616C, cvtSM1616C, cvtMS1616C, cvtMM1616C,
691 };
692
693 /***********************************************************************
694 * PCM_DriverDetails
695 *
696 */
697 static LRESULT PCM_DriverDetails(PACMDRIVERDETAILSW add)
698 {
699 add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
700 add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
701 add->wMid = 0xFF;
702 add->wPid = 0x00;
703 add->vdwACM = 0x01000000;
704 add->vdwDriver = 0x01000000;
705 add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CONVERTER;
706 add->cFormatTags = 1;
707 add->cFilterTags = 0;
708 add->hicon = (HICON)0;
709 MultiByteToWideChar( CP_ACP, 0, "WINE-PCM", -1,
710 add->szShortName, sizeof(add->szShortName)/sizeof(WCHAR) );
711 MultiByteToWideChar( CP_ACP, 0, "Wine PCM converter", -1,
712 add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) );
713 MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
714 add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) );
715 MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
716 add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
717 add->szFeatures[0] = 0;
718
719 return MMSYSERR_NOERROR;
720 }
721
722 /***********************************************************************
723 * PCM_FormatTagDetails
724 *
725 */
726 static LRESULT PCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
727 {
728 switch (dwQuery) {
729 case ACM_FORMATTAGDETAILSF_INDEX:
730 if (aftd->dwFormatTagIndex != 0) return ACMERR_NOTPOSSIBLE;
731 break;
732 case ACM_FORMATTAGDETAILSF_FORMATTAG:
733 if (aftd->dwFormatTag != WAVE_FORMAT_PCM) return ACMERR_NOTPOSSIBLE;
734 break;
735 case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
736 if (aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN &&
737 aftd->dwFormatTag != WAVE_FORMAT_PCM)
738 return ACMERR_NOTPOSSIBLE;
739 break;
740 default:
741 WARN("Unsupported query %08lx\n", dwQuery);
742 return MMSYSERR_NOTSUPPORTED;
743 }
744
745 aftd->dwFormatTagIndex = 0;
746 aftd->dwFormatTag = WAVE_FORMAT_PCM;
747 aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
748 aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CONVERTER;
749 aftd->cStandardFormats = NUM_PCM_FORMATS;
750 aftd->szFormatTag[0] = 0;
751
752 return MMSYSERR_NOERROR;
753 }
754
755 /***********************************************************************
756 * PCM_FormatDetails
757 *
758 */
759 static LRESULT PCM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
760 {
761 switch (dwQuery) {
762 case ACM_FORMATDETAILSF_FORMAT:
763 if (PCM_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
764 break;
765 case ACM_FORMATDETAILSF_INDEX:
766 assert(afd->dwFormatIndex < NUM_PCM_FORMATS);
767 afd->pwfx->wFormatTag = WAVE_FORMAT_PCM;
768 afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
769 afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
770 afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
771 /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
772 * afd->pwfx->cbSize = 0;
773 */
774 afd->pwfx->nBlockAlign =
775 (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
776 afd->pwfx->nAvgBytesPerSec =
777 afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
778 break;
779 default:
780 WARN("Unsupported query %08lx\n", dwQuery);
781 return MMSYSERR_NOTSUPPORTED;
782 }
783
784 afd->dwFormatTag = WAVE_FORMAT_PCM;
785 afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CONVERTER;
786 afd->szFormat[0] = 0; /* let MSACM format this for us... */
787 afd->cbwfx = sizeof(PCMWAVEFORMAT);
788
789 return MMSYSERR_NOERROR;
790 }
791
792 /***********************************************************************
793 * PCM_FormatSuggest
794 *
795 */
796 static LRESULT PCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
797 {
798 /* some tests ... */
799 if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
800 adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
801 PCM_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
802
803 /* is no suggestion for destination, then copy source value */
804 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS)) {
805 adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
806 }
807 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC)) {
808 adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
809 }
810 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE)) {
811 adfs->pwfxDst->wBitsPerSample = adfs->pwfxSrc->wBitsPerSample;
812 }
813 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG)) {
814 if (adfs->pwfxSrc->wFormatTag != WAVE_FORMAT_PCM) return ACMERR_NOTPOSSIBLE;
815 adfs->pwfxDst->wFormatTag = adfs->pwfxSrc->wFormatTag;
816 }
817 /* check if result is ok */
818 if (PCM_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
819
820 /* recompute other values */
821 adfs->pwfxDst->nBlockAlign = (adfs->pwfxDst->nChannels * adfs->pwfxDst->wBitsPerSample) / 8;
822 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxDst->nBlockAlign;
823
824 return MMSYSERR_NOERROR;
825 }
826
827 /***********************************************************************
828 * PCM_Reset
829 *
830 */
831 static void PCM_Reset(AcmPcmData* apd, int srcNumBits)
832 {
833 apd->srcPos = 0;
834 apd->dstPos = 0;
835 /* initialize with neutral value */
836 if (srcNumBits == 16) {
837 apd->last[0].s = 0;
838 apd->last[1].s = 0;
839 } else {
840 apd->last[0].b = (BYTE)0x80;
841 apd->last[1].b = (BYTE)0x80;
842 }
843 }
844
845 /***********************************************************************
846 * PCM_StreamOpen
847 *
848 */
849 static LRESULT PCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
850 {
851 AcmPcmData* apd;
852 int idx = 0;
853
854 assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
855
856 if (PCM_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
857 PCM_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
858 return ACMERR_NOTPOSSIBLE;
859
860 apd = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmPcmData));
861 if (apd == 0) return MMSYSERR_NOMEM;
862
863 adsi->dwDriver = (DWORD)apd;
864 adsi->fdwDriver = 0;
865
866 if (adsi->pwfxSrc->wBitsPerSample == 16) idx += 8;
867 if (adsi->pwfxDst->wBitsPerSample == 16) idx += 4;
868 if (adsi->pwfxSrc->nChannels == 1) idx += 2;
869 if (adsi->pwfxDst->nChannels == 1) idx += 1;
870
871 if (adsi->pwfxSrc->nSamplesPerSec == adsi->pwfxDst->nSamplesPerSec) {
872 apd->cvt.cvtKeepRate = PCM_ConvertKeepRate[idx];
873 } else {
874 adsi->fdwDriver |= PCM_RESAMPLE;
875 apd->dstIncr = (double)(adsi->pwfxSrc->nSamplesPerSec) /
876 (double)(adsi->pwfxDst->nSamplesPerSec);
877 PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
878 apd->cvt.cvtChangeRate = PCM_ConvertChangeRate[idx];
879 }
880
881 return MMSYSERR_NOERROR;
882 }
883
884 /***********************************************************************
885 * PCM_StreamClose
886 *
887 */
888 static LRESULT PCM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
889 {
890 HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
891 return MMSYSERR_NOERROR;
892 }
893
894 /***********************************************************************
895 * PCM_round
896 *
897 */
898 static inline DWORD PCM_round(DWORD a, DWORD b, DWORD c)
899 {
900 assert(a && b && c);
901 /* to be sure, always return an entire number of c... */
902 return ((double)a * (double)b + (double)c - 1) / (double)c;
903 }
904
905 /***********************************************************************
906 * PCM_StreamSize
907 *
908 */
909 static LRESULT PCM_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
910 {
911 DWORD srcMask = ~(adsi->pwfxSrc->nBlockAlign - 1);
912 DWORD dstMask = ~(adsi->pwfxDst->nBlockAlign - 1);
913
914 switch (adss->fdwSize) {
915 case ACM_STREAMSIZEF_DESTINATION:
916 /* cbDstLength => cbSrcLength */
917 adss->cbSrcLength = PCM_round(adss->cbDstLength & dstMask,
918 adsi->pwfxSrc->nAvgBytesPerSec,
919 adsi->pwfxDst->nAvgBytesPerSec) & srcMask;
920 break;
921 case ACM_STREAMSIZEF_SOURCE:
922 /* cbSrcLength => cbDstLength */
923 adss->cbDstLength = PCM_round(adss->cbSrcLength & srcMask,
924 adsi->pwfxDst->nAvgBytesPerSec,
925 adsi->pwfxSrc->nAvgBytesPerSec) & dstMask;
926 break;
927 default:
928 WARN("Unsupported query %08lx\n", adss->fdwSize);
929 return MMSYSERR_NOTSUPPORTED;
930 }
931 return MMSYSERR_NOERROR;
932 }
933
934 /***********************************************************************
935 * PCM_StreamConvert
936 *
937 */
938 static LRESULT PCM_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
939 {
940 AcmPcmData* apd = (AcmPcmData*)adsi->dwDriver;
941 DWORD nsrc = NUM_OF(adsh->cbSrcLength, adsi->pwfxSrc->nBlockAlign);
942 DWORD ndst = NUM_OF(adsh->cbDstLength, adsi->pwfxDst->nBlockAlign);
943
944 if (adsh->fdwConvert &
945 ~(ACM_STREAMCONVERTF_BLOCKALIGN|
946 ACM_STREAMCONVERTF_END|
947 ACM_STREAMCONVERTF_START)) {
948 FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
949 }
950 /* ACM_STREAMCONVERTF_BLOCKALIGN
951 * currently all conversions are block aligned, so do nothing for this flag
952 * ACM_STREAMCONVERTF_END
953 * no pending data, so do nothing for this flag
954 */
955 if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START) &&
956 (adsi->fdwDriver & PCM_RESAMPLE)) {
957 PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
958 }
959
960 /* do the job */
961 if (adsi->fdwDriver & PCM_RESAMPLE) {
962 DWORD nsrc2 = nsrc;
963 DWORD ndst2 = ndst;
964
965 apd->cvt.cvtChangeRate(apd, adsh->pbSrc, &nsrc2, adsh->pbDst, &ndst2);
966 nsrc -= nsrc2;
967 ndst -= ndst2;
968 } else {
969 if (nsrc < ndst) ndst = nsrc; else nsrc = ndst;
970
971 /* nsrc is now equal to ndst */
972 apd->cvt.cvtKeepRate(adsh->pbSrc, nsrc, adsh->pbDst);
973 }
974
975 adsh->cbSrcLengthUsed = nsrc * adsi->pwfxSrc->nBlockAlign;
976 adsh->cbDstLengthUsed = ndst * adsi->pwfxDst->nBlockAlign;
977
978 return MMSYSERR_NOERROR;
979 }
980
981 /**************************************************************************
982 * DriverProc (MSACM32.@)
983 */
984 LRESULT CALLBACK PCM_DriverProc(DWORD dwDevID, HDRVR hDriv, UINT wMsg,
985 LPARAM dwParam1, LPARAM dwParam2)
986 {
987 TRACE("(%08lx %08lx %u %08lx %08lx);\n",
988 dwDevID, (DWORD)hDriv, wMsg, dwParam1, dwParam2);
989
990 switch (wMsg) {
991 case DRV_LOAD: return 1;
992 case DRV_FREE: return 1;
993 case DRV_OPEN: return PCM_drvOpen((LPSTR)dwParam1, (PACMDRVOPENDESCW)dwParam2);
994 case DRV_CLOSE: return PCM_drvClose(dwDevID);
995 case DRV_ENABLE: return 1;
996 case DRV_DISABLE: return 1;
997 case DRV_QUERYCONFIGURE: return 1;
998 case DRV_CONFIGURE: MessageBoxA(0, "MSACM PCM filter !", "Wine Driver", MB_OK); return 1;
999 case DRV_INSTALL: return DRVCNF_RESTART;
1000 case DRV_REMOVE: return DRVCNF_RESTART;
1001
1002 case ACMDM_DRIVER_NOTIFY:
1003 /* no caching from other ACM drivers is done so far */
1004 return MMSYSERR_NOERROR;
1005
1006 case ACMDM_DRIVER_DETAILS:
1007 return PCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
1008
1009 case ACMDM_FORMATTAG_DETAILS:
1010 return PCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
1011
1012 case ACMDM_FORMAT_DETAILS:
1013 return PCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
1014
1015 case ACMDM_FORMAT_SUGGEST:
1016 return PCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
1017
1018 case ACMDM_STREAM_OPEN:
1019 return PCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
1020
1021 case ACMDM_STREAM_CLOSE:
1022 return PCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
1023
1024 case ACMDM_STREAM_SIZE:
1025 return PCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
1026
1027 case ACMDM_STREAM_CONVERT:
1028 return PCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
1029
1030 case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
1031 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
1032 /* this converter is not a hardware driver */
1033 case ACMDM_FILTERTAG_DETAILS:
1034 case ACMDM_FILTER_DETAILS:
1035 /* this converter is not a filter */
1036 case ACMDM_STREAM_RESET:
1037 /* only needed for asynchronous driver... we aren't, so just say it */
1038 case ACMDM_STREAM_PREPARE:
1039 case ACMDM_STREAM_UNPREPARE:
1040 /* nothing special to do here... so don't do anything */
1041 return MMSYSERR_NOTSUPPORTED;
1042
1043 default:
1044 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1045 }
1046 return 0;
1047 }