Subversion Repositories planix.SVN

/*

 *	Get Audio routines source file

 *

 *	Copyright (c) 1999 Albert L Faber

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/* $Id: get_audio.c,v 1.61 2001/03/19 21:26:05 markt Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <assert.h>

#ifdef HAVE_LIMITS_H

# include <limits.h>

#endif

#include <stdio.h>

#ifdef STDC_HEADERS

# include <stdlib.h>

# include <string.h>

#else

# ifndef HAVE_STRCHR

#  define strchr index

#  define strrchr rindex

# endif

char   *strchr(), *strrchr();

# ifndef HAVE_MEMCPY

#  define memcpy(d, s, n) bcopy ((s), (d), (n))

#  define memmove(d, s, n) bcopy ((s), (d), (n))

# endif

#endif

#include <math.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "lame.h"

#include "main.h"

#include "get_audio.h"

#include "portableio.h"

#include "timestatus.h"

#include "lametime.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

/* global data for get_audio.c. */

int     count_samples_carefully;

int     pcmbitwidth;

mp3data_struct mp3input_data; /* used by Ogg and MP3 */

unsigned int num_samples_read;

FILE   *musicin;

#ifdef AMIGA_MPEGA

int     lame_decode_initfile(const char *fullname,

                             mp3data_struct * const mp3data);

#else

int     lame_decode_initfile(FILE * const fd, mp3data_struct * const mp3data);

#endif

/* read mp3 file until mpglib returns one frame of PCM data */

int     lame_decode_fromfile(FILE * fd, short int pcm_l[], short int pcm_r[],

                             mp3data_struct * mp3data);

/* and for Vorbis: */

int     lame_decode_ogg_initfile( lame_global_flags*  gfp,

                                  FILE*               fd,

                                  mp3data_struct*     mp3data );

int     lame_decode_ogg_fromfile( lame_global_flags*  gfc,

                                  FILE*               fd,

                                  short int           pcm_l[],

                                  short int           pcm_r[],

                                  mp3data_struct*     mp3data );

static int read_samples_pcm(FILE * musicin, short sample_buffer[2304],

                            int frame_size, int samples_to_read);

static int read_samples_mp3(lame_global_flags * gfp, FILE * musicin,

                            short int mpg123pcm[2][1152], int num_chan);

static int read_samples_ogg(lame_global_flags * gfp, FILE * musicin,

                            short int mpg123pcm[2][1152], int num_chan);

void    CloseSndFile(sound_file_format input, FILE * musicin);

FILE   *OpenSndFile(lame_global_flags * gfp, char *);

/* Replacement for forward fseek(,,SEEK_CUR), because fseek() fails on pipes */

static int

fskip(FILE * fp, long offset, int whence)

{

#ifndef PIPE_BUF

    char    buffer[4096];

#else

    char    buffer[PIPE_BUF];

#endif

    int     read;

    if (0 == fseek(fp, offset, whence))

        return 0;

    if (whence != SEEK_CUR || offset < 0) {

        fprintf(stderr,

                "fskip problem: Mostly the return status of functions is not evaluated so it is more secure to pollute <stderr>.\n");

        return -1;

    }

    while (offset > 0) {

        read = offset > sizeof(buffer) ? sizeof(buffer) : offset;

        if ((read = fread(buffer, 1, read, fp)) <= 0)

            return -1;

        offset -= read;

    }

    return 0;

}

FILE   *

init_outfile(char *outPath, int decode)

{

    FILE   *outf;

    /* open the output file */

    if (0 == strcmp(outPath, "-"))

        lame_set_stream_binary_mode(outf = stdout);

    else 

        if ((outf = fopen(outPath, "wb+")) == NULL)

            return NULL;

    return outf;

}

void

init_infile(lame_global_flags * gfp, char *inPath)

{

    /* open the input file */

    count_samples_carefully = 0;

    pcmbitwidth = 16;

    musicin = OpenSndFile(gfp, inPath);

}

void

close_infile(void)

{

    CloseSndFile(input_format, musicin);

}

void

SwapBytesInWords(short *ptr, int short_words)

