.wav파일을 읽어서 data를 decode하기전에 audio play하는 코드데,
소리에서 잡음이 섞어 나오네, 왜 그러는지 좀 봐죠.

static int
get_audio(lame_global_flags * const gfp, int buffer[2][1152])
{
    int     num_channels = lame_get_num_channels(gfp);
    int     insamp[2 * 1152];
    int     samples_read;
    int     framesize;
    int     samples_to_read;
    unsigned int remaining, tmp_num_samples;
    int     i;
    int    *p;

    /*
     * NOTE: LAME can now handle arbritray size input data packets,
     * so there is no reason to read the input data in chuncks of
     * size "framesize".  EXCEPT:  the LAME graphical frame analyzer
     * will get out of sync if we read more than framesize worth of data.
     */

    samples_to_read = framesize = lame_get_framesize(gfp);
    assert(framesize <= 1152);

    /* get num_samples */
    tmp_num_samples = lame_get_num_samples(gfp);

    /* if this flag has been set, then we are carefull to read
     * exactly num_samples and no more.  This is useful for .wav and .aiff
     * files which have id3 or other tags at the end.  Note that if you
     * are using LIBSNDFILE, this is not necessary
     */
    if (global.count_samples_carefully) {
        remaining = tmp_num_samples - Min(tmp_num_samples, global.num_samples_read);
        if (remaining < (unsigned int) framesize && 0 != tmp_num_samples)
            /* in case the input is a FIFO (at least it\'s reproducible with
               a FIFO) tmp_num_samples may be 0 and therefore remaining
               would be 0, but we need to read some samples, so don\'t
               change samples_to_read to the wrong value in this case */
            samples_to_read = remaining;
    }

    if (is_mpeg_file_format(input_format)) {
        if (buffer != NULL)
            samples_read = read_samples_mp3(gfp, global.musicin, buf_tmp16);
        else
            samples_read = read_samples_mp3(gfp, global.musicin, buffer16);
        if (samples_read < 0) {
            return samples_read;
        }
    }
    else {
        samples_read = read_samples_pcm(global.musicin, insamp, num_channels * samples_to_read);
        if (samples_read < 0) {
            return samples_read;
        }
        p = insamp + samples_read;
        samples_read /= num_channels;
        if (buffer != NULL) { /* output to int buffer */
            if (num_channels == 2) {
                for (i = samples_read; --i >= 0;) {
                    buffer[1][i] = *--p;
                    buffer[0][i] = *--p;
                }
            }
            else if (num_channels == 1) {
                memset(buffer[1], 0, samples_read * sizeof(int));
                for (i = samples_read; --i >= 0;) {
                    buffer[0][i] = *--p;
                }
            }
            else
                assert(0);
        }
        else {          /* convert from int; output to 16-bit buffer */
            if (num_channels == 2) {
                for (i = samples_read; --i >= 0;) {
                    buffer16[1][i] = *--p >> (8 * sizeof(int) - 16);
                    buffer16[0][i] = *--p >> (8 * sizeof(int) - 16);
                }
            }
        }
    }

    /* if num_samples = MAX_U_32_NUM, then it is considered infinitely long.
       Don\'t count the samples */
    if (tmp_num_samples != MAX_U_32_NUM)
        global. num_samples_read += samples_read;

    return samples_read;
}

-----------------------------------------------------------------------
static int
lame_encoder(lame_global_flags * gf, FILE * outf, int nogap, char *inPath, char *outPath)
{
    unsigned char mp3buffer[LAME_MAXMP3BUFFER];
    int     Buffer[2][1152];
    int     iread, imp3, owrite, id3v2_size;

    static HWAVEOUT     hWaveOut ;
    static PBYTE        pBuffer ;
    static PWAVEHDR     pWaveHdr ;
    static WAVEFORMATEX waveformat ;
    MMRESULT     rc;                                               
    char         sError[129];

    encoder_progress_begin(gf, inPath, outPath);

    imp3 = lame_get_id3v2_tag(gf, mp3buffer, sizeof(mp3buffer));
    if ((size_t)imp3 > sizeof(mp3buffer)) {
        encoder_progress_end(gf);
        error_printf("Error writing ID3v2 tag: buffer too small: buffer size=%d  ID3v2 size=%d\\n"
                , sizeof(mp3buffer)
                , imp3
                    );
        return 1;
    }
    owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
    if (owrite != imp3) {
        encoder_progress_end(gf);
        error_printf("Error writing ID3v2 tag \\n");
        return 1;
    }
    if (flush_write == 1) {
        fflush(outf);
    }   
    id3v2_size = imp3;

    do {
        /* read in \'iread\' samples */
        iread = get_audio(gf, Buffer);

  pWaveHdr = malloc (sizeof (WAVEHDR)) ;
  pBuffer  = malloc (4096) ;

  if (!pWaveHdr || !pBuffer)
  {
   if (!pWaveHdr) free (pWaveHdr) ;
            if (!pBuffer)  free (pBuffer) ;

            return TRUE ;
  }
   
        waveformat.wFormatTag      = WAVE_FORMAT_PCM ;
        waveformat.nChannels       = 2 ;
        waveformat.nSamplesPerSec  = 44100 ;
        waveformat.nAvgBytesPerSec = 176400 ;
        waveformat.nBlockAlign     = 4 ;
        waveformat.wBitsPerSample  = 16 ;
        waveformat.cbSize          = 0 ;
                        
        if (waveOutOpen (&hWaveOut, WAVE_MAPPER, &waveformat,
                                     0, 0, WAVE_ALLOWSYNC) != MMSYSERR_NOERROR)
        {
            free (pWaveHdr) ;
            free (pBuffer) ;

            hWaveOut = NULL ;
            return TRUE ;
        }
        pWaveHdr->lpData          = (LPSTR) Buffer;
        pWaveHdr->dwBufferLength  = 4096 ;
        pWaveHdr->dwBytesRecorded = 0 ;
        pWaveHdr->dwUser          = 0 ;
        pWaveHdr->dwFlags         = 0 ;
        pWaveHdr->dwLoops         = 1 ;
        pWaveHdr->lpNext          = NULL ;
        pWaveHdr->reserved        = 0 ;
                   
        waveOutPrepareHeader (hWaveOut, pWaveHdr,
                                          sizeof (WAVEHDR)) ;

        rc = waveOutWrite (hWaveOut, pWaveHdr, sizeof (WAVEHDR)) ;
        waveOutClose (hWaveOut) ;
        waveOutGetErrorText(rc, sError, 128);   
        error_printf("mp3 internal error:  error code=%s\\n", sError);

 } while (iread > 0);
return 0;
}