mirror of https://github.com/xiph/flac
add new verify option (-V)
This commit is contained in:
Josh Coalson
parent
6c2553681e
commit
bbbef82a92
|
|
@ -16,6 +16,8 @@
|
|||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
/*@@@ need to "_finish()" the verify decoder */
|
||||
|
||||
#include <assert.h>
|
||||
#if defined _WIN32 && !defined __CYGWIN__
|
||||
/* where MSVC puts unlink() */
|
||||
|
|
@ -23,23 +25,43 @@
|
|||
#else
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
#include <stdio.h> /* for FILE */
|
||||
#include <stdio.h> /* for FILE et al. */
|
||||
#include <stdlib.h> /* for malloc */
|
||||
#include <string.h> /* for strcmp() */
|
||||
#include "FLAC/all.h"
|
||||
#include "encode.h"
|
||||
|
||||
#define CHUNK_OF_SAMPLES 2048
|
||||
|
||||
typedef enum {
|
||||
FLAC__VERIFY_OK,
|
||||
FLAC__VERIFY_FAILED_IN_FRAME,
|
||||
FLAC__VERIFY_FAILED_IN_METADATA
|
||||
} verify_code;
|
||||
|
||||
typedef struct {
|
||||
int32 *original[FLAC__MAX_CHANNELS];
|
||||
unsigned size; /* of each original[] in samples */
|
||||
unsigned tail; /* in wide samples */
|
||||
const byte *encoded_signal;
|
||||
unsigned encoded_bytes;
|
||||
bool into_frames;
|
||||
verify_code result;
|
||||
FLAC__StreamDecoder *decoder;
|
||||
} verify_fifo_struct;
|
||||
|
||||
typedef struct {
|
||||
FILE *fout;
|
||||
const char *outfile;
|
||||
FLAC__Encoder *encoder;
|
||||
bool verify;
|
||||
bool verbose;
|
||||
uint64 unencoded_size;
|
||||
uint64 total_samples_to_encode;
|
||||
uint64 bytes_written;
|
||||
uint64 samples_written;
|
||||
unsigned current_frame;
|
||||
verify_fifo_struct verify_fifo;
|
||||
} encoder_wrapper_struct;
|
||||
|
||||
static bool is_big_endian_host;
|
||||
|
|
@ -55,14 +77,18 @@ static int32 *input[FLAC__MAX_CHANNELS];
|
|||
/* local routines */
|
||||
static bool init(encoder_wrapper_struct *encoder_wrapper);
|
||||
static bool init_encoder(bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned channels, unsigned bps, unsigned sample_rate, encoder_wrapper_struct *encoder_wrapper);
|
||||
static void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps);
|
||||
static void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, encoder_wrapper_struct *encoder_wrapper);
|
||||
static FLAC__EncoderWriteStatus write_callback(const FLAC__Encoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
|
||||
static void metadata_callback(const FLAC__Encoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data);
|
||||
static FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data);
|
||||
static FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data);
|
||||
static void verify_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
|
||||
static void verify_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
|
||||
static void print_stats(const encoder_wrapper_struct *encoder_wrapper);
|
||||
static bool read_little_endian_uint16(FILE *f, uint16 *val, bool eof_ok);
|
||||
static bool read_little_endian_uint32(FILE *f, uint32 *val, bool eof_ok);
|
||||
|
||||
int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 skip, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision)
|
||||
int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision)
|
||||
{
|
||||
encoder_wrapper_struct encoder_wrapper;
|
||||
FILE *fin;
|
||||
|
|
@ -73,6 +99,7 @@ int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
uint32 xx;
|
||||
|
||||
encoder_wrapper.encoder = 0;
|
||||
encoder_wrapper.verify = verify;
|
||||
encoder_wrapper.verbose = verbose;
|
||||
encoder_wrapper.bytes_written = 0;
|
||||
encoder_wrapper.samples_written = 0;
|
||||
|
|
@ -200,6 +227,7 @@ int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
|
||||
encoder_wrapper.total_samples_to_encode = data_bytes / bytes_per_wide_sample - skip;
|
||||
encoder_wrapper.unencoded_size = encoder_wrapper.total_samples_to_encode * bytes_per_wide_sample + 44; /* 44 for the size of the WAV headers */
|
||||
encoder_wrapper.verify_fifo.into_frames = true;
|
||||
|
||||
while(data_bytes > 0) {
|
||||
bytes_read = fread(ucbuffer, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, fin);
|
||||
|
|
@ -217,9 +245,9 @@ int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
}
|
||||
else {
|
||||
unsigned wide_samples = bytes_read / bytes_per_wide_sample;
|
||||
format_input(wide_samples, false, is_unsigned_samples, channels, bps);
|
||||
format_input(wide_samples, false, is_unsigned_samples, channels, bps, &encoder_wrapper);
|
||||
if(!FLAC__encoder_process(encoder_wrapper.encoder, input, wide_samples)) {
|
||||
fprintf(stderr, "ERROR during encoding, state = %d\n", encoder_wrapper.encoder->state);
|
||||
fprintf(stderr, "ERROR during encoding, state = %d:%s\n", encoder_wrapper.encoder->state, FLAC__EncoderStateString[encoder_wrapper.encoder->state]);
|
||||
goto wav_abort_;
|
||||
}
|
||||
data_bytes -= bytes_read;
|
||||
|
|
@ -228,7 +256,7 @@ int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
|
||||
wav_end_:
|
||||
if(encoder_wrapper.encoder) {
|
||||
if(encoder_wrapper.encoder->state != FLAC__ENCODER_UNINITIALIZED)
|
||||
if(encoder_wrapper.encoder->state == FLAC__ENCODER_OK)
|
||||
FLAC__encoder_finish(encoder_wrapper.encoder);
|
||||
FLAC__encoder_free_instance(encoder_wrapper.encoder);
|
||||
}
|
||||
|
|
@ -236,22 +264,40 @@ wav_end_:
|
|||
print_stats(&encoder_wrapper);
|
||||
printf("\n");
|
||||
}
|
||||
if(verify) {
|
||||
if(encoder_wrapper.verify_fifo.result != FLAC__VERIFY_OK) {
|
||||
printf("Verify FAILED! Do not use %s\n", outfile);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
printf("Verify succeeded\n");
|
||||
}
|
||||
}
|
||||
fclose(fin);
|
||||
return 0;
|
||||
wav_abort_:
|
||||
if(encoder_wrapper.verbose && encoder_wrapper.total_samples_to_encode > 0)
|
||||
printf("\n");
|
||||
if(encoder_wrapper.encoder) {
|
||||
if(encoder_wrapper.encoder->state != FLAC__ENCODER_UNINITIALIZED)
|
||||
if(encoder_wrapper.encoder->state == FLAC__ENCODER_OK)
|
||||
FLAC__encoder_finish(encoder_wrapper.encoder);
|
||||
FLAC__encoder_free_instance(encoder_wrapper.encoder);
|
||||
}
|
||||
if(verify) {
|
||||
if(encoder_wrapper.verify_fifo.result != FLAC__VERIFY_OK) {
|
||||
printf("Verify FAILED! Do not use %s\n", outfile);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
printf("Verify succeeded\n");
|
||||
}
|
||||
}
|
||||
fclose(fin);
|
||||
unlink(outfile);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 skip, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate)
|
||||
int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate)
|
||||
{
|
||||
encoder_wrapper_struct encoder_wrapper;
|
||||
FILE *fin;
|
||||
|
|
@ -259,6 +305,7 @@ int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
const size_t bytes_per_wide_sample = channels * (bps >> 3);
|
||||
|
||||
encoder_wrapper.encoder = 0;
|
||||
encoder_wrapper.verify = verify;
|
||||
encoder_wrapper.verbose = verbose;
|
||||
encoder_wrapper.bytes_written = 0;
|
||||
encoder_wrapper.samples_written = 0;
|
||||
|
|
@ -311,6 +358,8 @@ int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
goto raw_abort_;
|
||||
}
|
||||
|
||||
encoder_wrapper.verify_fifo.into_frames = true;
|
||||
|
||||
while(!feof(fin)) {
|
||||
bytes_read = fread(ucbuffer, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, fin);
|
||||
if(bytes_read == 0) {
|
||||
|
|
@ -325,16 +374,16 @@ int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
}
|
||||
else {
|
||||
unsigned wide_samples = bytes_read / bytes_per_wide_sample;
|
||||
format_input(wide_samples, is_big_endian, is_unsigned_samples, channels, bps);
|
||||
format_input(wide_samples, is_big_endian, is_unsigned_samples, channels, bps, &encoder_wrapper);
|
||||
if(!FLAC__encoder_process(encoder_wrapper.encoder, input, wide_samples)) {
|
||||
fprintf(stderr, "ERROR during encoding, state = %d\n", encoder_wrapper.encoder->state);
|
||||
fprintf(stderr, "ERROR during encoding, state = %d:%s\n", encoder_wrapper.encoder->state, FLAC__EncoderStateString[encoder_wrapper.encoder->state]);
|
||||
goto raw_abort_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(encoder_wrapper.encoder) {
|
||||
if(encoder_wrapper.encoder->state != FLAC__ENCODER_UNINITIALIZED)
|
||||
if(encoder_wrapper.encoder->state == FLAC__ENCODER_OK)
|
||||
FLAC__encoder_finish(encoder_wrapper.encoder);
|
||||
FLAC__encoder_free_instance(encoder_wrapper.encoder);
|
||||
}
|
||||
|
|
@ -342,16 +391,34 @@ int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 ski
|
|||
print_stats(&encoder_wrapper);
|
||||
printf("\n");
|
||||
}
|
||||
if(verify) {
|
||||
if(encoder_wrapper.verify_fifo.result != FLAC__VERIFY_OK) {
|
||||
printf("Verify FAILED! Do not use %s\n", outfile);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
printf("Verify succeeded\n");
|
||||
}
|
||||
}
|
||||
fclose(fin);
|
||||
return 0;
|
||||
raw_abort_:
|
||||
if(encoder_wrapper.verbose && encoder_wrapper.total_samples_to_encode > 0)
|
||||
printf("\n");
|
||||
if(encoder_wrapper.encoder) {
|
||||
if(encoder_wrapper.encoder->state != FLAC__ENCODER_UNINITIALIZED)
|
||||
if(encoder_wrapper.encoder->state == FLAC__ENCODER_OK)
|
||||
FLAC__encoder_finish(encoder_wrapper.encoder);
|
||||
FLAC__encoder_free_instance(encoder_wrapper.encoder);
|
||||
}
|
||||
if(verify) {
|
||||
if(encoder_wrapper.verify_fifo.result != FLAC__VERIFY_OK) {
|
||||
printf("Verify FAILED! Do not use %s\n", outfile);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
printf("Verify succeeded\n");
|
||||
}
|
||||
}
|
||||
fclose(fin);
|
||||
unlink(outfile);
|
||||
return 1;
|
||||
|
|
@ -381,6 +448,33 @@ bool init_encoder(bool lax, bool do_mid_side, bool do_exhaustive_model_search, b
|
|||
if(channels != 2 || bps > 16)
|
||||
do_mid_side = false;
|
||||
|
||||
if(encoder_wrapper->verify) {
|
||||
unsigned i;
|
||||
|
||||
/* set up the fifo which will hold the original signal to compare against */
|
||||
encoder_wrapper->verify_fifo.size = blocksize + CHUNK_OF_SAMPLES;
|
||||
for(i = 0; i < channels; i++) {
|
||||
if(0 == (encoder_wrapper->verify_fifo.original[i] = (int32*)malloc(sizeof(int32) * encoder_wrapper->verify_fifo.size))) {
|
||||
fprintf(stderr, "ERROR allocating verify buffers\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
encoder_wrapper->verify_fifo.tail = 0;
|
||||
encoder_wrapper->verify_fifo.into_frames = false;
|
||||
encoder_wrapper->verify_fifo.result = FLAC__VERIFY_OK;
|
||||
|
||||
/* set up a stream decoder for verification */
|
||||
encoder_wrapper->verify_fifo.decoder = FLAC__stream_decoder_get_new_instance();
|
||||
if(0 == encoder_wrapper->verify_fifo.decoder) {
|
||||
fprintf(stderr, "ERROR creating the verify decoder instance\n");
|
||||
return false;
|
||||
}
|
||||
if(FLAC__stream_decoder_init(encoder_wrapper->verify_fifo.decoder, verify_read_callback, verify_write_callback, verify_metadata_callback, verify_error_callback, encoder_wrapper) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA) {
|
||||
fprintf(stderr, "ERROR initializing decoder, state = %d:%s\n", encoder_wrapper->verify_fifo.decoder->state, FLAC__StreamDecoderStateString[encoder_wrapper->verify_fifo.decoder->state]);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
encoder_wrapper->encoder->streamable_subset = !lax;
|
||||
encoder_wrapper->encoder->channels = channels;
|
||||
encoder_wrapper->encoder->bits_per_sample = bps;
|
||||
|
|
@ -401,7 +495,7 @@ bool init_encoder(bool lax, bool do_mid_side, bool do_exhaustive_model_search, b
|
|||
return true;
|
||||
}
|
||||
|
||||
void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps)
|
||||
void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, encoder_wrapper_struct *encoder_wrapper)
|
||||
{
|
||||
unsigned wide_sample, sample, channel, byte;
|
||||
|
||||
|
|
@ -438,6 +532,13 @@ void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_sa
|
|||
input[channel][wide_sample] = (int32)ssbuffer[sample];
|
||||
}
|
||||
}
|
||||
|
||||
if(encoder_wrapper->verify) {
|
||||
for(channel = 0; channel < channels; channel++)
|
||||
memcpy(&encoder_wrapper->verify_fifo.original[channel][encoder_wrapper->verify_fifo.tail], &input[channel][0], sizeof(int32) * wide_samples);
|
||||
encoder_wrapper->verify_fifo.tail += wide_samples;
|
||||
assert(encoder_wrapper->verify_fifo.tail <= encoder_wrapper->verify_fifo.size);
|
||||
}
|
||||
}
|
||||
|
||||
FLAC__EncoderWriteStatus write_callback(const FLAC__Encoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
|
||||
|
|
@ -452,6 +553,23 @@ FLAC__EncoderWriteStatus write_callback(const FLAC__Encoder *encoder, const byte
|
|||
if(samples && encoder_wrapper->verbose && encoder_wrapper->total_samples_to_encode > 0 && !(current_frame & mask))
|
||||
print_stats(encoder_wrapper);
|
||||
|
||||
if(encoder_wrapper->verify) {
|
||||
encoder_wrapper->verify_fifo.encoded_signal = buffer;
|
||||
encoder_wrapper->verify_fifo.encoded_bytes = bytes;
|
||||
if(encoder_wrapper->verify_fifo.into_frames) {
|
||||
if(!FLAC__stream_decoder_process_one_frame(encoder_wrapper->verify_fifo.decoder)) {
|
||||
encoder_wrapper->verify_fifo.result = FLAC__VERIFY_FAILED_IN_FRAME;
|
||||
return FLAC__ENCODER_WRITE_FATAL_ERROR;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if(!FLAC__stream_decoder_process_metadata(encoder_wrapper->verify_fifo.decoder)) {
|
||||
encoder_wrapper->verify_fifo.result = FLAC__VERIFY_FAILED_IN_METADATA;
|
||||
return FLAC__ENCODER_WRITE_FATAL_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(fwrite(buffer, sizeof(byte), bytes, encoder_wrapper->fout) == bytes)
|
||||
return FLAC__ENCODER_WRITE_OK;
|
||||
else
|
||||
|
|
@ -514,6 +632,53 @@ end_:
|
|||
return;
|
||||
}
|
||||
|
||||
FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data)
|
||||
{
|
||||
encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
|
||||
(void)decoder;
|
||||
|
||||
*bytes = encoder_wrapper->verify_fifo.encoded_bytes;
|
||||
memcpy(buffer, encoder_wrapper->verify_fifo.encoded_signal, *bytes);
|
||||
|
||||
return FLAC__STREAM_DECODER_READ_CONTINUE;
|
||||
}
|
||||
|
||||
FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data)
|
||||
{
|
||||
encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
|
||||
unsigned channel, l, r;
|
||||
|
||||
for(channel = 0; channel < decoder->channels; channel++) {
|
||||
if(0 != memcmp(buffer[channel], encoder_wrapper->verify_fifo.original[channel], sizeof(int32) * decoder->blocksize)) {
|
||||
fprintf(stderr, "\nERROR: mismatch in decoded data, verify FAILED!\n");
|
||||
fprintf(stderr, " Please submit a bug report to http://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
|
||||
return FLAC__STREAM_DECODER_WRITE_ABORT;
|
||||
}
|
||||
}
|
||||
/* dequeue the frame from the fifo */
|
||||
for(channel = 0; channel < decoder->channels; channel++) {
|
||||
for(l = 0, r = header->blocksize; r < encoder_wrapper->verify_fifo.tail; l++, r++) {
|
||||
encoder_wrapper->verify_fifo.original[channel][l] = encoder_wrapper->verify_fifo.original[channel][r];
|
||||
}
|
||||
}
|
||||
encoder_wrapper->verify_fifo.tail -= header->blocksize;
|
||||
return FLAC__STREAM_DECODER_WRITE_CONTINUE;
|
||||
}
|
||||
|
||||
void verify_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data)
|
||||
{
|
||||
(void)decoder;
|
||||
(void)metadata;
|
||||
(void)client_data;
|
||||
}
|
||||
|
||||
void verify_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
|
||||
{
|
||||
(void)decoder;
|
||||
(void)client_data;
|
||||
fprintf(stderr, "\nERROR: verification decoder returned error %d:%s\n", status, FLAC__StreamDecoderErrorStatusString[status]);
|
||||
}
|
||||
|
||||
void print_stats(const encoder_wrapper_struct *encoder_wrapper)
|
||||
{
|
||||
#ifdef _MSC_VER
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
#include "FLAC/ordinals.h"
|
||||
|
||||
int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 skip, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision);
|
||||
int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 skip, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate);
|
||||
int encode_wav(const char *infile, const char *outfile, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision);
|
||||
int encode_raw(const char *infile, const char *outfile, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned rice_optimization_level, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ static int usage(const char *message, ...);
|
|||
int main(int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
bool verbose = true, lax = false, mode_decode = false, do_mid_side = true, do_exhaustive_model_search = false, do_qlp_coeff_prec_search = false;
|
||||
bool verify = false, verbose = true, lax = false, mode_decode = false, do_mid_side = true, do_exhaustive_model_search = false, do_qlp_coeff_prec_search = false;
|
||||
unsigned max_lpc_order = 8;
|
||||
unsigned qlp_coeff_precision = 0;
|
||||
uint64 skip = 0;
|
||||
|
|
@ -78,6 +78,10 @@ int main(int argc, char *argv[])
|
|||
qlp_coeff_precision = atoi(argv[++i]);
|
||||
else if(0 == strcmp(argv[i], "-r"))
|
||||
rice_optimization_level = atoi(argv[++i]);
|
||||
else if(0 == strcmp(argv[i], "-V"))
|
||||
verify = true;
|
||||
else if(0 == strcmp(argv[i], "-V-"))
|
||||
verify = false;
|
||||
else if(0 == strcmp(argv[i], "-fb"))
|
||||
format_is_big_endian = true;
|
||||
else if(0 == strcmp(argv[i], "-fl"))
|
||||
|
|
@ -231,10 +235,11 @@ int main(int argc, char *argv[])
|
|||
printf("welcome to redistribute it under certain conditions. Type `flac' for details.\n\n");
|
||||
|
||||
if(!mode_decode) {
|
||||
printf("options:%s -b %u%s -l %u%s%s -q %u -r %u\n",
|
||||
printf("options:%s -b %u%s -l %u%s%s -q %u -r %u%s\n",
|
||||
lax?" --lax":"", (unsigned)blocksize, do_mid_side?" -m":"", max_lpc_order,
|
||||
do_exhaustive_model_search?" -e":"", do_qlp_coeff_prec_search?" -p":"",
|
||||
qlp_coeff_precision, (unsigned)rice_optimization_level
|
||||
qlp_coeff_precision, (unsigned)rice_optimization_level,
|
||||
verify? " -V":""
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -246,9 +251,9 @@ int main(int argc, char *argv[])
|
|||
return decode_raw(argv[i], argv[i+1], verbose, skip, format_is_big_endian, format_is_unsigned_samples);
|
||||
else
|
||||
if(format_is_wave)
|
||||
return encode_wav(argv[i], argv[i+1], verbose, skip, lax, do_mid_side, do_exhaustive_model_search, do_qlp_coeff_prec_search, rice_optimization_level, max_lpc_order, (unsigned)blocksize, qlp_coeff_precision);
|
||||
return encode_wav(argv[i], argv[i+1], verbose, skip, verify, lax, do_mid_side, do_exhaustive_model_search, do_qlp_coeff_prec_search, rice_optimization_level, max_lpc_order, (unsigned)blocksize, qlp_coeff_precision);
|
||||
else
|
||||
return encode_raw(argv[i], argv[i+1], verbose, skip, lax, do_mid_side, do_exhaustive_model_search, do_qlp_coeff_prec_search, rice_optimization_level, max_lpc_order, (unsigned)blocksize, qlp_coeff_precision, format_is_big_endian, format_is_unsigned_samples, format_channels, format_bps, format_sample_rate);
|
||||
return encode_raw(argv[i], argv[i+1], verbose, skip, verify, lax, do_mid_side, do_exhaustive_model_search, do_qlp_coeff_prec_search, rice_optimization_level, max_lpc_order, (unsigned)blocksize, qlp_coeff_precision, format_is_big_endian, format_is_unsigned_samples, format_channels, format_bps, format_sample_rate);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -325,7 +330,8 @@ int usage(const char *message, ...)
|
|||
printf(" -p : do exhaustive search of LP coefficient quantization (expensive!); overrides -q\n");
|
||||
printf(" -q bits : precision of the quantized linear-predictor coefficients, 0 => let encoder decide (min is %u, default is -q 0)\n", FLAC__MIN_QLP_COEFF_PRECISION);
|
||||
printf(" -r level : rice parameter optimization level (level is 0..99, 0 => none, default is -r 0, above 4 doesn't usually help much)\n");
|
||||
printf(" -m-, -e-, -p-, --lax- can all be used to turn off a particular option\n");
|
||||
printf(" -V : verify a correct encoding by decoding the output in parallel and comparing to the original\n");
|
||||
printf(" -m-, -e-, -p-, -V-, --lax- can all be used to turn off a particular option\n");
|
||||
printf("format options:\n");
|
||||
printf(" -fb | -fl : big-endian | little-endian byte order\n");
|
||||
printf(" -fc channels\n");
|
||||
|
|
|
|||
Loading…
Reference in New Issue