/*

 *      Command line parsing related functions

 *

 *      Copyright (c) 1999 Mark Taylor

 *                    2000-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: parse.c,v 1.307 2017/09/26 12:25:07 robert Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <assert.h>

#include <ctype.h>

#include <math.h>

#ifdef STDC_HEADERS

# include <stdio.h>

# 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_LIMITS_H

# include <limits.h>

#endif

#include "lame.h"

#include "parse.h"

#include "main.h"

#include "get_audio.h"

#include "version.h"

#include "console.h"

#undef dimension_of

#define dimension_of(array) (sizeof(array)/sizeof(array[0]))

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

#ifdef HAVE_ICONV

#include <iconv.h>

#include <errno.h>

#include <locale.h>

#include <langinfo.h>

#endif

#if defined _ALLOW_INTERNAL_OPTIONS

#define INTERNAL_OPTS 1

#else

#define INTERNAL_OPTS 0

#endif

#if (INTERNAL_OPTS!=0)

#include "set_get.h"

#define DEV_HELP(a) a

#else

#define DEV_HELP(a)

#define lame_set_tune(a,b) (void)0

#define lame_set_short_threshold(a,b,c) (void)0

#define lame_set_maskingadjust(a,b) (void)0

#define lame_set_maskingadjust_short(a,b) (void)0

#define lame_set_ATHcurve(a,b) (void)0

#define lame_set_preset_notune(a,b) (void)0

#define lame_set_substep(a,b) (void)0

#define lame_set_subblock_gain(a,b) (void)0

#define lame_set_sfscale(a,b) (void)0

#endif

static int const lame_alpha_version_enabled = LAME_ALPHA_VERSION;

static int const internal_opts_enabled = INTERNAL_OPTS;

/* GLOBAL VARIABLES.  set by parse_args() */

/* we need to clean this up */

ReaderConfig global_reader = { sf_unknown, 0, 0, 0, 0 };

WriterConfig global_writer = { 0 };

UiConfig global_ui_config = {0,0,0,0};

DecoderConfig global_decoder;

RawPCMConfig global_raw_pcm = 

{ /* in_bitwidth */ 16

, /* in_signed   */ -1

, /* in_endian   */ ByteOrderLittleEndian

};

/* possible text encodings */

typedef enum TextEncoding

{ TENC_RAW     /* bytes will be stored as-is into ID3 tags, which are Latin1 per definition */

, TENC_LATIN1  /* text will be converted from local encoding to Latin1, as ID3 needs it */

, TENC_UTF16   /* text will be converted from local encoding to Unicode, as ID3v2 wants it */

} TextEncoding;

#ifdef HAVE_ICONV

#define ID3TAGS_EXTENDED

/* search for Zero termination in multi-byte strings */

static size_t

strlenMultiByte(char const* str, size_t w)

{    

    size_t n = 0;

    if (str != 0) {

        size_t i, x = 0;

        for (n = 0; ; ++n) {

            x = 0;

            for (i = 0; i < w; ++i) {

                x += *str++ == 0 ? 1 : 0;

            }

            if (x == w) {

                break;

            }

        }

    }

    return n;

}

static size_t

currCharCodeSize(void)

{

    size_t n = 1;

    char dst[32];

    char* src = "A";

    char* cur_code = nl_langinfo(CODESET);

    iconv_t xiconv = iconv_open(cur_code, "ISO_8859-1");

    if (xiconv != (iconv_t)-1) {

        for (n = 0; n < 32; ++n) {

            char* i_ptr = src;

            char* o_ptr = dst;

            size_t srcln = 1;

            size_t avail = n;

            size_t rc = iconv(xiconv, &i_ptr, &srcln, &o_ptr, &avail);

            if (rc != (size_t)-1) {

                break;

            }

        }

        iconv_close(xiconv);

    }

    return n;

}

#if 0

static

char* fromLatin1( char* src )