{                       /* Some speedy code */

    unsigned long val;

    unsigned long *p = (unsigned long *) ptr;

#ifndef lint

# if defined(CHAR_BIT)

#  if CHAR_BIT != 8

#   error CHAR_BIT != 8

#  endif

# else

#  error can not determine number of bits in a char

# endif

#endif /* lint */

    assert(sizeof(short) == 2);

#if defined(SIZEOF_UNSIGNED_LONG) && SIZEOF_UNSIGNED_LONG == 4

    for (; short_words >= 2; short_words -= 2, p++) {

        val = *p;

        *p = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0x00FF00FF);

    }

    ptr = (short *) p;

    for (; short_words >= 1; short_words -= 1, ptr++) {

        val = *ptr;

        *ptr = ((val << 8) & 0xFF00) | ((val >> 8) & 0x00FF);

    }

#elif defined(SIZEOF_UNSIGNED_LONG) && SIZEOF_UNSIGNED_LONG == 8

    for (; short_words >= 4; short_words -= 4, p++) {

        val = *p;

        *p =

            ((val << 8) & 0xFF00FF00FF00FF00) | ((val >> 8) &

                                                 0x00FF00FF00FF00FF);

    }

    ptr = (short *) p;

    for (; short_words >= 1; short_words -= 1, ptr++) {

        val = *ptr;

        *ptr = ((val << 8) & 0xFF00) | ((val >> 8) & 0x00FF);

    }

#else

# ifdef SIZEOF_UNSIGNED_LONG

//#  warning Using unoptimized SwapBytesInWords().

# endif

    for (; short_words >= 1; short_words -= 1, ptr++) {

        val = *ptr;

        *ptr = ((val << 8) & 0xFF00) | ((val >> 8) & 0x00FF);

    }

#endif

    assert(short_words == 0);

}

/************************************************************************

*

* get_audio()

*

* PURPOSE:  reads a frame of audio data from a file to the buffer,

*   aligns the data for future processing, and separates the

*   left and right channels

*

************************************************************************/

int

get_audio(lame_global_flags * const gfp, short buffer[2][1152])

{

    int     num_channels = lame_get_num_channels( gfp );

    short   insamp[2 * 1152];

    int     samples_read;

    int     framesize;

    int     samples_to_read;

    unsigned int remaining, tmp_num_samples;

    int     j;

    short  *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 "gfp->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 = gfp->framesize;

    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 (count_samples_carefully) {

        remaining = tmp_num_samples - Min(tmp_num_samples, num_samples_read);

        if (remaining < framesize)

            samples_to_read = remaining;

    }

    switch (input_format) {

    case sf_mp1:

    case sf_mp2:

    case sf_mp3:

        samples_read = read_samples_mp3(gfp, musicin, buffer, num_channels);

        break;

    case sf_ogg:

        samples_read = read_samples_ogg(gfp, musicin, buffer, num_channels);

        break;

    default:

        samples_read =

            read_samples_pcm(musicin, insamp, num_channels * framesize,

                             num_channels * samples_to_read);

        samples_read /= num_channels;

        p = insamp;

        switch (num_channels) {

        case 1:

            for (j = 0; j < framesize; j++) {

                buffer[0][j] = *p++;

                buffer[1][j] = 0;

            }

            break;

        case 2:

            for (j = 0; j < framesize; j++) {

                buffer[0][j] = *p++;

                buffer[1][j] = *p++;

            }

            break;

        default:

            assert(0);

            break;

        }

    }

    /* 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 )

        num_samples_read += samples_read;

    return samples_read;

}

int

read_samples_ogg(lame_global_flags * const gfp,

                 FILE * const musicin,

                 short int oggpcm[2][1152], const int stereo)

{

    int     out = 0;

#ifdef HAVE_VORBIS

    static const char type_name[] = "Ogg Vorbis file";

    out =

        lame_decode_ogg_fromfile( gfp,

                                  musicin,

                                  oggpcm[0],

                                  oggpcm[1],

                                  &mp3input_data );

    /*

     * out < 0:  error, probably EOF

     * out = 0:  not possible with lame_decode_fromfile() ???

     * out > 0:  number of output samples

     */

    if (out < 0) {

        memset(oggpcm, 0, sizeof(**oggpcm) * 2 * 1152);

        return 0;

    }

    if (lame_get_num_channels( gfp ) != mp3input_data.stereo)

        fprintf(stderr,

                "Error: number of channels has changed in %s - not supported\n",

                type_name);

    if ( lame_get_in_samplerate( gfp ) != mp3input_data.samplerate )

        fprintf(stderr,

                "Error: sample frequency has changed in %s - not supported\n",

                type_name);

#else

    out = -1;           /* wanna read ogg without vorbis support? */

#endif

    return out;

}

