title: Questions on using LAME in C
body: <p>I am trying to write a <code>pcm</code> to <code>mp3</code> conversion program using <code>Lame</code>. While the pcm data does get converted to an mp3 file, the output is very squeaky. Before I post questions, the following is the code I have:  </p>
  
  <pre><code>/*
  Sample program to generate a single sinusoid and encode it in mp3.
  */
  
  #include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;math.h&gt;
  #include &lt;include/lame/lame.h&gt;
  #include &lt;assert.h&gt;
  #include &lt;string.h&gt;
  
  int main(int argc, char *argv[]) {
  
    unsigned int sampleRate = 16000;  /*assumed.*/
    unsigned int nSecondsAudio = 4;
    float *arr;
    lame_global_flags *gfp;
    unsigned char mp3buffer[2304]; /*some odd buffer sizes hard-coded.*/
    int pcm_samples_1d[2*1152];
    int pcm_samples_2d[2][1152];
    int read = 0, write = 0;
    int return_code = 1;
    int mp3buf_size;
    FILE *mp3;
    FILE *pcm;
    int framesize = 0;
    int i = 0, j = 0, num_samples_encoded = 0;
  
    /*Step 1. Generate sinusoid.*/
    /*arr = (float *) malloc(sizeof(float) * nSecondsAudio * sampleRate);
    arr = generateSinusoid(sampleRate, nSecondsAudio);*/
  
    /*Step 2. See if encoder exists.*/
    char *s = (char *) malloc(sizeof(char)*200);
    s = get_lame_version();
    printf("Lame version = %s\n", s);
  
  
    /* Init lame flags.*/
    gfp = lame_init();
    if(!gfp) {
      printf("Unable to initialize gfp object.");
    } else {
      printf("Able to initialize gfp object.\n");
    }
  
    /* set other parameters.*/
    lame_set_num_channels(gfp, 1);
    /*lame_set_num_samples(gfp, (nSecondsAudio * sampleRate));*/
    lame_set_in_samplerate(gfp, sampleRate);
    lame_set_quality(gfp, 5);  /* set for high speed and good quality. */
    lame_set_mode(gfp, 3);  /* the input audio is mono */
  
    lame_set_out_samplerate(gfp, sampleRate);
    printf("Able to set a number of parameters too.");
    framesize = lame_get_framesize(gfp);
    printf("Framesize = %d\n", framesize);
    assert(framesize &lt;= 1152);
  
    /* set more internal variables. check for failure.*/
    if(lame_init_params(gfp) == -1) {
      printf("Something failed in setting internal parameters.");
    }
  
    /* encode the pcm array as mp3.*
     * Read the file. Encode whatever is read.
     * As soon as end of file is reached, flush the buffers.
     * Write everything to a file.
     * Write headers too.
    */
  
    /* Open PCM file for reading from.*/
    pcm = fopen("out.pcm", "rb");   /*hard-coded to the only available pcm file.*/
    if(!pcm) {
      printf("Cannot open pcm file for reading.");
      return 1;
    }
  
    mp3 = fopen("out.mp3", "wb+");
    if(!mp3) {
      printf("Cannot open file for writing.");
      return 1;
   }
  
    do {
     read = fread(pcm_samples_1d, sizeof(short), 2304, pcm); /*reads framesize shorts from pcm file.*/
     printf("Read %d shorts from file.\n", read);
  
     /* check for number of samples read. if 0, start flushing, else encode.*/
     if(read &gt; 0) {
       /* got data in 1D array. convert it to 2D */
       /* snippet below taken from lame source code. needs better understanding. pcm_samples_2d[0] = contents of buffer. pcm_samples_2d[1] = 0 since number of channels is always one.*/
       memset(pcm_samples_2d[1], 0, 1152 * sizeof(int));  /*set all other samples with 0.*/
       memset(pcm_samples_2d[0], 0, 1152 * sizeof(int));
       i = 0, j = 0;
       for(i = 0; i &lt; 1152; i++) {
         pcm_samples_2d[0][i] = pcm_samples_1d[i];
       }
  
       /* encode samples. */
       num_samples_encoded = lame_encode_buffer_int(gfp, pcm_samples_2d[0], pcm_samples_2d[1], read, mp3buffer, sizeof(mp3buffer));
  
       printf("number of samples encoded = %d\n", num_samples_encoded);
  
       /* check for value returned.*/
       if(num_samples_encoded &gt; 1) {
         printf("It seems the conversion was successful.\n");
       } else if(num_samples_encoded == -1) {
         printf("mp3buf was too small");
         return 1;
       } else if(num_samples_encoded == -2) {
         printf("There was a malloc problem.");
         return 1;
       } else if(num_samples_encoded == -3) {
         printf("lame_init_params() not called.");
         return 1;
       } else if(num_samples_encoded == -4) {
         printf("Psycho acoustic problems.");
         return 1;
       } else {
         printf("The conversion was not successful.");
         return 1;
       }
  
       printf("Contents of mp3buffer = \n");
       for(i = 0; i &lt; 2304; i++) {
         printf("mp3buffer[%d] = %d\n", i, mp3buffer[i]);
       }
  
  
       write = (int) fwrite(mp3buffer, sizeof(char), num_samples_encoded, mp3);
       if(write != num_samples_encoded) {
         printf("There seems to have been an error writing to mp3 within the loop.\n");
         return 1;
       } else {
         printf("Writing of %d samples a success.\n", write);
       }
     }
   } while(read &gt; 0);
  
   /* in case where the number of samples read is 0, or negative, start flushing.*/
   read = lame_encode_flush(gfp, mp3buffer, sizeof(mp3buffer)); /*this may yield one more mp3 buffer.*/
   if(read &lt; 0) {
     if(read == -1) {
       printf("mp3buffer is probably not big enough.\n");
     } else {
       printf("MP3 internal error.\n");
     }
     return 1;
   } else {
     printf("Flushing stage yielded %d frames.\n", read);
   }
  
   write = (int) fwrite(mp3buffer, 1, read, mp3);
   if(write != read) {
     printf("There seems to have been an error writing to mp3.\n");
     return 1;
   }
  
    /*samples have been written. write ID3 tag.*/
    read = lame_get_id3v1_tag(gfp, mp3buffer, sizeof(mp3buffer));
    if(sizeof(read) &gt; sizeof(mp3buffer)) {
      printf("Buffer too small to write ID3v1 tag.\n");
    } else {
      if(read &gt; 0) {
        write = (int) fwrite(mp3buffer, 1, read, mp3);
        if(read != write) {
          printf("more errors in writing id tag to mp3 file.\n");
        }
      }
    }
  
    lame_close(gfp);
    fclose(pcm);
    fclose(mp3);
  
    return 0;
  }
  </code></pre>
  
  <p>My questions:<br>
  1. My input pcm data is sampled at 16kHz, mono and encoded at 16 bits. Given that there is only one channel, what are the left and right channels in input to lame_encode_buffer_int?<br>
  2. I am not sure I understand the "conversion" process of going from a 1d array to a 2d array (pcm_samples_1d to pcm_samples_2d in the code) and as given in <a href="https://stackoverflow.com/q/11485456/350685">this question</a>.<br>
  3. Why am I getting a squeaky voice? In the code, the libraries used were compiled from source using the <code>--enable-debug</code> flag. Yet, I am not able to step in to the functions on using <code>gdb</code>. What else should I have done?  </p>
  
  <p>What I have tried so far:<br>
  1. Read the documentation (or what is available on the net) of the LAME project.<br>
  2. Read through questions posted here on SO and other forums.<br>
  3. Gone through the source code: <code>lame.h</code>, <code>frontend/main.c</code> frontend/get_audio.c` etc.  </p>
  
  <p>Any help on this is most welcome.</p>