00001 /**********************************************************/ 00002 /*/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/ 00003 /* 00004 Copyright: 1995 - Grupo de Voz (DAET) ETSII/IT-Bilbao 00005 00006 Nombre fuente................ CODEC.C 00007 Nombre paquete............... SPL 00008 Lenguaje fuente.............. C (Borland C/C++ 3.1) 00009 Estado....................... Completado 00010 Dependencia Hard/OS.......... definicion de tipos fundamentales 00011 Codigo condicional........... - 00012 00013 Codificacion................. Borja Etxebarria 00014 00015 Version dd/mm/aa Autor Proposito de la edicion 00016 ------- -------- -------- ----------------------- 00017 1.1.1 04/03/97 Borja quitar warning (inicializar variable inocente) 00018 1.1.0 27/08/95 Borja ADPCM ZyXEL. 00019 1.0.0 23/07/95 Borja Codificacion inicial. 00020 00021 ======================== Contenido ======================== 00022 <DOC> 00023 Modulos para la codificacion/decodificacion de audio PCM 00024 con diferentes formatos de compresion. 00025 00026 Estos algoritmos necesitan almancenar informacion de estado 00027 y de control que les permita continuar el proceso en llamadas 00028 sucesivas al algoritmo con bloques de datos del bitstream a 00029 procesar. Esta informacion de contexto se almacena en una 00030 estructura de control adecuada a cada caso. 00031 00032 Antes de comenzar cualquier proceso de codificacion o 00033 decodificacion, se debe inicializar una estructura de control 00034 con la funcion ???_reset(). Una vez inicializada, se pasara 00035 esta estructura a ???_code() o ???_decode() junto con el 00036 bitstream a procesar. En sucesivas llamadas al algoritmo con 00037 nuevos bloques de datos de un mismo bitstream, deberemos pasar 00038 la misma estructura de control. 00039 00040 No se debe utilizar la misma estructura de control para hacer 00041 ???_code() y ???_decode(). Son procesos independientes y 00042 deben utilizar estructuras diferentes. Una vez terminado con 00043 ???_code(), podremos utilizar la misma estructura para hacer 00044 ???_decode(), aunque deberemos reinicializarla con ???_reset(). 00045 00046 La senyal descomprimida esta en formato PCM 16 bits. El 00047 bitstream es una array de valores INT16 (1 word con signo, 00048 2 bytes). Cada word es una muestra. Los bloques de datos 00049 enviados al codificador o recibidos del decodificador son 00050 vectores de elementos INT16 (pINT16). No se soporta 00051 bitstreams stereo (entrelazado L-R de muestras). El bloque 00052 de entrada debe estar alineado a una muestra (no vale empezar 00053 con el segundo byte de una muestra). 00054 00055 La senyal comprimida tiene un formato dependiente del codec 00056 utilizado. Los bloques de datos recibidos del codificador o 00057 enviados al codificador son arrays genericos de bytes, vectores 00058 de elementos UINT8 (pUINT8). El bloque codificado de entrada 00059 debe estar alineado al comienzo de una muestra (o trama): ver 00060 la explicacion sobre CGRAIN abajo. 00061 00062 Dado un bloque de muestras PCM16 formado por {d} muestras INT16, 00063 la funcion (realmente macro) ???_d2c(d) {devuelve} el numero 00064 de bytes que ocupa el bitstream codificado. Puesto que se trabaja 00065 a nivel de bit (muestra comprimida < 8 bits) en general puede suceder 00066 que algun bit del ultimo byte quede sin utilizar. 00067 00068 Dado un bitstream codificado de {c} bytes, la funcion (macro) 00069 ????_c2d(c) {devuelve} el numero de muestras INT16 que ocupa 00070 el bloque decodificado. En general algun bit final en el bitstream 00071 codificado no sea suficiente para decodificar una muestra y por 00072 tanto se ignora. 00073 00074 La informacion de contexto almacenada entre una llamada y otra 00075 al algoritmo es minima y no soporta un bitstream continuo. Como 00076 ya se ha dicho, puede suceder que los ultimos bits del bitstream 00077 comprimido no se utilizen, bien porque no hay muestras suficientes 00078 (coder) o bien porque no hay suficientes para una muestra (decoder). 00079 Para que al codificar se obtenga un bitstream continuo sin bits 00080 desaprovechados, deberemos codificar tramas de longitud multiplo 00081 de ????_DGRAIN (muestras, UINT16). Para que al decodificar no se 00082 ignoren bits finales deberemos decodificar bitstreams de longitud 00083 multiplo de ????_CGRAIN (bytes, UINT8). 00084 00085 Un ejemplo para aclarar esto, utilizando por decir algo un codec 00086 ADPCM-2 (2 bits/muestra). Si llamamos a code() con un vector de 00087 6 muestras, el bitstream codificado ocupara 2 bytes, pero los 4 00088 ultimos bits del segundo byte estaran sin utilizar: 00089 00090 . 11 22 33 44 55 66 -- -- n = usado 00091 . <--Byte1--> <--Byte2--> - = sin usar 00092 00093 Llamadas sucesivas a code() con bloques de 6 muestras produciran 00094 por tanto un bitstream discontinuo, en el que hay bits sin aprovechar: 00095 00096 . 11223344 5566---- 11223344 5566---- 11223344 5566---- ... 00097 00098 Aparte del derroche de bits, esto obliga a que el decodificador trabaje 00099 con bloques de 2 bytes que encajen con los anteriores, para evitar que 00100 utilice los bits no utilizados. 00101 00102 Por ello, en este caso conviene utilizar en el codificador bloques de 00103 muestras de longitud multiplo de 4 (DGRAIN), que produce siempre bytes 00104 completamente aprovechados. En decodificacion podremos utilizar bloques 00105 de bytes de cualquier longitud (== multiplo de 1 byte, CGRAIN) pues en 00106 un byte siempre hay informacion suficiente para decodificar 4 muestras. 00107 Si por ejemplo utilizasemos un ADPCM-3 entonces CGRAIN seria 3 bytes, 00108 pues es la longitud en bytes necesaria que nos asegura un numero entero 00109 de muestras: 00110 00111 . 11122233 34445556 66777888 00112 . byte0 byte1 byte2 00113 00114 Ademas tendremos que asegurarnos SIEMPRE de que la entrada al 00115 decodificador esta sincronizada al comienzo de una muestra. 00116 En el ejemplo anterior el decodificador debe recibir un bloque que 00117 comience en el byte0 o byte3 o byte6, etc; si comenzase en el 00118 byte1, o byte2 funcionaria mal. Para asegurarnos que esto 00119 es siempre asi, basta con trabajar siempre con bloques de longitud 00120 multiplo de CGRAIN. 00121 00122 Se cumple: ???_CGRAIN = ???_d2c(???_DGRAIN) 00123 00124 00125 Codec ADPCM Intel/DVI 00126 ---------------------- 00127 Es el function-set adpcm_idvi_???(). 00128 Algoritmo extraido de IMA Compatibility Project Proceedings, 00129 Vol 2, n. 2, May 1992. 00130 Utiliza coma fija (numeros enteros) y es bastante mas rapido 00131 que el algoritmo del estandar del CCITT. No son compatibles! 00132 00133 Codec ADPCM ZyXEL-2 00134 ------------------- 00135 Function set adpcm_zy2_???(). 00136 Utilizado por los modem-voz ZyXEL, 2 bits por muestra. Esta 00137 optimizado para trabajar a una frecuencia de muestreo de 00138 9600 m/s. 00139 00140 Codec ADPCM ZyXEL-3 00141 ------------------- 00142 Function set adpcm_zy3_???(). 00143 Utilizado por los modem-voz ZyXEL, 3 bits por muestra. Esta 00144 optimizado para trabajar a una frecuencia de muestreo de 00145 9600 m/s. 00146 </DOC> 00147 =========================================================== 00148 */ 00149 /*/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/ 00150 /**********************************************************/ 00151 00152 /**********************************************************/ 00153 00154 #include "codec.h" 00155 00156 /**********************************************************/ 00157 /* Intel ADPCM step index variation table */ 00158 PRIVATE INT _adpcm_idvi_idxtab[16] = { 00159 -1, -1, -1, -1, 2, 4, 6, 8, 00160 -1, -1, -1, -1, 2, 4, 6, 8, 00161 }; 00162 00163 /* Intel ADPCM step sizes */ 00164 PRIVATE INT16 _adpcm_idvi_steptab[89] = { 00165 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 00166 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 00167 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 00168 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 00169 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 00170 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 00171 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 00172 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 00173 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 00174 }; 00175 00176 /* <DOC> */ 00177 /**********************************************************/ 00178 /* Inicializa la estructura de tipo ADPCM_IDVI apuntada 00179 por {a} a estado de reposo inicial. Se debe llamar a esta 00180 funcion antes de comenzar el proceso de codificacion o 00181 decodificacion ADPCM Intel/DVI. 00182 Una vez inicializada la estructura, utilizaremos adpcm_idvi_code() 00183 o adpcm_idvi_decode() para ir codificando/decodificando un bitstream. 00184 No mezclar la misma estructura {a} para codificar y/o decodificar 00185 bitstreams diferentes! Utilizar una estructura diferente para cada 00186 bitstream. */ 00187 00188 PUBLIC SPL_VOID XAPI adpcm_idvi_reset( ADPCM_IDVI * a ) 00189 /* </DOC> */ 00190 { 00191 a->valprev = 0; 00192 a->index = 0; 00193 } 00194 00195 /* <DOC> */ 00196 /**********************************************************/ 00197 /* Codificador ADPCM Intel/DVI. Codifica un bitstream 00198 PCM 16bit_lineal/muestra a ADPCM 4bits/muestra. 00199 - En {a} se envia un puntero a la estructura ADPCM_IDVI necesaria 00200 para almanenar informacion de estado entre una llamada y otra a 00201 esta funcion. Antes de utilizar esta funcion por primera vez 00202 se debe inicializar la estructura con adpcm_idvi_reset(). Luego 00203 ya podemos ir llamando a esta funcion tantas veces como se quiera. 00204 Cada vez que se quiera codificar un bitstream nuevo se debe volver 00205 a llamar a adpcm_idvi_reset() para reinicializar el proceso. 00206 - En {v16} recibe un puntero a un bloque de muestras PCM16. 00207 - En {v8} recibe un puntero a un buffer para salvar muestras ADPCM4. 00208 - El numero de muestras a codificar se envia en {nd}. 00209 00210 En el vector {v16} el usuario debe enviar {nd} muestras de tipo 00211 INT16. En el vector {v8} el usuario debe enviar un buffer de 00212 {nd}/2 bytes (UINT8) si {nd} es par o de {nd}/2+1 bytes si {nd} es 00213 impar (la funcion adpcm_idvi_d2c(nd) {devuelve} directamente 00214 el valor adecuado). 00215 00216 La funcion codifica las {nd} muestras recibidas en {v16} y mete 00217 el resultado en {v8}. Si {nd} es impar, los ultimos cuatro bits 00218 del ultimo byte de {v8} quedan sin utilizar y se inicializan a 0. 00219 00220 No mezclar llamadas a adpcm_idvi_code() con adpcm_idvi_decode() sobre 00221 la misma estructura {a}!!. 00222 00223 Formato del bitstream Intel/DVI ADPCM4: 00224 - ADPCM4: array de valores UINT8 (1 byte). Cada uno de estos bytes 00225 almacena 2 'muestras' ADPCM de 4 bits. Los 4 bits mas significativos 00226 forman la primera muestra, y los 4 menos significativos forman la 00227 muestra siguiente. */ 00228 00229 PUBLIC SPL_VOID XAPI adpcm_idvi_code( ADPCM_IDVI * a, pINT16 v16, pUINT8 v8, SPL_INT nd ) 00230 /* </DOC> */ 00231 { 00232 UINT8 sign; /* Current adpcm sign bit */ 00233 UINT8 delta; /* Current adpcm output value */ 00234 INT16 diff; /* Difference between val and valprev */ 00235 INT16 step; /* Stepsize */ 00236 INT16 valpred; /* Predicted output value */ 00237 INT32 lvalpred; /* Predicted output value (before trunc. to int) */ 00238 INT16 vpdiff; /* Current change to valpred */ 00239 INT index; /* Current step change index */ 00240 UINT8 outputbuffer; /* place to keep previous 4-bit value */ 00241 BOOL bufferstep; /* toggle between outputbuffer/output */ 00242 00243 valpred = a->valprev; 00244 index = a->index; 00245 step = _adpcm_idvi_steptab[index]; 00246 outputbuffer = 0; 00247 bufferstep = TRUE; 00248 00249 for ( ; nd > 0 ; nd-- ) { 00250 /* Step 1 - compute difference with previous value */ 00251 diff = (*(v16++)) - valpred; 00252 if (diff<0) { 00253 sign = 0x8; 00254 diff = -diff; 00255 } 00256 else 00257 sign = 0; 00258 00259 /* Step 2 - Divide and clamp 00260 Note: 00261 This code *approximately* computes: 00262 delta = diff*4/step; 00263 vpdiff = (delta+0.5)*step/4; 00264 but in shift step bits are dropped. The net result of this is 00265 that even if you have fast mul/div hardware you cannot put it to 00266 good use since the fixup would be too expensive. */ 00267 vpdiff = (step >> 3); 00268 if ( diff >= step ) { 00269 delta = 0x4; 00270 diff -= step; 00271 vpdiff += step; 00272 } 00273 else 00274 delta = 0; 00275 step >>= 1; 00276 if ( diff >= step ) { 00277 delta |= 0x2; 00278 diff -= step; 00279 vpdiff += step; 00280 } 00281 step >>= 1; 00282 if ( diff >= step ) { 00283 delta |= 0x1; 00284 vpdiff += step; 00285 } 00286 00287 /* Step 3 - Update previous value */ 00288 if (sign) 00289 lvalpred = (INT32)valpred - (INT32)vpdiff; 00290 else 00291 lvalpred = (INT32)valpred + (INT32)vpdiff; 00292 00293 /* Step 4 - Clamp previous value to 16 bits */ 00294 if (lvalpred > 32767) 00295 valpred = 32767; 00296 else if (lvalpred < ((INT32)-32768L)) 00297 valpred = ((INT16)-32768L); 00298 else 00299 valpred = (INT16)lvalpred; 00300 00301 /* Step 5 - Assemble value, update index and step values */ 00302 delta |= sign; 00303 00304 index += _adpcm_idvi_idxtab[delta]; 00305 if (index < 0) 00306 index = 0; 00307 if (index > 88) 00308 index = 88; 00309 step = _adpcm_idvi_steptab[index]; 00310 00311 /* Step 6 - Output value */ 00312 if (bufferstep) 00313 outputbuffer = (delta << 4) /*& 0xf0*/; 00314 else 00315 (*(v8++)) = (delta /*& 0x0f*/) | outputbuffer; 00316 bufferstep = !bufferstep; 00317 } 00318 00319 /* Output last step, if needed */ 00320 if (!bufferstep) 00321 (*(v8++)) = outputbuffer; 00322 00323 /* Save status for next call to coder */ 00324 a->valprev = valpred; 00325 a->index = index; 00326 } 00327 00328 /* <DOC> */ 00329 /**********************************************************/ 00330 /* Decodificador ADPCM Intel/DVI. Decodifica un bitstream 00331 ADPCM 4bits/muestra a PCM 16bit_lineal/muestra. 00332 - En {a} se envia un puntero a la estructura ADPCM_IDVI necesaria 00333 para almanenar informacion de estado entre una llamada y otra a 00334 esta funcion. Antes de utilizar esta funcion por primera vez 00335 se debe inicializar la estructura con adpcm_idvi_reset(). Luego 00336 ya podemos ir llamando a esta funcion tantas veces como se quiera. 00337 Cada vez que se quiera decodificar un bitstream nuevo se debe volver 00338 a llamar a adpcm_idvi_reset() para reinicializar el proceso. 00339 - En {v8} recibe un puntero a un bloque de muestras ADPCM4. 00340 - En {v16} recibe un puntero a un buffer para salvar muestras PCM16. 00341 - El numero de muestras a decodificar se envia en {nd}. 00342 00343 En el vector {v8} el usuario debe enviar {nd} muestras de tipo 00344 ADPCM4, es decir, {nd}/2 bytes (UINT8) si {nd} es par o {nd}/2+1 00345 bytes si {nd} es impar (la funcion adpcm_idvi_d2c(nd) {devuelve} 00346 directamente el valor adecuado). En el vector {v16} el usuario 00347 debe enviar un buffer de {nd} elementos de tipo UINT16. 00348 00349 La funcion decodifica las {nd} muestras recibidas en {v8} y mete 00350 el resultado en {v16}. Si {nd} es impar, los ultimos cuatro bits 00351 del ultimo byte de {v8} no se decodifican. 00352 00353 No mezclar llamadas a adpcm_idvi_code() con adpcm_idvi_decode() sobre 00354 la misma estructura {a}!!. 00355 00356 Ver adpcm_idvi_code() para el formato del bitstream Intel/DVI ADPCM4 */ 00357 00358 PUBLIC SPL_VOID XAPI adpcm_idvi_decode( ADPCM_IDVI * a, pUINT8 v8, pINT16 v16, SPL_INT nd ) 00359 /* </DOC> */ 00360 { 00361 UINT8 sign; /* Current adpcm sign bit */ 00362 UINT8 delta; /* Current adpcm output value */ 00363 INT16 step; /* Stepsize */ 00364 INT16 valpred; /* Predicted output value */ 00365 INT32 lvalpred; /* Predicted output value (before trunc. to int) */ 00366 INT16 vpdiff; /* Current change to valpred */ 00367 INT index; /* Current step change index */ 00368 UINT8 inputbuffer; /* place to keep next 4-bit value */ 00369 BOOL bufferstep; /* toggle between inputbuffer/output */ 00370 00371 valpred = a->valprev; 00372 index = a->index; 00373 step = _adpcm_idvi_steptab[index]; 00374 bufferstep = FALSE; 00375 inputbuffer = 0; 00376 00377 for ( ; nd > 0 ; nd-- ) { 00378 /* Step 1 - get the delta value */ 00379 if (bufferstep) 00380 delta = inputbuffer & 0xf; 00381 else { 00382 inputbuffer = (*(v8++)); 00383 delta = (inputbuffer >> 4) /*& 0xf*/; 00384 } 00385 bufferstep = !bufferstep; 00386 00387 /* Step 2 - Find new index value (for later) */ 00388 index += _adpcm_idvi_idxtab[delta]; 00389 if (index < 0) 00390 index = 0; 00391 if (index > 88) 00392 index = 88; 00393 00394 /* Step 3 - Separate sign and magnitude */ 00395 sign = delta & 0x8; 00396 delta = delta & 0x7; 00397 00398 /* Step 4 - Compute difference and new predicted value 00399 Computes 'vpdiff = (delta+0.5)*step/4', but see comment 00400 in adpcm_coder. */ 00401 vpdiff = step >> 3; 00402 if (delta & 0x4) 00403 vpdiff += step; 00404 if (delta & 0x2) 00405 vpdiff += step>>1; 00406 if (delta & 0x1) 00407 vpdiff += step>>2; 00408 00409 if (sign) 00410 lvalpred = (INT32)valpred - (INT32)vpdiff; 00411 else 00412 lvalpred = (INT32)valpred + (INT32)vpdiff; 00413 00414 /* Step 5 - clamp output value */ 00415 if (lvalpred > 32767) 00416 valpred = 32767; 00417 else if (lvalpred < ((INT32)-32768L)) 00418 valpred = ((INT16)-32768L); 00419 else 00420 valpred = (INT16)lvalpred; 00421 00422 /* Step 6 - Update step value */ 00423 step = _adpcm_idvi_steptab[index]; 00424 00425 /* Step 7 - Output value */ 00426 (*(v16++)) = valpred; 00427 } 00428 00429 a->valprev = valpred; 00430 a->index = index; 00431 } 00432 00433 /**********************************************************/ 00434 /* macros internos utilizados por adpcm_zy2_???() */ 00435 00436 #define ZY2_K0 0x3800 00437 #define ZY2_K1 0x5600 00438 00439 #define ZY2_ADAPT(data, bsign, bmag) { \ 00440 if (data&bsign) { /* decrece */ \ 00441 if (data&bmag) { /* mag=1 */ \ 00442 a->ExtMax -= (a->Delta + (a->Delta>>1)); \ 00443 a->Delta = (INT16)(((INT32)a->Delta*ZY2_K1+8192)>>14); \ 00444 } \ 00445 else { /* mag=0 */ \ 00446 a->ExtMax -= (a->Delta>>1); \ 00447 a->Delta = (INT16)(((INT32)a->Delta*ZY2_K0+8192)>>14); \ 00448 } \ 00449 } \ 00450 else { /* crece */ \ 00451 /* a->Delta impar, incrementa en uno... no entiendo muy bien */ \ 00452 if (a->Delta&1) \ 00453 a->ExtMax++; \ 00454 if (data&bmag) { /* mag=1 */ \ 00455 a->ExtMax += (a->Delta + (a->Delta>>1)); \ 00456 a->Delta = (INT16)(((INT32)a->Delta*ZY2_K1+8192)>>14); \ 00457 } \ 00458 else { /* mag=0 */ \ 00459 a->ExtMax += (a->Delta>>1); \ 00460 a->Delta = (INT16)(((INT32)a->Delta*ZY2_K0+8192)>>14); \ 00461 } \ 00462 } \ 00463 } 00464 00465 #define ZY2_TOADPCM(Edata, data, bsign, bmag) { \ 00466 Edata -= a->ExtMax; \ 00467 if (Edata<0) { \ 00468 data |= bsign; \ 00469 if (-Edata>a->Delta) \ 00470 data |= bmag; \ 00471 } \ 00472 else if (Edata>a->Delta) \ 00473 data |= bmag; \ 00474 ZY2_ADAPT(data,bsign,bmag); \ 00475 } 00476 00477 /* <DOC> */ 00478 /**********************************************************/ 00479 /* Inicializa la estructura de tipo ADPCM_ZY2 apuntada 00480 por {a} a estado de reposo inicial. Se debe llamar a esta 00481 funcion antes de comenzar el proceso de codificacion o 00482 decodificacion ADPCM ZyXEL-2. 00483 Una vez inicializada la estructura, utilizaremos adpcm_zy2_code() 00484 o adpcm_zy2_decode() para ir codificando/decodificando un bitstream. 00485 No mezclar la misma estructura {a} para codificar y/o decodificar 00486 bitstreams diferentes! Utilizar una estructura diferente para cada 00487 bitstream. */ 00488 00489 PUBLIC SPL_VOID XAPI adpcm_zy2_reset( ADPCM_ZY2 * a ) 00490 /* </DOC> */ 00491 { 00492 a->Delta = 5; 00493 a->ExtMax = 0; 00494 } 00495 00496 /* <DOC> */ 00497 /**********************************************************/ 00498 /* Codificador ADPCM ZyXEL-2. Codifica un bitstream 00499 PCM 16bit_lineal/muestra a ADPCM 2bits/muestra. 00500 Optimizado para frec_muestreo = 9600 m/s. 00501 - En {a} se envia un puntero a la estructura ADPCM_ZY2 necesaria 00502 para almanenar informacion de estado entre una llamada y otra a 00503 esta funcion. Antes de utilizar esta funcion por primera vez 00504 se debe inicializar la estructura con adpcm_zy2_reset(). Luego 00505 ya podemos ir llamando a esta funcion tantas veces como se quiera. 00506 Cada vez que se quiera codificar un bitstream nuevo se debe volver 00507 a llamar a adpcm_zy2_reset() para reinicializar el proceso. 00508 - En {v16} recibe un puntero a un bloque de muestras PCM16. 00509 - En {v8} recibe un puntero a un buffer para salvar muestras ADPCM2. 00510 - El numero de muestras a codificar se envia en {nd}. 00511 00512 En el vector {v16} el usuario debe enviar {nd} muestras de tipo 00513 INT16. En el vector {v8} el usuario debe enviar un buffer de 00514 {nd}/4 bytes (UINT8) si {nd} es multiplo de 4 o de {nd}/4+1 bytes si 00515 {nd} es no lo es (la funcion adpcm_zy2_d2c(nd) {devuelve} directamente 00516 el valor adecuado). 00517 00518 La funcion codifica las {nd} muestras recibidas en {v16} y mete 00519 el resultado en {v8}. Si {nd} no es multiplo de 4, los ultimos bits 00520 del ultimo byte de {v8} quedan sin utilizar y se inicializan a 0. 00521 00522 No mezclar llamadas a adpcm_zy2_code() con adpcm_zy2_decode() sobre 00523 la misma estructura {a}!!. 00524 00525 Formato del bitstream ADPCM2 de ZyXEL: 00526 - ADPCM2 array de valores UINT8 (1 byte). Cada uno de estos bytes 00527 almacena 4 'muestras' ADPCM de 2 bits. Los 2 bits mas significativos 00528 forman la primera muestra, y los 2 menos significativos forman la 00529 cuarta muestra. */ 00530 00531 PUBLIC SPL_VOID XAPI adpcm_zy2_code( ADPCM_ZY2 * a, pINT16 v16, pUINT8 v8, SPL_INT nd ) 00532 /* </DOC> */ 00533 { 00534 INT16 Edata; 00535 UINT8 Rdata; 00536 00537 while (nd>=4) { 00538 Rdata = 0; 00539 00540 Edata = (*v16++); 00541 ZY2_TOADPCM(Edata,Rdata,0x80,0x40); 00542 00543 Edata = (*v16++); 00544 ZY2_TOADPCM(Edata,Rdata,0x20,0x10); 00545 00546 Edata = (*v16++); 00547 ZY2_TOADPCM(Edata,Rdata,0x08,0x04); 00548 00549 Edata = (*v16++); 00550 ZY2_TOADPCM(Edata,Rdata,0x02,0x01); 00551 00552 (*v8++) = Rdata; 00553 00554 nd -= 4; 00555 } 00556 00557 if (nd) { 00558 Rdata = 0; 00559 00560 Edata = (*v16++); 00561 ZY2_TOADPCM(Edata,Rdata,0x80,0x40); 00562 00563 if (!(--nd)) { 00564 *v8 = Rdata; 00565 return; 00566 } 00567 00568 Edata = (*v16++); 00569 ZY2_TOADPCM(Edata,Rdata,0x20,0x10); 00570 00571 if (!(--nd)) { 00572 *v8 = Rdata; 00573 return; 00574 } 00575 00576 Edata = (*v16); 00577 ZY2_TOADPCM(Edata,Rdata,0x08,0x04); 00578 00579 *v8 = Rdata; 00580 } 00581 } 00582 00583 /* <DOC> */ 00584 /**********************************************************/ 00585 /* Decodificador ADPCM ZyXEL-2. Decodifica un bitstream 00586 ADPCM 2bits/muestra a PCM 16bit_lineal/muestra. 00587 - En {a} se envia un puntero a la estructura ADPCM_ZY2 necesaria 00588 para almanenar informacion de estado entre una llamada y otra a 00589 esta funcion. Antes de utilizar esta funcion por primera vez 00590 se debe inicializar la estructura con adpcm_zy2_reset(). Luego 00591 ya podemos ir llamando a esta funcion tantas veces como se quiera. 00592 Cada vez que se quiera decodificar un bitstream nuevo se debe volver 00593 a llamar a adpcm_zy2_reset() para reinicializar el proceso. 00594 - En {v8} recibe un puntero a un bloque de muestras ADPCM2. 00595 - En {v16} recibe un puntero a un buffer para salvar muestras PCM16. 00596 - El numero de muestras a decodificar se envia en {nd}. 00597 00598 En el vector {v8} el usuario debe enviar {nd} muestras de tipo 00599 ADPCM2, es decir, {nd}/4 bytes (UINT8) si {nd} es multiplo 00600 de 4 o {nd}/4+1 bytes si {nd} no lo es (la funcion adpcm_zy2_d2c(nd) 00601 {devuelve} directamente el valor adecuado). En el vector {v16} el usuario 00602 debe enviar un buffer de {nd} elementos de tipo UINT16. 00603 00604 La funcion decodifica las {nd} muestras recibidas en {v8} y mete 00605 el resultado en {v16}. Si {nd} no es multiplo de 4, los ultimos bits 00606 del ultimo byte de {v8} no se decodifican. 00607 00608 No mezclar llamadas a adpcm_zy2_code() con adpcm_zy2_decode() sobre 00609 la misma estructura {a}!!. 00610 00611 Ver adpcm_zy2_code() para el formato del bitstream ADPCM ZyXEL-2 */ 00612 00613 PUBLIC SPL_VOID XAPI adpcm_zy2_decode( ADPCM_ZY2 * a, pUINT8 v8, pINT16 v16, SPL_INT nd ) 00614 /* </DOC> */ 00615 { 00616 UINT8 in; 00617 00618 while (nd>=4) { 00619 in = (*(v8++)); /* coge byte, y avanza puntero */ 00620 00621 ZY2_ADAPT(in,0x80,0x40); /* xx-- ---- */ 00622 *(v16++) = a->ExtMax; 00623 00624 ZY2_ADAPT(in,0x20,0x10); /* --xx ---- */ 00625 *(v16++) = a->ExtMax; 00626 00627 ZY2_ADAPT(in,0x08,0x04); /* ---- xx-- */ 00628 *(v16++) = a->ExtMax; 00629 00630 ZY2_ADAPT(in,0x02,0x01); /* ---- --xx */ 00631 *(v16++) = a->ExtMax; 00632 00633 nd -= 4; 00634 } 00635 00636 if (nd) { 00637 in = (*v8); /* coge byte */ 00638 00639 ZY2_ADAPT(in,0x80,0x40); /* xx-- ---- */ 00640 *(v16++) = a->ExtMax; 00641 00642 if (!(--nd)) 00643 return; 00644 00645 ZY2_ADAPT(in,0x20,0x10); /* --xx ---- */ 00646 *(v16++) = a->ExtMax; 00647 00648 if (!(--nd)) 00649 return; 00650 00651 ZY2_ADAPT(in,0x08,0x04); /* ---- xx-- */ 00652 *v16 = a->ExtMax; 00653 } 00654 } 00655 00656 /**********************************************************/ 00657 /* macros internos utilizados por adpcm_zy3_???() */ 00658 00659 #define ZY3_K0 0x399a 00660 #define ZY3_K1 0x3a9f 00661 #define ZY3_K2 0x4d14 00662 #define ZY3_K3 0x6607 00663 00664 #define ZY3_ADAPT(data, bsign, bmag1, bmag0) { \ 00665 if (data&bsign) { /* decrece */ \ 00666 if (data&bmag1) { \ 00667 if (data&bmag0) { /* mag=3 */ \ 00668 a->ExtMax -= ((a->Delta<<1) + a->Delta + (a->Delta>>1)); \ 00669 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K3+8192)>>14); \ 00670 } \ 00671 else { /* mag=2 */ \ 00672 a->ExtMax -= ((a->Delta<<1) + (a->Delta>>1)); \ 00673 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K2+8192)>>14); \ 00674 } \ 00675 } \ 00676 else if (data&bmag0) { /* mag=1 */ \ 00677 a->ExtMax -= (a->Delta + (a->Delta>>1)); \ 00678 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K1+8192)>>14); \ 00679 } \ 00680 else { /* mag=0*/ \ 00681 a->ExtMax -= (a->Delta>>1); \ 00682 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K0+8192)>>14); \ 00683 } \ 00684 } \ 00685 else { /* crece */ \ 00686 /* a->Delta impar, incrementa en uno... no entiendo muy bien */ \ 00687 if (a->Delta&1) \ 00688 a->ExtMax++; \ 00689 if (data&bmag1) { \ 00690 if (data&bmag0) { /* mag=3 */ \ 00691 a->ExtMax += ((a->Delta<<1) + a->Delta + (a->Delta>>1)); \ 00692 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K3+8192)>>14); \ 00693 } \ 00694 else {/* mag=2 */ \ 00695 a->ExtMax += ((a->Delta<<1) + (a->Delta>>1)); \ 00696 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K2+8192)>>14); \ 00697 } \ 00698 } \ 00699 else if (data&bmag0) { /* mag=1 */ \ 00700 a->ExtMax += (a->Delta + (a->Delta>>1)); \ 00701 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K1+8192)>>14); \ 00702 } \ 00703 else { /* mag=0 */ \ 00704 a->ExtMax += (a->Delta>>1); \ 00705 a->Delta = (INT16)(((INT32)a->Delta*ZY3_K0+8192)>>14); \ 00706 } \ 00707 } \ 00708 } 00709 00710 #define ZY3_TOADPCM(Edata, data, bsign, bmag1, bmag0) { \ 00711 Edata -= a->ExtMax; \ 00712 if (Edata<0) { \ 00713 data |= bsign; \ 00714 Edata = -Edata; \ 00715 } \ 00716 if (Edata>(a->Delta<<1)) { \ 00717 data |=bmag1; \ 00718 if (Edata>(a->Delta+(a->Delta<<1))) \ 00719 data |= bmag0; \ 00720 } \ 00721 else if (Edata>a->Delta) \ 00722 data |= bmag0; \ 00723 ZY3_ADAPT(data, bsign, bmag1, bmag0); \ 00724 } 00725 00726 /* <DOC> */ 00727 /**********************************************************/ 00728 /* Inicializa la estructura de tipo ADPCM_ZY3 apuntada 00729 por {a} a estado de reposo inicial. Se debe llamar a esta 00730 funcion antes de comenzar el proceso de codificacion o 00731 decodificacion ADPCM ZyXEL-3. 00732 Una vez inicializada la estructura, utilizaremos adpcm_zy3_code() 00733 o adpcm_zy3_decode() para ir codificando/decodificando un bitstream. 00734 No mezclar la misma estructura {a} para codificar y/o decodificar 00735 bitstreams diferentes! Utilizar una estructura diferente para cada 00736 bitstream. */ 00737 00738 PUBLIC SPL_VOID XAPI adpcm_zy3_reset( ADPCM_ZY3 * a ) 00739 /* </DOC> */ 00740 { 00741 a->Delta = 5; 00742 a->ExtMax = 0; 00743 } 00744 00745 /* <DOC> */ 00746 /**********************************************************/ 00747 /* Codificador ADPCM ZyXEL-3. Codifica un bitstream 00748 PCM 16bit_lineal/muestra a ADPCM 3bits/muestra. 00749 Optimizado para frec_muestreo = 9600 m/s. 00750 - En {a} se envia un puntero a la estructura ADPCM_ZY3 necesaria 00751 para almanenar informacion de estado entre una llamada y otra a 00752 esta funcion. Antes de utilizar esta funcion por primera vez 00753 se debe inicializar la estructura con adpcm_zy3_reset(). Luego 00754 ya podemos ir llamando a esta funcion tantas veces como se quiera. 00755 Cada vez que se quiera codificar un bitstream nuevo se debe volver 00756 a llamar a adpcm_zy3_reset() para reinicializar el proceso. 00757 - En {v16} recibe un puntero a un bloque de muestras PCM16. 00758 - En {v8} recibe un puntero a un buffer para salvar muestras ADPCM2. 00759 - El numero de muestras a codificar se envia en {nd}. 00760 00761 En el vector {v16} el usuario debe enviar {nd} muestras de tipo 00762 INT16. En el vector {v8} el usuario debe enviar un buffer de 00763 longitud adecuada (la funcion adpcm_zy3_d2c(nd) {devuelve} 00764 directamente el valor en bytes necesario). 00765 00766 La funcion codifica las {nd} muestras recibidas en {v16} y mete 00767 el resultado en {v8}. Si {nd} no es multiplo de 4, los ultimos bits 00768 del ultimo byte de {v8} quedan sin utilizar y se inicializan a 0. 00769 00770 No mezclar llamadas a adpcm_zy3_code() con adpcm_zy3_decode() sobre 00771 la misma estructura {a}!!. 00772 00773 Formato del bitstream ADPCM3 de ZyXEL: 00774 - ADPCM3 array de valores UINT8 (1 byte). Cada grupo de 3 bytes 00775 almacena 8 'muestras' ADPCM de 3 bits: 00776 . 11122233 34445556 66777888 00777 . byte0 byte1 byte2 00778 */ 00779 00780 PUBLIC SPL_VOID XAPI adpcm_zy3_code( ADPCM_ZY3 * a, pINT16 v16, pUINT8 v8, SPL_INT nd ) 00781 /* </DOC> */ 00782 { 00783 INT16 Edata; 00784 UINT8 Rdata, Tmp; 00785 00786 while (nd>=8) { 00787 Rdata = 0; 00788 00789 Edata = (*v16++); 00790 ZY3_TOADPCM(Edata,Rdata,0x80,0x40,0x20); /* xxx- ---- */ 00791 00792 Edata = (*v16++); 00793 ZY3_TOADPCM(Edata,Rdata,0x10,0x08,0x04); /* ---x xx-- */ 00794 00795 Tmp = Rdata; 00796 Rdata = 0; 00797 Edata = (*v16++); 00798 ZY3_TOADPCM(Edata,Rdata,0x02,0x01,0x80); /* ---- --xx x--- ---- */ 00799 (*v8++) = Tmp | (Rdata &0x03); 00800 Rdata &= 0x80; 00801 00802 Edata = (*v16++); 00803 ZY3_TOADPCM(Edata,Rdata,0x40,0x20,0x10); /* -xxx ---- */ 00804 00805 Edata = (*v16++); 00806 ZY3_TOADPCM(Edata,Rdata,0x08,0x04,0x02); /* ---- xxx- */ 00807 00808 Tmp = Rdata; 00809 Rdata = 0; 00810 Edata = (*v16++); 00811 ZY3_TOADPCM(Edata,Rdata,0x01,0x80,0x40); /* ---- ---x xx-- ---- */ 00812 (*v8++) = Tmp | (Rdata &0x01); 00813 Rdata &= 0xc0; 00814 00815 Edata = (*v16++); 00816 ZY3_TOADPCM(Edata,Rdata,0x20,0x10,0x08); /* --xx x--- */ 00817 00818 Edata = (*v16++); 00819 ZY3_TOADPCM(Edata,Rdata,0x04,0x02,0x01); /* ---- -xxx */ 00820 (*v8++) = Rdata; 00821 00822 nd -= 8; 00823 } 00824 00825 if (nd) { 00826 Rdata = 0; 00827 00828 Edata = (*v16++); 00829 ZY3_TOADPCM(Edata,Rdata,0x80,0x40,0x20); /* xxx- ---- */ 00830 00831 if (!(--nd)) { 00832 *v8 = Rdata; 00833 return; 00834 } 00835 00836 Edata = (*v16++); 00837 ZY3_TOADPCM(Edata,Rdata,0x10,0x08,0x04); /* ---x xx-- */ 00838 00839 if (!(--nd)) { 00840 *v8 = Rdata; 00841 return; 00842 } 00843 00844 Tmp = Rdata; 00845 Rdata = 0; 00846 Edata = (*v16++); 00847 ZY3_TOADPCM(Edata,Rdata,0x02,0x01,0x80); /* ---- --xx x--- ---- */ 00848 (*v8++) = Tmp | (Rdata &0x03); 00849 Rdata &= 0x80; 00850 00851 if (!(--nd)) { 00852 *v8 = Rdata; 00853 return; 00854 } 00855 00856 Edata = (*v16++); 00857 ZY3_TOADPCM(Edata,Rdata,0x40,0x20,0x10); /* -xxx ---- */ 00858 00859 if (!(--nd)) { 00860 *v8 = Rdata; 00861 return; 00862 } 00863 00864 Edata = (*v16++); 00865 ZY3_TOADPCM(Edata,Rdata,0x08,0x04,0x02); /* ---- xxx- */ 00866 00867 if (!(--nd)) { 00868 *v8 = Rdata; 00869 return; 00870 } 00871 00872 Tmp = Rdata; 00873 Rdata = 0; 00874 Edata = (*v16++); 00875 ZY3_TOADPCM(Edata,Rdata,0x01,0x80,0x40); /* ---- ---x xx-- ---- */ 00876 (*v8++) = Tmp | (Rdata &0x01); 00877 Rdata &= 0xc0; 00878 00879 if (!(--nd)) { 00880 *v8 = Rdata; 00881 return; 00882 } 00883 00884 Edata = (*v16); 00885 ZY3_TOADPCM(Edata,Rdata,0x20,0x10,0x08); /* --xx x--- */ 00886 00887 *v8 = Rdata; 00888 } 00889 00890 } 00891 00892 /* <DOC> */ 00893 /**********************************************************/ 00894 /* Decodificador ADPCM ZyXEL-3. Decodifica un bitstream 00895 ADPCM 3bits/muestra a PCM 16bit_lineal/muestra. 00896 - En {a} se envia un puntero a la estructura ADPCM_ZY3 necesaria 00897 para almanenar informacion de estado entre una llamada y otra a 00898 esta funcion. Antes de utilizar esta funcion por primera vez 00899 se debe inicializar la estructura con adpcm_zy3_reset(). Luego 00900 ya podemos ir llamando a esta funcion tantas veces como se quiera. 00901 Cada vez que se quiera decodificar un bitstream nuevo se debe volver 00902 a llamar a adpcm_zy3_reset() para reinicializar el proceso. 00903 - En {v8} recibe un puntero a un bloque de muestras ADPCM3. 00904 - En {v16} recibe un puntero a un buffer para salvar muestras PCM16. 00905 - El numero de muestras a decodificar se envia en {nd}. 00906 00907 En el vector {v8} el usuario debe enviar {nd} muestras de tipo 00908 ADPCM3, la funcion adpcm_zy2_d2c(nd) {devuelve} directamente el valor 00909 en bytes adecuado. En el vector {v16} el usuario debe enviar un buffer 00910 de {nd} elementos de tipo UINT16. 00911 00912 La funcion decodifica las {nd} muestras recibidas en {v8} y mete 00913 el resultado en {v16}. Si {nd} no es multiplo de 8, los ultimos bits 00914 del ultimo byte de {v8} no se decodifican. 00915 00916 No mezclar llamadas a adpcm_zy3_code() con adpcm_zy3_decode() sobre 00917 la misma estructura {a}!!. 00918 00919 Ver adpcm_zy3_code() para el formato del bitstream ADPCM ZyXEL-3 */ 00920 00921 PUBLIC SPL_VOID XAPI adpcm_zy3_decode( ADPCM_ZY3 * a, pUINT8 v8, pINT16 v16, SPL_INT nd ) 00922 /* </DOC> */ 00923 { 00924 UINT8 in, tmp; 00925 00926 while (nd>=8) { 00927 in = (*v8++); 00928 00929 ZY3_ADAPT(in,0x80,0x40,0x20); /* xxx- ---- */ 00930 *(v16++) = a->ExtMax; 00931 ZY3_ADAPT(in,0x10,0x08,0x04); /* ---x xx-- */ 00932 *(v16++) = a->ExtMax; 00933 00934 tmp = (in&0x03); 00935 in = (*v8++); 00936 00937 tmp |= (in&0x80); 00938 ZY3_ADAPT(tmp,0x02,0x01,0x80); /* ---- --xx x--- ---- */ 00939 *(v16++) = a->ExtMax; 00940 00941 ZY3_ADAPT(in,0x40,0x20,0x10); /* -xxx ---- */ 00942 *(v16++) = a->ExtMax; 00943 ZY3_ADAPT(in,0x08,0x04,0x02); /* ---- xxx- */ 00944 *(v16++) = a->ExtMax; 00945 00946 tmp = (in&0x01); 00947 in = (*v8++); 00948 00949 tmp |= (in&0xc0); 00950 ZY3_ADAPT(tmp,0x01,0x80,0x40); /* ---- ---x xx-- ---- */ 00951 *(v16++) = a->ExtMax; 00952 00953 ZY3_ADAPT(in,0x20,0x10,0x08); /* --xx x--- */ 00954 *(v16++) = a->ExtMax; 00955 ZY3_ADAPT(in,0x04,0x02,0x01); /* ---- -xxx */ 00956 *(v16++) = a->ExtMax; 00957 00958 nd -= 8; 00959 } 00960 00961 if (nd) { 00962 in = (*v8++); 00963 00964 ZY3_ADAPT(in,0x80,0x40,0x20); /* xxx- ---- */ 00965 *(v16++) = a->ExtMax; 00966 00967 if (!(--nd)) 00968 return; 00969 00970 ZY3_ADAPT(in,0x10,0x08,0x04); /* ---x xx-- */ 00971 *(v16++) = a->ExtMax; 00972 00973 if (!(--nd)) 00974 return; 00975 00976 tmp = (in&0x03); 00977 in = (*v8++); 00978 00979 tmp |= (in&0x80); 00980 ZY3_ADAPT(tmp,0x02,0x01,0x80); /* ---- --xx x--- ---- */ 00981 *(v16++) = a->ExtMax; 00982 00983 if (!(--nd)) 00984 return; 00985 00986 ZY3_ADAPT(in,0x40,0x20,0x10); /* -xxx ---- */ 00987 *(v16++) = a->ExtMax; 00988 00989 if (!(--nd)) 00990 return; 00991 00992 ZY3_ADAPT(in,0x08,0x04,0x02); /* ---- xxx- */ 00993 *(v16++) = a->ExtMax; 00994 00995 if (!(--nd)) 00996 return; 00997 00998 tmp = (in&0x01); 00999 in = (*v8); 01000 01001 tmp |= (in&0xc0); 01002 ZY3_ADAPT(tmp,0x01,0x80,0x40); /* ---- ---x xx-- ---- */ 01003 *(v16++) = a->ExtMax; 01004 01005 if (!(--nd)) 01006 return; 01007 01008 ZY3_ADAPT(in,0x20,0x10,0x08); /* --xx x--- */ 01009 *v16 = a->ExtMax; 01010 } 01011 } 01012 01013 /**********************************************************/
1.5.6