main.c

音频编码

#ifdef BRHIST
                    if (brhist)
                        brhist_disp(gf);
#endif
                }
            }
        }

        /* encode */
        imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
                                      mp3buffer, sizeof(mp3buffer));

        /* was our output buffer big enough? */
        if (imp3 < 0) {
            if (imp3 == -1)
                fprintf(stderr, "mp3 buffer is not big enough... \n");
            else
                fprintf(stderr, "mp3 internal error:  error code=%i\n", imp3);
            return 1;
        }

        if (fwrite(mp3buffer, 1, imp3, outf) != imp3) {
            fprintf(stderr, "Error writing mp3 output \n");
            return 1;
        }

    } while (iread);

    if (nogap) 
        imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
    else
        imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */

    if (imp3 < 0) {
        if (imp3 == -1)
            fprintf(stderr, "mp3 buffer is not big enough... \n");
        else
            fprintf(stderr, "mp3 internal error:  error code=%i\n", imp3);
        return 1;

    }

    if (silent <= 0) {
#ifdef BRHIST
        brhist_jump_back();
#endif
        frames = lame_get_frameNum(gf);
        timestatus(lame_get_out_samplerate(gf),
                   frames, lame_get_totalframes(gf), lame_get_framesize(gf));
#ifdef BRHIST
        if (brhist) {
            brhist_disp(gf);
        }
        brhist_disp_total(gf);
#endif
        timestatus_finish();
    }

    fwrite(mp3buffer, 1, imp3, outf);

    return 0;
}






void
brhist_init_package(lame_global_flags * gf)
{
#ifdef BRHIST
    if (brhist) {
        if (brhist_init
            (gf, lame_get_VBR_min_bitrate_kbps(gf),
             lame_get_VBR_max_bitrate_kbps(gf))) {
            /* fail to initialize */
            brhist = 0;
        }
    }
    else {
        brhist_init(gf, 128, 128); /* Dirty hack */
    }
#endif
}




void parse_nogap_filenames(int nogapout, char *inPath, char *outPath, char *outdir) {

    char    *slasher;
    int     n;

    strcpy(outPath,outdir);
    if (!nogapout) 	{
        strncpy(outPath, inPath, PATH_MAX + 1 - 4);
        n=strlen(outPath);
        /* nuke old extension, if one  */
        if (outPath[n-3] == 'w' 
            && outPath[n-2] == 'a'
            && outPath[n-1] == 'v'
            && outPath[n-4] == '.') {
            outPath[n-3] = 'm';
            outPath[n-2] = 'p';
            outPath[n-1] = '3';
        } else {
            outPath[n+0] = '.';
            outPath[n+1] = 'm';
            outPath[n+2] = 'p';
            outPath[n+3] = '3';
            outPath[n+4] = 0;
        }
    } else 	{
        slasher = inPath;
        slasher += PATH_MAX + 1 - 4;
        
        /* backseek to last dir delemiter */
        while (*slasher != '/' && *slasher != '\\' && slasher != inPath
               && *slasher != ':')
            {
                slasher--;
            }
        
        /* skip one foward if needed */
        if (slasher != inPath 
            && (outPath[strlen(outPath)-1] == '/'
                ||
                outPath[strlen(outPath)-1] == '\\'
                ||
                outPath[strlen(outPath)-1] == ':')) 
	    slasher++;
        else if (slasher == inPath
                 && (outPath[strlen(outPath)-1] != '/'
                     &&
                     outPath[strlen(outPath)-1] != '\\'
                     && 
                     outPath[strlen(outPath)-1] != ':'))
#ifdef _WIN32
	    strcat(outPath, "\\");
#elif __OS2__
        strcat(outPath, "\\");
#else
        strcat(outPath, "/");
#endif
        
        strncat(outPath, slasher, PATH_MAX + 1 - 4);
        n=strlen(outPath);
        /* nuke old extension  */
        if (outPath[n-3] == 'w' 
            && outPath[n-2] == 'a'
            && outPath[n-1] == 'v'
            && outPath[n-4] == '.') 	  {
	    outPath[n-3] = 'm';
	    outPath[n-2] = 'p';
	    outPath[n-1] = '3';
        } else {
	    outPath[n+0] = '.';
	    outPath[n+1] = 'm';
	    outPath[n+2] = 'p';
	    outPath[n+3] = '3';
	    outPath[n+4] = 0;
        }
    }
}


  

