w~1

mpeg layerI II III, support window and linux

                         &sample_frames);
             }
             if(clip > 0) printf("%d samples clipped\n", clip);
             break;
          }

          case 3: {
             int nSlots;
             int gr, ch, ss, sb, main_data_end, flush_main ;
	     int  bytes_to_discard ;
	     static int frame_start = 0;

             bitsPerSlot = 8;        
             if(fr_ps.header->version == MPEG_PHASE2_LSF)
		samplesPerFrame = 576;
	     else
		samplesPerFrame = 1152;
 
             III_get_side_info(&bs, &III_side_info, &fr_ps);
             nSlots = main_data_slots(fr_ps);
             for (; nSlots > 0; nSlots--)  /* read main data. */
                hputbuf((unsigned int) getbits(&bs,8), 8);
	     main_data_end = hsstell() / 8; /*of privious frame*/
             if ( flush_main=(hsstell() % bitsPerSlot) ) { 
                hgetbits((int)(bitsPerSlot - flush_main));
		main_data_end ++;
	     }
             bytes_to_discard = frame_start - main_data_end
 			            - III_side_info.main_data_begin ;
#ifdef DEBUG_MAIN
             //printf("bytes_to_discard = %d\n",bytes_to_discard);
#endif 
             if( main_data_end > 4096 )
             {   frame_start -= 4096;
                 rewindNbytes( 4096 );
             }

             frame_start += main_data_slots(fr_ps);
#ifdef DEBUG_MAIN 
             //printf("frame_start = %d\n",frame_start);
#endif             
             if (bytes_to_discard < 0) {
         printf("Not enough main data to decode frame %d.  Frame discarded.\n", 
                        frameNum - 1); break;
             }
             for (; bytes_to_discard > 0; bytes_to_discard--) hgetbits(8);

             clip = 0;
             for (gr=0;gr<Max_gr;gr++) {
               double lr[2][SBLIMIT][SSLIMIT],ro[2][SBLIMIT][SSLIMIT];

               for (ch=0; ch<stereo; ch++) {
                 long int is[SBLIMIT][SSLIMIT];   /* Quantized samples. */
                 int part2_start;
                 part2_start = hsstell();
                 if(fr_ps.header->version != MPEG_PHASE2_LSF)
                 {
                    III_get_scale_factors(&III_scalefac,&III_side_info,gr,ch,
			   &fr_ps);
                 }
                 else
                 {
                    III_get_LSF_scale_factors(&III_scalefac,
                                                    &III_side_info,
                                                    gr,ch,&fr_ps);
                 }
                 III_hufman_decode(is, &III_side_info, ch, gr, part2_start,
                                   &fr_ps);
                 III_dequantize_sample(is, ro[ch], &III_scalefac,
                                   &(III_side_info.ch[ch].gr[gr]), ch, &fr_ps);
               }
               III_stereo(ro,lr,&III_scalefac,
                            &(III_side_info.ch[0].gr[gr]), &fr_ps);

               for (ch=0; ch<stereo; ch++) {
                    double re[SBLIMIT][SSLIMIT];
                    double hybridIn[SBLIMIT][SSLIMIT];/* Hybrid filter input */
                    double hybridOut[SBLIMIT][SSLIMIT];/* Hybrid filter out */
                    double polyPhaseIn[SBLIMIT];     /* PolyPhase Input. */

                    III_reorder (lr[ch],re,&(III_side_info.ch[ch].gr[gr]),
                                  &fr_ps);

                    III_antialias(re, hybridIn, /* Antialias butterflies. */
                                  &(III_side_info.ch[ch].gr[gr]), &fr_ps);

                    for (sb=0; sb<SBLIMIT; sb++) { /* Hybrid synthesis. */
                        III_hybrid(hybridIn[sb], hybridOut[sb], sb, ch,
                                   &(III_side_info.ch[ch].gr[gr]), &fr_ps);
                    }

                    for (ss=0;ss<18;ss++) /*Frequency inversion for polyphase.*/
                       for (sb=0; sb<SBLIMIT; sb++)
                          if ((ss%2) && (sb%2))
                             hybridOut[sb][ss] = -hybridOut[sb][ss];

                    for (ss=0;ss<18;ss++) { /* Polyphase synthesis */
                        for (sb=0; sb<SBLIMIT; sb++)
                            polyPhaseIn[sb] = hybridOut[sb][ss];
                        clip += SubBandSynthesis (polyPhaseIn, ch,
                                                  &((*pcm_sample)[ch][ss][0]));
                        }
                    }
                /* Output PCM sample points for one granule. */
                out_fifo(*pcm_sample, 18, &fr_ps, done, musicout,
                         &sample_frames);
             }
             if(clip > 0) printf("%d samples clipped.\n", clip);
             break;
          }
       }

