/*

 *      Get Audio routines source file

 *

 *      Copyright (c) 1999 Albert L Faber

 *                    2008-2017 Robert Hegemann

 *

 * 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.167 2017/09/06 15:07:29 robert 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

#ifdef HAVE_INTTYPES_H

# include <inttypes.h>

#else

# ifdef HAVE_STDINT_H

#  include <stdint.h>

# endif

#endif

#define         MAX_U_32_NUM            0xFFFFFFFF

#include <math.h>

#if defined(__riscos__)

# include <kernel.h>

# include <sys/swis.h>

#elif defined(_WIN32)

# include <sys/types.h>

# include <sys/stat.h>

#else

# include <sys/stat.h>

#endif

#ifdef __sun__

/* woraround for SunOS 4.x, it has SEEK_* defined here */

#include <unistd.h>

#endif

#include "lame.h"

#include "main.h"

#include "get_audio.h"

#include "lametime.h"

#include "console.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

#ifndef STR

# define __STR(x)  #x

# define STR(x)    __STR(x)

#define __LOC__ __FILE__ "("STR(__LINE__)") : "

#endif

#define FLOAT_TO_UNSIGNED(f) ((unsigned long)(((long)((f) - 2147483648.0)) + 2147483647L + 1))

#define UNSIGNED_TO_FLOAT(u) (((double)((long)((u) - 2147483647L - 1))) + 2147483648.0)

static unsigned int uint32_high_low(unsigned char *bytes)

{

    uint32_t const hh = bytes[0];

    uint32_t const hl = bytes[1];

    uint32_t const lh = bytes[2];

    uint32_t const ll = bytes[3];

    return (hh << 24) | (hl << 16) | (lh << 8) | ll;

}

static double

read_ieee_extended_high_low(FILE * fp)

{

    unsigned char bytes[10];

    memset(bytes, 0, 10);

    fread(bytes, 1, 10, fp);

    {

        int32_t const s = (bytes[0] & 0x80);

        int32_t const e_h = (bytes[0] & 0x7F);

        int32_t const e_l = bytes[1];

        int32_t e = (e_h << 8) | e_l;

        uint32_t const hm = uint32_high_low(bytes + 2);

        uint32_t const lm = uint32_high_low(bytes + 6);

        double  result = 0;

        if (e != 0 || hm != 0 || lm != 0) {

            if (e == 0x7fff) {

                result = HUGE_VAL;

            }

            else {

                double  mantissa_h = UNSIGNED_TO_FLOAT(hm);

                double  mantissa_l = UNSIGNED_TO_FLOAT(lm);

                e -= 0x3fff;

                e -= 31;

                result = ldexp(mantissa_h, e);

                e -= 32;

                result += ldexp(mantissa_l, e);

            }

        }

        return s ? -result : result;

    }

}

static int

read_16_bits_low_high(FILE * fp)

{

    unsigned char bytes[2] = { 0, 0 };

    fread(bytes, 1, 2, fp);

    {

        int32_t const low = bytes[0];

        int32_t const high = (signed char) (bytes[1]);

        return (high << 8) | low;

    }

}

static int

read_32_bits_low_high(FILE * fp)

{

    unsigned char bytes[4] = { 0, 0, 0, 0 };

    fread(bytes, 1, 4, fp);

    {

        int32_t const low = bytes[0];

        int32_t const medl = bytes[1];

        int32_t const medh = bytes[2];

        int32_t const high = (signed char) (bytes[3]);

        return (high << 24) | (medh << 16) | (medl << 8) | low;

    }

}

static int

read_16_bits_high_low(FILE * fp)

{

    unsigned char bytes[2] = { 0, 0 };

    fread(bytes, 1, 2, fp);

    {

        int32_t const low = bytes[1];

        int32_t const high = (signed char) (bytes[0]);

        return (high << 8) | low;

    }

}

static int

read_32_bits_high_low(FILE * fp)

{

    unsigned char bytes[4] = { 0, 0, 0, 0 };

    fread(bytes, 1, 4, fp);

    {

        int32_t const low = bytes[3];

        int32_t const medl = bytes[2];

        int32_t const medh = bytes[1];

        int32_t const high = (signed char) (bytes[0]);

        return (high << 24) | (medh << 16) | (medl << 8) | low;

    }

}

static void

write_16_bits_low_high(FILE * fp, int val)