void print_lame_tag_leading_info(lame_global_flags *gf) {
    if(lame_get_bWriteVbrTag(gf))
      printf("Writing LAME Tag...");
}

void print_trailing_info(lame_global_flags *gf)
{
    if (lame_get_bWriteVbrTag(gf))
      printf("done\n");

    if (lame_get_findReplayGain(gf) ) {
      int RadioGain = lame_get_RadioGain(gf);
      printf("ReplayGain: %s%.1fdB\n", RadioGain > 0 ? "+" : "", ((float)RadioGain) / 10.0);
      if (RadioGain > 0x1FE || RadioGain < -0x1FE) 
	printf("WARNING: ReplayGain exceeds the -51dB to +51dB range. Such a result is too\n"
	       "         high to be stored in the header.\n" );
    }
	
    /* if (the user requested printing info about clipping) and (decoding
       on the fly has actually been performed) */
    if(print_clipping_info && lame_get_decode_on_the_fly(gf)) {
      float noclipGainChange = (float)lame_get_noclipGainChange(gf) / 10.0;
      float noclipScale = lame_get_noclipScale(gf);

      if (noclipGainChange > 0.0) { /* clipping occurs */
	printf("WARNING: clipping occurs at the current gain. Set your decoder to decrease\n"
	       "         the  gain  by  at least %.1fdB or encode again ", noclipGainChange); 
                                                                            
	/* advice the user on the scale factor */
	if (noclipScale > 0) {
	  printf("using  --scale %.2f\n", noclipScale);
	  printf("         or less (the value under --scale is approximate).\n" );
	}
	else {
          /* the user specified his own scale factor. We could suggest 
           * the scale factor of (32767.0/gfp->PeakSample)*(gfp->scale)
           * but it's usually very inaccurate. So we'd rather advice him to 
           * disable scaling first and see our suggestion on the scale factor then. */
	  printf("using --scale <arg>\n"
	         "         (For   a   suggestion  on  the  optimal  value  of  <arg>  encode\n"
	         "         with  --scale 1  first)\n" );
	}
		    
      }
      else { /* no clipping */
	if (noclipGainChange > -0.1)
	  printf("\nThe waveform does not clip and is less than 0.1dB away from full scale.\n" );
	else                                                                                        
	  printf("\nThe waveform does not clip and is at least %.1fdB away from full scale.\n", -noclipGainChange);
      }                                                                                             
    }
  
}