{

    char* dst = 0;

    if (src != 0) {

        size_t const l = strlen(src);

        size_t const n = l*4;

        dst = calloc(n+4, 4);

        if (dst != 0) {

            char* cur_code = nl_langinfo(CODESET);

            iconv_t xiconv = iconv_open(cur_code, "ISO_8859-1");

            if (xiconv != (iconv_t)-1) {

                char* i_ptr = src;

                char* o_ptr = dst;

                size_t srcln = l;

                size_t avail = n;                

                iconv(xiconv, &i_ptr, &srcln, &o_ptr, &avail);

                iconv_close(xiconv);

            }

        }

    }

    return dst;

}

static

char* fromUtf16( char* src )

{

    char* dst = 0;

    if (src != 0) {

        size_t const l = strlenMultiByte(src, 2);

        size_t const n = l*4;

        dst = calloc(n+4, 4);

        if (dst != 0) {

            char* cur_code = nl_langinfo(CODESET);

            iconv_t xiconv = iconv_open(cur_code, "UTF-16LE");

            if (xiconv != (iconv_t)-1) {

                char* i_ptr = (char*)src;

                char* o_ptr = dst;

                size_t srcln = l*2;

                size_t avail = n;                

                iconv(xiconv, &i_ptr, &srcln, &o_ptr, &avail);

                iconv_close(xiconv);

            }

        }

    }

    return dst;

}

#endif

static

char* toLatin1( char* src )

{

    size_t w = currCharCodeSize();

    char* dst = 0;

    if (src != 0) {

        size_t const l = strlenMultiByte(src, w);

        size_t const n = l*4;

        dst = calloc(n+4, 4);

        if (dst != 0) {

            char* cur_code = nl_langinfo(CODESET);

            iconv_t xiconv = iconv_open("ISO_8859-1//TRANSLIT", cur_code);

            if (xiconv != (iconv_t)-1) {

                char* i_ptr = (char*)src;

                char* o_ptr = dst;

                size_t srcln = l*w;

                size_t avail = n;

                iconv(xiconv, &i_ptr, &srcln, &o_ptr, &avail);

                iconv_close(xiconv);

            }

        }

    }

    return dst;

}

static

char* toUtf16( char* src )

{

    size_t w = currCharCodeSize();

    char* dst = 0;

    if (src != 0) {

        size_t const l = strlenMultiByte(src, w);

        size_t const n = (l+1)*4;

        dst = calloc(n+4, 4);

        if (dst != 0) {

            char* cur_code = nl_langinfo(CODESET);

            iconv_t xiconv = iconv_open("UTF-16LE//TRANSLIT", cur_code);

            dst[0] = 0xff;

            dst[1] = 0xfe;

            if (xiconv != (iconv_t)-1) {

                char* i_ptr = (char*)src;

                char* o_ptr = &dst[2];

                size_t srcln = l*w;

                size_t avail = n;

                iconv(xiconv, &i_ptr, &srcln, &o_ptr, &avail);

                iconv_close(xiconv);

            }

        }

    }

    return dst;

}

#endif

#if defined( _WIN32 ) && !defined(__MINGW32__)

#define ID3TAGS_EXTENDED

char* toLatin1(char const* s)

{

    return utf8ToLatin1(s);

}

unsigned short* toUtf16(char const* s)

{

    return utf8ToUtf16(s);

}

#endif

static int evaluateArgument(char const* token, char const* arg, char* _EndPtr)

{

    if (arg != 0 && arg != _EndPtr)

        return 1;

    error_printf("WARNING: argument missing for '%s'\n", token);

    return 0;

}

static int getDoubleValue(char const* token, char const* arg, double* ptr)

{

    char *_EndPtr=0;

    double d = strtod(arg, &_EndPtr);

    if (ptr != 0) {

        *ptr = d;

    }

    return evaluateArgument(token, arg, _EndPtr);

}

static int getIntValue(char const* token, char const* arg, int* ptr)

