diff options
Diffstat (limited to 'frontend/parse.c')
| -rw-r--r-- | frontend/parse.c | 2341 |
1 files changed, 2341 insertions, 0 deletions
diff --git a/frontend/parse.c b/frontend/parse.c new file mode 100644 index 0000000..2c6a10c --- /dev/null +++ b/frontend/parse.c @@ -0,0 +1,2341 @@ +/* + * Command line parsing related functions + * + * Copyright (c) 1999 Mark Taylor + * + * 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 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 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: parse.c,v 1.247.2.8 2009/12/11 22:44:25 robert Exp $ */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <assert.h> +#include <ctype.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 __OS2__ +#include <os2.h> +#define PRTYC_IDLE 1 +#define PRTYC_REGULAR 2 +#define PRTYD_MINIMUM -31 +#define PRTYD_MAXIMUM 31 +#endif + +#ifdef HAVE_LIMITS_H +# include <limits.h> +#endif + +#include "lame.h" +#include "set_get.h" + +#include "brhist.h" +#include "parse.h" +#include "main.h" +#include "get_audio.h" +#include "version.h" +#include "console.h" + +#ifdef WITH_DMALLOC +#include <dmalloc.h> +#endif + + +#ifdef HAVE_ICONV +#include <iconv.h> +#include <errno.h> +#endif + +#if defined DEBUG || _DEBUG || _ALLOW_INTERNAL_OPTIONS +#define INTERNAL_OPTS 1 +#else +#define INTERNAL_OPTS LAME_ALPHA_VERSION +#endif + +#if (INTERNAL_OPTS!=0) +#define DEV_HELP(a) a +#else +#define DEV_HELP(a) +#endif + + + +/* GLOBAL VARIABLES. set by parse_args() */ +/* we need to clean this up */ +sound_file_format input_format; +int swapbytes = 0; /* force byte swapping default=0 */ +int silent; /* Verbosity */ +int ignore_tag_errors; /* Ignore errors in values passed for tags */ +int brhist; +float update_interval; /* to use Frank's time status display */ +int mp3_delay; /* to adjust the number of samples truncated + during decode */ +int mp3_delay_set; /* user specified the value of the mp3 encoder + delay to assume for decoding */ + +int disable_wav_header; +mp3data_struct mp3input_data; /* used by MP3 */ +int print_clipping_info; /* print info whether waveform clips */ + + +int in_signed = -1; + +enum ByteOrder in_endian = ByteOrderLittleEndian; + +int in_bitwidth = 16; + +int flush_write = 0; + + + +/** + * Long Filename support for the WIN32 platform + * + */ +#ifdef WIN32 +#include <winbase.h> +static void +dosToLongFileName(char *fn) +{ + const int MSIZE = PATH_MAX + 1 - 4; /* we wanna add ".mp3" later */ + WIN32_FIND_DATAA lpFindFileData; + HANDLE h = FindFirstFileA(fn, &lpFindFileData); + if (h != INVALID_HANDLE_VALUE) { + int a; + char *q, *p; + FindClose(h); + for (a = 0; a < MSIZE; a++) { + if ('\0' == lpFindFileData.cFileName[a]) + break; + } + if (a >= MSIZE || a == 0) + return; + q = strrchr(fn, '\\'); + p = strrchr(fn, '/'); + if (p - q > 0) + q = p; + if (q == NULL) + q = strrchr(fn, ':'); + if (q == NULL) + strncpy(fn, lpFindFileData.cFileName, a); + else { + a += q - fn + 1; + if (a >= MSIZE) + return; + strncpy(++q, lpFindFileData.cFileName, MSIZE - a); + } + } +} +#endif +#if defined(WIN32) +#include <windows.h> +BOOL +SetPriorityClassMacro(DWORD p) +{ + HANDLE op = GetCurrentProcess(); + return SetPriorityClass(op, p); +} + +static void +setWin32Priority(lame_global_flags * gfp, int Priority) +{ + switch (Priority) { + case 0: + case 1: + SetPriorityClassMacro(IDLE_PRIORITY_CLASS); + console_printf("==> Priority set to Low.\n"); + break; + default: + case 2: + SetPriorityClassMacro(NORMAL_PRIORITY_CLASS); + console_printf("==> Priority set to Normal.\n"); + break; + case 3: + case 4: + SetPriorityClassMacro(HIGH_PRIORITY_CLASS); + console_printf("==> Priority set to High.\n"); + break; + } +} +#endif + + +#if defined(__OS2__) +/* OS/2 priority functions */ +static int +setOS2Priority(lame_global_flags * gfp, int Priority) +{ + int rc; + + switch (Priority) { + + case 0: + rc = DosSetPriority(0, /* Scope: only one process */ + PRTYC_IDLE, /* select priority class (idle, regular, etc) */ + 0, /* set delta */ + 0); /* Assume current process */ + console_printf("==> Priority set to 0 (Low priority).\n"); + break; + + case 1: + rc = DosSetPriority(0, /* Scope: only one process */ + PRTYC_IDLE, /* select priority class (idle, regular, etc) */ + PRTYD_MAXIMUM, /* set delta */ + 0); /* Assume current process */ + console_printf("==> Priority set to 1 (Medium priority).\n"); + break; + + case 2: + rc = DosSetPriority(0, /* Scope: only one process */ + PRTYC_REGULAR, /* select priority class (idle, regular, etc) */ + PRTYD_MINIMUM, /* set delta */ + 0); /* Assume current process */ + console_printf("==> Priority set to 2 (Regular priority).\n"); + break; + + case 3: + rc = DosSetPriority(0, /* Scope: only one process */ + PRTYC_REGULAR, /* select priority class (idle, regular, etc) */ + 0, /* set delta */ + 0); /* Assume current process */ + console_printf("==> Priority set to 3 (High priority).\n"); + break; + + case 4: + rc = DosSetPriority(0, /* Scope: only one process */ + PRTYC_REGULAR, /* select priority class (idle, regular, etc) */ + PRTYD_MAXIMUM, /* set delta */ + 0); /* Assume current process */ + console_printf("==> Priority set to 4 (Maximum priority). I hope you enjoy it :)\n"); + break; + + default: + console_printf("==> Invalid priority specified! Assuming idle priority.\n"); + } + + + return 0; +} +#endif + + +extern int +id3tag_set_textinfo_ucs2(lame_global_flags* gfp, char const* id, unsigned short const* text); + +extern int +id3tag_set_comment_ucs2(lame_global_flags* gfp, char const* lng, unsigned short const* desc, unsigned short const* text); + +/* possible text encodings */ +typedef enum TextEncoding +{ TENC_RAW /* bytes will be stored as-is into ID3 tags, which are Latin1/UCS2 per definition */ +, TENC_LATIN1 /* text will be converted from local encoding to Latin1, as ID3 needs it */ +, TENC_UCS2 /* text will be converted from local encoding to UCS-2, as ID3v2 wants it */ +} TextEncoding; + +#ifdef HAVE_ICONV + +/* 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* env_lang = getenv("LANG"); + char* xxx_code = env_lang == NULL ? NULL : strrchr(env_lang, '.'); + char* cur_code = xxx_code == NULL ? "" : xxx_code+1; + 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* env_lang = getenv("LANG"); + char* xxx_code = env_lang == NULL ? NULL : strrchr(env_lang, '.'); + char* cur_code = xxx_code == NULL ? "" : xxx_code+1; + 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* fromUcs2( 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* env_lang = getenv("LANG"); + char* xxx_code = env_lang == NULL ? NULL : strrchr(env_lang, '.'); + char* cur_code = xxx_code == NULL ? "" : xxx_code+1; + iconv_t xiconv = iconv_open(cur_code, "UCS-2LE"); + 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* env_lang = getenv("LANG"); + char* xxx_code = env_lang == NULL ? NULL : strrchr(env_lang, '.'); + char* cur_code = xxx_code == NULL ? "" : xxx_code+1; + iconv_t xiconv = iconv_open("ISO_8859-1", 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* toUcs2( 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* env_lang = getenv("LANG"); + char* xxx_code = env_lang == NULL ? NULL : strrchr(env_lang, '.'); + char* cur_code = xxx_code == NULL ? "" : xxx_code+1; + iconv_t xiconv = iconv_open("UCS-2LE", 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; +} + + +static int +set_id3v2tag(lame_global_flags* gfp, int type, unsigned short const* str) +{ + switch (type) + { + case 'a': return id3tag_set_textinfo_ucs2(gfp, "TPE1", str); + case 't': return id3tag_set_textinfo_ucs2(gfp, "TIT2", str); + case 'l': return id3tag_set_textinfo_ucs2(gfp, "TALB", str); + case 'g': return id3tag_set_textinfo_ucs2(gfp, "TCON", str); + case 'c': return id3tag_set_comment_ucs2(gfp, 0, 0, str); + case 'n': return id3tag_set_textinfo_ucs2(gfp, "TRCK", 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; + switch (enc) + { + default: + case TENC_RAW: x = strdup(str); break; +#ifdef HAVE_ICONV + case TENC_LATIN1: x = toLatin1(str); break; + case TENC_UCS2: x = toUcs2(str); break; +#endif + } + switch (enc) + { + default: + case TENC_RAW: + case TENC_LATIN1: result = set_id3tag(gfp, type, x); break; +#ifdef HAVE_ICONV + case TENC_UCS2: result = set_id3v2tag(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 + /* 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, lw - 2 - lenu, "", u); + else + fprintf(fp, "LAME version %s\n%*s(%s)\n\n", v, lw - 2 - lenu, "", u); + + if (LAME_ALPHA_VERSION) + 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, + "Can I use LAME in my commercial program?\n" + "\n" + "Yes, you can, under the restrictions of the LGPL. In particular, you\n" + "can include a compiled version of the LAME library (for example,\n" + "lame.dll) with a commercial program. Some notable requirements of\n" + "the LGPL:\n" "\n"); + fprintf(fp, + "1. In your program, you cannot include any source code from LAME, with\n" + " the exception of files whose only purpose is to describe the library\n" + " interface (such as lame.h).\n" "\n"); + fprintf(fp, + "2. Any modifications of LAME must be released under the LGPL.\n" + " The LAME project (www.mp3dev.org) would appreciate being\n" + " notified of any modifications.\n" "\n"); + fprintf(fp, + "3. You must give prominent notice that your program is:\n" + " A. using LAME (including version number)\n" + " B. LAME is under the LGPL\n" + " C. Provide a copy of the LGPL. (the file COPYING contains the LGPL)\n" + " D. Provide a copy of LAME source, or a pointer where the LAME\n" + " source can be obtained (such as www.mp3dev.org)\n" + " An example of prominent notice would be an \"About the LAME encoding engine\"\n" + " button in some pull down menu within the executable of your program.\n" "\n"); + fprintf(fp, + "4. If you determine that distribution of LAME requires a patent license,\n" + " you must obtain such license.\n" "\n" "\n"); + fprintf(fp, + "*** IMPORTANT NOTE ***\n" + "\n" + "The decoding functions provided in LAME use the mpglib decoding engine which\n" + "is under the GPL. They may not be used by any program not released under the\n" + "GPL unless you obtain such permission from the MPG123 project (www.mpg123.de).\n" + "\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. Recommended.\n" + " -f fast mode (lower quality)\n" + " -V n quality setting for VBR. default n=%i\n" + " 0=high quality,bigger files. 9=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 + " --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"); +} + +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" +#if (defined HAVE_MPGLIB || defined AMIGA_MPEGA) + " --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 + " --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" + ); + fprintf(fp, + "\n" + " Input options for RAW PCM:\n" + " -r input is raw pcm\n" + " -x force byte-swapping of input\n" + " -s sfreq sampling frequency of input file (kHz) - default 44.1 kHz\n" + " --bitwidth w input bit width is w (default 16)\n" + " --signed input is signed (default)\n" + " --unsigned input is unsigned\n" + " --little-endian input is little-endian (default)\n" + " --big-endian input is big-endian\n" + ); + + wait_for(fp, lessmode); + fprintf(fp, + " Operational options:\n" + " -a downmix from stereo to mono file for mono encoding\n" + " -m <mode> (j)oint, (s)imple, (f)orce, (d)dual-mono, (m)ono\n" + " default is (j) or (s) depending on bitrate\n" + " joint = joins 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" + " --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 achive 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" + " --silent don't print anything on screen\n" + " --quiet don't print anything on screen\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 5 \n" + " -q 0: Highest quality, very slow \n" + " -q 9: Poor quality, but fast \n" + " -h Same as -q 2. Recommended.\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" + , + 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(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" + DEV_HELP( + " --short use short blocks when appropriate\n" + " --noshort do not use short blocks\n" + " --allshort use only short blocks\n" + ) + ); + fprintf(fp, + " --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" + " --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" + DEV_HELP(" --shortthreshold x,y short block switching threshold,\n" + " x for L/R/M channel, y for S channel\n" + " Noise Shaping related:\n" + " --substep n use pseudo substep noise shaping method types 0-2\n") + ); + + wait_for(fp, lessmode); + + fprintf(fp, + " experimental switches:\n" + DEV_HELP( + " -X n[,m] selects between different noise measurements\n" + " n for long block, m for short. if m is omitted, m = n\n" + ) + " -Y lets LAME ignore noise in sfb21, like in CBR\n" + DEV_HELP( + " -Z [n] currently no effects\n" + ) + ); + + 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" "\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); + 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" + " --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" + " --tg <genre> audio/song genre (name or number in list)\n" + " --ti <file> audio/song albumArt (jpeg/png/gif file, 128KB max, v2.3)\n" + " --tv <id=value> user-defined frame specified by id and value (v2.3 tag)\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" + " --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" +#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", bitrate_table[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; +} + + +/* note: for presets it would be better to externalize them in a file. + suggestion: lame --preset <file-name> ... + or: lame --preset my-setting ... and my-setting is defined in lame.ini + */ + +/* +Note from GB on 08/25/2002: +I am merging --presets and --alt-presets. Old presets are now aliases for +corresponding abr values from old alt-presets. This way we now have a +unified preset system, and I hope than more people will use the new tuned +presets instead of the old unmaintained ones. +*/ + + + +/************************************************************************ +* +* usage +* +* PURPOSE: Writes presetting info to #stdout# +* +************************************************************************/ + + +static void +presets_longinfo_dm(FILE * msgfp) +{ + fprintf(msgfp, + "\n" + "The --preset switches are aliases over LAME settings.\n" + "\n" "\n"); + fprintf(msgfp, + "To activate these presets:\n" + "\n" " For VBR modes (generally highest quality):\n" "\n"); + fprintf(msgfp, + " \"--preset medium\" This preset should provide near transparency\n" + " to most people on most music.\n" + "\n" + " \"--preset standard\" This preset should generally be transparent\n" + " to most people on most music and is already\n" + " quite high in quality.\n" "\n"); + fprintf(msgfp, + " \"--preset extreme\" If you have extremely good hearing and similar\n" + " equipment, this preset will generally provide\n" + " slightly higher quality than the \"standard\"\n" + " mode.\n" "\n"); + fprintf(msgfp, + " For CBR 320kbps (highest quality possible from the --preset switches):\n" + "\n" + " \"--preset insane\" This preset will usually be overkill for most\n" + " people and most situations, but if you must\n" + " have the absolute highest quality with no\n" + " regard to filesize, this is the way to go.\n" "\n"); + fprintf(msgfp, + " For ABR modes (high quality per given bitrate but not as high as VBR):\n" + "\n" + " \"--preset <kbps>\" Using this preset will usually give you good\n" + " quality at a specified bitrate. Depending on the\n" + " bitrate entered, this preset will determine the\n"); + fprintf(msgfp, + " optimal settings for that particular situation.\n" + " While this approach works, it is not nearly as\n" + " flexible as VBR, and usually will not attain the\n" + " same level of quality as VBR at higher bitrates.\n" "\n"); + fprintf(msgfp, + "The following options are also available for the corresponding profiles:\n" + "\n" + " <fast> standard\n" + " <fast> extreme\n" + " insane\n" + " <cbr> (ABR Mode) - The ABR Mode is implied. To use it,\n" + " simply specify a bitrate. For example:\n" + " \"--preset 185\" activates this\n" + " preset and uses 185 as an average kbps.\n" "\n"); + fprintf(msgfp, + " \"fast\" - Enables the fast VBR mode for a particular profile.\n" "\n"); + fprintf(msgfp, + " \"cbr\" - If you use the ABR mode (read above) with a significant\n" + " bitrate such as 80, 96, 112, 128, 160, 192, 224, 256, 320,\n" + " you can use the \"cbr\" option to force CBR mode encoding\n" + " instead of the standard abr mode. ABR does provide higher\n" + " quality but CBR may be useful in situations such as when\n" + " streaming an mp3 over the internet may be important.\n" "\n"); + fprintf(msgfp, + " For example:\n" + "\n" + " \"--preset fast standard <input file> <output file>\"\n" + " or \"--preset cbr 192 <input file> <output file>\"\n" + " or \"--preset 172 <input file> <output file>\"\n" + " or \"--preset extreme <input file> <output file>\"\n" "\n" "\n"); + fprintf(msgfp, + "A few aliases are also available for ABR mode:\n" + "phone => 16kbps/mono phon+/lw/mw-eu/sw => 24kbps/mono\n" + "mw-us => 40kbps/mono voice => 56kbps/mono\n" + "fm/radio/tape => 112kbps hifi => 160kbps\n" + "cd => 192kbps studio => 256kbps\n"); +} + + +extern void lame_set_msfix(lame_t gfp, double msfix); + + + +static int +presets_set(lame_t gfp, int fast, int cbr, const char *preset_name, const char *ProgramName) +{ + int mono = 0; + + if ((strcmp(preset_name, "help") == 0) && (fast < 1) + && (cbr < 1)) { + lame_version_print(stdout); + presets_longinfo_dm(stdout); + return -1; + } + + + + /*aliases for compatibility with old presets */ + + if (strcmp(preset_name, "phone") == 0) { + preset_name = "16"; + mono = 1; + } + if ((strcmp(preset_name, "phon+") == 0) || + (strcmp(preset_name, "lw") == 0) || + (strcmp(preset_name, "mw-eu") == 0) || (strcmp(preset_name, "sw") == 0)) { + preset_name = "24"; + mono = 1; + } + if (strcmp(preset_name, "mw-us") == 0) { + preset_name = "40"; + mono = 1; + } + if (strcmp(preset_name, "voice") == 0) { + preset_name = "56"; + mono = 1; + } + if (strcmp(preset_name, "fm") == 0) { + preset_name = "112"; + } + if ((strcmp(preset_name, "radio") == 0) || (strcmp(preset_name, "tape") == 0)) { + preset_name = "112"; + } + if (strcmp(preset_name, "hifi") == 0) { + preset_name = "160"; + } + if (strcmp(preset_name, "cd") == 0) { + preset_name = "192"; + } + if (strcmp(preset_name, "studio") == 0) { + preset_name = "256"; + } + + if (strcmp(preset_name, "medium") == 0) { + lame_set_VBR_q(gfp, 4); + if (fast > 0) { + lame_set_VBR(gfp, vbr_mtrh); + } + else { + lame_set_VBR(gfp, vbr_rh); + } + return 0; + } + + if (strcmp(preset_name, "standard") == 0) { + lame_set_VBR_q(gfp, 2); + if (fast > 0) { + lame_set_VBR(gfp, vbr_mtrh); + } + else { + lame_set_VBR(gfp, vbr_rh); + } + return 0; + } + + else if (strcmp(preset_name, "extreme") == 0) { + lame_set_VBR_q(gfp, 0); + if (fast > 0) { + lame_set_VBR(gfp, vbr_mtrh); + } + else { + lame_set_VBR(gfp, vbr_rh); + } + return 0; + } + + else if ((strcmp(preset_name, "insane") == 0) && (fast < 1)) { + + lame_set_preset(gfp, INSANE); + + return 0; + } + + /* Generic ABR Preset */ + if (((atoi(preset_name)) > 0) && (fast < 1)) { + if ((atoi(preset_name)) >= 8 && (atoi(preset_name)) <= 320) { + lame_set_preset(gfp, atoi(preset_name)); + + if (cbr == 1) + lame_set_VBR(gfp, vbr_off); + + if (mono == 1) { + lame_set_mode(gfp, MONO); + } + + return 0; + + } + else { + lame_version_print(Console_IO.Error_fp); + error_printf("Error: The bitrate specified is out of the valid range for this preset\n" + "\n" + "When using this mode you must enter a value between \"32\" and \"320\"\n" + "\n" "For further information try: \"%s --preset help\"\n", ProgramName); + return -1; + } + } + + lame_version_print(Console_IO.Error_fp); + error_printf("Error: You did not enter a valid profile and/or options with --preset\n" + "\n" + "Available profiles are:\n" + "\n" + " <fast> medium\n" + " <fast> standard\n" + " <fast> extreme\n" + " insane\n" + " <cbr> (ABR Mode) - The ABR Mode is implied. To use it,\n" + " simply specify a bitrate. For example:\n" + " \"--preset 185\" activates this\n" + " preset and uses 185 as an average kbps.\n" "\n"); + error_printf(" Some examples:\n" + "\n" + " or \"%s --preset fast standard <input file> <output file>\"\n" + " or \"%s --preset cbr 192 <input file> <output file>\"\n" + " or \"%s --preset 172 <input file> <output file>\"\n" + " or \"%s --preset extreme <input file> <output file>\"\n" + "\n" + "For further information try: \"%s --preset help\"\n", ProgramName, ProgramName, + ProgramName, ProgramName, ProgramName); + return -1; +} + +static void +genre_list_handler(int num, const char *name, void *cookie) +{ + (void) cookie; + console_printf("%3d %s\n", num, name); +} + + +/************************************************************************ +* +* parse_args +* +* PURPOSE: Sets encoding parameters to the specifications of the +* command line. Default settings are used for parameters +* not specified in the command line. +* +* If the input file is in WAVE or AIFF format, the sampling frequency is read +* from the AIFF header. +* +* The input and output filenames are read into #inpath# and #outpath#. +* +************************************************************************/ + +/* would use real "strcasecmp" but it isn't portable */ +static int +local_strcasecmp(const char *s1, const char *s2) +{ + unsigned char c1; + unsigned char c2; + + do { + c1 = tolower(*s1); + c2 = tolower(*s2); + if (!c1) { + break; + } + ++s1; + ++s2; + } while (c1 == c2); + return c1 - c2; +} + + + +/* LAME is a simple frontend which just uses the file extension */ +/* to determine the file type. Trying to analyze the file */ +/* contents is well beyond the scope of LAME and should not be added. */ +static int +filename_to_type(const char *FileName) +{ + size_t len = strlen(FileName); + + if (len < 4) + return sf_unknown; + + FileName += len - 4; + if (0 == local_strcasecmp(FileName, ".mpg")) + return sf_mp123; + if (0 == local_strcasecmp(FileName, ".mp1")) + return sf_mp123; + if (0 == local_strcasecmp(FileName, ".mp2")) + return sf_mp123; + if (0 == local_strcasecmp(FileName, ".mp3")) + return sf_mp123; + if (0 == local_strcasecmp(FileName, ".wav")) + return sf_wave; + if (0 == local_strcasecmp(FileName, ".aif")) + return sf_aiff; + if (0 == local_strcasecmp(FileName, ".raw")) + return sf_raw; + if (0 == local_strcasecmp(FileName, ".ogg")) + return sf_ogg; + return sf_unknown; +} + +static int +resample_rate(double freq) +{ + if (freq >= 1.e3) + freq *= 1.e-3; + + switch ((int) freq) { + case 8: + return 8000; + case 11: + return 11025; + case 12: + return 12000; + case 16: + return 16000; + case 22: + return 22050; + case 24: + return 24000; + case 32: + return 32000; + case 44: + return 44100; + case 48: + return 48000; + default: + error_printf("Illegal resample frequency: %.3f kHz\n", freq); + return 0; + } +} + + +static int +set_id3_albumart(lame_t gfp, char const* file_name) +{ + int ret = -1; + FILE *fpi = 0; + char *albumart = 0; + + if (file_name == 0) { + return 0; + } + fpi = fopen(file_name, "rb"); + if (!fpi) { + ret = 1; + } + else { + size_t size; + + fseek(fpi, 0, SEEK_END); + size = ftell(fpi); + fseek(fpi, 0, SEEK_SET); + albumart = (char *)malloc(size); + if (!albumart) { + ret = 2; + } + else { + if (fread(albumart, 1, size, fpi) != size) { + ret = 3; + } + else { + ret = id3tag_set_albumart(gfp, albumart, size) ? 4 : 0; + } + free(albumart); + } + fclose(fpi); + } + switch (ret) { + case 1: error_printf("Could not find: '%s'.\n", file_name); break; + case 2: error_printf("Insufficient memory for reading the albumart.\n"); break; + case 3: error_printf("Read error: '%s'.\n", file_name); break; + case 4: error_printf("Unsupported image: '%s'.\nSpecify JPEG/PNG/GIF image (128KB maximum)\n", file_name); break; + default: break; + } + return ret; +} + + +enum ID3TAG_MODE +{ ID3TAG_MODE_DEFAULT +, ID3TAG_MODE_V1_ONLY +, ID3TAG_MODE_V2_ONLY +}; + +/* Ugly, NOT final version */ + +#define T_IF(str) if ( 0 == local_strcasecmp (token,str) ) { +#define T_ELIF(str) } else if ( 0 == local_strcasecmp (token,str) ) { +#define T_ELIF_INTERNAL(str) } else if (INTERNAL_OPTS && (0 == local_strcasecmp (token,str)) ) { +#define T_ELIF2(str1,str2) } else if ( 0 == local_strcasecmp (token,str1) || 0 == local_strcasecmp (token,str2) ) { +#define T_ELSE } else { +#define T_END } + +int +parse_args(lame_global_flags * gfp, int argc, char **argv, + char *const inPath, char *const outPath, char **nogap_inPath, int *num_nogap) +{ + int input_file = 0; /* set to 1 if we parse an input file name */ + int i; + int autoconvert = 0; + double val; + int nogap = 0; + int nogap_tags = 0; /* set to 1 to use VBR tags in NOGAP mode */ + const char *ProgramName = argv[0]; + int count_nogap = 0; + int noreplaygain = 0; /* is RG explicitly disabled by the user */ + int id3tag_mode = ID3TAG_MODE_DEFAULT; + + inPath[0] = '\0'; + outPath[0] = '\0'; + /* turn on display options. user settings may turn them off below */ + silent = 0; + ignore_tag_errors = 0; + brhist = 1; + mp3_delay = 0; + mp3_delay_set = 0; + print_clipping_info = 0; + disable_wav_header = 0; + id3tag_init(gfp); + + /* process args */ + for (i = 0; ++i < argc;) { + char c; + char *token; + char *arg; + char *nextArg; + int argUsed; + + token = argv[i]; + if (*token++ == '-') { + argUsed = 0; + nextArg = i + 1 < argc ? argv[i + 1] : ""; + + if (!*token) { /* The user wants to use stdin and/or stdout. */ + input_file = 1; + if (inPath[0] == '\0') + strncpy(inPath, argv[i], PATH_MAX + 1); + else if (outPath[0] == '\0') + strncpy(outPath, argv[i], PATH_MAX + 1); + } + if (*token == '-') { /* GNU style */ + token++; + + T_IF("resample") + argUsed = 1; + (void) lame_set_out_samplerate(gfp, resample_rate(atof(nextArg))); + + T_ELIF("vbr-old") + lame_set_VBR(gfp, vbr_rh); + + T_ELIF("vbr-new") + lame_set_VBR(gfp, vbr_mtrh); + + T_ELIF("vbr-mtrh") + lame_set_VBR(gfp, vbr_mtrh); + + T_ELIF("cbr") + lame_set_VBR(gfp, vbr_off); + + T_ELIF("abr") + argUsed = 1; + lame_set_VBR(gfp, vbr_abr); + lame_set_VBR_mean_bitrate_kbps(gfp, atoi(nextArg)); + /* values larger than 8000 are bps (like Fraunhofer), so it's strange to get 320000 bps MP3 when specifying 8000 bps MP3 */ + if (lame_get_VBR_mean_bitrate_kbps(gfp) >= 8000) + lame_set_VBR_mean_bitrate_kbps(gfp, + (lame_get_VBR_mean_bitrate_kbps(gfp) + + 500) / 1000); + + lame_set_VBR_mean_bitrate_kbps(gfp, Min(lame_get_VBR_mean_bitrate_kbps(gfp), 320)); + lame_set_VBR_mean_bitrate_kbps(gfp, Max(lame_get_VBR_mean_bitrate_kbps(gfp), 8)); + + T_ELIF("r3mix") + lame_set_preset(gfp, R3MIX); + + T_ELIF("bitwidth") + argUsed = 1; + in_bitwidth = atoi(nextArg); + + T_ELIF("signed") + in_signed = 1; + + T_ELIF("unsigned") + in_signed = 0; + + T_ELIF("little-endian") + in_endian = ByteOrderLittleEndian; + + T_ELIF("big-endian") + in_endian = ByteOrderBigEndian; + + T_ELIF("mp1input") + input_format = sf_mp1; + + T_ELIF("mp2input") + input_format = sf_mp2; + + T_ELIF("mp3input") + input_format = sf_mp3; + + T_ELIF("ogginput") + error_printf("sorry, vorbis support in LAME is deprecated.\n"); + return -1; + + T_ELIF("phone") + if (presets_set(gfp, 0, 0, token, ProgramName) < 0) + return -1; + error_printf("Warning: --phone is deprecated, use --preset phone instead!"); + + T_ELIF("voice") + if (presets_set(gfp, 0, 0, token, ProgramName) < 0) + return -1; + error_printf("Warning: --voice is deprecated, use --preset voice instead!"); + + T_ELIF_INTERNAL("noshort") + (void) lame_set_no_short_blocks(gfp, 1); + + T_ELIF_INTERNAL("short") + (void) lame_set_no_short_blocks(gfp, 0); + + T_ELIF_INTERNAL("allshort") + (void) lame_set_force_short_blocks(gfp, 1); + + + T_ELIF("decode") + (void) lame_set_decode_only(gfp, 1); + + T_ELIF("flush") + flush_write = 1; + + T_ELIF("decode-mp3delay") + mp3_delay = atoi(nextArg); + mp3_delay_set = 1; + argUsed = 1; + + T_ELIF("nores") + lame_set_disable_reservoir(gfp, 1); + + T_ELIF("strictly-enforce-ISO") + lame_set_strict_ISO(gfp, 1); + + T_ELIF("scale") + argUsed = 1; + (void) lame_set_scale(gfp, (float) atof(nextArg)); + + T_ELIF("scale-l") + argUsed = 1; + (void) lame_set_scale_left(gfp, (float) atof(nextArg)); + + T_ELIF("scale-r") + argUsed = 1; + (void) lame_set_scale_right(gfp, (float) atof(nextArg)); + + T_ELIF("noasm") + argUsed = 1; + if (!strcmp(nextArg, "mmx")) + (void) lame_set_asm_optimizations(gfp, MMX, 0); + if (!strcmp(nextArg, "3dnow")) + (void) lame_set_asm_optimizations(gfp, AMD_3DNOW, 0); + if (!strcmp(nextArg, "sse")) + (void) lame_set_asm_optimizations(gfp, SSE, 0); + + T_ELIF("freeformat") + lame_set_free_format(gfp, 1); + + T_ELIF("replaygain-fast") + lame_set_findReplayGain(gfp, 1); + +#ifdef DECODE_ON_THE_FLY + T_ELIF("replaygain-accurate") + lame_set_decode_on_the_fly(gfp, 1); + lame_set_findReplayGain(gfp, 1); +#endif + + T_ELIF("noreplaygain") + noreplaygain = 1; + lame_set_findReplayGain(gfp, 0); + + +#ifdef DECODE_ON_THE_FLY + T_ELIF("clipdetect") + print_clipping_info = 1; + lame_set_decode_on_the_fly(gfp, 1); +#endif + + T_ELIF("nohist") + brhist = 0; + +#if defined(__OS2__) || defined(WIN32) + T_ELIF("priority") + char *endptr; + int priority = (int) strtol(nextArg, &endptr, 10); + if (endptr != nextArg) { + argUsed = 1; + } +# if defined(__OS2__) + setOS2Priority(gfp, priority); +# else /* WIN32 */ + setWin32Priority(gfp, priority); +# endif +#endif + + /* options for ID3 tag */ + T_ELIF("tt") + argUsed = 1; + id3_tag(gfp, 't', TENC_RAW, nextArg); + + T_ELIF("ta") + argUsed = 1; + id3_tag(gfp, 'a', TENC_RAW, nextArg); + + T_ELIF("tl") + argUsed = 1; + id3_tag(gfp, 'l', TENC_RAW, nextArg); + + T_ELIF("ty") + argUsed = 1; + id3_tag(gfp, 'y', TENC_RAW, nextArg); + + T_ELIF("tc") + argUsed = 1; + id3_tag(gfp, 'c', TENC_RAW, nextArg); + + T_ELIF("tn") + int ret = id3_tag(gfp, 'n', TENC_RAW, nextArg); + argUsed = 1; + if (ret != 0) { + if (0 == ignore_tag_errors) { + if (id3tag_mode == ID3TAG_MODE_V1_ONLY) { + error_printf("The track number has to be between 1 and 255 for ID3v1.\n"); + return -1; + } + else if (id3tag_mode == ID3TAG_MODE_V2_ONLY) { + /* track will be stored as-is in ID3v2 case, so no problem here */ + } + else { + if (silent < 10) { + error_printf("The track number has to be between 1 and 255 for ID3v1, ignored for ID3v1.\n"); + } + } + } + } + + T_ELIF("tg") + int ret = id3_tag(gfp, 'g', TENC_RAW, nextArg); + argUsed = 1; + if (ret != 0) { + if (0 == ignore_tag_errors) { + if (ret == -1) { + error_printf("Unknown ID3v1 genre number: '%s'.\n", nextArg); + return -1; + } + else if (ret == -2) { + if (id3tag_mode == ID3TAG_MODE_V1_ONLY) { + error_printf("Unknown ID3v1 genre: '%s'.\n", nextArg); + return -1; + } + else if (id3tag_mode == ID3TAG_MODE_V2_ONLY) { + /* genre will be stored as-is in ID3v2 case, so no problem here */ + } + else { + if (silent < 10) { + error_printf("Unknown ID3v1 genre: '%s'. Setting ID3v1 genre to 'Other'\n", nextArg); + } + } + } + else { + error_printf("Internal error.\n"); + return -1; + } + } + } + + T_ELIF("tv") + argUsed = 1; + if (id3_tag(gfp, 'v', TENC_RAW, nextArg)) { + if (silent < 10) { + error_printf("Invalid field value: '%s'. Ignored\n", nextArg); + } + } + + T_ELIF("ti") + argUsed = 1; + if (set_id3_albumart(gfp, nextArg) != 0) { + if (! ignore_tag_errors) { + return -1; + } + } + + T_ELIF("ignore-tag-errors") + ignore_tag_errors = 1; + + T_ELIF("add-id3v2") + id3tag_add_v2(gfp); + + T_ELIF("id3v1-only") + id3tag_v1_only(gfp); + id3tag_mode = ID3TAG_MODE_V1_ONLY; + + T_ELIF("id3v2-only") + id3tag_v2_only(gfp); + id3tag_mode = ID3TAG_MODE_V2_ONLY; + + T_ELIF("space-id3v1") + id3tag_space_v1(gfp); + + T_ELIF("pad-id3v2") + id3tag_pad_v2(gfp); + + T_ELIF("pad-id3v2-size") + int n = atoi(nextArg); + n = n <= 128000 ? n : 128000; + n = n >= 0 ? n : 0; + id3tag_set_pad(gfp, n); + argUsed = 1; + + + T_ELIF("genre-list") + id3tag_genre_list(genre_list_handler, NULL); + return -2; + +#ifdef HAVE_ICONV + /* some experimental switches for setting ID3 tags + * with proper character encodings + */ + T_ELIF("lTitle") argUsed = 1; id3_tag(gfp, 't', TENC_LATIN1, nextArg); + T_ELIF("lArtist") argUsed = 1; id3_tag(gfp, 'a', TENC_LATIN1, nextArg); + T_ELIF("lAlbum") argUsed = 1; id3_tag(gfp, 'l', TENC_LATIN1, nextArg); + T_ELIF("lGenre") argUsed = 1; id3_tag(gfp, 'g', TENC_LATIN1, nextArg); + T_ELIF("lComment")argUsed = 1; id3_tag(gfp, 'c', TENC_LATIN1, nextArg); + T_ELIF("lFieldvalue") + argUsed = 1; + if (id3_tag(gfp, 'v', TENC_LATIN1, nextArg)) { + if (silent < 10) { + error_printf("Invalid field value: '%s'. Ignored\n", nextArg); + } + } + + T_ELIF("uTitle") argUsed = 1; id3_tag(gfp, 't', TENC_UCS2, nextArg); + T_ELIF("uArtist") argUsed = 1; id3_tag(gfp, 'a', TENC_UCS2, nextArg); + T_ELIF("uAlbum") argUsed = 1; id3_tag(gfp, 'l', TENC_UCS2, nextArg); + T_ELIF("uGenre") argUsed = 1; id3_tag(gfp, 'g', TENC_UCS2, nextArg); + T_ELIF("uComment")argUsed = 1; id3_tag(gfp, 'c', TENC_UCS2, nextArg); + /* + T_ELIF("uFieldvalue") + argUsed = 1; + if (id3_tag(gfp, 'v', TENC_UCS2, nextArg)) { + if (silent < 10) { + error_printf("Invalid field value: '%s'. Ignored\n", nextArg); + } + } + */ +#endif + + T_ELIF("lowpass") + val = atof(nextArg); + argUsed = 1; + if (val < 0) { + lame_set_lowpassfreq(gfp, -1); + } + else { + /* useful are 0.001 kHz...50 kHz, 50 Hz...50000 Hz */ + if (val < 0.001 || val > 50000.) { + error_printf("Must specify lowpass with --lowpass freq, freq >= 0.001 kHz\n"); + return -1; + } + lame_set_lowpassfreq(gfp, (int) (val * (val < 50. ? 1.e3 : 1.e0) + 0.5)); + } + + T_ELIF("lowpass-width") + val = atof(nextArg); + argUsed = 1; + /* useful are 0.001 kHz...16 kHz, 16 Hz...50000 Hz */ + if (val < 0.001 || val > 50000.) { + error_printf + ("Must specify lowpass width with --lowpass-width freq, freq >= 0.001 kHz\n"); + return -1; + } + lame_set_lowpasswidth(gfp, (int) (val * (val < 16. ? 1.e3 : 1.e0) + 0.5)); + + T_ELIF("highpass") + val = atof(nextArg); + argUsed = 1; + if (val < 0.0) { + lame_set_highpassfreq(gfp, -1); + } + else { + /* useful are 0.001 kHz...16 kHz, 16 Hz...50000 Hz */ + if (val < 0.001 || val > 50000.) { + error_printf("Must specify highpass with --highpass freq, freq >= 0.001 kHz\n"); + return -1; + } + lame_set_highpassfreq(gfp, (int) (val * (val < 16. ? 1.e3 : 1.e0) + 0.5)); + } + + T_ELIF("highpass-width") + val = atof(nextArg); + argUsed = 1; + /* useful are 0.001 kHz...16 kHz, 16 Hz...50000 Hz */ + if (val < 0.001 || val > 50000.) { + error_printf + ("Must specify highpass width with --highpass-width freq, freq >= 0.001 kHz\n"); + return -1; + } + lame_set_highpasswidth(gfp, (int) val); + + T_ELIF("comp") + argUsed = 1; + val = atof(nextArg); + if (val < 1.0) { + error_printf("Must specify compression ratio >= 1.0\n"); + return -1; + } + lame_set_compression_ratio(gfp, (float) val); + + T_ELIF("notemp") + (void) lame_set_useTemporal(gfp, 0); + + T_ELIF("interch") + argUsed = 1; + (void) lame_set_interChRatio(gfp, (float) atof(nextArg)); + + T_ELIF("temporal-masking") + argUsed = 1; + (void) lame_set_useTemporal(gfp, atoi(nextArg) ? 1 : 0); + + T_ELIF("nspsytune") + ; + + T_ELIF("nssafejoint") + lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); + + T_ELIF("nsmsfix") + argUsed = 1; + (void) lame_set_msfix(gfp, atof(nextArg)); + + T_ELIF("ns-bass") + argUsed = 1; + { + double d; + int k; + d = atof(nextArg); + k = (int) (d * 4); + if (k < -32) + k = -32; + if (k > 31) + k = 31; + if (k < 0) + k += 64; + lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (k << 2)); + } + + T_ELIF("ns-alto") + argUsed = 1; + { + double d; + int k; + d = atof(nextArg); + k = (int) (d * 4); + if (k < -32) + k = -32; + if (k > 31) + k = 31; + if (k < 0) + k += 64; + lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (k << 8)); + } + + T_ELIF("ns-treble") + argUsed = 1; + { + double d; + int k; + d = atof(nextArg); + k = (int) (d * 4); + if (k < -32) + k = -32; + if (k > 31) + k = 31; + if (k < 0) + k += 64; + lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (k << 14)); + } + + T_ELIF("ns-sfb21") + /* to be compatible with Naoki's original code, + * ns-sfb21 specifies how to change ns-treble for sfb21 */ + argUsed = 1; + { + double d; + int k; + d = atof(nextArg); + k = (int) (d * 4); + if (k < -32) + k = -32; + if (k > 31) + k = 31; + if (k < 0) + k += 64; + lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (k << 20)); + } + + T_ELIF("nspsytune2") { + } + + /* some more GNU-ish options could be added + * brief => few messages on screen (name, status report) + * o/output file => specifies output filename + * O => stdout + * i/input file => specifies input filename + * I => stdin + */ + T_ELIF2("quiet", "silent") + silent = 10; /* on a scale from 1 to 10 be very silent */ + + T_ELIF("brief") + silent = -5; /* print few info on screen */ + + T_ELIF("verbose") + silent = -10; /* print a lot on screen */ + + T_ELIF2("version", "license") + print_license(stdout); + return -2; + + T_ELIF2("help", "usage") + short_help(gfp, stdout, ProgramName); + return -2; + + T_ELIF("longhelp") + long_help(gfp, stdout, ProgramName, 0 /* lessmode=NO */ ); + return -2; + + T_ELIF("?") +#ifdef __unix__ + FILE *fp = popen("less -Mqc", "w"); + long_help(gfp, fp, ProgramName, 0 /* lessmode=NO */ ); + pclose(fp); +#else + long_help(gfp, stdout, ProgramName, 1 /* lessmode=YES */ ); +#endif + return -2; + + T_ELIF2("preset", "alt-preset") + argUsed = 1; + { + int fast = 0, cbr = 0; + + while ((strcmp(nextArg, "fast") == 0) || (strcmp(nextArg, "cbr") == 0)) { + + if ((strcmp(nextArg, "fast") == 0) && (fast < 1)) + fast = 1; + if ((strcmp(nextArg, "cbr") == 0) && (cbr < 1)) + cbr = 1; + + argUsed++; + nextArg = i + argUsed < argc ? argv[i + argUsed] : ""; + } + + if (presets_set(gfp, fast, cbr, nextArg, ProgramName) < 0) + return -1; + } + + T_ELIF("disptime") + argUsed = 1; + update_interval = (float) atof(nextArg); + + T_ELIF("nogaptags") + nogap_tags = 1; + + T_ELIF("nogapout") + strcpy(outPath, nextArg); + argUsed = 1; + + T_ELIF("nogap") + nogap = 1; + + + T_ELIF_INTERNAL("tune") /*without helptext */ + argUsed = 1; + { + extern void lame_set_tune(lame_t, float); + lame_set_tune(gfp, (float) atof(nextArg)); + } + + T_ELIF_INTERNAL("shortthreshold") { + float x, y; + int n = sscanf(nextArg, "%f,%f", &x, &y); + if (n == 1) { + y = x; + } + argUsed = 1; + (void) lame_set_short_threshold(gfp, x, y); + } + + T_ELIF_INTERNAL("maskingadjust") /*without helptext */ + argUsed = 1; + (void) lame_set_maskingadjust(gfp, (float) atof(nextArg)); + + T_ELIF_INTERNAL("maskingadjustshort") /*without helptext */ + argUsed = 1; + (void) lame_set_maskingadjust_short(gfp, (float) atof(nextArg)); + + T_ELIF_INTERNAL("athcurve") /*without helptext */ + argUsed = 1; + (void) lame_set_ATHcurve(gfp, (float) atof(nextArg)); + + T_ELIF_INTERNAL("no-preset-tune") /*without helptext */ + (void) lame_set_preset_notune(gfp, 0); + + T_ELIF_INTERNAL("substep") + argUsed = 1; + (void) lame_set_substep(gfp, atoi(nextArg)); + + T_ELIF_INTERNAL("sbgain") /*without helptext */ + argUsed = 1; + (void) lame_set_subblock_gain(gfp, atoi(nextArg)); + + T_ELIF_INTERNAL("sfscale") /*without helptext */ + (void) lame_set_sfscale(gfp, 1); + + T_ELIF_INTERNAL("noath") + (void) lame_set_noATH(gfp, 1); + + T_ELIF_INTERNAL("athonly") + (void) lame_set_ATHonly(gfp, 1); + + T_ELIF_INTERNAL("athshort") + (void) lame_set_ATHshort(gfp, 1); + + T_ELIF_INTERNAL("athlower") + argUsed = 1; + (void) lame_set_ATHlower(gfp, (float) atof(nextArg)); + + T_ELIF_INTERNAL("athtype") + argUsed = 1; + (void) lame_set_ATHtype(gfp, atoi(nextArg)); + + T_ELIF_INTERNAL("athaa-type") /* switch for developing, no DOCU */ + argUsed = 1; /* once was 1:Gaby, 2:Robert, 3:Jon, else:off */ + lame_set_athaa_type(gfp, atoi(nextArg)); /* now: 0:off else:Jon */ + + T_ELIF ("athaa-sensitivity") + argUsed=1; + lame_set_athaa_sensitivity(gfp, (float) atof(nextArg)); + + T_ELIF_INTERNAL("debug-file") /* switch for developing, no DOCU */ + argUsed = 1; /* file name to print debug info into */ + { + set_debug_file(nextArg); + } + + T_ELSE { + error_printf("%s: unrecognized option --%s\n", ProgramName, token); + return -1; + } + T_END i += argUsed; + + } + else { + while ((c = *token++) != '\0') { + arg = *token ? token : nextArg; + switch (c) { + case 'm': + argUsed = 1; + + switch (*arg) { + case 's': + (void) lame_set_mode(gfp, STEREO); + break; + case 'd': + (void) lame_set_mode(gfp, DUAL_CHANNEL); + break; + case 'f': + lame_set_force_ms(gfp, 1); + /* FALLTHROUGH */ + case 'j': + (void) lame_set_mode(gfp, JOINT_STEREO); + break; + case 'm': + (void) lame_set_mode(gfp, MONO); + break; + case 'a': + (void) lame_set_mode(gfp, JOINT_STEREO); + break; + default: + error_printf("%s: -m mode must be s/d/j/f/m not %s\n", ProgramName, + arg); + return -1; + } + break; + + case 'V': + argUsed = 1; + /* to change VBR default look in lame.h */ + if (lame_get_VBR(gfp) == vbr_off) + lame_set_VBR(gfp, vbr_default); + lame_set_VBR_quality(gfp, (float)atof(arg)); + break; + case 'v': + /* to change VBR default look in lame.h */ + if (lame_get_VBR(gfp) == vbr_off) + lame_set_VBR(gfp, vbr_default); + break; + + case 'q': + argUsed = 1; + { + int tmp_quality = atoi(arg); + + /* XXX should we move this into lame_set_quality()? */ + if (tmp_quality < 0) + tmp_quality = 0; + if (tmp_quality > 9) + tmp_quality = 9; + + (void) lame_set_quality(gfp, tmp_quality); + } + break; + case 'f': + (void) lame_set_quality(gfp, 7); + break; + case 'h': + (void) lame_set_quality(gfp, 2); + break; + + case 's': + argUsed = 1; + val = atof(arg); + (void) lame_set_in_samplerate(gfp, + (int) (val * (val <= 192 ? 1.e3 : 1.e0) + + 0.5)); + break; + case 'b': + argUsed = 1; + lame_set_brate(gfp, atoi(arg)); + lame_set_VBR_min_bitrate_kbps(gfp, lame_get_brate(gfp)); + break; + case 'B': + argUsed = 1; + lame_set_VBR_max_bitrate_kbps(gfp, atoi(arg)); + break; + case 'F': + lame_set_VBR_hard_min(gfp, 1); + break; + case 't': /* dont write VBR tag */ + (void) lame_set_bWriteVbrTag(gfp, 0); + disable_wav_header = 1; + break; + case 'T': /* do write VBR tag */ + (void) lame_set_bWriteVbrTag(gfp, 1); + nogap_tags = 1; + disable_wav_header = 0; + break; + case 'r': /* force raw pcm input file */ +#if defined(LIBSNDFILE) + error_printf + ("WARNING: libsndfile may ignore -r and perform fseek's on the input.\n" + "Compile without libsndfile if this is a problem.\n"); +#endif + input_format = sf_raw; + break; + case 'x': /* force byte swapping */ + swapbytes = 1; + break; + case 'p': /* (jo) error_protection: add crc16 information to stream */ + lame_set_error_protection(gfp, 1); + break; + case 'a': /* autoconvert input file from stereo to mono - for mono mp3 encoding */ + autoconvert = 1; + (void) lame_set_mode(gfp, MONO); + break; + case 'd': /*(void) lame_set_allow_diff_short( gfp, 1 ); */ + case 'k': /*lame_set_lowpassfreq(gfp, -1); + lame_set_highpassfreq(gfp, -1); */ + error_printf("WARNING: -%c is obsolete.\n", c); + break; + case 'S': + silent = 10; + break; + case 'X': + /* experimental switch -X: + the differnt types of quant compare are tough + to communicate to endusers, so they shouldn't + bother to toy around with them + */ + { + int x, y; + int n = sscanf(arg, "%d,%d", &x, &y); + if (n == 1) { + y = x; + } + argUsed = 1; + if (INTERNAL_OPTS) { + lame_set_quant_comp(gfp, x); + lame_set_quant_comp_short(gfp, y); + } + } + break; + case 'Y': + lame_set_experimentalY(gfp, 1); + break; + case 'Z': + /* experimental switch -Z: + this switch is obsolete + */ + { + int n = 1; + argUsed = sscanf(arg, "%d", &n); + if (INTERNAL_OPTS) { + lame_set_experimentalZ(gfp, n); + } + } + break; + case 'e': + argUsed = 1; + + switch (*arg) { + case 'n': + lame_set_emphasis(gfp, 0); + break; + case '5': + lame_set_emphasis(gfp, 1); + break; + case 'c': + lame_set_emphasis(gfp, 3); + break; + default: + error_printf("%s: -e emp must be n/5/c not %s\n", ProgramName, arg); + return -1; + } + break; + case 'c': + lame_set_copyright(gfp, 1); + break; + case 'o': + lame_set_original(gfp, 0); + break; + + case '?': + long_help(gfp, stdout, ProgramName, 0 /* LESSMODE=NO */ ); + return -1; + + default: + error_printf("%s: unrecognized option -%c\n", ProgramName, c); + return -1; + } + if (argUsed) { + if (arg == token) + token = ""; /* no more from token */ + else + ++i; /* skip arg we used */ + arg = ""; + argUsed = 0; + } + } + } + } + else { + if (nogap) { + if ((num_nogap != NULL) && (count_nogap < *num_nogap)) { + strncpy(nogap_inPath[count_nogap++], argv[i], PATH_MAX + 1); + input_file = 1; + } + else { + /* sorry, calling program did not allocate enough space */ + error_printf + ("Error: 'nogap option'. Calling program does not allow nogap option, or\n" + "you have exceeded maximum number of input files for the nogap option\n"); + *num_nogap = -1; + return -1; + } + } + else { + /* normal options: inputfile [outputfile], and + either one can be a '-' for stdin/stdout */ + if (inPath[0] == '\0') { + strncpy(inPath, argv[i], PATH_MAX + 1); + input_file = 1; + } + else { + if (outPath[0] == '\0') + strncpy(outPath, argv[i], PATH_MAX + 1); + else { + error_printf("%s: excess arg %s\n", ProgramName, argv[i]); + return -1; + } + } + } + } + } /* loop over args */ + + if (!input_file) { + usage(Console_IO.Console_fp, ProgramName); + return -1; + } + + if (inPath[0] == '-') + silent = (silent <= 1 ? 1 : silent); +#ifdef WIN32 + else + dosToLongFileName(inPath); +#endif + + if (outPath[0] == '\0' && count_nogap == 0) { + if (inPath[0] == '-') { + /* if input is stdin, default output is stdout */ + strcpy(outPath, "-"); + } + else { + strncpy(outPath, inPath, PATH_MAX + 1 - 4); + if (lame_get_decode_only(gfp)) { + strncat(outPath, ".wav", 4); + } + else { + strncat(outPath, ".mp3", 4); + } + } + } + + /* RG is enabled by default */ + if (!noreplaygain) + lame_set_findReplayGain(gfp, 1); + + /* disable VBR tags with nogap unless the VBR tags are forced */ + if (nogap && lame_get_bWriteVbrTag(gfp) && nogap_tags == 0) { + console_printf("Note: Disabling VBR Xing/Info tag since it interferes with --nogap\n"); + lame_set_bWriteVbrTag(gfp, 0); + } + + /* some file options not allowed with stdout */ + if (outPath[0] == '-') { + (void) lame_set_bWriteVbrTag(gfp, 0); /* turn off VBR tag */ + } + + /* if user did not explicitly specify input is mp3, check file name */ + if (input_format == sf_unknown) + input_format = filename_to_type(inPath); + +#if !(defined HAVE_MPGLIB || defined AMIGA_MPEGA) + if (is_mpeg_file_format(input_format)) { + error_printf("Error: libmp3lame not compiled with mpg123 *decoding* support \n"); + return -1; + } +#endif + + + if (input_format == sf_ogg) { + error_printf("sorry, vorbis support in LAME is deprecated.\n"); + return -1; + } + /* default guess for number of channels */ + if (autoconvert) + (void) lame_set_num_channels(gfp, 2); + else if (MONO == lame_get_mode(gfp)) + (void) lame_set_num_channels(gfp, 1); + else + (void) lame_set_num_channels(gfp, 2); + + if (lame_get_free_format(gfp)) { + if (lame_get_brate(gfp) < 8 || lame_get_brate(gfp) > 640) { + error_printf("For free format, specify a bitrate between 8 and 640 kbps\n"); + error_printf("with the -b <bitrate> option\n"); + return -1; + } + } + if (num_nogap != NULL) + *num_nogap = count_nogap; + return 0; +} + + +/* end of parse.c */ |