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