{

    char *_EndPtr=0;

    long d = strtol(arg, &_EndPtr, 10);

    if (ptr != 0) {

        *ptr = d;

    }

    return evaluateArgument(token, arg, _EndPtr);

}

#ifdef ID3TAGS_EXTENDED

static int

set_id3v2tag(lame_global_flags* gfp, int type, unsigned short const* str)

{

    switch (type)

    {

        case 'a': return id3tag_set_textinfo_utf16(gfp, "TPE1", str);

        case 't': return id3tag_set_textinfo_utf16(gfp, "TIT2", str);

        case 'l': return id3tag_set_textinfo_utf16(gfp, "TALB", str);

        case 'g': return id3tag_set_textinfo_utf16(gfp, "TCON", str);

        case 'c': return id3tag_set_comment_utf16(gfp, 0, 0, str);

        case 'n': return id3tag_set_textinfo_utf16(gfp, "TRCK", str);

        case 'y': return id3tag_set_textinfo_utf16(gfp, "TYER", str);

        case 'v': return id3tag_set_fieldvalue_utf16(gfp, str);

    }

    return 0;

}

#endif

static int

set_id3tag(lame_global_flags* gfp, int type, char const* str)

{

    switch (type)

    {

        case 'a': return id3tag_set_artist(gfp, str), 0;

        case 't': return id3tag_set_title(gfp, str), 0;

        case 'l': return id3tag_set_album(gfp, str), 0;

        case 'g': return id3tag_set_genre(gfp, str);

        case 'c': return id3tag_set_comment(gfp, str), 0;

        case 'n': return id3tag_set_track(gfp, str);

        case 'y': return id3tag_set_year(gfp, str), 0;

        case 'v': return id3tag_set_fieldvalue(gfp, str);

    }

    return 0;

}

static int

id3_tag(lame_global_flags* gfp, int type, TextEncoding enc, char* str)

{

    void* x = 0;

    int result;

    if (enc == TENC_UTF16 && type != 'v' ) {

        id3_tag(gfp, type, TENC_LATIN1, str); /* for id3v1 */

    }

    switch (enc) 

    {

        default:

#ifdef ID3TAGS_EXTENDED

        case TENC_LATIN1: x = toLatin1(str); break;

        case TENC_UTF16:  x = toUtf16(str);   break;

#else

        case TENC_RAW:    x = strdup(str);   break;

#endif

    }

    switch (enc)

    {

        default:

#ifdef ID3TAGS_EXTENDED

        case TENC_LATIN1: result = set_id3tag(gfp, type, x);   break;

        case TENC_UTF16:  result = set_id3v2tag(gfp, type, x); break;

#else

        case TENC_RAW:    result = set_id3tag(gfp, type, x);   break;

#endif

    }

    free(x);

    return result;

}

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

*

* license

*

* PURPOSE:  Writes version and license to the file specified by fp

*

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

static int

lame_version_print(FILE * const fp)

{

    const char *b = get_lame_os_bitness();

    const char *v = get_lame_version();

    const char *u = get_lame_url();

    const size_t lenb = strlen(b);

    const size_t lenv = strlen(v);

    const size_t lenu = strlen(u);

    const size_t lw = 80;       /* line width of terminal in characters */

    const size_t sw = 16;       /* static width of text */

    if (lw >= lenb + lenv + lenu + sw || lw < lenu + 2)

        /* text fits in 80 chars per line, or line even too small for url */

        if (lenb > 0)

            fprintf(fp, "LAME %s version %s (%s)\n\n", b, v, u);

        else

            fprintf(fp, "LAME version %s (%s)\n\n", v, u);

    else {

        int const n_white_spaces = (int)((lenu+2) > lw ? 0 : lw-2-lenu);

        /* text too long, wrap url into next line, right aligned */

        if (lenb > 0)

            fprintf(fp, "LAME %s version %s\n%*s(%s)\n\n", b, v, n_white_spaces, "", u);

        else

            fprintf(fp, "LAME version %s\n%*s(%s)\n\n", v, n_white_spaces, "", u);

    }

    if (lame_alpha_version_enabled)

        fprintf(fp, "warning: alpha versions should be used for testing only\n\n");

    return 0;

}

