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

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

mpeg/mp3

开发平台：

C/C++

MUSICOUT.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Decoder - Lower Sampling Frequency Extension
  4.  *
  5.  * $Id: musicout.c,v 1.2 1996/03/28 03:13:37 rowlands Exp $
  6.  *
  7.  * $Log: musicout.c,v $
  8.  * Revision 1.2  1996/03/28 03:13:37  rowlands
  9.  * Merged layers 1-2 and layer 3 revisions
  10.  *
  11.  * Revision 1.1  1996/02/14 03:45:52  rowlands
  12.  * Initial revision
  13.  *
  14.  * Received from FhG
  15.  **********************************************************************/
  16. /**********************************************************************
  17.  *   date   programmers                comment                        *
  18.  * 2/25/91  Douglas Wong        start of version 1.0 records          *
  19.  * 3/06/91  Douglas Wong        rename setup.h to dedef.h             *
  20.  *                              removed extraneous variables          *
  21.  *                              removed window_samples (now part of   *
  22.  *                              filter_samples)                       *
  23.  * 3/07/91  Davis Pan           changed output file to "codmusic"     *
  24.  * 5/10/91  Vish (PRISM)        Ported to Macintosh and Unix.         *
  25.  *                              Incorporated new "out_fifo()" which   *
  26.  *                              writes out last incomplete buffer.    *
  27.  *                              Incorporated all AIFF routines which  *
  28.  *                              are also compatible with SUN.         *
  29.  *                              Incorporated user interface for       *
  30.  *                              specifying sound file names.          *
  31.  *                              Also incorporated user interface for  *
  32.  *                              writing AIFF compatible sound files.  *
  33.  * 27jun91  dpwe (Aware)        Added musicout and &sample_frames as  *
  34.  *                              args to out_fifo (were glob refs).    *
  35.  *                              Used new 'frame_params' struct.       *
  36.  *                              Clean,simplify, track clipped output  *
  37.  *                              and total bits/frame received.        *
  38.  * 7/10/91  Earle Jennings      changed to floats to FLOAT            *
  39.  *10/ 1/91  S.I. Sudharsanan,   Ported to IBM AIX platform.           *
  40.  *          Don H. Lee,                                               *
  41.  *          Peter W. Farrett                                          *
  42.  *10/ 3/91  Don H. Lee          implemented CRC-16 error protection   *
  43.  *                              newly introduced functions are        *
  44.  *                              buffer_CRC and recover_CRC_error      *
  45.  *                              Additions and revisions are marked    *
  46.  *                              with "dhl" for clarity                *
  47.  * 2/11/92  W. Joseph Carter    Ported new code to Macintosh.  Most   *
  48.  *                              important fixes involved changing     *
  49.  *                              16-bit ints to long or unsigned in    *
  50.  *                              bit alloc routines for quant of 65535 *
  51.  *                              and passing proper function args.     *
  52.  *                              Removed "Other Joint Stereo" option   *
  53.  *                              and made bitrate be total channel     *
  54.  *                              bitrate, irrespective of the mode.    *
  55.  *                              Fixed many small bugs & reorganized.  *
  56.  *19 aug 92 Soren H. Nielsen    Changed MS-DOS file name extensions.  *
  57.  * 8/27/93 Seymour Shlien,      Fixes in Unix and MSDOS ports,        *
  58.  *         Daniel Lauzon, and                                         *
  59.  *         Bill Truerniet                                             *
  60.  *--------------------------------------------------------------------*
  61.  * 4/23/92  J. Pineda           Added code for layer III.  LayerIII   *
  62.  *          Amit Gulati         decoding is currently performed in    *
  63.  *                              two-passes for ease of sideinfo and   *
  64.  *                              maindata buffering and decoding.      *
  65.  *                              The second (computation) pass is      *
  66.  *                              activated with "decode -3 <outfile>"  *
  67.  * 10/25/92 Amit Gulati         Modified usage() for layerIII         *
  68.  * 12/10/92 Amit Gulati         Changed processing order of re-order- *
  69.  *                              -ing step.  Fixed adjustment of       *
  70.  *                              main_data_end pointer to exclude      *
  71.  *                              side information.                     *
  72.  *  9/07/93 Toshiyuki Ishino    Integrated Layer III with Ver 3.9.    *
  73.  *--------------------------------------------------------------------*
  74.  * 11/20/93 Masahiro Iwadare    Integrated Layer III with Ver 4.0.    *
  75.  *--------------------------------------------------------------------*
  76.  *  7/14/94 Juergen Koller      Bug fixes in Layer III code           *
  77.  *--------------------------------------------------------------------*
  78.  * 08/11/94 IIS                 Bug fixes in Layer III code           *
  79.  *--------------------------------------------------------------------*
  80.  * 11/04/94 Jon Rowlands        Prototype fixes                       *
  81.  *--------------------------------------------------------------------*
  82.  *  7/12/95 Soeren H. Nielsen   Changes for LSF Layer I and II        *
  83.  *--------------------------------------------------------------------*
  84.  *  7/14/94 Juergen Koller      Bug fixes in Layer III code           *
  85.  *--------------------------------------------------------------------*
  86.  *     8/95 Roland Bitto        addapdet to MPEG 2                    *
  87.  *--------------------------------------------------------------------*
  88.  * 11/22/95 Heiko Purnhagen     skip ancillary data in bitstream      *
  89.  **********************************************************************/
  91. #include        "common.h"
  92. #include        "decoder.h"
  94. /********************************************************************
  95. /*
  96. /*        This part contains the MPEG I decoder for Layers I & II.
  97. /*
  98. /*********************************************************************/
  100. /****************************************************************
  101. /*
  102. /*        For MS-DOS user (Turbo c) change all instance of malloc
  103. /*        to _farmalloc and free to _farfree. Compiler model hugh
  104. /*        Also make sure all the pointer specified are changed to far.
  105. /*
  106. /*****************************************************************/
  107. /* local functions definition */
  109. static void usage();
  110. static void GetArguments();
  111.   
  113. /*********************************************************************
  114. /*
  115. /* Core of the Layer II decoder.  Default layer is Layer II.
  116. /*
  117. /*********************************************************************/
  119. /* Global variable definitions for "musicout.c" */
  121. char *programName;
  122. int main_data_slots();
  123. int side_info_slots();
  125. /* Implementations */
  127. main(argc, argv)
  128. int argc;
  129. char **argv;
  130. {
  131. /*typedef short PCM[2][3][SBLIMIT];*/
  132. typedef short PCM[2][SSLIMIT][SBLIMIT];
  133.     PCM FAR *pcm_sample;
  134. typedef unsigned int SAM[2][3][SBLIMIT];
  135.     SAM FAR *sample;
  136. typedef double FRA[2][3][SBLIMIT];
  137.     FRA FAR *fraction;
  138. typedef double VE[2][HAN_SIZE];
  139.     VE FAR *w;
  141.     Bit_stream_struc  bs;
  142.     frame_params      fr_ps;
  143.     layer             info;
  144.     FILE              *musicout;
  145.     unsigned long     sample_frames;
  147.     int               i, j, k, stereo, done=FALSE, clip, sync; 
  148.     int               error_protection, crc_error_count, total_error_count;
  149.     unsigned int      old_crc, new_crc;
  150.     unsigned int      bit_alloc[2][SBLIMIT], scfsi[2][SBLIMIT],
  151.                       scale_index[2][3][SBLIMIT];
  152.     unsigned long     bitsPerSlot, samplesPerFrame, frameNum = 0;
  153.     unsigned long     frameBits, gotBits = 0;
  154.     IFF_AIFF          pcm_aiff_data;
  155.     Arguments_t       Arguments;
  156.     int Max_gr;
  158. III_scalefac_t III_scalefac;
  159. III_side_info_t III_side_info;
  161. #ifdef  MACINTOSH
  162.     console_options.nrows = MAC_WINDOW_SIZE;
  163.     argc = ccommand(&argv);
  164. #endif
  166.     /* Most large variables are declared dynamically to ensure
  167.        compatibility with smaller machines */
  169.     pcm_sample = (PCM FAR *) mem_alloc((long) sizeof(PCM), "PCM Samp");
  170.     sample = (SAM FAR *) mem_alloc((long) sizeof(SAM), "Sample");
  171.     fraction = (FRA FAR *) mem_alloc((long) sizeof(FRA), "fraction");
  172.     w = (VE FAR *) mem_alloc((long) sizeof(VE), "w");
  174.     fr_ps.header = &info;
  175.     fr_ps.tab_num = -1;                /* no table loaded */
  176.     fr_ps.alloc = NULL;
  177.     for (i=0;i<HAN_SIZE;i++) for (j=0;j<2;j++) (*w)[j][i] = 0.0;
  179.     Arguments.topSb = 0;
  180.     GetArguments(argc, argv, &Arguments);
  181.     if ((musicout = fopen(Arguments.decoded_file_name, "w+b")) == NULL) {
  182.           printf ("Could not create "%s".n", Arguments.decoded_file_name);
  183.           exit(1);
  184.         }
  185.     open_bit_stream_r(&bs, Arguments.encoded_file_name, BUFFER_SIZE);
  187.     if (Arguments.need_aiff)
  188.        if (aiff_seek_to_sound_data(musicout) == -1) {
  189.           printf("Could not seek to PCM sound data in "%s".n",
  190.                  Arguments.decoded_file_name);
  191.           exit(1);
  192.        }
  194.     sample_frames = 0;
  196.     while (!end_bs(&bs)) {
  198.        sync = seek_sync(&bs, SYNC_WORD, SYNC_WORD_LNGTH);
  199.        frameBits = sstell(&bs) - gotBits;
  200.        if(frameNum > 0)        /* don't want to print on 1st loop; no lay */
  201.           if(frameBits%bitsPerSlot)
  202.              fprintf(stderr,"Got %ld bits = %ld slots plus %ldn",
  203.                      frameBits, frameBits/bitsPerSlot, frameBits%bitsPerSlot);
  204.        gotBits += frameBits;
  206.        if (!sync) {
  207.           printf("Frame cannot be locatedn");
  208.           printf("Input stream may be emptyn");
  209.           done = TRUE;
  210.           /* finally write out the buffer */
  211.           if (info.lay != 1) out_fifo(*pcm_sample, 3, &fr_ps, done,
  212.                                       musicout, &sample_frames);
  213.           else               out_fifo(*pcm_sample, 1, &fr_ps, done,
  214.                                       musicout, &sample_frames);
  215.           break;
  216.        }
  218.        decode_info(&bs, &fr_ps);
  219.        hdr_to_frps(&fr_ps);
  220.        stereo = fr_ps.stereo;
  221.        if(fr_ps.header->version == MPEG_PHASE2_LSF) {
  222. Max_gr = 1;
  223.        }
  224.        else
  225.        { 
  226. Max_gr = 2;
  227.        }
  229.        error_protection = info.error_protection;
  230.        crc_error_count = 0;
  231.        total_error_count = 0;
  232.        if(frameNum == 0) WriteHdr(&fr_ps, stdout);  /* printout layer/mode */
  234. #ifdef ESPS
  235. if (frameNum == 0 && Arguments.need_esps) {
  236. esps_write_header(musicout,(long) sample_frames, (double)
  237. s_freq[info.version][info.sampling_frequency] * 1000,
  238. (int) stereo, Arguments.decoded_file_name );
  239. } /* MI */
  240. #endif
  242.        fprintf(stderr, "{%4lu}", frameNum++); fflush(stderr); 
  243.        if (error_protection) buffer_CRC(&bs, &old_crc);
  245.        switch (info.lay) {
  247.           case 1: {
  248.              bitsPerSlot = 32;        samplesPerFrame = 384;
  249.              I_decode_bitalloc(&bs,bit_alloc,&fr_ps);
  250.              I_decode_scale(&bs, bit_alloc, scale_index, &fr_ps);
  252.              if (error_protection) {
  253.                 I_CRC_calc(&fr_ps, bit_alloc, &new_crc);
  254.                 if (new_crc != old_crc) {
  255.                    crc_error_count++;
  256.                    total_error_count++;
  257.                    recover_CRC_error(*pcm_sample, crc_error_count,
  258.                                      &fr_ps, musicout, &sample_frames);
  259.                    break;
  260.                 }
  261.                 else crc_error_count = 0;
  262.              }
  264.              clip = 0;
  265.              for (i=0;i<SCALE_BLOCK;i++) {
  266.                 I_buffer_sample(&bs,(*sample),bit_alloc,&fr_ps);
  267.                 I_dequantize_sample(*sample,*fraction,bit_alloc,&fr_ps);
  268.                 I_denormalize_sample((*fraction),scale_index,&fr_ps);
  270.                 if(Arguments.topSb>0)        /* clear channels to 0 */
  271.                    for(j=Arguments.topSb; j<fr_ps.sblimit; ++j)
  272.                       for(k=0; k<stereo; ++k)
  273.                          (*fraction)[k][0][j] = 0;
  275.                 for (j=0;j<stereo;j++) {
  276.                    clip += SubBandSynthesis (&((*fraction)[j][0][0]), j,
  277.                                              &((*pcm_sample)[j][0][0]));
  278.                 }
  279.                 out_fifo(*pcm_sample, 1, &fr_ps, done,
  280.                          musicout, &sample_frames);
  281.              }
  282.              if(clip > 0) printf("%d output samples clippedn", clip);
  283.              break;
  284.           }
  286.           case 2: {
  287.              bitsPerSlot = 8;        samplesPerFrame = 1152;
  288.              II_decode_bitalloc(&bs, bit_alloc, &fr_ps);
  289.              II_decode_scale(&bs, scfsi, bit_alloc, scale_index, &fr_ps);
  291.              if (error_protection) { 
  292.                 II_CRC_calc(&fr_ps, bit_alloc, scfsi, &new_crc);
  293.                 if (new_crc != old_crc) {
  294.                    crc_error_count++;
  295.                    total_error_count++;
  296.                    recover_CRC_error(*pcm_sample, crc_error_count,
  297.                                      &fr_ps, musicout, &sample_frames);
  298.                    break;
  299.                 }
  300.                 else crc_error_count = 0;
  301.              }
  303.              clip = 0;
  304.              for (i=0;i<SCALE_BLOCK;i++) {
  305.                 II_buffer_sample(&bs,(*sample),bit_alloc,&fr_ps);
  306.                 II_dequantize_sample((*sample),bit_alloc,(*fraction),&fr_ps);
  307.                 II_denormalize_sample((*fraction),scale_index,&fr_ps,i>>2);
  309.                 if(Arguments.topSb>0)        /* debug : clear channels to 0 */
  310.                    for(j=Arguments.topSb; j<fr_ps.sblimit; ++j)
  311.                       for(k=0; k<stereo; ++k)
  312.                          (*fraction)[k][0][j] =
  313.                          (*fraction)[k][1][j] =
  314.                          (*fraction)[k][2][j] = 0;
  316.                 for (j=0;j<3;j++) for (k=0;k<stereo;k++) {
  317.                    clip += SubBandSynthesis (&((*fraction)[k][j][0]), k,
  318.                                              &((*pcm_sample)[k][j][0]));
  319.                 }
  320.                 out_fifo(*pcm_sample, 3, &fr_ps, done, musicout,
  321.                          &sample_frames);
  322.              }
  323.              if(clip > 0) printf("%d samples clippedn", clip);
  324.              break;
  325.           }
  327.           case 3: {
  328.              int nSlots;
  329.              int gr, ch, ss, sb, main_data_end, flush_main ;
  330.      int  bytes_to_discard ;
  331.      static int frame_start = 0;
  333.              bitsPerSlot = 8;        
  334.              if(fr_ps.header->version == MPEG_PHASE2_LSF)
  335. samplesPerFrame = 576;
  336.      else
  337. samplesPerFrame = 1152;
  338.  
  339.              III_get_side_info(&bs, &III_side_info, &fr_ps);
  340.              nSlots = main_data_slots(fr_ps);
  341.              for (; nSlots > 0; nSlots--)  /* read main data. */
  342.                 hputbuf((unsigned int) getbits(&bs,8), 8);
  343.      main_data_end = hsstell() / 8; /*of privious frame*/
  344.              if ( flush_main=(hsstell() % bitsPerSlot) ) { 
  345.                 hgetbits((int)(bitsPerSlot - flush_main));
  346. main_data_end ++;
  347.      }
  348.              bytes_to_discard = frame_start - main_data_end
  349.               - III_side_info.main_data_begin ;
  350.              if( main_data_end > 4096 )
  351.              {   frame_start -= 4096;
  352.                  rewindNbytes( 4096 );
  353.              }
  355.              frame_start += main_data_slots(fr_ps);
  356.              if (bytes_to_discard < 0) {
  357.          printf("Not enough main data to decode frame %d.  Frame discarded.n", 
  358.                         frameNum - 1); break;
  359.              }
  360.              for (; bytes_to_discard > 0; bytes_to_discard--) hgetbits(8);
  362.              clip = 0;
  363.              for (gr=0;gr<Max_gr;gr++) {
  364.                double lr[2][SBLIMIT][SSLIMIT],ro[2][SBLIMIT][SSLIMIT];
  366.                for (ch=0; ch<stereo; ch++) {
  367.                  long int is[SBLIMIT][SSLIMIT];   /* Quantized samples. */
  368.                  int part2_start;
  369.                  part2_start = hsstell();
  370.                  if(fr_ps.header->version != MPEG_PHASE2_LSF)
  371.                  {
  372.                     III_get_scale_factors(&III_scalefac,&III_side_info,gr,ch,
  373.    &fr_ps);
  374.                  }
  375.                  else
  376.                  {
  377.                     III_get_LSF_scale_factors(&III_scalefac,
  378.                                                     &III_side_info,
  379.                                                     gr,ch,&fr_ps);
  380.                  }
  381.                  III_hufman_decode(is, &III_side_info, ch, gr, part2_start,
  382.                                    &fr_ps);
  383.                  III_dequantize_sample(is, ro[ch], &III_scalefac,
  384.                                    &(III_side_info.ch[ch].gr[gr]), ch, &fr_ps);
  385.                }
  386.                III_stereo(ro,lr,&III_scalefac,
  387.                             &(III_side_info.ch[0].gr[gr]), &fr_ps);
  389.                for (ch=0; ch<stereo; ch++) {
  390.                     double re[SBLIMIT][SSLIMIT];
  391.                     double hybridIn[SBLIMIT][SSLIMIT];/* Hybrid filter input */
  392.                     double hybridOut[SBLIMIT][SSLIMIT];/* Hybrid filter out */
  393.                     double polyPhaseIn[SBLIMIT];     /* PolyPhase Input. */
  395.                     III_reorder (lr[ch],re,&(III_side_info.ch[ch].gr[gr]),
  396.                                   &fr_ps);
  398.                     III_antialias(re, hybridIn, /* Antialias butterflies. */
  399.                                   &(III_side_info.ch[ch].gr[gr]), &fr_ps);
  401.                     for (sb=0; sb<SBLIMIT; sb++) { /* Hybrid synthesis. */
  402.                         III_hybrid(hybridIn[sb], hybridOut[sb], sb, ch,
  403.                                    &(III_side_info.ch[ch].gr[gr]), &fr_ps);
  404.                     }
  406.                     for (ss=0;ss<18;ss++) /*Frequency inversion for polyphase.*/
  407.                        for (sb=0; sb<SBLIMIT; sb++)
  408.                           if ((ss%2) && (sb%2))
  409.                              hybridOut[sb][ss] = -hybridOut[sb][ss];
  411.                     for (ss=0;ss<18;ss++) { /* Polyphase synthesis */
  412.                         for (sb=0; sb<SBLIMIT; sb++)
  413.                             polyPhaseIn[sb] = hybridOut[sb][ss];
  414.                         clip += SubBandSynthesis (polyPhaseIn, ch,
  415.                                                   &((*pcm_sample)[ch][ss][0]));
  416.                         }
  417.                     }
  418.                 /* Output PCM sample points for one granule. */
  419.                 out_fifo(*pcm_sample, 18, &fr_ps, done, musicout,
  420.                          &sample_frames);
  421.              }
  422.              if(clip > 0) printf("%d samples clipped.n", clip);
  423.              break;
  424.           }
  425.        }
  427. /* skip ancillary data   HP 22-nov-95 */
  428.        if (info.bitrate_index > 0) { /* if not free-format */
  429. long anc_len;
  431. anc_len = (int)((double)samplesPerFrame /
  432.        s_freq[info.version][info.sampling_frequency] *
  433.        (double)bitrate[info.version][info.lay-1][info.bitrate_index] /
  434.        (double)bitsPerSlot);
  435. if (info.padding)
  436. anc_len++;
  437. anc_len *= bitsPerSlot;
  438. anc_len -= sstell(&bs)-gotBits+SYNC_WORD_LNGTH;
  439. for (j=0; j<anc_len; j++)
  440. get1bit(&bs);
  441. }
  442.     }
  444.     if (Arguments.need_aiff) {
  445.        pcm_aiff_data.numChannels       = stereo;
  446.        pcm_aiff_data.numSampleFrames   = sample_frames;
  447.        pcm_aiff_data.sampleSize        = 16;
  448.        pcm_aiff_data.sampleRate        = s_freq[info.version][info.sampling_frequency]*1000;
  449.        pcm_aiff_data.sampleType        = IFF_ID_SSND;
  450.        pcm_aiff_data.blkAlgn.offset    = 0;
  451.        pcm_aiff_data.blkAlgn.blockSize = 0;
  453.        if (aiff_write_headers(musicout, &pcm_aiff_data) == -1) {
  454.           printf("Could not write AIFF headers to "%s"n",
  455.                  Arguments.decoded_file_name);
  456.           exit(2);
  457.        }
  458.     }
  460.     printf("Avg slots/frame = %.3f; b/smp = %.2f; br = %.3f kbpsn",
  461.            (FLOAT) gotBits / (frameNum * bitsPerSlot),
  462.            (FLOAT) gotBits / (frameNum * samplesPerFrame),
  463.            (FLOAT) gotBits / (frameNum * samplesPerFrame) *
  464.            s_freq[info.version][info.sampling_frequency]);
  466.     close_bit_stream_r(&bs);
  467.     fclose(musicout);
  469.     /* for the correct AIFF header information */
  470.     /*             on the Macintosh            */
  471.     /* the file type and the file creator for  */
  472.     /* Macintosh compatible Digidesign is set  */
  474. #ifdef  MACINTOSH
  475.     if (Arguments.need_aiff)
  476. set_mac_file_attr(Arguments.decoded_file_name, VOL_REF_NUM,
  477.                                      CREATR_DEC_AIFF, FILTYP_DEC_AIFF);
  478.     else set_mac_file_attr(Arguments.decoded_file_name, VOL_REF_NUM,
  479.                                      CREATR_DEC_BNRY, FILTYP_DEC_BNRY);
  480. #endif
  482.     printf("Decoding of "%s" is finishedn", Arguments.encoded_file_name);
  483.     printf("The decoded PCM output file name is "%s"n", Arguments.decoded_file_name);
  484.     if (Arguments.need_aiff)
  485.        printf(""%s" has been written with AIFF header informationn",
  486.               Arguments.decoded_file_name);
  488.     exit( 0 );
  489. }
  491. static void usage()  /* print syntax & exit */
  492. {
  493.    fprintf(stderr,
  494.       "usage: %s                         queries for all arguments, orn",
  495.        programName);
  496.    fprintf(stderr,
  497.       "       %s [-A][-s sb] inputBS [outPCM]n", programName);
  498.    fprintf(stderr,"wheren");
  499.    fprintf(stderr," -A       write an AIFF output PCM sound filen");
  500.    fprintf(stderr," -s sb    resynth only up to this sb (debugging only)n");
  501.    fprintf(stderr," inputBS  input bit stream of encoded audion");
  502.    fprintf(stderr," outPCM   output PCM sound file (dflt inName+%s)n",
  503.            DFLT_OPEXT);
  504.    exit(1);
  505. }
  508. static void GetArguments(argc, argv,Arguments) 
  509.     int argc;
  510.     char **argv;
  511.     Arguments_t *Arguments;
  513. {
  514.     char              t[50];
  516.     programName = argv[0];
  517.     if(argc==1) {        /* no command line args -> interact */
  518.        do {
  519.           printf ("Enter encoded file name <required>: ");
  520.           gets (Arguments->encoded_file_name);
  521.           if (Arguments->encoded_file_name[0] == NULL_CHAR)
  522.              printf ("Encoded file name is required. n");
  523.        } while (Arguments->encoded_file_name[0] == NULL_CHAR);
  524.        printf (">>> Encoded file name is: %s n", Arguments->encoded_file_name);
  525. #ifdef  MS_DOS
  526.        printf ("Enter MPEG decoded file name <%s>: ",
  527.                new_ext(Arguments->encoded_file_name, DFLT_OPEXT)); /* 92-08-19 shn */
  528. #else
  529.        printf ("Enter MPEG decoded file name <%s%s>: ",
  530.                                      Arguments->encoded_file_name,
  531.                                      DFLT_OPEXT);
  532. #endif
  533.        gets (Arguments->decoded_file_name);
  534.        if (Arguments->decoded_file_name[0] == NULL_CHAR) {
  535. #ifdef  MS_DOS
  536.            /* replace old extension with new one, 92-08-19 shn */
  537.            strcpy(Arguments->decoded_file_name,
  538.                         new_ext(Arguments->encoded_file_name, DFLT_OPEXT));
  539. #else
  540.            strcat (strcpy(Arguments->decoded_file_name, 
  541.                                Arguments->encoded_file_name), DFLT_OPEXT);
  542. #endif
  543.        }
  544.        printf (">>> MPEG decoded file name is: %s n", 
  545.                                         Arguments->decoded_file_name);
  547.        printf(
  548.           "Do you wish to write an AIFF compatible sound file ? (y/<n>) : ");
  549.        gets(t);
  550.        if (*t == 'y' || *t == 'Y') Arguments->need_aiff = TRUE;
  551.        else                        Arguments->need_aiff = FALSE;
  552.        if (Arguments->need_aiff)
  553.             printf(">>> An AIFF compatible sound file will be writtenn");
  554.        else printf(">>> A non-headered PCM sound file will be writtenn");
  556.        printf(
  557.           "Do you wish to exit (last chance before decoding) ? (y/<n>) : ");
  558.        gets(t);
  559.        if (*t == 'y' || *t == 'Y') exit(0);
  560.     }
  561.     else {        /* interpret CL Args */
  562.        int i=0, err=0;
  564.        Arguments->need_aiff = FALSE;
  565.        Arguments->need_esps = FALSE; /* MI */
  566.        Arguments->encoded_file_name[0] = '';
  567.        Arguments->decoded_file_name[0] = '';
  569.        while(++i<argc && err == 0) {
  570.           char c, *token, *arg, *nextArg;
  571.           int  argUsed;
  573.           token = argv[i];
  574.           if(*token++ == '-') {
  575.              if(i+1 < argc) nextArg = argv[i+1];
  576.              else           nextArg = "";
  577.              argUsed = 0;
  578.              while(c = *token++) {
  579.                 if(*token /* NumericQ(token) */) arg = token;
  580.                 else                             arg = nextArg;
  581.                 switch(c) {
  582.                    case 's':  Arguments->topSb = atoi(arg); argUsed = 1;
  583.                       if(Arguments->topSb<1 || Arguments->topSb>SBLIMIT) {
  584.                          fprintf(stderr, "%s: -s band %s not %d..%dn",
  585.                                  programName, arg, 1, SBLIMIT);
  586.                          err = 1;
  587.                       }
  588.                       break;
  589.                    case 'A':  Arguments->need_aiff = TRUE; break;
  590.                    case 'E':  Arguments->need_esps = TRUE; break; /* MI */
  591.                    default:   fprintf(stderr,"%s: unrecognized option %cn",
  592.                                       programName, c);
  593.                       err = 1; break;
  594.                 }
  595.                 if(argUsed) {
  596.                    if(arg == token) token = ""; /* no more from token */
  597.                    else             ++i; /* skip arg we used */
  598.                    arg = ""; argUsed = 0;
  599.                 }
  600.              }
  601.           }
  602.           else {
  603.              if(Arguments->encoded_file_name[0] == '')
  604.                 strcpy(Arguments->encoded_file_name, argv[i]);
  605.              else
  606.                 if(Arguments->decoded_file_name[0] == '')
  607.                    strcpy(Arguments->decoded_file_name, argv[i]);
  608.                 else {
  609.                    fprintf(stderr,
  610.                            "%s: excess arg %sn", programName, argv[i]);
  611.                    err = 1;
  612.                 }
  613.           }
  614.        }
  616.        if(err || Arguments->encoded_file_name[0] == '') usage();  /* never returns */
  618.        if(Arguments->decoded_file_name[0] == '') {
  619.           strcpy(Arguments->decoded_file_name, Arguments->encoded_file_name);
  620.           strcat(Arguments->decoded_file_name, DFLT_OPEXT);
  621.        }
  623.     }
  624.     /* report results of dialog / command line */
  625.     printf("Input file = '%s'  output file = '%s'n",
  626.            Arguments->encoded_file_name, Arguments->decoded_file_name);
  627.     if(Arguments->need_aiff) printf("Output file written in AIFF formatn");
  628.     if(Arguments->need_esps) printf("Output file written in ESPS formatn"); /* MI */
  629. }