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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
lame.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：41k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

lame.c：源码内容
  1. /*
  2.  * LAME MP3 encoding engine
  3.  *
  4.  * Copyright (c) 1999 Mark Taylor
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Library General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Library General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Library General Public
  17.  * License along with this library; if not, write to the
  18.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19.  * Boston, MA 02111-1307, USA.
  20.  */
  23. #include <assert.h>
  25. #ifdef HAVEGTK
  26. #include "gtkanal.h"
  27. #include <gtk/gtk.h>
  28. #endif
  29. #include "lame.h"
  30. #include "util.h"
  31. #include "timestatus.h"
  32. #include "psymodel.h"
  33. #include "newmdct.h"
  34. #include "quantize.h"
  35. #include "quantize-pvt.h"
  36. #include "l3bitstream.h"
  37. #include "formatBitstream.h"
  38. #include "version.h"
  39. #include "VbrTag.h"
  40. #include "id3tag.h"
  41. #include "tables.h"
  42. #include "brhist.h"
  43. #include "get_audio.h"
  45. #ifdef __riscos__
  46. #include "asmstuff.h"
  47. #endif
  50. /* Global variable definitions for lame.c */
  51. static Bit_stream_struc   bs;
  52. static III_side_info_t l3_side;
  53. #define MFSIZE (1152+1152+ENCDELAY-MDCTDELAY)
  54. static short int mfbuf[2][MFSIZE];
  55. static int mf_size;
  56. static int mf_samples_to_encode;
  60. /********************************************************************
  61.  *   initialize internal params based on data in gf
  62.  *   (globalflags struct filled in by calling program)
  63.  *
  64.  ********************************************************************/
  65. void lame_init_params(lame_global_flags *gfp)
  66. {
  67.   int i;
  68.   FLOAT compression_ratio;
  71.   memset(&bs, 0, sizeof(Bit_stream_struc));
  72.   memset(&l3_side,0x00,sizeof(III_side_info_t));
  75.   gfp->frameNum=0;
  76.   InitFormatBitStream();
  77.   if (gfp->num_channels==1) {
  78.     gfp->mode = MPG_MD_MONO;
  79.   }
  80.   gfp->stereo=2;
  81.   if (gfp->mode == MPG_MD_MONO) gfp->stereo=1;
  83. #ifdef BRHIST
  84.   if (gfp->silent) {
  85.     disp_brhist=0;  /* turn of VBR historgram */
  86.   }
  87.   if (!gfp->VBR) {
  88.     disp_brhist=0;  /* turn of VBR historgram */
  89.   }
  90. #endif
  92.   /* set the output sampling rate, and resample options if necessary
  93.      samplerate = input sample rate
  94.      resamplerate = ouput sample rate
  95.   */
  96.   if (gfp->out_samplerate==0) {
  97.     /* user did not specify output sample rate */
  98.     gfp->out_samplerate=gfp->in_samplerate;   /* default */
  101.     /* if resamplerate is not valid, find a valid value */
  102.     if (gfp->out_samplerate>=48000) gfp->out_samplerate=48000;
  103.     else if (gfp->out_samplerate>=44100) gfp->out_samplerate=44100;
  104.     else if (gfp->out_samplerate>=32000) gfp->out_samplerate=32000;
  105.     else if (gfp->out_samplerate>=24000) gfp->out_samplerate=24000;
  106.     else if (gfp->out_samplerate>=22050) gfp->out_samplerate=22050;
  107.     else gfp->out_samplerate=16000;
  110.     if (gfp->brate>0) {
  111.       /* check if user specified bitrate requires downsampling */
  112.       compression_ratio = gfp->out_samplerate*16*gfp->stereo/(1000.0*gfp->brate);
  113.       if (!gfp->VBR && compression_ratio > 13 ) {
  114. /* automatic downsample, if possible */
  115. gfp->out_samplerate = (10*1000.0*gfp->brate)/(16*gfp->stereo);
  116. if (gfp->out_samplerate<=16000) gfp->out_samplerate=16000;
  117. else if (gfp->out_samplerate<=22050) gfp->out_samplerate=22050;
  118. else if (gfp->out_samplerate<=24000) gfp->out_samplerate=24000;
  119. else if (gfp->out_samplerate<=32000) gfp->out_samplerate=32000;
  120. else if (gfp->out_samplerate<=44100) gfp->out_samplerate=44100;
  121. else gfp->out_samplerate=48000;
  122.       }
  123.     }
  124.   }
  126.   gfp->mode_gr = (gfp->out_samplerate <= 24000) ? 1 : 2;  /* mode_gr = 2 */
  127.   gfp->encoder_delay = ENCDELAY;
  128.   gfp->framesize = gfp->mode_gr*576;
  130.   if (gfp->brate==0) { /* user didn't specify a bitrate, use default */
  131.     gfp->brate=128;
  132.     if (gfp->mode_gr==1) gfp->brate=64;
  133.   }
  136.   gfp->resample_ratio=1;
  137.   if (gfp->out_samplerate != gfp->in_samplerate) gfp->resample_ratio = (FLOAT)gfp->in_samplerate/(FLOAT)gfp->out_samplerate;
  139.   /* estimate total frames.  must be done after setting sampling rate so
  140.    * we know the framesize.  */
  141.   gfp->totalframes=0;
  142.   gfp->totalframes = 2+ gfp->num_samples/(gfp->resample_ratio*gfp->framesize);
  146.   /* 44.1kHz at 56kbs/channel: compression factor of 12.6
  147.      44.1kHz at 64kbs/channel: compression factor of 11.025
  148.      44.1kHz at 80kbs/channel: compression factor of 8.82
  149.      22.05kHz at 24kbs:  14.7
  150.      22.05kHz at 32kbs:  11.025
  151.      22.05kHz at 40kbs:  8.82
  152.      16kHz at 16kbs:  16.0
  153.      16kHz at 24kbs:  10.7
  155.      compression_ratio
  156.         11                                .70?
  157.         12                   sox resample .66
  158.         14.7                 sox resample .45
  160.   */
  161.   if (gfp->brate >= 320) gfp->VBR=0;  /* dont bother with VBR at 320kbs */
  162.   compression_ratio = gfp->out_samplerate*16*gfp->stereo/(1000.0*gfp->brate);
  165.   /* for VBR, take a guess at the compression_ratio */
  166.   /* VBR_q           compression       like
  167.      0                4.4             320kbs
  168.      1                5.4             256kbs
  169.      3                7.4             192kbs
  170.      4                8.8             160kbs
  171.      6                10.4            128kbs
  172.   */
  173.   if (gfp->VBR && compression_ratio>11) {
  174.     compression_ratio = 4.4 + gfp->VBR_q;
  175.   }
  178.   /* At higher quality (lower compression) use STEREO instead of JSTEREO.
  179.    * (unless the user explicitly specified a mode ) */
  180.   if ( (!gfp->mode_fixed) && (gfp->mode !=MPG_MD_MONO)) {
  181.     if (compression_ratio < 9 ) {
  182.       gfp->mode = MPG_MD_STEREO;
  183.     }
  184.   }
  188.   /****************************************************************/
  189.   /* if a filter has not been enabled, see if we should add one: */
  190.   /****************************************************************/
  191.   if (gfp->lowpassfreq == 0) {
  192.     /* If the user has not selected their own filter, add a lowpass
  193.      * filter based on the compression ratio.  Formula based on
  194.           44.1   /160    4.4x
  195.           44.1   /128    5.5x      keep all bands
  196.           44.1   /96kbs  7.3x      keep band 28
  197.           44.1   /80kbs  8.8x      keep band 25
  198.           44.1khz/64kbs  11x       keep band 21  22?
  200.   16khz/24kbs  10.7x       keep band 21
  201.   22kHz/32kbs  11x         keep band ?
  202.   22kHz/24kbs  14.7x       keep band 16
  203.           16    16     16x         keep band 14
  204.     */
  207.     /* Should we use some lowpass filters? */
  208.     int band = 1+floor(.5 + 14-18*log(compression_ratio/16.0));
  209.     if (band < 31) {
  210.       gfp->lowpass1 = band/31.0;
  211.       gfp->lowpass2 = band/31.0;
  212.     }
  213.   }
  215.   /****************************************************************/
  216.   /* apply user driven filters*/
  217.   /****************************************************************/
  218.   if ( gfp->highpassfreq > 0 ) {
  219.     gfp->highpass1 = 2.0*gfp->highpassfreq/gfp->out_samplerate; /* will always be >=0 */
  220.     if ( gfp->highpasswidth >= 0 ) {
  221.       gfp->highpass2 = 2.0*(gfp->highpassfreq+gfp->highpasswidth)/gfp->out_samplerate;
  222.     } else {
  223.       /* 15% above on default */
  224.       /* gfp->highpass2 = 1.15*2.0*gfp->highpassfreq/gfp->out_samplerate;  */
  225.       gfp->highpass2 = 1.00*2.0*gfp->highpassfreq/gfp->out_samplerate; 
  226.     }
  227.     gfp->highpass1 = Min( 1, gfp->highpass1 );
  228.     gfp->highpass2 = Min( 1, gfp->highpass2 );
  229.   }
  231.   if ( gfp->lowpassfreq > 0 ) {
  232.     gfp->lowpass2 = 2.0*gfp->lowpassfreq/gfp->out_samplerate; /* will always be >=0 */
  233.     if ( gfp->lowpasswidth >= 0 ) {
  234.       gfp->lowpass1 = 2.0*(gfp->lowpassfreq-gfp->lowpasswidth)/gfp->out_samplerate;
  235.       if ( gfp->lowpass1 < 0 ) { /* has to be >= 0 */
  236. gfp->lowpass1 = 0;
  237.       }
  238.     } else {
  239.       /* 15% below on default */
  240.       /* gfp->lowpass1 = 0.85*2.0*gfp->lowpassfreq/gfp->out_samplerate;  */
  241.       gfp->lowpass1 = 1.00*2.0*gfp->lowpassfreq/gfp->out_samplerate;
  242.     }
  243.     gfp->lowpass1 = Min( 1, gfp->lowpass1 );
  244.     gfp->lowpass2 = Min( 1, gfp->lowpass2 );
  245.   }
  248.   /***************************************************************/
  249.   /* compute info needed for polyphase filter                    */
  250.   /***************************************************************/
  251.   if (gfp->filter_type==0) {
  252.     int band,maxband,minband;
  253.     FLOAT8 amp,freq;
  254.     if (gfp->lowpass1 > 0) {
  255.       minband=999;
  256.       maxband=-1;
  257.       for (band=0;  band <=31 ; ++band) { 
  258. freq = band/31.0;
  259. amp = 1;
  260. /* this band and above will be zeroed: */
  261. if (freq >= gfp->lowpass2) {
  262.   gfp->lowpass_band= Min(gfp->lowpass_band,band);
  263.   amp=0;
  264. }
  265. if (gfp->lowpass1 < freq && freq < gfp->lowpass2) {
  266.           minband = Min(minband,band);
  267.           maxband = Max(maxband,band);
  268.   amp = cos((PI/2)*(gfp->lowpass1-freq)/(gfp->lowpass2-gfp->lowpass1));
  269. }
  270. /* printf("lowpass band=%i  amp=%f n",band,amp);*/
  271.       }
  272.       /* compute the *actual* transition band implemented by the polyphase filter */
  273.       if (minband==999) gfp->lowpass1 = (gfp->lowpass_band-.75)/31.0;
  274.       else gfp->lowpass1 = (minband-.75)/31.0;
  275.       gfp->lowpass2 = gfp->lowpass_band/31.0;
  276.     }
  278.     /* make sure highpass filter is within 90% of whan the effective highpass
  279.      * frequency will be */
  280.     if (gfp->highpass2 > 0) 
  281.       if (gfp->highpass2 <  .9*(.75/31.0) ) {
  282. gfp->highpass1=0; gfp->highpass2=0;
  283. fprintf(stderr,"Warning: highpass filter disabled.  highpass frequency to smalln");
  284.       }
  285.     
  287.     if (gfp->highpass2 > 0) {
  288.       minband=999;
  289.       maxband=-1;
  290.       for (band=0;  band <=31; ++band) { 
  291. freq = band/31.0;
  292. amp = 1;
  293. /* this band and below will be zereod */
  294. if (freq <= gfp->highpass1) {
  295.   gfp->highpass_band = Max(gfp->highpass_band,band);
  296.   amp=0;
  297. }
  298. if (gfp->highpass1 < freq && freq < gfp->highpass2) {
  299.           minband = Min(minband,band);
  300.           maxband = Max(maxband,band);
  301.   amp = cos((PI/2)*(gfp->highpass2-freq)/(gfp->highpass2-gfp->highpass1));
  302. }
  303. /* printf("highpass band=%i  amp=%f n",band,amp);*/
  304.       }
  305.       /* compute the *actual* transition band implemented by the polyphase filter */
  306.       gfp->highpass1 = gfp->highpass_band/31.0;
  307.       if (maxband==-1) gfp->highpass2 = (gfp->highpass_band+.75)/31.0;
  308.       else gfp->highpass2 = (maxband+.75)/31.0;
  309.     }
  310.     /*
  311.     printf("lowpass band with amp=0:  %i n",gfp->lowpass_band);
  312.     printf("highpass band with amp=0:  %i n",gfp->highpass_band);
  313.     */
  314.   }
  318.   /***************************************************************/
  319.   /* compute info needed for FIR filter */
  320.   /***************************************************************/
  321.   if (gfp->filter_type==1) {
  322.   }
  327.   gfp->mode_ext=MPG_MD_LR_LR;
  328.   gfp->stereo = (gfp->mode == MPG_MD_MONO) ? 1 : 2;
  331.   gfp->samplerate_index = SmpFrqIndex((long)gfp->out_samplerate, &gfp->version);
  332.   if( gfp->samplerate_index < 0) {
  333.     display_bitrates(stderr);
  334.     exit(1);
  335.   }
  336.   if( (gfp->bitrate_index = BitrateIndex(gfp->brate, gfp->version,gfp->out_samplerate)) < 0) {
  337.     display_bitrates(stderr);
  338.     exit(1);
  339.   }
  342.   /* choose a min/max bitrate for VBR */
  343.   if (gfp->VBR) {
  344.     /* if the user didn't specify VBR_max_bitrate: */
  345.     if (0==gfp->VBR_max_bitrate_kbps) {
  346.       /* default max bitrate is 256kbs */
  347.       /* we do not normally allow 320bps frams with VBR, unless: */
  348.       gfp->VBR_max_bitrate=13;   /* default: allow 256kbs */
  349.       if (gfp->VBR_min_bitrate_kbps>=256) gfp->VBR_max_bitrate=14;
  350.       if (gfp->VBR_q == 0) gfp->VBR_max_bitrate=14;   /* allow 320kbs */
  351.       if (gfp->VBR_q >= 4) gfp->VBR_max_bitrate=12;   /* max = 224kbs */
  352.       if (gfp->VBR_q >= 8) gfp->VBR_max_bitrate=9;    /* low quality, max = 128kbs */
  353.     }else{
  354.       if( (gfp->VBR_max_bitrate  = BitrateIndex(gfp->VBR_max_bitrate_kbps, gfp->version,gfp->out_samplerate)) < 0) {
  355. display_bitrates(stderr);
  356. exit(1);
  357.       }
  358.     }
  359.     if (0==gfp->VBR_min_bitrate_kbps) {
  360.       gfp->VBR_min_bitrate=1;  /* 32 kbps */
  361.     }else{
  362.       if( (gfp->VBR_min_bitrate  = BitrateIndex(gfp->VBR_min_bitrate_kbps, gfp->version,gfp->out_samplerate)) < 0) {
  363. display_bitrates(stderr);
  364. exit(1);
  365.       }
  366.     }
  368.   }
  371.   if (gfp->VBR) gfp->quality=Min(gfp->quality,2);    /* always use quality <=2  with VBR */
  372.   /* dont allow forced mid/side stereo for mono output */
  373.   if (gfp->mode == MPG_MD_MONO) gfp->force_ms=0;
  376.   /* Do not write VBR tag if VBR flag is not specified */
  377.   if (gfp->VBR==0) gfp->bWriteVbrTag=0;
  379.   /* some file options not allowed if output is: not specified or stdout */
  381.   if (gfp->outPath!=NULL && gfp->outPath[0]=='-' ) {
  382.     gfp->bWriteVbrTag=0; /* turn off VBR tag */
  383.   }
  385.   if (gfp->outPath==NULL || gfp->outPath[0]=='-' ) {
  386.     id3tag.used=0;         /* turn of id3 tagging */
  387.   }
  391.   if (gfp->gtkflag) {
  392.     gfp->bWriteVbrTag=0;  /* disable Xing VBR tag */
  393.   }
  395.   init_bit_stream_w(&bs);
  399.   /* set internal feature flags.  USER should not access these since
  400.    * some combinations will produce strange results */
  402.   /* no psymodel, no noise shaping */
  403.   if (gfp->quality==9) {
  404.     gfp->filter_type=0;
  405.     gfp->psymodel=0;
  406.     gfp->quantization=0;
  407.     gfp->noise_shaping=0;
  408.     gfp->noise_shaping_stop=0;
  409.     gfp->use_best_huffman=0;
  410.   }
  412.   if (gfp->quality==8) gfp->quality=7;
  414.   /* use psymodel (for short block and m/s switching), but no noise shapping */
  415.   if (gfp->quality==7) {
  416.     gfp->filter_type=0;
  417.     gfp->psymodel=1;
  418.     gfp->quantization=0;
  419.     gfp->noise_shaping=0;
  420.     gfp->noise_shaping_stop=0;
  421.     gfp->use_best_huffman=0;
  422.   }
  424.   if (gfp->quality==6) gfp->quality=5;
  426.   if (gfp->quality==5) {
  427.     /* the default */
  428.     gfp->filter_type=0;
  429.     gfp->psymodel=1;
  430.     gfp->quantization=0;
  431.     gfp->noise_shaping=1;
  432.     gfp->noise_shaping_stop=0;
  433.     gfp->use_best_huffman=0;
  434.   }
  436.   if (gfp->quality==4) gfp->quality=2;
  437.   if (gfp->quality==3) gfp->quality=2;
  439.   if (gfp->quality==2) {
  440.     gfp->filter_type=0;
  441.     gfp->psymodel=1;
  442.     gfp->quantization=1;
  443.     gfp->noise_shaping=1;
  444.     gfp->noise_shaping_stop=0;
  445.     gfp->use_best_huffman=1;
  446.   }
  448.   if (gfp->quality==1) {
  449.     gfp->filter_type=0;
  450.     gfp->psymodel=1;
  451.     gfp->quantization=1;
  452.     gfp->noise_shaping=1;
  453.     gfp->noise_shaping_stop=1;
  454.     gfp->use_best_huffman=1;
  455.   }
  457.   if (gfp->quality==0) {
  458.     /* 0..1 quality */
  459.     gfp->filter_type=1;         /* not yet coded */
  460.     gfp->psymodel=1;
  461.     gfp->quantization=1;
  462.     gfp->noise_shaping=3;       /* not yet coded */
  463.     gfp->noise_shaping_stop=2;  /* not yet coded */
  464.     gfp->use_best_huffman=2;   /* not yet coded */
  465.     exit(-99);
  466.   }
  469.   for (i = 0; i < SBMAX_l + 1; i++) {
  470.     scalefac_band.l[i] =
  471.       sfBandIndex[gfp->samplerate_index + (gfp->version * 3)].l[i];
  472.   }
  473.   for (i = 0; i < SBMAX_s + 1; i++) {
  474.     scalefac_band.s[i] =
  475.       sfBandIndex[gfp->samplerate_index + (gfp->version * 3)].s[i];
  476.   }
  480.   if (gfp->bWriteVbrTag)
  481.     {
  482.       /* Write initial VBR Header to bitstream */
  483.       InitVbrTag(&bs,1-gfp->version,gfp->mode,gfp->samplerate_index);
  484.     }
  486. #ifdef HAVEGTK
  487.   gtkflag=gfp->gtkflag;
  488. #endif
  490. #ifdef BRHIST
  491.   if (gfp->VBR) {
  492.     if (disp_brhist)
  493.       brhist_init(gfp,1, 14);
  494.   } else
  495.     disp_brhist = 0;
  496. #endif
  497.   return;
  498. }
  508. /************************************************************************
  509.  *
  510.  * print_config
  511.  *
  512.  * PURPOSE:  Prints the encoding parameters used
  513.  *
  514.  ************************************************************************/
  515. void lame_print_config(lame_global_flags *gfp)
  516. {
  517.   static const char *mode_names[4] = { "stereo", "j-stereo", "dual-ch", "single-ch" };
  518.   FLOAT out_samplerate=gfp->out_samplerate/1000.0;
  519.   FLOAT in_samplerate = gfp->resample_ratio*out_samplerate;
  520.   FLOAT compression=
  521.     (FLOAT)(gfp->stereo*16*out_samplerate)/(FLOAT)(gfp->brate);
  523.   lame_print_version(stderr);
  524.   if (gfp->num_channels==2 && gfp->stereo==1) {
  525.     fprintf(stderr, "Autoconverting from stereo to mono. Setting encoding to mono mode.n");
  526.   }
  527.   if (gfp->resample_ratio!=1) {
  528.     fprintf(stderr,"Resampling:  input=%ikHz  output=%ikHzn",
  529.     (int)in_samplerate,(int)out_samplerate);
  530.   }
  531.   if (gfp->highpass2>0.0)
  532.     fprintf(stderr, "Using polyphase highpass filter, transition band: %.0f Hz -  %.0f Hzn",
  533.     gfp->highpass1*out_samplerate*500,
  534.     gfp->highpass2*out_samplerate*500);
  535.   if (gfp->lowpass1>0.0)
  536.     fprintf(stderr, "Using polyphase lowpass filter,  transition band:  %.0f Hz - %.0f Hzn",
  537.     gfp->lowpass1*out_samplerate*500,
  538.     gfp->lowpass2*out_samplerate*500);
  540.   if (gfp->gtkflag) {
  541.     fprintf(stderr, "Analyzing %s n",gfp->inPath);
  542.   }
  543.   else {
  544.     fprintf(stderr, "Encoding %s to %sn",
  545.     (strcmp(gfp->inPath, "-")? gfp->inPath : "stdin"),
  546.     (strcmp(gfp->outPath, "-")? gfp->outPath : "stdout"));
  547.     if (gfp->VBR)
  548.       fprintf(stderr, "Encoding as %.1fkHz VBR(q=%i) %s MPEG%i LayerIII  qval=%in",
  549.       gfp->out_samplerate/1000.0,
  550.       gfp->VBR_q,mode_names[gfp->mode],2-gfp->version,gfp->quality);
  551.     else
  552.       fprintf(stderr, "Encoding as %.1f kHz %d kbps %s MPEG%i LayerIII (%4.1fx)  qval=%in",
  553.       gfp->out_samplerate/1000.0,gfp->brate,
  554.       mode_names[gfp->mode],2-gfp->version,compression,gfp->quality);
  555.   }
  556.   fflush(stderr);
  557. }
  570. /************************************************************************
  571. *
  572. * encodeframe()           Layer 3
  573. *
  574. * encode a single frame
  575. *
  576. ************************************************************************
  577. lame_encode_frame()
  580.                        gr 0            gr 1
  581. inbuf:           |--------------|---------------|-------------|
  582. MDCT output:  |--------------|---------------|-------------|
  584. FFT's                    <---------1024---------->
  585.                                          <---------1024-------->
  589.     inbuf = buffer of PCM data size=MP3 framesize
  590.     encoder acts on inbuf[ch][0], but output is delayed by MDCTDELAY
  591.     so the MDCT coefficints are from inbuf[ch][-MDCTDELAY]
  593.     psy-model FFT has a 1 granule day, so we feed it data for the next granule.
  594.     FFT is centered over granule:  224+576+224
  595.     So FFT starts at:   576-224-MDCTDELAY
  597.     MPEG2:  FFT ends at:  BLKSIZE+576-224-MDCTDELAY
  598.     MPEG1:  FFT ends at:  BLKSIZE+2*576-224-MDCTDELAY    (1904)
  600.     FFT starts at 576-224-MDCTDELAY (304)  = 576-FFTOFFSET
  602. */
  603. int lame_encode_frame(lame_global_flags *gfp,
  604. short int inbuf_l[],short int inbuf_r[],
  605. int mf_size,char *mp3buf, int mp3buf_size)
  606. {
  607.   static unsigned long frameBits;
  608.   static unsigned long bitsPerSlot;
  609.   static FLOAT8 frac_SpF;
  610.   static FLOAT8 slot_lag;
  611.   static unsigned long sentBits = 0;
  612.   FLOAT8 xr[2][2][576];
  613.   int l3_enc[2][2][576];
  614.   int mp3count;
  615.   III_psy_ratio masking_ratio[2][2];    /*LR ratios */
  616.   III_psy_ratio masking_MS_ratio[2][2]; /*MS ratios */
  617.   III_psy_ratio (*masking)[2][2];  /*LR ratios and MS ratios*/
  618.   III_scalefac_t scalefac[2][2];
  619.   short int *inbuf[2];
  621.   typedef FLOAT8 pedata[2][2];
  622.   pedata pe,pe_MS;
  623.   pedata *pe_use;
  625.   int ch,gr,mean_bits;
  626.   int bitsPerFrame;
  628.   int check_ms_stereo;
  629.   static FLOAT8 ms_ratio[2]={0,0};
  630.   FLOAT8 ms_ratio_next=0;
  631.   FLOAT8 ms_ratio_prev=0;
  632.   static FLOAT8 ms_ener_ratio[2]={0,0};
  634.   memset((char *) masking_ratio, 0, sizeof(masking_ratio));
  635.   memset((char *) masking_MS_ratio, 0, sizeof(masking_MS_ratio));
  636.   memset((char *) scalefac, 0, sizeof(scalefac));
  637.   inbuf[0]=inbuf_l;
  638.   inbuf[1]=inbuf_r;
  640.   gfp->mode_ext = MPG_MD_LR_LR;
  642.   if (gfp->frameNum==0 )  {
  643.     /* Figure average number of 'slots' per frame. */
  644.     FLOAT8 avg_slots_per_frame;
  645.     FLOAT8 sampfreq =   gfp->out_samplerate/1000.0;
  646.     int bit_rate = gfp->brate;
  647.     sentBits = 0;
  648.     bitsPerSlot = 8;
  649.     avg_slots_per_frame = (bit_rate*gfp->framesize) /
  650.            (sampfreq* bitsPerSlot);
  651.     /* -f fast-math option causes some strange rounding here, be carefull: */
  652.     frac_SpF  = avg_slots_per_frame - floor(avg_slots_per_frame + 1e-9);
  653.     if (fabs(frac_SpF) < 1e-9) frac_SpF = 0;
  655.     slot_lag  = -frac_SpF;
  656.     gfp->padding = 1;
  657.     if (frac_SpF==0) gfp->padding = 0;
  658.     /* check FFT will not use a negative starting offset */
  659.     assert(576>=FFTOFFSET);
  660.     /* check if we have enough data for FFT */
  661.     assert(mf_size>=(BLKSIZE+gfp->framesize-FFTOFFSET));
  662.   }
  665.   /********************** padding *****************************/
  666.   switch (gfp->padding_type) {
  667.   case 0:
  668.     gfp->padding=0;
  669.     break;
  670.   case 1:
  671.     gfp->padding=1;
  672.     break;
  673.   case 2:
  674.   default:
  675.     if (gfp->VBR) {
  676.       gfp->padding=0;
  677.     } else {
  678.       if (gfp->disable_reservoir) {
  679. gfp->padding = 0;
  680. /* if the user specified --nores, dont very gfp->padding either */
  681. /* tiny changes in frac_SpF rounding will cause file differences */
  682.       }else{
  683. if (frac_SpF != 0) {
  684.   if (slot_lag > (frac_SpF-1.0) ) {
  685.     slot_lag -= frac_SpF;
  686.     gfp->padding = 0;
  687.   }
  688.   else {
  689.     gfp->padding = 1;
  690.     slot_lag += (1-frac_SpF);
  691.   }
  692. }
  693.       }
  694.     }
  695.   }
  698.   /********************** status display  *****************************/
  699.   if (!gfp->gtkflag && !gfp->silent) {
  700.     int mod = gfp->version == 0 ? 200 : 50;
  701.     if (gfp->frameNum%mod==0) {
  702.       timestatus(gfp->out_samplerate,gfp->frameNum,gfp->totalframes,gfp->framesize);
  703. #ifdef BRHIST
  704.       if (disp_brhist)
  705. {
  706.   brhist_add_count();
  707.   brhist_disp();
  708. }
  709. #endif
  710.     }
  711.   }
  714.   if (gfp->psymodel) {
  715.     /* psychoacoustic model
  716.      * psy model has a 1 granule (576) delay that we must compensate for
  717.      * (mt 6/99).
  718.      */
  719.     short int *bufp[2];  /* address of beginning of left & right granule */
  720.     int blocktype[2];
  722.     ms_ratio_prev=ms_ratio[gfp->mode_gr-1];
  723.     for (gr=0; gr < gfp->mode_gr ; gr++) {
  725.       for ( ch = 0; ch < gfp->stereo; ch++ )
  726. bufp[ch] = &inbuf[ch][576 + gr*576-FFTOFFSET];
  728.       L3psycho_anal( gfp,bufp, gr, 
  729.      &ms_ratio[gr],&ms_ratio_next,&ms_ener_ratio[gr],
  730.      masking_ratio, masking_MS_ratio,
  731.      pe[gr],pe_MS[gr],blocktype);
  733.       for ( ch = 0; ch < gfp->stereo; ch++ )
  734. l3_side.gr[gr].ch[ch].tt.block_type=blocktype[ch];
  736.     }
  737.   }else{
  738.     for (gr=0; gr < gfp->mode_gr ; gr++)
  739.       for ( ch = 0; ch < gfp->stereo; ch++ ) {
  740. l3_side.gr[gr].ch[ch].tt.block_type=NORM_TYPE;
  741. pe[gr][ch]=700;
  742.       }
  743.   }
  746.   /* block type flags */
  747.   for( gr = 0; gr < gfp->mode_gr; gr++ ) {
  748.     for ( ch = 0; ch < gfp->stereo; ch++ ) {
  749.       gr_info *cod_info = &l3_side.gr[gr].ch[ch].tt;
  750.       cod_info->mixed_block_flag = 0;     /* never used by this model */
  751.       if (cod_info->block_type == NORM_TYPE )
  752. cod_info->window_switching_flag = 0;
  753.       else
  754. cod_info->window_switching_flag = 1;
  755.     }
  756.   }
  758.   /* polyphase filtering / mdct */
  759.   mdct_sub48(gfp,inbuf[0], inbuf[1], xr, &l3_side);
  761.   /* use m/s gfp->stereo? */
  762.   check_ms_stereo =  (gfp->mode == MPG_MD_JOINT_STEREO);
  763.   if (check_ms_stereo) {
  764.     /* make sure block type is the same in each channel */
  765.     check_ms_stereo =
  766.       (l3_side.gr[0].ch[0].tt.block_type==l3_side.gr[0].ch[1].tt.block_type) &&
  767.       (l3_side.gr[1].ch[0].tt.block_type==l3_side.gr[1].ch[1].tt.block_type);
  768.   }
  769.   if (check_ms_stereo) {
  770.     /* ms_ratio = is like the ratio of side_energy/total_energy */
  771.     FLOAT8 ms_ratio_ave,ms_ener_ratio_ave;
  772.     /*     ms_ratio_ave = .5*(ms_ratio[0] + ms_ratio[1]);*/
  773.     ms_ratio_ave = .25*(ms_ratio[0] + ms_ratio[1]+
  774.  ms_ratio_prev + ms_ratio_next);
  775.     ms_ener_ratio_ave = .5*(ms_ener_ratio[0]+ms_ener_ratio[1]);
  776.     if ( ms_ratio_ave <.35 /*&& ms_ener_ratio_ave<.75*/ ) gfp->mode_ext = MPG_MD_MS_LR;
  777.   }
  778.   if (gfp->force_ms) gfp->mode_ext = MPG_MD_MS_LR;
  781. #ifdef HAVEGTK
  782.   if (gfp->gtkflag) {
  783.     int j;
  784.     for ( gr = 0; gr < gfp->mode_gr; gr++ ) {
  785.       for ( ch = 0; ch < gfp->stereo; ch++ ) {
  786. pinfo->ms_ratio[gr]=ms_ratio[gr];
  787. pinfo->ms_ener_ratio[gr]=ms_ener_ratio[gr];
  788. pinfo->blocktype[gr][ch]=
  789.   l3_side.gr[gr].ch[ch].tt.block_type;
  790. for ( j = 0; j < 576; j++ ) pinfo->xr[gr][ch][j]=xr[gr][ch][j];
  791. /* if MS stereo, switch to MS psy data */
  792. if (gfp->mode_ext==MPG_MD_MS_LR) {
  793.   pinfo->pe[gr][ch]=pinfo->pe[gr][ch+2];
  794.   pinfo->ers[gr][ch]=pinfo->ers[gr][ch+2];
  795.   memcpy(pinfo->energy[gr][ch],pinfo->energy[gr][ch+2],
  796.  sizeof(pinfo->energy[gr][ch]));
  797. }
  798.       }
  799.     }
  800.   }
  801. #endif
  806.   /* bit and noise allocation */
  807.   if (MPG_MD_MS_LR == gfp->mode_ext) {
  808.     masking = &masking_MS_ratio;    /* use MS masking */
  809.     pe_use=&pe_MS;
  810.   } else {
  811.     masking = &masking_ratio;    /* use LR masking */
  812.     pe_use=&pe;
  813.   }
  816.   /*
  817.   VBR_iteration_loop_new( gfp,*pe_use, ms_ratio, xr, masking, &l3_side, l3_enc,
  818.      &scalefac);
  819.   */
  822.   if (gfp->VBR) {
  823.     VBR_iteration_loop( gfp,*pe_use, ms_ratio, xr, *masking, &l3_side, l3_enc,
  824. scalefac);
  825.   }else{
  826.     iteration_loop( gfp,*pe_use, ms_ratio, xr, *masking, &l3_side, l3_enc,
  827.     scalefac);
  828.   }
  833. #ifdef BRHIST
  834.   brhist_temp[gfp->bitrate_index]++;
  835. #endif
  838.   /*  write the frame to the bitstream  */
  839.   getframebits(gfp,&bitsPerFrame,&mean_bits);
  840.   III_format_bitstream( gfp,bitsPerFrame, l3_enc, &l3_side,
  841. scalefac, &bs);
  844.   frameBits = bs.totbit - sentBits;
  847.   if ( frameBits % bitsPerSlot )   /* a program failure */
  848.     fprintf( stderr, "Sent %ld bits = %ld slots plus %ldn",
  849.      frameBits, frameBits/bitsPerSlot,
  850.      frameBits%bitsPerSlot );
  851.   sentBits += frameBits;
  853.   /* copy mp3 bit buffer into array */
  854.   mp3count = copy_buffer(mp3buf,mp3buf_size,&bs);
  856.   if (gfp->bWriteVbrTag) AddVbrFrame((int)(sentBits/8));
  858. #ifdef HAVEGTK
  859.   if (gfp->gtkflag) {
  860.     int j;
  861.     for ( ch = 0; ch < gfp->stereo; ch++ ) {
  862.       for ( j = 0; j < FFTOFFSET; j++ )
  863. pinfo->pcmdata[ch][j] = pinfo->pcmdata[ch][j+gfp->framesize];
  864.       for ( j = FFTOFFSET; j < 1600; j++ ) {
  865. pinfo->pcmdata[ch][j] = inbuf[ch][j-FFTOFFSET];
  866.       }
  867.     }
  868.   }
  869. #endif
  870.   gfp->frameNum++;
  872.   return mp3count;
  873. }
  877. int fill_buffer_resample(lame_global_flags *gfp,short int *outbuf,int desired_len,
  878.         short int *inbuf,int len,int *num_used,int ch) {
  880.   static FLOAT8 itime[2];
  881. #define OLDBUFSIZE 5
  882.   static short int inbuf_old[2][OLDBUFSIZE];
  883.   static int init[2]={0,0};
  884.   int i,j=0,k,linear,value;
  886.   if (gfp->frameNum==0 && !init[ch]) {
  887.     init[ch]=1;
  888.     itime[ch]=0;
  889.     memset((char *) inbuf_old[ch], 0, sizeof(short int)*OLDBUFSIZE);
  890.   }
  891.   if (gfp->frameNum!=0) init[ch]=0; /* reset, for next time framenum=0 */
  894.   /* if downsampling by an integer multiple, use linear resampling,
  895.    * otherwise use quadratic */
  896.   linear = ( fabs(gfp->resample_ratio - floor(.5+gfp->resample_ratio)) < .0001 );
  898.   /* time of j'th element in inbuf = itime + j/ifreq; */
  899.   /* time of k'th element in outbuf   =  j/ofreq */
  900.   for (k=0;k<desired_len;k++) {
  901.     int y0,y1,y2,y3;
  902.     FLOAT8 x0,x1,x2,x3;
  903.     FLOAT8 time0;
  905.     time0 = k*gfp->resample_ratio;       /* time of k'th output sample */
  906.     j = floor( time0 -itime[ch]  );
  907.     /* itime[ch] + j;    */            /* time of j'th input sample */
  908.     if (j+2 >= len) break;             /* not enough data in input buffer */
  910.     x1 = time0-(itime[ch]+j);
  911.     x2 = x1-1;
  912.     y1 = (j<0) ? inbuf_old[ch][OLDBUFSIZE+j] : inbuf[j];
  913.     y2 = ((1+j)<0) ? inbuf_old[ch][OLDBUFSIZE+1+j] : inbuf[1+j];
  915.     /* linear resample */
  916.     if (linear) {
  917.       outbuf[k] = floor(.5 +  (y2*x1-y1*x2) );
  918.     } else {
  919.       /* quadratic */
  920.       x0 = x1+1;
  921.       x3 = x1-2;
  922.       y0 = ((j-1)<0) ? inbuf_old[ch][OLDBUFSIZE+(j-1)] : inbuf[j-1];
  923.       y3 = ((j+2)<0) ? inbuf_old[ch][OLDBUFSIZE+(j+2)] : inbuf[j+2];
  924.       value = floor(.5 +
  925. -y0*x1*x2*x3/6 + y1*x0*x2*x3/2 - y2*x0*x1*x3/2 +y3*x0*x1*x2/6
  926. );
  927.       if (value > 32767) outbuf[k]=32767;
  928.       else if (value < -32767) outbuf[k]=-32767;
  929.       else outbuf[k]=value;
  931.       /*
  932.       printf("k=%i  new=%i   [ %i %i %i %i ]n",k,outbuf[k],
  933.      y0,y1,y2,y3);
  934.       */
  935.     }
  936.   }
  939.   /* k = number of samples added to outbuf */
  940.   /* last k sample used data from j,j+1, or j+1 overflowed buffer */
  941.   /* remove num_used samples from inbuf: */
  942.   *num_used = Min(len,j+2);
  943.   itime[ch] += *num_used - k*gfp->resample_ratio;
  944.   for (i=0;i<OLDBUFSIZE;i++)
  945.     inbuf_old[ch][i]=inbuf[*num_used + i -OLDBUFSIZE];
  946.   return k;
  947. }
  952. int fill_buffer(lame_global_flags *gfp,short int *outbuf,int desired_len,short int *inbuf,int len) {
  953.   int j;
  954.   j=Min(desired_len,len);
  955.   memcpy( (char *) outbuf,(char *)inbuf,sizeof(short int)*j);
  956.   return j;
  957. }
  962. /*
  963.  * THE MAIN LAME ENCODING INTERFACE
  964.  * mt 3/00
  965.  *
  966.  * input pcm data, output (maybe) mp3 frames.
  967.  * This routine handles all buffering, resampling and filtering for you.
  968.  * The required mp3buffer_size can be computed from num_samples,
  969.  * samplerate and encoding rate, but here is a worst case estimate:
  970.  *
  971.  * mp3buffer_size in bytes = 1.25*num_samples + 7200
  972.  *
  973.  * return code = number of bytes output in mp3buffer.  can be 0
  974. */
  975. int lame_encode_buffer(lame_global_flags *gfp,
  976.    short int buffer_l[], short int buffer_r[],int nsamples,
  977.    char *mp3buf, int mp3buf_size)
  978. {
  979.   static int frame_buffered=0;
  980.   int mp3size=0,ret,i,ch,mf_needed;
  982.   short int *in_buffer[2];
  983.   in_buffer[0] = buffer_l;
  984.   in_buffer[1] = buffer_r;
  986.   /* some sanity checks */
  987.   assert(ENCDELAY>=MDCTDELAY);
  988.   assert(BLKSIZE-FFTOFFSET >= 0);
  989.   mf_needed = BLKSIZE+gfp->framesize-FFTOFFSET;
  990.   assert(MFSIZE>=mf_needed);
  992.   /* The reason for
  993.    *       int mf_samples_to_encode = ENCDELAY + 288;
  994.    * ENCDELAY = internal encoder delay.  And then we have to add 288
  995.    * because of the 50% MDCT overlap.  A 576 MDCT granule decodes to
  996.    * 1152 samples.  To synthesize the 576 samples centered under this granule
  997.    * we need the previous granule for the first 288 samples (no problem), and
  998.    * the next granule for the next 288 samples (not possible if this is last
  999.    * granule).  So we need to pad with 288 samples to make sure we can
  1000.    * encode the 576 samples we are interested in.
  1001.    */
  1002.   if (gfp->frameNum==0 && !frame_buffered) {
  1003.     memset((char *) mfbuf, 0, sizeof(mfbuf));
  1004.     frame_buffered=1;
  1005.     mf_samples_to_encode = ENCDELAY+288;
  1006.     mf_size=ENCDELAY-MDCTDELAY;  /* we pad input with this many 0's */
  1007.   }
  1008.   if (gfp->frameNum==1) {
  1009.     /* reset, for the next time frameNum==0 */
  1010.     frame_buffered=0;
  1011.   }
  1013.   if (gfp->num_channels==2  && gfp->stereo==1) {
  1014.     /* downsample to mono */
  1015.     for (i=0; i<nsamples; ++i) {
  1016.       in_buffer[0][i]=((int)in_buffer[0][i]+(int)in_buffer[1][i])/2;
  1017.       in_buffer[1][i]=0;
  1018.     }
  1019.   }
  1022.   while (nsamples > 0) {
  1023.     int n_in=0;
  1024.     int n_out=0;
  1025.     /* copy in new samples */
  1026.     for (ch=0; ch<gfp->stereo; ch++) {
  1027.       if (gfp->resample_ratio!=1)  {
  1028. n_out=fill_buffer_resample(gfp,&mfbuf[ch][mf_size],gfp->framesize,
  1029.   in_buffer[ch],nsamples,&n_in,ch);
  1030.       } else {
  1031. n_out=fill_buffer(gfp,&mfbuf[ch][mf_size],gfp->framesize,in_buffer[ch],nsamples);
  1032. n_in = n_out;
  1033.       }
  1034.       in_buffer[ch] += n_in;
  1035.     }
  1038.     nsamples -= n_in;
  1039.     mf_size += n_out;
  1040.     assert(mf_size<=MFSIZE);
  1041.     mf_samples_to_encode += n_out;
  1043.     if (mf_size >= mf_needed) {
  1044.       /* encode the frame */
  1045.       ret = lame_encode_frame(gfp,mfbuf[0],mfbuf[1],mf_size,mp3buf,mp3buf_size);
  1046.       if (ret == -1) {
  1047. /* fatel error: mp3buffer was too small */
  1048. return -1;
  1049.       }
  1050.       mp3buf += ret;
  1051.       mp3size += ret;
  1052.       /* shift out old samples */
  1053.       mf_size -= gfp->framesize;
  1054.       mf_samples_to_encode -= gfp->framesize;
  1055.       for (ch=0; ch<gfp->stereo; ch++)
  1056. for (i=0; i<mf_size; i++)
  1057.   mfbuf[ch][i]=mfbuf[ch][i+gfp->framesize];
  1058.     }
  1059.   }
  1060.   assert(nsamples==0);
  1061.   return mp3size;
  1062. }
  1067. int lame_encode_buffer_interleaved(lame_global_flags *gfp,
  1068.    short int buffer[], int nsamples, char *mp3buf, int mp3buf_size)
  1069. {
  1070.   static int frame_buffered=0;
  1071.   int mp3size=0,ret,i,ch,mf_needed;
  1073.   /* some sanity checks */
  1074.   assert(ENCDELAY>=MDCTDELAY);
  1075.   assert(BLKSIZE-FFTOFFSET >= 0);
  1076.   mf_needed = BLKSIZE+gfp->framesize-FFTOFFSET;
  1077.   assert(MFSIZE>=mf_needed);
  1079.   if (gfp->num_channels == 1) {
  1080.     return lame_encode_buffer(gfp,buffer, NULL ,nsamples,mp3buf,mp3buf_size);
  1081.   }
  1083.   if (gfp->resample_ratio!=1)  {
  1084.     short int *buffer_l;
  1085.     short int *buffer_r;
  1086.     buffer_l=malloc(sizeof(short int)*nsamples);
  1087.     buffer_r=malloc(sizeof(short int)*nsamples);
  1088.     if (buffer_l == NULL || buffer_r == NULL) {
  1089.       return -1;
  1090.     }
  1091.     for (i=0; i<nsamples; i++) {
  1092.       buffer_l[i]=buffer[2*i];
  1093.       buffer_r[i]=buffer[2*i+1];
  1094.     }
  1095.     ret = lame_encode_buffer(gfp,buffer_l,buffer_r,nsamples,mp3buf,mp3buf_size);
  1096.     free(buffer_l);
  1097.     free(buffer_r);
  1098.     return ret;
  1099.   }
  1102.   if (gfp->frameNum==0 && !frame_buffered) {
  1103.     memset((char *) mfbuf, 0, sizeof(mfbuf));
  1104.     frame_buffered=1;
  1105.     mf_samples_to_encode = ENCDELAY+288;
  1106.     mf_size=ENCDELAY-MDCTDELAY;  /* we pad input with this many 0's */
  1107.   }
  1108.   if (gfp->frameNum==1) {
  1109.     /* reset, for the next time frameNum==0 */
  1110.     frame_buffered=0;
  1111.   }
  1113.   if (gfp->num_channels==2  && gfp->stereo==1) {
  1114.     /* downsample to mono */
  1115.     for (i=0; i<nsamples; ++i) {
  1116.       buffer[2*i]=((int)buffer[2*i]+(int)buffer[2*i+1])/2;
  1117.       buffer[2*i+1]=0;
  1118.     }
  1119.   }
  1122.   while (nsamples > 0) {
  1123.     int n_out;
  1124.     /* copy in new samples */
  1125.     n_out = Min(gfp->framesize,nsamples);
  1126.     for (i=0; i<n_out; ++i) {
  1127.       mfbuf[0][mf_size+i]=buffer[2*i];
  1128.       mfbuf[1][mf_size+i]=buffer[2*i+1];
  1129.     }
  1130.     buffer += 2*n_out;
  1132.     nsamples -= n_out;
  1133.     mf_size += n_out;
  1134.     assert(mf_size<=MFSIZE);
  1135.     mf_samples_to_encode += n_out;
  1137.     if (mf_size >= mf_needed) {
  1138.       /* encode the frame */
  1139.       ret = lame_encode_frame(gfp,mfbuf[0],mfbuf[1],mf_size,mp3buf,mp3buf_size);
  1140.       if (ret == -1) {
  1141. /* fatel error: mp3buffer was too small */
  1142. return -1;
  1143.       }
  1144.       mp3buf += ret;
  1145.       mp3size += ret;
  1147.       /* shift out old samples */
  1148.       mf_size -= gfp->framesize;
  1149.       mf_samples_to_encode -= gfp->framesize;
  1150.       for (ch=0; ch<gfp->stereo; ch++)
  1151. for (i=0; i<mf_size; i++)
  1152.   mfbuf[ch][i]=mfbuf[ch][i+gfp->framesize];
  1153.     }
  1154.   }
  1155.   assert(nsamples==0);
  1156.   return mp3size;
  1157. }
  1172. /* old LAME interface */
  1173. /* With this interface, it is the users responsibilty to keep track of the
  1174.  * buffered, unencoded samples.  Thus mf_samples_to_encode is not incremented.
  1175.  *
  1176.  * lame_encode() is also used to flush the PCM input buffer by
  1177.  * lame_encode_finish()
  1178.  */
  1179. int lame_encode(lame_global_flags *gfp, short int in_buffer[2][1152],char *mp3buf,int size){
  1180.   int imp3,save;
  1181.   save = mf_samples_to_encode;
  1182.   imp3= lame_encode_buffer(gfp,in_buffer[0],in_buffer[1],576*gfp->mode_gr,
  1183.         mp3buf,size);
  1184.   mf_samples_to_encode = save;
  1185.   return imp3;
  1186. }
  1191. /* initialize mp3 encoder */
  1192. void lame_init(lame_global_flags *gfp)
  1193. {
  1195.   /*
  1196.    *  Disable floating point exepctions
  1197.    */
  1198. #ifdef __FreeBSD__
  1199. # include <floatingpoint.h>
  1200.   {
  1201.   /* seet floating point mask to the Linux default */
  1202.   fp_except_t mask;
  1203.   mask=fpgetmask();
  1204.   /* if bit is set, we get SIGFPE on that error! */
  1205.   fpsetmask(mask & ~(FP_X_INV|FP_X_DZ));
  1206.   /*  fprintf(stderr,"FreeBSD mask is 0x%xn",mask); */
  1207.   }
  1208. #endif
  1209. #if defined(__riscos__) && !defined(ABORTFP)
  1210.   /* Disable FPE's under RISC OS */
  1211.   /* if bit is set, we disable trapping that error! */
  1212.   /*   _FPE_IVO : invalid operation */
  1213.   /*   _FPE_DVZ : divide by zero */
  1214.   /*   _FPE_OFL : overflow */
  1215.   /*   _FPE_UFL : underflow */
  1216.   /*   _FPE_INX : inexact */
  1217.   DisableFPETraps( _FPE_IVO | _FPE_DVZ | _FPE_OFL );
  1218. #endif
  1221.   /*
  1222.    *  Debugging stuff
  1223.    *  The default is to ignore FPE's, unless compiled with -DABORTFP
  1224.    *  so add code below to ENABLE FPE's.
  1225.    */
  1227. #if defined(ABORTFP) && !defined(__riscos__)
  1228. #if defined(_MSC_VER)
  1229.   {
  1230. #include <float.h>
  1231. unsigned int mask;
  1232. mask=_controlfp( 0, 0 );
  1233. mask&=~(_EM_OVERFLOW|_EM_UNDERFLOW|_EM_ZERODIVIDE|_EM_INVALID);
  1234. mask=_controlfp( mask, _MCW_EM );
  1235. }
  1236. #elif defined(__CYGWIN__)
  1237. #  define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw))
  1238. #  define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw))
  1240. #  define _EM_INEXACT     0x00000001 /* inexact (precision) */
  1241. #  define _EM_UNDERFLOW   0x00000002 /* underflow */
  1242. #  define _EM_OVERFLOW    0x00000004 /* overflow */
  1243. #  define _EM_ZERODIVIDE  0x00000008 /* zero divide */
  1244. #  define _EM_INVALID     0x00000010 /* invalid */
  1245.   {
  1246.     unsigned int mask;
  1247.     _FPU_GETCW(mask);
  1248.     /* Set the FPU control word to abort on most FPEs */
  1249.     mask &= ~(_EM_UNDERFLOW | _EM_OVERFLOW | _EM_ZERODIVIDE | _EM_INVALID);
  1250.     _FPU_SETCW(mask);
  1251.   }
  1252. # else
  1253.   {
  1254. #  include <fpu_control.h>
  1255. #ifndef _FPU_GETCW
  1256. #define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw))
  1257. #endif
  1258. #ifndef _FPU_SETCW
  1259. #define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw))
  1260. #endif
  1261.     unsigned int mask;
  1262.     _FPU_GETCW(mask);
  1263.     /* Set the Linux mask to abort on most FPE's */
  1264.     /* if bit is set, we _mask_ SIGFPE on that error! */
  1265.     /*  mask &= ~( _FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM | _FPU_MASK_UM );*/
  1266.     mask &= ~( _FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM );
  1267.     _FPU_SETCW(mask);
  1268.   }
  1269. #endif
  1270. #endif /* ABORTFP && !__riscos__ */
  1274.   /* Global flags.  set defaults here */
  1275.   gfp->allow_diff_short=0;
  1276.   gfp->ATHonly=0;
  1277.   gfp->noATH=0;
  1278.   gfp->bWriteVbrTag=1;
  1279.   gfp->cwlimit=0;
  1280.   gfp->disable_reservoir=0;
  1281.   gfp->experimentalX = 0;
  1282.   gfp->experimentalY = 0;
  1283.   gfp->experimentalZ = 0;
  1284.   gfp->frameNum=0;
  1285.   gfp->gtkflag=0;
  1286.   gfp->quality=5;
  1287.   gfp->input_format=sf_unknown;
  1289.   gfp->filter_type=0;
  1290.   gfp->lowpassfreq=0;
  1291.   gfp->highpassfreq=0;
  1292.   gfp->lowpasswidth=-1;
  1293.   gfp->highpasswidth=-1;
  1294.   gfp->lowpass1=0;
  1295.   gfp->lowpass2=0;
  1296.   gfp->highpass1=0;
  1297.   gfp->highpass2=0;
  1298.   gfp->lowpass_band=32;
  1299.   gfp->highpass_band=-1;
  1301.   gfp->no_short_blocks=0;
  1302.   gfp->resample_ratio=1;
  1303.   gfp->padding_type=2;
  1304.   gfp->padding=0;
  1305.   gfp->swapbytes=0;
  1306.   gfp->silent=0;
  1307.   gfp->totalframes=0;
  1308.   gfp->VBR=0;
  1309.   gfp->VBR_q=4;
  1310.   gfp->VBR_min_bitrate_kbps=0;
  1311.   gfp->VBR_max_bitrate_kbps=0;
  1312.   gfp->VBR_min_bitrate=1;
  1313.   gfp->VBR_max_bitrate=13;
  1316.   gfp->version = 1;   /* =1   Default: MPEG-1 */
  1317.   gfp->mode = MPG_MD_JOINT_STEREO;
  1318.   gfp->mode_fixed=0;
  1319.   gfp->force_ms=0;
  1320.   gfp->brate=0;
  1321.   gfp->copyright=0;
  1322.   gfp->original=1;
  1323.   gfp->extension=0;
  1324.   gfp->error_protection=0;
  1325.   gfp->emphasis=0;
  1326.   gfp->in_samplerate=1000*44.1;
  1327.   gfp->out_samplerate=0;
  1328.   gfp->num_channels=2;
  1329.   gfp->num_samples=MAX_U_32_NUM;
  1331.   gfp->inPath=NULL;
  1332.   gfp->outPath=NULL;
  1333.   id3tag.used=0;
  1335. }
  1339. /*****************************************************************/
  1340. /* flush internal mp3 buffers,                                   */
  1341. /*****************************************************************/
  1342. int lame_encode_finish(lame_global_flags *gfp,char *mp3buffer, int mp3buffer_size)
  1343. {
  1344.   int imp3,mp3count,mp3buffer_size_remaining;
  1345.   short int buffer[2][1152];
  1346.   memset((char *)buffer,0,sizeof(buffer));
  1347.   mp3count = 0;
  1349.   while (mf_samples_to_encode > 0) {
  1351.     mp3buffer_size_remaining = mp3buffer_size - mp3count;
  1352.     /* if user specifed buffer size = 0, dont check size */
  1353.     if (mp3buffer_size == 0) mp3buffer_size_remaining=0;  
  1354.     imp3=lame_encode(gfp,buffer,mp3buffer,mp3buffer_size_remaining);
  1356.     if (imp3 == -1) {
  1357.       /* fatel error: mp3buffer too small */
  1358.       desalloc_buffer(&bs);    /* Deallocate all buffers */
  1359.       return -1;
  1360.     }
  1361.     mp3buffer += imp3;
  1362.     mp3count += imp3;
  1363.     mf_samples_to_encode -= gfp->framesize;
  1364.   }
  1367.   gfp->frameNum--;
  1368.   if (!gfp->gtkflag && !gfp->silent) {
  1369.       timestatus(gfp->out_samplerate,gfp->frameNum,gfp->totalframes,gfp->framesize);
  1370. #ifdef BRHIST
  1371.       if (disp_brhist)
  1372. {
  1373.   brhist_add_count();
  1374.   brhist_disp();
  1375.   brhist_disp_total(gfp);
  1376. }
  1377. #endif
  1378.       fprintf(stderr,"n");
  1379.       fflush(stderr);
  1380.   }
  1383.   III_FlushBitstream();
  1384.   mp3buffer_size_remaining = mp3buffer_size - mp3count;
  1385.   /* if user specifed buffer size = 0, dont check size */
  1386.   if (mp3buffer_size == 0) mp3buffer_size_remaining=0;  
  1388.   imp3= copy_buffer(mp3buffer,mp3buffer_size_remaining,&bs);
  1389.   if (imp3 == -1) {
  1390.     /* fatel error: mp3buffer too small */
  1391.     desalloc_buffer(&bs);    /* Deallocate all buffers */
  1392.     return -1;
  1393.   }
  1395.   mp3count += imp3;
  1396.   desalloc_buffer(&bs);    /* Deallocate all buffers */
  1397.   return mp3count;
  1398. }
  1401. /*****************************************************************/
  1402. /* write VBR Xing header, and ID3 tag, if asked for               */
  1403. /*****************************************************************/
  1404. void lame_mp3_tags(lame_global_flags *gfp)
  1405. {
  1406.   if (gfp->bWriteVbrTag)
  1407.     {
  1408.       /* Calculate relative quality of VBR stream
  1409.        * 0=best, 100=worst */
  1410.       int nQuality=gfp->VBR_q*100/9;
  1411.       /* Write Xing header again */
  1412.       PutVbrTag(gfp->outPath,nQuality,1-gfp->version);
  1413.     }
  1416.   /* write an ID3 tag  */
  1417.   if(id3tag.used) {
  1418.     id3_buildtag(&id3tag);
  1419.     id3_writetag(gfp->outPath, &id3tag);
  1420.   }
  1421. }
  1424. void lame_version(lame_global_flags *gfp,char *ostring) {
  1425.   strncpy(ostring,get_lame_version(),20);
  1426. }