static int

print_license(FILE * const fp)

{                       /* print version & license */

    lame_version_print(fp);

    fprintf(fp,

            "Copyright (c) 1999-2011 by The LAME Project\n"

            "Copyright (c) 1999,2000,2001 by Mark Taylor\n"

            "Copyright (c) 1998 by Michael Cheng\n"

            "Copyright (c) 1995,1996,1997 by Michael Hipp: mpglib\n" "\n");

    fprintf(fp,

            "This library is free software; you can redistribute it and/or\n"

            "modify it under the terms of the GNU Library General Public\n"

            "License as published by the Free Software Foundation; either\n"

            "version 2 of the License, or (at your option) any later version.\n"

            "\n");

    fprintf(fp,

            "This library is distributed in the hope that it will be useful,\n"

            "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

            "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"

            "Library General Public License for more details.\n"

            "\n");

    fprintf(fp,

            "You should have received a copy of the GNU Library General Public\n"

            "License along with this program. If not, see\n"

            "<http://www.gnu.org/licenses/>.\n");

    return 0;

}

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

*

* usage

*

* PURPOSE:  Writes command line syntax to the file specified by fp

*

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

int

usage(FILE * const fp, const char *ProgramName)

{                       /* print general syntax */

    lame_version_print(fp);

    fprintf(fp,

            "usage: %s [options] <infile> [outfile]\n"

            "\n"

            "    <infile> and/or <outfile> can be \"-\", which means stdin/stdout.\n"

            "\n"

            "Try:\n"

            "     \"%s --help\"           for general usage information\n"

            " or:\n"

            "     \"%s --preset help\"    for information on suggested predefined settings\n"

            " or:\n"

            "     \"%s --longhelp\"\n"

            "  or \"%s -?\"              for a complete options list\n\n",

            ProgramName, ProgramName, ProgramName, ProgramName, ProgramName);

    return 0;

}

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

*

* usage

*

* PURPOSE:  Writes command line syntax to the file specified by fp

*           but only the most important ones, to fit on a vt100 terminal

*

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

int

short_help(const lame_global_flags * gfp, FILE * const fp, const char *ProgramName)

{                       /* print short syntax help */

    lame_version_print(fp);

    fprintf(fp,

            "usage: %s [options] <infile> [outfile]\n"

            "\n"

            "    <infile> and/or <outfile> can be \"-\", which means stdin/stdout.\n"

            "\n" "RECOMMENDED:\n" "    lame -V2 input.wav output.mp3\n" "\n", ProgramName);

    fprintf(fp,

            "OPTIONS:\n"

            "    -b bitrate      set the bitrate, default 128 kbps\n"

            "    -h              higher quality, but a little slower.\n"

            "    -f              fast mode (lower quality)\n"

            "    -V n            quality setting for VBR.  default n=%i\n"

            "                    0=high quality,bigger files. 9.999=smaller files\n",

            lame_get_VBR_q(gfp));

    fprintf(fp,

            "    --preset type   type must be \"medium\", \"standard\", \"extreme\", \"insane\",\n"

            "                    or a value for an average desired bitrate and depending\n"

            "                    on the value specified, appropriate quality settings will\n"

            "                    be used.\n"

            "                    \"--preset help\" gives more info on these\n" "\n");

    fprintf(fp,

#if defined(WIN32)

            "    --priority type  sets the process priority\n"

            "                     0,1 = Low priority\n"

            "                     2   = normal priority\n"

            "                     3,4 = High priority\n" "\n"

#endif

#if defined(__OS2__)

            "    --priority type  sets the process priority\n"

            "                     0 = Low priority\n"

            "                     1 = Medium priority\n"

            "                     2 = Regular priority\n"

            "                     3 = High priority\n"

            "                     4 = Maximum priority\n" "\n"

#endif

            "    --help id3      ID3 tagging related options\n" "\n"

            DEV_HELP(

            "    --help dev      developer options\n" "\n"

            )

            "    --longhelp      full list of options\n" "\n"

            "    --license       print License information\n\n"

            );

    return 0;

}

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

