codecs/mp3/src/isbt.c

   1 /*____________________________________________________________________________
   2
   3         FreeAmp - The Free MP3 Player
   4
   5         MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
   6         Corp.  http://www.xingtech.com
   7
   8         Portions Copyright (C) 1998-1999 EMusic.com
   9
  10         This program is free software; you can redistribute it and/or modify
  11         it under the terms of the GNU General Public License as published by
  12         the Free Software Foundation; either version 2 of the License, or
  13         (at your option) any later version.
  14
  15         This program is distributed in the hope that it will be useful,
  16         but WITHOUT ANY WARRANTY; without even the implied warranty of
  17         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18         GNU General Public License for more details.
  19
  20         You should have received a copy of the GNU General Public License
  21         along with this program; if not, write to the Free Software
  22         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24         $Id$
  25 ____________________________________________________________________________*/
  26
  27 /****  isbt.c  ***************************************************
  28
  29 MPEG audio decoder, dct and window
  30 portable C       integer version of csbt.c
  31
  32 mods 11/15/95 for Layer I
  33
  34 mods 1/7/97 warnings
  35
  36 ******************************************************************/
  37
  38 #include <stdlib.h>
  39 #include <stdio.h>
  40 #include <float.h>
  41 #include <math.h>
  42 #include "itype.h"
  43
  44
  45 #ifdef _MSC_VER
  46 #pragma warning(disable: 4244)
  47 #pragma warning(disable: 4056)
  48 #endif
  49
  50
  51
  52 /* asm is quick only, c code does not need separate window for right */
  53 /* full is opposite of quick */
  54 #ifdef  FULL_INTEGER
  55 #define i_window_dual_right   i_window_dual
  56 #define i_window16_dual_right i_window16_dual
  57 #define i_window8_dual_right  i_window8_dual
  58 #endif
  59
  60
  61 void i_dct32(SAMPLEINT * sample, WININT * vbuf);
  62 void i_dct32_dual(SAMPLEINT * sample, WININT * vbuf);
  63 void i_dct32_dual_mono(SAMPLEINT * sample, WININT * vbuf);
  64
  65 void i_dct16(SAMPLEINT * sample, WININT * vbuf);
  66 void i_dct16_dual(SAMPLEINT * sample, WININT * vbuf);
  67 void i_dct16_dual_mono(SAMPLEINT * sample, WININT * vbuf);
  68
  69 void i_dct8(SAMPLEINT * sample, WININT * vbuf);
  70 void i_dct8_dual(SAMPLEINT * sample, WININT * vbuf);
  71 void i_dct8_dual_mono(SAMPLEINT * sample, WININT * vbuf);
  72
  73
  74 void i_window(WININT * vbuf, int vb_ptr, short *pcm);
  75 void i_window_dual(WININT * vbuf, int vb_ptr, short *pcm);
  76 void i_window_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
  77
  78 void i_window16(WININT * vbuf, int vb_ptr, short *pcm);
  79 void i_window16_dual(WININT * vbuf, int vb_ptr, short *pcm);
  80 void i_window16_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
  81
  82 void i_window8(WININT * vbuf, int vb_ptr, short *pcm);
  83 void i_window8_dual(WININT * vbuf, int vb_ptr, short *pcm);
  84 void i_window8_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
  85
  86 /*--------------------------------------------------------------------*/
  87 /*--  floating point window coefs  ---*/
  88 /*--  for integer-quick window, table used to generate integer coefs --*/
  89 static float wincoef[264] =
  90 {
  91 #include "tableawd.h"
  92 };
  93
  94 /* circular window buffers */
  95 /* extern windows because of asm */
  96 static signed int vb_ptr;
  97
  98 // static WININT vbuf[512];
  99 //static WININT vbuf2[512];
 100 extern WININT vbuf[512];
 101 extern WININT vbuf2[512];
 102
 103 DCTCOEF *i_dct_coef_addr(void);
 104
 105 /*======================================================================*/
 106 static void gencoef(void)               /* gen coef for N=32 */
 107 {
 108    int p, n, i, k;
 109    double t, pi;
 110    DCTCOEF *coef32;
 111
 112    coef32 = i_dct_coef_addr();
 113
 114
 115    pi = 4.0 * atan(1.0);
 116    n = 16;
 117    k = 0;
 118    for (i = 0; i < 5; i++, n = n / 2)
 119    {
 120       for (p = 0; p < n; p++, k++)
 121       {
 122          t = (pi / (4 * n)) * (2 * p + 1);
 123          coef32[k] = (1 << DCTBITS) * (0.50 / cos(t)) + 0.5;
 124       }
 125    }
 126 }
 127 /*------------------------------------------------------------*/
 128 WINCOEF *i_wincoef_addr(void);
 129 static void genwincoef_q(void)  /* gen int window coefs from floating table */
 130 {
 131    int i, j, k, m;
 132    float x;
 133    WINCOEF *iwincoef;
 134
 135    iwincoef = i_wincoef_addr();
 136
 137
 138 /*--- coefs generated inline for quick window ---*/
 139 /*-- quick uses only 116 coefs --*/
 140
 141    k = 0;
 142    m = 0;
 143    for (i = 0; i < 16; i++)
 144    {
 145       k += 5;
 146       for (j = 0; j < 7; j++)
 147       {
 148          x = (1 << WINBITS) * wincoef[k++];
 149          if (x > 0.0)
 150             x += 0.5;
 151          else
 152             x -= 0.5;
 153          iwincoef[m++] = x;
 154       }
 155       k += 4;
 156    }
 157    k++;
 158    for (j = 0; j < 4; j++)
 159    {
 160       x = (1 << WINBITS) * wincoef[k++];
 161       if (x > 0.0)
 162          x += 0.5;
 163       else
 164          x -= 0.5;
 165       iwincoef[m++] = x;
 166    }
 167 }
 168 /*------------------------------------------------------------*/
 169 static void genwincoef(void)    /* gen int window coefs from floating table */
 170 {
 171    int i;
 172    float x;
 173    WINCOEF *iwincoef;
 174
 175    iwincoef = i_wincoef_addr();
 176
 177    for (i = 0; i < 264; i++)
 178    {
 179       x = (1 << WINBITS) * wincoef[i];
 180       if (x > 0.0)
 181          x += 0.5;
 182       else
 183          x -= 0.5;
 184       iwincoef[i] = x;
 185    }
 186 }
 187 /*------------------------------------------------------------*/
 188 void i_sbt_init(void)
 189 {
 190    int i;
 191    static int first_pass = 1;
 192
 193 #ifdef FULL_INTEGER
 194    static int full_integer = 1;
 195
 196 #else
 197    static int full_integer = 0;
 198
 199 #endif
 200
 201    if (first_pass)
 202    {
 203       gencoef();
 204       if (full_integer)
 205          genwincoef();
 206       else
 207          genwincoef_q();
 208       first_pass = 0;
 209    }
 210
 211 /* clear window vbuf */
 212    for (i = 0; i < 512; i++)
 213       vbuf[i] = vbuf2[i] = 0;
 214    vb_ptr = 0;
 215
 216 }
 217 /*==============================================================*/
 218 /*==============================================================*/
 219 /*==============================================================*/
 220 void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n)
 221 {
 222    int i;
 223
 224    for (i = 0; i < n; i++)
 225    {
 226       i_dct32(sample, vbuf + vb_ptr);
 227       i_window(vbuf, vb_ptr, pcm);
 228       sample += 64;
 229       vb_ptr = (vb_ptr - 32) & 511;
 230       pcm += 32;
 231    }
 232
 233 }
 234 /*------------------------------------------------------------*/
 235 void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n)
 236 {
 237    int i;
 238
 239    for (i = 0; i < n; i++)
 240    {
 241       i_dct32_dual(sample, vbuf + vb_ptr);
 242       i_dct32_dual(sample + 1, vbuf2 + vb_ptr);
 243       i_window_dual(vbuf, vb_ptr, pcm);
 244       i_window_dual_right(vbuf2, vb_ptr, pcm + 1);
 245       sample += 64;
 246       vb_ptr = (vb_ptr - 32) & 511;
 247       pcm += 64;
 248    }
 249 }
 250 /*------------------------------------------------------------*/
 251 /* convert dual to mono */
 252 void i_sbt_dual_mono(SAMPLEINT * sample, short *pcm, int n)
 253 {
 254    int i;
 255
 256    for (i = 0; i < n; i++)
 257    {
 258       i_dct32_dual_mono(sample, vbuf + vb_ptr);
 259       i_window(vbuf, vb_ptr, pcm);
 260       sample += 64;
 261       vb_ptr = (vb_ptr - 32) & 511;
 262       pcm += 32;
 263    }
 264 }
 265 /*------------------------------------------------------------*/
 266 /* convert dual to left */
 267 void i_sbt_dual_left(SAMPLEINT * sample, short *pcm, int n)
 268 {
 269    int i;
 270
 271    for (i = 0; i < n; i++)
 272    {
 273       i_dct32_dual(sample, vbuf + vb_ptr);
 274       i_window(vbuf, vb_ptr, pcm);
 275       sample += 64;
 276       vb_ptr = (vb_ptr - 32) & 511;
 277       pcm += 32;
 278    }
 279 }
 280 /*------------------------------------------------------------*/
 281 /* convert dual to right */
 282 void i_sbt_dual_right(SAMPLEINT * sample, short *pcm, int n)
 283 {
 284    int i;
 285
 286    sample++;                    /* point to right chan */
 287    for (i = 0; i < n; i++)
 288    {
 289       i_dct32_dual(sample, vbuf + vb_ptr);
 290       i_window(vbuf, vb_ptr, pcm);
 291       sample += 64;
 292       vb_ptr = (vb_ptr - 32) & 511;
 293       pcm += 32;
 294    }
 295 }
 296 /*------------------------------------------------------------*/
 297 /*---------------- 16 pt sbt's  -------------------------------*/
 298 /*------------------------------------------------------------*/
 299 void i_sbt16_mono(SAMPLEINT * sample, short *pcm, int n)
 300 {
 301    int i;
 302
 303    for (i = 0; i < n; i++)
 304    {
 305       i_dct16(sample, vbuf + vb_ptr);
 306       i_window16(vbuf, vb_ptr, pcm);
 307       sample += 64;
 308       vb_ptr = (vb_ptr - 16) & 255;
 309       pcm += 16;
 310    }
 311
 312 }
 313 /*------------------------------------------------------------*/
 314 void i_sbt16_dual(SAMPLEINT * sample, short *pcm, int n)
 315 {
 316    int i;
 317
 318    for (i = 0; i < n; i++)
 319    {
 320       i_dct16_dual(sample, vbuf + vb_ptr);
 321       i_dct16_dual(sample + 1, vbuf2 + vb_ptr);
 322       i_window16_dual(vbuf, vb_ptr, pcm);
 323       i_window16_dual_right(vbuf2, vb_ptr, pcm + 1);
 324       sample += 64;
 325       vb_ptr = (vb_ptr - 16) & 255;
 326       pcm += 32;
 327    }
 328
 329 }
 330 /*------------------------------------------------------------*/
 331 void i_sbt16_dual_mono(SAMPLEINT * sample, short *pcm, int n)
 332 {
 333    int i;
 334
 335    for (i = 0; i < n; i++)
 336    {
 337       i_dct16_dual_mono(sample, vbuf + vb_ptr);
 338       i_window16(vbuf, vb_ptr, pcm);
 339       sample += 64;
 340       vb_ptr = (vb_ptr - 16) & 255;
 341       pcm += 16;
 342    }
 343 }
 344 /*------------------------------------------------------------*/
 345 void i_sbt16_dual_left(SAMPLEINT * sample, short *pcm, int n)
 346 {
 347    int i;
 348
 349    for (i = 0; i < n; i++)
 350    {
 351       i_dct16_dual(sample, vbuf + vb_ptr);
 352       i_window16(vbuf, vb_ptr, pcm);
 353       sample += 64;
 354       vb_ptr = (vb_ptr - 16) & 255;
 355       pcm += 16;
 356    }
 357 }
 358 /*------------------------------------------------------------*/
 359 void i_sbt16_dual_right(SAMPLEINT * sample, short *pcm, int n)
 360 {
 361    int i;
 362
 363    sample++;
 364    for (i = 0; i < n; i++)
 365    {
 366       i_dct16_dual(sample, vbuf + vb_ptr);
 367       i_window16(vbuf, vb_ptr, pcm);
 368       sample += 64;
 369       vb_ptr = (vb_ptr - 16) & 255;
 370       pcm += 16;
 371    }
 372 }
 373 /*------------------------------------------------------------*/
 374 /*---------------- 8 pt sbt's  -------------------------------*/
 375 /*------------------------------------------------------------*/
 376 void i_sbt8_mono(SAMPLEINT * sample, short *pcm, int n)
 377 {
 378    int i;
 379
 380    for (i = 0; i < n; i++)
 381    {
 382       i_dct8(sample, vbuf + vb_ptr);
 383       i_window8(vbuf, vb_ptr, pcm);
 384       sample += 64;
 385       vb_ptr = (vb_ptr - 8) & 127;
 386       pcm += 8;
 387    }
 388
 389 }
 390 /*------------------------------------------------------------*/
 391 void i_sbt8_dual(SAMPLEINT * sample, short *pcm, int n)
 392 {
 393    int i;
 394
 395    for (i = 0; i < n; i++)
 396    {
 397       i_dct8_dual(sample, vbuf + vb_ptr);
 398       i_dct8_dual(sample + 1, vbuf2 + vb_ptr);
 399       i_window8_dual(vbuf, vb_ptr, pcm);
 400       i_window8_dual_right(vbuf2, vb_ptr, pcm + 1);
 401       sample += 64;
 402       vb_ptr = (vb_ptr - 8) & 127;
 403       pcm += 16;
 404    }
 405 }
 406 /*------------------------------------------------------------*/
 407 void i_sbt8_dual_mono(SAMPLEINT * sample, short *pcm, int n)
 408 {
 409    int i;
 410
 411    for (i = 0; i < n; i++)
 412    {
 413       i_dct8_dual_mono(sample, vbuf + vb_ptr);
 414       i_window8(vbuf, vb_ptr, pcm);
 415       sample += 64;
 416       vb_ptr = (vb_ptr - 8) & 127;
 417       pcm += 8;
 418    }
 419 }
 420 /*------------------------------------------------------------*/
 421 void i_sbt8_dual_left(SAMPLEINT * sample, short *pcm, int n)
 422 {
 423    int i;
 424
 425    for (i = 0; i < n; i++)
 426    {
 427       i_dct8_dual(sample, vbuf + vb_ptr);
 428       i_window8(vbuf, vb_ptr, pcm);
 429       sample += 64;
 430       vb_ptr = (vb_ptr - 8) & 127;
 431       pcm += 8;
 432    }
 433 }
 434 /*------------------------------------------------------------*/
 435 void i_sbt8_dual_right(SAMPLEINT * sample, short *pcm, int n)
 436 {
 437    int i;
 438
 439    sample++;
 440    for (i = 0; i < n; i++)
 441    {
 442       i_dct8_dual(sample, vbuf + vb_ptr);
 443       i_window8(vbuf, vb_ptr, pcm);
 444       sample += 64;
 445       vb_ptr = (vb_ptr - 8) & 127;
 446       pcm += 8;
 447    }
 448 }
 449 /*------------------------------------------------------------*/
 450 /*--- 8 bit output ----------------*/
 451 #include "isbtb.c"
 452 /*----------------------------------*/
 453
 454 #ifdef _MSC_VER
 455 #pragma warning(default: 4244)
 456 #pragma warning(default: 4056)
 457 #endif