int

read_samples_mp3(lame_global_flags * const gfp,

                 FILE * const musicin, short int mpg123pcm[2][1152], int stereo)

{

    int     out;

#if defined(AMIGA_MPEGA)  ||  defined(HAVE_MPGLIB)

    static const char type_name[] = "MP3 file";

    out =

        lame_decode_fromfile(musicin, mpg123pcm[0], mpg123pcm[1],

                             &mp3input_data);

    /*

     * out < 0:  error, probably EOF

     * out = 0:  not possible with lame_decode_fromfile() ???

     * out > 0:  number of output samples

     */

    if (out < 0) {

        memset(mpg123pcm, 0, sizeof(**mpg123pcm) * 2 * 1152);

        return 0;

    }

    if ( lame_get_num_channels( gfp ) != mp3input_data.stereo )

        fprintf(stderr,

                "Error: number of channels has changed in %s - not supported\n",

                type_name);

    if ( lame_get_in_samplerate( gfp ) != mp3input_data.samplerate )

        fprintf(stderr,

                "Error: sample frequency has changed in %s - not supported\n",

                type_name);

#else

    out = -1;

#endif

    return out;

}

static int

WriteWaveHeader(FILE * const fp, const int pcmbytes,

                const int freq, const int channels, const int bits)

{

    int     bytes = (bits + 7) / 8;

    /* quick and dirty, but documented */

    fwrite("RIFF", 1, 4, fp); // label

    Write32BitsLowHigh(fp, pcmbytes + 44 - 8); // length in bytes without header

    fwrite("WAVEfmt ", 2, 4, fp); // 2 labels

    Write32BitsLowHigh(fp, 2 + 2 + 4 + 4 + 2 + 2); // length of PCM format declaration area

    Write16BitsLowHigh(fp, 1); // is PCM?

    Write16BitsLowHigh(fp, channels); // number of channels

    Write32BitsLowHigh(fp, freq); // sample frequency in [Hz]

    Write32BitsLowHigh(fp, freq * channels * bytes); // bytes per second

    Write16BitsLowHigh(fp, channels * bytes); // bytes per sample time

    Write16BitsLowHigh(fp, bits); // bits per sample

    fwrite("data", 1, 4, fp); // label

    Write32BitsLowHigh(fp, pcmbytes); // length in bytes of raw PCM data

    return ferror(fp) ? -1 : 0;

}

/* the simple lame decoder */

/* After calling lame_init(), lame_init_params() and

 * init_infile(), call this routine to read the input MP3 file

 * and output .wav data to the specified file pointer*/

/* lame_decoder will ignore the first 528 samples, since these samples

 * represent the mpglib delay (and are all 0).  skip = number of additional

 * samples to skip, to (for example) compensate for the encoder delay */

int

lame_decoder(lame_global_flags * gfp, FILE * outf, int skip, char *inPath,

             char *outPath)

