/*
 *	TwoLAME: an optimized MPEG Audio Layer Two encoder
 *
 *	Copyright (C) 2004-2007 The TwoLAME Project
 *
 *	This library is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU Lesser General Public
 *	License as published by the Free Software Foundation; either
 *	version 2.1 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
 *	Lesser General Public License for more details.
 *
 *	You should have received a copy of the GNU Lesser 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$
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>

#include <twolame.h>
#include <sndfile.h>
#include "frontend.h"



/* 
  Global Variables
*/
int use_raw = FALSE;            // use raw input?
int sample_size = 16;           // number of bits per sample for raw input
int single_frame_mode = FALSE;  // only encode a single frame of MPEG audio ?
int byteswap = FALSE;           // swap endian on input audio ?
int channelswap = FALSE;        // swap left and right channels ?
SF_INFO sfinfo;                 // contains information about input file format

char inputfilename[MAX_NAME_SIZE] = "\0";
char outputfilename[MAX_NAME_SIZE] = "\0";





/* 
  new_extension()
  Puts a new extension name on a file name <filename>.
  Removes the last extension name, if any.
*/
static void new_extension(char *filename, char *extname, char *newname)
{
    int found, dotpos;

    // First, strip the old extension
    dotpos = strlen(filename);
    found = 0;
    do {
        switch (filename[dotpos]) {
        case '.':
            found = 1;
            break;
        case '\\':
        case '/':
        case ':':
            found = -1;
            break;
        default:
            dotpos--;
            if (dotpos < 0)
                found = -1;
            break;
        }
    } while (found == 0);

    if (found == -1) {
        strncpy(newname, filename, MAX_NAME_SIZE);
    }
    if (found == 1) {
        strncpy(newname, filename, dotpos);
        newname[dotpos] = '\0';
    }
    // Make sure there is room in the string for the 
    // new filename and the extension
    if (strlen(newname) + strlen(extname) + 1 < MAX_NAME_SIZE) {
        strcat(newname, extname);
    }
}

static char *format_filesize_string(int filesize)
{
    static const int constKB = 1024;    // Kilobyte
    static const int constMB = 1024 * 1024; // Megabyte
    static const int constGB = 1024 * 1024 * 1024;  // Gigabyte
    char *string = malloc(MAX_NAME_SIZE);

    if (filesize < constKB) {
        snprintf(string, MAX_NAME_SIZE, "%d bytes", filesize);
    } else if (filesize < constMB) {
        snprintf(string, MAX_NAME_SIZE, "%2.2f KB", (float) filesize / constKB);
    } else if (filesize < constGB) {
        snprintf(string, MAX_NAME_SIZE, "%2.2f MB", (float) filesize / constMB);
    } else {
        snprintf(string, MAX_NAME_SIZE, "%2.2f GB", (float) filesize / constGB);
    }

    return string;
}

/*
	print_filenames()
	Display the input and output filenames
*/
static void print_filenames(int verbosity)
{
    char *ifn, *ofn;

    if (strcmp(inputfilename, "-") == 0)
        ifn = "STDIN";
    else
        ifn = inputfilename;

    if (strcmp(outputfilename, "-") == 0)
        ofn = "STDOUT";
    else
        ofn = outputfilename;


    if (verbosity == 1) {
        fprintf(stderr, "Encoding %s to %s\n", ifn, ofn);
    } else if (verbosity > 1) {
        fprintf(stderr, "---------------------------------------------------------\n");
        fprintf(stderr, "Input Filename: %s\n", ifn);
        fprintf(stderr, "Output Filename: %s\n", ofn);
    }

}