int
main(int argc, char **argv)
{
    int     ret;
    lame_global_flags *gf;
    char    outPath[PATH_MAX + 1];
    char    nogapdir[PATH_MAX + 1];
    char    inPath[PATH_MAX + 1];

    /* support for "nogap" encoding of up to 200 .wav files */
#define MAX_NOGAP 200
    int    nogapout = 0;
    int     max_nogap = MAX_NOGAP;
    char   *nogap_inPath[MAX_NOGAP];

    int     i;
    FILE   *outf;

#if macintosh
    argc = ccommand(&argv);
#endif

#if defined(_WIN32)
   /* set affinity back to all CPUs.  Fix for EAC/lame on SMP systems from
     "Todd Richmond" <[e-mail]> */
    typedef BOOL (WINAPI *SPAMFunc)(HANDLE, DWORD);
    SPAMFunc func;
    SYSTEM_INFO si;

    if ((func = (SPAMFunc)GetProcAddress(GetModuleHandle("KERNEL32.DLL"),
        "SetProcessAffinityMask")) != NULL) {
        GetSystemInfo(&si);
        func(GetCurrentProcess(), si.dwActiveProcessorMask);
    }
#endif


#ifdef __EMX__
    /* This gives wildcard expansion on Non-POSIX shells with OS/2 */
    _wildcard(&argc, &argv);
#endif

    for (i = 0; i < max_nogap; ++i) {
        nogap_inPath[i] = malloc(PATH_MAX + 1);
    }

    memset(inPath, 0, sizeof(inPath));
    
    /* initialize libmp3lame */
    input_format = sf_unknown;
    if (NULL == (gf = lame_init())) {
        fprintf(stderr, "fatal error during initialization\n");
        return 1;
    }
    if (argc <= 1) {
        usage(stderr, argv[0]); /* no command-line args, print usage, exit  */
        return 1;
    }

    /* parse the command line arguments, setting various flags in the
     * struct 'gf'.  If you want to parse your own arguments,
     * or call libmp3lame from a program which uses a GUI to set arguments,
     * skip this call and set the values of interest in the gf struct.
     * (see the file API and lame.h for documentation about these parameters)
     */
    parse_args_from_string(gf, getenv("LAMEOPT"), inPath, outPath);
    ret = parse_args(gf, argc, argv, inPath, outPath, nogap_inPath, &max_nogap);
    if (ret < 0)
        return ret == -2 ? 0 : 1;

    if (update_interval < 0.)
        update_interval = 2.;

    if (outPath[0] != '\0' && max_nogap>0) {
        strncpy(nogapdir, outPath, PATH_MAX + 1);  
        nogapout = 1;
    }
    
    /* initialize input file.  This also sets samplerate and as much
       other data on the input file as available in the headers */
    if (max_nogap > 0) {
        /* for nogap encoding of multiple input files, it is not possible to
         * specify the output file name, only an optional output directory. */
        parse_nogap_filenames(nogapout,nogap_inPath[0],outPath,nogapdir);
        outf = init_files(gf, nogap_inPath[0], outPath);
    }
    else {
        outf = init_files(gf, inPath, outPath);
    }
    if (outf == NULL) {
        return -1;
    }

    /* Now that all the options are set, lame needs to analyze them and
     * set some more internal options and check for problems
     */
    i = lame_init_params(gf);
    if (i < 0) {
        if (i == -1) {
            display_bitrates(stderr);
        }
        fprintf(stderr, "fatal error during initialization\n");
        return i;
    }

    if (silent > 0 
#ifndef RH_HIST   
    || lame_get_VBR(gf) == vbr_off
#endif
    ) {
        brhist = 0;     /* turn off VBR histogram */
    }


    if (lame_get_decode_only(gf)) {
        /* decode an mp3 file to a .wav */
        if (mp3_delay_set)
            lame_decoder(gf, outf, mp3_delay, inPath, outPath);
        else
            lame_decoder(gf, outf, 0, inPath, outPath);

    }
    else {
        if (max_nogap > 0) {
            /*
             * encode multiple input files using nogap option
             */
            for (i = 0; i < max_nogap; ++i) {
                int     use_flush_nogap = (i != (max_nogap - 1));
                if (i > 0) {
                    parse_nogap_filenames(nogapout,nogap_inPath[i],outPath,nogapdir);
                    /* note: if init_files changes anything, like
                       samplerate, num_channels, etc, we are screwed */
                    outf = init_files(gf, nogap_inPath[i], outPath);
                }
                brhist_init_package(gf);
                lame_set_nogap_total(gf, max_nogap);
                lame_set_nogap_currentindex(gf, i);
                ret =
                    lame_encoder(gf, outf, use_flush_nogap, nogap_inPath[i],
                                 outPath);	
                
                if (silent<=0) print_lame_tag_leading_info(gf);
                lame_mp3_tags_fid(gf, outf); /* add VBR tags to mp3 file */
		
                if (silent<=0) print_trailing_info(gf);
                
                fclose(outf); /* close the output file */
                close_infile(); /* close the input file */

                /* reinitialize bitstream for next encoding.  this is normally done
                 * by lame_init_params(), but we cannot call that routine twice */
                if (use_flush_nogap) 
                    lame_init_bitstream(gf);
            }
            lame_close(gf);

        }
        else {
            /*
             * encode a single input file
             */
            brhist_init_package(gf);
            ret = lame_encoder(gf, outf, 0, inPath, outPath);
            
            if (silent<=0) print_lame_tag_leading_info(gf);
            lame_mp3_tags_fid(gf, outf); /* add VBR tags to mp3 file */
	    
            if (silent<=0) print_trailing_info(gf);
            
            fclose(outf); /* close the output file */
            close_infile(); /* close the input file */
            lame_close(gf);
        }
    }
    return ret;
}