{

    unsigned char bytes[2];

    bytes[0] = (val & 0xff);

    bytes[1] = ((val >> 8) & 0xff);

    fwrite(bytes, 1, 2, fp);

}

static void

write_32_bits_low_high(FILE * fp, int val)

{

    unsigned char bytes[4];

    bytes[0] = (val & 0xff);

    bytes[1] = ((val >> 8) & 0xff);

    bytes[2] = ((val >> 16) & 0xff);

    bytes[3] = ((val >> 24) & 0xff);

    fwrite(bytes, 1, 4, fp);

}

#ifdef LIBSNDFILE

#include <sndfile.h>

#else

typedef void SNDFILE;

#endif /* ifdef LIBSNDFILE */

typedef struct blockAlign_struct {

    unsigned long offset;

    unsigned long blockSize;

} blockAlign;

typedef struct IFF_AIFF_struct {

    short   numChannels;

    unsigned long numSampleFrames;

    short   sampleSize;

    double  sampleRate;

    unsigned long sampleType;

    blockAlign blkAlgn;

} IFF_AIFF;

struct PcmBuffer {

    void   *ch[2];           /* buffer for each channel */

    int     w;               /* sample width */

    int     n;               /* number samples allocated */

    int     u;               /* number samples used */

    int     skip_start;      /* number samples to ignore at the beginning */

    int     skip_end;        /* number samples to ignore at the end */

};

typedef struct PcmBuffer PcmBuffer;

static void

initPcmBuffer(PcmBuffer * b, int w)

{

    b->ch[0] = 0;

    b->ch[1] = 0;

    b->w = w;

    b->n = 0;

    b->u = 0;

    b->skip_start = 0;

    b->skip_end = 0;

}

static void

freePcmBuffer(PcmBuffer * b)

{

    if (b != 0) {

        free(b->ch[0]);

        free(b->ch[1]);

        b->ch[0] = 0;

        b->ch[1] = 0;

        b->n = 0;

        b->u = 0;

    }

}

static int

addPcmBuffer(PcmBuffer * b, void *a0, void *a1, int read)

{

    int     a_n;

    if (b == 0) {

        return 0;

    }

    if (read < 0) {

        return b->u - b->skip_end;

    }

    if (b->skip_start >= read) {

        b->skip_start -= read;

        return b->u - b->skip_end;

    }

    a_n = read - b->skip_start;

    if (b != 0 && a_n > 0) {

        int const a_skip = b->w * b->skip_start;

        int const a_want = b->w * a_n;

        int const b_used = b->w * b->u;

        int const b_have = b->w * b->n;

        int const b_need = b->w * (b->u + a_n);

        if (b_have < b_need) {

            b->n = b->u + a_n;

            b->ch[0] = realloc(b->ch[0], b_need);

            b->ch[1] = realloc(b->ch[1], b_need);

        }

        b->u += a_n;

        if (b->ch[0] != 0 && a0 != 0) {

            char   *src = a0;

            char   *dst = b->ch[0];

            memcpy(dst + b_used, src + a_skip, a_want);

        }

        if (b->ch[1] != 0 && a1 != 0) {

            char   *src = a1;

            char   *dst = b->ch[1];

            memcpy(dst + b_used, src + a_skip, a_want);

        }

    }

    b->skip_start = 0;

    return b->u - b->skip_end;

}

static int

takePcmBuffer(PcmBuffer * b, void *a0, void *a1, int a_n, int mm)

{

    if (a_n > mm) {

        a_n = mm;

    }

    if (b != 0 && a_n > 0) {

        int const a_take = b->w * a_n;

        if (a0 != 0 && b->ch[0] != 0) {

            memcpy(a0, b->ch[0], a_take);

        }

        if (a1 != 0 && b->ch[1] != 0) {

            memcpy(a1, b->ch[1], a_take);

        }

        b->u -= a_n;

        if (b->u < 0) {

            b->u = 0;

            return a_n;

        }

        if (b->ch[0] != 0) {

            memmove(b->ch[0], (char *) b->ch[0] + a_take, b->w * b->u);

        }

        if (b->ch[1] != 0) {

            memmove(b->ch[1], (char *) b->ch[1] + a_take, b->w * b->u);

        }

    }

    return a_n;

}

/* global data for get_audio.c. */