{

    short int Buffer[2][1152];

    int     iread;

    double  wavsize;

    int     i;

    void    (*WriteFunction) (FILE * fp, char *p, int n);

    int tmp_num_channels = lame_get_num_channels( gfp );

    fprintf(stderr, "\rinput:  %s%s(%g kHz, %i channel%s, ",

            strcmp(inPath, "-") ? inPath : "<stdin>",

            strlen(inPath) > 26 ? "\n\t" : "  ",

            lame_get_in_samplerate( gfp ) / 1.e3,

            tmp_num_channels, tmp_num_channels != 1 ? "s" : "");

    switch (input_format) {

    case sf_mp3:

        skip += 528 + 1; /* mp3 decoder has a 528 sample delay, plus user supplied "skip" */

        fprintf(stderr, "MPEG-%u%s Layer %s", 2 - gfp->version,

                lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "III");

        break;

    case sf_mp2:

        skip += 240 + 1;

        fprintf(stderr, "MPEG-%u%s Layer %s", 2 - gfp->version,

                lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "II");

        break;

    case sf_mp1:

        skip += 240 + 1;

        fprintf(stderr, "MPEG-%u%s Layer %s", 2 - gfp->version,

                lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "I");

        break;

    case sf_ogg:

        fprintf(stderr, "Ogg Vorbis");

        skip = 0;       /* other formats have no delay *//* is += 0 not better ??? */

        break;

    case sf_raw:

        fprintf(stderr, "raw PCM data");

        mp3input_data.nsamp = lame_get_num_samples( gfp );

        mp3input_data.framesize = 1152;

        skip = 0;       /* other formats have no delay *//* is += 0 not better ??? */

        break;

    case sf_wave:

        fprintf(stderr, "Microsoft WAVE");

        mp3input_data.nsamp = lame_get_num_samples( gfp );

        mp3input_data.framesize = 1152;

        skip = 0;       /* other formats have no delay *//* is += 0 not better ??? */

        break;

    case sf_aiff:

        fprintf(stderr, "SGI/Apple AIFF");

        mp3input_data.nsamp = lame_get_num_samples( gfp );

        mp3input_data.framesize = 1152;

        skip = 0;       /* other formats have no delay *//* is += 0 not better ??? */

        break;

    default:

        fprintf(stderr, "unknown");

        mp3input_data.nsamp = lame_get_num_samples( gfp );

        mp3input_data.framesize = 1152;

        skip = 0;       /* other formats have no delay *//* is += 0 not better ??? */

        assert(0);

        break;

    }

    fprintf(stderr, ")\noutput: %s%s(16 bit, Microsoft WAVE)\n",

            strcmp(outPath, "-") ? outPath : "<stdout>",

            strlen(outPath) > 45 ? "\n\t" : "  ");

    if (skip > 0)

        fprintf(stderr, "skipping initial %i samples (encoder+decoder delay)\n",

                skip);

    if ( 0 == lame_get_disable_waveheader( gfp ) )

        WriteWaveHeader(outf, 0x7FFFFFFF, lame_get_in_samplerate( gfp ),

                        tmp_num_channels,

                        16);

    /* unknown size, so write maximum 32 bit signed value */

    wavsize = -skip;

    WriteFunction = swapbytes ? WriteBytesSwapped : WriteBytes;

    mp3input_data.totalframes = mp3input_data.nsamp / mp3input_data.framesize;

    assert(tmp_num_channels >= 1 && tmp_num_channels <= 2);

    do {

        iread = get_audio(gfp, Buffer); /* read in 'iread' samples */

        mp3input_data.framenum += iread / mp3input_data.framesize;

        wavsize += iread;

        if (!silent)

            decoder_progress(gfp, &mp3input_data);

        skip -= (i = skip < iread ? skip : iread); /* 'i' samples are to skip in this frame */

        for (; i < iread; i++) {

            if ( lame_get_disable_waveheader( gfp ) ) {

                WriteFunction(outf, (char *) Buffer[0] + i, sizeof(short));

                if (tmp_num_channels == 2)

                    WriteFunction(outf, (char *) Buffer[1] + i, sizeof(short));

            }

            else {

                Write16BitsLowHigh(outf, Buffer[0][i]);

                if (tmp_num_channels == 2)

                    Write16BitsLowHigh(outf, Buffer[1][i]);

            }

        }

    } while (iread);

    i = (16 / 8) * tmp_num_channels;

    assert(i > 0);

    if (wavsize <= 0) {

        fprintf(stderr, "WAVE file contains 0 PCM samples\n");

        wavsize = 0;

    }

    else if (wavsize > 0xFFFFFFD0 / i) {

        fprintf(stderr,

                "Very huge WAVE file, can't set filesize accordingly\n");

        wavsize = 0xFFFFFFD0;

    }

    else {

        wavsize *= i;

    }

    if ( 0 == lame_get_disable_waveheader( gfp ) )

        if (!fseek(outf, 0l, SEEK_SET)) /* if outf is seekable, rewind and adjust length */

            WriteWaveHeader(outf, wavsize, lame_get_in_samplerate( gfp ),

                            tmp_num_channels, 16);

    fclose(outf);

    decoder_progress_finish(gfp);

    return 0;

}

#if defined(LIBSNDFILE)

#if 0                   /* currently disabled */