/* skip ancillary data   HP 22-nov-95 */
       if (info.bitrate_index > 0) { /* if not free-format */
		long anc_len;

		anc_len = (int)((double)samplesPerFrame /
			       s_freq[info.version][info.sampling_frequency] *
			       (double)bitrate[info.version][info.lay-1][info.bitrate_index] /
			       (double)bitsPerSlot);
		if (info.padding)
			anc_len++;
		anc_len *= bitsPerSlot;
		anc_len -= sstell(&bs)-gotBits+SYNC_WORD_LNGTH;
		for (j=0; j<anc_len; j++)
			get1bit(&bs);
	}
    }

    if (Arguments.need_aiff) {
       pcm_aiff_data.numChannels       = stereo;
       pcm_aiff_data.numSampleFrames   = sample_frames;
       pcm_aiff_data.sampleSize        = 16;
       pcm_aiff_data.sampleRate        = s_freq[info.version][info.sampling_frequency]*1000;
       pcm_aiff_data.sampleType        = IFF_ID_SSND;
       pcm_aiff_data.blkAlgn.offset    = 0;
       pcm_aiff_data.blkAlgn.blockSize = 0;

       if (aiff_write_headers(musicout, &pcm_aiff_data) == -1) {
          printf("Could not write AIFF headers to \"%s\"\n",
                 Arguments.decoded_file_name);
          exit(2);
       }
    }

    printf("Avg slots/frame = %.3f; b/smp = %.2f; br = %.3f kbps\n",
           (FLOAT) gotBits / (frameNum * bitsPerSlot),
           (FLOAT) gotBits / (frameNum * samplesPerFrame),
           (FLOAT) gotBits / (frameNum * samplesPerFrame) *
           s_freq[info.version][info.sampling_frequency]);

    close_bit_stream_r(&bs);
    fclose(musicout);

    /* for the correct AIFF header information */
    /*             on the Macintosh            */
    /* the file type and the file creator for  */
    /* Macintosh compatible Digidesign is set  */

#ifdef  MACINTOSH
    if (Arguments.need_aiff)
		set_mac_file_attr(Arguments.decoded_file_name, VOL_REF_NUM,
                                     CREATR_DEC_AIFF, FILTYP_DEC_AIFF);
    else	set_mac_file_attr(Arguments.decoded_file_name, VOL_REF_NUM,
                                     CREATR_DEC_BNRY, FILTYP_DEC_BNRY);
#endif

    printf("Decoding of \"%s\" is finished\n", Arguments.encoded_file_name);
    printf("The decoded PCM output file name is \"%s\"\n", Arguments.decoded_file_name);
    if (Arguments.need_aiff)
       printf("\"%s\" has been written with AIFF header information\n",
              Arguments.decoded_file_name);

    exit( 0 );
}

static void usage()  /* print syntax & exit */
{
   fprintf(stderr,
      "usage: %s                         queries for all arguments, or\n",
       programName);
   fprintf(stderr,
      "       %s [-A][-s sb] inputBS [outPCM]\n", programName);
   fprintf(stderr,"where\n");
   fprintf(stderr," -A       write an AIFF output PCM sound file\n");
   fprintf(stderr," -s sb    resynth only up to this sb (debugging only)\n");
   fprintf(stderr," inputBS  input bit stream of encoded audio\n");
   fprintf(stderr," outPCM   output PCM sound file (dflt inName+%s)\n",
           DFLT_OPEXT);
   exit(1);
}


static void GetArguments(argc, argv,Arguments) 
    int argc;
    char **argv;
    Arguments_t *Arguments;