*

* usage

*

* PURPOSE:  Writes command line syntax to the file specified by fp

*

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

static void

wait_for(FILE * const fp, int lessmode)

{

    if (lessmode) {

        fflush(fp);

        getchar();

    }

    else {

        fprintf(fp, "\n");

    }

    fprintf(fp, "\n");

}

static void

help_id3tag(FILE * const fp)

{

    fprintf(fp,

            "  ID3 tag options:\n"

            "    --tt <title>    audio/song title (max 30 chars for version 1 tag)\n"

            "    --ta <artist>   audio/song artist (max 30 chars for version 1 tag)\n"

            "    --tl <album>    audio/song album (max 30 chars for version 1 tag)\n"

            "    --ty <year>     audio/song year of issue (1 to 9999)\n"

            "    --tc <comment>  user-defined text (max 30 chars for v1 tag, 28 for v1.1)\n");

    fprintf(fp,

            "    --tn <track[/total]>   audio/song track number and (optionally) the total\n"

            "                           number of tracks on the original recording. (track\n"

            "                           and total each 1 to 255. just the track number\n"

            "                           creates v1.1 tag, providing a total forces v2.0).\n");

    fprintf(fp,

            "    --tg <genre>    audio/song genre (name or number in list)\n"

            "    --ti <file>     audio/song albumArt (jpeg/png/gif file, v2.3 tag)\n"

            "    --tv <id=value> user-defined frame specified by id and value (v2.3 tag)\n"

            "                    syntax: --tv \"TXXX=description=content\"\n"

            );

    fprintf(fp,

            "    --add-id3v2     force addition of version 2 tag\n"

            "    --id3v1-only    add only a version 1 tag\n"

            "    --id3v2-only    add only a version 2 tag\n"

#ifdef ID3TAGS_EXTENDED

            "    --id3v2-utf16   add following options in unicode text encoding\n"

            "    --id3v2-latin1  add following options in latin-1 text encoding\n"

#endif

            "    --space-id3v1   pad version 1 tag with spaces instead of nulls\n"

            "    --pad-id3v2     same as '--pad-id3v2-size 128'\n"

            "    --pad-id3v2-size <value> adds version 2 tag, pad with extra <value> bytes\n"

            "    --genre-list    print alphabetically sorted ID3 genre list and exit\n"

            "    --ignore-tag-errors  ignore errors in values passed for tags\n" "\n"

            );

    fprintf(fp,

            "    Note: A version 2 tag will NOT be added unless one of the input fields\n"

            "    won't fit in a version 1 tag (e.g. the title string is longer than 30\n"

            "    characters), or the '--add-id3v2' or '--id3v2-only' options are used,\n"

            "    or output is redirected to stdout.\n"

            );

}

static void

help_developer_switches(FILE * const fp)