# include "sndfile.h"   // prototype for sf_get_lib_version()

void

print_sndlib_version(FILE * fp)

{

    char    tmp[80];

    sf_get_lib_version(tmp, sizeof(tmp));

    fprintf(fp,

            "Input handled by %s  (http://www.zip.com.au/~erikd/libsndfile/)\n",

            tmp);

}

#endif

/*

** Copyright (C) 1999 Albert Faber

**

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

void

CloseSndFile(sound_file_format input, FILE * musicin)

{

    SNDFILE *gs_pSndFileIn = (SNDFILE *) musicin;

    if (input == sf_mp1 || input == sf_mp2 || input == sf_mp3) {

#ifndef AMIGA_MPEGA

        if (fclose(musicin) != 0) {

            fprintf(stderr, "Could not close audio input file\n");

            exit(2);

        }

#endif

    }

    else {

        if (gs_pSndFileIn) {

            if (sf_close(gs_pSndFileIn) != 0) {

                fprintf(stderr, "Could not close sound file \n");

                exit(2);

            }

        }

    }

}

FILE   *

OpenSndFile(lame_global_flags * gfp, char *inPath)

{

    char   *lpszFileName = inPath;

    FILE   *musicin;

    SNDFILE *gs_pSndFileIn;

    SF_INFO gs_wfInfo;

    if (input_format == sf_mp1 ||

        input_format == sf_mp2 || input_format == sf_mp3) {

#ifdef AMIGA_MPEGA

        if (-1 == lame_decode_initfile(lpszFileName, &mp3input_data)) {

            fprintf(stderr, "Error reading headers in mp3 input file %s.\n",

                    lpszFileName);

            exit(1);

        }

#endif

#ifdef HAVE_MPGLIB

        if ((musicin = fopen(lpszFileName, "rb")) == NULL) {

            fprintf(stderr, "Could not find \"%s\".\n", lpszFileName);

            exit(1);

        }

        if (-1 == lame_decode_initfile(musicin, &mp3input_data)) {

            fprintf(stderr, "Error reading headers in mp3 input file %s.\n",

                    lpszFileName);

            exit(1);

        }

#endif

        if( -1 == lame_set_num_channels( gfp, mp3input_data.stereo ) ) {

            fprintf( stderr,

                     "Unsupported number of channels: %ud\n",

                     mp3input_data.stereo );

            exit( 1 );

        }

        (void) lame_set_in_samplerate( gfp, mp3input_data.samplerate );

        (void) lame_set_num_samples( gfp, mp3input_data.nsamp );

    }

    else if (input_format == sf_ogg) {

#ifdef HAVE_VORBIS

        if ((musicin = fopen(lpszFileName, "rb")) == NULL) {

            fprintf(stderr, "Could not find \"%s\".\n", lpszFileName);

            exit(1);

        }

        if ( -1 == lame_decode_ogg_initfile( gfp,

                                             musicin,

                                             &mp3input_data ) ) {

            fprintf(stderr, "Error reading headers in mp3 input file %s.\n",

                    lpszFileName);

            exit(1);

        }

#else

        fprintf(stderr, "mp3enc not compiled with libvorbis support.\n");

        exit(1);

#endif

    }

    else {

        /* Try to open the sound file */

        /* set some defaults incase input is raw PCM */

        gs_wfInfo.seekable = (input_format != sf_raw); /* if user specified -r, set to not seekable */

        gs_wfInfo.samplerate = lame_get_in_samplerate( gfp );

        gs_wfInfo.pcmbitwidth = 16;

        gs_wfInfo.channels = lame_get_num_channels( gfp );

#ifndef WORDS_BIGENDIAN

        /* little endian */

        if (swapbytes)

            gs_wfInfo.format = SF_FORMAT_RAW_BE;

        else

            gs_wfInfo.format = SF_FORMAT_RAW_LE;

#else

        if (swapbytes)

            gs_wfInfo.format = SF_FORMAT_RAW_LE;

        else

            gs_wfInfo.format = SF_FORMAT_RAW_BE;

