lib/bladeenc/codec.c

   1 /*
   2             (c) Copyright 1998-2000 - Tord Jansson
   3             ======================================
   4
   5         This file is part of the BladeEnc MP3 Encoder, based on
   6         ISO's reference code for MPEG Layer 3 compression, and might
   7         contain smaller or larger sections that are directly taken
   8         from ISO's reference code.
   9
  10         All changes to the ISO reference code herein are either
  11         copyrighted by Tord Jansson (tord.jansson@swipnet.se)
  12         or sublicensed to Tord Jansson by a third party.
  13
  14     BladeEnc is free software; you can redistribute this file
  15     and/or modify it under the terms of the GNU Lesser General Public
  16     License as published by the Free Software Foundation; either
  17     version 2.1 of the License, or (at your option) any later version.
  18
  19
  20
  21     ------------    CHANGES    ------------
  22
  23     2000-11-22  Andre Piotrowski
  24
  25     -   big fix: module - original dist10 error - l3_sb_sample has to be of type 'L3SBS' not 'SBS'.
  26     -   bug fix: codecInit() - don't reset fInit-huffman_read_flag - read_huffcodetab() is a memory eater!
  27
  28     2000-12-11  ap
  29
  30     -   reformatted
  31     -   speed up: use single buffer
  32 */
  33
  34 #include    <stdlib.h>
  35 #include    <assert.h>
  36
  37 #include    "common.h"
  38 #include    "l3psy.h"
  39 #include    "mdct.h"
  40 #include    "reservoir.h"
  41 #include    "formatbitstream2.h"
  42 #include    "l3bitstream.h"
  43 #include    "loop.h"
  44 #include    "encoder.h"
  45 #include    "codec.h"
  46
  47
  48
  49
  50
  51 extern  int             fInit_fft;
  52
  53
  54
  55
  56
  57 /************************************************************************/
  58
  59 #define SAMPLES_PER_FRAME       1152
  60
  61 static  L3SBS                   l3_sb_sample;
  62
  63 static  layer                   info;
  64
  65
  66
  67 #if ORG_BUFFERS
  68 static  short                   buffer[2][1152];
  69 /*  static  float                   snr32[32]; */
  70 static  short                   sam[2][2048];
  71 #else
  72 static  FLOAT                   buffer[2][2048];
  73 static  int                     buffer_idx;
  74 #endif
  75
  76
  77
  78 static  int                     whole_SpF;
  79
  80 static  double                  frac_SpF, slot_lag;
  81
  82 static  int                     stereo, error_protection;
  83
  84 static  III_side_info_t         l3_side;
  85 static  CodecInitOut            sOut;
  86
  87 static  frame_params            fr_ps;
  88
  89
  90
  91 char                    *pEncodedOutput;
  92 int                     outputBit;
  93
  94 volatile double         avg_slots_per_frame;
  95
  96
  97
  98
  99
 100 /*____ codecInit() ____________________________________________________________*/
 101
 102 CodecInitOut            *codecInit (CodecInitIn *psIn)
 103 {
 104     int                     j;
 105
 106     /* Read psIn */
 107
 108     switch (psIn->frequency)
 109     {
 110         case 48000:  info.sampling_frequency = 1;  break;
 111         case 44100:  info.sampling_frequency = 0;  break;
 112         case 32000:  info.sampling_frequency = 2;  break;
 113         default   :  return FALSE;
 114     }
 115
 116     switch (psIn->mode)
 117     {
 118         case  0:  info.mode = MPG_MD_STEREO      ;  info.mode_ext = 0;  break;
 119         case  2:  info.mode = MPG_MD_DUAL_CHANNEL;  info.mode_ext = 0;  break;
 120         case  3:  info.mode = MPG_MD_MONO        ;  info.mode_ext = 0;  break;
 121         default:  return FALSE;
 122     }
 123
 124     j = 0;
 125     while (j < 15  &&  bitratex[1][j] != psIn->bitrate)
 126         j++;
 127     info.bitrate_index    = j;
 128
 129     info.version          = 1;   /* Default: MPEG-1 */
 130     info.emphasis         = psIn->emphasis;
 131     info.extension        = psIn->fPrivate;
 132     info.copyright        = psIn->fCopyright;
 133     info.original         = psIn->fOriginal;
 134     info.error_protection = psIn->fCRC;
 135
 136
 137 /*_______ Static-fix _______________*/
 138
 139
 140     fInit_mdct_sub = 0;
 141     fInit_mdct = 0;
 142
 143     fInit_fft = 0;
 144
 145     fInit_iteration_loop = 0;
 146 /*  DON'T DO THAT ALL THE TIME
 147     fInit_huffman_read_flag = 0;
 148 */
 149
 150     fixStatic_loop();
 151
 152     l3_side.main_data_begin = 0;
 153     fixStatic_reservoir();
 154
 155
 156 /*___________________________________*/
 157
 158     psycho_anal_init (psIn->frequency);
 159     initWindowFilterSubband ();
 160     initFormatBitstream ();
 161
 162 /*     clear buffers */
 163     memset ((char *) l3_sb_sample, 0, sizeof(l3_sb_sample));
 164     memset((char *) buffer, 0, sizeof(buffer));
 165 /*    memset((char *) snr32, 0, sizeof(snr32));*/
 166 #if ORG_BUFFERS
 167     memset((char *) sam, 0, sizeof(sam));
 168 #endif
 169
 170
 171
 172     fr_ps.header      = &info;
 173     fr_ps.tab_num     = -1;   /* no table loaded */
 174     fr_ps.alloc       = NULL;
 175     fr_ps.actual_mode = info.mode;
 176     fr_ps.stereo      = (info.mode == MPG_MD_MONO) ? 1 : 2;
 177     fr_ps.sblimit     = SBLIMIT;
 178     fr_ps.jsbound     = SBLIMIT;
 179
 180
 181     stereo = fr_ps.stereo;
 182     error_protection = info.error_protection;
 183
 184     avg_slots_per_frame =
 185         ((double) SAMPLES_PER_FRAME / s_freq[1][info.sampling_frequency]) *
 186         ((double) bitratex[1][info.bitrate_index] / 8.0);
 187     whole_SpF = (int) avg_slots_per_frame;
 188     frac_SpF  = avg_slots_per_frame - (double) whole_SpF;
 189     slot_lag  = -frac_SpF;
 190
 191 /*    if (frac_SpF == 0)
 192         info.padding = 0;
 193 */
 194     genNoisePowTab();
 195
 196 /*________________________*/
 197
 198
 199     if( stereo != 2 )
 200         sOut.nSamples = SAMPLES_PER_FRAME;
 201     else
 202         sOut.nSamples = SAMPLES_PER_FRAME*2;
 203
 204     sOut.bufferSize = 2048;
 205
 206     return  &sOut;          /* How many samples we want in each chunk... */
 207 }
 208
 209
 210
 211
 212
 213 /*____ codecEncodeChunk() _____________________________________________________*/
 214
 215 unsigned int            codecEncodeChunk
 216 (
 217     int                     nSamples,
 218     short                   *pSamples,
 219     char                    *pDest
 220 )
 221 {
 222     static  double              xr[2][2][576];
 223     static  double              xr_dec[2][2][576];
 224     static  double              pe[2][2];
 225     static  int                 l3_enc[2][2][576];
 226     static  III_psy_ratio       ratio;
 227     static  III_scalefac_t      scalefac;
 228     int                         gr, ch;
 229     int                         mean_bits, sideinfo_len;
 230     int                         bitsPerFrame;
 231     int                         j;
 232
 233 /*
 234     static  int                 fFirst = TRUE;
 235
 236     if (fFirst)
 237     {
 238         memset ((char *) &xr      , 0, sizeof(xr));
 239         memset ((char *) &xr_dec  , 0, sizeof(xr_dec));
 240         memset ((char *) &pe      , 0, sizeof(pe));
 241         memset ((char *) &l3_enc  , 0, sizeof(l3_enc));
 242         memset ((char *) &ratio   , 0, sizeof(ratio));
 243         memset ((char *) &l3_side , 0, sizeof(l3_side));
 244         memset ((char *) &scalefac, 0, sizeof(scalefac));
 245
 246         fFirst = FALSE;
 247     }
 248 */
 249
 250
 251 /* rebuffer audio */
 252
 253 #if ORG_BUFFERS
 254     rebuffer_audio (buffer, pSamples, nSamples, stereo);
 255 #else
 256     rebuffer_audio (pSamples, buffer, &buffer_idx, nSamples, stereo);
 257 #endif
 258
 259
 260 /* psychoacoustic model */
 261
 262     for (gr = 0;  gr < 2;  gr++)
 263         for (ch = 0;  ch < stereo;  ch++)
 264             psycho_anal
 265             (
 266 #if ORG_BUFFERS
 267                 &buffer[ch][gr*576],
 268                 &sam[ch][0],
 269 #else
 270                 buffer[ch],
 271                 (buffer_idx+gr*576) & 2047,
 272 #endif
 273                 ch,
 274                 3,
 275                 /*snr32,*/
 276                 &ratio.l[gr][ch][0],
 277                 &ratio.s[gr][ch][0],
 278                 &pe[gr][ch],
 279                 &l3_side.gr[gr].ch[ch].tt
 280             );
 281
 282
 283 /* polyphase filtering */
 284
 285     for (gr = 0;  gr < 2;  gr++)
 286     {
 287         int     gr_plus_1 = gr_idx[gr+1];
 288
 289         for (ch = 0;  ch < stereo;  ch++)
 290         {
 291             for (j = 0;  j < 18;  j++)
 292             {
 293                 windowFilterSubband
 294                 (
 295 #if ORG_BUFFERS
 296                     &buffer[ch][gr*18*32+32*j],
 297                     ch,
 298 #else
 299                     buffer[ch],
 300                     (buffer_idx+768-480+gr*18*32+32*j) & 2047,
 301 #endif
 302                     l3_sb_sample[ch][gr_plus_1][j]
 303                 );
 304             }
 305         }
 306     }
 307
 308
 309 /* apply mdct to the polyphase outputs */
 310
 311     mdct_sub (&l3_sb_sample, xr, stereo, &l3_side, 2);
 312
 313
 314     pEncodedOutput = pDest;
 315     outputBit = 8;
 316     pEncodedOutput[0] = 0;
 317
 318
 319     if (frac_SpF != 0)
 320     {
 321         if (slot_lag > (frac_SpF-1.0))
 322         {
 323             slot_lag -= frac_SpF;
 324             info.padding = 0;
 325         }
 326         else
 327         {
 328             info.padding = 1;
 329             slot_lag += (1-frac_SpF);
 330         }
 331     }
 332
 333     bitsPerFrame = 8 * whole_SpF + (info.padding * 8);
 334
 335
 336 /* determine the mean bitrate for main data */
 337
 338     sideinfo_len = 32;
 339
 340     if (stereo == 1)
 341         sideinfo_len += 136;
 342     else
 343         sideinfo_len += 256;
 344
 345     if (info.error_protection)
 346         sideinfo_len += 16;
 347
 348     mean_bits = (bitsPerFrame - sideinfo_len) / 2;
 349
 350
 351 /* bit and noise allocation */
 352
 353     iteration_loop
 354     (
 355         pe,
 356         xr,
 357         &ratio,
 358         &l3_side,
 359         l3_enc,
 360         mean_bits,
 361         stereo,
 362         xr_dec,
 363         &scalefac,
 364         &fr_ps,
 365         0,
 366         bitsPerFrame
 367     );
 368
 369
 370 /* write the frame to the bitstream */
 371
 372     III_format_bitstream
 373     (
 374         bitsPerFrame,
 375         &fr_ps,
 376         l3_enc,
 377         &l3_side,
 378         &scalefac,
 379         xr,
 380         NULL,
 381         0
 382     );
 383
 384
 385     return  pEncodedOutput - pDest;
 386 }
 387
 388
 389
 390
 391
 392 /*____ codecExit() ____________________________________________________________*/
 393
 394 unsigned int            codecExit (char *pDest)
 395 {
 396     pEncodedOutput = pDest;
 397     outputBit = 8;
 398     pEncodedOutput[0] = 0;
 399
 400     psycho_anal_exit ();
 401     exitFormatBitstream ();
 402     III_FlushBitstream ();
 403
 404     return pEncodedOutput - pDest;
 405 }
 406
 407
 408
 409
 410
 411 /*____ codecFlush() _________________________________________________________*/
 412
 413 unsigned int            codecFlush (char *pDest)
 414 {
 415     pEncodedOutput = pDest;
 416     outputBit = 8;
 417     pEncodedOutput[0] = 0;
 418
 419     flushFrame ();
 420
 421     whole_SpF = (int) avg_slots_per_frame;
 422     frac_SpF  = avg_slots_per_frame - (double) whole_SpF;
 423     slot_lag  = -frac_SpF;
 424
 425     l3_side.main_data_begin = 0;
 426     fixStatic_reservoir ();
 427
 428     return pEncodedOutput - pDest;
 429 }
 430
 431
 432