{

    if ( !internal_opts_enabled ) {

    fprintf(fp,

            "    Note: Almost all of the following switches aren't available in this build!\n\n"

            );

    }

    fprintf(fp,

            "  ATH related:\n"

            "    --noath         turns ATH down to a flat noise floor\n"

            "    --athshort      ignore GPSYCHO for short blocks, use ATH only\n"

            "    --athonly       ignore GPSYCHO completely, use ATH only\n"

            "    --athtype n     selects between different ATH types [0-4]\n"

            "    --athlower x    lowers ATH by x dB\n"

            );

    fprintf(fp,

            "    --athaa-type n  ATH auto adjust: 0 'no' else 'loudness based'\n"

/** OBSOLETE "    --athaa-loudapprox n   n=1 total energy or n=2 equal loudness curve\n"*/

            "    --athaa-sensitivity x  activation offset in -/+ dB for ATH auto-adjustment\n"

            "\n");

    fprintf(fp,

            "  PSY related:\n"

            "    --short         use short blocks when appropriate\n"

            "    --noshort       do not use short blocks\n"

            "    --allshort      use only short blocks\n"

            );

    fprintf(fp,

            "(1) --temporal-masking x   x=0 disables, x=1 enables temporal masking effect\n"

            "    --nssafejoint   M/S switching criterion\n"

            "    --nsmsfix <arg> M/S switching tuning [effective 0-3.5]\n"

            "(2) --interch x     adjust inter-channel masking ratio\n"

            "    --ns-bass x     adjust masking for sfbs  0 -  6 (long)  0 -  5 (short)\n"

            "    --ns-alto x     adjust masking for sfbs  7 - 13 (long)  6 - 10 (short)\n"

            "    --ns-treble x   adjust masking for sfbs 14 - 21 (long) 11 - 12 (short)\n"

            );

    fprintf(fp,

            "    --ns-sfb21 x    change ns-treble by x dB for sfb21\n"

            "    --shortthreshold x,y  short block switching threshold,\n"

            "                          x for L/R/M channel, y for S channel\n"

            "    -Z [n]          always do calculate short block maskings\n");

    fprintf(fp,

            "  Noise Shaping related:\n"

            "(1) --substep n     use pseudo substep noise shaping method types 0-2\n"

            "(1) -X n[,m]        selects between different noise measurements\n"

            "                    n for long block, m for short. if m is omitted, m = n\n"

            " 1: CBR, ABR and VBR-old encoding modes only\n"

            " 2: ignored\n"

           );

}

int

long_help(const lame_global_flags * gfp, FILE * const fp, const char *ProgramName, int lessmode)