{
    char              t[50];

    programName = argv[0];
    if(argc==1) {        /* no command line args -> interact */
       do {
          printf ("Enter encoded file name <required>: ");
          gets (Arguments->encoded_file_name);
          if (Arguments->encoded_file_name[0] == NULL_CHAR)
             printf ("Encoded file name is required. \n");
       } while (Arguments->encoded_file_name[0] == NULL_CHAR);
       printf (">>> Encoded file name is: %s \n", Arguments->encoded_file_name);
#ifdef  MS_DOS
       printf ("Enter MPEG decoded file name <%s>: ",
               new_ext(Arguments->encoded_file_name, DFLT_OPEXT)); /* 92-08-19 shn */
#else
       printf ("Enter MPEG decoded file name <%s%s>: ",
                                     Arguments->encoded_file_name,
                                     DFLT_OPEXT);
#endif
       gets (Arguments->decoded_file_name);
       if (Arguments->decoded_file_name[0] == NULL_CHAR) {
#ifdef  MS_DOS
           /* replace old extension with new one, 92-08-19 shn */
           strcpy(Arguments->decoded_file_name,
                        new_ext(Arguments->encoded_file_name, DFLT_OPEXT));
#else
           strcat (strcpy(Arguments->decoded_file_name, 
                               Arguments->encoded_file_name), DFLT_OPEXT);
#endif
       }
       printf (">>> MPEG decoded file name is: %s \n", 
                                        Arguments->decoded_file_name);

       printf(
          "Do you wish to write an AIFF compatible sound file ? (y/<n>) : ");
       gets(t);
       if (*t == 'y' || *t == 'Y') Arguments->need_aiff = TRUE;
       else                        Arguments->need_aiff = FALSE;
       if (Arguments->need_aiff)
            printf(">>> An AIFF compatible sound file will be written\n");
       else printf(">>> A non-headered PCM sound file will be written\n");

       printf(
          "Do you wish to exit (last chance before decoding) ? (y/<n>) : ");
       gets(t);
       if (*t == 'y' || *t == 'Y') exit(0);
    }
    else {        /* interpret CL Args */
       int i=0, err=0;

       Arguments->need_aiff = FALSE;
       Arguments->need_esps = FALSE;	/* MI */
       Arguments->encoded_file_name[0] = '\0';
       Arguments->decoded_file_name[0] = '\0';

       while(++i<argc && err == 0) {
          char c, *token, *arg, *nextArg;
          int  argUsed;

          token = argv[i];
          if(*token++ == '-') {
             if(i+1 < argc) nextArg = argv[i+1];
             else           nextArg = "";
             argUsed = 0;
             while(c = *token++) {
                if(*token /* NumericQ(token) */) arg = token;
                else                             arg = nextArg;
                switch(c) {
                   case 's':  Arguments->topSb = atoi(arg); argUsed = 1;
                      if(Arguments->topSb<1 || Arguments->topSb>SBLIMIT) {
                         fprintf(stderr, "%s: -s band %s not %d..%d\n",
                                 programName, arg, 1, SBLIMIT);
                         err = 1;
                      }
                      break;
                   case 'A':  Arguments->need_aiff = TRUE; break;
                   case 'E':  Arguments->need_esps = TRUE; break;	/* MI */
                   default:   fprintf(stderr,"%s: unrecognized option %c\n",
                                      programName, c);
                      err = 1; break;
                }
                if(argUsed) {
                   if(arg == token) token = ""; /* no more from token */
                   else             ++i; /* skip arg we used */
                   arg = ""; argUsed = 0;
                }
             }
          }
          else {
             if(Arguments->encoded_file_name[0] == '\0')
                strcpy(Arguments->encoded_file_name, argv[i]);
             else
                if(Arguments->decoded_file_name[0] == '\0')
                   strcpy(Arguments->decoded_file_name, argv[i]);
                else {
                   fprintf(stderr,
                           "%s: excess arg %s\n", programName, argv[i]);
                   err = 1;
                }
          }
       }

       if(err || Arguments->encoded_file_name[0] == '\0') usage();  /* never returns */

       if(Arguments->decoded_file_name[0] == '\0') {
          strcpy(Arguments->decoded_file_name, Arguments->encoded_file_name);
          strcat(Arguments->decoded_file_name, DFLT_OPEXT);
       }

    }
    /* report results of dialog / command line */
    printf("Input file = '%s'  output file = '%s'\n",
           Arguments->encoded_file_name, Arguments->decoded_file_name);
    if(Arguments->need_aiff) printf("Output file written in AIFF format\n");
    if(Arguments->need_esps) printf("Output file written in ESPS format\n"); /* MI */
}