toolame-02l/toolame.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include "common.h"
   5 #include "encoder.h"
   6 #include "musicin.h"
   7 #include "options.h"
   8 #include "audio_read.h"
   9 #include "bitstream.h"
  10 #include "mem.h"
  11 #include "crc.h"
  12 #include "psycho_n1.h"
  13 #include "psycho_0.h"
  14 #include "psycho_1.h"
  15 #include "psycho_2.h"
  16 #include "psycho_3.h"
  17 #include "psycho_4.h"
  18 #include "encode.h"
  19 #include "availbits.h"
  20 #include "subband.h"
  21 #include "encode_new.h"
  22 #include "toolame.h"
  23
  24 #include <assert.h>
  25
  26 FILE *musicin;
  27 Bit_stream_struc bs;
  28 char *programName;
  29 char toolameversion[10] = "0.2l";
  30
  31 // Input buffer management.  This is not reentrant but neither is toolame.
  32
  33 pthread_mutex_t toolame_input_lock;
  34 pthread_mutex_t toolame_output_lock;
  35 char *toolame_buffer = 0;
  36 int toolame_buffer_bytes = 0;
  37 int toolame_error = 0;
  38 int toolame_eof = 0;
  39
  40 // functions for library access
  41
  42 void toolame_init_buffers()
  43 {
  44         pthread_mutex_init(&toolame_input_lock, 0);
  45         pthread_mutex_init(&toolame_output_lock, 0);
  46         pthread_mutex_lock(&toolame_input_lock);
  47         if(!toolame_buffer) toolame_buffer = malloc(TOOLAME_BUFFER_BYTES);
  48         toolame_buffer_bytes = 0;
  49         toolame_error = 0;
  50         toolame_eof = 0;
  51 }
  52
  53 int toolame_send_buffer(char *data, int bytes)
  54 {
  55         int got_it = 0;
  56         if(bytes > TOOLAME_BUFFER_BYTES)
  57         {
  58                 fprintf(stderr,
  59                         "toolame_send_buffer: bytes %d exceed maximum bytes %d\n",
  60                         bytes,
  61                         TOOLAME_BUFFER_BYTES);
  62                 return 1;
  63         }
  64         if(toolame_error) return 1;
  65
  66         if(!bytes)
  67         {
  68 //              pthread_mutex_lock(&toolame_output_lock);
  69                 toolame_eof = 1;
  70                 pthread_mutex_unlock(&toolame_input_lock);
  71                 return 0;
  72         }
  73
  74         while(!got_it)
  75         {
  76                 pthread_mutex_lock(&toolame_output_lock);
  77                 if(toolame_error)
  78                 {
  79                         pthread_mutex_unlock(&toolame_input_lock);
  80                         return 1;
  81                 }
  82
  83                 if(toolame_buffer_bytes < TOOLAME_BUFFER_BYTES - bytes)
  84                 {
  85                         memcpy(toolame_buffer + toolame_buffer_bytes, data, bytes);
  86                         toolame_buffer_bytes += bytes;
  87                         got_it = 1;
  88                 }
  89                 pthread_mutex_unlock(&toolame_input_lock);
  90         }
  91
  92         return 0;
  93 }
  94
  95 int toolame_buffer_read(char *dst, int size, int n)
  96 {
  97         int got_it = 0;
  98         int result = 0;
  99
 100 //printf("toolame_buffer_read 1 %d %d %d\n", got_it, toolame_eof, toolame_error);
 101         while(!got_it && !toolame_eof && !toolame_error)
 102         {
 103 //printf("toolame_buffer_read 2\n");
 104                 pthread_mutex_lock(&toolame_input_lock);
 105 //printf("toolame_buffer_read 3\n");
 106                 if(toolame_eof || toolame_buffer_bytes >= size * n)
 107                         got_it = 1;
 108                 else
 109                         pthread_mutex_unlock(&toolame_output_lock);
 110         }
 111         result = size * n;
 112         if(result > toolame_buffer_bytes)
 113                 result = toolame_buffer_bytes;
 114         memcpy(dst, toolame_buffer, result);
 115
 116         if(size * n > result)
 117                 bzero(dst + result, size * n - result);
 118         memcpy(toolame_buffer, toolame_buffer + result, toolame_buffer_bytes - result);
 119         toolame_buffer_bytes -= result;
 120         pthread_mutex_unlock(&toolame_output_lock);
 121
 122 //printf("toolame_buffer_read 100 %d\n", result);
 123         return result;
 124 }
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140 void global_init (void)
 141 {
 142   glopts.usepsy = TRUE;
 143   glopts.usepadbit = TRUE;
 144   glopts.quickmode = FALSE;
 145   glopts.quickcount = 10;
 146   glopts.downmix = FALSE;
 147   glopts.byteswap = FALSE;
 148   glopts.channelswap = FALSE;
 149   glopts.vbr = FALSE;
 150   glopts.vbrlevel = 0;
 151   glopts.athlevel = 0;
 152   glopts.verbosity = 2;
 153 }
 154
 155 /************************************************************************
 156 *
 157 * main
 158 *
 159 * PURPOSE:  MPEG II Encoder with
 160 * psychoacoustic models 1 (MUSICAM) and 2 (AT&T)
 161 *
 162 * SEMANTICS:  One overlapping frame of audio of up to 2 channels are
 163 * processed at a time in the following order:
 164 * (associated routines are in parentheses)
 165 *
 166 * 1.  Filter sliding window of data to get 32 subband
 167 * samples per channel.
 168 * (window_subband,filter_subband)
 169 *
 170 * 2.  If joint stereo mode, combine left and right channels
 171 * for subbands above #jsbound#.
 172 * (combine_LR)
 173 *
 174 * 3.  Calculate scalefactors for the frame, and
 175 * also calculate scalefactor select information.
 176 * (*_scale_factor_calc)
 177 *
 178 * 4.  Calculate psychoacoustic masking levels using selected
 179 * psychoacoustic model.
 180 * (psycho_i, psycho_ii)
 181 *
 182 * 5.  Perform iterative bit allocation for subbands with low
 183 * mask_to_noise ratios using masking levels from step 4.
 184 * (*_main_bit_allocation)
 185 *
 186 * 6.  If error protection flag is active, add redundancy for
 187 * error protection.
 188 * (*_CRC_calc)
 189 *
 190 * 7.  Pack bit allocation, scalefactors, and scalefactor select
 191 *headerrmation onto bitstream.
 192 * (*_encode_bit_alloc,*_encode_scale,transmission_pattern)
 193 *
 194 * 8.  Quantize subbands and pack them into bitstream
 195 * (*_subband_quantization, *_sample_encoding)
 196 *
 197 ************************************************************************/
 198
 199 int frameNum = 0;
 200
 201 int toolame (int argc, char **argv)
 202 {
 203   typedef double SBS[2][3][SCALE_BLOCK][SBLIMIT];
 204   SBS *sb_sample;
 205   typedef double JSBS[3][SCALE_BLOCK][SBLIMIT];
 206   JSBS *j_sample;
 207   typedef double IN[2][HAN_SIZE];
 208   IN *win_que;
 209   typedef unsigned int SUB[2][3][SCALE_BLOCK][SBLIMIT];
 210   SUB *subband;
 211
 212   frame_info frame;
 213   frame_header header;
 214   char original_file_name[MAX_NAME_SIZE];
 215   char encoded_file_name[MAX_NAME_SIZE];
 216   short **win_buf;
 217   static short buffer[2][1152];
 218   static unsigned int bit_alloc[2][SBLIMIT], scfsi[2][SBLIMIT];
 219   static unsigned int scalar[2][3][SBLIMIT], j_scale[3][SBLIMIT];
 220   static double smr[2][SBLIMIT], lgmin[2][SBLIMIT], max_sc[2][SBLIMIT];
 221   // FLOAT snr32[32];
 222   short sam[2][1344];           /* was [1056]; */
 223   int model, nch, error_protection;
 224   static unsigned int crc;
 225   int sb, ch, adb;
 226   unsigned long frameBits, sentBits = 0;
 227   unsigned long num_samples;
 228   int lg_frame;
 229   int i;
 230
 231   /* Used to keep the SNR values for the fast/quick psy models */
 232   static FLOAT smrdef[2][32];
 233
 234   static int psycount = 0;
 235   extern int minimum;
 236
 237   sb_sample = (SBS *) mem_alloc (sizeof (SBS), "sb_sample");
 238   j_sample = (JSBS *) mem_alloc (sizeof (JSBS), "j_sample");
 239   win_que = (IN *) mem_alloc (sizeof (IN), "Win_que");
 240   subband = (SUB *) mem_alloc (sizeof (SUB), "subband");
 241   win_buf = (short **) mem_alloc (sizeof (short *) * 2, "win_buf");
 242
 243   /* clear buffers */
 244   memset ((char *) buffer, 0, sizeof (buffer));
 245   memset ((char *) bit_alloc, 0, sizeof (bit_alloc));
 246   memset ((char *) scalar, 0, sizeof (scalar));
 247   memset ((char *) j_scale, 0, sizeof (j_scale));
 248   memset ((char *) scfsi, 0, sizeof (scfsi));
 249   memset ((char *) smr, 0, sizeof (smr));
 250   memset ((char *) lgmin, 0, sizeof (lgmin));
 251   memset ((char *) max_sc, 0, sizeof (max_sc));
 252   //memset ((char *) snr32, 0, sizeof (snr32));
 253   memset ((char *) sam, 0, sizeof (sam));
 254
 255   global_init ();
 256
 257   header.extension = 0;
 258   frame.header = &header;
 259   frame.tab_num = -1;           /* no table loaded */
 260   frame.alloc = NULL;
 261   header.version = MPEG_AUDIO_ID;       /* Default: MPEG-1 */
 262
 263   programName = argv[0];
 264   if (argc == 1)                /* no command-line args */
 265     short_usage ();
 266   else
 267     parse_args (argc, argv, &frame, &model, &num_samples, original_file_name,
 268                 encoded_file_name);
 269   print_config (&frame, &model, original_file_name, encoded_file_name);
 270
 271   /* this will load the alloc tables and do some other stuff */
 272   hdr_to_frps (&frame);
 273   nch = frame.nch;
 274   error_protection = header.error_protection;
 275
 276   while (get_audio (musicin, buffer, num_samples, nch, &header) > 0) {
 277     if (glopts.verbosity > 1)
 278       if (++frameNum % 10 == 0)
 279         fprintf (stderr, "[%4u]\r", frameNum);
 280     fflush (stderr);
 281     win_buf[0] = &buffer[0][0];
 282     win_buf[1] = &buffer[1][0];
 283
 284     adb = available_bits (&header, &glopts);
 285     lg_frame = adb / 8;
 286     if (header.dab_extension) {
 287       /* in 24 kHz we always have 4 bytes */
 288       if (header.sampling_frequency == 1)
 289         header.dab_extension = 4;
 290 /* You must have one frame in memory if you are in DAB mode                 */
 291 /* in conformity of the norme ETS 300 401 http://www.etsi.org               */
 292       /* see bitstream.c            */
 293       if (frameNum == 1)
 294         minimum = lg_frame + MINIMUM;
 295       adb -= header.dab_extension * 8 + header.dab_length * 8 + 16;
 296     }
 297
 298     {
 299       int gr, bl, ch;
 300       /* New polyphase filter
 301          Combines windowing and filtering. Ricardo Feb'03 */
 302       for( gr = 0; gr < 3; gr++ )
 303         for ( bl = 0; bl < 12; bl++ )
 304           for ( ch = 0; ch < nch; ch++ )
 305             WindowFilterSubband( &buffer[ch][gr * 12 * 32 + 32 * bl], ch,
 306                                  &(*sb_sample)[ch][gr][bl][0] );
 307     }
 308
 309 #ifdef REFERENCECODE
 310     {
 311       /* Old code. left here for reference */
 312       int gr, bl, ch;
 313       for (gr = 0; gr < 3; gr++)
 314         for (bl = 0; bl < SCALE_BLOCK; bl++)
 315           for (ch = 0; ch < nch; ch++) {
 316             window_subband (&win_buf[ch], &(*win_que)[ch][0], ch);
 317             filter_subband (&(*win_que)[ch][0], &(*sb_sample)[ch][gr][bl][0]);
 318           }
 319     }
 320 #endif
 321
 322
 323 #ifdef NEWENCODE
 324     scalefactor_calc_new(*sb_sample, scalar, nch, frame.sblimit);
 325     find_sf_max (scalar, &frame, max_sc);
 326     if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
 327       /* this way we calculate more mono than we need */
 328       /* but it is cheap */
 329       combine_LR_new (*sb_sample, *j_sample, frame.sblimit);
 330       scalefactor_calc_new (j_sample, &j_scale, 1, frame.sblimit);
 331     }
 332 #else
 333     scale_factor_calc (*sb_sample, scalar, nch, frame.sblimit);
 334     pick_scale (scalar, &frame, max_sc);
 335     if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
 336       /* this way we calculate more mono than we need */
 337       /* but it is cheap */
 338       combine_LR (*sb_sample, *j_sample, frame.sblimit);
 339       scale_factor_calc (j_sample, &j_scale, 1, frame.sblimit);
 340     }
 341 #endif
 342
 343
 344
 345     if ((glopts.quickmode == TRUE) && (++psycount % glopts.quickcount != 0)) {
 346       /* We're using quick mode, so we're only calculating the model every
 347          'quickcount' frames. Otherwise, just copy the old ones across */
 348       for (ch = 0; ch < nch; ch++) {
 349         for (sb = 0; sb < SBLIMIT; sb++)
 350           smr[ch][sb] = smrdef[ch][sb];
 351       }
 352     } else {
 353       /* calculate the psymodel */
 354       switch (model) {
 355       case -1:
 356         psycho_n1 (smr, nch);
 357         break;
 358       case 0:   /* Psy Model A */
 359         psycho_0 (smr, nch, scalar, (FLOAT) s_freq[header.version][header.sampling_frequency] * 1000);
 360         break;
 361       case 1:
 362         psycho_1 (buffer, max_sc, smr, &frame);
 363         break;
 364       case 2:
 365         for (ch = 0; ch < nch; ch++) {
 366           psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
 367                      (FLOAT) s_freq[header.version][header.sampling_frequency] *
 368                      1000, &glopts);
 369         }
 370         break;
 371       case 3:
 372         /* Modified psy model 1 */
 373         psycho_3 (buffer, max_sc, smr, &frame, &glopts);
 374         break;
 375       case 4:
 376         /* Modified Psycho Model 2 */
 377         for (ch = 0; ch < nch; ch++) {
 378           psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
 379                      (FLOAT) s_freq[header.version][header.sampling_frequency] *
 380                      1000, &glopts);
 381         }
 382         break;
 383       case 5:
 384         /* Model 5 comparse model 1 and 3 */
 385         psycho_1 (buffer, max_sc, smr, &frame);
 386         fprintf(stdout,"1 ");
 387         smr_dump(smr,nch);
 388         psycho_3 (buffer, max_sc, smr, &frame, &glopts);
 389         fprintf(stdout,"3 ");
 390         smr_dump(smr,nch);
 391         break;
 392       case 6:
 393         /* Model 6 compares model 2 and 4 */
 394         for (ch = 0; ch < nch; ch++)
 395           psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
 396                     (FLOAT) s_freq[header.version][header.sampling_frequency] *
 397                     1000, &glopts);
 398         fprintf(stdout,"2 ");
 399         smr_dump(smr,nch);
 400         for (ch = 0; ch < nch; ch++)
 401           psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
 402                      (FLOAT) s_freq[header.version][header.sampling_frequency] *
 403                      1000, &glopts);
 404         fprintf(stdout,"4 ");
 405         smr_dump(smr,nch);
 406         break;
 407       case 7:
 408         fprintf(stdout,"Frame: %i\n",frameNum);
 409         /* Dump the SMRs for all models */
 410         psycho_1 (buffer, max_sc, smr, &frame);
 411         fprintf(stdout,"1");
 412         smr_dump(smr, nch);
 413         psycho_3 (buffer, max_sc, smr, &frame, &glopts);
 414         fprintf(stdout,"3");
 415         smr_dump(smr,nch);
 416         for (ch = 0; ch < nch; ch++)
 417           psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
 418                     (FLOAT) s_freq[header.version][header.sampling_frequency] *
 419                     1000, &glopts);
 420         fprintf(stdout,"2");
 421         smr_dump(smr,nch);
 422         for (ch = 0; ch < nch; ch++)
 423           psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
 424                      (FLOAT) s_freq[header.version][header.sampling_frequency] *
 425                      1000, &glopts);
 426         fprintf(stdout,"4");
 427         smr_dump(smr,nch);
 428         break;
 429       case 8:
 430         /* Compare 0 and 4 */
 431         psycho_n1 (smr, nch);
 432         fprintf(stdout,"0");
 433         smr_dump(smr,nch);
 434
 435         for (ch = 0; ch < nch; ch++)
 436           psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
 437                      (FLOAT) s_freq[header.version][header.sampling_frequency] *
 438                      1000, &glopts);
 439         fprintf(stdout,"4");
 440         smr_dump(smr,nch);
 441         break;
 442       default:
 443         fprintf (stderr, "Invalid psy model specification: %i\n", model);
 444 toolame_error = 1;
 445 pthread_mutex_unlock(&toolame_output_lock);
 446 return 1;
 447         exit (0);
 448       }
 449
 450       if (glopts.quickmode == TRUE)
 451         /* copy the smr values and reuse them later */
 452         for (ch = 0; ch < nch; ch++) {
 453           for (sb = 0; sb < SBLIMIT; sb++)
 454             smrdef[ch][sb] = smr[ch][sb];
 455         }
 456
 457       if (glopts.verbosity > 4)
 458         smr_dump(smr, nch);
 459
 460
 461
 462
 463     }
 464
 465 #ifdef NEWENCODE
 466     sf_transmission_pattern (scalar, scfsi, &frame);
 467     main_bit_allocation_new (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
 468     //main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
 469
 470     if (error_protection)
 471       CRC_calc (&frame, bit_alloc, scfsi, &crc);
 472
 473     write_header (&frame, &bs);
 474     //encode_info (&frame, &bs);
 475     if (error_protection)
 476       putbits (&bs, crc, 16);
 477     write_bit_alloc (bit_alloc, &frame, &bs);
 478     //encode_bit_alloc (bit_alloc, &frame, &bs);
 479     write_scalefactors(bit_alloc, scfsi, scalar, &frame, &bs);
 480     //encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
 481     subband_quantization_new (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
 482                           *subband, &frame);
 483     //subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
 484     //    *subband, &frame);
 485     write_samples_new(*subband, bit_alloc, &frame, &bs);
 486     //sample_encoding (*subband, bit_alloc, &frame, &bs);
 487 #else
 488     transmission_pattern (scalar, scfsi, &frame);
 489     main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
 490     if (error_protection)
 491       CRC_calc (&frame, bit_alloc, scfsi, &crc);
 492     encode_info (&frame, &bs);
 493     if (error_protection)
 494       encode_CRC (crc, &bs);
 495     encode_bit_alloc (bit_alloc, &frame, &bs);
 496     encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
 497     subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
 498                           *subband, &frame);
 499     sample_encoding (*subband, bit_alloc, &frame, &bs);
 500 #endif
 501
 502
 503     /* If not all the bits were used, write out a stack of zeros */
 504     for (i = 0; i < adb; i++)
 505       put1bit (&bs, 0);
 506     if (header.dab_extension) {
 507       /* Reserve some bytes for X-PAD in DAB mode */
 508       putbits (&bs, 0, header.dab_length * 8);
 509
 510       for (i = header.dab_extension - 1; i >= 0; i--) {
 511         CRC_calcDAB (&frame, bit_alloc, scfsi, scalar, &crc, i);
 512         /* this crc is for the previous frame in DAB mode  */
 513         if (bs.buf_byte_idx + lg_frame < bs.buf_size)
 514           bs.buf[bs.buf_byte_idx + lg_frame] = crc;
 515         /* reserved 2 bytes for F-PAD in DAB mode  */
 516         putbits (&bs, crc, 8);
 517       }
 518       putbits (&bs, 0, 16);
 519     }
 520
 521     frameBits = sstell (&bs) - sentBits;
 522
 523     if (frameBits % 8) {        /* a program failure */
 524       fprintf (stderr, "Sent %ld bits = %ld slots plus %ld\n", frameBits,
 525                frameBits / 8, frameBits % 8);
 526       fprintf (stderr, "If you are reading this, the program is broken\n");
 527       fprintf (stderr, "email [mfc at NOTplanckenerg.com] without the NOT\n");
 528       fprintf (stderr, "with the command line arguments and other info\n");
 529 toolame_error = 1;
 530 pthread_mutex_unlock(&toolame_output_lock);
 531 return 1;
 532       exit (0);
 533     }
 534
 535     sentBits += frameBits;
 536   }
 537
 538   close_bit_stream_w (&bs);
 539
 540   if ((glopts.verbosity > 1) && (glopts.vbr == TRUE)) {
 541     int i;
 542 #ifdef NEWENCODE
 543     extern int vbrstats_new[15];
 544 #else
 545     extern int vbrstats[15];
 546 #endif
 547     fprintf (stdout, "VBR stats:\n");
 548     for (i = 1; i < 15; i++)
 549       fprintf (stdout, "%4i ", bitrate[header.version][i]);
 550     fprintf (stdout, "\n");
 551     for (i = 1; i < 15; i++)
 552 #ifdef NEWENCODE
 553       fprintf (stdout,"%4i ",vbrstats_new[i]);
 554 #else
 555       fprintf (stdout, "%4i ", vbrstats[i]);
 556 #endif
 557     fprintf (stdout, "\n");
 558   }
 559
 560   fprintf (stderr,
 561            "Avg slots/frame = %.3f; b/smp = %.2f; bitrate = %.3f kbps\n",
 562            (FLOAT) sentBits / (frameNum * 8),
 563            (FLOAT) sentBits / (frameNum * 1152),
 564            (FLOAT) sentBits / (frameNum * 1152) *
 565            s_freq[header.version][header.sampling_frequency]);
 566
 567 pthread_mutex_unlock(&toolame_output_lock);
 568 return 0;
 569 //  if (fclose (musicin) != 0) {
 570 //    fprintf (stderr, "Could not close \"%s\".\n", original_file_name);
 571 //    exit (2);
 572 //  }
 573
 574   fprintf (stderr, "\nDone\n");
 575 return 0;
 576   exit (0);
 577 }
 578
 579 /************************************************************************
 580 *
 581 * print_config
 582 *
 583 * PURPOSE:  Prints the encoding parameters used
 584 *
 585 ************************************************************************/
 586
 587 void print_config (frame_info * frame, int *psy, char *inPath,
 588                    char *outPath)
 589 {
 590   frame_header *header = frame->header;
 591
 592   if (glopts.verbosity == 0)
 593     return;
 594
 595   fprintf (stderr, "--------------------------------------------\n");
 596   fprintf (stderr, "Input File : '%s'   %.1f kHz\n",
 597            (strcmp (inPath, "-") ? inPath : "stdin"),
 598            s_freq[header->version][header->sampling_frequency]);
 599   fprintf (stderr, "Output File: '%s'\n",
 600            (strcmp (outPath, "-") ? outPath : "stdout"));
 601   fprintf (stderr, "%d kbps ", bitrate[header->version][header->bitrate_index]);
 602   fprintf (stderr, "%s ", version_names[header->version]);
 603   if (header->mode != MPG_MD_JOINT_STEREO)
 604     fprintf (stderr, "Layer II %s Psycho model=%d  (Mode_Extension=%d)\n",
 605              mode_names[header->mode], *psy, header->mode_ext);
 606   else
 607     fprintf (stderr, "Layer II %s Psy model %d \n", mode_names[header->mode],
 608              *psy);
 609
 610   fprintf (stderr, "[De-emph:%s\tCopyright:%s\tOriginal:%s\tCRC:%s]\n",
 611            ((header->emphasis) ? "On" : "Off"),
 612            ((header->copyright) ? "Yes" : "No"),
 613            ((header->original) ? "Yes" : "No"),
 614            ((header->error_protection) ? "On" : "Off"));
 615
 616   fprintf (stderr, "[Padding:%s\tByte-swap:%s\tChanswap:%s\tDAB:%s]\n",
 617            ((glopts.usepadbit) ? "Normal" : "Off"),
 618            ((glopts.byteswap) ? "On" : "Off"),
 619            ((glopts.channelswap) ? "On" : "Off"),
 620            ((glopts.dab) ? "On" : "Off"));
 621
 622   if (glopts.vbr == TRUE)
 623     fprintf (stderr, "VBR Enabled. Using MNR boost of %f\n", glopts.vbrlevel);
 624   fprintf(stderr,"ATH adjustment %f\n",glopts.athlevel);
 625
 626   fprintf (stderr, "--------------------------------------------\n");
 627 }
 628
 629
 630 /************************************************************************
 631 *
 632 * usage
 633 *
 634 * PURPOSE:  Writes command line syntax to the file specified by #stderr#
 635 *
 636 ************************************************************************/
 637
 638 void usage (void)
 639 {                               /* print syntax & exit */
 640   /* FIXME: maybe have an option to display better definitions of help codes, and
 641      long equivalents of the flags */
 642   fprintf (stdout, "\ntooLAME version %s (http://toolame.sourceforge.net)\n",
 643            toolameversion);
 644   fprintf (stdout, "MPEG Audio Layer II encoder\n\n");
 645   fprintf (stdout, "usage: \n");
 646   fprintf (stdout, "\t%s [options] <input> <output>\n\n", programName);
 647
 648   fprintf (stdout, "Options:\n");
 649   fprintf (stdout, "Input\n");
 650   fprintf (stdout, "\t-s sfrq  input smpl rate in kHz   (dflt %4.1f)\n",
 651            DFLT_SFQ);
 652   fprintf (stdout, "\t-a       downmix from stereo to mono\n");
 653   fprintf (stdout, "\t-x       force byte-swapping of input\n");
 654   fprintf (stdout, "\t-g       swap channels of input file\n");
 655   fprintf (stdout, "Output\n");
 656   fprintf (stdout, "\t-m mode  channel mode : s/d/j/m   (dflt %4c)\n",
 657            DFLT_MOD);
 658   fprintf (stdout, "\t-p psy   psychoacoustic model 0/1/2/3 (dflt %4u)\n",
 659            DFLT_PSY);
 660   fprintf (stdout, "\t-b br    total bitrate in kbps    (dflt 192)\n");
 661   fprintf (stdout, "\t-v lev   vbr mode\n");
 662   fprintf (stdout, "\t-l lev   ATH level (dflt 0)\n");
 663   fprintf (stdout, "Operation\n");
 664   // fprintf (stdout, "\t-f       fast mode (turns off psy model)\n");
 665   // deprecate the -f switch. use "-p 0" instead.
 666   fprintf (stdout,
 667            "\t-q num   quick mode. only calculate psy model every num frames\n");
 668   fprintf (stdout, "Misc\n");
 669   fprintf (stdout, "\t-d emp   de-emphasis n/5/c        (dflt %4c)\n",
 670            DFLT_EMP);
 671   fprintf (stdout, "\t-c       mark as copyright\n");
 672   fprintf (stdout, "\t-o       mark as original\n");
 673   fprintf (stdout, "\t-e       add error protection\n");
 674   fprintf (stdout, "\t-r       force padding bit/frame off\n");
 675   fprintf (stdout, "\t-D len   add DAB extensions of length [len]\n");
 676   fprintf (stdout, "\t-t       talkativity 0=no messages (dflt 2)");
 677   fprintf (stdout, "Files\n");
 678   fprintf (stdout,
 679            "\tinput    input sound file. (WAV,AIFF,PCM or use '/dev/stdin')\n");
 680   fprintf (stdout, "\toutput   output bit stream of encoded audio\n");
 681   fprintf (stdout,
 682            "\n\tAllowable bitrates for 16, 22.05 and 24kHz sample input\n");
 683   fprintf (stdout,
 684            "\t8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160\n");
 685   fprintf (stdout,
 686            "\n\tAllowable bitrates for 32, 44.1 and 48kHz sample input\n");
 687   fprintf (stdout,
 688            "\t32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384\n");
 689   exit (1);
 690 }
 691
 692 /*********************************************
 693  * void short_usage(void)
 694  ********************************************/
 695 void short_usage (void)
 696 {
 697   /* print a bit of info about the program */
 698   fprintf (stderr, "tooLAME version %s\n (http://toolame.sourceforge.net)\n",
 699            toolameversion);
 700   fprintf (stderr, "MPEG Audio Layer II encoder\n\n");
 701   fprintf (stderr, "USAGE: %s [options] <infile> [outfile]\n\n", programName);
 702   fprintf (stderr, "Try \"%s -h\" for more information.\n", programName);
 703   exit (0);
 704 }
 705
 706 /*********************************************
 707  * void proginfo(void)
 708  ********************************************/
 709 void proginfo (void)
 710 {
 711   /* print a bit of info about the program */
 712   fprintf (stderr,
 713            "\ntooLAME version 0.2g (http://toolame.sourceforge.net)\n");
 714   fprintf (stderr, "MPEG Audio Layer II encoder\n\n");
 715 }
 716
 717 /************************************************************************
 718 *
 719 * parse_args
 720 *
 721 * PURPOSE:  Sets encoding parameters to the specifications of the
 722 * command line.  Default settings are used for parameters
 723 * not specified in the command line.
 724 *
 725 * SEMANTICS:  The command line is parsed according to the following
 726 * syntax:
 727 *
 728 * -m  is followed by the mode
 729 * -p  is followed by the psychoacoustic model number
 730 * -s  is followed by the sampling rate
 731 * -b  is followed by the total bitrate, irrespective of the mode
 732 * -d  is followed by the emphasis flag
 733 * -c  is followed by the copyright/no_copyright flag
 734 * -o  is followed by the original/not_original flag
 735 * -e  is followed by the error_protection on/off flag
 736 * -f  turns off psy model (fast mode)
 737 * -q <i>  only calculate psy model every ith frame
 738 * -a  downmix from stereo to mono
 739 * -r  turn off padding bits in frames.
 740 * -x  force byte swapping of input
 741 * -g  swap the channels on an input file
 742 * -t  talkativity. how verbose should the program be. 0 = no messages.
 743 *
 744 * If the input file is in AIFF format, the sampling frequency is read
 745 * from the AIFF header.
 746 *
 747 * The input and output filenames are read into #inpath# and #outpath#.
 748 *
 749 ************************************************************************/
 750
 751 void parse_args (int argc, char **argv, frame_info * frame, int *psy,
 752                  unsigned long *num_samples, char inPath[MAX_NAME_SIZE],
 753                  char outPath[MAX_NAME_SIZE])
 754 {
 755   FLOAT srate;
 756   int brate;
 757   frame_header *header = frame->header;
 758   int err = 0, i = 0;
 759   long samplerate;
 760
 761   /* preset defaults */
 762   inPath[0] = '\0';
 763   outPath[0] = '\0';
 764   header->lay = DFLT_LAY;
 765   switch (DFLT_MOD) {
 766   case 's':
 767     header->mode = MPG_MD_STEREO;
 768     header->mode_ext = 0;
 769     break;
 770   case 'd':
 771     header->mode = MPG_MD_DUAL_CHANNEL;
 772     header->mode_ext = 0;
 773     break;
 774     /* in j-stereo mode, no default header->mode_ext was defined, gave error..
 775        now  default = 2   added by MFC 14 Dec 1999.  */
 776   case 'j':
 777     header->mode = MPG_MD_JOINT_STEREO;
 778     header->mode_ext = 2;
 779     break;
 780   case 'm':
 781     header->mode = MPG_MD_MONO;
 782     header->mode_ext = 0;
 783     break;
 784   default:
 785     fprintf (stderr, "%s: Bad mode dflt %c\n", programName, DFLT_MOD);
 786     abort ();
 787   }
 788   *psy = DFLT_PSY;
 789   if ((header->sampling_frequency =
 790        toolame_SmpFrqIndex ((long) (1000 * DFLT_SFQ), &header->version)) < 0) {
 791     fprintf (stderr, "%s: bad sfrq default %.2f\n", programName, DFLT_SFQ);
 792     abort ();
 793   }
 794   header->bitrate_index = 14;
 795   brate = 0;
 796   switch (DFLT_EMP) {
 797   case 'n':
 798     header->emphasis = 0;
 799     break;
 800   case '5':
 801     header->emphasis = 1;
 802     break;
 803   case 'c':
 804     header->emphasis = 3;
 805     break;
 806   default:
 807     fprintf (stderr, "%s: Bad emph dflt %c\n", programName, DFLT_EMP);
 808     abort ();
 809   }
 810   header->copyright = 0;
 811   header->original = 0;
 812   header->error_protection = FALSE;
 813   header->dab_extension = 0;
 814
 815   /* process args */
 816   while (++i < argc && err == 0) {
 817     char c, *token, *arg, *nextArg;
 818     int argUsed;
 819
 820     token = argv[i];
 821     if (*token++ == '-') {
 822       if (i + 1 < argc)
 823         nextArg = argv[i + 1];
 824       else
 825         nextArg = "";
 826       argUsed = 0;
 827       if (!*token) {
 828         /* The user wants to use stdin and/or stdout. */
 829         if (inPath[0] == '\0')
 830           strncpy (inPath, argv[i], MAX_NAME_SIZE);
 831         else if (outPath[0] == '\0')
 832           strncpy (outPath, argv[i], MAX_NAME_SIZE);
 833       }
 834       while ((c = *token++)) {
 835         if (*token /* NumericQ(token) */ )
 836           arg = token;
 837         else
 838           arg = nextArg;
 839         switch (c) {
 840         case 'm':
 841           argUsed = 1;
 842           if (*arg == 's') {
 843             header->mode = MPG_MD_STEREO;
 844             header->mode_ext = 0;
 845           } else if (*arg == 'd') {
 846             header->mode = MPG_MD_DUAL_CHANNEL;
 847             header->mode_ext = 0;
 848           } else if (*arg == 'j') {
 849             header->mode = MPG_MD_JOINT_STEREO;
 850           } else if (*arg == 'm') {
 851             header->mode = MPG_MD_MONO;
 852             header->mode_ext = 0;
 853           } else {
 854             fprintf (stderr, "%s: -m mode must be s/d/j/m not %s\n",
 855                      programName, arg);
 856             err = 1;
 857           }
 858           break;
 859         case 'p':
 860           *psy = atoi (arg);
 861           argUsed = 1;
 862           break;
 863
 864         case 's':
 865           argUsed = 1;
 866           srate = atof (arg);
 867           /* samplerate = rint( 1000.0 * srate ); $A  */
 868           samplerate = (long) ((1000.0 * srate) + 0.5);
 869           if ((header->sampling_frequency =
 870                toolame_SmpFrqIndex ((long) samplerate, &header->version)) < 0)
 871             err = 1;
 872           break;
 873
 874         case 'b':
 875           argUsed = 1;
 876           brate = atoi (arg);
 877           break;
 878         case 'd':
 879           argUsed = 1;
 880           if (*arg == 'n')
 881             header->emphasis = 0;
 882           else if (*arg == '5')
 883             header->emphasis = 1;
 884           else if (*arg == 'c')
 885             header->emphasis = 3;
 886           else {
 887             fprintf (stderr, "%s: -d emp must be n/5/c not %s\n", programName,
 888                      arg);
 889             err = 1;
 890           }
 891           break;
 892         case 'D':
 893           argUsed = 1;
 894           header->dab_length = atoi (arg);
 895           header->error_protection = TRUE;
 896           header->dab_extension = 2;
 897           glopts.dab = TRUE;
 898           break;
 899         case 'c':
 900           header->copyright = 1;
 901           break;
 902         case 'o':
 903           header->original = 1;
 904           break;
 905         case 'e':
 906           header->error_protection = TRUE;
 907           break;
 908         case 'f':
 909           *psy = 0;
 910           /* this switch is deprecated? FIXME get rid of glopts.usepsy
 911              instead us psymodel 0, i.e. "-p 0" */
 912           glopts.usepsy = FALSE;
 913           break;
 914         case 'r':
 915           glopts.usepadbit = FALSE;
 916           header->padding = 0;
 917           break;
 918         case 'q':
 919           argUsed = 1;
 920           glopts.quickmode = TRUE;
 921           glopts.usepsy = TRUE;
 922           glopts.quickcount = atoi (arg);
 923           if (glopts.quickcount == 0) {
 924             /* just don't use psy model */
 925             glopts.usepsy = FALSE;
 926             glopts.quickcount = FALSE;
 927           }
 928           break;
 929         case 'a':
 930           glopts.downmix = TRUE;
 931           header->mode = MPG_MD_MONO;
 932           header->mode_ext = 0;
 933           break;
 934         case 'x':
 935           glopts.byteswap = TRUE;
 936           break;
 937         case 'v':
 938           argUsed = 1;
 939           glopts.vbr = TRUE;
 940           glopts.vbrlevel = atof (arg);
 941           glopts.usepadbit = FALSE;     /* don't use padding for VBR */
 942           header->padding = 0;
 943           /* MFC Feb 2003: in VBR mode, joint stereo doesn't make
 944              any sense at the moment, as there are no noisy subbands
 945              according to bits_for_nonoise in vbr mode */
 946           header->mode = MPG_MD_STEREO; /* force stereo mode */
 947           header->mode_ext = 0;
 948           break;
 949         case 'l':
 950           argUsed = 1;
 951           glopts.athlevel = atof(arg);
 952           break;
 953         case 'h':
 954           usage ();
 955           break;
 956         case 'g':
 957           glopts.channelswap = TRUE;
 958           break;
 959         case 't':
 960           argUsed = 1;
 961           glopts.verbosity = atoi (arg);
 962           break;
 963         default:
 964           fprintf (stderr, "%s: unrec option %c\n", programName, c);
 965           err = 1;
 966           break;
 967         }
 968         if (argUsed) {
 969           if (arg == token)
 970             token = "";         /* no more from token */
 971           else
 972             ++i;                /* skip arg we used */
 973           arg = "";
 974           argUsed = 0;
 975         }
 976       }
 977     } else {
 978       if (inPath[0] == '\0')
 979         strcpy (inPath, argv[i]);
 980       else if (outPath[0] == '\0')
 981         strcpy (outPath, argv[i]);
 982       else {
 983         fprintf (stderr, "%s: excess arg %s\n", programName, argv[i]);
 984         err = 1;
 985       }
 986     }
 987   }
 988
 989   if (header->dab_extension) {
 990     /* in 48 kHz */
 991     /* if the bit rate per channel is less then 56 kbit/s, we have 2 scf-crc */
 992     /* else we have 4 scf-crc */
 993     /* in 24 kHz, we have 4 scf-crc, see main loop */
 994     if (brate / (header->mode == MPG_MD_MONO ? 1 : 2) >= 56)
 995       header->dab_extension = 4;
 996   }
 997
 998
 999   if (err || inPath[0] == '\0')
1000     usage ();                   /* If no infile defined, or err has occured, then call usage() */
1001
1002   if (outPath[0] == '\0') {
1003     /* replace old extension with new one, 1992-08-19, 1995-06-12 shn */
1004     new_ext (inPath, DFLT_EXT, outPath);
1005   }
1006
1007   if (!strcmp (inPath, "-")) {
1008     musicin = stdin;            /* read from stdin */
1009     *num_samples = MAX_U_32_NUM;
1010   } else {
1011     if ((musicin = fopen (inPath, "rb")) == NULL) {
1012       fprintf (stderr, "Could not find \"%s\".\n", inPath);
1013       exit (1);
1014     }
1015     parse_input_file (musicin, inPath, header, num_samples);
1016   }
1017
1018   /* check for a valid bitrate */
1019   if (brate == 0)
1020     brate = bitrate[header->version][10];
1021
1022   /* Check to see we have a sane value for the bitrate for this version */
1023   if ((header->bitrate_index = toolame_BitrateIndex (brate, header->version)) < 0)
1024     err = 1;
1025
1026   /* All options are hunky dory, open the input audio file and
1027      return to the main drag */
1028   open_bit_stream_w (&bs, outPath, BUFFER_SIZE);
1029 }
1030
1031
1032 void smr_dump(double smr[2][SBLIMIT], int nch) {
1033   int ch, sb;
1034
1035   fprintf(stdout,"SMR:");
1036   for (ch = 0;ch<nch; ch++) {
1037     if (ch==1)
1038       fprintf(stdout,"    ");
1039     for (sb=0;sb<SBLIMIT;sb++)
1040       fprintf(stdout,"%3.0f ",smr[ch][sb]);
1041     fprintf(stdout,"\n");
1042   }
1043 }