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 = MM_MICROSOFT; 657 add->wPid = MM_MSFT_ACM_G711; 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, "Microsoft CCITT G.711", -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 } 847 848 return MMSYSERR_NOERROR; 849 } 850 851 /*********************************************************************** 852 * G711_Reset 853 * 854 */ 855 static void G711_Reset(PACMDRVSTREAMINSTANCE adsi, AcmG711Data* aad) 856 { 857 } 858 859 /*********************************************************************** 860 * G711_StreamOpen 861 * 862 */ 863 static LRESULT G711_StreamOpen(PACMDRVSTREAMINSTANCE adsi) 864 { 865 AcmG711Data* aad; 866 867 assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC)); 868 869 if (G711_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF || 870 G711_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF) 871 return ACMERR_NOTPOSSIBLE; 872 873 aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmG711Data)); 874 if (aad == 0) return MMSYSERR_NOMEM; 875 876 adsi->dwDriver = (DWORD_PTR)aad; 877 878 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 879 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 880 { 881 goto theEnd; 882 } 883 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW && 884 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 885 { 886 /* resampling or mono <=> stereo not available 887 * G711 algo only define 16 bit per sample output 888 */ 889 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || 890 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels || 891 adsi->pwfxDst->wBitsPerSample != 16) 892 goto theEnd; 893 894 /* g711 A-Law decoding... */ 895 if (adsi->pwfxDst->wBitsPerSample == 16) 896 aad->convert = cvtXXalaw16K; 897 } 898 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 899 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW) 900 { 901 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || 902 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels || 903 adsi->pwfxSrc->wBitsPerSample != 16) 904 goto theEnd; 905 906 /* g711 coding... */ 907 if (adsi->pwfxSrc->wBitsPerSample == 16) 908 aad->convert = cvtXX16alawK; 909 } 910 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW && 911 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 912 { 913 /* resampling or mono <=> stereo not available 914 * G711 algo only define 16 bit per sample output 915 */ 916 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || 917 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels || 918 adsi->pwfxDst->wBitsPerSample != 16) 919 goto theEnd; 920 921 /* g711 MU-Law decoding... */ 922 if (adsi->pwfxDst->wBitsPerSample == 16) 923 aad->convert = cvtXXulaw16K; 924 } 925 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 926 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW) 927 { 928 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || 929 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels || 930 adsi->pwfxSrc->wBitsPerSample != 16) 931 goto theEnd; 932 933 /* g711 coding... */ 934 if (adsi->pwfxSrc->wBitsPerSample == 16) 935 aad->convert = cvtXX16ulawK; 936 } 937 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW && 938 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW) 939 { 940 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || 941 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels) 942 goto theEnd; 943 944 /* MU-Law => A-Law... */ 945 aad->convert = cvtXXulawalawK; 946 } 947 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW && 948 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW) 949 { 950 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || 951 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels) 952 goto theEnd; 953 954 /* A-Law => MU-Law... */ 955 aad->convert = cvtXXalawulawK; 956 } 957 else goto theEnd; 958 959 G711_Reset(adsi, aad); 960 961 return MMSYSERR_NOERROR; 962 963 theEnd: 964 HeapFree(GetProcessHeap(), 0, aad); 965 adsi->dwDriver = 0L; 966 return MMSYSERR_NOTSUPPORTED; 967 } 968 969 /*********************************************************************** 970 * G711_StreamClose 971 * 972 */ 973 static LRESULT G711_StreamClose(PACMDRVSTREAMINSTANCE adsi) 974 { 975 HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver); 976 return MMSYSERR_NOERROR; 977 } 978 979 /*********************************************************************** 980 * G711_StreamSize 981 * 982 */ 983 static LRESULT G711_StreamSize(const ACMDRVSTREAMINSTANCE *adsi, PACMDRVSTREAMSIZE adss) 984 { 985 switch (adss->fdwSize) 986 { 987 case ACM_STREAMSIZEF_DESTINATION: 988 /* cbDstLength => cbSrcLength */ 989 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 990 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW || 991 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)) 992 { 993 adss->cbSrcLength = adss->cbDstLength * 2; 994 } 995 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW || 996 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) && 997 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 998 { 999 adss->cbSrcLength = adss->cbDstLength / 2; 1000 } 1001 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW || 1002 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) && 1003 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW || 1004 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)) 1005 { 1006 adss->cbSrcLength = adss->cbDstLength; 1007 } 1008 else 1009 { 1010 return MMSYSERR_NOTSUPPORTED; 1011 } 1012 break; 1013 case ACM_STREAMSIZEF_SOURCE: 1014 /* cbSrcLength => cbDstLength */ 1015 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && 1016 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW || 1017 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)) 1018 { 1019 adss->cbDstLength = adss->cbSrcLength / 2; 1020 } 1021 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW || 1022 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) && 1023 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) 1024 { 1025 adss->cbDstLength = adss->cbSrcLength * 2; 1026 } 1027 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW || 1028 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) && 1029 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW || 1030 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)) 1031 { 1032 adss->cbDstLength = adss->cbSrcLength; 1033 } 1034 else 1035 { 1036 return MMSYSERR_NOTSUPPORTED; 1037 } 1038 break; 1039 default: 1040 WARN("Unsupported query %08x\n", adss->fdwSize); 1041 return MMSYSERR_NOTSUPPORTED; 1042 } 1043 return MMSYSERR_NOERROR; 1044 } 1045 1046 /*********************************************************************** 1047 * G711_StreamConvert 1048 * 1049 */ 1050 static LRESULT G711_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh) 1051 { 1052 AcmG711Data* aad = (AcmG711Data*)adsi->dwDriver; 1053 DWORD nsrc = adsh->cbSrcLength; 1054 DWORD ndst = adsh->cbDstLength; 1055 1056 if (adsh->fdwConvert & 1057 ~(ACM_STREAMCONVERTF_BLOCKALIGN| 1058 ACM_STREAMCONVERTF_END| 1059 ACM_STREAMCONVERTF_START)) 1060 { 1061 FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert); 1062 } 1063 /* ACM_STREAMCONVERTF_BLOCKALIGN 1064 * currently all conversions are block aligned, so do nothing for this flag 1065 * ACM_STREAMCONVERTF_END 1066 * no pending data, so do nothing for this flag 1067 */ 1068 if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START)) 1069 { 1070 G711_Reset(adsi, aad); 1071 } 1072 1073 aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst); 1074 adsh->cbSrcLengthUsed = nsrc; 1075 adsh->cbDstLengthUsed = ndst; 1076 1077 return MMSYSERR_NOERROR; 1078 } 1079 1080 /************************************************************************** 1081 * G711_DriverProc [exported] 1082 */ 1083 LRESULT CALLBACK G711_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, 1084 LPARAM dwParam1, LPARAM dwParam2) 1085 { 1086 TRACE("(%08lx %p %04x %08lx %08lx);\n", 1087 dwDevID, hDriv, wMsg, dwParam1, dwParam2); 1088 1089 switch (wMsg) 1090 { 1091 case DRV_LOAD: return 1; 1092 case DRV_FREE: return 1; 1093 case DRV_OPEN: return G711_drvOpen((LPSTR)dwParam1); 1094 case DRV_CLOSE: return G711_drvClose(dwDevID); 1095 case DRV_ENABLE: return 1; 1096 case DRV_DISABLE: return 1; 1097 case DRV_QUERYCONFIGURE: return 1; 1098 case DRV_CONFIGURE: MessageBoxA(0, "MS G711 (a-Law & mu-Law) filter !", "Wine Driver", MB_OK); return 1; 1099 case DRV_INSTALL: return DRVCNF_RESTART; 1100 case DRV_REMOVE: return DRVCNF_RESTART; 1101 1102 case ACMDM_DRIVER_NOTIFY: 1103 /* no caching from other ACM drivers is done so far */ 1104 return MMSYSERR_NOERROR; 1105 1106 case ACMDM_DRIVER_DETAILS: 1107 return G711_DriverDetails((PACMDRIVERDETAILSW)dwParam1); 1108 1109 case ACMDM_FORMATTAG_DETAILS: 1110 return G711_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2); 1111 1112 case ACMDM_FORMAT_DETAILS: 1113 return G711_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2); 1114 1115 case ACMDM_FORMAT_SUGGEST: 1116 return G711_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1); 1117 1118 case ACMDM_STREAM_OPEN: 1119 return G711_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1); 1120 1121 case ACMDM_STREAM_CLOSE: 1122 return G711_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1); 1123 1124 case ACMDM_STREAM_SIZE: 1125 return G711_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2); 1126 1127 case ACMDM_STREAM_CONVERT: 1128 return G711_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2); 1129 1130 case ACMDM_HARDWARE_WAVE_CAPS_INPUT: 1131 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT: 1132 /* this converter is not a hardware driver */ 1133 case ACMDM_FILTERTAG_DETAILS: 1134 case ACMDM_FILTER_DETAILS: 1135 /* this converter is not a filter */ 1136 case ACMDM_STREAM_RESET: 1137 /* only needed for asynchronous driver... we aren't, so just say it */ 1138 return MMSYSERR_NOTSUPPORTED; 1139 case ACMDM_STREAM_PREPARE: 1140 case ACMDM_STREAM_UNPREPARE: 1141 /* nothing special to do here... so don't do anything */ 1142 return MMSYSERR_NOERROR; 1143 1144 default: 1145 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2); 1146 } 1147 } 1148