kode54
/
cog
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
cog/Frameworks/WavPack/Files/wavpack.c

1647 lines
48 KiB
C
Raw Blame History

////////////////////////////////////////////////////////////////////////////
// **** WAVPACK **** //
// Hybrid Lossless Wavefile Compressor //
// Copyright (c) 1998 - 2005 Conifer Software. //
// All Rights Reserved. //
// Distributed under the BSD Software License (see license.txt) //
////////////////////////////////////////////////////////////////////////////
// wavpack.c
// This is the main module for the WavPack command-line compressor.
#if defined(WIN32)
#include <windows.h>
#include <io.h>
#else
#include <sys/param.h>
#include <sys/stat.h>
#include <locale.h>
#include <iconv.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <math.h>
#include "wavpack.h"
#include "md5.h"
#if defined (__GNUC__) && !defined(WIN32)
#include <unistd.h>
#include <glob.h>
#include <sys/time.h>
#else
#include <sys/timeb.h>
#endif
#ifdef DEBUG_ALLOC
#define malloc malloc_db
#define realloc realloc_db
#define free free_db
void *malloc_db (uint32_t size);
void *realloc_db (void *ptr, uint32_t size);
void free_db (void *ptr);
int32_t dump_alloc (void);
static char *strdup (const char *s)
{ char *d = malloc (strlen (s) + 1); return strcpy (d, s); }
#endif
///////////////////////////// local variable storage //////////////////////////
static const char *sign_on = "\n"
" WAVPACK Hybrid Lossless Audio Compressor %s Version %s %s\n"
" Copyright (c) 1998 - 2005 Conifer Software. All Rights Reserved.\n\n";
static const char *usage =
#if defined (WIN32)
" Usage: WAVPACK [-options] [@]infile[.wav]|- [[@]outfile[.wv]|outpath|-]\n"
#else
" Usage: WAVPACK [-options] [@]infile[.wav]|- [...] [-o [@]outfile[.wv]|outpath|-]\n"
#endif
" (default is lossless; infile may contain wildcards: ?,*)\n\n"
" Options: -a = Adobe Audition (CoolEdit) mode for 32-bit floats\n"
" -bn = enable hybrid compression, n = 2.0 to 23.9 bits/sample, or\n"
" n = 24-9600 kbits/second (kbps)\n"
" -c = create correction file (.wvc) for hybrid mode (=lossless)\n"
" -cc = maximum hybrid compression (hurts lossy quality & decode speed)\n"
" -d = delete source file if successful (use with caution!)\n"
#if defined (WIN32)
" -e = create self-extracting executable (needs wvselfx.exe)\n"
#endif
" -f = fast mode (fast, but some compromise in compression ratio)\n"
" -h = high quality (best compression in all modes, but slower)\n"
" -i = ignore length in wav header (no pipe output allowed)\n"
" -jn = joint-stereo override (0 = left/right, 1 = mid/side)\n"
#if defined (WIN32)
" -l = run at low priority (for smoother multitasking)\n"
#endif
" -m = compute & store MD5 signature of raw audio data\n"
" -n = calculate average and peak quantization noise (hybrid only)\n"
#if !defined (WIN32)
" -o FILENAME | PATH = specify output filename or path\n"
#endif
" -p = practical float storage (also 32-bit ints, not lossless)\n"
" -r = generate new RIFF wav header (removing extra chunk info)\n"
" -q = quiet (keep console output to a minimum)\n"
" -sn = noise shaping override (hybrid only, n = -1.0 to 1.0, 0 = off)\n"
" -t = copy input file's time stamp to output file(s)\n"
" -w \"Field=Value\" = write specified metadata to APEv2 tag\n"
" -x[n] = extra encode processing (optional n = 1-6 for less/more)\n"
" -y = yes to all warnings (use with caution!)\n\n"
" Web: Visit www.wavpack.com for latest version and info\n";
// this global is used to indicate the special "debug" mode where extra debug messages
// are displayed and all messages are logged to the file \wavpack.log
int debug_logging_mode;
static int overwrite_all, num_files, file_index;
#if defined (WIN32)
static char *wvselfx_image;
static uint32_t wvselfx_size;
#endif
/////////////////////////// local function declarations ///////////////////////
static FILE *wild_fopen (char *filename, const char *mode);
static int pack_file (char *infilename, char *outfilename, char *out2filename, const WavpackConfig *config);
static int pack_audio (WavpackContext *wpc, FILE *infile);
static void display_progress (double file_progress);
#define NO_ERROR 0L
#define SOFT_ERROR 1
#define HARD_ERROR 2
//////////////////////////////////////////////////////////////////////////////
// The "main" function for the command-line WavPack compressor. //
//////////////////////////////////////////////////////////////////////////////
int main (argc, argv) int argc; char **argv;
{
int delete_source = 0, error_count = 0, tag_next_arg = 0, output_spec = 0;
char *outfilename = NULL, *out2filename = NULL;
char **matches = NULL;
WavpackConfig config;
int result, i;
#if defined(WIN32)
struct _finddata_t _finddata_t;
char selfname [MAX_PATH];
if (GetModuleFileName (NULL, selfname, sizeof (selfname)) && filespec_name (selfname) &&
strupr (filespec_name (selfname)) && strstr (filespec_name (selfname), "DEBUG")) {
char **argv_t = argv;
int argc_t = argc;
debug_logging_mode = TRUE;
while (--argc_t)
error_line ("arg %d: %s", argc - argc_t, *++argv_t);
}
strcpy (selfname, *argv);
#else
if (filespec_name (*argv))
if (strstr (filespec_name (*argv), "ebug") || strstr (filespec_name (*argv), "DEBUG")) {
char **argv_t = argv;
int argc_t = argc;
debug_logging_mode = TRUE;
while (--argc_t)
error_line ("arg %d: %s", argc - argc_t, *++argv_t);
}
#endif
CLEAR (config);
// loop through command-line arguments
while (--argc)
#if defined (WIN32)
if ((**++argv == '-' || **argv == '/') && (*argv)[1])
#else
if ((**++argv == '-') && (*argv)[1])
#endif
while (*++*argv)
switch (**argv) {
case 'Y': case 'y':
overwrite_all = 1;
break;
case 'D': case 'd':
delete_source = 1;
break;
case 'C': case 'c':
if (config.flags & CONFIG_CREATE_WVC)
config.flags |= CONFIG_OPTIMIZE_WVC;
else
config.flags |= CONFIG_CREATE_WVC;
break;
case 'X': case 'x':
config.xmode = strtol (++*argv, argv, 10);
if (config.xmode < 0 || config.xmode > 6) {
error_line ("extra mode only goes from 1 to 6!");
++error_count;
}
else
config.flags |= CONFIG_EXTRA_MODE;
--*argv;
break;
case 'F': case 'f':
if (config.flags & CONFIG_FAST_FLAG)
config.flags |= CONFIG_VERY_FAST_FLAG;
else
config.flags |= CONFIG_FAST_FLAG;
break;
case 'H': case 'h':
if (config.flags & CONFIG_HIGH_FLAG)
config.flags |= CONFIG_VERY_HIGH_FLAG;
else
config.flags |= CONFIG_HIGH_FLAG;
break;
case 'N': case 'n':
config.flags |= CONFIG_CALC_NOISE;
break;
case 'A': case 'a':
config.flags |= CONFIG_ADOBE_MODE;
break;
#if defined (WIN32)
case 'E': case 'e':
config.flags |= CONFIG_CREATE_EXE;
break;
case 'L': case 'l':
SetPriorityClass (GetCurrentProcess(), IDLE_PRIORITY_CLASS);
break;
#else
case 'O': case 'o':
output_spec = 1;
break;
#endif
case 'T': case 't':
config.flags |= CONFIG_COPY_TIME;
break;
case 'P': case 'p':
config.flags |= CONFIG_SKIP_WVX;
break;
case 'Q': case 'q':
config.flags |= CONFIG_QUIET_MODE;
break;
case 'M': case 'm':
config.flags |= CONFIG_MD5_CHECKSUM;
break;
case 'I': case 'i':
config.flags |= CONFIG_IGNORE_LENGTH;
break;
case 'R': case 'r':
config.flags |= CONFIG_NEW_RIFF_HEADER;
break;
case 'K': case 'k':
config.block_samples = strtol (++*argv, argv, 10);
--*argv;
break;
case 'B': case 'b':
config.flags |= CONFIG_HYBRID_FLAG;
config.bitrate = strtod (++*argv, argv);
--*argv;
if (config.bitrate < 2.0 || config.bitrate > 9600.0) {
error_line ("hybrid spec must be 2.0 to 9600!");
++error_count;
}
if (config.bitrate >= 24.0)
config.flags |= CONFIG_BITRATE_KBPS;
break;
case 'J': case 'j':
switch (strtol (++*argv, argv, 10)) {
case 0:
config.flags |= CONFIG_JOINT_OVERRIDE;
config.flags &= ~CONFIG_JOINT_STEREO;
break;
case 1:
config.flags |= (CONFIG_JOINT_OVERRIDE | CONFIG_JOINT_STEREO);
break;
default:
error_line ("-j0 or -j1 only!");
++error_count;
}
--*argv;
break;
case 'S': case 's':
config.shaping_weight = strtod (++*argv, argv);
if (!config.shaping_weight) {
config.flags |= CONFIG_SHAPE_OVERRIDE;
config.flags &= ~CONFIG_HYBRID_SHAPE;
}
else if (config.shaping_weight >= -1.0 && config.shaping_weight <= 1.0)
config.flags |= (CONFIG_HYBRID_SHAPE | CONFIG_SHAPE_OVERRIDE);
else {
error_line ("-s-1.00 to -s1.00 only!");
++error_count;
}
--*argv;
break;
case 'W': case 'w':
tag_next_arg = 1;
break;
default:
error_line ("illegal option: %c !", **argv);
++error_count;
}
else if (tag_next_arg) {
tag_next_arg = 0;
config.tag_strings = realloc (config.tag_strings, ++config.num_tag_strings * sizeof (*config.tag_strings));
config.tag_strings [config.num_tag_strings - 1] = *argv;
}
#if defined (WIN32)
else if (!num_files) {
matches = realloc (matches, (num_files + 1) * sizeof (*matches));
matches [num_files] = malloc (strlen (*argv) + 10);
strcpy (matches [num_files], *argv);
if (*(matches [num_files]) != '-' && *(matches [num_files]) != '@' &&
!filespec_ext (matches [num_files]))
strcat (matches [num_files], ".wav");
num_files++;
}
else if (!outfilename) {
outfilename = malloc (strlen (*argv) + PATH_MAX);
strcpy (outfilename, *argv);
}
else if (!out2filename) {
out2filename = malloc (strlen (*argv) + PATH_MAX);
strcpy (out2filename, *argv);
}
else {
error_line ("extra unknown argument: %s !", *argv);
++error_count;
}
#else
else if (output_spec) {
outfilename = malloc (strlen (*argv) + PATH_MAX);
strcpy (outfilename, *argv);
output_spec = 0;
}
else {
matches = realloc (matches, (num_files + 1) * sizeof (*matches));
matches [num_files] = malloc (strlen (*argv) + 10);
strcpy (matches [num_files], *argv);
if (*(matches [num_files]) != '-' && *(matches [num_files]) != '@' &&
!filespec_ext (matches [num_files]))
strcat (matches [num_files], ".wav");
num_files++;
}
#endif
setup_break (); // set up console and detect ^C and ^Break
// check for various command-line argument problems
if (!(~config.flags & (CONFIG_HIGH_FLAG | CONFIG_FAST_FLAG))) {
error_line ("high and fast modes are mutually exclusive!");
++error_count;
}
if ((config.flags & CONFIG_IGNORE_LENGTH) && outfilename && *outfilename == '-') {
error_line ("can't ignore length in header when using stdout!");
++error_count;
}
if (config.flags & CONFIG_HYBRID_FLAG) {
if ((config.flags & CONFIG_CREATE_WVC) && outfilename && *outfilename == '-') {
error_line ("can't create correction file when using stdout!");
++error_count;
}
}
else {
if (config.flags & (CONFIG_CALC_NOISE | CONFIG_SHAPE_OVERRIDE | CONFIG_CREATE_WVC)) {
error_line ("-s, -n and -c options are for hybrid mode (-b) only!");
++error_count;
}
}
if (!(config.flags & CONFIG_QUIET_MODE) && !error_count)
fprintf (stderr, sign_on, VERSION_OS, VERSION_STR, DATE_STR);
if (!num_files) {
printf ("%s", usage);
return 1;
}
// loop through any tag specification strings and check for file access
for (i = 0; i < config.num_tag_strings; ++i) {
char *cp = strchr (config.tag_strings [i], '='), *string = NULL;
if (cp && cp > config.tag_strings [i]) {
int item_len = cp - config.tag_strings [i];
if (cp [1] == '@') {
FILE *file = wild_fopen (cp+2, "rb");
if (!file && filespec_name (matches [0]) && *matches [0] != '-') {
char *temp = malloc (strlen (matches [0]) + PATH_MAX);
strcpy (temp, matches [0]);
strcpy (filespec_name (temp), cp+2);
file = wild_fopen (temp, "rb");
free (temp);
}
if (!file && filespec_name (outfilename) && *outfilename != '-') {
char *temp = malloc (strlen (outfilename) + PATH_MAX);
strcpy (temp, outfilename);
strcpy (filespec_name (temp), cp+2);
file = wild_fopen (temp, "rb");
free (temp);
}
if (file) {
uint32_t bcount, file_len;
file_len = DoGetFileSize (file);
if (file_len < 1048576 && (string = malloc (item_len + file_len + 2)) != NULL) {
memcpy (string, config.tag_strings [i], item_len + 1);
if (!DoReadFile (file, string + item_len + 1, file_len, &bcount) || bcount != file_len) {
free (string);
string = NULL;
}
else
string [item_len + file_len + 1] = 0;
}
DoCloseHandle (file);
}
}
else
string = config.tag_strings [i];
}
if (!string) {
error_line ("error in tag spec: %s !", config.tag_strings [i]);
++error_count;
}
else {
config.tag_strings [i] = string;
// error_line ("final tag data: %s", string);
}
}
if (error_count)
return 1;
// If we are trying to create self-extracting .exe files, this is where
// we read the wvselfx.exe file into memory in preparation for pre-pending
// it to the WavPack files.
#if defined (WIN32)
if (config.flags & CONFIG_CREATE_EXE) {
FILE *wvselfx_file;
uint32_t bcount;
strcpy (filespec_name (selfname), "wvselfx.exe");
wvselfx_file = fopen (selfname, "rb");
if (!wvselfx_file) {
_searchenv ("wvselfx.exe", "PATH", selfname);
wvselfx_file = fopen (selfname, "rb");
}
if (wvselfx_file) {
wvselfx_size = DoGetFileSize (wvselfx_file);
if (wvselfx_size && wvselfx_size != 26624 && wvselfx_size < 49152) {
wvselfx_image = malloc (wvselfx_size);
if (!DoReadFile (wvselfx_file, wvselfx_image, wvselfx_size, &bcount) || bcount != wvselfx_size) {
free (wvselfx_image);
wvselfx_image = NULL;
}
}
DoCloseHandle (wvselfx_file);
}
if (!wvselfx_image) {
error_line ("wvselfx.exe file is not readable or is outdated!");
free (wvselfx_image);
exit (1);
}
}
#endif
for (file_index = 0; file_index < num_files; ++file_index) {
char *infilename = matches [file_index];
// If the single infile specification begins with a '@', then it
// actually points to a file that contains the names of the files
// to be converted. This was included for use by Wim Speekenbrink's
// frontends, but could be used for other purposes.
if (*infilename == '@') {
FILE *list = fopen (infilename+1, "rt");
int di, c;
for (di = file_index; di < num_files - 1; di++)
matches [di] = matches [di + 1];
file_index--;
num_files--;
if (list == NULL) {
error_line ("file %s not found!", infilename+1);
free (infilename);
return 1;
}
while ((c = getc (list)) != EOF) {
while (c == '\n')
c = getc (list);
if (c != EOF) {
char *fname = malloc (PATH_MAX);
int ci = 0;
do
fname [ci++] = c;
while ((c = getc (list)) != '\n' && c != EOF && ci < PATH_MAX);
fname [ci++] = '\0';
fname = realloc (fname, ci);
matches = realloc (matches, ++num_files * sizeof (*matches));
for (di = num_files - 1; di > file_index + 1; di--)
matches [di] = matches [di - 1];
matches [++file_index] = fname;
}
}
fclose (list);
free (infilename);
}
#if defined (WIN32)
else if (filespec_wild (infilename)) {
FILE *list = fopen (infilename+1, "rt");
int di;
for (di = file_index; di < num_files - 1; di++)
matches [di] = matches [di + 1];
file_index--;
num_files--;
if ((i = _findfirst (infilename, &_finddata_t)) != -1L) {
do {
if (!(_finddata_t.attrib & _A_SUBDIR)) {
matches = realloc (matches, ++num_files * sizeof (*matches));
for (di = num_files - 1; di > file_index + 1; di--)
matches [di] = matches [di - 1];
matches [++file_index] = malloc (strlen (infilename) + strlen (_finddata_t.name) + 10);
strcpy (matches [file_index], infilename);
*filespec_name (matches [file_index]) = '\0';
strcat (matches [file_index], _finddata_t.name);
}
} while (_findnext (i, &_finddata_t) == 0);
_findclose (i);
}
free (infilename);
}
#endif
}
// If the outfile specification begins with a '@', then it actually points
// to a file that contains the output specification. This was included for
// use by Wim Speekenbrink's frontends because certain filenames could not
// be passed on the command-line, but could be used for other purposes.
if (outfilename && outfilename [0] == '@') {
FILE *list = fopen (outfilename+1, "rt");
int c;
if (list == NULL) {
error_line ("file %s not found!", outfilename+1);
free(outfilename);
return 1;
}
while ((c = getc (list)) == '\n');
if (c != EOF) {
int ci = 0;
do
outfilename [ci++] = c;
while ((c = getc (list)) != '\n' && c != EOF && ci < PATH_MAX);
outfilename [ci] = '\0';
}
else {
error_line ("output spec file is empty!");
free(outfilename);
fclose (list);
return 1;
}
fclose (list);
}
if (out2filename && (num_files > 1 || !(config.flags & CONFIG_CREATE_WVC))) {
error_line ("extra unknown argument: %s !", out2filename);
return 1;
}
// if we found any files to process, this is where we start
if (num_files) {
char outpath, addext;
if (outfilename && *outfilename != '-') {
outpath = (filespec_path (outfilename) != NULL);
if (num_files > 1 && !outpath) {
error_line ("%s is not a valid output path", outfilename);
free(outfilename);
return 1;
}
}
else
outpath = 0;
addext = !outfilename || outpath || !filespec_ext (outfilename);
// loop through and process files in list
for (file_index = 0; file_index < num_files; ++file_index) {
if (check_break ())
break;
// generate output filename
if (outpath) {
strcat (outfilename, filespec_name (matches [file_index]));
if (filespec_ext (outfilename))
*filespec_ext (outfilename) = '\0';
}
else if (!outfilename) {
outfilename = malloc (strlen (matches [file_index]) + 10);
strcpy (outfilename, matches [file_index]);
if (filespec_ext (outfilename))
*filespec_ext (outfilename) = '\0';
}
if (addext && *outfilename != '-')
strcat (outfilename, (config.flags & CONFIG_CREATE_EXE) ? ".exe" : ".wv");
// if "correction" file is desired, generate name for that
if (config.flags & CONFIG_CREATE_WVC) {
if (!out2filename) {
out2filename = malloc (strlen (outfilename) + 10);
strcpy (out2filename, outfilename);
}
else {
char *temp = malloc (strlen (outfilename) + PATH_MAX);
strcpy (temp, outfilename);
strcpy (filespec_name (temp), filespec_name (out2filename));
strcpy (out2filename, temp);
free (temp);
}
if (filespec_ext (out2filename))
*filespec_ext (out2filename) = '\0';
strcat (out2filename, ".wvc");
}
else
out2filename = NULL;
if (num_files > 1)
fprintf (stderr, "\n%s:\n", matches [file_index]);
result = pack_file (matches [file_index], outfilename, out2filename, &config);
if (result != NO_ERROR)
++error_count;
if (result == HARD_ERROR)
break;
// delete source file if that option is enabled
if (result == NO_ERROR && delete_source)
error_line ("%s source file %s", DoDeleteFile (matches [file_index]) ?
"deleted" : "can't delete", matches [file_index]);
// clean up in preparation for potentially another file
if (outpath)
*filespec_name (outfilename) = '\0';
else if (*outfilename != '-') {
free (outfilename);
outfilename = NULL;
}
if (out2filename) {
free (out2filename);
out2filename = NULL;
}
free (matches [file_index]);
}
if (num_files > 1) {
if (error_count)
fprintf (stderr, "\n **** warning: errors occurred in %d of %d files! ****\n", error_count, num_files);
else if (!(config.flags & CONFIG_QUIET_MODE))
fprintf (stderr, "\n **** %d files successfully processed ****\n", num_files);
}
free (matches);
}
else {
error_line ("nothing to do!");
++error_count;
}
if (outfilename)
free (outfilename);
#ifdef DEBUG_ALLOC
error_line ("malloc_count = %d", dump_alloc ());
#endif
return error_count ? 1 : 0;
}
// This structure and function are used to write completed WavPack blocks in
// a device independent way.
typedef struct {
uint32_t bytes_written, first_block_size;
FILE *file;
int error;
} write_id;
static int write_block (void *id, void *data, int32_t length)
{
write_id *wid = (write_id *) id;
uint32_t bcount;
if (wid->error)
return FALSE;
if (wid && wid->file && data && length) {
if (!DoWriteFile (wid->file, data, length, &bcount) || bcount != length) {
DoTruncateFile (wid->file);
DoCloseHandle (wid->file);
wid->file = NULL;
wid->error = 1;
return FALSE;
}
else {
wid->bytes_written += length;
if (!wid->first_block_size)
wid->first_block_size = bcount;
}
}
return TRUE;
}
// Special version of fopen() that allows a wildcard specification for the
// filename. If a wildcard is specified, then it must match 1 and only 1
// file to be acceptable (i.e. it won't match just the "first" file).
#if defined (WIN32)
static FILE *wild_fopen (char *filename, const char *mode)
{
struct _finddata_t _finddata_t;
char *matchname = NULL;
FILE *res = NULL;
int i;
if (!filespec_wild (filename) || !filespec_name (filename))
return fopen (filename, mode);
if ((i = _findfirst (filename, &_finddata_t)) != -1L) {
do {
if (!(_finddata_t.attrib & _A_SUBDIR)) {
if (matchname) {
free (matchname);
matchname = NULL;
break;
}
else {
matchname = malloc (strlen (filename) + strlen (_finddata_t.name));
strcpy (matchname, filename);
strcpy (filespec_name (matchname), _finddata_t.name);
}
}
} while (_findnext (i, &_finddata_t) == 0);
_findclose (i);
}
if (matchname) {
res = fopen (matchname, mode);
free (matchname);
}
return res;
}
#else
static FILE *wild_fopen (char *filename, const char *mode)
{
return fopen (filename, mode);
}
#endif
// This function packs a single file "infilename" and stores the result at
// "outfilename". If "out2filename" is specified, then the "correction"
// file would go there. The files are opened and closed in this function
// and the "config" structure specifies the mode of compression.
static void AnsiToUTF8 (char *string, int len);
static int pack_file (char *infilename, char *outfilename, char *out2filename, const WavpackConfig *config)
{
uint32_t total_samples = 0, bcount;
WavpackConfig loc_config = *config;
RiffChunkHeader riff_chunk_header;
write_id wv_file, wvc_file;
ChunkHeader chunk_header;
WaveHeader WaveHeader;
WavpackContext *wpc;
double dtime;
FILE *infile;
int result;
#if defined(WIN32)
struct _timeb time1, time2;
#else
struct timeval time1, time2;
struct timezone timez;
#endif
CLEAR (wv_file);
CLEAR (wvc_file);
wpc = WavpackOpenFileOutput (write_block, &wv_file, out2filename ? &wvc_file : NULL);
// open the source file for reading
if (*infilename == '-') {
infile = stdin;
#if defined(WIN32)
setmode (fileno (stdin), O_BINARY);
#endif
}
else if ((infile = fopen (infilename, "rb")) == NULL) {
error_line ("can't open file %s!", infilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
// check both output files for overwrite warning required
if (*outfilename != '-' && !overwrite_all && (wv_file.file = fopen (outfilename, "rb")) != NULL) {
DoCloseHandle (wv_file.file);
fprintf (stderr, "overwrite %s (yes/no/all)? ", FN_FIT (outfilename));
SetConsoleTitle ("overwrite?");
switch (yna ()) {
case 'n':
DoCloseHandle (infile);
WavpackCloseFile (wpc);
return SOFT_ERROR;
case 'a':
overwrite_all = 1;
}
}
if (out2filename && !overwrite_all && (wvc_file.file = fopen (out2filename, "rb")) != NULL) {
DoCloseHandle (wvc_file.file);
fprintf (stderr, "overwrite %s (yes/no/all)? ", FN_FIT (out2filename));
SetConsoleTitle ("overwrite?");
switch (yna ()) {
case 'n':
DoCloseHandle (infile);
WavpackCloseFile (wpc);
return SOFT_ERROR;
case 'a':
overwrite_all = 1;
}
}
#if defined(WIN32)
_ftime (&time1);
#else
gettimeofday(&time1,&timez);
#endif
// open output file for writing
if (*outfilename == '-') {
wv_file.file = stdout;
#if defined(WIN32)
setmode (fileno (stdout), O_BINARY);
#endif
}
else if ((wv_file.file = fopen (outfilename, "w+b")) == NULL) {
error_line ("can't create file %s!", outfilename);
DoCloseHandle (infile);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
if (!(loc_config.flags & CONFIG_QUIET_MODE)) {
if (*outfilename == '-')
fprintf (stderr, "packing %s to stdout,", *infilename == '-' ? "stdin" : FN_FIT (infilename));
else if (out2filename)
fprintf (stderr, "creating %s (+%s),", FN_FIT (outfilename), filespec_ext (out2filename));
else
fprintf (stderr, "creating %s,", FN_FIT (outfilename));
}
#if defined (WIN32)
if (loc_config.flags & CONFIG_CREATE_EXE)
if (!DoWriteFile (wv_file.file, wvselfx_image, wvselfx_size, &bcount) || bcount != wvselfx_size) {
error_line ("can't write WavPack data, disk probably full!");
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
#endif
// if not in "raw" mode, read (and copy to output) initial RIFF form header
if (!(loc_config.flags & CONFIG_RAW_FLAG)) {
if ((!DoReadFile (infile, &riff_chunk_header, sizeof (RiffChunkHeader), &bcount) ||
bcount != sizeof (RiffChunkHeader) || strncmp (riff_chunk_header.ckID, "RIFF", 4) ||
strncmp (riff_chunk_header.formType, "WAVE", 4))) {
error_line ("%s is not a valid .WAV file!", infilename);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
else if (!(loc_config.flags & CONFIG_NEW_RIFF_HEADER) &&
!WavpackAddWrapper (wpc, &riff_chunk_header, sizeof (RiffChunkHeader))) {
error_line ("%s", wpc->error_message);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
}
// if not in "raw" mode, loop through all elements of the RIFF wav header
// (until the data chuck) and copy them to the output file
while (!(loc_config.flags & CONFIG_RAW_FLAG)) {
if (!DoReadFile (infile, &chunk_header, sizeof (ChunkHeader), &bcount) ||
bcount != sizeof (ChunkHeader)) {
error_line ("%s is not a valid .WAV file!", infilename);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
else if (!(loc_config.flags & CONFIG_NEW_RIFF_HEADER) &&
!WavpackAddWrapper (wpc, &chunk_header, sizeof (ChunkHeader))) {
error_line ("%s", wpc->error_message);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
little_endian_to_native (&chunk_header, ChunkHeaderFormat);
// if it's the format chunk, we want to get some info out of there and
// make sure it's a .wav file we can handle
if (!strncmp (chunk_header.ckID, "fmt ", 4)) {
int supported = TRUE, format;
if (chunk_header.ckSize < 16 || chunk_header.ckSize > sizeof (WaveHeader) ||
!DoReadFile (infile, &WaveHeader, chunk_header.ckSize, &bcount) ||
bcount != chunk_header.ckSize) {
error_line ("%s is not a valid .WAV file!", infilename);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
else if (!(loc_config.flags & CONFIG_NEW_RIFF_HEADER) &&
!WavpackAddWrapper (wpc, &WaveHeader, chunk_header.ckSize)) {
error_line ("%s", wpc->error_message);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
little_endian_to_native (&WaveHeader, WaveHeaderFormat);
if (debug_logging_mode) {
error_line ("format tag size = %d", chunk_header.ckSize);
error_line ("FormatTag = %x, NumChannels = %d, BitsPerSample = %d",
WaveHeader.FormatTag, WaveHeader.NumChannels, WaveHeader.BitsPerSample);
error_line ("BlockAlign = %d, SampleRate = %d, BytesPerSecond = %d",
WaveHeader.BlockAlign, WaveHeader.SampleRate, WaveHeader.BytesPerSecond);
if (chunk_header.ckSize > 16)
error_line ("cbSize = %d, ValidBitsPerSample = %d", WaveHeader.cbSize,
WaveHeader.ValidBitsPerSample);
if (chunk_header.ckSize > 20)
error_line ("ChannelMask = %x, SubFormat = %d",
WaveHeader.ChannelMask, WaveHeader.SubFormat);
}
if (chunk_header.ckSize > 16 && WaveHeader.cbSize == 2)
loc_config.flags |= CONFIG_ADOBE_MODE;
format = (WaveHeader.FormatTag == 0xfffe && chunk_header.ckSize == 40) ?
WaveHeader.SubFormat : WaveHeader.FormatTag;
loc_config.bits_per_sample = chunk_header.ckSize == 40 ?
WaveHeader.ValidBitsPerSample : WaveHeader.BitsPerSample;
if (format != 1 && format != 3)
supported = FALSE;
if (!WaveHeader.NumChannels ||
WaveHeader.BlockAlign / WaveHeader.NumChannels > 4)
supported = FALSE;
if (loc_config.bits_per_sample < 1 || loc_config.bits_per_sample > 32)
supported = FALSE;
if (!supported) {
error_line ("%s is an unsupported .WAV format!", infilename);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
if (chunk_header.ckSize < 40) {
if (WaveHeader.NumChannels <= 2)
loc_config.channel_mask = 0x5 - WaveHeader.NumChannels;
else
loc_config.channel_mask = (1 << WaveHeader.NumChannels) - 1;
}
else
loc_config.channel_mask = WaveHeader.ChannelMask;
if (format == 3)
loc_config.float_norm_exp = 127;
else if ((loc_config.flags & CONFIG_ADOBE_MODE) &&
WaveHeader.BlockAlign / WaveHeader.NumChannels == 4) {
if (WaveHeader.BitsPerSample == 24)
loc_config.float_norm_exp = 127 + 23;
else if (WaveHeader.BitsPerSample == 32)
loc_config.float_norm_exp = 127 + 15;
}
if (debug_logging_mode) {
if (loc_config.float_norm_exp == 127)
error_line ("data format: normalized 32-bit floating point");
else if (loc_config.float_norm_exp)
error_line ("data format: 32-bit floating point (Audition %d:%d float type 1)",
loc_config.float_norm_exp - 126, 150 - loc_config.float_norm_exp);
else
error_line ("data format: %d-bit integers stored in %d byte(s)",
loc_config.bits_per_sample, WaveHeader.BlockAlign / WaveHeader.NumChannels);
}
}
else if (!strncmp (chunk_header.ckID, "data", 4)) {
// on the data chunk, get size and exit loop
total_samples = chunk_header.ckSize / WaveHeader.BlockAlign;
break;
}
else { // just copy unknown chunks to output file
int bytes_to_copy = (chunk_header.ckSize + 1) & ~1L;
char *buff = malloc (bytes_to_copy);
if (debug_logging_mode)
error_line ("extra unknown chunk \"%c%c%c%c\" of %d bytes",
chunk_header.ckID [0], chunk_header.ckID [1], chunk_header.ckID [2],
chunk_header.ckID [3], chunk_header.ckSize);
if (!DoReadFile (infile, buff, bytes_to_copy, &bcount) ||
bcount != bytes_to_copy ||
(!(loc_config.flags & CONFIG_NEW_RIFF_HEADER) &&
!WavpackAddWrapper (wpc, buff, bytes_to_copy))) {
error_line ("%s", wpc->error_message);
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
free (buff);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
free (buff);
}
}
loc_config.bytes_per_sample = WaveHeader.BlockAlign / WaveHeader.NumChannels;
loc_config.num_channels = WaveHeader.NumChannels;
loc_config.sample_rate = WaveHeader.SampleRate;
WavpackSetConfiguration (wpc, &loc_config, total_samples);
// if we are creating a "correction" file, open it now for writing
if (out2filename) {
if ((wvc_file.file = fopen (out2filename, "w+b")) == NULL) {
error_line ("can't create correction file!");
DoCloseHandle (infile);
DoCloseHandle (wv_file.file);
DoDeleteFile (outfilename);
WavpackCloseFile (wpc);
return SOFT_ERROR;
}
}
// pack the audio portion of the file now
result = pack_audio (wpc, infile);
// if everything went well (and we're not ignoring length) try to read
// anything else that might be appended to the audio data and write that
// to the WavPack metadata as "wrapper"
if (result == NO_ERROR && !(loc_config.flags & CONFIG_IGNORE_LENGTH)) {
uchar buff [16];
while (DoReadFile (infile, buff, sizeof (buff), &bcount) && bcount)
if (!(loc_config.flags & CONFIG_NEW_RIFF_HEADER) &&
!WavpackAddWrapper (wpc, buff, bcount)) {
error_line ("%s", wpc->error_message);
result = HARD_ERROR;
break;
}
}
DoCloseHandle (infile); // we're now done with input file, so close
// we're now done with any WavPack blocks, so flush any remaining data
if (result == NO_ERROR && !WavpackFlushSamples (wpc)) {
error_line ("%s", wpc->error_message);
result = HARD_ERROR;
}
// if still no errors, check to see if we need to create & write a tag
// (which is NOT stored in regular WavPack blocks)
if (result == NO_ERROR && config->num_tag_strings) {
int i;
for (i = 0; i < config->num_tag_strings; ++i) {
int item_len = strchr (config->tag_strings [i], '=') - config->tag_strings [i];
int value_len = strlen (config->tag_strings [i]) - item_len - 1;
if (value_len) {
char *item = malloc (item_len + 1);
char *value = malloc (value_len * 2 + 1);
strncpy (item, config->tag_strings [i], item_len);
item [item_len] = 0;
strcpy (value, config->tag_strings [i] + item_len + 1);
AnsiToUTF8 (value, value_len * 2 + 1);
WavpackAppendTagItem (wpc, item, value, strlen (value));
free (value);
free (item);
}
}
if (!WavpackWriteTag (wpc)) {
error_line ("%s", wpc->error_message);
result = HARD_ERROR;
}
}
// At this point we're done writing to the output files. However, in some
// situations we might have to back up and re-write the initial blocks.
// Currently the only case is if we're ignoring length.
if (result == NO_ERROR && WavpackGetNumSamples (wpc) != WavpackGetSampleIndex (wpc)) {
if (loc_config.flags & CONFIG_IGNORE_LENGTH) {
char *block_buff = malloc (wv_file.first_block_size);
uint32_t wrapper_size;
if (block_buff && !DoSetFilePositionAbsolute (wv_file.file, 0) &&
DoReadFile (wv_file.file, block_buff, wv_file.first_block_size, &bcount) &&
bcount == wv_file.first_block_size && !strncmp (block_buff, "wvpk", 4)) {
WavpackUpdateNumSamples (wpc, block_buff);
if (WavpackGetWrapperLocation (block_buff, &wrapper_size)) {
RiffChunkHeader *riffhdr = WavpackGetWrapperLocation (block_buff, NULL);
ChunkHeader *datahdr = (ChunkHeader *)((char *) riffhdr + wrapper_size - sizeof (ChunkHeader));
uint32_t data_size = WavpackGetSampleIndex (wpc) * WavpackGetNumChannels (wpc) * WavpackGetBytesPerSample (wpc);
if (!strncmp (riffhdr->ckID, "RIFF", 4)) {
little_endian_to_native (riffhdr, ChunkHeaderFormat);
riffhdr->ckSize = wrapper_size + data_size - 8;
native_to_little_endian (riffhdr, ChunkHeaderFormat);
}
if (!strncmp (datahdr->ckID, "data", 4)) {
little_endian_to_native (datahdr, ChunkHeaderFormat);
datahdr->ckSize = data_size;
native_to_little_endian (datahdr, ChunkHeaderFormat);
}
}
if (DoSetFilePositionAbsolute (wv_file.file, 0) ||
!DoWriteFile (wv_file.file, block_buff, wv_file.first_block_size, &bcount) ||
bcount != wv_file.first_block_size) {
error_line ("couldn't update WavPack header with actual length!!");
result = SOFT_ERROR;
}
free (block_buff);
}
else {
error_line ("couldn't update WavPack header with actual length!!");
result = SOFT_ERROR;
}
if (result == NO_ERROR && wvc_file.file) {
block_buff = malloc (wvc_file.first_block_size);
if (block_buff && !DoSetFilePositionAbsolute (wvc_file.file, 0) &&
DoReadFile (wvc_file.file, block_buff, wvc_file.first_block_size, &bcount) &&
bcount == wvc_file.first_block_size && !strncmp (block_buff, "wvpk", 4)) {
WavpackUpdateNumSamples (wpc, block_buff);
if (DoSetFilePositionAbsolute (wvc_file.file, 0) ||
!DoWriteFile (wvc_file.file, block_buff, wvc_file.first_block_size, &bcount) ||
bcount != wvc_file.first_block_size) {
error_line ("couldn't update WavPack header with actual length!!");
result = SOFT_ERROR;
}
}
else {
error_line ("couldn't update WavPack header with actual length!!");
result = SOFT_ERROR;
}
free (block_buff);
}
if (result == NO_ERROR)
error_line ("warning: length was %s by %d samples, corrected",
WavpackGetSampleIndex (wpc) < total_samples ? "short" : "long",
abs (total_samples - WavpackGetSampleIndex (wpc)));
}
else {
error_line ("couldn't read all samples, file may be corrupt!!");
result = SOFT_ERROR;
}
}
// at this point we're done with the files, so close 'em whether there
// were any other errors or not
if (!DoCloseHandle (wv_file.file)) {
error_line ("can't close WavPack file!");
if (result == NO_ERROR)
result = SOFT_ERROR;
}
if (out2filename && !DoCloseHandle (wvc_file.file)) {
error_line ("can't close correction file!");
if (result == NO_ERROR)
result = SOFT_ERROR;
}
// if there were any errors, delete the output files, close the context,
// and return the error
if (result != NO_ERROR) {
DoDeleteFile (outfilename);
if (out2filename)
DoDeleteFile (out2filename);
WavpackCloseFile (wpc);
return result;
}
if (result == NO_ERROR && (loc_config.flags & CONFIG_COPY_TIME))
if (!copy_timestamp (infilename, outfilename) ||
(out2filename && !copy_timestamp (infilename, out2filename)))
error_line ("failure copying time stamp!");
// compute and display the time consumed along with some other details of
// the packing operation, and then return NO_ERROR
#if defined(WIN32)
_ftime (&time2);
dtime = time2.time + time2.millitm / 1000.0;
dtime -= time1.time + time1.millitm / 1000.0;
#else
gettimeofday(&time2,&timez);
dtime = time2.tv_sec + time2.tv_usec / 1000000.0;
dtime -= time1.tv_sec + time1.tv_usec / 1000000.0;
#endif
if ((loc_config.flags & CONFIG_CALC_NOISE) && pack_noise (wpc, NULL) > 0.0) {
int full_scale_bits = WavpackGetBitsPerSample (wpc);
double full_scale_rms = 0.5, sum, peak;
while (full_scale_bits--)
full_scale_rms *= 2.0;
full_scale_rms = full_scale_rms * (full_scale_rms - 1.0) * 0.5;
sum = pack_noise (wpc, &peak);
error_line ("ave noise = %.2f dB, peak noise = %.2f dB",
log10 (sum / WavpackGetNumSamples (wpc) / full_scale_rms) * 10,
log10 (peak / full_scale_rms) * 10);
}
if (!(loc_config.flags & CONFIG_QUIET_MODE)) {
char *file, *fext, *oper, *cmode, cratio [16] = "";
if (outfilename && *outfilename != '-') {
file = FN_FIT (outfilename);
fext = wvc_file.bytes_written ? " (+.wvc)" : "";
oper = "created";
}
else {
file = (*infilename == '-') ? "stdin" : FN_FIT (infilename);
fext = "";
oper = "packed";
}
if (WavpackLossyBlocks (wpc)) {
cmode = "lossy";
if (WavpackGetAverageBitrate (wpc, TRUE) != 0.0)
sprintf (cratio, ", %d kbps", (int) (WavpackGetAverageBitrate (wpc, TRUE) / 1000.0));
}
else {
cmode = "lossless";
if (WavpackGetRatio (wpc) != 0.0)
sprintf (cratio, ", %.2f%%", 100.0 - WavpackGetRatio (wpc) * 100.0);
}
error_line ("%s %s%s in %.2f secs (%s%s)", oper, file, fext, dtime, cmode, cratio);
}
WavpackCloseFile (wpc);
return NO_ERROR;
}
// This function handles the actual audio data compression. It assumes that the
// input file is positioned at the beginning of the audio data and that the
// WavPack configuration has been set. This is where the conversion from RIFF
// little-endian standard the executing processor's format is done and where
// (if selected) the MD5 sum is calculated and displayed.
#define INPUT_SAMPLES 65536
static int pack_audio (WavpackContext *wpc, FILE *infile)
{
uint32_t samples_remaining, samples_read = 0;
double progress = -1.0;
int bytes_per_sample;
int32_t *sample_buffer;
uchar *input_buffer;
MD5_CTX md5_context;
if (wpc->config.flags & CONFIG_MD5_CHECKSUM)
MD5Init (&md5_context);
WavpackPackInit (wpc);
bytes_per_sample = WavpackGetBytesPerSample (wpc) * WavpackGetNumChannels (wpc);
input_buffer = malloc (INPUT_SAMPLES * bytes_per_sample);
sample_buffer = malloc (INPUT_SAMPLES * sizeof (int32_t) * WavpackGetNumChannels (wpc));
samples_remaining = WavpackGetNumSamples (wpc);
while (1) {
uint32_t bytes_to_read, bytes_read = 0;
uint sample_count;
if ((wpc->config.flags & CONFIG_IGNORE_LENGTH) || samples_remaining > INPUT_SAMPLES)
bytes_to_read = INPUT_SAMPLES * bytes_per_sample;
else
bytes_to_read = samples_remaining * bytes_per_sample;
samples_remaining -= bytes_to_read / bytes_per_sample;
DoReadFile (infile, input_buffer, bytes_to_read, &bytes_read);
samples_read += sample_count = bytes_read / bytes_per_sample;
if (wpc->config.flags & CONFIG_MD5_CHECKSUM)
MD5Update (&md5_context, input_buffer, bytes_read);
if (!sample_count)
break;
if (sample_count) {
uint cnt = sample_count * WavpackGetNumChannels (wpc);
uchar *sptr = input_buffer;
int32_t *dptr = sample_buffer;
switch (WavpackGetBytesPerSample (wpc)) {
case 1:
while (cnt--)
*dptr++ = *sptr++ - 128;
break;
case 2:
while (cnt--) {
*dptr++ = sptr [0] | ((int32_t)(signed char) sptr [1] << 8);
sptr += 2;
}
break;
case 3:
while (cnt--) {
*dptr++ = sptr [0] | ((int32_t) sptr [1] << 8) | ((int32_t)(signed char) sptr [2] << 16);
sptr += 3;
}
break;
case 4:
while (cnt--) {
*dptr++ = sptr [0] | ((int32_t) sptr [1] << 8) | ((int32_t) sptr [2] << 16) | ((int32_t)(signed char) sptr [3] << 24);
sptr += 4;
}
break;
}
}
if (!WavpackPackSamples (wpc, sample_buffer, sample_count)) {
error_line ("%s", wpc->error_message);
free (sample_buffer);
free (input_buffer);
return HARD_ERROR;
}
if (check_break ()) {
fprintf (stderr, "^C\n");
free (sample_buffer);
free (input_buffer);
return SOFT_ERROR;
}
if (WavpackGetProgress (wpc) != -1.0 &&
progress != floor (WavpackGetProgress (wpc) * 100.0 + 0.5)) {
int nobs = progress == -1.0;
progress = WavpackGetProgress (wpc);
display_progress (progress);
progress = floor (progress * 100.0 + 0.5);
if (!(wpc->config.flags & CONFIG_QUIET_MODE))
fprintf (stderr, "%s%3d%% done...",
nobs ? " " : "\b\b\b\b\b\b\b\b\b\b\b\b", (int) progress);
}
}
free (sample_buffer);
free (input_buffer);
if (!WavpackFlushSamples (wpc)) {
error_line ("%s", wpc->error_message);
return HARD_ERROR;
}
if (wpc->config.flags & CONFIG_MD5_CHECKSUM) {
char md5_string [] = "original md5 signature: 00000000000000000000000000000000";
uchar md5_digest [16];
int i;
MD5Final (md5_digest, &md5_context);
for (i = 0; i < 16; ++i)
sprintf (md5_string + 24 + (i * 2), "%02x", md5_digest [i]);
if (!(wpc->config.flags & CONFIG_QUIET_MODE))
error_line (md5_string);
WavpackStoreMD5Sum (wpc, md5_digest);
}
return NO_ERROR;
}
// Convert the Unicode wide-format string into a UTF-8 string using no more
// than the specified buffer length. The wide-format string must be NULL
// terminated and the resulting string will be NULL terminated. The actual
// number of characters converted (not counting terminator) is returned, which
// may be less than the number of characters in the wide string if the buffer
// length is exceeded.
static int WideCharToUTF8 (const ushort *Wide, uchar *pUTF8, int len)
{
const ushort *pWide = Wide;
int outndx = 0;
while (*pWide) {
if (*pWide < 0x80 && outndx + 1 < len)
pUTF8 [outndx++] = (uchar) *pWide++;
else if (*pWide < 0x800 && outndx + 2 < len) {
pUTF8 [outndx++] = (uchar) (0xc0 | ((*pWide >> 6) & 0x1f));
pUTF8 [outndx++] = (uchar) (0x80 | (*pWide++ & 0x3f));
}
else if (outndx + 3 < len) {
pUTF8 [outndx++] = (uchar) (0xe0 | ((*pWide >> 12) & 0xf));
pUTF8 [outndx++] = (uchar) (0x80 | ((*pWide >> 6) & 0x3f));
pUTF8 [outndx++] = (uchar) (0x80 | (*pWide++ & 0x3f));
}
else
break;
}
pUTF8 [outndx] = 0;
return pWide - Wide;
}
// Convert a Ansi string into its Unicode UTF-8 format equivalent. The
// conversion is done in-place so the maximum length of the string buffer must
// be specified because the string may become longer or shorter. If the
// resulting string will not fit in the specified buffer size then it is
// truncated.
static void AnsiToUTF8 (char *string, int len)
{
int max_chars = strlen (string);
#if defined(WIN32)
ushort *temp = (ushort *) malloc ((max_chars + 1) * 2);
MultiByteToWideChar (CP_ACP, 0, string, -1, temp, max_chars + 1);
WideCharToUTF8 (temp, (uchar *) string, len);
#else
char *temp = malloc (len);
char *outp = temp;
char *inp = string;
size_t insize = max_chars;
size_t outsize = len - 1;
int err = 0;
char *old_locale;
memset(temp, 0, len);
old_locale = setlocale (LC_CTYPE, "");
iconv_t converter = iconv_open ("UTF-8", "");
err = iconv (converter, &inp, &insize, &outp, &outsize);
iconv_close (converter);
setlocale (LC_CTYPE, old_locale);
if (err == -1) {
free(temp);
return;
}
memmove (string, temp, len);
#endif
free (temp);
}
//////////////////////////////////////////////////////////////////////////////
// This function displays the progress status on the title bar of the DOS //
// window that WavPack is running in. The "file_progress" argument is for //
// the current file only and ranges from 0 - 1; this function takes into //
// account the total number of files to generate a batch progress number. //
//////////////////////////////////////////////////////////////////////////////
static void display_progress (double file_progress)
{
char title [40];
file_progress = (file_index + file_progress) / num_files;
sprintf (title, "%d%% (WavPack)", (int) ((file_progress * 100.0) + 0.5));
SetConsoleTitle (title);
}
Reference in New Issue View Git Blame Copy Permalink