typedef struct get_audio_global_data_struct {

    int     count_samples_carefully;

    int     pcmbitwidth;

    int     pcmswapbytes;

    int     pcm_is_unsigned_8bit;

    int     pcm_is_ieee_float;

    unsigned int num_samples_read;

    FILE   *music_in;

    SNDFILE *snd_file;

    hip_t   hip;

    PcmBuffer pcm32;

    PcmBuffer pcm16;

    size_t  in_id3v2_size;

    unsigned char* in_id3v2_tag;

} get_audio_global_data;

static get_audio_global_data global;

#ifdef AMIGA_MPEGA

int     lame_decode_initfile(const char *fullname, mp3data_struct * const mp3data);

#else

int     lame_decode_initfile(FILE * fd, mp3data_struct * mp3data, int *enc_delay, int *enc_padding);

#endif

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

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

                                mp3data_struct * mp3data);

static int read_samples_pcm(FILE * musicin, int sample_buffer[2304], int samples_to_read);

static int read_samples_mp3(lame_t gfp, FILE * musicin, short int mpg123pcm[2][1152]);

#ifdef LIBSNDFILE

static SNDFILE *open_snd_file(lame_t gfp, char const *inPath);

#endif

static FILE *open_mpeg_file(lame_t gfp, char const *inPath, int *enc_delay, int *enc_padding);

static FILE *open_wave_file(lame_t gfp, char const *inPath, int *enc_delay, int *enc_padding);

static int close_input_file(FILE * musicin);

static  size_t

min_size_t(size_t a, size_t b)

{

    if (a < b) {

        return a;

    }

    return b;

}

enum ByteOrder machine_byte_order(void);

enum ByteOrder

machine_byte_order(void)

{

    long    one = 1;

    return !(*((char *) (&one))) ? ByteOrderBigEndian : ByteOrderLittleEndian;

}

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

/* S_ISFIFO macro is defined on newer Linuxes */

#ifndef S_ISFIFO

# ifdef _S_IFIFO

    /* _S_IFIFO is defined on Win32 and Cygwin */

#  define S_ISFIFO(m) (((m)&_S_IFIFO) == _S_IFIFO)

# endif

#endif

#ifdef S_ISFIFO

    /* fseek is known to fail on pipes with several C-Library implementations

       workaround: 1) test for pipe

       2) for pipes, only relatvie seeking is possible

       3)            and only in forward direction!

       else fallback to old code

     */

    {

        int const fd = fileno(fp);

        struct stat file_stat;

        if (fstat(fd, &file_stat) == 0) {

            if (S_ISFIFO(file_stat.st_mode)) {

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

                    return -1;

                }

                while (offset > 0) {

                    size_t const bytes_to_skip = min_size_t(sizeof(buffer), offset);

                    size_t const read = fread(buffer, 1, bytes_to_skip, fp);

                    if (read < 1) {

                        return -1;

                    }

                    assert( read <= LONG_MAX );

                    offset -= (long) read;

                }

                return 0;

            }

        }

    }

#endif

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

        return 0;

    }

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

        if (global_ui_config.silent < 10) {

            error_printf

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

        }

        return -1;

    }

    while (offset > 0) {

        size_t const bytes_to_skip = min_size_t(sizeof(buffer), offset);

        size_t const read = fread(buffer, 1, bytes_to_skip, fp);

        if (read < 1) {

            return -1;

        }

        assert( read <= LONG_MAX );

        offset -= (long) read;

    }

    return 0;

}

static  off_t

lame_get_file_size(FILE * fp)

{

    struct stat sb;

    int     fd = fileno(fp);

    if (0 == fstat(fd, &sb))

        return sb.st_size;

    return (off_t) - 1;

}

FILE   *

init_outfile(char const *outPath, int decode)

{

    FILE   *outf;

    /* open the output file */

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

        outf = stdout;

        lame_set_stream_binary_mode(outf);

    }

    else {

        outf = lame_fopen(outPath, "w+b");

#ifdef __riscos__

        /* Assign correct file type */

        if (outf != NULL) {

            char   *p, *out_path = strdup(outPath);

            for (p = out_path; *p; p++) { /* ugly, ugly to modify a string */

                switch (*p) {

                case '.':

                    *p = '/';

                    break;

                case '/':

                    *p = '.';

                    break;

                }

            }

            SetFiletype(out_path, decode ? 0xFB1 /*WAV*/ : 0x1AD /*AMPEG*/);

            free(out_path);

        }

#else

        (void) decode;

#endif

    }

    return outf;

}