/* 
  usage_long() 
  Display the extended usage information
*/
static void usage_long()
{

    fprintf(stderr, "TwoLAME version %s (%s)\n", get_twolame_version(), get_twolame_url());
    fprintf(stderr, "MPEG Audio Layer II (MP2) encoder\n");
    fprintf(stderr, "Usage: \n");

    fprintf(stderr, "\ttwolame [options] <infile> [outfile]\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "Both input and output filenames can be set to - to use stdin/stdout.\n");
    fprintf(stderr, "  <infile>       input sound file (any format supported by libsndfile)\n");
    fprintf(stderr, "  <outfile>      output bit stream of encoded audio\n");

    fprintf(stderr, "\nInput Options\n");
    fprintf(stderr, "\t-r, --raw-input          input is raw signed PCM audio\n");
    fprintf(stderr, "\t-x, --byte-swap          force byte-swapping of input\n");
    fprintf(stderr, "\t-s, --samplerate srate   sampling frequency of raw input (Hz)\n");
    fprintf(stderr,
            "\t    --samplesize bits    size of raw input samples in bits (default 16-bit)\n");
    fprintf(stderr, "\t-N, --channels nch       number of channels in raw input\n");
    fprintf(stderr, "\t-g, --swap-channels      swap channels of input file\n");
    fprintf(stderr, "\t    --scale value        scale input (multiply PCM data)\n");
    fprintf(stderr, "\t    --scale-l value      scale channel 0 (left) input\n");
    fprintf(stderr, "\t    --scale-r value      scale channel 1 (right) input\n");


    fprintf(stderr, "\nOutput Options\n");
    fprintf(stderr, "\t-m, --mode mode          (s)tereo, (j)oint, (d)ual, (m)ono or (a)uto\n");
    fprintf(stderr,
            "\t-a, --downmix            downmix from stereo to mono file for mono encoding\n");
    fprintf(stderr, "\t-b, --bitrate br         total bitrate in kbps (default 192 for 44.1kHz)\n");
    fprintf(stderr, "\t-P, --psyc-mode psyc     psychoacoustic model -1 to 4 (default 3)\n");
    fprintf(stderr, "\t-v, --vbr                enable VBR mode\n");
    fprintf(stderr,
            "\t-V, --vbr-level lev      enable VBR and set VBR level -50 to 50 (default 5)\n");
    fprintf(stderr, "\t-B, --max-bitrate rate   set the upper bitrate when in VBR mode\n");
    fprintf(stderr, "\t-l, --ath lev            ATH level (default 0.0)\n");
    fprintf(stderr, "\t-q, --quick num          only calculate psy model every num frames\n");
    fprintf(stderr, "\t-S, --single-frame       only encode a single frame of MPEG Audio\n");


    fprintf(stderr, "\nMiscellaneous Options\n");
    fprintf(stderr, "\t-c, --copyright          mark as copyright\n");
    fprintf(stderr, "\t    --non-copyright      mark as non-copyright (default)\n");
    fprintf(stderr, "\t-o, --non-original       mark as non-original\n");
    fprintf(stderr, "\t    --original           mark as original (default)\n");
    fprintf(stderr, "\t-p, --protect            enable CRC error protection\n");
    fprintf(stderr, "\t-d, --padding            force padding bit/frame on\n");
    fprintf(stderr, "\t-R, --reserve-bits num   set number of reserved bits in each frame\n");
    fprintf(stderr, "\t-e, --deemphasis emp     de-emphasis n/5/c (default: (n)one)\n");
    fprintf(stderr, "\t-E, --energy             turn on energy level extensions\n");

    fprintf(stderr, "\nVerbosity Options\n");
    fprintf(stderr, "\t-t, --talkativity num    talkativity 0-10 (default is 2)\n");
    fprintf(stderr, "\t    --quiet              same as --talkativity=0\n");
    fprintf(stderr, "\t    --brief              same as --talkativity=1\n");
    fprintf(stderr, "\t    --verbose            same as --talkativity=4\n");


    fprintf(stderr, "\n");
    fprintf(stderr, "\nAllowable bitrates for 32, 44.1 and 48kHz sample input (MPEG-1)\n");
    fprintf(stderr, "  32,  48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384\n");
    fprintf(stderr, "\nAllowable bitrates for 16, 22.05 and 24kHz sample input (MPEG-2)\n");
    fprintf(stderr, "   8,  16,  24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160\n");

    fprintf(stderr, "\n");
    exit(ERR_NO_ENCODE);
}



/* 
  usage_short() 
  Display the short usage information
*/
static void usage_short()
{
    /* print a bit of info about the program */
    fprintf(stderr, "TwoLAME version %s (%s)\n", get_twolame_version(), get_twolame_url());
    fprintf(stderr, "MPEG Audio Layer II (MP2) encoder\n\n");
    fprintf(stderr, "Usage: twolame [options] <infile> [outfile]\n\n");
    fprintf(stderr, "Try \"twolame --help\" for more information.\n");
    exit(ERR_NO_ENCODE);
}


/*
	build_shortopt_string()
	Creates a short args string from the options structure
	for use with getopt_long
*/
static char *build_shortopt_string(struct option *opts)
{
    int count = 0;
    char *shortstr = NULL;
    int c = 0, n = 0;

    // Start by counting the number of options
    while (opts[count].val != 0) {
        count++;
    }


    // Allocate memory for the string
    shortstr = malloc((count * 2) + 1);

    // And loop through the options again
    for (n = 0; opts[n].val != 0; n++) {
        if (opts[n].val > 0 && opts[n].val < 127) {
            shortstr[c++] = opts[n].val;
            if (opts[n].has_arg == optional_argument) {
                fprintf(stderr, "gah: can't do optional arguments\n");
            } else if (opts[n].has_arg == required_argument) {
                shortstr[c++] = ':';
            }
        }
    }

    // Finally - terminate the string
    shortstr[c] = '\0';

    return shortstr;
}



/* 
  parse_args() 
  Parse the command line arguments
*/
static void parse_args(int argc, char **argv, twolame_options * encopts)
{
    int ch = 0;

    // process args
    struct option longopts[] = {

        // Input
        {"raw-input", no_argument, NULL, 'r'},
        {"byte-swap", no_argument, NULL, 'x'},
        {"samplerate", required_argument, NULL, 's'},
        {"samplesize", required_argument, NULL, 1000},
        {"channels", required_argument, NULL, 'N'},
        {"swap-channels", no_argument, NULL, 'g'},
        {"scale", required_argument, NULL, 1001},
        {"scale-l", required_argument, NULL, 1002},
        {"scale-r", required_argument, NULL, 1003},

        // Output
        {"mode", required_argument, NULL, 'm'},
        {"downmix", no_argument, NULL, 'a'},
        {"bitrate", required_argument, NULL, 'b'},
        {"psyc-mode", required_argument, NULL, 'P'},
        {"vbr", no_argument, NULL, 'v'},
        {"vbr-level", required_argument, NULL, 'V'},
        {"max-bitrate", required_argument, NULL, 'B'},
        {"ath", required_argument, NULL, 'l'},
        {"quick", required_argument, NULL, 'q'},
        {"single-frame", no_argument, NULL, 'S'},

        // Misc
        {"copyright", no_argument, NULL, 'c'},
        {"non-copyright", no_argument, NULL, 1004},
        {"non-original", no_argument, NULL, 'o'},
        {"original", no_argument, NULL, 1005},
        {"protect", no_argument, NULL, 'p'},
        {"padding", no_argument, NULL, 'd'},
        {"reserve-bits", required_argument, NULL, 'R'},
        {"deemphasis", required_argument, NULL, 'e'},
        {"energy", no_argument, NULL, 'E'},

        // Verbosity
        {"talkativity", required_argument, NULL, 't'},
        {"quiet", no_argument, NULL, 1006},
        {"brief", no_argument, NULL, 1007},
        {"verbose", no_argument, NULL, 1008},
        {"help", no_argument, NULL, 'h'},

        {NULL, 0, NULL, 0}
    };


    // Create a short options structure from the long one
    char *shortopts = build_shortopt_string(longopts);
    // fprintf(stderr,"shortopts: %s\n", shortopts);


    // Input format defaults
    memset(&sfinfo, 0, sizeof(sfinfo));
    sfinfo.format = 0;
    sfinfo.samplerate = DEFAULT_SAMPLERATE;
    sfinfo.channels = DEFAULT_CHANNELS;
    sfinfo.frames = 0;


    while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
        switch (ch) {

            // Input
        case 'r':
            use_raw = 1;
            break;

        case 'x':
            byteswap = TRUE;
            break;

        case 's':
            twolame_set_out_samplerate(encopts, atoi(optarg));
            sfinfo.samplerate = atoi(optarg);
            break;

        case 1000:             // --samplesize
            sample_size = atoi(optarg);
            break;

        case 'N':
            sfinfo.channels = atoi(optarg);
            break;

        case 'g':
            channelswap = TRUE;
            break;

        case 1001:             // --scale
            twolame_set_scale(encopts, atof(optarg));
            break;

        case 1002:             // --scale-l
            twolame_set_scale_left(encopts, atof(optarg));
            break;

        case 1003:             // --scale-r
            twolame_set_scale_right(encopts, atof(optarg));
            break;



            // Output
        case 'm':
            if (*optarg == 's') {
                twolame_set_mode(encopts, TWOLAME_STEREO);
            } else if (*optarg == 'd') {
                twolame_set_mode(encopts, TWOLAME_DUAL_CHANNEL);
            } else if (*optarg == 'j') {
                twolame_set_mode(encopts, TWOLAME_JOINT_STEREO);
            } else if (*optarg == 'm') {
                twolame_set_mode(encopts, TWOLAME_MONO);
            } else if (*optarg == 'a') {
                twolame_set_mode(encopts, TWOLAME_AUTO_MODE);
            } else {
                fprintf(stderr, "Error: mode must be a/s/d/j/m not '%s'\n\n", optarg);
                usage_long();
            }
            break;

        case 'a':              // downmix
            twolame_set_mode(encopts, TWOLAME_MONO);
            break;

        case 'b':
            twolame_set_bitrate(encopts, atoi(optarg));
            break;

        case 'P':
            twolame_set_psymodel(encopts, atoi(optarg));
            break;

        case 'v':
            twolame_set_VBR(encopts, TRUE);
            break;

        case 'V':
            twolame_set_VBR(encopts, TRUE);
            twolame_set_VBR_level(encopts, atof(optarg));
            break;

        case 'B':
            twolame_set_VBR_max_bitrate_kbps(encopts, atoi(optarg));
            break;

        case 'l':
            twolame_set_ATH_level(encopts, atof(optarg));
            break;

        case 'q':
            twolame_set_quick_mode(encopts, TRUE);
            twolame_set_quick_count(encopts, atoi(optarg));
            break;

        case 'S':
            single_frame_mode = TRUE;
            break;


            // Miscellaneous 
        case 'c':
            twolame_set_copyright(encopts, TRUE);
            break;
        case 1004:              // --non-copyright
            twolame_set_copyright(encopts, FALSE);
            break;
        case 'o':              // --non-original
            twolame_set_original(encopts, FALSE);
            break;
        case 1005:             // --original
            twolame_set_original(encopts, TRUE);
            break;
        case 'p':
            twolame_set_error_protection(encopts, TRUE);
            break;
        case 'd':
            twolame_set_padding(encopts, TWOLAME_PAD_ALL);
            break;
        case 'R':
            twolame_set_num_ancillary_bits(encopts, atoi(optarg));
            break;
        case 'e':
            if (*optarg == 'n')
                twolame_set_emphasis(encopts, TWOLAME_EMPHASIS_N);
            else if (*optarg == '5')
                twolame_set_emphasis(encopts, TWOLAME_EMPHASIS_5);
            else if (*optarg == 'c')
                twolame_set_emphasis(encopts, TWOLAME_EMPHASIS_C);
            else {
                fprintf(stderr, "Error: emphasis must be n/5/c not '%s'\n\n", optarg);
                usage_long();
            }
            break;
        case 'E':
            twolame_set_energy_levels(encopts, TRUE);
            break;


            // Verbosity
        case 't':
            twolame_set_verbosity(encopts, atoi(optarg));
            break;

        case 1006:             // --quiet
            twolame_set_verbosity(encopts, 0);
            break;

        case 1007:             // --brief
            twolame_set_verbosity(encopts, 1);
            break;

        case 1008:             // --verbose
            twolame_set_verbosity(encopts, 4);
            break;

        case 'h':
            usage_long();
            break;

        default:
            usage_short();
            break;
        }
    }



    // Look for the input and output file names
    argc -= optind;
    argv += optind;
    while (argc) {
        if (inputfilename[0] == '\0')
            strncpy(inputfilename, *argv, MAX_NAME_SIZE);
        else if (outputfilename[0] == '\0')
            strncpy(outputfilename, *argv, MAX_NAME_SIZE);
        else {
            fprintf(stderr, "excess argument: %s\n", *argv);
            usage_short();
        }

        argv++;
        argc--;
    }


    // Check that we now have input and output file names ok
    if (inputfilename[0] == '\0') {
        fprintf(stderr, "Missing input filename.\n");
        usage_short();
    }
    if (outputfilename[0] == '\0' && strcmp(inputfilename, "-") != 0) {
        // Create output filename from the inputfilename 
        // and change the suffix
        new_extension(inputfilename, OUTPUT_SUFFIX, outputfilename);
    }
    if (outputfilename[0] == '\0') {
        fprintf(stderr, "Missing output filename.\n");
        usage_short();
    }
    // Check -r is supplied when reading from STDIN
    if (strcmp(inputfilename, "-") == 0 && !use_raw) {
        fprintf(stderr, "Error: please use RAW audio '-r' switch when reading from STDIN.\n");
        usage_short();
    }
}



