?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved msacmdrv.h to include directory to avoid inter-dll header
[wine/multimedia.git] / dlls / msacm / msg711 / msg711.c
blob1f043691b99f5672d58539d503f314e1d4c0c99b
1 /*
2 * G711 handling (includes A-Law & MU-Law)
3 *
4 * Copyright (C) 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 WINE_DEFAULT_DEBUG_CHANNEL(g711);
37
38 /***********************************************************************
39 * G711_drvOpen
40 */
41 static DWORD G711_drvOpen(LPCSTR str)
42 {
43 return 1;
44 }
45
46 /***********************************************************************
47 * G711_drvClose
48 */
49 static DWORD G711_drvClose(DWORD dwDevID)
50 {
51 return 1;
52 }
53
54 typedef struct tagAcmG711Data
55 {
56 void (*convert)(PACMDRVSTREAMINSTANCE adsi,
57 const unsigned char*, LPDWORD, unsigned char*, LPDWORD);
58 } AcmG711Data;
59
60 /* table to list all supported formats... those are the basic ones. this
61 * also helps given a unique index to each of the supported formats
62 */
63 typedef struct
64 {
65 int nChannels;
66 int nBits;
67 int rate;
68 } Format;
69
70 static Format PCM_Formats[] =
71 {
72 /*{1, 8, 8000}, {2, 8, 8000}, */{1, 16, 8000}, {2, 16, 8000},
73 /*{1, 8, 11025}, {2, 8, 11025}, */{1, 16, 11025}, {2, 16, 11025},
74 /*{1, 8, 22050}, {2, 8, 22050}, */{1, 16, 22050}, {2, 16, 22050},
75 /*{1, 8, 44100}, {2, 8, 44100}, */{1, 16, 44100}, {2, 16, 44100},
76 };
77
78 static Format ALaw_Formats[] =
79 {
80 {1, 8, 8000}, {2, 8, 8000}, {1, 8, 11025}, {2, 8, 11025},
81 {1, 8, 22050}, {2, 8, 22050}, {1, 8, 44100}, {2, 8, 44100},
82 };
83
84 static Format ULaw_Formats[] =
85 {
86 {1, 8, 8000}, {2, 8, 8000}, {1, 8, 11025}, {2, 8, 11025},
87 {1, 8, 22050}, {2, 8, 22050}, {1, 8, 44100}, {2, 8, 44100},
88 };
89
90 #define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
91 #define NUM_ALAW_FORMATS (sizeof(ALaw_Formats) / sizeof(ALaw_Formats[0]))
92 #define NUM_ULAW_FORMATS (sizeof(ULaw_Formats) / sizeof(ULaw_Formats[0]))
93
94 /***********************************************************************
95 * G711_GetFormatIndex
96 */
97 static DWORD G711_GetFormatIndex(LPWAVEFORMATEX wfx)
98 {
99 int i, hi;
100 Format* fmts;
101
102 switch (wfx->wFormatTag)
103 {
104 case WAVE_FORMAT_PCM:
105 hi = NUM_PCM_FORMATS;
106 fmts = PCM_Formats;
107 break;
108 case WAVE_FORMAT_ALAW:
109 hi = NUM_ALAW_FORMATS;
110 fmts = ALaw_Formats;
111 break;
112 case WAVE_FORMAT_MULAW:
113 hi = NUM_ULAW_FORMATS;
114 fmts = ULaw_Formats;
115 break;
116 default:
117 return 0xFFFFFFFF;
118 }
119
120 for (i = 0; i < hi; i++)
121 {
122 if (wfx->nChannels == fmts[i].nChannels &&
123 wfx->nSamplesPerSec == fmts[i].rate &&
124 wfx->wBitsPerSample == fmts[i].nBits)
125 return i;
126 }
127
128 return 0xFFFFFFFF;
129 }
130
131 /***********************************************************************
132 * R16
133 *
134 * Read a 16 bit sample (correctly handles endianess)
135 */
136 static inline short R16(const unsigned char* src)
137 {
138 return (short)((unsigned short)src[0] | ((unsigned short)src[1] << 8));
139 }
140
141 /***********************************************************************
142 * W16
143 *
144 * Write a 16 bit sample (correctly handles endianess)
145 */
146 static inline void W16(unsigned char* dst, short s)
147 {
148 dst[0] = LOBYTE(s);
149 dst[1] = HIBYTE(s);
150 }
151
152 /* You can uncomment this if you don't want the statically generated conversion
153 * table, but rather recompute the Xlaw => PCM conversion for each sample
154 #define NO_FASTDECODE
155 * Since the conversion tables are rather small (2k), I don't think it's really
156 * interesting not to use them, but keeping the actual conversion code around
157 * is helpful to regenerate the tables when needed.
158 */
159
160 /* -------------------------------------------------------------------------------*/
161
162 /*
163 * This source code is a product of Sun Microsystems, Inc. and is provided
164 * for unrestricted use. Users may copy or modify this source code without
165 * charge.
166 *
167 * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
168 * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
169 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
170 *
171 * Sun source code is provided with no support and without any obligation on
172 * the part of Sun Microsystems, Inc. to assist in its use, correction,
173 * modification or enhancement.
174 *
175 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
176 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
177 * OR ANY PART THEREOF.
178 *
179 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
180 * or profits or other special, indirect and consequential damages, even if
181 * Sun has been advised of the possibility of such damages.
182 *
183 * Sun Microsystems, Inc.
184 * 2550 Garcia Avenue
185 * Mountain View, California 94043
186 */
187
188 /*
189 * g711.c
190 *
191 * u-law, A-law and linear PCM conversions.
192 */
193
194 /*
195 * December 30, 1994:
196 * Functions linear2alaw, linear2ulaw have been updated to correctly
197 * convert unquantized 16 bit values.
198 * Tables for direct u- to A-law and A- to u-law conversions have been
199 * corrected.
200 * Borge Lindberg, Center for PersonKommunikation, Aalborg University.
201 * bli@cpk.auc.dk
202 *
203 */
204
205 #define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
206 #define QUANT_MASK (0xf) /* Quantization field mask. */
207 #define NSEGS (8) /* Number of A-law segments. */
208 #define SEG_SHIFT (4) /* Left shift for segment number. */
209 #define SEG_MASK (0x70) /* Segment field mask. */
210
211 static short seg_aend[8] = {0x1F, 0x3F, 0x7F, 0xFF,
212 0x1FF, 0x3FF, 0x7FF, 0xFFF};
213 static short seg_uend[8] = {0x3F, 0x7F, 0xFF, 0x1FF,
214 0x3FF, 0x7FF, 0xFFF, 0x1FFF};
215
216 /* copy from CCITT G.711 specifications */
217 static unsigned char _u2a[128] = { /* u- to A-law conversions */
218 1, 1, 2, 2, 3, 3, 4, 4,
219 5, 5, 6, 6, 7, 7, 8, 8,
220 9, 10, 11, 12, 13, 14, 15, 16,
221 17, 18, 19, 20, 21, 22, 23, 24,
222 25, 27, 29, 31, 33, 34, 35, 36,
223 37, 38, 39, 40, 41, 42, 43, 44,
224 46, 48, 49, 50, 51, 52, 53, 54,
225 55, 56, 57, 58, 59, 60, 61, 62,
226 64, 65, 66, 67, 68, 69, 70, 71,
227 72, 73, 74, 75, 76, 77, 78, 79,
228 /* corrected:
229 81, 82, 83, 84, 85, 86, 87, 88,
230 should be: */
231 80, 82, 83, 84, 85, 86, 87, 88,
232 89, 90, 91, 92, 93, 94, 95, 96,
233 97, 98, 99, 100, 101, 102, 103, 104,
234 105, 106, 107, 108, 109, 110, 111, 112,
235 113, 114, 115, 116, 117, 118, 119, 120,
236 121, 122, 123, 124, 125, 126, 127, 128};
237
238 static unsigned char _a2u[128] = { /* A- to u-law conversions */
239 1, 3, 5, 7, 9, 11, 13, 15,
240 16, 17, 18, 19, 20, 21, 22, 23,
241 24, 25, 26, 27, 28, 29, 30, 31,
242 32, 32, 33, 33, 34, 34, 35, 35,
243 36, 37, 38, 39, 40, 41, 42, 43,
244 44, 45, 46, 47, 48, 48, 49, 49,
245 50, 51, 52, 53, 54, 55, 56, 57,
246 58, 59, 60, 61, 62, 63, 64, 64,
247 65, 66, 67, 68, 69, 70, 71, 72,
248 /* corrected:
249 73, 74, 75, 76, 77, 78, 79, 79,
250 should be: */
251 73, 74, 75, 76, 77, 78, 79, 80,
252
253 80, 81, 82, 83, 84, 85, 86, 87,
254 88, 89, 90, 91, 92, 93, 94, 95,
255 96, 97, 98, 99, 100, 101, 102, 103,
256 104, 105, 106, 107, 108, 109, 110, 111,
257 112, 113, 114, 115, 116, 117, 118, 119,
258 120, 121, 122, 123, 124, 125, 126, 127};
259
260 static short
261 search(
262 int val, /* changed from "short" *drago* */
263 short *table,
264 int size) /* changed from "short" *drago* */
265 {
266 int i; /* changed from "short" *drago* */
267
268 for (i = 0; i < size; i++) {
269 if (val <= *table++)
270 return (i);
271 }
272 return (size);
273 }
274
275 /*
276 * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
277 *
278 * linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
279 *
280 * Linear Input Code Compressed Code
281 * ------------------------ ---------------
282 * 0000000wxyza 000wxyz
283 * 0000001wxyza 001wxyz
284 * 000001wxyzab 010wxyz
285 * 00001wxyzabc 011wxyz
286 * 0001wxyzabcd 100wxyz
287 * 001wxyzabcde 101wxyz
288 * 01wxyzabcdef 110wxyz
289 * 1wxyzabcdefg 111wxyz
290 *
291 * For further information see John C. Bellamy's Digital Telephony, 1982,
292 * John Wiley & Sons, pps 98-111 and 472-476.
293 */
294 static inline unsigned char
295 linear2alaw(int pcm_val) /* 2's complement (16-bit range) */
296 /* changed from "short" *drago* */
297 {
298 int mask; /* changed from "short" *drago* */
299 int seg; /* changed from "short" *drago* */
300 unsigned char aval;
301
302 pcm_val = pcm_val >> 3;
303
304 if (pcm_val >= 0) {
305 mask = 0xD5; /* sign (7th) bit = 1 */
306 } else {
307 mask = 0x55; /* sign bit = 0 */
308 pcm_val = -pcm_val - 1;
309 }
310
311 /* Convert the scaled magnitude to segment number. */
312 seg = search(pcm_val, seg_aend, 8);
313
314 /* Combine the sign, segment, and quantization bits. */
315
316 if (seg >= 8) /* out of range, return maximum value. */
317 return (unsigned char) (0x7F ^ mask);
318 else {
319 aval = (unsigned char) seg << SEG_SHIFT;
320 if (seg < 2)
321 aval |= (pcm_val >> 1) & QUANT_MASK;
322 else
323 aval |= (pcm_val >> seg) & QUANT_MASK;
324 return (aval ^ mask);
325 }
326 }
327
328 #ifdef NO_FASTDECODE
329 /*
330 * alaw2linear() - Convert an A-law value to 16-bit linear PCM
331 *
332 */
333 static inline int
334 alaw2linear(unsigned char a_val)
335 {
336 int t; /* changed from "short" *drago* */
337 int seg; /* changed from "short" *drago* */
338
339 a_val ^= 0x55;
340
341 t = (a_val & QUANT_MASK) << 4;
342 seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
343 switch (seg) {
344 case 0:
345 t += 8;
346 break;
347 case 1:
348 t += 0x108;
349 break;
350 default:
351 t += 0x108;
352 t <<= seg - 1;
353 }
354 return ((a_val & SIGN_BIT) ? t : -t);
355 }
356 #else
357 /* EPP (for Wine):
358 * this array has been statically generated from the above routine
359 */
360 static unsigned short _a2l[] = {
361 0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80,
362 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580,
363 0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0,
364 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0,
365 0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600,
366 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600,
367 0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00,
368 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00,
369 0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8,
370 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58,
371 0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8,
372 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58,
373 0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60,
374 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
375 0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0,
376 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0,
377 0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280,
378 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80,
379 0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940,
380 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40,
381 0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00,
382 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00,
383 0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500,
384 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500,
385 0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128,
386 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8,
387 0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028,
388 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
389 0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0,
390 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0,
391 0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250,
392 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350,
393 };
394 static int inline
395 alaw2linear(unsigned char a_val)
396 {
397 return (short)_a2l[a_val];
398 }
399 #endif
400
401 #define BIAS (0x84) /* Bias for linear code. */
402 #define CLIP 8159
403
404 /*
405 * linear2ulaw() - Convert a linear PCM value to u-law
406 *
407 * In order to simplify the encoding process, the original linear magnitude
408 * is biased by adding 33 which shifts the encoding range from (0 - 8158) to
409 * (33 - 8191). The result can be seen in the following encoding table:
410 *
411 * Biased Linear Input Code Compressed Code
412 * ------------------------ ---------------
413 * 00000001wxyza 000wxyz
414 * 0000001wxyzab 001wxyz
415 * 000001wxyzabc 010wxyz
416 * 00001wxyzabcd 011wxyz
417 * 0001wxyzabcde 100wxyz
418 * 001wxyzabcdef 101wxyz
419 * 01wxyzabcdefg 110wxyz
420 * 1wxyzabcdefgh 111wxyz
421 *
422 * Each biased linear code has a leading 1 which identifies the segment
423 * number. The value of the segment number is equal to 7 minus the number
424 * of leading 0's. The quantization interval is directly available as the
425 * four bits wxyz. * The trailing bits (a - h) are ignored.
426 *
427 * Ordinarily the complement of the resulting code word is used for
428 * transmission, and so the code word is complemented before it is returned.
429 *
430 * For further information see John C. Bellamy's Digital Telephony, 1982,
431 * John Wiley & Sons, pps 98-111 and 472-476.
432 */
433 static inline unsigned char
434 linear2ulaw(short pcm_val) /* 2's complement (16-bit range) */
435 {
436 short mask;
437 short seg;
438 unsigned char uval;
439
440 /* Get the sign and the magnitude of the value. */
441 pcm_val = pcm_val >> 2;
442 if (pcm_val < 0) {
443 pcm_val = -pcm_val;
444 mask = 0x7F;
445 } else {
446 mask = 0xFF;
447 }
448 if ( pcm_val > CLIP ) pcm_val = CLIP; /* clip the magnitude */
449 pcm_val += (BIAS >> 2);
450
451 /* Convert the scaled magnitude to segment number. */
452 seg = search(pcm_val, seg_uend, 8);
453
454 /*
455 * Combine the sign, segment, quantization bits;
456 * and complement the code word.
457 */
458 if (seg >= 8) /* out of range, return maximum value. */
459 return (unsigned char) (0x7F ^ mask);
460 else {
461 uval = (unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
462 return (uval ^ mask);
463 }
464 }
465
466 #ifdef NO_FASTDECODE
467 /*
468 * ulaw2linear() - Convert a u-law value to 16-bit linear PCM
469 *
470 * First, a biased linear code is derived from the code word. An unbiased
471 * output can then be obtained by subtracting 33 from the biased code.
472 *
473 * Note that this function expects to be passed the complement of the
474 * original code word. This is in keeping with ISDN conventions.
475 */
476 static inline short
477 ulaw2linear(unsigned char u_val)
478 {
479 short t;
480
481 /* Complement to obtain normal u-law value. */
482 u_val = ~u_val;
483
484 /*
485 * Extract and bias the quantization bits. Then
486 * shift up by the segment number and subtract out the bias.
487 */
488 t = ((u_val & QUANT_MASK) << 3) + BIAS;
489 t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
490
491 return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
492 }
493 #else
494 /* EPP (for Wine):
495 * this array has been statically generated from the above routine
496 */
497 static unsigned short _u2l[] = {
498 0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84,
499 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84,
500 0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84,
501 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84,
502 0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804,
503 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004,
504 0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444,
505 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844,
506 0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64,
507 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64,
508 0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74,
509 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74,
510 0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC,
511 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
512 0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0,
513 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000,
514 0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C,
515 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C,
516 0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C,
517 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C,
518 0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC,
519 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC,
520 0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC,
521 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC,
522 0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C,
523 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C,
524 0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C,
525 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
526 0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104,
527 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084,
528 0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040,
529 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000,
530 };
531 static inline short ulaw2linear(unsigned char u_val)
532 {
533 return (short)_u2l[u_val];
534 }
535 #endif
536
537 /* A-law to u-law conversion */
538 static inline unsigned char
539 alaw2ulaw(unsigned char aval)
540 {
541 aval &= 0xff;
542 return (unsigned char) ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
543 (0x7F ^ _a2u[aval ^ 0x55]));
544 }
545
546 /* u-law to A-law conversion */
547 static inline unsigned char
548 ulaw2alaw(unsigned char uval)
549 {
550 uval &= 0xff;
551 return (unsigned char) ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
552 (unsigned char) (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
553 }
554
555 /* -------------------------------------------------------------------------------*/
556
557 static void cvtXXalaw16K(PACMDRVSTREAMINSTANCE adsi,
558 const unsigned char* src, LPDWORD srcsize,
559 unsigned char* dst, LPDWORD dstsize)
560 {
561 DWORD len = min(*srcsize, *dstsize / 2);
562 DWORD i;
563 short w;
564
565 *srcsize = len;
566 *dstsize = len * 2;
567 for (i = 0; i < len; i++)
568 {
569 w = alaw2linear(*src++);
570 W16(dst, w); dst += 2;
571 }
572 }
573
574 static void cvtXX16alawK(PACMDRVSTREAMINSTANCE adsi,
575 const unsigned char* src, LPDWORD srcsize,
576 unsigned char* dst, LPDWORD dstsize)
577 {
578 DWORD len = min(*srcsize / 2, *dstsize);
579 DWORD i;
580
581 *srcsize = len * 2;
582 *dstsize = len;
583 for (i = 0; i < len; i++)
584 {
585 *dst++ = linear2alaw(R16(src)); src += 2;
586 }
587 }
588
589 static void cvtXXulaw16K(PACMDRVSTREAMINSTANCE adsi,
590 const unsigned char* src, LPDWORD srcsize,
591 unsigned char* dst, LPDWORD dstsize)
592 {
593 DWORD len = min(*srcsize, *dstsize / 2);
594 DWORD i;
595 short w;
596
597 *srcsize = len;
598 *dstsize = len * 2;
599 for (i = 0; i < len; i++)
600 {
601 w = ulaw2linear(*src++);
602 W16(dst, w); dst += 2;
603 }
604 }
605
606 static void cvtXX16ulawK(PACMDRVSTREAMINSTANCE adsi,
607 const unsigned char* src, LPDWORD srcsize,
608 unsigned char* dst, LPDWORD dstsize)
609 {
610 DWORD len = min(*srcsize / 2, *dstsize);
611 DWORD i;
612
613 *srcsize = len * 2;
614 *dstsize = len;
615 for (i = 0; i < len; i++)
616 {
617 *dst++ = linear2ulaw(R16(src)); src += 2;
618 }
619 }
620
621 static void cvtXXalawulawK(PACMDRVSTREAMINSTANCE adsi,
622 const unsigned char* src, LPDWORD srcsize,
623 unsigned char* dst, LPDWORD dstsize)
624 {
625 DWORD len = min(*srcsize, *dstsize);
626 DWORD i;
627
628 *srcsize = len;
629 *dstsize = len;
630
631 for (i = 0; i < len; i++)
632 *dst++ = alaw2ulaw(*src++);
633 }
634
635
636 static void cvtXXulawalawK(PACMDRVSTREAMINSTANCE adsi,
637 const unsigned char* src, LPDWORD srcsize,
638 unsigned char* dst, LPDWORD dstsize)
639 {
640 DWORD len = min(*srcsize, *dstsize);
641 DWORD i;
642
643 *srcsize = len;
644 *dstsize = len;
645
646 for (i = 0; i < len; i++)
647 *dst++ = ulaw2alaw(*src++);
648 }
649
650 /***********************************************************************
651 * G711_DriverDetails
652 *
653 */
654 static LRESULT G711_DriverDetails(PACMDRIVERDETAILSW add)
655 {
656 add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
657 add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
658 add->wMid = 0xFF;
659 add->wPid = 0x00;
660 add->vdwACM = 0x01000000;
661 add->vdwDriver = 0x01000000;
662 add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
663 add->cFormatTags = 3; /* PCM, G711 A-LAW & MU-LAW */
664 add->cFilterTags = 0;
665 add->hicon = NULL;
666 MultiByteToWideChar( CP_ACP, 0, "WINE-G711", -1,
667 add->szShortName, sizeof(add->szShortName)/sizeof(WCHAR) );
668 MultiByteToWideChar( CP_ACP, 0, "Wine G711 converter", -1,
669 add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) );
670 MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
671 add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) );
672 MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
673 add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
674 add->szFeatures[0] = 0;
675
676 return MMSYSERR_NOERROR;
677 }
678
679 /***********************************************************************
680 * G711_FormatTagDetails
681 *
682 */
683 static LRESULT G711_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
684 {
685 static WCHAR szPcm[]={'P','C','M',0};
686 static WCHAR szALaw[]={'A','-','L','a','w',0};
687 static WCHAR szULaw[]={'U','-','L','a','w',0};
688
689 switch (dwQuery)
690 {
691 case ACM_FORMATTAGDETAILSF_INDEX:
692 if (aftd->dwFormatTagIndex >= 3) return ACMERR_NOTPOSSIBLE;
693 break;
694 case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
695 if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
696 {
697 aftd->dwFormatTagIndex = 1;
698 break;
699 }
700 /* fall thru */
701 case ACM_FORMATTAGDETAILSF_FORMATTAG:
702 switch (aftd->dwFormatTag)
703 {
704 case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break;
705 case WAVE_FORMAT_ALAW: aftd->dwFormatTagIndex = 1; break;
706 case WAVE_FORMAT_MULAW: aftd->dwFormatTagIndex = 2; break;
707 default: return ACMERR_NOTPOSSIBLE;
708 }
709 break;
710 default:
711 WARN("Unsupported query %08lx\n", dwQuery);
712 return MMSYSERR_NOTSUPPORTED;
713 }
714
715 aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
716 switch (aftd->dwFormatTagIndex)
717 {
718 case 0:
719 aftd->dwFormatTag = WAVE_FORMAT_PCM;
720 aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
721 aftd->cStandardFormats = NUM_PCM_FORMATS;
722 lstrcpyW(aftd->szFormatTag, szPcm);
723 break;
724 case 1:
725 aftd->dwFormatTag = WAVE_FORMAT_ALAW;
726 aftd->cbFormatSize = sizeof(WAVEFORMATEX);
727 aftd->cStandardFormats = NUM_ALAW_FORMATS;
728 lstrcpyW(aftd->szFormatTag, szALaw);
729 break;
730 case 2:
731 aftd->dwFormatTag = WAVE_FORMAT_MULAW;
732 aftd->cbFormatSize = sizeof(WAVEFORMATEX);
733 aftd->cStandardFormats = NUM_ULAW_FORMATS;
734 lstrcpyW(aftd->szFormatTag, szULaw);
735 break;
736 }
737 return MMSYSERR_NOERROR;
738 }
739
740 /***********************************************************************
741 * G711_FormatDetails
742 *
743 */
744 static LRESULT G711_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
745 {
746 switch (dwQuery)
747 {
748 case ACM_FORMATDETAILSF_FORMAT:
749 if (G711_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
750 break;
751 case ACM_FORMATDETAILSF_INDEX:
752 afd->pwfx->wFormatTag = afd->dwFormatTag;
753 switch (afd->dwFormatTag)
754 {
755 case WAVE_FORMAT_PCM:
756 if (afd->dwFormatIndex >= NUM_PCM_FORMATS) return ACMERR_NOTPOSSIBLE;
757 afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
758 afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
759 afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
760 afd->pwfx->nBlockAlign = afd->pwfx->nChannels * 2;
761 afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
762 break;
763 case WAVE_FORMAT_ALAW:
764 if (afd->dwFormatIndex >= NUM_ALAW_FORMATS) return ACMERR_NOTPOSSIBLE;
765 afd->pwfx->nChannels = ALaw_Formats[afd->dwFormatIndex].nChannels;
766 afd->pwfx->nSamplesPerSec = ALaw_Formats[afd->dwFormatIndex].rate;
767 afd->pwfx->wBitsPerSample = ALaw_Formats[afd->dwFormatIndex].nBits;
768 afd->pwfx->nBlockAlign = ALaw_Formats[afd->dwFormatIndex].nChannels;
769 afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nChannels;
770 afd->pwfx->cbSize = 0;
771 break;
772 case WAVE_FORMAT_MULAW:
773 if (afd->dwFormatIndex >= NUM_ULAW_FORMATS) return ACMERR_NOTPOSSIBLE;
774 afd->pwfx->nChannels = ULaw_Formats[afd->dwFormatIndex].nChannels;
775 afd->pwfx->nSamplesPerSec = ULaw_Formats[afd->dwFormatIndex].rate;
776 afd->pwfx->wBitsPerSample = ULaw_Formats[afd->dwFormatIndex].nBits;
777 afd->pwfx->nBlockAlign = ULaw_Formats[afd->dwFormatIndex].nChannels;
778 afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nChannels;
779 afd->pwfx->cbSize = 0;
780 break;
781 default:
782 WARN("Unsupported tag %08lx\n", afd->dwFormatTag);
783 return MMSYSERR_INVALPARAM;
784 }
785 break;
786 default:
787 WARN("Unsupported query %08lx\n", dwQuery);
788 return MMSYSERR_NOTSUPPORTED;
789 }
790 afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
791 afd->szFormat[0] = 0; /* let MSACM format this for us... */
792
793 return MMSYSERR_NOERROR;
794 }
795
796 /***********************************************************************
797 * G711_FormatSuggest
798 *
799 */
800 static LRESULT G711_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
801 {
802 /* some tests ... */
803 if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
804 adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
805 G711_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
806 /* FIXME: should do those tests against the real size (according to format tag */
807
808 /* If no suggestion for destination, then copy source value */
809 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS))
810 adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
811 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC))
812 adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
813
814 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE))
815 {
816 if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
817 adfs->pwfxDst->wBitsPerSample = 8;
818 else
819 adfs->pwfxDst->wBitsPerSample = 16;
820 }
821 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
822 {
823 switch (adfs->pwfxSrc->wFormatTag)
824 {
825 case WAVE_FORMAT_PCM: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_ALAW; break;
826 case WAVE_FORMAT_ALAW: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break;
827 case WAVE_FORMAT_MULAW: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break;
828 }
829 }
830 /* check if result is ok */
831 if (G711_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
832
833 /* recompute other values */
834 switch (adfs->pwfxDst->wFormatTag)
835 {
836 case WAVE_FORMAT_PCM:
837 adfs->pwfxDst->nBlockAlign = adfs->pwfxDst->nChannels;
838 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxDst->nBlockAlign;
839 break;
840 case WAVE_FORMAT_ALAW:
841 adfs->pwfxDst->nBlockAlign = adfs->pwfxDst->nChannels * 2;
842 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxSrc->nChannels * 2;
843 break;
844 case WAVE_FORMAT_MULAW:
845 adfs->pwfxDst->nBlockAlign = adfs->pwfxDst->nChannels * 2;
846 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxSrc->nChannels * 2;
847 break;
848 default:
849 FIXME("\n");
850 break;
851 }
852
853 return MMSYSERR_NOERROR;
854 }
855
856 /***********************************************************************
857 * G711_Reset
858 *
859 */
860 static void G711_Reset(PACMDRVSTREAMINSTANCE adsi, AcmG711Data* aad)
861 {
862 }
863
864 /***********************************************************************
865 * G711_StreamOpen
866 *
867 */
868 static LRESULT G711_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
869 {
870 AcmG711Data* aad;
871
872 assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
873
874 if (G711_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
875 G711_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
876 return ACMERR_NOTPOSSIBLE;
877
878 aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmG711Data));
879 if (aad == 0) return MMSYSERR_NOMEM;
880
881 adsi->dwDriver = (DWORD)aad;
882
883 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
884 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
885 {
886 goto theEnd;
887 }
888 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW &&
889 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
890 {
891 /* resampling or mono <=> stereo not available
892 * G711 algo only define 16 bit per sample output
893 */
894 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
895 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
896 adsi->pwfxDst->wBitsPerSample != 16)
897 goto theEnd;
898
899 /* g711 A-Law decoding... */
900 if (adsi->pwfxDst->wBitsPerSample == 16)
901 aad->convert = cvtXXalaw16K;
902 }
903 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
904 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW)
905 {
906 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
907 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
908 adsi->pwfxSrc->wBitsPerSample != 16)
909 goto theEnd;
910
911 /* g711 coding... */
912 if (adsi->pwfxSrc->wBitsPerSample == 16)
913 aad->convert = cvtXX16alawK;
914 }
915 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW &&
916 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
917 {
918 /* resampling or mono <=> stereo not available
919 * G711 algo only define 16 bit per sample output
920 */
921 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
922 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
923 adsi->pwfxDst->wBitsPerSample != 16)
924 goto theEnd;
925
926 /* g711 MU-Law decoding... */
927 if (adsi->pwfxDst->wBitsPerSample == 16)
928 aad->convert = cvtXXulaw16K;
929 }
930 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
931 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW)
932 {
933 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
934 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
935 adsi->pwfxSrc->wBitsPerSample != 16)
936 goto theEnd;
937
938 /* g711 coding... */
939 if (adsi->pwfxSrc->wBitsPerSample == 16)
940 aad->convert = cvtXX16ulawK;
941 }
942 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW &&
943 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW)
944 {
945 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
946 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels)
947 goto theEnd;
948
949 /* MU-Law => A-Law... */
950 aad->convert = cvtXXulawalawK;
951 }
952 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW &&
953 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)
954 {
955 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
956 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels)
957 goto theEnd;
958
959 /* A-Law => MU-Law... */
960 aad->convert = cvtXXalawulawK;
961 }
962 else goto theEnd;
963
964 G711_Reset(adsi, aad);
965
966 return MMSYSERR_NOERROR;
967
968 theEnd:
969 HeapFree(GetProcessHeap(), 0, aad);
970 adsi->dwDriver = 0L;
971 return MMSYSERR_NOTSUPPORTED;
972 }
973
974 /***********************************************************************
975 * G711_StreamClose
976 *
977 */
978 static LRESULT G711_StreamClose(PACMDRVSTREAMINSTANCE adsi)
979 {
980 HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
981 return MMSYSERR_NOERROR;
982 }
983
984 /***********************************************************************
985 * G711_round
986 *
987 */
988 static inline DWORD G711_round(DWORD a, DWORD b, DWORD c)
989 {
990 assert(a && b && c);
991 /* to be sure, always return an entire number of c... */
992 return ((double)a * (double)b + (double)c - 1) / (double)c;
993 }
994
995 /***********************************************************************
996 * G711_StreamSize
997 *
998 */
999 static LRESULT G711_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
1000 {
1001 switch (adss->fdwSize)
1002 {
1003 case ACM_STREAMSIZEF_DESTINATION:
1004 /* cbDstLength => cbSrcLength */
1005 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
1006 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
1007 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
1008 {
1009 adss->cbSrcLength = adss->cbDstLength / 2;
1010 }
1011 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
1012 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
1013 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
1014 {
1015 adss->cbSrcLength = adss->cbDstLength * 2;
1016 }
1017 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
1018 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
1019 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
1020 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
1021 {
1022 adss->cbSrcLength = adss->cbDstLength;
1023 }
1024 else
1025 {
1026 return MMSYSERR_NOTSUPPORTED;
1027 }
1028 break;
1029 case ACM_STREAMSIZEF_SOURCE:
1030 /* cbSrcLength => cbDstLength */
1031 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
1032 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
1033 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
1034 {
1035 adss->cbDstLength = adss->cbSrcLength * 2;
1036 }
1037 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
1038 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
1039 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
1040 {
1041 adss->cbDstLength = adss->cbSrcLength / 2;
1042 }
1043 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
1044 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
1045 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
1046 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
1047 {
1048 adss->cbDstLength = adss->cbSrcLength;
1049 }
1050 else
1051 {
1052 return MMSYSERR_NOTSUPPORTED;
1053 }
1054 break;
1055 default:
1056 WARN("Unsupported query %08lx\n", adss->fdwSize);
1057 return MMSYSERR_NOTSUPPORTED;
1058 }
1059 FIXME("\n");
1060 return MMSYSERR_NOERROR;
1061 }
1062
1063 /***********************************************************************
1064 * G711_StreamConvert
1065 *
1066 */
1067 static LRESULT G711_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
1068 {
1069 AcmG711Data* aad = (AcmG711Data*)adsi->dwDriver;
1070 DWORD nsrc = adsh->cbSrcLength;
1071 DWORD ndst = adsh->cbDstLength;
1072
1073 if (adsh->fdwConvert &
1074 ~(ACM_STREAMCONVERTF_BLOCKALIGN|
1075 ACM_STREAMCONVERTF_END|
1076 ACM_STREAMCONVERTF_START))
1077 {
1078 FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
1079 }
1080 /* ACM_STREAMCONVERTF_BLOCKALIGN
1081 * currently all conversions are block aligned, so do nothing for this flag
1082 * ACM_STREAMCONVERTF_END
1083 * no pending data, so do nothing for this flag
1084 */
1085 if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START))
1086 {
1087 G711_Reset(adsi, aad);
1088 }
1089
1090 aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst);
1091 adsh->cbSrcLengthUsed = nsrc;
1092 adsh->cbDstLengthUsed = ndst;
1093
1094 return MMSYSERR_NOERROR;
1095 }
1096
1097 /**************************************************************************
1098 * G711_DriverProc [exported]
1099 */
1100 LRESULT CALLBACK G711_DriverProc(DWORD dwDevID, HDRVR hDriv, UINT wMsg,
1101 LPARAM dwParam1, LPARAM dwParam2)
1102 {
1103 TRACE("(%08lx %08lx %04x %08lx %08lx);\n",
1104 dwDevID, (DWORD)hDriv, wMsg, dwParam1, dwParam2);
1105
1106 switch (wMsg)
1107 {
1108 case DRV_LOAD: return 1;
1109 case DRV_FREE: return 1;
1110 case DRV_OPEN: return G711_drvOpen((LPSTR)dwParam1);
1111 case DRV_CLOSE: return G711_drvClose(dwDevID);
1112 case DRV_ENABLE: return 1;
1113 case DRV_DISABLE: return 1;
1114 case DRV_QUERYCONFIGURE: return 1;
1115 case DRV_CONFIGURE: MessageBoxA(0, "MS G711 (a-Law & mu-Law) filter !", "Wine Driver", MB_OK); return 1;
1116 case DRV_INSTALL: return DRVCNF_RESTART;
1117 case DRV_REMOVE: return DRVCNF_RESTART;
1118
1119 case ACMDM_DRIVER_NOTIFY:
1120 /* no caching from other ACM drivers is done so far */
1121 return MMSYSERR_NOERROR;
1122
1123 case ACMDM_DRIVER_DETAILS:
1124 return G711_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
1125
1126 case ACMDM_FORMATTAG_DETAILS:
1127 return G711_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
1128
1129 case ACMDM_FORMAT_DETAILS:
1130 return G711_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
1131
1132 case ACMDM_FORMAT_SUGGEST:
1133 return G711_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
1134
1135 case ACMDM_STREAM_OPEN:
1136 return G711_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
1137
1138 case ACMDM_STREAM_CLOSE:
1139 return G711_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
1140
1141 case ACMDM_STREAM_SIZE:
1142 return G711_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
1143
1144 case ACMDM_STREAM_CONVERT:
1145 return G711_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
1146
1147 case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
1148 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
1149 /* this converter is not a hardware driver */
1150 case ACMDM_FILTERTAG_DETAILS:
1151 case ACMDM_FILTER_DETAILS:
1152 /* this converter is not a filter */
1153 case ACMDM_STREAM_RESET:
1154 /* only needed for asynchronous driver... we aren't, so just say it */
1155 return MMSYSERR_NOTSUPPORTED;
1156 case ACMDM_STREAM_PREPARE:
1157 case ACMDM_STREAM_UNPREPARE:
1158 /* nothing special to do here... so don't do anything */
1159 return MMSYSERR_NOERROR;
1160
1161 default:
1162 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1163 }
1164 return 0;
1165 }
Maarten's multimedia branch