static void

setSkipStartAndEnd(lame_t gfp, int enc_delay, int enc_padding)

{

    int     skip_start = 0, skip_end = 0;

    if (global_decoder.mp3_delay_set)

        skip_start = global_decoder.mp3_delay;

    switch (global_reader.input_format) {

    case sf_mp123:

        break;

    case sf_mp3:

        if (skip_start == 0) {

            if (enc_delay > -1 || enc_padding > -1) {

                if (enc_delay > -1)

                    skip_start = enc_delay + 528 + 1;

                if (enc_padding > -1)

                    skip_end = enc_padding - (528 + 1);

            }

            else

                skip_start = lame_get_encoder_delay(gfp) + 528 + 1;

        }

        else {

            /* user specified a value of skip. just add for decoder */

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

        }

        break;

    case sf_mp2:

        skip_start += 240 + 1;

        break;

    case sf_mp1:

        skip_start += 240 + 1;

        break;

    case sf_raw:

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

        break;

    case sf_wave:

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

        break;

    case sf_aiff:

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

        break;

    default:

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

        break;

    }

    skip_start = skip_start < 0 ? 0 : skip_start;

    skip_end = skip_end < 0 ? 0 : skip_end;

    global. pcm16.skip_start = global.pcm32.skip_start = skip_start;

    global. pcm16.skip_end = global.pcm32.skip_end = skip_end;

}

int

init_infile(lame_t gfp, char const *inPath)

{

    int     enc_delay = 0, enc_padding = 0;

    /* open the input file */

    global. count_samples_carefully = 0;

    global. num_samples_read = 0;

    global. pcmbitwidth = global_raw_pcm.in_bitwidth;

    global. pcmswapbytes = global_reader.swapbytes;

    global. pcm_is_unsigned_8bit = global_raw_pcm.in_signed == 1 ? 0 : 1;

    global. pcm_is_ieee_float = 0;

    global. hip = 0;

    global. music_in = 0;

    global. snd_file = 0;

    global. in_id3v2_size = 0;

    global. in_id3v2_tag = 0;

    if (is_mpeg_file_format(global_reader.input_format)) {

        global. music_in = open_mpeg_file(gfp, inPath, &enc_delay, &enc_padding);

    }

    else {

#ifdef LIBSNDFILE

        if (strcmp(inPath, "-") != 0) { /* not for stdin */

            global. snd_file = open_snd_file(gfp, inPath);

        }

#endif

        if (global.snd_file == 0) {

            global. music_in = open_wave_file(gfp, inPath, &enc_delay, &enc_padding);

        }

    }

    initPcmBuffer(&global.pcm32, sizeof(int));

    initPcmBuffer(&global.pcm16, sizeof(short));

    setSkipStartAndEnd(gfp, enc_delay, enc_padding);

    {

        unsigned long n = lame_get_num_samples(gfp);

        if (n != MAX_U_32_NUM) {

            unsigned long const discard = global.pcm32.skip_start + global.pcm32.skip_end;

            lame_set_num_samples(gfp, n > discard ? n - discard : 0);

        }

    }

    return (global.snd_file != NULL || global.music_in != NULL) ? 1 : -1;

}

int

samples_to_skip_at_start(void)

{

    return global.pcm32.skip_start;

}

int

samples_to_skip_at_end(void)

{

    return global.pcm32.skip_end;

}

void

close_infile(void)

{

#if defined(HAVE_MPGLIB)

    if (global.hip != 0) {

        hip_decode_exit(global.hip); /* release mp3decoder memory */

        global. hip = 0;

    }

#endif

    close_input_file(global.music_in);

#ifdef LIBSNDFILE

    if (global.snd_file) {

        if (sf_close(global.snd_file) != 0) {

            if (global_ui_config.silent < 10) {

                error_printf("Could not close sound file \n");

            }

        }

        global. snd_file = 0;

    }

#endif

    freePcmBuffer(&global.pcm32);

    freePcmBuffer(&global.pcm16);

    global. music_in = 0;

    free(global.in_id3v2_tag);

    global.in_id3v2_tag = 0;

    global.in_id3v2_size = 0;

}

static int

        get_audio_common(lame_t gfp, int buffer[2][1152], short buffer16[2][1152]);

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

*

* 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_t gfp, int buffer[2][1152])