static FILE *open_output_file(char *filename)
{
    FILE *file;


    // Do they want STDOUT ?
    if (strncmp(filename, "-", 1) == 0) {
        file = stdout;
    } else {
        file = fopen(filename, "wb");
    }

    // Check for errors
    if (file == NULL) {
        perror("Failed to open output file");
        exit(ERR_OPENING_OUTPUT);
    }

    return file;
}


int main(int argc, char **argv)
{
    twolame_options *encopts = NULL;
    audioin_t *inputfile = NULL;
    FILE *outputfile = NULL;
    short int *pcmaudio = NULL;
    unsigned int frame_count = 0;
    unsigned int total_frames = 0;
    unsigned int frame_len = 0;
    unsigned int total_bytes = 0;
    unsigned char *mp2buffer = NULL;
    int samples_read = 0;
    int mp2fill_size = 0;
    int audioReadSize = 0;


    // Allocate memory for the PCM audio data
    if ((pcmaudio = (short int *) calloc(AUDIO_BUF_SIZE, sizeof(short int))) == NULL) {
        fprintf(stderr, "Error: pcmaudio memory allocation failed\n");
        exit(ERR_MEM_ALLOC);
    }
    // Allocate memory for the encoded MP2 audio data
    if ((mp2buffer = (unsigned char *) calloc(MP2_BUF_SIZE, sizeof(unsigned char))) == NULL) {
        fprintf(stderr, "Error: mp2buffer memory allocation failed\n");
        exit(ERR_MEM_ALLOC);
    }
    // Initialise Encoder Options Structure 
    encopts = twolame_init();
    if (encopts == NULL) {
        fprintf(stderr, "Error: initializing libtwolame encoder failed.\n");
        exit(ERR_MEM_ALLOC);
    }
    // Get options and parameters from the command line
    parse_args(argc, argv, encopts);

    // Display the filenames
    print_filenames(twolame_get_verbosity(encopts));

    // Open the input file
    if (use_raw) {
        // use raw input handler
        inputfile = open_audioin_raw(inputfilename, &sfinfo, sample_size);
    } else {
        // use libsndfile
        inputfile = open_audioin_sndfile(inputfilename, &sfinfo);
    }

    // Display input information
    if (twolame_get_verbosity(encopts) > 1) {
        inputfile->print_info(inputfile);
    }
    // Use information from input file to configure libtwolame 
    twolame_set_num_channels(encopts, sfinfo.channels);
    twolame_set_in_samplerate(encopts, sfinfo.samplerate);


    // Open the output file
    outputfile = open_output_file(outputfilename);

    // initialise twolame with this set of options
    if (twolame_init_params(encopts) != 0) {
        fprintf(stderr, "Error: configuring libtwolame encoder failed.\n");
        exit(ERR_INVALID_PARAM);
    }
    // display encoder settings
    twolame_print_config(encopts);


    // Only encode a single frame of mpeg audio ?
    if (single_frame_mode)
        audioReadSize = TWOLAME_SAMPLES_PER_FRAME;
    else
        audioReadSize = AUDIO_BUF_SIZE;

    // Calculate the size and number of frames we are going to encode
    frame_len = twolame_get_framelength(encopts);
    if (sfinfo.frames)
        total_frames = sfinfo.frames / TWOLAME_SAMPLES_PER_FRAME;


    // Now do the reading/encoding/writing
    while ((samples_read = inputfile->read(inputfile, pcmaudio, audioReadSize)) > 0) {
        int bytes_out = 0;

        // Force byte swapping if requested
        if (byteswap) {
            int i;
            for (i = 0; i < samples_read; i++) {
                short tmp = pcmaudio[i];
                char *src = (char *) &tmp;
                char *dst = (char *) &pcmaudio[i];
                dst[0] = src[1];
                dst[1] = src[0];
            }
        }
        // Calculate the number of samples we have (per channel)
        samples_read /= sfinfo.channels;

        // Do swapping of left and right channels if requested
        if (channelswap && sfinfo.channels == 2) {
            int i;
            for (i = 0; i < samples_read; i++) {
                short tmp = pcmaudio[(2 * i)];
                pcmaudio[(2 * i)] = pcmaudio[(2 * i) + 1];
                pcmaudio[(2 * i) + 1] = tmp;
            }
        }
        // Encode the audio to MP2
        mp2fill_size =
            twolame_encode_buffer_interleaved(encopts, pcmaudio, samples_read, mp2buffer,
                                              MP2_BUF_SIZE);

        // Stop if we don't have any bytes (probably don't have enough audio for a full frame of
        // mpeg audio)
        if (mp2fill_size == 0)
            break;
        if (mp2fill_size < 0) {
            fprintf(stderr, "error while encoding audio: %d\n", mp2fill_size);
            exit(ERR_ENCODING);
        }
        // Check that a whole number of frame was written
        // if (mp2fill_size % frame_len != 0) {
        // fprintf(stderr,"error while encoding audio: non-whole number of frames written\n");
        // exit(ERR_ENCODING);
        // }

        // Write the encoded audio out
        bytes_out = fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outputfile);
        if (bytes_out != mp2fill_size) {
            perror("error while writing to output file");
            exit(ERR_WRITING_OUTPUT);
        }
        total_bytes += bytes_out;

        // Only single frame ?
        if (single_frame_mode)
            break;


        // Display Progress
        frame_count += (mp2fill_size / frame_len);
        if (twolame_get_verbosity(encopts) > 0) {
            fprintf(stderr, "\rEncoding frame: %i", frame_count);
            if (total_frames) {
                fprintf(stderr, "/%i (%i%%)", total_frames, (frame_count * 100) / total_frames);
            }
            fflush(stderr);
        }
    }

    // Was there an error reading the audio?
    if (inputfile->error_str(inputfile)) {
        fprintf(stderr, "Error reading from input file: %s\n", inputfile->error_str(inputfile));
    }
    // 
    // flush any remaining audio. (don't send any new audio data) There
    // should only ever be a max of 1 frame on a flush. There may be zero
    // frames if the audio data was an exact multiple of 1152
    // 
    mp2fill_size = twolame_encode_flush(encopts, mp2buffer, MP2_BUF_SIZE);
    if (mp2fill_size > 0) {
        frame_count++;
        int bytes_out = fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outputfile);
        if (bytes_out <= 0) {
            perror("error while writing to output file");
            exit(ERR_WRITING_OUTPUT);
        }
        total_bytes += bytes_out;
    }

    if (twolame_get_verbosity(encopts) > 1) {
        char *filesize = format_filesize_string(total_bytes);
        fprintf(stderr, "\nEncoding Finished.\n");
        fprintf(stderr, "Total bytes written: %s.\n", filesize);
        free(filesize);
    }
    // Close input and output streams
    inputfile->close(inputfile);
    fclose(outputfile);

    // Close the libtwolame encoder
    twolame_close(&encopts);


    // Free up memory
    free(pcmaudio);
    free(mp2buffer);

    return (ERR_NO_ERROR);
}

/* vim:ts=4:sw=4:nowrap: */