#endif

        gs_pSndFileIn = sf_open_read(lpszFileName, &gs_wfInfo);

        musicin = (SNDFILE *) gs_pSndFileIn;

        /* Check result */

        if (gs_pSndFileIn == NULL) {

            sf_perror(gs_pSndFileIn);

            fprintf(stderr, "Could not open sound file \"%s\".\n",

                    lpszFileName);

            exit(1);

        }

        if ((gs_wfInfo.format == SF_FORMAT_RAW_LE) ||

            (gs_wfInfo.format == SF_FORMAT_RAW_BE)) input_format = sf_raw;

#ifdef _DEBUG_SND_FILE

        DEBUGF("\n\nSF_INFO structure\n");

        DEBUGF("samplerate        :%d\n", gs_wfInfo.samplerate);

        DEBUGF("samples           :%d\n", gs_wfInfo.samples);

        DEBUGF("channels          :%d\n", gs_wfInfo.channels);

        DEBUGF("pcmbitwidth       :%d\n", gs_wfInfo.pcmbitwidth);

        DEBUGF("format            :");

        /* new formats from sbellon@sbellon.de  1/2000 */

        switch (gs_wfInfo.format & SF_FORMAT_TYPEMASK) {

        case SF_FORMAT_WAV:

            DEBUGF("Microsoft WAV format (big endian). ");

            break;

        case SF_FORMAT_AIFF:

            DEBUGF("Apple/SGI AIFF format (little endian). ");

            break;

        case SF_FORMAT_AU:

            DEBUGF("Sun/NeXT AU format (big endian). ");

            break;

        case SF_FORMAT_AULE:

            DEBUGF("DEC AU format (little endian). ");

            break;

        case SF_FORMAT_RAW:

            DEBUGF("RAW PCM data. ");

            break;

        case SF_FORMAT_PAF:

            DEBUGF("Ensoniq PARIS file format. ");

            break;

        case SF_FORMAT_SVX:

            DEBUGF("Amiga IFF / SVX8 / SV16 format. ");

            break;

        case SF_FORMAT_NIST:

            DEBUGF("Sphere NIST format. ");

            break;

        default:

            assert(0);

            break;

        }

        switch (gs_wfInfo.format & SF_FORMAT_SUBMASK) {

        case SF_FORMAT_PCM:

            DEBUGF("PCM data in 8, 16, 24 or 32 bits.");

            break;

        case SF_FORMAT_FLOAT:

            DEBUGF("32 bit Intel x86 floats.");

            break;

        case SF_FORMAT_ULAW:

            DEBUGF("U-Law encoded.");

            break;

        case SF_FORMAT_ALAW:

            DEBUGF("A-Law encoded.");

            break;

        case SF_FORMAT_IMA_ADPCM:

            DEBUGF("IMA ADPCM.");

            break;

        case SF_FORMAT_MS_ADPCM:

            DEBUGF("Microsoft ADPCM.");

            break;

        case SF_FORMAT_PCM_BE:

            DEBUGF("Big endian PCM data.");

            break;

        case SF_FORMAT_PCM_LE:

            DEBUGF("Little endian PCM data.");

            break;

        case SF_FORMAT_PCM_S8:

            DEBUGF("Signed 8 bit PCM.");

            break;

        case SF_FORMAT_PCM_U8:

            DEBUGF("Unsigned 8 bit PCM.");

            break;

        case SF_FORMAT_SVX_FIB:

            DEBUGF("SVX Fibonacci Delta encoding.");

            break;

        case SF_FORMAT_SVX_EXP:

            DEBUGF("SVX Exponential Delta encoding.");

            break;

        default:

            assert(0);

            break;

        }

        DEBUGF("\n");

        DEBUGF("pcmbitwidth       :%d\n", gs_wfInfo.pcmbitwidth);

        DEBUGF("sections          :%d\n", gs_wfInfo.sections);

        DEBUGF("seekable          :\n", gs_wfInfo.seekable);

#endif

        (void) lame_set_num_samples( gfp, gs_wfInfo.samples );

        if( -1 == lame_set_num_channels( gfp, gs_wfInfo.channels ) ) {

            fprintf( stderr,

                     "Unsupported number of channels: %ud\n",

                     gs_wfInfo.channels );

            exit( 1 );

        }

        (void) lame_set_in_samplerate( gfp, gs_wfInfo.samplerate );

        pcmbitwidth = gs_wfInfo.pcmbitwidth;

    }

    if (lame_get_num_samples( gfp ) == MAX_U_32_NUM) {