{

    int     used = 0, read = 0;

    do {

        read = get_audio_common(gfp, buffer, NULL);

        used = addPcmBuffer(&global.pcm32, buffer[0], buffer[1], read);

    } while (used <= 0 && read > 0);

    if (read < 0) {

        return read;

    }

    if (global_reader.swap_channel == 0)

        return takePcmBuffer(&global.pcm32, buffer[0], buffer[1], used, 1152);

    else

        return takePcmBuffer(&global.pcm32, buffer[1], buffer[0], used, 1152);

}

/*

  get_audio16 - behave as the original get_audio function, with a limited

                16 bit per sample output

*/

int

get_audio16(lame_t gfp, short buffer[2][1152])

{

    int     used = 0, read = 0;

    do {

        read = get_audio_common(gfp, NULL, buffer);

        used = addPcmBuffer(&global.pcm16, buffer[0], buffer[1], read);

    } while (used <= 0 && read > 0);

    if (read < 0) {

        return read;

    }

    if (global_reader.swap_channel == 0)

        return takePcmBuffer(&global.pcm16, buffer[0], buffer[1], used, 1152);

    else

        return takePcmBuffer(&global.pcm16, buffer[1], buffer[0], used, 1152);

}

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

  get_audio_common - central functionality of get_audio*

    in: gfp

        buffer    output to the int buffer or 16-bit buffer

   out: buffer    int output    (if buffer != NULL)

        buffer16  16-bit output (if buffer == NULL) 

returns: samples read

note: either buffer or buffer16 must be allocated upon call

*/

static int

get_audio_common(lame_t gfp, int buffer[2][1152], short buffer16[2][1152])

{

    const int num_channels = lame_get_num_channels(gfp);

    const int framesize = lame_get_framesize(gfp);

    int     insamp[2 * 1152];

    short   buf_tmp16[2][1152];

    int     samples_read;

    int     samples_to_read;

    unsigned int remaining;

    int     i;

    int    *p;

    /* sanity checks, that's what we expect to be true */

    if ((num_channels < 1 || 2 < num_channels)

      ||(framesize < 1 || 1152 < framesize)) {

        if (global_ui_config.silent < 10) {

            error_printf("Error: internal problem!\n");

        }

        return -1;

    }

    /* 

     * 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;

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

        unsigned int tmp_num_samples;

        /* get num_samples */

        if (is_mpeg_file_format(global_reader.input_format)) {

            tmp_num_samples = global_decoder.mp3input_data.nsamp;

        }

        else {

            tmp_num_samples = lame_get_num_samples(gfp);

        }

        if (global.num_samples_read < tmp_num_samples) {

            remaining = tmp_num_samples - global.num_samples_read;

        }

        else {

            remaining = 0;

        }

        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(global_reader.input_format)) {

        if (buffer != NULL)

            samples_read = read_samples_mp3(gfp, global.music_in, buf_tmp16);

        else

            samples_read = read_samples_mp3(gfp, global.music_in, buffer16);

        if (samples_read < 0) {

            return samples_read;

        }

    }

    else {

        if (global.snd_file) {

#ifdef LIBSNDFILE

            samples_read = sf_read_int(global.snd_file, insamp, num_channels * samples_to_read);

#else

            samples_read = 0;

#endif

        }

        else {

            samples_read =

                read_samples_pcm(global.music_in, 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);

                }

            }

            else if (num_channels == 1) {

                memset(buffer16[1], 0, samples_read * sizeof(short));

                for (i = samples_read; --i >= 0;) {

                    buffer16[0][i] = *--p >> (8 * sizeof(int) - 16);

                }

            }

            else

                assert(0);

        }

    }

    /* LAME mp3 output 16bit -  convert to int, if necessary */

    if (is_mpeg_file_format(global_reader.input_format)) {

        if (buffer != NULL) {

            for (i = samples_read; --i >= 0;)

                buffer[0][i] = buf_tmp16[0][i] << (8 * sizeof(int) - 16);

            if (num_channels == 2) {

                for (i = samples_read; --i >= 0;)

                    buffer[1][i] = buf_tmp16[1][i] << (8 * sizeof(int) - 16);

            }

            else if (num_channels == 1) {

                memset(buffer[1], 0, samples_read * sizeof(int));

            }

            else

                assert(0);

        }

    }

    /* if ... then it is considered infinitely long.

       Don't count the samples */

    if (global.count_samples_carefully)

        global. num_samples_read += samples_read;

    return samples_read;