{                       /* print long syntax help */

    lame_version_print(fp);

    fprintf(fp,

            "usage: %s [options] <infile> [outfile]\n"

            "\n"

            "    <infile> and/or <outfile> can be \"-\", which means stdin/stdout.\n"

            "\n" "RECOMMENDED:\n" "    lame -V2 input.wav output.mp3\n" "\n", ProgramName);

    fprintf(fp,

            "OPTIONS:\n"

            "  Input options:\n"

            "    --scale <arg>   scale input (multiply PCM data) by <arg>\n"

            "    --scale-l <arg> scale channel 0 (left) input (multiply PCM data) by <arg>\n"

            "    --scale-r <arg> scale channel 1 (right) input (multiply PCM data) by <arg>\n"

            "    --swap-channel  swap L/R channels\n"

            "    --ignorelength  ignore file length in WAV header\n"

            "    --gain <arg>    apply Gain adjustment in decibels, range -20.0 to +12.0\n"

           );

#if (defined HAVE_MPGLIB || defined AMIGA_MPEGA)

    fprintf(fp,

            "    --mp1input      input file is a MPEG Layer I   file\n"

            "    --mp2input      input file is a MPEG Layer II  file\n"

            "    --mp3input      input file is a MPEG Layer III file\n"

           );

#endif

    fprintf(fp,

            "    --nogap <file1> <file2> <...>\n"

            "                    gapless encoding for a set of contiguous files\n"

            "    --nogapout <dir>\n"

            "                    output dir for gapless encoding (must precede --nogap)\n"

            "    --nogaptags     allow the use of VBR tags in gapless encoding\n"

            "    --out-dir <dir> output dir, must exist\n"

           );

    fprintf(fp,

            "\n"

            "  Input options for RAW PCM:\n"

            "    -r              input is raw pcm\n"

            "    -s sfreq        sampling frequency of input file (kHz) - default 44.1 kHz\n"

            "    --signed        input is signed (default)\n"

            "    --unsigned      input is unsigned\n"

            "    --bitwidth w    input bit width is w (default 16)\n"

            "    -x              force byte-swapping of input\n"

            "    --little-endian input is little-endian (default)\n"

            "    --big-endian    input is big-endian\n"

            "    -a              downmix from stereo to mono file for mono encoding\n"

           );

    wait_for(fp, lessmode);

    fprintf(fp,

            "  Operational options:\n"

            "    -m <mode>       (j)oint, (s)imple, (f)orce, (d)ual-mono, (m)ono (l)eft (r)ight\n"

            "                    default is (j)\n"

            "                    joint  = Uses the best possible of MS and LR stereo\n"

            "                    simple = force LR stereo on all frames\n"

            "                    force  = force MS stereo on all frames.\n"

	   );

    fprintf(fp,

            "    --preset type   type must be \"medium\", \"standard\", \"extreme\", \"insane\",\n"

            "                    or a value for an average desired bitrate and depending\n"

            "                    on the value specified, appropriate quality settings will\n"

            "                    be used.\n"

            "                    \"--preset help\" gives more info on these\n"

            "    --comp  <arg>   choose bitrate to achieve a compression ratio of <arg>\n");

    fprintf(fp, "    --replaygain-fast   compute RG fast but slightly inaccurately (default)\n"

#ifdef DECODE_ON_THE_FLY

            "    --replaygain-accurate   compute RG more accurately and find the peak sample\n"

#endif

            "    --noreplaygain  disable ReplayGain analysis\n"

#ifdef DECODE_ON_THE_FLY

            "    --clipdetect    enable --replaygain-accurate and print a message whether\n"

            "                    clipping occurs and how far the waveform is from full scale\n"

#endif

        );

    fprintf(fp,

            "    --flush         flush output stream as soon as possible\n"

            "    --freeformat    produce a free format bitstream\n"

            "    --decode        input=mp3 file, output=wav\n"

            "    -t              disable writing wav header when using --decode\n");

    wait_for(fp, lessmode);

    fprintf(fp,

            "  Verbosity:\n"

            "    --disptime <arg>print progress report every arg seconds\n"

            "    -S              don't print progress report, VBR histograms\n"

            "    --nohist        disable VBR histogram display\n"

            "    --quiet         don't print anything on screen\n"

            "    --silent        don't print anything on screen, but fatal errors\n"

            "    --brief         print more useful information\n"

            "    --verbose       print a lot of useful information\n" "\n");

    fprintf(fp,

            "  Noise shaping & psycho acoustic algorithms:\n"

            "    -q <arg>        <arg> = 0...9.  Default  -q 3 \n"

            "                    -q 0:  Highest quality, very slow \n"

            "                    -q 9:  Poor quality, but fast \n"

            "    -h              Same as -q 2.   \n"

            "    -f              Same as -q 7.   Fast, ok quality\n");

    wait_for(fp, lessmode);

    fprintf(fp,

            "  CBR (constant bitrate, the default) options:\n"

            "    -b <bitrate>    set the bitrate in kbps, default 128 kbps\n"

            "    --cbr           enforce use of constant bitrate\n"

            "\n"

            "  ABR options:\n"

            "    --abr <bitrate> specify average bitrate desired (instead of quality)\n" "\n");

    fprintf(fp,

            "  VBR options:\n"

            "    -V n            quality setting for VBR.  default n=%i\n"

            "                    0=high quality,bigger files. 9=smaller files\n"

            "    -v              the same as -V 4\n"

            "    --vbr-old       use old variable bitrate (VBR) routine\n"

            "    --vbr-new       use new variable bitrate (VBR) routine (default)\n"

            "    -Y              lets LAME ignore noise in sfb21, like in CBR\n"

			"                    (Default for V3 to V9.999)\n"

            ,

            lame_get_VBR_q(gfp));

    fprintf(fp,

            "    -b <bitrate>    specify minimum allowed bitrate, default  32 kbps\n"

            "    -B <bitrate>    specify maximum allowed bitrate, default 320 kbps\n"

            "    -F              strictly enforce the -b option, for use with players that\n"

            "                    do not support low bitrate mp3\n"

            "    -t              disable writing LAME Tag\n"

            "    -T              enable and force writing LAME Tag\n");

    wait_for(fp, lessmode);

    DEV_HELP(

        help_developer_switches(fp);

        wait_for(fp, lessmode);

            )

    fprintf(fp,

            "  MP3 header/stream options:\n"

            "    -e <emp>        de-emphasis n/5/c  (obsolete)\n"

            "    -c              mark as copyright\n"

            "    -o              mark as non-original\n"

            "    -p              error protection.  adds 16 bit checksum to every frame\n"

            "                    (the checksum is computed correctly)\n"

            "    --nores         disable the bit reservoir\n"

            "    --strictly-enforce-ISO   comply as much as possible to ISO MPEG spec\n");

    fprintf(fp,

            "    --buffer-constraint <constraint> available values for constraint:\n"

            "                                     default, strict, maximum\n"

            "\n"

            );

    fprintf(fp,

            "  Filter options:\n"

            "  --lowpass <freq>        frequency(kHz), lowpass filter cutoff above freq\n"

            "  --lowpass-width <freq>  frequency(kHz) - default 15%% of lowpass freq\n"

            "  --highpass <freq>       frequency(kHz), highpass filter cutoff below freq\n"

            "  --highpass-width <freq> frequency(kHz) - default 15%% of highpass freq\n");

    fprintf(fp,

            "  --resample <sfreq>  sampling frequency of output file(kHz)- default=automatic\n");

    wait_for(fp, lessmode);

    help_id3tag(fp);

    fprintf(fp,

#if defined(WIN32)

            "\n\nMS-Windows-specific options:\n"

            "    --priority <type>  sets the process priority:\n"

            "                         0,1 = Low priority (IDLE_PRIORITY_CLASS)\n"

            "                         2 = normal priority (NORMAL_PRIORITY_CLASS, default)\n"

            "                         3,4 = High priority (HIGH_PRIORITY_CLASS))\n"

            "    Note: Calling '--priority' without a parameter will select priority 0.\n"

#endif

#if defined(__OS2__)

            "\n\nOS/2-specific options:\n"

            "    --priority <type>  sets the process priority:\n"

            "                         0 = Low priority (IDLE, delta = 0)\n"

            "                         1 = Medium priority (IDLE, delta = +31)\n"

            "                         2 = Regular priority (REGULAR, delta = -31)\n"

            "                         3 = High priority (REGULAR, delta = 0)\n"

            "                         4 = Maximum priority (REGULAR, delta = +31)\n"

            "    Note: Calling '--priority' without a parameter will select priority 0.\n"

#endif

            "\nMisc:\n    --license       print License information\n\n"

        );

#if defined(HAVE_NASM)

    wait_for(fp, lessmode);

    fprintf(fp,

            "  Platform specific:\n"

            "    --noasm <instructions> disable assembly optimizations for mmx/3dnow/sse\n");

    wait_for(fp, lessmode);

#endif

    display_bitrates(fp);

    return 0;

}

static void

display_bitrate(FILE * const fp, const char *const version, const int d, const int indx)

{

    int     i;

    int nBitrates = 14;

    if (d == 4)

        nBitrates = 8;

    fprintf(fp,

            "\nMPEG-%-3s layer III sample frequencies (kHz):  %2d  %2d  %g\n"

            "bitrates (kbps):", version, 32 / d, 48 / d, 44.1 / d);

    for (i = 1; i <= nBitrates; i++)

        fprintf(fp, " %2i", lame_get_bitrate(indx, i));

    fprintf(fp, "\n");

}

int

display_bitrates(FILE * const fp)

{

    display_bitrate(fp, "1", 1, 1);

    display_bitrate(fp, "2", 2, 0);

    display_bitrate(fp, "2.5", 4, 0);

    fprintf(fp, "\n");

    fflush(fp);

    return 0;

}