libfaad2/output.c

   1 /*
   2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   3 ** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU General Public License as published by
   7 ** the Free Software Foundation; either version 2 of the License, or
   8 ** (at your option) any later version.
   9 **
  10 ** This program is distributed in the hope that it will be useful,
  11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ** GNU General Public License for more details.
  14 **
  15 ** You should have received a copy of the GNU General Public License
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 **
  19 ** Any non-GPL usage of this software or parts of this software is strictly
  20 ** forbidden.
  21 **
  22 ** Initially modified for use with MPlayer by Rich Felker on 2005/03/29
  23 ** $Id$
  24 ** detailed changelog at http://svn.mplayerhq.hu/mplayer/trunk/
  25 **/
  26
  27 #include "common.h"
  28 #include "structs.h"
  29
  30 #include "output.h"
  31 #include "decoder.h"
  32
  33 #ifndef FIXED_POINT
  34
  35
  36 #define FLOAT_SCALE (1.0f/(1<<15))
  37
  38 #define DM_MUL REAL_CONST(0.3203772410170407) // 1/(1+sqrt(2) + 1/sqrt(2))
  39 #define RSQRT2 REAL_CONST(0.7071067811865475244) // 1/sqrt(2)
  40
  41
  42 static INLINE real_t get_sample(real_t **input, uint8_t channel, uint16_t sample,
  43                                 uint8_t down_matrix, uint8_t *internal_channel)
  44 {
  45     if (!down_matrix)
  46         return input[internal_channel[channel]][sample];
  47
  48     if (channel == 0)
  49     {
  50         return DM_MUL * (input[internal_channel[1]][sample] +
  51             input[internal_channel[0]][sample] * RSQRT2 +
  52             input[internal_channel[3]][sample] * RSQRT2);
  53     } else {
  54         return DM_MUL * (input[internal_channel[2]][sample] +
  55             input[internal_channel[0]][sample] * RSQRT2 +
  56             input[internal_channel[4]][sample] * RSQRT2);
  57     }
  58 }
  59
  60 #ifndef HAS_LRINTF
  61 #define CLIP(sample, max, min) \
  62 if (sample >= 0.0f)            \
  63 {                              \
  64     sample += 0.5f;            \
  65     if (sample >= max)         \
  66         sample = max;          \
  67 } else {                       \
  68     sample += -0.5f;           \
  69     if (sample <= min)         \
  70         sample = min;          \
  71 }
  72 #else
  73 #define CLIP(sample, max, min) \
  74 if (sample >= 0.0f)            \
  75 {                              \
  76     if (sample >= max)         \
  77         sample = max;          \
  78 } else {                       \
  79     if (sample <= min)         \
  80         sample = min;          \
  81 }
  82 #endif
  83
  84 #define CONV(a,b) ((a<<1)|(b&0x1))
  85
  86 static void to_PCM_16bit(NeAACDecHandle hDecoder, real_t **input,
  87                          uint8_t channels, uint16_t frame_len,
  88                          int16_t **sample_buffer)
  89 {
  90     uint8_t ch, ch1;
  91     uint16_t i;
  92
  93     switch (CONV(channels,hDecoder->downMatrix))
  94     {
  95     case CONV(1,0):
  96     case CONV(1,1):
  97         for(i = 0; i < frame_len; i++)
  98         {
  99             real_t inp = input[hDecoder->internal_channel[0]][i];
 100
 101             CLIP(inp, 32767.0f, -32768.0f);
 102
 103             (*sample_buffer)[i] = (int16_t)lrintf(inp);
 104         }
 105         break;
 106     case CONV(2,0):
 107         if (hDecoder->upMatrix)
 108         {
 109             ch  = hDecoder->internal_channel[0];
 110             for(i = 0; i < frame_len; i++)
 111             {
 112                 real_t inp0 = input[ch][i];
 113
 114                 CLIP(inp0, 32767.0f, -32768.0f);
 115
 116                 (*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);
 117                 (*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp0);
 118             }
 119         } else {
 120             ch  = hDecoder->internal_channel[0];
 121             ch1 = hDecoder->internal_channel[1];
 122             for(i = 0; i < frame_len; i++)
 123             {
 124                 real_t inp0 = input[ch ][i];
 125                 real_t inp1 = input[ch1][i];
 126
 127                 CLIP(inp0, 32767.0f, -32768.0f);
 128                 CLIP(inp1, 32767.0f, -32768.0f);
 129
 130                 (*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);
 131                 (*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp1);
 132             }
 133         }
 134         break;
 135     default:
 136         for (ch = 0; ch < channels; ch++)
 137         {
 138             for(i = 0; i < frame_len; i++)
 139             {
 140                 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
 141
 142                 CLIP(inp, 32767.0f, -32768.0f);
 143
 144                 (*sample_buffer)[(i*channels)+ch] = (int16_t)lrintf(inp);
 145             }
 146         }
 147         break;
 148     }
 149 }
 150
 151 static void to_PCM_24bit(NeAACDecHandle hDecoder, real_t **input,
 152                          uint8_t channels, uint16_t frame_len,
 153                          int32_t **sample_buffer)
 154 {
 155     uint8_t ch, ch1;
 156     uint16_t i;
 157
 158     switch (CONV(channels,hDecoder->downMatrix))
 159     {
 160     case CONV(1,0):
 161     case CONV(1,1):
 162         for(i = 0; i < frame_len; i++)
 163         {
 164             real_t inp = input[hDecoder->internal_channel[0]][i];
 165
 166             inp *= 256.0f;
 167             CLIP(inp, 8388607.0f, -8388608.0f);
 168
 169             (*sample_buffer)[i] = (int32_t)lrintf(inp);
 170         }
 171         break;
 172     case CONV(2,0):
 173         if (hDecoder->upMatrix)
 174         {
 175             ch = hDecoder->internal_channel[0];
 176             for(i = 0; i < frame_len; i++)
 177             {
 178                 real_t inp0 = input[ch][i];
 179
 180                 inp0 *= 256.0f;
 181                 CLIP(inp0, 8388607.0f, -8388608.0f);
 182
 183                 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
 184                 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp0);
 185             }
 186         } else {
 187             ch  = hDecoder->internal_channel[0];
 188             ch1 = hDecoder->internal_channel[1];
 189             for(i = 0; i < frame_len; i++)
 190             {
 191                 real_t inp0 = input[ch ][i];
 192                 real_t inp1 = input[ch1][i];
 193
 194                 inp0 *= 256.0f;
 195                 inp1 *= 256.0f;
 196                 CLIP(inp0, 8388607.0f, -8388608.0f);
 197                 CLIP(inp1, 8388607.0f, -8388608.0f);
 198
 199                 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
 200                 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp1);
 201             }
 202         }
 203         break;
 204     default:
 205         for (ch = 0; ch < channels; ch++)
 206         {
 207             for(i = 0; i < frame_len; i++)
 208             {
 209                 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
 210
 211                 inp *= 256.0f;
 212                 CLIP(inp, 8388607.0f, -8388608.0f);
 213
 214                 (*sample_buffer)[(i*channels)+ch] = (int32_t)lrintf(inp);
 215             }
 216         }
 217         break;
 218     }
 219 }
 220
 221 static void to_PCM_32bit(NeAACDecHandle hDecoder, real_t **input,
 222                          uint8_t channels, uint16_t frame_len,
 223                          int32_t **sample_buffer)
 224 {
 225     uint8_t ch, ch1;
 226     uint16_t i;
 227
 228     switch (CONV(channels,hDecoder->downMatrix))
 229     {
 230     case CONV(1,0):
 231     case CONV(1,1):
 232         for(i = 0; i < frame_len; i++)
 233         {
 234             real_t inp = input[hDecoder->internal_channel[0]][i];
 235
 236             inp *= 65536.0f;
 237             CLIP(inp, 2147483647.0f, -2147483648.0f);
 238
 239             (*sample_buffer)[i] = (int32_t)lrintf(inp);
 240         }
 241         break;
 242     case CONV(2,0):
 243         if (hDecoder->upMatrix)
 244         {
 245             ch = hDecoder->internal_channel[0];
 246             for(i = 0; i < frame_len; i++)
 247             {
 248                 real_t inp0 = input[ch][i];
 249
 250                 inp0 *= 65536.0f;
 251                 CLIP(inp0, 2147483647.0f, -2147483648.0f);
 252
 253                 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
 254                 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp0);
 255             }
 256         } else {
 257             ch  = hDecoder->internal_channel[0];
 258             ch1 = hDecoder->internal_channel[1];
 259             for(i = 0; i < frame_len; i++)
 260             {
 261                 real_t inp0 = input[ch ][i];
 262                 real_t inp1 = input[ch1][i];
 263
 264                 inp0 *= 65536.0f;
 265                 inp1 *= 65536.0f;
 266                 CLIP(inp0, 2147483647.0f, -2147483648.0f);
 267                 CLIP(inp1, 2147483647.0f, -2147483648.0f);
 268
 269                 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
 270                 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp1);
 271             }
 272         }
 273         break;
 274     default:
 275         for (ch = 0; ch < channels; ch++)
 276         {
 277             for(i = 0; i < frame_len; i++)
 278             {
 279                 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
 280
 281                 inp *= 65536.0f;
 282                 CLIP(inp, 2147483647.0f, -2147483648.0f);
 283
 284                 (*sample_buffer)[(i*channels)+ch] = (int32_t)lrintf(inp);
 285             }
 286         }
 287         break;
 288     }
 289 }
 290
 291 static void to_PCM_float(NeAACDecHandle hDecoder, real_t **input,
 292                          uint8_t channels, uint16_t frame_len,
 293                          float32_t **sample_buffer)
 294 {
 295     uint8_t ch, ch1;
 296     uint16_t i;
 297
 298     switch (CONV(channels,hDecoder->downMatrix))
 299     {
 300     case CONV(1,0):
 301     case CONV(1,1):
 302         for(i = 0; i < frame_len; i++)
 303         {
 304             real_t inp = input[hDecoder->internal_channel[0]][i];
 305             (*sample_buffer)[i] = inp*FLOAT_SCALE;
 306         }
 307         break;
 308     case CONV(2,0):
 309         if (hDecoder->upMatrix)
 310         {
 311             ch = hDecoder->internal_channel[0];
 312             for(i = 0; i < frame_len; i++)
 313             {
 314                 real_t inp0 = input[ch][i];
 315                 (*sample_buffer)[(i*2)+0] = inp0*FLOAT_SCALE;
 316                 (*sample_buffer)[(i*2)+1] = inp0*FLOAT_SCALE;
 317             }
 318         } else {
 319             ch  = hDecoder->internal_channel[0];
 320             ch1 = hDecoder->internal_channel[1];
 321             for(i = 0; i < frame_len; i++)
 322             {
 323                 real_t inp0 = input[ch ][i];
 324                 real_t inp1 = input[ch1][i];
 325                 (*sample_buffer)[(i*2)+0] = inp0*FLOAT_SCALE;
 326                 (*sample_buffer)[(i*2)+1] = inp1*FLOAT_SCALE;
 327             }
 328         }
 329         break;
 330     default:
 331         for (ch = 0; ch < channels; ch++)
 332         {
 333             for(i = 0; i < frame_len; i++)
 334             {
 335                 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
 336                 (*sample_buffer)[(i*channels)+ch] = inp*FLOAT_SCALE;
 337             }
 338         }
 339         break;
 340     }
 341 }
 342
 343 static void to_PCM_double(NeAACDecHandle hDecoder, real_t **input,
 344                           uint8_t channels, uint16_t frame_len,
 345                           double **sample_buffer)
 346 {
 347     uint8_t ch, ch1;
 348     uint16_t i;
 349
 350     switch (CONV(channels,hDecoder->downMatrix))
 351     {
 352     case CONV(1,0):
 353     case CONV(1,1):
 354         for(i = 0; i < frame_len; i++)
 355         {
 356             real_t inp = input[hDecoder->internal_channel[0]][i];
 357             (*sample_buffer)[i] = (double)inp*FLOAT_SCALE;
 358         }
 359         break;
 360     case CONV(2,0):
 361         if (hDecoder->upMatrix)
 362         {
 363             ch = hDecoder->internal_channel[0];
 364             for(i = 0; i < frame_len; i++)
 365             {
 366                 real_t inp0 = input[ch][i];
 367                 (*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;
 368                 (*sample_buffer)[(i*2)+1] = (double)inp0*FLOAT_SCALE;
 369             }
 370         } else {
 371             ch  = hDecoder->internal_channel[0];
 372             ch1 = hDecoder->internal_channel[1];
 373             for(i = 0; i < frame_len; i++)
 374             {
 375                 real_t inp0 = input[ch ][i];
 376                 real_t inp1 = input[ch1][i];
 377                 (*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;
 378                 (*sample_buffer)[(i*2)+1] = (double)inp1*FLOAT_SCALE;
 379             }
 380         }
 381         break;
 382     default:
 383         for (ch = 0; ch < channels; ch++)
 384         {
 385             for(i = 0; i < frame_len; i++)
 386             {
 387                 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
 388                 (*sample_buffer)[(i*channels)+ch] = (double)inp*FLOAT_SCALE;
 389             }
 390         }
 391         break;
 392     }
 393 }
 394
 395 void *output_to_PCM(NeAACDecHandle hDecoder,
 396                     real_t **input, void *sample_buffer, uint8_t channels,
 397                     uint16_t frame_len, uint8_t format)
 398 {
 399     int16_t   *short_sample_buffer = (int16_t*)sample_buffer;
 400     int32_t   *int_sample_buffer = (int32_t*)sample_buffer;
 401     float32_t *float_sample_buffer = (float32_t*)sample_buffer;
 402     double    *double_sample_buffer = (double*)sample_buffer;
 403
 404 #ifdef PROFILE
 405     int64_t count = faad_get_ts();
 406 #endif
 407
 408     /* Copy output to a standard PCM buffer */
 409     switch (format)
 410     {
 411     case FAAD_FMT_16BIT:
 412         to_PCM_16bit(hDecoder, input, channels, frame_len, &short_sample_buffer);
 413         break;
 414     case FAAD_FMT_24BIT:
 415         to_PCM_24bit(hDecoder, input, channels, frame_len, &int_sample_buffer);
 416         break;
 417     case FAAD_FMT_32BIT:
 418         to_PCM_32bit(hDecoder, input, channels, frame_len, &int_sample_buffer);
 419         break;
 420     case FAAD_FMT_FLOAT:
 421         to_PCM_float(hDecoder, input, channels, frame_len, &float_sample_buffer);
 422         break;
 423     case FAAD_FMT_DOUBLE:
 424         to_PCM_double(hDecoder, input, channels, frame_len, &double_sample_buffer);
 425         break;
 426     }
 427
 428 #ifdef PROFILE
 429     count = faad_get_ts() - count;
 430     hDecoder->output_cycles += count;
 431 #endif
 432
 433     return sample_buffer;
 434 }
 435
 436 #else
 437
 438 #define DM_MUL FRAC_CONST(0.3203772410170407) // 1/(1+sqrt(2) + 1/sqrt(2))
 439 #define RSQRT2 FRAC_CONST(0.7071067811865475244) // 1/sqrt(2)
 440
 441 static INLINE real_t get_sample(real_t **input, uint8_t channel, uint16_t sample,
 442                                 uint8_t down_matrix, uint8_t up_matrix,
 443                                 uint8_t *internal_channel)
 444 {
 445     if (up_matrix == 1)
 446         return input[internal_channel[0]][sample];
 447
 448     if (!down_matrix)
 449         return input[internal_channel[channel]][sample];
 450
 451     if (channel == 0)
 452     {
 453         real_t C   = MUL_F(input[internal_channel[0]][sample], RSQRT2);
 454         real_t L_S = MUL_F(input[internal_channel[3]][sample], RSQRT2);
 455         real_t cum = input[internal_channel[1]][sample] + C + L_S;
 456         return MUL_F(cum, DM_MUL);
 457     } else {
 458         real_t C   = MUL_F(input[internal_channel[0]][sample], RSQRT2);
 459         real_t R_S = MUL_F(input[internal_channel[4]][sample], RSQRT2);
 460         real_t cum = input[internal_channel[2]][sample] + C + R_S;
 461         return MUL_F(cum, DM_MUL);
 462     }
 463 }
 464
 465 void* output_to_PCM_sux(NeAACDecHandle hDecoder,
 466                     real_t **input, void *sample_buffer, uint8_t channels,
 467                     uint16_t frame_len, uint8_t format)
 468 {
 469     uint8_t ch;
 470     uint16_t i;
 471     int16_t *short_sample_buffer = (int16_t*)sample_buffer;
 472     int32_t *int_sample_buffer = (int32_t*)sample_buffer;
 473
 474     /* Copy output to a standard PCM buffer */
 475     for (ch = 0; ch < channels; ch++)
 476     {
 477         switch (format)
 478         {
 479         case FAAD_FMT_16BIT:
 480             for(i = 0; i < frame_len; i++)
 481             {
 482                 int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
 483                     hDecoder->internal_channel);
 484                 if (tmp >= 0)
 485                 {
 486                     tmp += (1 << (REAL_BITS-1));
 487                     if (tmp >= REAL_CONST(32767))
 488                     {
 489                         tmp = REAL_CONST(32767);
 490                     }
 491                 } else {
 492                     tmp += -(1 << (REAL_BITS-1));
 493                     if (tmp <= REAL_CONST(-32768))
 494                     {
 495                         tmp = REAL_CONST(-32768);
 496                     }
 497                 }
 498                 tmp >>= REAL_BITS;
 499                 short_sample_buffer[(i*channels)+ch] = (int16_t)tmp;
 500             }
 501             break;
 502         case FAAD_FMT_24BIT:
 503             for(i = 0; i < frame_len; i++)
 504             {
 505                 int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
 506                     hDecoder->internal_channel);
 507                 if (tmp >= 0)
 508                 {
 509                     tmp += (1 << (REAL_BITS-9));
 510                     tmp >>= (REAL_BITS-8);
 511                     if (tmp >= 8388607)
 512                     {
 513                         tmp = 8388607;
 514                     }
 515                 } else {
 516                     tmp += -(1 << (REAL_BITS-9));
 517                     tmp >>= (REAL_BITS-8);
 518                     if (tmp <= -8388608)
 519                     {
 520                         tmp = -8388608;
 521                     }
 522                 }
 523                 int_sample_buffer[(i*channels)+ch] = (int32_t)tmp;
 524             }
 525             break;
 526         case FAAD_FMT_32BIT:
 527             for(i = 0; i < frame_len; i++)
 528             {
 529                 int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
 530                     hDecoder->internal_channel);
 531                 if (tmp >= 0)
 532                 {
 533                     tmp += (1 << (16-REAL_BITS-1));
 534                     tmp <<= (16-REAL_BITS);
 535                 } else {
 536                     tmp += -(1 << (16-REAL_BITS-1));
 537                     tmp <<= (16-REAL_BITS);
 538                 }
 539                 int_sample_buffer[(i*channels)+ch] = (int32_t)tmp;
 540             }
 541             break;
 542         case FAAD_FMT_FIXED:
 543             for(i = 0; i < frame_len; i++)
 544             {
 545                 real_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
 546                     hDecoder->internal_channel);
 547                 int_sample_buffer[(i*channels)+ch] = (int32_t)tmp;
 548             }
 549             break;
 550         }
 551     }
 552
 553     return sample_buffer;
 554 }
 555
 556 void* output_to_PCM(NeAACDecHandle hDecoder,
 557                     real_t **input, void *sample_buffer, uint8_t channels,
 558                     uint16_t frame_len, uint8_t format)
 559 {
 560     int ch;
 561     int i;
 562     int16_t *short_sample_buffer = (int16_t*)sample_buffer;
 563     real_t *ch0 = input[hDecoder->internal_channel[0]];
 564     real_t *ch1 = input[hDecoder->internal_channel[1]];
 565     real_t *ch2 = input[hDecoder->internal_channel[2]];
 566     real_t *ch3 = input[hDecoder->internal_channel[3]];
 567     real_t *ch4 = input[hDecoder->internal_channel[4]];
 568
 569     if (format != FAAD_FMT_16BIT)
 570         return output_to_PCM_sux(hDecoder, input, sample_buffer, channels, frame_len, format);
 571
 572     if (hDecoder->downMatrix) {
 573         for(i = 0; i < frame_len; i++)
 574         {
 575             int32_t tmp;
 576             tmp = (ch1[i] + ((ch0[i]+ch3[i])>>1) + ((ch0[i]+ch3[i])>>2) + (1<<(REAL_BITS))) >> (REAL_BITS+1);
 577             if ((tmp+0x8000) & ~0xffff) tmp = ~(tmp>>31)-0x8000;
 578             short_sample_buffer[0] = tmp;
 579             tmp = (ch2[i] + ((ch0[i]+ch4[i])>>1) + ((ch0[i]+ch4[i])>>2) + (1<<(REAL_BITS))) >> (REAL_BITS+1);
 580             if ((tmp+0x8000) & ~0xffff) tmp = ~(tmp>>31)-0x8000;
 581             short_sample_buffer[1] = tmp;
 582             short_sample_buffer += channels;
 583         }
 584         return sample_buffer;
 585     }
 586
 587     /* Copy output to a standard PCM buffer */
 588     for(i = 0; i < frame_len; i++)
 589     {
 590         for (ch = 0; ch < channels; ch++)
 591         {
 592             int32_t tmp = input[hDecoder->internal_channel[ch]][i];
 593             tmp += (1 << (REAL_BITS-1));
 594             tmp >>= REAL_BITS;
 595             if ((tmp+0x8000) & ~0xffff) tmp = ~(tmp>>31)-0x8000;
 596             *(short_sample_buffer++) = tmp;
 597         }
 598     }
 599
 600     return sample_buffer;
 601 }
 602
 603 #endif