开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
MUSICIN.C
资源名称：mpeg.zip　[点击查看]
上传用户：njqiyou
上传日期：2007-01-08
资源大小：574k
文件大小：42k
源码类别：

mpeg/mp3

开发平台：

C/C++

MUSICIN.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Encoder - Lower Sampling Frequency Extension
  4.  *
  5.  * $Id: musicin.c,v 1.2 1997/01/19 22:28:29 rowlands Exp $
  6.  *
  7.  * $Log: musicin.c,v $
  8.  * Revision 1.2  1997/01/19 22:28:29  rowlands
  9.  * Layer 3 bug fixes from Seymour Shlien
  10.  *
  11.  * Revision 1.1  1996/02/14 04:04:23  rowlands
  12.  * Initial revision
  13.  *
  14.  * Received from Mike Coleman
  15.  **********************************************************************/
  16. /**********************************************************************
  17.  *   date   programmers         comment                               *
  18.  * 3/01/91  Douglas Wong,       start of version 1.1 records          *
  19.  *          Davis Pan                                                 *
  20.  * 3/06/91  Douglas Wong,       rename: setup.h to endef.h            *
  21.  *                              removed extraneous variables          *
  22.  * 3/21/91  J.Georges Fritsch   introduction of the bit-stream        *
  23.  *                              package. This package allows you      *
  24.  *                              to generate the bit-stream in a       *
  25.  *                              binary or ascii format                *
  26.  * 3/31/91  Bill Aspromonte     replaced the read of the SB matrix    *
  27.  *                              by an "code generated" one            *
  28.  * 5/10/91  W. Joseph Carter    Ported to Macintosh and Unix.         *
  29.  *                              Incorporated Jean-Georges Fritsch's   *
  30.  *                              "bitstream.c" package.                *
  31.  *                              Modified to strictly adhere to        *
  32.  *                              encoded bitstream specs, including    *
  33.  *                              "Berlin changes".                     *
  34.  *                              Modified user interface dialog & code *
  35.  *                              to accept any input & output          *
  36.  *                              filenames desired.  Also added        *
  37.  *                              de-emphasis prompt and final bail-out *
  38.  *                              opportunity before encoding.          *
  39.  *                              Added AIFF PCM sound file reading     *
  40.  *                              capability.                           *
  41.  *                              Modified PCM sound file handling to   *
  42.  *                              process all incoming samples and fill *
  43.  *                              out last encoded frame with zeros     *
  44.  *                              (silence) if needed.                  *
  45.  *                              Located and fixed numerous software   *
  46.  *                              bugs and table data errors.           *
  47.  * 27jun91  dpwe (Aware Inc)    Used new frame_params struct.         *
  48.  *                              Clear all automatic arrays.           *
  49.  *                              Changed some variable names,          *
  50.  *                              simplified some code.                 *
  51.  *                              Track number of bits actually sent.   *
  52.  *                              Fixed padding slot, stereo bitrate    *
  53.  *                              Added joint-stereo : scales L+R.      *
  54.  * 6/12/91  Earle Jennings      added fix for MS_DOS in obtain_param  *
  55.  * 6/13/91  Earle Jennings      added stack length adjustment before  *
  56.  *                              main for MS_DOS                       *
  57.  * 7/10/91  Earle Jennings      conversion of all float to FLOAT      *
  58.  *                              port to MsDos from MacIntosh completed*
  59.  * 8/ 8/91  Jens Spille         Change for MS-C6.00                   *
  60.  * 8/22/91  Jens Spille         new obtain_parameters()               *
  61.  *10/ 1/91  S.I. Sudharsanan,   Ported to IBM AIX platform.           *
  62.  *          Don H. Lee,                                               *
  63.  *          Peter W. Farrett                                          *
  64.  *10/ 3/91  Don H. Lee          implemented CRC-16 error protection   *
  65.  *                              newly introduced functions are        *
  66.  *                              I_CRC_calc, II_CRC_calc and encode_CRC*
  67.  *                              Additions and revisions are marked    *
  68.  *                              with "dhl" for clarity                *
  69.  *11/11/91 Katherine Wang       Documentation of code.                *
  70.  *                                (variables in documentation are     *
  71.  *                                surround by the # symbol, and an '*'*
  72.  *                                denotes layer I or II versions)     *
  73.  * 2/11/92  W. Joseph Carter    Ported new code to Macintosh.  Most   *
  74.  *                              important fixes involved changing     *
  75.  *                              16-bit ints to long or unsigned in    *
  76.  *                              bit alloc routines for quant of 65535 *
  77.  *                              and passing proper function args.     *
  78.  *                              Removed "Other Joint Stereo" option   *
  79.  *                              and made bitrate be total channel     *
  80.  *                              bitrate, irrespective of the mode.    *
  81.  *                              Fixed many small bugs & reorganized.  *
  82.  * 2/25/92  Masahiro Iwadare    made code cleaner and more consistent *
  83.  * 8/07/92  Mike Coleman        make exit() codes return error status *
  84.  *                              made slight changes for portability   *
  85.  *19 aug 92 Soren H. Nielsen    Changed MS-DOS file name extensions.  *
  86.  * 8/25/92  Shaun Astarabadi    Replaced rint() function with explicit*
  87.  *                              rounding for portability with MSDOS.  *
  88.  * 9/22/92  jddevine@aware.com  Fixed _scale_factor_calc() calls.     *
  89.  *10/19/92  Masahiro Iwadare    added info->mode and info->mode_ext   *
  90.  *                              updates for AIFF format files         *
  91.  * 3/10/93  Kevin Peterson      In parse_args, only set non default   *
  92.  *                              bit rate if specified in arg list.    *
  93.  *                              Use return value from aiff_read_hdrs  *
  94.  *                              to fseek to start of sound data       *
  95.  * 7/26/93  Davis Pan           fixed bug in printing info->mode_ext  *
  96.  *                              value for joint stereo condition      *
  97.  * 8/27/93 Seymour Shlien,      Fixes in Unix and MSDOS ports,        *
  98.  *         Daniel Lauzon, and                                         *
  99.  *         Bill Truerniet                                             *
  100.  * 11/7/95 Soeren H. Nielsen    LSF added. Bug fix in MSDOS ext.      *
  101.  * 8/02/95 mc@fivebats.com      Changed default bitrate selection so  *
  102.  *                              it works with the new LSF stuff       *
  103.  *10/01/95 mc@fivebats.com      Added layer3                          *
  104.  **********************************************************************/
  106. #ifdef MS_DOS
  107. #include <dos.h>
  108. #endif
  109. #include <stdlib.h>
  110. #include "common.h"
  111. #include "encoder.h"
  112. #include "l3psy.h"
  113. #include "mdct.h"
  114. #include "loop.h"
  115. #include "l3bitstream.h"
  116. #include <assert.h>
  118. /* Global variable definitions for "musicin.c" */
  120. FILE               *musicin;
  121. Bit_stream_struc   bs;
  122. char               *programName;
  124. /* Implementations */
  126. /************************************************************************
  127. *
  128. * obtain_parameters
  129. *
  130. * PURPOSE:  Prompts for and reads user input for encoding parameters
  131. *
  132. * SEMANTICS:  The parameters read are:
  133. * - input and output filenames
  134. * - sampling frequency (if AIFF file, will read from the AIFF file header)
  135. * - layer number
  136. * - mode (stereo, joint stereo, dual channel or mono)
  137. * - psychoacoustic model (I or II)
  138. * - total bitrate, irrespective of the mode
  139. * - de-emphasis, error protection, copyright and original or copy flags
  140. *
  141. ************************************************************************/
  143. void
  144. obtain_parameters(fr_ps,psy,num_samples,original_file_name,encoded_file_name)
  145. frame_params    *fr_ps;
  146. int             *psy;
  147. unsigned long   *num_samples;
  148. char            original_file_name[MAX_NAME_SIZE];
  149. char            encoded_file_name[MAX_NAME_SIZE];
  150. {
  151.     int j;
  152.     long int freq;
  153.     int model, brt;
  154.     char t[50];
  155.     IFF_AIFF pcm_aiff_data;
  156.     layer *info = fr_ps->header;
  157.     long soundPosition;
  158. #ifdef  MS_DOS
  159.     char temp_str[MAX_NAME_SIZE];
  160. #endif 
  162.     do  {
  163.        printf("Enter PCM input file name <required>: ");
  164.        gets(original_file_name);
  165.        if (original_file_name[0] == NULL_CHAR)
  166.        printf("PCM input file name is required.n");
  167.     } while (original_file_name[0] == NULL_CHAR);
  168.     printf(">>> PCM input file name is: %sn", original_file_name);
  169.  
  170.     if ((musicin = fopen(original_file_name, "rb")) == NULL) {
  171.        printf("Could not find "%s".n", original_file_name);
  172.        exit(1);
  173.     }
  175. #ifdef  MS_DOS
  176.     /* replace old extension with new one, 1992-08-19, 1995-06-12 shn */
  177.     new_ext(original_file_name, DFLT_EXT, temp_str);
  178.     printf("Enter MPEG encoded output file name <%s>: ",
  179.            temp_str);
  180. #else
  181.     printf("Enter MPEG encoded output file name <%s%s>: ",
  182.            original_file_name, DFLT_EXT);
  183. #endif
  184.  
  185.     gets(encoded_file_name);
  186.     
  187.     if (encoded_file_name[0] == NULL_CHAR) {
  188. #ifdef  MS_DOS
  189.   strcpy(encoded_file_name, temp_str);
  190. #else
  191.         strcat(strcpy(encoded_file_name, original_file_name), DFLT_EXT);
  192. #endif
  193.     }
  194.         
  196.     printf(">>> MPEG encoded output file name is: %sn", encoded_file_name);
  197.  
  198.     open_bit_stream_w(&bs, encoded_file_name, BUFFER_SIZE);
  199.  
  200.     if ((soundPosition = aiff_read_headers(musicin, &pcm_aiff_data)) != -1) {
  202.        printf(">>> Using Audio IFF sound file headersn");
  204.        aiff_check(original_file_name, &pcm_aiff_data, &info->version);
  206.        if (fseek(musicin, soundPosition, SEEK_SET) != 0) {
  207.           printf("Could not seek to PCM sound data in "%s".n",
  208.                  original_file_name);
  209.           exit(1);
  210.        }
  212.        info->sampling_frequency =
  213.       SmpFrqIndex((long)pcm_aiff_data.sampleRate, &info->version);
  214.        printf(">>> %f Hz sampling frequency selectedn",
  215.               pcm_aiff_data.sampleRate);
  217.        /* Determine number of samples in sound file */
  218. #ifndef MS_DOS
  219.        *num_samples = pcm_aiff_data.numChannels *
  220.                       pcm_aiff_data.numSampleFrames;
  221. #else
  222.        *num_samples = (long)(pcm_aiff_data.numChannels) *
  223.                       (long)(pcm_aiff_data.numSampleFrames);
  224. #endif
  226.     }
  227.     else {    /* Not using Audio IFF sound file headers. */
  229.        printf("What is the sampling frequency? <44100>[Hz]: ");
  230.        gets(t);
  231.        freq = atol(t);
  232.        switch (freq) {
  233.           case 48000 : info->sampling_frequency = 1;
  234.               printf(">>> %ld Hz sampling freq selectedn", freq);
  235.               break;
  236.           case 44100 : info->sampling_frequency = 0;
  237.               printf(">>> %ld Hz sampling freq selectedn", freq);
  238.               break;
  239.           case 32000 : info->sampling_frequency = 2;
  240.               printf(">>> %ld Hz sampling freq selectedn", freq);
  241.               break;
  242.           case 24000 : info->sampling_frequency = 1;
  243.         info->version = MPEG_PHASE2_LSF;
  244.               printf(">>> %ld Hz sampling freq selectedn", freq);
  245.               break;
  246.           case 22050 : info->sampling_frequency = 0;
  247.         info->version = MPEG_PHASE2_LSF;
  248.               printf(">>> %ld Hz sampling freq selectedn", freq);
  249.               break;
  250.           case 16000 : info->sampling_frequency = 2;
  251.         info->version = MPEG_PHASE2_LSF;
  252.               printf(">>> %ld Hz sampling freq selectedn", freq);
  253.               break;
  254.           default:    info->sampling_frequency = 0;
  255.               printf(">>> Default 44.1 kHz samp freq selectedn");
  256.        }
  257.        printf(">>> Encoding algorithm is %sn", version_names[info->version]);
  258.        if (fseek(musicin, 0, SEEK_SET) != 0) {
  259.           printf("Could not seek to PCM sound data in "%s".n",
  260.                   original_file_name);
  261.           exit(1);
  262.        }
  263.  
  264.        /* Declare sound file to have "infinite" number of samples. */
  265.        *num_samples = MAX_U_32_NUM;
  267.     }
  269.     printf("Which layer do you want to use?n");
  270.     printf("Available: Layer (1), Layer (<2>), Layer (3): ");
  271.     gets(t);
  272.     switch(*t){
  273.        case '1': info->lay = 1; printf(">>> Using Layer %sn",t); break;
  274.        case '2': info->lay = 2; printf(">>> Using Layer %sn",t); break;
  275.      case '3': info->lay = 3; printf(">>> Using Layer %sn",t); break;
  276.        default:  info->lay = 2; printf(">>> Using default Layer 2n"); break;
  277.     }
  279.     printf("Which mode do you want?n");
  280.     printf("Available: (<s>)tereo, (j)oint stereo, ");
  281.     printf("(d)ual channel, s(i)ngle Channel: ");
  282.     gets(t);
  283.     switch(*t){
  284.        case 's':
  285.        case 'S':
  286.           info->mode = MPG_MD_STEREO; info->mode_ext = 0;
  287.           printf(">>> Using mode %sn",t);
  288.           break;
  289.        case 'j':
  290.        case 'J':
  291.           info->mode = MPG_MD_JOINT_STEREO;
  292.           printf(">>> Using mode %sn",t);
  293.           break;
  294.        case 'd':
  295.        case 'D':
  296.           info->mode = MPG_MD_DUAL_CHANNEL; info->mode_ext = 0;
  297.           printf(">>> Using mode %sn",t);
  298.           break;
  299.        case 'i':
  300.        case 'I':
  301.           info->mode = MPG_MD_MONO; info->mode_ext = 0;
  302.           printf(">>> Using mode %sn",t);
  303.           break;
  304.        default:
  305.           info->mode = MPG_MD_STEREO; info->mode_ext = 0;
  306.           printf(">>> Using default stereo moden");
  307.           break;
  308.     }
  310.     printf("Which psychoacoustic model do you want to use? <1>: ");
  311.     gets(t);
  312.     model = atoi(t);
  313.     if (model > 2 || model < 1) {
  314.        printf(">>> Default model 1 selectedn");
  315.        *psy = 1;
  316.     }
  317.     else {
  318.        *psy = model;
  319.        printf(">>> Using psychoacoustic model %dn", model);
  320.     }
  321.     
  322.     /* set default bitrate to highest allowed, which is index 14 */
  323.   brt = bitrate[info->version][info->lay-1][14];
  324.     printf( "What is the total bitrate? <%u>[kbps]: ", brt );
  325.     gets( t );
  326.     brt = atoi( t );
  327.     if ( brt == 0 )
  328.       j = 15;
  329.     else
  330.       j = 0;
  331.     while ( j < 15 )
  332.     {
  333.     if ( bitrate[info->version][info->lay-1][j] == brt )
  334.           break;
  335.     j++;
  336.     }
  337.     if ( j == 15 )
  338.     {
  339.     brt = bitrate[info->version][info->lay-1][14];
  340.         printf( ">>> Using default %u kbpsn", brt );
  341.         info->bitrate_index = 14;
  342.     }
  343.     else
  344.     {
  345.        info->bitrate_index = j;
  346.        printf( ">>> Bitrate = %d kbpsn", bitrate[info->version][info->lay-1][j] );
  347.     }
  348.  
  349.     printf("What type of de-emphasis should the decoder use?n");
  350.     printf("Available: (<n>)one, (5)0/15 microseconds, (c)citt j.17: ");
  351.     gets(t);
  352.     if (*t != 'n' && *t != '5' && *t != 'c') {
  353.        printf(">>> Using default no de-emphasisn");
  354.        info->emphasis = 0;
  355.     }
  356.     else {
  357.        if (*t == 'n')      info->emphasis = 0;
  358.        else if (*t == '5') info->emphasis = 1;
  359.        else if (*t == 'c') info->emphasis = 3;
  360.        printf(">>> Using de-emphasis %sn",t);
  361.     }
  362.  
  363. /*  Start 2. Part changes for CD Ver 3.2; jsp; 22-Aug-1991 */
  364.  
  365.     printf("Do you want to set the private bit? (y/<n>): ");
  366.     gets(t);
  367.     if (*t == 'y' || *t == 'Y') info->extension = 1;
  368.     else                        info->extension = 0;
  369.     if(info->extension) printf(">>> Private bit setn");
  370.     else                printf(">>> Private bit not setn");
  371.  
  372. /*  End changes for CD Ver 3.2; jsp; 22-Aug-1991 */
  373.  
  374.     printf("Do you want error protection? (y/<n>): ");
  375.     gets(t);
  376.     if (*t == 'y' || *t == 'Y') info->error_protection = TRUE;
  377.     else                        info->error_protection = FALSE;
  378.     if(info->error_protection) printf(">>> Error protection usedn");
  379.     else printf(">>> Error protection not usedn");
  380.  
  381.     printf("Is the material copyrighted? (y/<n>): ");
  382.     gets(t);
  383.     if (*t == 'y' || *t == 'Y') info->copyright = 1;
  384.     else                        info->copyright = 0;
  385.     if(info->copyright) printf(">>> Copyrighted materialn");
  386.     else                printf(">>> Material not copyrightedn");
  387.  
  388.     printf("Is this the original? (y/<n>): ");
  389.     gets(t);
  390.     if (*t == 'y' || *t == 'Y') info->original = 1;
  391.     else                        info->original = 0;
  392.     if(info->original) printf(">>> Original materialn");
  393.     else               printf(">>> Material not originaln");
  394.  
  395.     printf("Do you wish to exit (last chance before encoding)? (y/<n>): ");
  396.     gets(t);
  397.     if (*t == 'y' || *t == 'Y') exit(0);
  398. }
  400. /************************************************************************
  401. *
  402. * parse_args
  403. *
  404. * PURPOSE:  Sets encoding parameters to the specifications of the
  405. * command line.  Default settings are used for parameters
  406. * not specified in the command line.
  407. *
  408. * SEMANTICS:  The command line is parsed according to the following
  409. * syntax:
  410. *
  411. * -l  is followed by the layer number
  412. * -m  is followed by the mode
  413. * -p  is followed by the psychoacoustic model number
  414. * -s  is followed by the sampling rate
  415. * -b  is followed by the total bitrate, irrespective of the mode
  416. * -d  is followed by the emphasis flag
  417. * -c  is followed by the copyright/no_copyright flag
  418. * -o  is followed by the original/not_original flag
  419. * -e  is followed by the error_protection on/off flag
  420. *
  421. * If the input file is in AIFF format, the sampling frequency is read
  422. * from the AIFF header.
  423. *
  424. * The input and output filenames are read into #inpath# and #outpath#.
  425. *
  426. ************************************************************************/
  427.  
  428. void
  429. parse_args(argc, argv, fr_ps, psy, num_samples, inPath, outPath)
  430. int     argc;
  431. char    **argv;
  432. frame_params  *fr_ps;
  433. int     *psy;
  434. unsigned long *num_samples;
  435. char    inPath[MAX_NAME_SIZE];
  436. char    outPath[MAX_NAME_SIZE];
  437. {
  438.    FLOAT srate;
  439.    int   brate;
  440.    layer *info = fr_ps->header;
  441.    int   err = 0, i = 0;
  442.    IFF_AIFF pcm_aiff_data;
  443.    long samplerate;
  444.    long soundPosition;
  445.  
  446.    /* preset defaults */
  447.    inPath[0] = '';   outPath[0] = '';
  448.    info->lay = DFLT_LAY;
  449.    switch(DFLT_MOD) {
  450.       case 's': info->mode = MPG_MD_STEREO; info->mode_ext = 0; break;
  451.       case 'd': info->mode = MPG_MD_DUAL_CHANNEL; info->mode_ext=0; break;
  452.       case 'j': info->mode = MPG_MD_JOINT_STEREO; break;
  453.       case 'm': info->mode = MPG_MD_MONO; info->mode_ext = 0; break;
  454.       default:
  455.          fprintf(stderr, "%s: Bad mode dflt %cn", programName, DFLT_MOD);
  456.          abort();
  457.    }
  458.    *psy = DFLT_PSY;
  459.    if((info->sampling_frequency = SmpFrqIndex((long)(1000*DFLT_SFQ), &info->version)) < 0) {
  460.       fprintf(stderr, "%s: bad sfrq default %.2fn", programName, DFLT_SFQ);
  461.       abort();
  462.    }
  463.   info->bitrate_index = 14;
  464.   brate = 0;
  465.    switch(DFLT_EMP) {
  466.       case 'n': info->emphasis = 0; break;
  467.       case '5': info->emphasis = 1; break;
  468.       case 'c': info->emphasis = 3; break;
  469.       default: 
  470.          fprintf(stderr, "%s: Bad emph dflt %cn", programName, DFLT_EMP);
  471.          abort();
  472.    }
  473.    info->copyright = 0; info->original = 0; info->error_protection = FALSE;
  474.  
  475.    /* process args */
  476.    while(++i<argc && err == 0) {
  477.       char c, *token, *arg, *nextArg;
  478.       int  argUsed;
  479.  
  480.       token = argv[i];
  481.       if(*token++ == '-') {
  482.          if(i+1 < argc) nextArg = argv[i+1];
  483.          else           nextArg = "";
  484.          argUsed = 0;
  485.          while( (c = *token++) ) {
  486.             if(*token /* NumericQ(token) */) arg = token;
  487.             else                             arg = nextArg;
  488.             switch(c) {
  489.                case 'l':        info->lay = atoi(arg); argUsed = 1;
  490.                   if(info->lay<1 || info->lay>3) {
  491.                      fprintf(stderr,"%s: -l layer must be 1, 2, or 3, not %sn",
  492.                           programName, arg);
  493.                      err = 1;
  494.                   }
  495.                   break;
  496.                case 'm':        argUsed = 1;
  497.                   if (*arg == 's')
  498.                     { info->mode = MPG_MD_STEREO; info->mode_ext = 0; }
  499.                   else if (*arg == 'd')
  500.                     { info->mode = MPG_MD_DUAL_CHANNEL; info->mode_ext=0; }
  501.                   else if (*arg == 'j')
  502.                     { info->mode = MPG_MD_JOINT_STEREO; }
  503.                   else if (*arg == 'm')
  504.                     { info->mode = MPG_MD_MONO; info->mode_ext = 0; }
  505.                   else {
  506.                     fprintf(stderr,"%s: -m mode must be s/d/j/m not %sn",
  507.                             programName, arg);
  508.                     err = 1;
  509.                   }
  510.                   break;
  511.                case 'p':        *psy = atoi(arg); argUsed = 1;
  512.                   if(*psy<1 || *psy>2) {
  513.                      fprintf(stderr,"%s: -p model must be 1 or 2, not %sn",
  514.                              programName, arg);
  515.                      err = 1;
  516.                   }
  517.                   break;
  519.                case 's':
  520.                   argUsed = 1;
  521.                   srate = atof( arg );
  522.                   /* samplerate = rint( 1000.0 * srate ); $A  */
  523.                   samplerate = (long) (( 1000.0 * srate ) + 0.5);
  524.                   if( (info->sampling_frequency =
  525.           SmpFrqIndex((long) samplerate, &info->version)) < 0 )
  526.                       err = 1;
  527.                   break;
  528.                   
  529.                case 'b':        
  530.         argUsed = 1;
  531.       brate = atoi(arg); 
  532.       break;
  533.                case 'd':        argUsed = 1;
  534.                   if (*arg == 'n')                    info->emphasis = 0;
  535.                   else if (*arg == '5')               info->emphasis = 1;
  536.                   else if (*arg == 'c')               info->emphasis = 3;
  537.                   else {
  538.                      fprintf(stderr,"%s: -d emp must be n/5/c not %sn",
  539.                              programName, arg);
  540.                      err = 1;
  541.                   }
  542.                   break;
  543.                 case 'c':       info->copyright = 1; break;
  544.                 case 'o':       info->original  = 1; break;
  545.                 case 'e':       info->error_protection = TRUE; break;
  546.                 default:        fprintf(stderr,"%s: unrec option %cn",
  547.                                         programName, c);
  548.                                 err = 1; break;
  549.             }
  550.             if(argUsed) {
  551.                if(arg == token)    token = "";   /* no more from token */
  552.                else                ++i;          /* skip arg we used */
  553.                arg = ""; argUsed = 0;
  554.             }
  555.          }
  556.       }
  557.       else {
  558.          if(inPath[0] == '')       strcpy(inPath, argv[i]);
  559.          else if(outPath[0] == '') strcpy(outPath, argv[i]);
  560.          else {
  561.             fprintf(stderr,"%s: excess arg %sn", programName, argv[i]);
  562.             err = 1;
  563.          }
  564.       }
  565.    }
  567.    if(err || inPath[0] == '') usage();  /* never returns */
  568.  
  569.    if(outPath[0] == '') {
  570. #ifdef MS_DOS
  571.       /* replace old extension with new one, 1992-08-19, 1995-06-12 shn */
  572.       new_ext(inPath, DFLT_EXT, outPath);
  573. #else
  574.       strcpy(outPath, inPath);
  575.       strcat(outPath, DFLT_EXT);
  576. #endif
  577.    }
  579.    if ((musicin = fopen(inPath, "rb")) == NULL) {
  580.       printf("Could not find "%s".n", inPath);
  581.       exit(1);
  582.    }
  583.  
  584.    open_bit_stream_w(&bs, outPath, BUFFER_SIZE);
  586.    if ((soundPosition = aiff_read_headers(musicin, &pcm_aiff_data)) != -1) {
  588.       printf(">>> Using Audio IFF sound file headersn");
  590.       aiff_check(inPath, &pcm_aiff_data, &info->version);
  592.       if (fseek(musicin, soundPosition, SEEK_SET) != 0) {
  593.          printf("Could not seek to PCM sound data in "%s".n", inPath);
  594.          exit(1);
  595.       }
  597.       info->sampling_frequency = SmpFrqIndex((long)pcm_aiff_data.sampleRate, &info->version);
  598.       printf(">>> %f Hz sampling frequency selectedn",
  599.              pcm_aiff_data.sampleRate);
  601.       /* Determine number of samples in sound file */
  602. #ifndef MS_DOS
  603.       *num_samples = pcm_aiff_data.numChannels *
  604.                      pcm_aiff_data.numSampleFrames;
  605. #else
  606.       *num_samples = (long)(pcm_aiff_data.numChannels) *
  607.                      (long)(pcm_aiff_data.numSampleFrames);
  608. #endif
  609.       if ( pcm_aiff_data.numChannels == 1 ) {
  610.         info->mode = MPG_MD_MONO;
  611.         info->mode_ext = 0;
  612.       }
  613.    }
  614.    else {    /* Not using Audio IFF sound file headers. */
  616.       if (fseek(musicin, 0, SEEK_SET) != 0) {
  617.          printf("Could not seek to PCM sound data in "%s".n", inPath);
  618.          exit(1);
  619.       }
  620.  
  621.       /* Declare sound file to have "infinite" number of samples. */
  622.       *num_samples = MAX_U_32_NUM;
  624.    }
  625.    if ( brate == 0 )
  626.     brate = bitrate[info->version][info->lay-1][14];
  627.    if( (info->bitrate_index = BitrateIndex(info->lay, brate, info->version)) < 0) err=1;
  628.    if(err || inPath[0] == '') usage();  /* never returns */
  630. }
  632. /************************************************************************
  633. *
  634. * print_config
  635. *
  636. * PURPOSE:  Prints the encoding parameters used
  637. *
  638. ************************************************************************/
  639.  
  640. void print_config( frame_params *fr_ps, int *psy, char *inPath, char *outPath)
  641. {
  642.  layer *info = fr_ps->header;
  643.  
  644.    printf("Encoding configuration:n");
  645.    printf("Algorithm=%sn", version_names[info->version]);
  646.    if(info->mode != MPG_MD_JOINT_STEREO)
  647.       printf("Layer=%s   mode=%s   extn=%d   psy model=%dn",
  648.              layer_names[info->lay-1], mode_names[info->mode],
  649.              info->mode_ext, *psy);
  650.    else printf("Layer=%s   mode=%s   extn=data dependant   psy model=%dn",
  651.                layer_names[info->lay-1], mode_names[info->mode], *psy);
  652.    printf("samp frq=%.1f kHz   total bitrate=%d kbpsn",
  653.           s_freq[info->version][info->sampling_frequency],
  654.           bitrate[info->version][info->lay-1][info->bitrate_index]);
  655.    printf("de-emph=%d   c/right=%d   orig=%d   errprot=%sn",
  656.           info->emphasis, info->copyright, info->original,
  657.           ((info->error_protection) ? "on" : "off"));
  658.    printf("input file: '%s'   output file: '%s'n", inPath, outPath);
  659. }
  664.  
  665. /************************************************************************
  666. *
  667. * main
  668. *
  669. * PURPOSE:  MPEG I Encoder supporting layers 1 and 2, and 3, with
  670. * psychoacoustic models 1 (MUSICAM) and 2 (AT&T)
  671. *
  672. * SEMANTICS:  One overlapping frame of audio of up to 2 channels are
  673. * processed at a time in the following order:
  674. * (associated routines are in parentheses)
  675. *
  676. * 1.  Filter sliding window of data to get 32 subband
  677. * samples per channel.
  678. * (window_subband,filter_subband)
  679. *
  680. * 2.  If joint stereo mode, combine left and right channels
  681. * for subbands above #jsbound#.
  682. * (*_combine_LR)
  683. *
  684. * 3.  Calculate scalefactors for the frame, and if layer 2,
  685. * also calculate scalefactor select information.
  686. * (*_scale_factor_calc)
  687. *
  688. * 4.  Calculate psychoacoustic masking levels using selected
  689. * psychoacoustic model.
  690. * (*_Psycho_One, psycho_anal)
  691. *
  692. * 5.  Perform iterative bit allocation for subbands with low
  693. * mask_to_noise ratios using masking levels from step 4.
  694. * (*_main_bit_allocation)
  695. *
  696. * 6.  If error protection flag is active, add redundancy for
  697. * error protection.
  698. * (*_CRC_calc)
  699. *
  700. * 7.  Pack bit allocation, scalefactors, and scalefactor select
  701. * information (layer 2) onto bitstream.
  702. * (*_encode_bit_alloc,*_encode_scale,II_transmission_pattern)
  703. *
  704. * 8.  Quantize subbands and pack them into bitstream
  705. * (*_subband_quantization, *_sample_encoding)
  706. *
  707. ************************************************************************/
  709. int frameNum=0;
  711. void main(argc, argv)
  712. int     argc;
  713. char    **argv;
  714. {
  715.     typedef double SBS[2][3][SCALE_BLOCK][SBLIMIT];
  716.     SBS  FAR        *sb_sample;
  717.     L3SBS  FAR        *l3_sb_sample;
  718.     typedef double JSBS[3][SCALE_BLOCK][SBLIMIT];
  719.     JSBS FAR        *j_sample;
  720.     typedef double IN[2][HAN_SIZE];
  721.     IN   FAR        *win_que;
  722.     typedef unsigned int SUB[2][3][SCALE_BLOCK][SBLIMIT];
  723.     SUB  FAR        *subband;
  724.     
  725.     frame_params fr_ps;
  726.     layer info;
  727.     char original_file_name[MAX_NAME_SIZE];
  728.     char encoded_file_name[MAX_NAME_SIZE];
  729.     short FAR **win_buf;
  730.     static short FAR buffer[2][1152];
  731.     static unsigned int bit_alloc[2][SBLIMIT], scfsi[2][SBLIMIT];
  732.     static unsigned int scalar[2][3][SBLIMIT], j_scale[3][SBLIMIT];
  733.     static double FAR ltmin[2][SBLIMIT], lgmin[2][SBLIMIT], max_sc[2][SBLIMIT];
  734.     FLOAT snr32[32];
  735.     short sam[2][1344]; /* was [1056]; */
  736.     int whole_SpF, extra_slot = 0;
  737.     double avg_slots_per_frame, frac_SpF, slot_lag;
  738.     int model, stereo, error_protection;
  739.     static unsigned int crc;
  740.     int i, j, k, adb;
  741.     unsigned long bitsPerSlot, samplesPerFrame;
  742.     unsigned long frameBits, sentBits = 0;
  743.     unsigned long num_samples;
  744.     
  745. #ifdef  MACINTOSH
  746.     argc = ccommand( &argv );
  747. #endif
  748.     
  750.     /* Most large variables are declared dynamically to ensure
  751.        compatibility with smaller machines */
  752.     
  753.     sb_sample = (SBS FAR *) mem_alloc(sizeof(SBS), "sb_sample");
  754.     l3_sb_sample = (L3SBS FAR *) mem_alloc(sizeof(SBS), "l3_sb_sample");
  755.     j_sample = (JSBS FAR *) mem_alloc(sizeof(JSBS), "j_sample");
  756.     win_que = (IN FAR *) mem_alloc(sizeof(IN), "Win_que");
  757.     subband = (SUB FAR *) mem_alloc(sizeof(SUB),"subband");
  758.     win_buf = (short FAR **) mem_alloc(sizeof(short *)*2, "win_buf");
  759.  
  760.     /* clear buffers */
  761.     memset((char *) buffer, 0, sizeof(buffer));
  762.     memset((char *) bit_alloc, 0, sizeof(bit_alloc));
  763.     memset((char *) scalar, 0, sizeof(scalar));
  764.     memset((char *) j_scale, 0, sizeof(j_scale));
  765.     memset((char *) scfsi, 0, sizeof(scfsi));
  766.     memset((char *) ltmin, 0, sizeof(ltmin));
  767.     memset((char *) lgmin, 0, sizeof(lgmin));
  768.     memset((char *) max_sc, 0, sizeof(max_sc));
  769.     memset((char *) snr32, 0, sizeof(snr32));
  770.     memset((char *) sam, 0, sizeof(sam));
  771.  
  772.     fr_ps.header = &info;
  773.     fr_ps.tab_num = -1;             /* no table loaded */
  774.     fr_ps.alloc = NULL;
  775.     info.version = MPEG_AUDIO_ID;   /* Default: MPEG-1 */
  777.     programName = argv[0];
  778.     if(argc==1)     /* no command-line args */
  779.        obtain_parameters(&fr_ps, &model, &num_samples,
  780.                          original_file_name, encoded_file_name);
  781.     else
  782. parse_args(argc, argv, &fr_ps, &model, &num_samples,
  783.    original_file_name, encoded_file_name);
  784.     print_config(&fr_ps, &model,
  785.                  original_file_name, encoded_file_name);
  786.     
  787.     hdr_to_frps(&fr_ps);
  788.     stereo = fr_ps.stereo;
  789.     error_protection = info.error_protection;
  790.     
  791.     if (info.lay == 1)
  792.     { bitsPerSlot = 32; samplesPerFrame = 384;  }
  793.     else 
  794. if ( info.lay == 2 )
  795. { bitsPerSlot = 8;  samplesPerFrame = 1152; }
  796. else
  797. {  /* layer 3 */
  798.     bitsPerSlot = 8;
  799.     samplesPerFrame = info.version == 1 ? 1152 : 576;
  800.     
  801.     /* Apologize for missing features */
  802.     if ( info.mode == MPG_MD_JOINT_STEREO )
  803.     {
  804. fprintf( stderr, "Sorry, joint stereo not yet available for layer3n" );
  805. exit( 1 );
  806.     }
  807. #if 0
  808.     if ( info.version != MPEG_AUDIO_ID )
  809.     {
  810. fprintf( stderr, "Sorry, MPEG2-LSF not yet available for layer3n" );
  811. exit( 1 );
  812.     }
  813. #endif
  814.     if ( model != 2 )
  815.     {
  816. fprintf( stderr, "Sorry, psycho model 1 not available for layer3n" );
  817. exit( 1 );
  818.     }
  819. }
  820.     /* Figure average number of 'slots' per frame. */
  821.     /* Bitrate means TOTAL for both channels, not per side. */
  822.     avg_slots_per_frame = ((double)samplesPerFrame /
  823.                            s_freq[info.version][info.sampling_frequency]) *
  824.    ((double)bitrate[info.version][info.lay-1][info.bitrate_index] /
  825.     (double)bitsPerSlot);
  826.     whole_SpF = (int) avg_slots_per_frame;
  827.     printf("slots/frame = %dn",whole_SpF);
  828.     frac_SpF  = avg_slots_per_frame - (double)whole_SpF;
  829.     slot_lag  = -frac_SpF;
  830.     printf("frac SpF=%.3f, tot bitrate=%d kbps, s freq=%.1f kHzn",
  831.            frac_SpF, bitrate[info.version][info.lay-1][info.bitrate_index],
  832.            s_freq[info.version][info.sampling_frequency]);
  833.     
  834.     if (frac_SpF != 0)
  835. printf("Fractional number of slots, padding requiredn");
  836.     else info.padding = 0;
  837.     
  838.     while ( get_audio(musicin, buffer, num_samples, stereo, &info) > 0 )
  839.     {
  840. fprintf(stderr, "{%4lu}", frameNum++); fflush(stderr);
  841. win_buf[0] = &buffer[0][0];
  842. win_buf[1] = &buffer[1][0];
  843. if (frac_SpF != 0) {
  844.     if (slot_lag > (frac_SpF-1.0) ) {
  845. slot_lag -= frac_SpF;
  846. extra_slot = 0;
  847. info.padding = 0;
  848. /*  printf("No padding for this framen"); */
  849.     }
  850.     else {
  851. extra_slot = 1;
  852. info.padding = 1;
  853. slot_lag += (1-frac_SpF);
  854. /*  printf("Padding for this framen");    */
  855.     }
  856. }
  857. adb = (whole_SpF+extra_slot) * bitsPerSlot;
  859. switch (info.lay)
  860. {
  861.     
  862. /***************************** Layer I **********************************/
  863.     
  864.           case 1 :
  865.     for (j=0;j<SCALE_BLOCK;j++)
  866. for (k=0;k<stereo;k++) {
  867.     window_subband(&win_buf[k], &(*win_que)[k][0], k);
  868.     filter_subband(&(*win_que)[k][0], &(*sb_sample)[k][0][j][0]);
  869. }
  870.     
  871.     I_scale_factor_calc(*sb_sample, scalar, stereo);
  872.     if(fr_ps.actual_mode == MPG_MD_JOINT_STEREO) {
  873.                 I_combine_LR(*sb_sample, *j_sample);
  874.                 I_scale_factor_calc(j_sample, &j_scale, 1);
  875.     }
  876.     
  877.     put_scale(scalar, &fr_ps, max_sc);
  878.     
  879.     if (model == 1) I_Psycho_One(buffer, max_sc, ltmin, &fr_ps);
  880.     else {
  881.                 for (k=0;k<stereo;k++) {
  882.     psycho_anal(&buffer[k][0],&sam[k][0], k, info.lay, snr32,
  883. (FLOAT)s_freq[info.version][info.sampling_frequency]*1000);
  884.     for (i=0;i<SBLIMIT;i++) ltmin[k][i] = (double) snr32[i];
  885.                 }
  886.     }
  887.     
  888.     I_main_bit_allocation(ltmin, bit_alloc, &adb, &fr_ps);
  889.     
  890.     if (error_protection) I_CRC_calc(&fr_ps, bit_alloc, &crc);
  891.     
  892.     encode_info(&fr_ps, &bs);
  893.     
  894.     if (error_protection) encode_CRC(crc, &bs);
  895.     
  896.     I_encode_bit_alloc(bit_alloc, &fr_ps, &bs);
  897.     I_encode_scale(scalar, bit_alloc, &fr_ps, &bs);
  898.     I_subband_quantization(scalar, *sb_sample, j_scale, *j_sample,
  899.    bit_alloc, *subband, &fr_ps);
  900.     I_sample_encoding(*subband, bit_alloc, &fr_ps, &bs);
  901.     for (i=0;i<adb;i++) put1bit(&bs, 0);
  902.     break;
  903.     
  904. /***************************** Layer 2 **********************************/
  905.     
  906.           case 2 :
  907.     for (i=0;i<3;i++) for (j=0;j<SCALE_BLOCK;j++)
  908.                 for (k=0;k<stereo;k++) {
  909.     window_subband(&win_buf[k], &(*win_que)[k][0], k);
  910.     filter_subband(&(*win_que)[k][0], &(*sb_sample)[k][i][j][0]);
  911.                 }
  912.     
  913.     II_scale_factor_calc(*sb_sample, scalar, stereo, fr_ps.sblimit);
  914.     pick_scale(scalar, &fr_ps, max_sc);
  915.     if(fr_ps.actual_mode == MPG_MD_JOINT_STEREO) {
  916. II_combine_LR(*sb_sample, *j_sample, fr_ps.sblimit);
  917. II_scale_factor_calc(j_sample, &j_scale, 1, fr_ps.sblimit);
  918.     }       /* this way we calculate more mono than we need */
  919.     /* but it is cheap */
  920.     
  921.     if (model == 1) II_Psycho_One(buffer, max_sc, ltmin, &fr_ps);
  922.     else {
  923. for (k=0;k<stereo;k++) {
  924.     psycho_anal(&buffer[k][0],&sam[k][0], k, 
  925. info.lay, snr32,
  926. (FLOAT)s_freq[info.version][info.sampling_frequency]*1000);
  927.     for (i=0;i<SBLIMIT;i++) ltmin[k][i] = (double) snr32[i];
  928. }
  929.     }
  930.     
  931.     II_transmission_pattern(scalar, scfsi, &fr_ps);
  932.     II_main_bit_allocation(ltmin, scfsi, bit_alloc, &adb, &fr_ps);
  933.     
  934.     if (error_protection)
  935. II_CRC_calc(&fr_ps, bit_alloc, scfsi, &crc);
  936.     
  937.     encode_info(&fr_ps, &bs);
  938.     
  939.     if (error_protection) encode_CRC(crc, &bs);
  940.     
  941.     II_encode_bit_alloc(bit_alloc, &fr_ps, &bs);
  942.     II_encode_scale(bit_alloc, scfsi, scalar, &fr_ps, &bs);
  943.     II_subband_quantization(scalar, *sb_sample, j_scale,
  944.     *j_sample, bit_alloc, *subband, &fr_ps);
  945.     II_sample_encoding(*subband, bit_alloc, &fr_ps, &bs);
  946.     for (i=0;i<adb;i++) put1bit(&bs, 0);
  947.     break;
  948.     
  949. /***************************** Layer 3 **********************************/
  951.   case 3:
  952.   {
  953.       /*
  954. large "auto" vars are static due to the Macintosh linker
  955.       */ 
  956.       static double xr[2][2][576];
  957.       static double xr_dec[2][2][576];
  958.       static double pe[2][2];
  959.       static int l3_enc[2][2][576];
  960.       static III_psy_ratio ratio;
  961.       static III_side_info_t l3_side;
  962.       static III_scalefac_t  scalefac;
  963.       int gr, mode_gr, ch;
  964.       int mean_bits, sideinfo_len;
  965.       
  966.       int bitsPerFrame = 8 * whole_SpF + (info.padding * 8);
  967.       mode_gr = (info.version == 1) ? 2 : 1;
  969.       /*
  970. determine the mean bitrate for main data
  971.       */
  972.       sideinfo_len = 32;
  973.       if ( info.version == 1 )
  974.       {   /* MPEG 1 */
  975.   if ( stereo == 1 )
  976.       sideinfo_len += 136;
  977.   else
  978.       sideinfo_len += 256;
  979.       }
  980.       else
  981.       {   /* MPEG 2 */
  982.   if ( stereo == 1 )
  983.       sideinfo_len += 72;
  984.   else
  985.       sideinfo_len += 136;
  986.       }
  987.       if ( info.error_protection )
  988.   sideinfo_len += 16;
  989.       mean_bits = (bitsPerFrame - sideinfo_len) / mode_gr;
  991.       /*
  992. psychoacoustic model
  993.       */
  994.       for ( gr = 0; gr < mode_gr; gr++ )
  995.   for ( ch = 0; ch < stereo; ch++ )
  996.   {
  997.       L3psycho_anal( &buffer[ch][gr*576], &sam[ch][0], ch, info.lay,
  998.      snr32, s_freq[info.version][info.sampling_frequency] * 1000.0,
  999.      &ratio.l[gr][ch][0], &ratio.s[gr][ch][0],
  1000.      &pe[gr][ch], &l3_side.gr[gr].ch[ch].tt );
  1001.   }
  1003.       /*
  1004. polyphase filtering
  1005.       */
  1006.       for( gr = 0; gr < mode_gr; gr++ )
  1007.   for ( ch = 0; ch < stereo; ch++ )
  1008.       for ( j = 0; j < 18; j++ )
  1009.       {
  1010.   window_subband( &win_buf[ch], &(*win_que)[ch][0], ch );
  1011.   filter_subband( &(*win_que)[ch][0],  &(*l3_sb_sample)[ch][gr+1][j][0] );
  1012.       }
  1014.       /*
  1015. apply mdct to the polyphase outputs
  1016.       */
  1017.       mdct_sub( l3_sb_sample, xr, stereo, &l3_side, mode_gr );
  1018. #if 0
  1019.       delay( xr, stereo );
  1020. #endif
  1021.       /*
  1022. bit and noise allocation
  1023.       */
  1024.       iteration_loop( pe, xr, &ratio, &l3_side, l3_enc, mean_bits,
  1025.       stereo, xr_dec, &scalefac, &fr_ps, 0, bitsPerFrame );
  1027.       /*
  1028. write the frame to the bitstream
  1029.       */
  1030.       III_format_bitstream( bitsPerFrame, &fr_ps, l3_enc, &l3_side, &scalefac, &bs,
  1031.     xr, NULL, 0 );
  1032.   }
  1033.     break;  /* end of layer 3 */
  1034.     
  1036. } /* end switch  */
  1038. frameBits = sstell( &bs ) - sentBits;
  1039. if ( frameBits % bitsPerSlot )   /* a program failure */
  1040.     fprintf( stderr, "Sent %ld bits = %ld slots plus %ldn",
  1041.      frameBits, frameBits/bitsPerSlot,
  1042.      frameBits%bitsPerSlot );
  1043. sentBits += frameBits;
  1045.     }    
  1047.     if ( info.lay == 3 )
  1048. III_FlushBitstream();
  1050.     close_bit_stream_w( &bs );
  1052.     printf("Avg slots/frame = %.3f; b/smp = %.2f; br = %.3f kbpsn",
  1053.            (FLOAT) sentBits / (frameNum * bitsPerSlot),
  1054.            (FLOAT) sentBits / (frameNum * samplesPerFrame),
  1055.            (FLOAT) sentBits / (frameNum * samplesPerFrame) *
  1056.            s_freq[info.version][info.sampling_frequency]);
  1058.     if (fclose(musicin) != 0){
  1059. printf("Could not close "%s".n", original_file_name);
  1060. exit(2);
  1061.     }
  1063. #ifdef  MACINTOSH
  1064.     set_mac_file_attr( encoded_file_name, VOL_REF_NUM, CREATOR_ENCODE,
  1065.        FILETYPE_ENCODE );
  1066. #endif
  1068.     printf("Encoding of "%s" with psychoacoustic model %d is finishedn",
  1069.            original_file_name, model);
  1070.     printf("The MPEG encoded output file name is "%s"n",
  1071.    encoded_file_name);
  1072.     exit(0);
  1073. }
  1074.  
  1075. /************************************************************************
  1076. *
  1077. * usage
  1078. *
  1079. * PURPOSE:  Writes command line syntax to the file specified by #stderr#
  1080. *
  1081. ************************************************************************/
  1083. void usage()  /* print syntax & exit */
  1084. {
  1085.     fprintf(stderr,
  1086.     "usage: %s                         queries for all arguments, orn",
  1087.             programName);
  1088.     fprintf(stderr,
  1089.     "       %s [-l lay][-m mode][-p psy][-s sfrq][-b br][-d emp]n",
  1090.             programName);
  1091.     fprintf(stderr,
  1092.     "          [-c][-o][-e] inputPCM [outBS]n");
  1093.     fprintf(stderr,"wheren");
  1094.     fprintf(stderr," -l lay   use layer <lay> coding   (dflt %4u)n",DFLT_LAY);
  1095.     fprintf(stderr," -m mode  channel mode : s/d/j/m   (dflt %4c)n",DFLT_MOD);
  1096.     fprintf(stderr," -p psy   psychoacoustic model 1/2 (dflt %4u)n",DFLT_PSY);
  1097.     fprintf(stderr," -s sfrq  input smpl rate in kHz   (dflt %4.1f)n",DFLT_SFQ);
  1098.     fprintf(stderr," -b br    total bitrate in kbps    (dflt highest)n");
  1099.     fprintf(stderr," -d emp   de-emphasis n/5/c        (dflt %4c)n",DFLT_EMP);
  1100.     fprintf(stderr," -c       mark as copyrightn");
  1101.     fprintf(stderr," -o       mark as originaln");
  1102.     fprintf(stderr," -e       add error protectionn");
  1103.     fprintf(stderr," inputPCM input PCM sound file (standard or AIFF)n");
  1104.     fprintf(stderr," outBS    output bit stream of encoded audio (dflt inName+%s)n",
  1105.             DFLT_EXT);
  1106.     exit(1);
  1107. }
  1109. /************************************************************************
  1110. *
  1111. * aiff_check
  1112. *
  1113. * PURPOSE:  Checks AIFF header information to make sure it is valid.
  1114. *           Exits if not.
  1115. *
  1116. ************************************************************************/
  1118. void aiff_check( char *file_name, IFF_AIFF *pcm_aiff_data, int *version)
  1119. {
  1120.     if (pcm_aiff_data->sampleType != IFF_ID_SSND) {
  1121.        printf("Sound data is not PCM in "%s".n", file_name);
  1122.        exit(1);
  1123.     }
  1125.     if(SmpFrqIndex((long)pcm_aiff_data->sampleRate, version) < 0) {
  1126.        printf("in "%s".n", file_name);
  1127.        exit(1);
  1128.     }
  1130.     if (pcm_aiff_data->sampleSize != sizeof(short) * BITS_IN_A_BYTE) {
  1131.         printf("Sound data is not %d bits in "%s".n",
  1132.                sizeof(short) * BITS_IN_A_BYTE, file_name);
  1133.         exit(1);
  1134.     }
  1136.     if (pcm_aiff_data->numChannels != MONO &&
  1137.         pcm_aiff_data->numChannels != STEREO) {
  1138.        printf("Sound data is not mono or stereo in "%s".n", file_name);
  1139.        exit(1);
  1140.     }
  1142.     if (pcm_aiff_data->blkAlgn.blockSize != 0) {
  1143.        printf("Block size is not %d bytes in "%s".n", 0, file_name);
  1144.        exit(1);
  1145.     }
  1147.     if (pcm_aiff_data->blkAlgn.offset != 0) {
  1148.        printf("Block offset is not %d bytes in "%s".n", 0, file_name);
  1149.        exit(1);
  1150.     }
  1151. }