* will take on the defaults from the constructor, shown below.
* For more on what the parameters mean, see the documentation.
*
- * bool md5_checking (DEFAULT: false) MD5 checking will be turned off if a seek is requested
- * (*write_callback)() (DEFAULT: NULL ) The callbacks are the only values that MUST be set before FLAC__file_decoder_init()
- * (*metadata_callback)() (DEFAULT: NULL )
- * (*error_callback)() (DEFAULT: NULL )
- * void* client_data (DEFAULT: NULL ) passed back through the callbacks
+ * FLAC__bool md5_checking (DEFAULT: false) MD5 checking will be turned off if a seek is requested
+ * (*write_callback)() (DEFAULT: NULL ) The callbacks are the only values that MUST be set before FLAC__file_decoder_init()
+ * (*metadata_callback)() (DEFAULT: NULL )
+ * (*error_callback)() (DEFAULT: NULL )
+ * void* client_data (DEFAULT: NULL ) passed back through the callbacks
*/
FLAC__FileDecoder *FLAC__file_decoder_new();
void FLAC__file_decoder_delete(FLAC__FileDecoder *);
* FLAC__file_decoder_flush() or FLAC__file_decoder_reset() do
* NOT reset the values to the constructor defaults.
*/
-bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, bool value);
-bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value);
-bool FLAC__file_decoder_set_write_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data));
-bool FLAC__file_decoder_set_metadata_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data));
-bool FLAC__file_decoder_set_error_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data));
-bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value);
+FLAC__bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, FLAC__bool value);
+FLAC__bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value);
+FLAC__bool FLAC__file_decoder_set_write_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data));
+FLAC__bool FLAC__file_decoder_set_metadata_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data));
+FLAC__bool FLAC__file_decoder_set_error_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data));
+FLAC__bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value);
/*
* Various "get" methods
*/
FLAC__FileDecoderState FLAC__file_decoder_get_state(const FLAC__FileDecoder *decoder);
-bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder);
+FLAC__bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder);
/*
* Initialize the instance; should be called after construction and
* md5_checking is set AND the stored MD5 sum is non-zero AND the stored
* MD5 sum and computed MD5 sum do not match.
*/
-bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder);
+FLAC__bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder);
/*
* Methods for decoding the data
*/
-bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder);
-bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder);
-bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder);
-bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder);
+FLAC__bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder);
+FLAC__bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder);
+FLAC__bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder);
+FLAC__bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder);
-bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, uint64 sample);
+FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__uint64 sample);
#endif
#define FLAC__MAX_BLOCK_SIZE (65535u)
#define FLAC__MAX_CHANNELS (8u)
#define FLAC__MIN_BITS_PER_SAMPLE (4u)
-/*NOTE: only up to 24 because of the current predictor coefficient quantization and the fact we use int32s for all work */
+/*NOTE: only up to 24 because of the current predictor coefficient quantization and the fact we use FLAC__int32s for all work */
#define FLAC__MAX_BITS_PER_SAMPLE (24u)
/* the following is ((2 ** 20) - 1) div 10 */
#define FLAC__MAX_SAMPLE_RATE (1048570u)
#define FLAC__VERSION_STRING VERSION
#endif
-extern const byte FLAC__STREAM_SYNC_STRING[4]; /* = "fLaC" */;
+extern const FLAC__byte FLAC__STREAM_SYNC_STRING[4]; /* = "fLaC" */;
extern const unsigned FLAC__STREAM_SYNC; /* = 0x664C6143 */;
extern const unsigned FLAC__STREAM_SYNC_LEN; /* = 32 bits */;
* n: constant value for signal; n = frame's bits-per-sample
*/
typedef struct {
- int32 value;
+ FLAC__int32 value;
} FLAC__Subframe_Constant;
/*****************************************************************************
* n*i: unencoded signal; n = frame's bits-per-sample, i = frame's blocksize
*/
typedef struct {
- const int32 *data;
+ const FLAC__int32 *data;
} FLAC__Subframe_Verbatim;
/*****************************************************************************
typedef struct {
FLAC__EntropyCodingMethod entropy_coding_method;
unsigned order;
- int32 warmup[FLAC__MAX_FIXED_ORDER];
- const int32 *residual;
+ FLAC__int32 warmup[FLAC__MAX_FIXED_ORDER];
+ const FLAC__int32 *residual;
} FLAC__Subframe_Fixed;
/*****************************************************************************
unsigned order;
unsigned qlp_coeff_precision;
int quantization_level;
- int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
- int32 warmup[FLAC__MAX_LPC_ORDER];
- const int32 *residual;
+ FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
+ FLAC__int32 warmup[FLAC__MAX_LPC_ORDER];
+ const FLAC__int32 *residual;
} FLAC__Subframe_LPC;
extern const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /* = 4 bits */
FLAC__ChannelAssignment channel_assignment;
unsigned bits_per_sample;
union {
- uint32 frame_number;
- uint64 sample_number;
+ FLAC__uint32 frame_number;
+ FLAC__uint64 sample_number;
} number;
- uint8 crc;
+ FLAC__uint8 crc;
} FLAC__FrameHeader;
extern const unsigned FLAC__FRAME_HEADER_SYNC; /* = 0x3ffe */
* 16: CRC-16 (polynomial = x^16 + x^15 + x^2 + x^0, initialized with 0) of everything before the crc, back to and including the frame header sync code
*/
typedef struct {
- uint16 crc;
+ FLAC__uint16 crc;
} FLAC__FrameFooter;
extern const unsigned FLAC__FRAME_FOOTER_CRC_LEN; /* = 16 bits */
unsigned sample_rate;
unsigned channels;
unsigned bits_per_sample;
- uint64 total_samples;
- byte md5sum[16];
+ FLAC__uint64 total_samples;
+ FLAC__byte md5sum[16];
} FLAC__StreamMetaData_StreamInfo;
extern const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /* = 16 bits */
* 4+n/8 bytes total
*/
typedef struct {
- byte id[4];
- byte *data;
+ FLAC__byte id[4];
+ FLAC__byte *data;
} FLAC__StreamMetaData_Application;
extern const unsigned FLAC__STREAM_METADATA_APPLICATION_ID_LEN; /* = 32 bits */
* 18 bytes total
*/
typedef struct {
- uint64 sample_number;
- uint64 stream_offset;
+ FLAC__uint64 sample_number;
+ FLAC__uint64 stream_offset;
unsigned frame_samples;
} FLAC__StreamMetaData_SeekPoint;
extern const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN; /* = 16 bits */
extern const unsigned FLAC__STREAM_METADATA_SEEKPOINT_LEN; /* = 18 bytes */
-extern const uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; /* = 0xffffffffffffffff */
+extern const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; /* = 0xffffffffffffffff */
/*****************************************************************************
*
*/
typedef struct {
FLAC__MetaDataType type;
- bool is_last;
+ FLAC__bool is_last;
unsigned length; /* in bytes */
union {
FLAC__StreamMetaData_StreamInfo stream_info;
#ifndef FLAC__ORDINALS_H
#define FLAC__ORDINALS_H
-#ifdef bool
-#undef bool
-#endif
#ifdef true
#undef true
#endif
#ifdef false
#undef false
#endif
-#ifdef int8
-#undef int8
-#endif
-#ifdef uint8
-#undef uint8
-#endif
-#ifdef int16
-#undef int16
-#endif
-#ifdef uint16
-#undef uint16
-#endif
-#ifdef int32
-#undef int32
-#endif
-#ifdef uint32
-#undef uint32
-#endif
-#ifdef int64
-#undef int64
-#endif
-#ifdef uint64
-#undef uint64
-#endif
-#ifdef byte
-#undef byte
-#endif
-#ifdef real
-#undef real
-#endif
-
#define true 1
#define false 0
-typedef int bool;
-typedef signed char int8;
-typedef unsigned char uint8;
-typedef signed short int16;
-typedef unsigned short uint16;
-typedef signed int int32;
-typedef unsigned int uint32;
+typedef int FLAC__bool;
+typedef signed char FLAC__int8;
+typedef unsigned char FLAC__uint8;
+typedef signed short FLAC__int16;
+typedef unsigned short FLAC__uint16;
+typedef signed int FLAC__int32;
+typedef unsigned int FLAC__uint32;
#if defined _WIN32 && !defined __CYGWIN__
-typedef __int64 int64;
-typedef unsigned __int64 uint64;
+typedef __int64 FLAC__int64;
+typedef unsigned __int64 FLAC__uint64;
#else
-typedef long long int int64;
-typedef unsigned long long uint64;
+typedef long long int FLAC__int64;
+typedef unsigned long long FLAC__uint64;
#endif
-typedef uint8 byte;
-typedef float real;
+typedef FLAC__uint8 FLAC__byte;
+typedef float FLAC__real;
#endif
#include "format.h"
-bool FLAC__seek_table_is_valid(const FLAC__StreamMetaData_SeekTable *seek_table);
+FLAC__bool FLAC__seek_table_is_valid(const FLAC__StreamMetaData_SeekTable *seek_table);
#endif
* FLAC__stream_decoder_flush() or FLAC__stream_decoder_reset() do
* NOT reset the values to the constructor defaults.
*/
-bool FLAC__stream_decoder_set_read_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderReadStatus (*value)(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data));
-bool FLAC__stream_decoder_set_write_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data));
-bool FLAC__stream_decoder_set_metadata_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data));
-bool FLAC__stream_decoder_set_error_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data));
-bool FLAC__stream_decoder_set_client_data(const FLAC__StreamDecoder *decoder, void *value);
+FLAC__bool FLAC__stream_decoder_set_read_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderReadStatus (*value)(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data));
+FLAC__bool FLAC__stream_decoder_set_write_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data));
+FLAC__bool FLAC__stream_decoder_set_metadata_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data));
+FLAC__bool FLAC__stream_decoder_set_error_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data));
+FLAC__bool FLAC__stream_decoder_set_client_data(const FLAC__StreamDecoder *decoder, void *value);
/*
* Methods to return the current stream decoder state, number
/*
* state control methods
*/
-bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder);
-bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder);
+FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder);
+FLAC__bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder);
/*
* Methods for decoding the data
*/
-bool FLAC__stream_decoder_process_whole_stream(FLAC__StreamDecoder *decoder);
-bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder);
-bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder);
-bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder);
+FLAC__bool FLAC__stream_decoder_process_whole_stream(FLAC__StreamDecoder *decoder);
+FLAC__bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder);
+FLAC__bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder);
+FLAC__bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder);
#endif
* will take on the defaults from the constructor, shown below.
* For more on what the parameters mean, see the documentation.
*
- * bool streamable_subset (DEFAULT: true ) true to limit encoder to generating a Subset stream, else false
- * bool do_mid_side_stereo (DEFAULT: false) if true then channels must be 2
- * bool loose_mid_side_stereo (DEFAULT: false) if true then do_mid_side_stereo must be true
- * unsigned channels (DEFAULT: 2 ) must be <= FLAC__MAX_CHANNELS
- * unsigned bits_per_sample (DEFAULT: 16 ) do not give the encoder wider data than what you specify here or bad things will happen!
- * unsigned sample_rate (DEFAULT: 44100)
- * unsigned blocksize (DEFAULT: 1152 )
- * unsigned max_lpc_order (DEFAULT: 0 ) 0 => encoder will not try general LPC, only fixed predictors; must be <= FLAC__MAX_LPC_ORDER
- * unsigned qlp_coeff_precision (DEFAULT: 0 ) >= FLAC__MIN_QLP_COEFF_PRECISION, or 0 to let encoder select based on blocksize;
+ * FLAC__bool streamable_subset (DEFAULT: true ) true to limit encoder to generating a Subset stream, else false
+ * FLAC__bool do_mid_side_stereo (DEFAULT: false) if true then channels must be 2
+ * FLAC__bool loose_mid_side_stereo (DEFAULT: false) if true then do_mid_side_stereo must be true
+ * unsigned channels (DEFAULT: 2 ) must be <= FLAC__MAX_CHANNELS
+ * unsigned bits_per_sample (DEFAULT: 16 ) do not give the encoder wider data than what you specify here or bad things will happen!
+ * unsigned sample_rate (DEFAULT: 44100)
+ * unsigned blocksize (DEFAULT: 1152 )
+ * unsigned max_lpc_order (DEFAULT: 0 ) 0 => encoder will not try general LPC, only fixed predictors; must be <= FLAC__MAX_LPC_ORDER
+ * unsigned qlp_coeff_precision (DEFAULT: 0 ) >= FLAC__MIN_QLP_COEFF_PRECISION, or 0 to let encoder select based on blocksize;
* qlp_coeff_precision+bits_per_sample must be < 32
- * bool do_qlp_coeff_prec_search (DEFAULT: false) false => use qlp_coeff_precision, true => search around qlp_coeff_precision, take best
- * bool do_exhaustive_model_search (DEFAULT: false) false => use estimated bits per residual for scoring, true => generate all, take shortest
- * unsigned min_residual_partition_order (DEFAULT: 0 ) 0 => estimate Rice parameter based on residual variance; >0 => partition residual, use parameter
- * unsigned max_residual_partition_order (DEFAULT: 0 ) for each based on mean; min_ and max_ specify the min and max Rice partition order
- * unsigned rice_parameter_search_dist (DEFAULT: 0 ) 0 => try only calc'd parameter k; else try all [k-dist..k+dist] parameters, use best
- * uint64 total_samples_estimate (DEFAULT: 0 ) may be 0 if unknown. acts as a placeholder in the STREAMINFO until the actual total is calculated
+ * FLAC__bool do_qlp_coeff_prec_search (DEFAULT: false) false => use qlp_coeff_precision, true => search around qlp_coeff_precision, take best
+ * FLAC__bool do_exhaustive_model_search (DEFAULT: false) false => use estimated bits per residual for scoring, true => generate all, take shortest
+ * unsigned min_residual_partition_order (DEFAULT: 0 ) 0 => estimate Rice parameter based on residual variance; >0 => partition residual, use parameter
+ * unsigned max_residual_partition_order (DEFAULT: 0 ) for each based on mean; min_ and max_ specify the min and max Rice partition order
+ * unsigned rice_parameter_search_dist (DEFAULT: 0 ) 0 => try only calc'd parameter k; else try all [k-dist..k+dist] parameters, use best
+ * FLAC__uint64 total_samples_estimate (DEFAULT: 0 ) may be 0 if unknown. acts as a placeholder in the STREAMINFO until the actual total is calculated
* const FLAC__StreamMetaData_SeekTable *seek_table (DEFAULT: NULL) optional seek_table to prepend, NULL => no seek table
- * unsigned padding (DEFAULT: 0 ) size of PADDING block to add (goes after seek table); 0 => do not add a PADDING block
- * bool last_metadata_is_last (DEFAULT: true ) the value the encoder will use for the 'is_last' flag of the last metadata block it writes; set
+ * unsigned padding (DEFAULT: 0 ) size of PADDING block to add (goes after seek table); 0 => do not add a PADDING block
+ * FLAC__bool last_metadata_is_last (DEFAULT: true ) the value the encoder will use for the 'is_last' flag of the last metadata block it writes; set
* this to false if you will be adding more metadata blocks before the audio frames, else true
- * (*write_callback)() (DEFAULT: NULL ) The callbacks are the only values that MUST be set before FLAC__stream_encoder_init()
- * (*metadata_callback)() (DEFAULT: NULL )
- * void* client_data (DEFAULT: NULL ) passed back through the callbacks
+ * (*write_callback)() (DEFAULT: NULL ) The callbacks are the only values that MUST be set before FLAC__stream_encoder_init()
+ * (*metadata_callback)() (DEFAULT: NULL )
+ * void* client_data (DEFAULT: NULL ) passed back through the callbacks
*/
FLAC__StreamEncoder *FLAC__stream_encoder_new();
void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder);
* FLAC__stream_encoder_finish() does NOT reset the values to the
* constructor defaults.
*/
-bool FLAC__stream_encoder_set_streamable_subset(const FLAC__StreamEncoder *encoder, bool value);
-bool FLAC__stream_encoder_set_do_mid_side_stereo(const FLAC__StreamEncoder *encoder, bool value);
-bool FLAC__stream_encoder_set_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder, bool value);
-bool FLAC__stream_encoder_set_channels(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_bits_per_sample(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_sample_rate(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_blocksize(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_max_lpc_order(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_qlp_coeff_precision(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder, bool value);
-bool FLAC__stream_encoder_set_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder, bool value);
-bool FLAC__stream_encoder_set_min_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_max_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_total_samples_estimate(const FLAC__StreamEncoder *encoder, uint64 value);
-bool FLAC__stream_encoder_set_seek_table(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData_SeekTable *value);
-bool FLAC__stream_encoder_set_padding(const FLAC__StreamEncoder *encoder, unsigned value);
-bool FLAC__stream_encoder_set_last_metadata_is_last(const FLAC__StreamEncoder *encoder, bool value);
-bool FLAC__stream_encoder_set_write_callback(const FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteStatus (*value)(const FLAC__StreamEncoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data));
-bool FLAC__stream_encoder_set_metadata_callback(const FLAC__StreamEncoder *encoder, void (*value)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data));
-bool FLAC__stream_encoder_set_client_data(const FLAC__StreamEncoder *encoder, void *value);
+FLAC__bool FLAC__stream_encoder_set_streamable_subset(const FLAC__StreamEncoder *encoder, FLAC__bool value);
+FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(const FLAC__StreamEncoder *encoder, FLAC__bool value);
+FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder, FLAC__bool value);
+FLAC__bool FLAC__stream_encoder_set_channels(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_bits_per_sample(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_sample_rate(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_blocksize(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_max_lpc_order(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder, FLAC__bool value);
+FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder, FLAC__bool value);
+FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(const FLAC__StreamEncoder *encoder, FLAC__uint64 value);
+FLAC__bool FLAC__stream_encoder_set_seek_table(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData_SeekTable *value);
+FLAC__bool FLAC__stream_encoder_set_padding(const FLAC__StreamEncoder *encoder, unsigned value);
+FLAC__bool FLAC__stream_encoder_set_last_metadata_is_last(const FLAC__StreamEncoder *encoder, FLAC__bool value);
+FLAC__bool FLAC__stream_encoder_set_write_callback(const FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteStatus (*value)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data));
+FLAC__bool FLAC__stream_encoder_set_metadata_callback(const FLAC__StreamEncoder *encoder, void (*value)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data));
+FLAC__bool FLAC__stream_encoder_set_client_data(const FLAC__StreamEncoder *encoder, void *value);
/*
* Various "get" methods
*/
FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder);
-bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder);
-bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder);
-bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder);
-bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder);
-bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder);
-unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder);
+FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder);
+FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder);
+FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder);
+FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder);
+FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder);
+unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder);
/*
* Initialize the instance; should be called after construction and
/*
* Methods for encoding the data
*/
-bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const int32 *buf[], unsigned samples);
-bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const int32 buf[], unsigned samples);
+FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 *buf[], unsigned samples);
+FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buf[], unsigned samples);
#endif
#include "analyze.h"
typedef struct {
- int32 residual;
+ FLAC__int32 residual;
unsigned count;
} pair_t;
static subframe_stats_t all_;
static void init_stats(subframe_stats_t *stats);
-static void update_stats(subframe_stats_t *stats, int32 residual, unsigned incr);
+static void update_stats(subframe_stats_t *stats, FLAC__int32 residual, unsigned incr);
static void compute_stats(subframe_stats_t *stats);
-static bool dump_stats(const subframe_stats_t *stats, const char *filename);
+static FLAC__bool dump_stats(const subframe_stats_t *stats, const char *filename);
void flac__analyze_init(analysis_options aopts)
{
stats->sos = 0.0;
}
-void update_stats(subframe_stats_t *stats, int32 residual, unsigned incr)
+void update_stats(subframe_stats_t *stats, FLAC__int32 residual, unsigned incr)
{
unsigned i;
const double r = (double)residual, a = r*incr;
stats->stddev = sqrt(stats->variance);
}
-bool dump_stats(const subframe_stats_t *stats, const char *filename)
+FLAC__bool dump_stats(const subframe_stats_t *stats, const char *filename)
{
FILE *outfile;
unsigned i;
#define flac__analyze_h
typedef struct {
- bool do_residual_text;
- bool do_residual_gnuplot;
+ FLAC__bool do_residual_text;
+ FLAC__bool do_residual_gnuplot;
} analysis_options;
void flac__analyze_init(analysis_options aopts);
typedef struct {
const char *inbasefilename;
FILE *fout;
- bool abort_flag;
- bool analysis_mode;
+ FLAC__bool abort_flag;
+ FLAC__bool analysis_mode;
analysis_options aopts;
- bool test_only;
- bool is_wave_out;
- bool is_big_endian;
- bool is_unsigned_samples;
- uint64 total_samples;
+ FLAC__bool test_only;
+ FLAC__bool is_wave_out;
+ FLAC__bool is_big_endian;
+ FLAC__bool is_unsigned_samples;
+ FLAC__uint64 total_samples;
unsigned bps;
unsigned channels;
unsigned sample_rate;
- bool verbose;
- uint64 skip;
- bool skip_count_too_high;
- uint64 samples_processed;
+ FLAC__bool verbose;
+ FLAC__uint64 skip;
+ FLAC__bool skip_count_too_high;
+ FLAC__uint64 samples_processed;
unsigned frame_counter;
} stream_info_struct;
static FLAC__FileDecoder *decoder;
-static bool is_big_endian_host;
+static FLAC__bool is_big_endian_host;
/* local routines */
-static bool init(const char *infilename, stream_info_struct *stream_info);
-static bool write_little_endian_uint16(FILE *f, uint16 val);
-static bool write_little_endian_uint32(FILE *f, uint32 val);
-static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+static FLAC__bool init(const char *infilename, stream_info_struct *stream_info);
+static FLAC__bool write_little_endian_uint16(FILE *f, FLAC__uint16 val);
+static FLAC__bool write_little_endian_uint32(FILE *f, FLAC__uint32 val);
+static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
static void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
static void error_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
static void print_stats(const stream_info_struct *stream_info);
-int flac__decode_wav(const char *infile, const char *outfile, bool analysis_mode, analysis_options aopts, bool verbose, uint64 skip)
+int flac__decode_wav(const char *infile, const char *outfile, FLAC__bool analysis_mode, analysis_options aopts, FLAC__bool verbose, FLAC__uint64 skip)
{
- bool md5_failure = false;
+ FLAC__bool md5_failure = false;
stream_info_struct stream_info;
decoder = 0;
return 1;
}
-int flac__decode_raw(const char *infile, const char *outfile, bool analysis_mode, analysis_options aopts, bool verbose, uint64 skip, bool is_big_endian, bool is_unsigned_samples)
+int flac__decode_raw(const char *infile, const char *outfile, FLAC__bool analysis_mode, analysis_options aopts, FLAC__bool verbose, FLAC__uint64 skip, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples)
{
- bool md5_failure = false;
+ FLAC__bool md5_failure = false;
stream_info_struct stream_info;
decoder = 0;
return 1;
}
-bool init(const char *infilename, stream_info_struct *stream_info)
+FLAC__bool init(const char *infilename, stream_info_struct *stream_info)
{
- uint32 test = 1;
+ FLAC__uint32 test = 1;
- is_big_endian_host = (*((byte*)(&test)))? false : true;
+ is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
decoder = FLAC__file_decoder_new();
if(0 == decoder) {
return true;
}
-bool write_little_endian_uint16(FILE *f, uint16 val)
+FLAC__bool write_little_endian_uint16(FILE *f, FLAC__uint16 val)
{
- byte *b = (byte*)(&val);
+ FLAC__byte *b = (FLAC__byte*)(&val);
if(is_big_endian_host) {
- byte tmp;
+ FLAC__byte tmp;
tmp = b[1]; b[1] = b[0]; b[0] = tmp;
}
return fwrite(b, 1, 2, f) == 2;
}
-bool write_little_endian_uint32(FILE *f, uint32 val)
+FLAC__bool write_little_endian_uint32(FILE *f, FLAC__uint32 val)
{
- byte *b = (byte*)(&val);
+ FLAC__byte *b = (FLAC__byte*)(&val);
if(is_big_endian_host) {
- byte tmp;
+ FLAC__byte tmp;
tmp = b[3]; b[3] = b[0]; b[0] = tmp;
tmp = b[2]; b[2] = b[1]; b[1] = tmp;
}
return fwrite(b, 1, 4, f) == 4;
}
-FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
{
stream_info_struct *stream_info = (stream_info_struct *)client_data;
FILE *fout = stream_info->fout;
unsigned bps = stream_info->bps, channels = stream_info->channels;
- bool is_big_endian = (stream_info->is_wave_out? false : stream_info->is_big_endian);
- bool is_unsigned_samples = (stream_info->is_wave_out? bps<=8 : stream_info->is_unsigned_samples);
+ FLAC__bool is_big_endian = (stream_info->is_wave_out? false : stream_info->is_big_endian);
+ FLAC__bool is_unsigned_samples = (stream_info->is_wave_out? bps<=8 : stream_info->is_unsigned_samples);
unsigned wide_samples = frame->header.blocksize, wide_sample, sample, channel, byte;
- static int8 s8buffer[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * sizeof(int32)]; /* WATCHOUT: can be up to 2 megs */
- /* WATCHOUT: we say 'sizeof(int32)' above instead of '(FLAC__MAX_BITS_PER_SAMPLE+7)/8' because we have to use an array int32 even for 24 bps */
- uint8 *u8buffer = (uint8 *)s8buffer;
- int16 *s16buffer = (int16 *)s8buffer;
- uint16 *u16buffer = (uint16 *)s8buffer;
- int32 *s32buffer = (int32 *)s8buffer;
- uint32 *u32buffer = (uint32 *)s8buffer;
+ static FLAC__int8 s8buffer[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * sizeof(FLAC__int32)]; /* WATCHOUT: can be up to 2 megs */
+ /* WATCHOUT: we say 'sizeof(FLAC__int32)' above instead of '(FLAC__MAX_BITS_PER_SAMPLE+7)/8' because we have to use an array FLAC__int32 even for 24 bps */
+ FLAC__uint8 *u8buffer = (FLAC__uint8 *)s8buffer;
+ FLAC__int16 *s16buffer = (FLAC__int16 *)s8buffer;
+ FLAC__uint16 *u16buffer = (FLAC__uint16 *)s8buffer;
+ FLAC__int32 *s32buffer = (FLAC__int32 *)s8buffer;
+ FLAC__uint32 *u32buffer = (FLAC__uint32 *)s8buffer;
(void)decoder;
/* write the WAVE headers if necessary */
if(!stream_info->analysis_mode && !stream_info->test_only && stream_info->is_wave_out) {
- uint64 data_size = stream_info->total_samples * stream_info->channels * ((stream_info->bps+7)/8);
+ FLAC__uint64 data_size = stream_info->total_samples * stream_info->channels * ((stream_info->bps+7)/8);
if(data_size >= 0xFFFFFFDC) {
fprintf(stderr, "%s: ERROR: stream is too big to fit in a single WAVE file chunk\n", stream_info->inbasefilename);
stream_info->abort_flag = true;
return;
}
if(fwrite("RIFF", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
- if(!write_little_endian_uint32(stream_info->fout, (uint32)(data_size+36))) stream_info->abort_flag = true; /* filesize-8 */
+ if(!write_little_endian_uint32(stream_info->fout, (FLAC__uint32)(data_size+36))) stream_info->abort_flag = true; /* filesize-8 */
if(fwrite("WAVEfmt ", 1, 8, stream_info->fout) != 8) stream_info->abort_flag = true;
if(fwrite("\020\000\000\000", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true; /* chunk size = 16 */
if(fwrite("\001\000", 1, 2, stream_info->fout) != 2) stream_info->abort_flag = true; /* compression code == 1 */
- if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->channels))) stream_info->abort_flag = true;
+ if(!write_little_endian_uint16(stream_info->fout, (FLAC__uint16)(stream_info->channels))) stream_info->abort_flag = true;
if(!write_little_endian_uint32(stream_info->fout, stream_info->sample_rate)) stream_info->abort_flag = true;
if(!write_little_endian_uint32(stream_info->fout, stream_info->sample_rate * stream_info->channels * ((stream_info->bps+7) / 8))) stream_info->abort_flag = true; /* @@@ or is it (sample_rate*channels*bps) / 8 ??? */
- if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->channels * ((stream_info->bps+7) / 8)))) stream_info->abort_flag = true; /* block align */
- if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->bps))) stream_info->abort_flag = true; /* bits per sample */
+ if(!write_little_endian_uint16(stream_info->fout, (FLAC__uint16)(stream_info->channels * ((stream_info->bps+7) / 8)))) stream_info->abort_flag = true; /* block align */
+ if(!write_little_endian_uint16(stream_info->fout, (FLAC__uint16)(stream_info->bps))) stream_info->abort_flag = true; /* bits per sample */
if(fwrite("data", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
- if(!write_little_endian_uint32(stream_info->fout, (uint32)data_size)) stream_info->abort_flag = true; /* data size */
+ if(!write_little_endian_uint32(stream_info->fout, (FLAC__uint32)data_size)) stream_info->abort_flag = true; /* data size */
}
}
}
if(stream_info->verbose) {
#ifdef _MSC_VER
/* with VC++ you have to spoon feed it the casting */
- const double progress = (double)(int64)stream_info->samples_processed / (double)(int64)stream_info->total_samples * 100.0;
+ const double progress = (double)(FLAC__int64)stream_info->samples_processed / (double)(FLAC__int64)stream_info->total_samples * 100.0;
#else
const double progress = (double)stream_info->samples_processed / (double)stream_info->total_samples * 100.0;
#endif
#include "analyze.h"
/* outfile == 0 => test only */
-int flac__decode_wav(const char *infile, const char *outfile, bool analysis_mode, analysis_options aopts, bool verbose, uint64 skip);
-int flac__decode_raw(const char *infile, const char *outfile, bool analysis_mode, analysis_options aopts, bool verbose, uint64 skip, bool is_big_endian, bool is_unsigned_samples);
+int flac__decode_wav(const char *infile, const char *outfile, FLAC__bool analysis_mode, analysis_options aopts, FLAC__bool verbose, FLAC__uint64 skip);
+int flac__decode_raw(const char *infile, const char *outfile, FLAC__bool analysis_mode, analysis_options aopts, FLAC__bool verbose, FLAC__uint64 skip, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples);
#endif
};
typedef struct {
- int32 *original[FLAC__MAX_CHANNELS];
+ FLAC__int32 *original[FLAC__MAX_CHANNELS];
unsigned size; /* of each original[] in samples */
unsigned tail; /* in wide samples */
- const byte *encoded_signal;
+ const FLAC__byte *encoded_signal;
unsigned encoded_signal_capacity;
unsigned encoded_bytes;
- bool into_frames;
+ FLAC__bool into_frames;
verify_code result;
FLAC__StreamDecoder *decoder;
} verify_fifo_struct;
FILE *fout;
const char *outfilename;
FLAC__StreamEncoder *encoder;
- bool verify;
- bool verbose;
- uint64 unencoded_size;
- uint64 total_samples_to_encode;
- uint64 bytes_written;
- uint64 samples_written;
- uint64 stream_offset; /* i.e. number of bytes before the first byte of the the first frame's header */
+ FLAC__bool verify;
+ FLAC__bool verbose;
+ FLAC__uint64 unencoded_size;
+ FLAC__uint64 total_samples_to_encode;
+ FLAC__uint64 bytes_written;
+ FLAC__uint64 samples_written;
+ FLAC__uint64 stream_offset; /* i.e. number of bytes before the first byte of the the first frame's header */
unsigned current_frame;
verify_fifo_struct verify_fifo;
FLAC__StreamMetaData_SeekTable seek_table;
unsigned first_seek_point_to_check;
} encoder_wrapper_struct;
-static bool is_big_endian_host;
+static FLAC__bool is_big_endian_host;
static unsigned char ucbuffer[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__MAX_BITS_PER_SAMPLE+7)/8)];
static signed char *scbuffer = (signed char *)ucbuffer;
-static uint16 *usbuffer = (uint16 *)ucbuffer;
-static int16 *ssbuffer = (int16 *)ucbuffer;
+static FLAC__uint16 *usbuffer = (FLAC__uint16 *)ucbuffer;
+static FLAC__int16 *ssbuffer = (FLAC__int16 *)ucbuffer;
-static int32 in[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
-static int32 *input[FLAC__MAX_CHANNELS];
+static FLAC__int32 in[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
+static FLAC__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 loose_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned channels, unsigned bps, unsigned sample_rate, unsigned padding, char *requested_seek_points, int num_requested_seek_points, encoder_wrapper_struct *encoder_wrapper);
-static bool convert_to_seek_table(char *requested_seek_points, int num_requested_seek_points, uint64 stream_samples, unsigned blocksize, FLAC__StreamMetaData_SeekTable *seek_table);
-static void append_point_to_seek_table(FLAC__StreamMetaData_SeekTable *seek_table, uint64 sample, uint64 stream_samples, uint64 blocksize);
+static FLAC__bool init(encoder_wrapper_struct *encoder_wrapper);
+static FLAC__bool init_encoder(FLAC__bool lax, FLAC__bool do_mid_side, FLAC__bool loose_mid_side, FLAC__bool do_exhaustive_model_search, FLAC__bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned channels, unsigned bps, unsigned sample_rate, unsigned padding, char *requested_seek_points, int num_requested_seek_points, encoder_wrapper_struct *encoder_wrapper);
+static FLAC__bool convert_to_seek_table(char *requested_seek_points, int num_requested_seek_points, FLAC__uint64 stream_samples, unsigned blocksize, FLAC__StreamMetaData_SeekTable *seek_table);
+static void append_point_to_seek_table(FLAC__StreamMetaData_SeekTable *seek_table, FLAC__uint64 sample, FLAC__uint64 stream_samples, FLAC__uint64 blocksize);
static int seekpoint_compare(const FLAC__StreamMetaData_SeekPoint *l, const FLAC__StreamMetaData_SeekPoint *r);
-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__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
+static void format_input(unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, encoder_wrapper_struct *encoder_wrapper);
+static FLAC__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
static void metadata_callback(const FLAC__StreamEncoder *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__Frame *frame, const int32 *buffer[], void *client_data);
+static FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
+static FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__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, const char *fn);
-static bool read_little_endian_uint32(FILE *f, uint32 *val, bool eof_ok, const char *fn);
-static bool write_big_endian_uint16(FILE *f, uint16 val);
-static bool write_big_endian_uint64(FILE *f, uint64 val);
+static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
+static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
+static FLAC__bool write_big_endian_uint16(FILE *f, FLAC__uint16 val);
+static FLAC__bool write_big_endian_uint64(FILE *f, FLAC__uint64 val);
-int flac__encode_wav(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const byte *lookahead, unsigned lookahead_length, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool loose_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points)
+int flac__encode_wav(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, FLAC__bool verbose, FLAC__uint64 skip, FLAC__bool verify, FLAC__bool lax, FLAC__bool do_mid_side, FLAC__bool loose_mid_side, FLAC__bool do_exhaustive_model_search, FLAC__bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points)
{
encoder_wrapper_struct encoder_wrapper;
- bool is_unsigned_samples = false;
+ FLAC__bool is_unsigned_samples = false;
unsigned channels = 0, bps = 0, sample_rate = 0, data_bytes;
size_t bytes_per_wide_sample, bytes_read;
- uint16 x;
- uint32 xx;
- bool got_fmt_chunk = false, got_data_chunk = false;
+ FLAC__uint16 x;
+ FLAC__uint32 xx;
+ FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
encoder_wrapper.encoder = 0;
encoder_wrapper.verify = verify;
return 1;
}
-int flac__encode_raw(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const byte *lookahead, unsigned lookahead_length, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool loose_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate)
+int flac__encode_raw(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, FLAC__bool verbose, FLAC__uint64 skip, FLAC__bool verify, FLAC__bool lax, FLAC__bool do_mid_side, FLAC__bool loose_mid_side, FLAC__bool do_exhaustive_model_search, FLAC__bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate)
{
encoder_wrapper_struct encoder_wrapper;
size_t bytes_read;
return 1;
}
-bool init(encoder_wrapper_struct *encoder_wrapper)
+FLAC__bool init(encoder_wrapper_struct *encoder_wrapper)
{
unsigned i;
- uint32 test = 1;
+ FLAC__uint32 test = 1;
- is_big_endian_host = (*((byte*)(&test)))? false : true;
+ is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
for(i = 0; i < FLAC__MAX_CHANNELS; i++)
input[i] = &(in[i][0]);
return true;
}
-bool init_encoder(bool lax, bool do_mid_side, bool loose_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned channels, unsigned bps, unsigned sample_rate, unsigned padding, char *requested_seek_points, int num_requested_seek_points, encoder_wrapper_struct *encoder_wrapper)
+FLAC__bool init_encoder(FLAC__bool lax, FLAC__bool do_mid_side, FLAC__bool loose_mid_side, FLAC__bool do_exhaustive_model_search, FLAC__bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned channels, unsigned bps, unsigned sample_rate, unsigned padding, char *requested_seek_points, int num_requested_seek_points, encoder_wrapper_struct *encoder_wrapper)
{
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))) {
+ if(0 == (encoder_wrapper->verify_fifo.original[i] = (FLAC__int32*)malloc(sizeof(FLAC__int32) * encoder_wrapper->verify_fifo.size))) {
fprintf(stderr, "%s: ERROR allocating verify buffers\n", encoder_wrapper->inbasefilename);
return false;
}
return true;
}
-bool convert_to_seek_table(char *requested_seek_points, int num_requested_seek_points, uint64 stream_samples, unsigned blocksize, FLAC__StreamMetaData_SeekTable *seek_table)
+FLAC__bool convert_to_seek_table(char *requested_seek_points, int num_requested_seek_points, FLAC__uint64 stream_samples, unsigned blocksize, FLAC__StreamMetaData_SeekTable *seek_table)
{
unsigned i, j, real_points, placeholders;
char *pt = requested_seek_points, *q;
- bool first;
+ FLAC__bool first;
seek_table->num_points = 0;
unsigned j, n;
n = (unsigned)atoi(pt);
for(j = 0; j < n; j++)
- append_point_to_seek_table(seek_table, stream_samples * (uint64)j / (uint64)n, stream_samples, blocksize);
+ append_point_to_seek_table(seek_table, stream_samples * (FLAC__uint64)j / (FLAC__uint64)n, stream_samples, blocksize);
}
}
else { /* -S # */
- append_point_to_seek_table(seek_table, (uint64)atoi(pt), stream_samples, blocksize);
+ append_point_to_seek_table(seek_table, (FLAC__uint64)atoi(pt), stream_samples, blocksize);
}
pt = q;
return true;
}
-void append_point_to_seek_table(FLAC__StreamMetaData_SeekTable *seek_table, uint64 sample, uint64 stream_samples, uint64 blocksize)
+void append_point_to_seek_table(FLAC__StreamMetaData_SeekTable *seek_table, FLAC__uint64 sample, FLAC__uint64 stream_samples, FLAC__uint64 blocksize)
{
- const uint64 target_sample = (sample / blocksize) * blocksize;
+ const FLAC__uint64 target_sample = (sample / blocksize) * blocksize;
if(stream_samples == 0 || target_sample < stream_samples)
seek_table->points[seek_table->num_points++].sample_number = target_sample;
int seekpoint_compare(const FLAC__StreamMetaData_SeekPoint *l, const FLAC__StreamMetaData_SeekPoint *r)
{
- /* we don't just 'return l->sample_number - r->sample_number' since the result (int64) might overflow an 'int' */
+ /* we don't just 'return l->sample_number - r->sample_number' since the result (FLAC__int64) might overflow an 'int' */
if(l->sample_number == r->sample_number)
return 0;
else if(l->sample_number < r->sample_number)
return 1;
}
-void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, encoder_wrapper_struct *encoder_wrapper)
+void format_input(unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, encoder_wrapper_struct *encoder_wrapper)
{
unsigned wide_sample, sample, channel, byte;
if(is_unsigned_samples) {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- input[channel][wide_sample] = (int32)ucbuffer[sample] - 0x80;
+ input[channel][wide_sample] = (FLAC__int32)ucbuffer[sample] - 0x80;
}
else {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- input[channel][wide_sample] = (int32)scbuffer[sample];
+ input[channel][wide_sample] = (FLAC__int32)scbuffer[sample];
}
}
else if(bps == 16) {
if(is_unsigned_samples) {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- input[channel][wide_sample] = (int32)usbuffer[sample] - 0x8000;
+ input[channel][wide_sample] = (FLAC__int32)usbuffer[sample] - 0x8000;
}
else {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- input[channel][wide_sample] = (int32)ssbuffer[sample];
+ input[channel][wide_sample] = (FLAC__int32)ssbuffer[sample];
}
}
else if(bps == 24) {
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);
+ memcpy(&encoder_wrapper->verify_fifo.original[channel][encoder_wrapper->verify_fifo.tail], &input[channel][0], sizeof(FLAC__int32) * wide_samples);
encoder_wrapper->verify_fifo.tail += wide_samples;
FLAC__ASSERT(encoder_wrapper->verify_fifo.tail <= encoder_wrapper->verify_fifo.size);
}
}
-FLAC__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
+FLAC__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
{
encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
const unsigned mask = (FLAC__stream_encoder_get_do_exhaustive_model_search(encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder))? 0x1f : 0x7f;
/* mark the current seek point if hit (if stream_offset == 0 that means we're still writing metadata and haven't hit the first frame yet) */
if(encoder_wrapper->stream_offset > 0 && encoder_wrapper->seek_table.num_points > 0) {
- uint64 current_sample = (uint64)current_frame * (uint64)FLAC__stream_encoder_get_blocksize(encoder), test_sample;
+ FLAC__uint64 current_sample = (FLAC__uint64)current_frame * (FLAC__uint64)FLAC__stream_encoder_get_blocksize(encoder), test_sample;
unsigned i;
for(i = encoder_wrapper->first_seek_point_to_check; i < encoder_wrapper->seek_table.num_points; i++) {
test_sample = encoder_wrapper->seek_table.points[i].sample_number;
}
}
- if(fwrite(buffer, sizeof(byte), bytes, encoder_wrapper->fout) == bytes)
+ if(fwrite(buffer, sizeof(FLAC__byte), bytes, encoder_wrapper->fout) == bytes)
return FLAC__STREAM_ENCODER_WRITE_OK;
else
return FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR;
void metadata_callback(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data)
{
encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
- byte b;
+ FLAC__byte b;
FILE *f;
- const uint64 samples = metadata->data.stream_info.total_samples;
+ const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
const unsigned min_framesize = metadata->data.stream_info.min_framesize;
const unsigned max_framesize = metadata->data.stream_info.max_framesize;
if(-1 == fseek(f, 21, SEEK_SET)) goto framesize_;
if(fread(&b, 1, 1, f) != 1) goto framesize_;
if(-1 == fseek(f, 21, SEEK_SET)) goto framesize_;
- b = (b & 0xf0) | (byte)((samples >> 32) & 0x0F);
+ b = (b & 0xf0) | (FLAC__byte)((samples >> 32) & 0x0F);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
- b = (byte)((samples >> 24) & 0xFF);
+ b = (FLAC__byte)((samples >> 24) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
- b = (byte)((samples >> 16) & 0xFF);
+ b = (FLAC__byte)((samples >> 16) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
- b = (byte)((samples >> 8) & 0xFF);
+ b = (FLAC__byte)((samples >> 8) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
- b = (byte)(samples & 0xFF);
+ b = (FLAC__byte)(samples & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
framesize_:
if(-1 == fseek(f, 12, SEEK_SET)) goto seektable_;
- b = (byte)((min_framesize >> 16) & 0xFF);
+ b = (FLAC__byte)((min_framesize >> 16) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
- b = (byte)((min_framesize >> 8) & 0xFF);
+ b = (FLAC__byte)((min_framesize >> 8) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
- b = (byte)(min_framesize & 0xFF);
+ b = (FLAC__byte)(min_framesize & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
- b = (byte)((max_framesize >> 16) & 0xFF);
+ b = (FLAC__byte)((max_framesize >> 16) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
- b = (byte)((max_framesize >> 8) & 0xFF);
+ b = (FLAC__byte)((max_framesize >> 8) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
- b = (byte)(max_framesize & 0xFF);
+ b = (FLAC__byte)(max_framesize & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
seektable_:
return;
}
-FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data)
+FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
const unsigned encoded_bytes = encoder_wrapper->verify_fifo.encoded_bytes;
return FLAC__STREAM_DECODER_READ_CONTINUE;
}
-FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
{
encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
unsigned channel, l, r;
const unsigned channels = FLAC__stream_decoder_get_channels(decoder);
- const unsigned bytes_per_block = sizeof(int32) * FLAC__stream_decoder_get_blocksize(decoder);
+ const unsigned bytes_per_block = sizeof(FLAC__int32) * FLAC__stream_decoder_get_blocksize(decoder);
for(channel = 0; channel < channels; channel++) {
if(0 != memcmp(buffer[channel], encoder_wrapper->verify_fifo.original[channel], bytes_per_block)) {
{
#ifdef _MSC_VER
/* with VC++ you have to spoon feed it the casting */
- const double progress = (double)(int64)encoder_wrapper->samples_written / (double)(int64)encoder_wrapper->total_samples_to_encode;
- const double ratio = (double)(int64)encoder_wrapper->bytes_written / ((double)(int64)encoder_wrapper->unencoded_size * progress);
+ const double progress = (double)(FLAC__int64)encoder_wrapper->samples_written / (double)(FLAC__int64)encoder_wrapper->total_samples_to_encode;
+ const double ratio = (double)(FLAC__int64)encoder_wrapper->bytes_written / ((double)(FLAC__int64)encoder_wrapper->unencoded_size * progress);
#else
const double progress = (double)encoder_wrapper->samples_written / (double)encoder_wrapper->total_samples_to_encode;
const double ratio = (double)encoder_wrapper->bytes_written / ((double)encoder_wrapper->unencoded_size * progress);
}
}
-bool read_little_endian_uint16(FILE *f, uint16 *val, bool eof_ok, const char *fn)
+FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
{
size_t bytes_read = fread(val, 1, 2, f);
}
else {
if(is_big_endian_host) {
- byte tmp, *b = (byte*)val;
+ FLAC__byte tmp, *b = (FLAC__byte*)val;
tmp = b[1]; b[1] = b[0]; b[0] = tmp;
}
return true;
}
}
-bool read_little_endian_uint32(FILE *f, uint32 *val, bool eof_ok, const char *fn)
+FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
{
size_t bytes_read = fread(val, 1, 4, f);
}
else {
if(is_big_endian_host) {
- byte tmp, *b = (byte*)val;
+ FLAC__byte tmp, *b = (FLAC__byte*)val;
tmp = b[3]; b[3] = b[0]; b[0] = tmp;
tmp = b[2]; b[2] = b[1]; b[1] = tmp;
}
}
}
-bool write_big_endian_uint16(FILE *f, uint16 val)
+FLAC__bool write_big_endian_uint16(FILE *f, FLAC__uint16 val)
{
if(!is_big_endian_host) {
- byte *b = (byte *)&val, tmp;
+ FLAC__byte *b = (FLAC__byte *)&val, tmp;
tmp = b[0]; b[0] = b[1]; b[1] = tmp;
}
return fwrite(&val, 1, 2, f) == 2;
}
-bool write_big_endian_uint64(FILE *f, uint64 val)
+FLAC__bool write_big_endian_uint64(FILE *f, FLAC__uint64 val)
{
if(!is_big_endian_host) {
- byte *b = (byte *)&val, tmp;
+ FLAC__byte *b = (FLAC__byte *)&val, tmp;
tmp = b[0]; b[0] = b[7]; b[7] = tmp;
tmp = b[1]; b[1] = b[6]; b[6] = tmp;
tmp = b[2]; b[2] = b[5]; b[5] = tmp;
#include "FLAC/ordinals.h"
-int flac__encode_wav(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const byte *lookahead, unsigned lookahead_length, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool loose_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points);
-int flac__encode_raw(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const byte *lookahead, unsigned lookahead_length, bool verbose, uint64 skip, bool verify, bool lax, bool do_mid_side, bool loose_mid_side, bool do_exhaustive_model_search, bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points, bool is_big_endian, bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate);
+int flac__encode_wav(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, FLAC__bool verbose, FLAC__uint64 skip, FLAC__bool verify, FLAC__bool lax, FLAC__bool do_mid_side, FLAC__bool loose_mid_side, FLAC__bool do_exhaustive_model_search, FLAC__bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points);
+int flac__encode_raw(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, FLAC__bool verbose, FLAC__uint64 skip, FLAC__bool verify, FLAC__bool lax, FLAC__bool do_mid_side, FLAC__bool loose_mid_side, FLAC__bool do_exhaustive_model_search, FLAC__bool do_qlp_coeff_prec_search, unsigned min_residual_partition_order, unsigned max_residual_partition_order, unsigned rice_parameter_search_dist, unsigned max_lpc_order, unsigned blocksize, unsigned qlp_coeff_precision, unsigned padding, char *requested_seek_points, int num_requested_seek_points, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned sample_rate);
#endif
static int encode_file(const char *infilename, const char *forced_outfilename);
static int decode_file(const char *infilename, const char *forced_outfilename);
-bool verify = false, verbose = true, lax = false, test_only = false, analyze = false;
-bool do_mid_side = true, loose_mid_side = false, do_exhaustive_model_search = false, do_qlp_coeff_prec_search = false;
-bool force_to_stdout = false, delete_input = false;
+FLAC__bool verify = false, verbose = true, lax = false, test_only = false, analyze = false;
+FLAC__bool do_mid_side = true, loose_mid_side = false, do_exhaustive_model_search = false, do_qlp_coeff_prec_search = false;
+FLAC__bool force_to_stdout = false, delete_input = false;
const char *cmdline_forced_outfilename = 0;
analysis_options aopts = { false, false };
unsigned padding = 0;
unsigned max_lpc_order = 8;
unsigned qlp_coeff_precision = 0;
-uint64 skip = 0;
+FLAC__uint64 skip = 0;
int format_is_wave = -1, format_is_big_endian = -1, format_is_unsigned_samples = false;
int format_channels = -1, format_bps = -1, format_sample_rate = -1;
int blocksize = -1, min_residual_partition_order = -1, max_residual_partition_order = -1, rice_parameter_search_dist = -1;
int main(int argc, char *argv[])
{
int i, retval = 0;
- bool mode_decode = false;
+ FLAC__bool mode_decode = false;
if(argc <= 1)
return usage(0);
else if(0 == strcmp(argv[i], "--delete-input-file-"))
delete_input = false;
else if(0 == strcmp(argv[i], "--skip"))
- skip = (uint64)atoi(argv[++i]); /* @@@ takes a pretty damn big file to overflow atoi() here, but it could happen */
+ skip = (FLAC__uint64)atoi(argv[++i]); /* @@@ takes a pretty damn big file to overflow atoi() here, but it could happen */
else if(0 == strcmp(argv[i], "--lax"))
lax = true;
else if(0 == strcmp(argv[i], "--lax-"))
}
if(mode_decode) {
- bool first = true;
+ FLAC__bool first = true;
int save_format;
if(i == argc) {
}
}
else { /* encode */
- bool first = true;
+ FLAC__bool first = true;
int save_format;
if(i == argc) {
FILE *encode_infile;
char outfilename[4096]; /* @@@ bad MAGIC NUMBER */
char *p;
- byte lookahead[12];
+ FLAC__byte lookahead[12];
unsigned lookahead_length = 0;
int retval;
long infilesize;
/* This should be at least twice as large as the largest number of bytes required to represent any 'number' (in any encoding) you are going to read. */
static const unsigned FLAC__BITBUFFER_DEFAULT_CAPACITY = 65536; /* bytes */
-#define BYTE_BIT_TO_MASK(b) (((byte)'\x80') >> (b))
+#define BYTE_BIT_TO_MASK(b) (((FLAC__byte)'\x80') >> (b))
#ifdef min
#undef min
#endif
#define max(x,y) ((x)>(y)?(x):(y))
-static bool bitbuffer_resize_(FLAC__BitBuffer *bb, unsigned new_capacity)
+static FLAC__bool bitbuffer_resize_(FLAC__BitBuffer *bb, unsigned new_capacity)
{
- byte *new_buffer;
+ FLAC__byte *new_buffer;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
if(bb->capacity == new_capacity)
return true;
- new_buffer = (byte*)malloc(sizeof(byte) * new_capacity);
+ new_buffer = (FLAC__byte*)malloc(sizeof(FLAC__byte) * new_capacity);
if(new_buffer == 0)
return false;
memset(new_buffer, 0, new_capacity);
- memcpy(new_buffer, bb->buffer, sizeof(byte)*min(bb->bytes+(bb->bits?1:0), new_capacity));
+ memcpy(new_buffer, bb->buffer, sizeof(FLAC__byte)*min(bb->bytes+(bb->bits?1:0), new_capacity));
if(new_capacity < bb->bytes+(bb->bits?1:0)) {
bb->bytes = new_capacity;
bb->bits = 0;
return true;
}
-static bool bitbuffer_grow_(FLAC__BitBuffer *bb, unsigned min_bytes_to_add)
+static FLAC__bool bitbuffer_grow_(FLAC__BitBuffer *bb, unsigned min_bytes_to_add)
{
unsigned new_capacity;
return bitbuffer_resize_(bb, new_capacity);
}
-static bool bitbuffer_ensure_size_(FLAC__BitBuffer *bb, unsigned bits_to_add)
+static FLAC__bool bitbuffer_ensure_size_(FLAC__BitBuffer *bb, unsigned bits_to_add)
{
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-static bool bitbuffer_read_from_client_(FLAC__BitBuffer *bb, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+static FLAC__bool bitbuffer_read_from_client_(FLAC__BitBuffer *bb, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
unsigned bytes;
bb->consumed_bytes = bb->consumed_bits = bb->total_consumed_bits = 0;
}
-bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const byte buffer[], unsigned bytes)
+FLAC__bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const FLAC__byte buffer[], unsigned bytes)
{
FLAC__ASSERT(bb != 0);
FLAC__bitbuffer_init(bb);
return true;
else {
FLAC__ASSERT(buffer != 0);
- bb->buffer = (byte*)malloc(sizeof(byte)*bytes);
+ bb->buffer = (FLAC__byte*)malloc(sizeof(FLAC__byte)*bytes);
if(bb->buffer == 0)
return false;
- memcpy(bb->buffer, buffer, sizeof(byte)*bytes);
+ memcpy(bb->buffer, buffer, sizeof(FLAC__byte)*bytes);
bb->capacity = bb->bytes = bytes;
bb->bits = 0;
bb->total_bits = (bytes<<3);
}
}
-void FLAC__bitbuffer_init_read_crc16(FLAC__BitBuffer *bb, uint16 seed)
+void FLAC__bitbuffer_init_read_crc16(FLAC__BitBuffer *bb, FLAC__uint16 seed)
{
FLAC__ASSERT(bb != 0);
bb->read_crc16 = seed;
}
-bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
+FLAC__bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
{
- static const byte mask_[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
+ static const FLAC__byte mask_[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
unsigned bits_to_add = src->total_bits - src->total_consumed_bits;
FLAC__ASSERT(dest != 0);
bb->consumed_bytes = bb->consumed_bits = bb->total_consumed_bits = 0;
}
-bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb)
+FLAC__bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb)
{
if(bb->buffer == 0) {
bb->capacity = FLAC__BITBUFFER_DEFAULT_CAPACITY;
- bb->buffer = (byte*)malloc(sizeof(byte) * bb->capacity);
+ bb->buffer = (FLAC__byte*)malloc(sizeof(FLAC__byte) * bb->capacity);
if(bb->buffer == 0)
return false;
memset(bb->buffer, 0, bb->capacity);
return true;
}
-bool FLAC__bitbuffer_clone(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
+FLAC__bool FLAC__bitbuffer_clone(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
{
if(dest->capacity < src->capacity)
if(!bitbuffer_resize_(dest, src->capacity))
return false;
- memcpy(dest->buffer, src->buffer, sizeof(byte)*min(src->capacity, src->bytes+1));
+ memcpy(dest->buffer, src->buffer, sizeof(FLAC__byte)*min(src->capacity, src->bytes+1));
dest->bytes = src->bytes;
dest->bits = src->bits;
dest->total_bits = src->total_bits;
return true;
}
-bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits)
+FLAC__bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits)
{
unsigned n, k;
return true;
}
-bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, uint32 val, unsigned bits)
+FLAC__bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, FLAC__uint32 val, unsigned bits)
{
unsigned n, k;
return true;
}
-bool FLAC__bitbuffer_write_raw_int32(FLAC__BitBuffer *bb, int32 val, unsigned bits)
+FLAC__bool FLAC__bitbuffer_write_raw_int32(FLAC__BitBuffer *bb, FLAC__int32 val, unsigned bits)
{
- return FLAC__bitbuffer_write_raw_uint32(bb, (uint32)val, bits);
+ return FLAC__bitbuffer_write_raw_uint32(bb, (FLAC__uint32)val, bits);
}
-bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, uint64 val, unsigned bits)
+FLAC__bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, FLAC__uint64 val, unsigned bits)
{
- static const uint64 mask[] = {
+ static const FLAC__uint64 mask[] = {
0,
0x0000000000000001, 0x0000000000000003, 0x0000000000000007, 0x000000000000000F,
0x000000000000001F, 0x000000000000003F, 0x000000000000007F, 0x00000000000000FF,
return true;
}
-bool FLAC__bitbuffer_write_raw_int64(FLAC__BitBuffer *bb, int64 val, unsigned bits)
+FLAC__bool FLAC__bitbuffer_write_raw_int64(FLAC__BitBuffer *bb, FLAC__int64 val, unsigned bits)
{
- return FLAC__bitbuffer_write_raw_uint64(bb, (uint64)val, bits);
+ return FLAC__bitbuffer_write_raw_uint64(bb, (FLAC__uint64)val, bits);
}
-bool FLAC__bitbuffer_write_unary_unsigned(FLAC__BitBuffer *bb, unsigned val)
+FLAC__bool FLAC__bitbuffer_write_unary_unsigned(FLAC__BitBuffer *bb, unsigned val)
{
if(val < 32)
return FLAC__bitbuffer_write_raw_uint32(bb, 1, ++val);
return bits;
}
-bool FLAC__bitbuffer_write_symmetric_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
+FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
{
unsigned total_bits, interesting_bits, msbs;
- uint32 pattern;
+ FLAC__uint32 pattern;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-bool FLAC__bitbuffer_write_symmetric_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, bool *overflow)
+FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow)
{
unsigned total_bits, interesting_bits, msbs;
- uint32 pattern;
+ FLAC__uint32 pattern;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-bool FLAC__bitbuffer_write_symmetric_rice_signed_escape(FLAC__BitBuffer *bb, int val, unsigned parameter)
+FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed_escape(FLAC__BitBuffer *bb, int val, unsigned parameter)
{
unsigned total_bits, val_bits;
- uint32 pattern;
+ FLAC__uint32 pattern;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
+FLAC__bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
{
unsigned total_bits, interesting_bits, msbs, uval;
- uint32 pattern;
+ FLAC__uint32 pattern;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, bool *overflow)
+FLAC__bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow)
{
unsigned total_bits, interesting_bits, msbs, uval;
- uint32 pattern;
+ FLAC__uint32 pattern;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
+FLAC__bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
{
unsigned total_bits, msbs, uval;
unsigned k;
return true;
}
-bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned uval, unsigned parameter)
+FLAC__bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned uval, unsigned parameter)
{
unsigned total_bits, msbs;
unsigned k;
return true;
}
-bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, uint32 val)
+FLAC__bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, FLAC__uint32 val)
{
- bool ok = 1;
+ FLAC__bool ok = 1;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return ok;
}
-bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, uint64 val)
+FLAC__bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, FLAC__uint64 val)
{
- bool ok = 1;
+ FLAC__bool ok = 1;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
FLAC__ASSERT(!(val & 0xFFFFFFF000000000)); /* this version only handles 36 bits */
if(val < 0x80) {
- return FLAC__bitbuffer_write_raw_uint32(bb, (uint32)val, 8);
+ return FLAC__bitbuffer_write_raw_uint32(bb, (FLAC__uint32)val, 8);
}
else if(val < 0x800) {
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xC0 | (uint32)(val>>6), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xC0 | (FLAC__uint32)(val>>6), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
}
else if(val < 0x10000) {
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xE0 | (uint32)(val>>12), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xE0 | (FLAC__uint32)(val>>12), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
}
else if(val < 0x200000) {
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF0 | (uint32)(val>>18), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF0 | (FLAC__uint32)(val>>18), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
}
else if(val < 0x4000000) {
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF8 | (uint32)(val>>24), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>18)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF8 | (FLAC__uint32)(val>>24), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
}
else if(val < 0x80000000) {
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFC | (uint32)(val>>30), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>24)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>18)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFC | (FLAC__uint32)(val>>30), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
}
else {
ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFE, 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>30)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>24)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>18)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>30)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
+ ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
}
return ok;
}
-bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb)
+FLAC__bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb)
{
/* 0-pad to byte boundary */
if(bb->bits != 0)
return true;
}
-bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
/* to avoid a drastic speed penalty we don't:
FLAC__ASSERT(bb != 0);
}
}
-bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
/* to avoid a drastic speed penalty we don't:
FLAC__ASSERT(bb != 0);
}
}
-bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
/* to avoid a drastic speed penalty we don't:
FLAC__ASSERT(bb != 0);
}
}
-bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
/* to avoid a drastic speed penalty we don't:
FLAC__ASSERT(bb != 0);
}
}
-bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, uint32 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
#ifdef FLAC__NO_MANUAL_INLINING
{
unsigned i;
#else
{
unsigned i, bits_ = bits;
- uint32 v = 0;
+ FLAC__uint32 v = 0;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
}
#endif
-bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, int32 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, FLAC__int32 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
#ifdef FLAC__NO_MANUAL_INLINING
{
unsigned i;
- uint32 v;
+ FLAC__uint32 v;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
i = 32 - bits;
if(i) {
v <<= i;
- *val = (int32)v;
+ *val = (FLAC__int32)v;
*val >>= i;
}
else
- *val = (int32)v;
+ *val = (FLAC__int32)v;
return true;
}
#else
{
unsigned i, bits_ = bits;
- uint32 v = 0;
+ FLAC__uint32 v = 0;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
/* bits_ must be < 7 if we get to here */
v = (bb->buffer[bb->consumed_bytes] & (0xff >> bb->consumed_bits));
v <<= (32-i);
- *val = (int32)v;
+ *val = (FLAC__int32)v;
*val >>= (32-bits_);
bb->consumed_bits += bits_;
bb->total_consumed_bits += bits_;
i = 32 - bits;
if(i) {
v <<= i;
- *val = (int32)v;
+ *val = (FLAC__int32)v;
*val >>= i;
}
else
- *val = (int32)v;
+ *val = (FLAC__int32)v;
return true;
}
#endif
-bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, uint64 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
#ifdef FLAC__NO_MANUAL_INLINING
{
unsigned i;
#else
{
unsigned i, bits_ = bits;
- uint64 v = 0;
+ FLAC__uint64 v = 0;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
}
#endif
-bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, int64 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, FLAC__int64 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
#ifdef FLAC__NO_MANUAL_INLINING
{
unsigned i;
- uint64 v;
+ FLAC__uint64 v;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
i = 64 - bits;
if(i) {
v <<= i;
- *val = (int64)v;
+ *val = (FLAC__int64)v;
*val >>= i;
}
else
- *val = (int64)v;
+ *val = (FLAC__int64)v;
return true;
}
#else
{
unsigned i, bits_ = bits;
- uint64 v = 0;
+ FLAC__uint64 v = 0;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
/* bits_ must be < 7 if we get to here */
v = (bb->buffer[bb->consumed_bytes] & (0xff >> bb->consumed_bits));
v <<= (64-i);
- *val = (int64)v;
+ *val = (FLAC__int64)v;
*val >>= (64-bits_);
bb->consumed_bits += bits_;
bb->total_consumed_bits += bits_;
i = 64 - bits;
if(i) {
v <<= i;
- *val = (int64)v;
+ *val = (FLAC__int64)v;
*val >>= i;
}
else
- *val = (int64)v;
+ *val = (FLAC__int64)v;
return true;
}
#endif
-bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
#ifdef FLAC__NO_MANUAL_INLINING
{
unsigned bit, val_ = 0;
{
unsigned i, val_ = 0;
unsigned total_bytes_ = (bb->total_bits + 7) / 8;
- byte b;
+ FLAC__byte b;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
}
#endif
-bool FLAC__bitbuffer_read_symmetric_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_symmetric_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
- uint32 sign = 0, lsbs = 0, msbs = 0;
+ FLAC__uint32 sign = 0, lsbs = 0, msbs = 0;
FLAC__ASSERT(bb != 0);
FLAC__ASSERT(bb->buffer != 0);
return true;
}
-bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
- uint32 lsbs = 0, msbs = 0;
+ FLAC__uint32 lsbs = 0, msbs = 0;
unsigned uval;
FLAC__ASSERT(bb != 0);
return true;
}
-bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
- uint32 lsbs = 0, msbs = 0;
+ FLAC__uint32 lsbs = 0, msbs = 0;
unsigned bit, uval, k;
FLAC__ASSERT(bb != 0);
return true;
}
-bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+FLAC__bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
{
- uint32 lsbs, msbs = 0;
+ FLAC__uint32 lsbs, msbs = 0;
unsigned bit, k;
FLAC__ASSERT(bb != 0);
}
/* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
-bool FLAC__bitbuffer_read_utf8_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data, byte *raw, unsigned *rawlen)
+FLAC__bool FLAC__bitbuffer_read_utf8_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data, FLAC__byte *raw, unsigned *rawlen)
{
- uint32 v = 0;
- uint32 x;
+ FLAC__uint32 v = 0;
+ FLAC__uint32 x;
unsigned i;
if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
return false;
if(raw)
- raw[(*rawlen)++] = (byte)x;
+ raw[(*rawlen)++] = (FLAC__byte)x;
if(!(x & 0x80)) { /* 0xxxxxxx */
v = x;
i = 0;
if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
return false;
if(raw)
- raw[(*rawlen)++] = (byte)x;
+ raw[(*rawlen)++] = (FLAC__byte)x;
if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
*val = 0xffffffff;
return true;
}
/* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
-bool FLAC__bitbuffer_read_utf8_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data, byte *raw, unsigned *rawlen)
+FLAC__bool FLAC__bitbuffer_read_utf8_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data, FLAC__byte *raw, unsigned *rawlen)
{
- uint64 v = 0;
- uint32 x;
+ FLAC__uint64 v = 0;
+ FLAC__uint32 x;
unsigned i;
if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
return false;
if(raw)
- raw[(*rawlen)++] = (byte)x;
+ raw[(*rawlen)++] = (FLAC__byte)x;
if(!(x & 0x80)) { /* 0xxxxxxx */
v = x;
i = 0;
if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
return false;
if(raw)
- raw[(*rawlen)++] = (byte)x;
+ raw[(*rawlen)++] = (FLAC__byte)x;
if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
*val = 0xffffffffffffffff;
return true;
/* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
-byte const FLAC__crc8_table[256] = {
+FLAC__byte const FLAC__crc8_table[256] = {
0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
/* CRC-16, poly = x^16 + x^15 + x^2 + x^0, init = 0 */
-uint16 FLAC__crc16_table[256] = {
+FLAC__uint16 FLAC__crc16_table[256] = {
0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
};
-void FLAC__crc8_update(const byte data, uint8 *crc)
+void FLAC__crc8_update(const FLAC__byte data, FLAC__uint8 *crc)
{
*crc = FLAC__crc8_table[*crc ^ data];
}
-void FLAC__crc8_update_block(const byte *data, unsigned len, uint8 *crc)
+void FLAC__crc8_update_block(const FLAC__byte *data, unsigned len, FLAC__uint8 *crc)
{
while(len--)
*crc = FLAC__crc8_table[*crc ^ *data++];
}
-uint8 FLAC__crc8(const byte *data, unsigned len)
+FLAC__uint8 FLAC__crc8(const FLAC__byte *data, unsigned len)
{
- uint8 crc = 0;
+ FLAC__uint8 crc = 0;
while(len--)
crc = FLAC__crc8_table[crc ^ *data++];
return crc;
}
-void FLAC__crc16_update(const byte data, uint16 *crc)
+void FLAC__crc16_update(const FLAC__byte data, FLAC__uint16 *crc)
{
*crc = (*crc<<8) ^ FLAC__crc16_table[(*crc>>8) ^ data];
}
-void FLAC__crc16_update_block(const byte *data, unsigned len, uint16 *crc)
+void FLAC__crc16_update_block(const FLAC__byte *data, unsigned len, FLAC__uint16 *crc)
{
while(len--)
*crc = (*crc<<8) ^ FLAC__crc16_table[(*crc>>8) ^ *data++];
}
-uint16 FLAC__crc16(const byte *data, unsigned len)
+FLAC__uint16 FLAC__crc16(const FLAC__byte *data, unsigned len)
{
- uint16 crc = 0;
+ FLAC__uint16 crc = 0;
while(len--)
crc = (crc<<8) ^ FLAC__crc16_table[(crc>>8) ^ *data++];
*
***********************************************************************/
-static FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data);
-static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+static FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
+static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
static void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
static void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
-static bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64 target_sample);
+static FLAC__bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, FLAC__uint64 target_sample);
/***********************************************************************
*
***********************************************************************/
typedef struct FLAC__FileDecoderPrivate {
- FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+ FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
void (*metadata_callback)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
void (*error_callback)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
void *client_data;
char *filename; /* == NULL if stdin */
FLAC__StreamDecoder *stream_decoder;
struct MD5Context md5context;
- byte stored_md5sum[16]; /* this is what is stored in the metadata */
- byte computed_md5sum[16]; /* this is the sum we computed from the decoded data */
+ FLAC__byte stored_md5sum[16]; /* this is what is stored in the metadata */
+ FLAC__byte computed_md5sum[16]; /* this is the sum we computed from the decoded data */
/* the rest of these are only used for seeking: */
FLAC__StreamMetaData_StreamInfo stream_info; /* we keep this around so we can figure out how to seek quickly */
const FLAC__StreamMetaData_SeekTable *seek_table; /* we hold a pointer to the stream decoder's seek table for the same reason */
FLAC__Frame last_frame; /* holds the info of the last frame we seeked to */
- uint64 target_sample;
+ FLAC__uint64 target_sample;
} FLAC__FileDecoderPrivate;
/***********************************************************************
return decoder->protected->state;
}
-bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
+FLAC__bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
{
- bool md5_failed = false;
+ FLAC__bool md5_failed = false;
FLAC__ASSERT(decoder != 0);
if(decoder->protected->state == FLAC__FILE_DECODER_UNINITIALIZED)
return !md5_failed;
}
-bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, bool value)
+FLAC__bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, FLAC__bool value)
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value)
+FLAC__bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value)
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__file_decoder_set_write_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data))
+FLAC__bool FLAC__file_decoder_set_write_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data))
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__file_decoder_set_metadata_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
+FLAC__bool FLAC__file_decoder_set_metadata_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__file_decoder_set_error_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
+FLAC__bool FLAC__file_decoder_set_error_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value)
+FLAC__bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value)
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return decoder->protected->state;
}
-bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
+FLAC__bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
{
return decoder->protected->md5_checking;
}
-bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder)
+FLAC__bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder)
{
- bool ret;
+ FLAC__bool ret;
FLAC__ASSERT(decoder != 0);
if(decoder->private->stream_decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
return ret;
}
-bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder)
+FLAC__bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder)
{
- bool ret;
+ FLAC__bool ret;
FLAC__ASSERT(decoder != 0);
if(decoder->private->stream_decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
return ret;
}
-bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder)
+FLAC__bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder)
{
- bool ret;
+ FLAC__bool ret;
FLAC__ASSERT(decoder != 0);
if(decoder->private->stream_decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
return ret;
}
-bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder)
+FLAC__bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder)
{
- bool ret;
+ FLAC__bool ret;
FLAC__ASSERT(decoder != 0);
if(decoder->private->stream_decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
*
***********************************************************************/
-bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, uint64 sample)
+FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__uint64 sample)
{
long filesize;
struct stat filestats;
return seek_to_absolute_sample_(decoder, filesize, sample);
}
-FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data)
+FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
(void)decoder;
return FLAC__STREAM_DECODER_READ_END_OF_STREAM;
}
else if(*bytes > 0) {
- size_t bytes_read = fread(buffer, sizeof(byte), *bytes, file_decoder->private->file);
+ size_t bytes_read = fread(buffer, sizeof(FLAC__byte), *bytes, file_decoder->private->file);
if(bytes_read == 0) {
if(feof(file_decoder->private->file)) {
file_decoder->protected->state = FLAC__FILE_DECODER_END_OF_FILE;
return FLAC__STREAM_DECODER_READ_ABORT; /* abort to avoid a deadlock */
}
-FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
{
FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
(void)decoder;
if(file_decoder->protected->state == FLAC__FILE_DECODER_SEEKING) {
- uint64 this_frame_sample = frame->header.number.sample_number;
- uint64 next_frame_sample = this_frame_sample + (uint64)frame->header.blocksize;
- uint64 target_sample = file_decoder->private->target_sample;
+ FLAC__uint64 this_frame_sample = frame->header.number.sample_number;
+ FLAC__uint64 next_frame_sample = this_frame_sample + (FLAC__uint64)frame->header.blocksize;
+ FLAC__uint64 target_sample = file_decoder->private->target_sample;
file_decoder->private->last_frame = *frame; /* save the frame in the private */
if(this_frame_sample <= target_sample && target_sample < next_frame_sample) { /* we hit our target frame */
/* shift out the samples before target_sample */
if(delta > 0) {
unsigned channel;
- const int32 *newbuffer[FLAC__MAX_CHANNELS];
+ const FLAC__int32 *newbuffer[FLAC__MAX_CHANNELS];
for(channel = 0; channel < frame->header.channels; channel++)
newbuffer[channel] = buffer[channel] + delta;
file_decoder->private->last_frame.header.blocksize -= delta;
- file_decoder->private->last_frame.header.number.sample_number += (uint64)delta;
+ file_decoder->private->last_frame.header.number.sample_number += (FLAC__uint64)delta;
/* write the relevant samples */
return file_decoder->private->write_callback(file_decoder, &file_decoder->private->last_frame, newbuffer, file_decoder->private->client_data);
}
file_decoder->private->error_callback(file_decoder, status, file_decoder->private->client_data);
}
-bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64 target_sample)
+FLAC__bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, FLAC__uint64 target_sample)
{
long first_frame_offset, lower_bound, upper_bound, pos = -1, last_pos = -1;
int i, lower_seek_point = -1, upper_seek_point = -1;
unsigned approx_bytes_per_frame;
- uint64 last_frame_sample = 0xffffffffffffffff;
- bool needs_seek;
- const bool is_variable_blocksize_stream = (decoder->private->stream_info.min_blocksize != decoder->private->stream_info.max_blocksize);
+ FLAC__uint64 last_frame_sample = 0xffffffffffffffff;
+ FLAC__bool needs_seek;
+ const FLAC__bool is_variable_blocksize_stream = (decoder->private->stream_info.min_blocksize != decoder->private->stream_info.max_blocksize);
/* we are just guessing here, but we want to guess high, not low */
if(decoder->private->stream_info.max_framesize > 0) {
pos = lower_bound;
}
else if(upper_seek_point >= 0) {
- const uint64 target_offset = target_sample - decoder->private->seek_table->points[lower_seek_point].sample_number;
- const uint64 range_samples = decoder->private->seek_table->points[upper_seek_point].sample_number - decoder->private->seek_table->points[lower_seek_point].sample_number;
+ const FLAC__uint64 target_offset = target_sample - decoder->private->seek_table->points[lower_seek_point].sample_number;
+ const FLAC__uint64 range_samples = decoder->private->seek_table->points[upper_seek_point].sample_number - decoder->private->seek_table->points[lower_seek_point].sample_number;
const long range_bytes = upper_bound - lower_bound;
#ifdef _MSC_VER
/* with VC++ you have to spoon feed it the casting */
- pos = lower_bound + (long)((double)(int64)target_offset / (double)(int64)range_samples * (double)(range_bytes-1)) - approx_bytes_per_frame;
+ pos = lower_bound + (long)((double)(FLAC__int64)target_offset / (double)(FLAC__int64)range_samples * (double)(range_bytes-1)) - approx_bytes_per_frame;
#else
pos = lower_bound + (long)((double)target_offset / (double)range_samples * (double)(range_bytes-1)) - approx_bytes_per_frame;
#endif
/* We need to use the metadata and the filelength to estimate the position of the frame with the correct sample */
#ifdef _MSC_VER
/* with VC++ you have to spoon feed it the casting */
- pos = first_frame_offset + (long)((double)(int64)target_sample / (double)(int64)decoder->private->stream_info.total_samples * (double)(filesize-first_frame_offset-1)) - approx_bytes_per_frame;
+ pos = first_frame_offset + (long)((double)(FLAC__int64)target_sample / (double)(FLAC__int64)decoder->private->stream_info.total_samples * (double)(filesize-first_frame_offset-1)) - approx_bytes_per_frame;
#else
pos = first_frame_offset + (long)((double)target_sample / (double)decoder->private->stream_info.total_samples * (double)(filesize-first_frame_offset-1)) - approx_bytes_per_frame;
#endif
break;
}
else { /* we need to narrow the search */
- uint64 this_frame_sample = decoder->private->last_frame.header.number.sample_number;
+ FLAC__uint64 this_frame_sample = decoder->private->last_frame.header.number.sample_number;
if(this_frame_sample == last_frame_sample) {
/* our last move backwards wasn't big enough */
pos -= (last_pos - pos);
#endif
#define local_abs(x) ((unsigned)((x)<0? -(x) : (x)))
-unsigned FLAC__fixed_compute_best_predictor(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
+unsigned FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
{
- int32 last_error_0 = data[-1];
- int32 last_error_1 = data[-1] - data[-2];
- int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
- int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
- int32 error, save;
- uint32 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
+ FLAC__int32 last_error_0 = data[-1];
+ FLAC__int32 last_error_1 = data[-1] - data[-2];
+ FLAC__int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
+ FLAC__int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
+ FLAC__int32 error, save;
+ FLAC__uint32 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
unsigned i, order;
for(i = 0; i < data_len; i++) {
else
order = 4;
- residual_bits_per_sample[0] = (real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[1] = (real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[2] = (real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[3] = (real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[4] = (real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[0] = (FLAC__real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[1] = (FLAC__real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[2] = (FLAC__real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[3] = (FLAC__real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[4] = (FLAC__real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double) data_len) / M_LN2 : 0.0);
return order;
}
-unsigned FLAC__fixed_compute_best_predictor_slow(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
+unsigned FLAC__fixed_compute_best_predictor_slow(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
{
- int32 last_error_0 = data[-1];
- int32 last_error_1 = data[-1] - data[-2];
- int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
- int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
- int32 error, save;
+ FLAC__int32 last_error_0 = data[-1];
+ FLAC__int32 last_error_1 = data[-1] - data[-2];
+ FLAC__int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
+ FLAC__int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
+ FLAC__int32 error, save;
/* total_error_* are 64-bits to avoid overflow when encoding
* erratic signals when the bits-per-sample and blocksize are
* large.
*/
- uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
+ FLAC__uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
unsigned i, order;
for(i = 0; i < data_len; i++) {
/* signal, so we use it directly to compute E(|x|) */
#ifdef _MSC_VER
/* with VC++ you have to spoon feed it the casting */
- residual_bits_per_sample[0] = (real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)(int64)total_error_0 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[1] = (real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)(int64)total_error_1 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[2] = (real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)(int64)total_error_2 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[3] = (real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)(int64)total_error_3 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[4] = (real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)(int64)total_error_4 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[0] = (FLAC__real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)(FLAC__int64)total_error_0 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[1] = (FLAC__real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)(FLAC__int64)total_error_1 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[2] = (FLAC__real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)(FLAC__int64)total_error_2 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[3] = (FLAC__real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)(FLAC__int64)total_error_3 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[4] = (FLAC__real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)(FLAC__int64)total_error_4 / (double) data_len) / M_LN2 : 0.0);
#else
- residual_bits_per_sample[0] = (real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[1] = (real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[2] = (real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[3] = (real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double) data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[4] = (real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[0] = (FLAC__real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[1] = (FLAC__real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[2] = (FLAC__real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[3] = (FLAC__real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double) data_len) / M_LN2 : 0.0);
+ residual_bits_per_sample[4] = (FLAC__real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double) data_len) / M_LN2 : 0.0);
#endif
return order;
}
-void FLAC__fixed_compute_residual(const int32 data[], unsigned data_len, unsigned order, int32 residual[])
+void FLAC__fixed_compute_residual(const FLAC__int32 data[], unsigned data_len, unsigned order, FLAC__int32 residual[])
{
int i, idata_len = (int)data_len;
}
}
-void FLAC__fixed_restore_signal(const int32 residual[], unsigned data_len, unsigned order, int32 data[])
+void FLAC__fixed_restore_signal(const FLAC__int32 residual[], unsigned data_len, unsigned order, FLAC__int32 data[])
{
int i, idata_len = (int)data_len;
#include <stdio.h>
#include "FLAC/format.h"
-const byte FLAC__STREAM_SYNC_STRING[4] = { 'f','L','a','C' };
+const FLAC__byte FLAC__STREAM_SYNC_STRING[4] = { 'f','L','a','C' };
const unsigned FLAC__STREAM_SYNC = 0x664C6143;
const unsigned FLAC__STREAM_SYNC_LEN = 32; /* bits */;
const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN = 16; /* bits */
const unsigned FLAC__STREAM_METADATA_SEEKPOINT_LEN = 18; /* bytes */
-const uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = 0xffffffffffffffff;
+const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = 0xffffffffffffffff;
const unsigned FLAC__STREAM_METADATA_IS_LAST_LEN = 1; /* bits */
const unsigned FLAC__STREAM_METADATA_TYPE_LEN = 7; /* bits */
; **********************************************************************
;
-; unsigned FLAC__fixed_compute_best_predictor(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
+; unsigned FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
; {
-; int32 last_error_0 = data[-1];
-; int32 last_error_1 = data[-1] - data[-2];
-; int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
-; int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
-; int32 error, save;
-; uint32 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
+; FLAC__int32 last_error_0 = data[-1];
+; FLAC__int32 last_error_1 = data[-1] - data[-2];
+; FLAC__int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
+; FLAC__int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
+; FLAC__int32 error, save;
+; FLAC__uint32 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
; unsigned i, order;
;
; for(i = 0; i < data_len; i++) {
; else
; order = 4;
;
-; residual_bits_per_sample[0] = (real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (real)total_error_0 / (real) data_len) / M_LN2 : 0.0);
-; residual_bits_per_sample[1] = (real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (real)total_error_1 / (real) data_len) / M_LN2 : 0.0);
-; residual_bits_per_sample[2] = (real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (real)total_error_2 / (real) data_len) / M_LN2 : 0.0);
-; residual_bits_per_sample[3] = (real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (real)total_error_3 / (real) data_len) / M_LN2 : 0.0);
-; residual_bits_per_sample[4] = (real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (real)total_error_4 / (real) data_len) / M_LN2 : 0.0);
+; residual_bits_per_sample[0] = (FLAC__real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0);
+; residual_bits_per_sample[1] = (FLAC__real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0);
+; residual_bits_per_sample[2] = (FLAC__real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0);
+; residual_bits_per_sample[3] = (FLAC__real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0);
+; residual_bits_per_sample[4] = (FLAC__real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0);
;
; return order;
; }
push esi
push edi
sub esp, byte 16
- ; qword [esp] == temp space for loading uint64s to FPU regs
+ ; qword [esp] == temp space for loading FLAC__uint64s to FPU regs
; dword [esp] == last_error_0
; dword [esp + 4] == last_error_1
; dword [esp + 8] == last_error_2
.not_order_3:
mov ebp, 4
.got_order:
- ; residual_bits_per_sample[0] = (real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (real)total_error_0 / (real) data_len) / M_LN2 : 0.0);
- ; residual_bits_per_sample[1] = (real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (real)total_error_1 / (real) data_len) / M_LN2 : 0.0);
- ; residual_bits_per_sample[2] = (real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (real)total_error_2 / (real) data_len) / M_LN2 : 0.0);
- ; residual_bits_per_sample[3] = (real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (real)total_error_3 / (real) data_len) / M_LN2 : 0.0);
- ; residual_bits_per_sample[4] = (real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (real)total_error_4 / (real) data_len) / M_LN2 : 0.0);
+ ; residual_bits_per_sample[0] = (FLAC__real)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0);
+ ; residual_bits_per_sample[1] = (FLAC__real)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0);
+ ; residual_bits_per_sample[2] = (FLAC__real)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0);
+ ; residual_bits_per_sample[3] = (FLAC__real)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0);
+ ; residual_bits_per_sample[4] = (FLAC__real)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0);
xor eax, eax
cmp eax, [esp + 40]
je near .data_len_is_0
jz .total_error_0_is_0
fld1 ; ST = 1.0 data_len
mov [esp], ebx
- mov [esp + 4], eax ; [esp] = (uint64)total_error_0
+ mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_0
mov ebx, [esp + 44]
fild qword [esp] ; ST = total_error_0 1.0 data_len
fdiv st2 ; ST = total_error_0/data_len 1.0 data_len
jz .total_error_1_is_0
fld1 ; ST = 1.0 data_len
mov [esp], ecx
- mov [esp + 4], eax ; [esp] = (uint64)total_error_1
+ mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_1
fild qword [esp] ; ST = total_error_1 1.0 data_len
fdiv st2 ; ST = total_error_1/data_len 1.0 data_len
fldln2 ; ST = ln2 total_error_1/data_len 1.0 data_len
jz .total_error_2_is_0
fld1 ; ST = 1.0 data_len
mov [esp], edx
- mov [esp + 4], eax ; [esp] = (uint64)total_error_2
+ mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_2
fild qword [esp] ; ST = total_error_2 1.0 data_len
fdiv st2 ; ST = total_error_2/data_len 1.0 data_len
fldln2 ; ST = ln2 total_error_2/data_len 1.0 data_len
jz .total_error_3_is_0
fld1 ; ST = 1.0 data_len
mov [esp], esi
- mov [esp + 4], eax ; [esp] = (uint64)total_error_3
+ mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_3
fild qword [esp] ; ST = total_error_3 1.0 data_len
fdiv st2 ; ST = total_error_3/data_len 1.0 data_len
fldln2 ; ST = ln2 total_error_3/data_len 1.0 data_len
jz .total_error_4_is_0
fld1 ; ST = 1.0 data_len
mov [esp], edi
- mov [esp + 4], eax ; [esp] = (uint64)total_error_4
+ mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_4
fild qword [esp] ; ST = total_error_4 1.0 data_len
fdiv st2 ; ST = total_error_4/data_len 1.0 data_len
fldln2 ; ST = ln2 total_error_4/data_len 1.0 data_len
; **********************************************************************
;
-; void FLAC__lpc_compute_autocorrelation_asm(const real data[], unsigned data_len, unsigned lag, real autoc[])
+; void FLAC__lpc_compute_autocorrelation_asm(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[])
; {
-; real d;
+; FLAC__real d;
; unsigned sample, coeff;
; const unsigned limit = data_len - lag;
;
; **********************************************************************
;
-; void FLAC__lpc_compute_autocorrelation_asm(const real data[], unsigned data_len, unsigned lag, real autoc[])
+; void FLAC__lpc_compute_autocorrelation_asm(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[])
; {
-; real d;
+; FLAC__real d;
; unsigned sample, coeff;
; const unsigned limit = data_len - lag;
;
.end:
ret
-;void FLAC__lpc_compute_residual_from_qlp_coefficients(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[])
+;void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[])
;
; for(i = 0; i < data_len; i++) {
; sum = 0;
; **********************************************************************
;
-; void FLAC__lpc_restore_signal(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[])
+; void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[])
; {
; unsigned i, j;
-; int32 sum;
+; FLAC__int32 sum;
;
; FLAC__ASSERT(order > 0);
;
#include "FLAC/ordinals.h"
typedef struct {
- byte *buffer;
+ FLAC__byte *buffer;
unsigned capacity; /* in bytes */
unsigned bytes, bits;
unsigned total_bits; /* must always == 8*bytes+bits */
unsigned consumed_bytes, consumed_bits;
unsigned total_consumed_bits; /* must always == 8*consumed_bytes+consumed_bits */
- uint16 read_crc16;
+ FLAC__uint16 read_crc16;
} FLAC__BitBuffer;
void FLAC__bitbuffer_init(FLAC__BitBuffer *bb);
-bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const byte buffer[], unsigned bytes);
-void FLAC__bitbuffer_init_read_crc16(FLAC__BitBuffer *bb, uint16 seed);
-bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src);
+FLAC__bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const FLAC__byte buffer[], unsigned bytes);
+void FLAC__bitbuffer_init_read_crc16(FLAC__BitBuffer *bb, FLAC__uint16 seed);
+FLAC__bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src);
void FLAC__bitbuffer_free(FLAC__BitBuffer *bb); /* does not 'free(buffer)' */
-bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb);
-bool FLAC__bitbuffer_clone(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src);
-bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits);
-bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, uint32 val, unsigned bits);
-bool FLAC__bitbuffer_write_raw_int32(FLAC__BitBuffer *bb, int32 val, unsigned bits);
-bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, uint64 val, unsigned bits);
-bool FLAC__bitbuffer_write_raw_int64(FLAC__BitBuffer *bb, int64 val, unsigned bits);
-bool FLAC__bitbuffer_write_unary_unsigned(FLAC__BitBuffer *bb, unsigned val);
+FLAC__bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb);
+FLAC__bool FLAC__bitbuffer_clone(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src);
+FLAC__bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits);
+FLAC__bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, FLAC__uint32 val, unsigned bits);
+FLAC__bool FLAC__bitbuffer_write_raw_int32(FLAC__BitBuffer *bb, FLAC__int32 val, unsigned bits);
+FLAC__bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, FLAC__uint64 val, unsigned bits);
+FLAC__bool FLAC__bitbuffer_write_raw_int64(FLAC__BitBuffer *bb, FLAC__int64 val, unsigned bits);
+FLAC__bool FLAC__bitbuffer_write_unary_unsigned(FLAC__BitBuffer *bb, unsigned val);
unsigned FLAC__bitbuffer_rice_bits(int val, unsigned parameter);
unsigned FLAC__bitbuffer_golomb_bits_signed(int val, unsigned parameter);
unsigned FLAC__bitbuffer_golomb_bits_unsigned(unsigned val, unsigned parameter);
-bool FLAC__bitbuffer_write_symmetric_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter);
-bool FLAC__bitbuffer_write_symmetric_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, bool *overflow);
-bool FLAC__bitbuffer_write_symmetric_rice_signed_escape(FLAC__BitBuffer *bb, int val, unsigned parameter);
-bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter);
-bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, bool *overflow);
-bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned parameter);
-bool FLAC__bitbuffer_write_golomb_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, bool *overflow);
-bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned val, unsigned parameter);
-bool FLAC__bitbuffer_write_golomb_unsigned_guarded(FLAC__BitBuffer *bb, unsigned val, unsigned parameter, unsigned max_bits, bool *overflow);
-bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, uint32 val);
-bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, uint64 val);
-bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb);
-bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, uint32 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, int32 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, uint64 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, int64 *val, const unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_symmetric_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data);
-bool FLAC__bitbuffer_read_utf8_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data, byte *raw, unsigned *rawlen);
-bool FLAC__bitbuffer_read_utf8_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data, byte *raw, unsigned *rawlen);
+FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter);
+FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow);
+FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed_escape(FLAC__BitBuffer *bb, int val, unsigned parameter);
+FLAC__bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter);
+FLAC__bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow);
+FLAC__bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned parameter);
+FLAC__bool FLAC__bitbuffer_write_golomb_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow);
+FLAC__bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned val, unsigned parameter);
+FLAC__bool FLAC__bitbuffer_write_golomb_unsigned_guarded(FLAC__BitBuffer *bb, unsigned val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow);
+FLAC__bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, FLAC__uint32 val);
+FLAC__bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, FLAC__uint64 val);
+FLAC__bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb);
+FLAC__bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, FLAC__int32 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, FLAC__int64 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_symmetric_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data);
+FLAC__bool FLAC__bitbuffer_read_utf8_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data, FLAC__byte *raw, unsigned *rawlen);
+FLAC__bool FLAC__bitbuffer_read_utf8_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data, FLAC__byte *raw, unsigned *rawlen);
void FLAC__bitbuffer_dump(const FLAC__BitBuffer *bb, FILE *out);
#endif
} FLAC__CPUInfo_Type;
typedef struct {
- bool cmov;
- bool mmx;
- bool fxsr;
- bool sse;
- bool sse2;
+ FLAC__bool cmov;
+ FLAC__bool mmx;
+ FLAC__bool fxsr;
+ FLAC__bool sse;
+ FLAC__bool sse2;
} FLAC__CPUInfo_IA32;
extern const unsigned FLAC__CPUINFO_IA32_CPUID_CMOV;
extern const unsigned FLAC__CPUINFO_IA32_CPUID_MMX;
extern const unsigned FLAC__CPUINFO_IA32_CPUID_SSE2;
typedef struct {
- bool use_asm;
+ FLAC__bool use_asm;
FLAC__CPUInfo_Type type;
union {
FLAC__CPUInfo_IA32 ia32;
** polynomial = x^8 + x^2 + x^1 + x^0
** init = 0
*/
-extern byte const FLAC__crc8_table[256];
+extern FLAC__byte const FLAC__crc8_table[256];
#define FLAC__CRC8_UPDATE(data, crc) (crc) = FLAC__crc8_table[(crc) ^ (data)];
-void FLAC__crc8_update(const byte data, uint8 *crc);
-void FLAC__crc8_update_block(const byte *data, unsigned len, uint8 *crc);
-uint8 FLAC__crc8(const byte *data, unsigned len);
+void FLAC__crc8_update(const FLAC__byte data, FLAC__uint8 *crc);
+void FLAC__crc8_update_block(const FLAC__byte *data, unsigned len, FLAC__uint8 *crc);
+FLAC__uint8 FLAC__crc8(const FLAC__byte *data, unsigned len);
/* 16 bit CRC generator, MSB shifted first
** polynomial = x^16 + x^15 + x^2 + x^0
** init = 0
*/
-extern uint16 FLAC__crc16_table[256];
+extern FLAC__uint16 FLAC__crc16_table[256];
#define FLAC__CRC16_UPDATE(data, crc) (crc) = ((crc)<<8) ^ FLAC__crc16_table[((crc)>>8) ^ (data)];
-void FLAC__crc16_update(const byte data, uint16 *crc);
-void FLAC__crc16_update_block(const byte *data, unsigned len, uint16 *crc);
-uint16 FLAC__crc16(const byte *data, unsigned len);
+void FLAC__crc16_update(const FLAC__byte data, FLAC__uint16 *crc);
+void FLAC__crc16_update_block(const FLAC__byte *data, unsigned len, FLAC__uint16 *crc);
+FLAC__uint16 FLAC__crc16(const FLAC__byte *data, unsigned len);
#endif
* IN data_len
* OUT residual_bits_per_sample[0,FLAC__MAX_FIXED_ORDER]
*/
-unsigned FLAC__fixed_compute_best_predictor(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
+unsigned FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
#ifndef FLAC__NO_ASM
#ifdef FLAC__CPU_IA32
#ifdef FLAC__HAS_NASM
-unsigned FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
+unsigned FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
#endif
#endif
#endif
-unsigned FLAC__fixed_compute_best_predictor_slow(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
+unsigned FLAC__fixed_compute_best_predictor_slow(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
/*
* FLAC__fixed_compute_residual()
* IN order <= FLAC__MAX_FIXED_ORDER fixed-predictor order
* OUT residual[0,data_len-1] residual signal
*/
-void FLAC__fixed_compute_residual(const int32 data[], unsigned data_len, unsigned order, int32 residual[]);
+void FLAC__fixed_compute_residual(const FLAC__int32 data[], unsigned data_len, unsigned order, FLAC__int32 residual[]);
/*
* FLAC__fixed_restore_signal()
* IN data[-order,-1] previously-reconstructed historical samples
* OUT data[0,data_len-1] original signal
*/
-void FLAC__fixed_restore_signal(const int32 residual[], unsigned data_len, unsigned order, int32 data[]);
+void FLAC__fixed_restore_signal(const FLAC__int32 residual[], unsigned data_len, unsigned order, FLAC__int32 data[]);
#endif
* IN 0 < lag <= data_len
* OUT autoc[0,lag-1]
*/
-void FLAC__lpc_compute_autocorrelation(const real data[], unsigned data_len, unsigned lag, real autoc[]);
+void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
#ifndef FLAC__NO_ASM
#ifdef FLAC__CPU_IA32
#ifdef FLAC__HAS_NASM
-void FLAC__lpc_compute_autocorrelation_asm_ia32(const real data[], unsigned data_len, unsigned lag, real autoc[]);
-void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4(const real data[], unsigned data_len, unsigned lag, real autoc[]);
-void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8(const real data[], unsigned data_len, unsigned lag, real autoc[]);
-void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12(const real data[], unsigned data_len, unsigned lag, real autoc[]);
+void FLAC__lpc_compute_autocorrelation_asm_ia32(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
+void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
+void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
+void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
#endif
#endif
#endif
* in lp_coeff[8][0,8], the LP coefficients for order 8 will be
* in lp_coeff[7][0,7], etc.
*/
-void FLAC__lpc_compute_lp_coefficients(const real autoc[], unsigned max_order, real lp_coeff[][FLAC__MAX_LPC_ORDER], real error[]);
+void FLAC__lpc_compute_lp_coefficients(const FLAC__real autoc[], unsigned max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], FLAC__real error[]);
/*
* FLAC__lpc_quantize_coefficients()
* --------------------------------------------------------------------
* Quantizes the LP coefficients. NOTE: precision + bits_per_sample
- * must be less than 32 (sizeof(int32)*8).
+ * must be less than 32 (sizeof(FLAC__int32)*8).
*
* IN lp_coeff[0,order-1] LP coefficients
* IN order LP order
* 2 => coefficients are all zero, which is bad. 'shift' is
* unset.
*/
-int FLAC__lpc_quantize_coefficients(const real lp_coeff[], unsigned order, unsigned precision, unsigned bits_per_sample, int32 qlp_coeff[], int *shift);
+int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], unsigned order, unsigned precision, unsigned bits_per_sample, FLAC__int32 qlp_coeff[], int *shift);
/*
* FLAC__lpc_compute_residual_from_qlp_coefficients()
* IN lp_quantization quantization of LP coefficients in bits
* OUT residual[0,data_len-1] residual signal
*/
-void FLAC__lpc_compute_residual_from_qlp_coefficients(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[]);
+void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
#ifndef FLAC__NO_ASM
#ifdef FLAC__CPU_IA32
#ifdef FLAC__HAS_NASM
-void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[]);
+void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
+void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
#endif
#endif
#endif
* IN data[-order,-1] previously-reconstructed historical samples
* OUT data[0,data_len-1] original signal
*/
-void FLAC__lpc_restore_signal(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[]);
+void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
#ifndef FLAC__NO_ASM
#ifdef FLAC__CPU_IA32
#ifdef FLAC__HAS_NASM
-void FLAC__lpc_restore_signal_asm_ia32(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[]);
-void FLAC__lpc_restore_signal_asm_ia32_mmx(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[]);
+void FLAC__lpc_restore_signal_asm_ia32(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
+void FLAC__lpc_restore_signal_asm_ia32_mmx(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
#endif
#endif
#endif
* IN total_samples > 0 # of samples in residual signal
* RETURN expected bits per sample
*/
-real FLAC__lpc_compute_expected_bits_per_residual_sample(real lpc_error, unsigned total_samples);
-real FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(real lpc_error, real error_scale);
+FLAC__real FLAC__lpc_compute_expected_bits_per_residual_sample(FLAC__real lpc_error, unsigned total_samples);
+FLAC__real FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(FLAC__real lpc_error, FLAC__real error_scale);
/*
* FLAC__lpc_compute_best_order()
* IN bits_per_signal_sample # of bits per sample in the original signal
* RETURN [1,max_order] best order
*/
-unsigned FLAC__lpc_compute_best_order(const real lpc_error[], unsigned max_order, unsigned total_samples, unsigned bits_per_signal_sample);
+unsigned FLAC__lpc_compute_best_order(const FLAC__real lpc_error[], unsigned max_order, unsigned total_samples, unsigned bits_per_signal_sample);
#endif
#include "FLAC/ordinals.h"
struct MD5Context {
- uint32 buf[4];
- uint32 bytes[2];
- uint32 in[16];
- byte *internal_buf;
+ FLAC__uint32 buf[4];
+ FLAC__uint32 bytes[2];
+ FLAC__uint32 in[16];
+ FLAC__byte *internal_buf;
unsigned capacity;
};
void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);
void MD5Final(md5byte digest[16], struct MD5Context *context);
-void MD5Transform(uint32 buf[4], uint32 const in[16]);
+void MD5Transform(FLAC__uint32 buf[4], FLAC__uint32 const in[16]);
-bool FLAC__MD5Accumulate(struct MD5Context *ctx, const int32 *signal[], unsigned channels, unsigned samples, unsigned bytes_per_sample);
+FLAC__bool FLAC__MD5Accumulate(struct MD5Context *ctx, const FLAC__int32 *signal[], unsigned channels, unsigned samples, unsigned bytes_per_sample);
#endif /* !MD5_H */
#include <stdlib.h> /* for size_t */
-#include "FLAC/ordinals.h" /* for bool */
+#include "FLAC/ordinals.h" /* for FLAC__bool */
/* Returns the unaligned address returned by malloc.
* Use free() on this address to deallocate.
*/
void *FLAC__memory_alloc_aligned(size_t bytes, void **aligned_address);
-bool FLAC__memory_alloc_aligned_int32_array(unsigned elements, int32 **unaligned_pointer, int32 **aligned_pointer);
-bool FLAC__memory_alloc_aligned_uint32_array(unsigned elements, uint32 **unaligned_pointer, uint32 **aligned_pointer);
-bool FLAC__memory_alloc_aligned_unsigned_array(unsigned elements, unsigned **unaligned_pointer, unsigned **aligned_pointer);
-bool FLAC__memory_alloc_aligned_real_array(unsigned elements, real **unaligned_pointer, real **aligned_pointer);
+FLAC__bool FLAC__memory_alloc_aligned_int32_array(unsigned elements, FLAC__int32 **unaligned_pointer, FLAC__int32 **aligned_pointer);
+FLAC__bool FLAC__memory_alloc_aligned_uint32_array(unsigned elements, FLAC__uint32 **unaligned_pointer, FLAC__uint32 **aligned_pointer);
+FLAC__bool FLAC__memory_alloc_aligned_unsigned_array(unsigned elements, unsigned **unaligned_pointer, unsigned **aligned_pointer);
+FLAC__bool FLAC__memory_alloc_aligned_real_array(unsigned elements, FLAC__real **unaligned_pointer, FLAC__real **aligned_pointer);
#endif
#include "FLAC/format.h"
#include "bitbuffer.h"
-bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuffer *bb);
-bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_subset, bool is_last_block, FLAC__BitBuffer *bb);
-bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
-bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
-bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
-bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
+FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuffer *bb);
+FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__bool streamable_subset, FLAC__bool is_last_block, FLAC__BitBuffer *bb);
+FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
+FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
+FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
+FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb);
#endif
#include "FLAC/file_decoder.h"
typedef struct FLAC__FileDecoderProtected {
- bool md5_checking; /* if true, generate MD5 signature of decoded data and compare against signature in the Encoding metadata block */
+ FLAC__bool md5_checking; /* if true, generate MD5 signature of decoded data and compare against signature in the Encoding metadata block */
FLAC__FileDecoderState state;
} FLAC__FileDecoderProtected;
typedef struct FLAC__StreamEncoderProtected {
FLAC__StreamEncoderState state;
- bool streamable_subset;
- bool do_mid_side_stereo;
- bool loose_mid_side_stereo;
+ FLAC__bool streamable_subset;
+ FLAC__bool do_mid_side_stereo;
+ FLAC__bool loose_mid_side_stereo;
unsigned channels;
unsigned bits_per_sample;
unsigned sample_rate;
unsigned blocksize;
unsigned max_lpc_order;
unsigned qlp_coeff_precision;
- bool do_qlp_coeff_prec_search;
- bool do_exhaustive_model_search;
+ FLAC__bool do_qlp_coeff_prec_search;
+ FLAC__bool do_exhaustive_model_search;
unsigned min_residual_partition_order;
unsigned max_residual_partition_order;
unsigned rice_parameter_search_dist;
- uint64 total_samples_estimate;
+ FLAC__uint64 total_samples_estimate;
const FLAC__StreamMetaData_SeekTable *seek_table;
unsigned padding;
- bool last_metadata_is_last;
+ FLAC__bool last_metadata_is_last;
} FLAC__StreamEncoderProtected;
#endif
#define LOCAL_FABS(x) ((x)<0.0? -(x):(x))
-void FLAC__lpc_compute_autocorrelation(const real data[], unsigned data_len, unsigned lag, real autoc[])
+void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[])
{
/* a readable, but slower, version */
#if 0
- real d;
+ FLAC__real d;
unsigned i;
FLAC__ASSERT(lag > 0);
* this version tends to run faster because of better data locality
* ('data_len' is usually much larger than 'lag')
*/
- real d;
+ FLAC__real d;
unsigned sample, coeff;
const unsigned limit = data_len - lag;
}
}
-void FLAC__lpc_compute_lp_coefficients(const real autoc[], unsigned max_order, real lp_coeff[][FLAC__MAX_LPC_ORDER], real error[])
+void FLAC__lpc_compute_lp_coefficients(const FLAC__real autoc[], unsigned max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], FLAC__real error[])
{
unsigned i, j;
- real r, err, ref[FLAC__MAX_LPC_ORDER], lpc[FLAC__MAX_LPC_ORDER];
+ FLAC__real r, err, ref[FLAC__MAX_LPC_ORDER], lpc[FLAC__MAX_LPC_ORDER];
FLAC__ASSERT(0 < max_order);
FLAC__ASSERT(max_order <= FLAC__MAX_LPC_ORDER);
/* Update LPC coefficients and total error. */
lpc[i]=r;
for(j = 0; j < (i>>1); j++) {
- real tmp = lpc[j];
+ FLAC__real tmp = lpc[j];
lpc[j] += r * lpc[i-1-j];
lpc[i-1-j] += r * tmp;
}
}
}
-int FLAC__lpc_quantize_coefficients(const real lp_coeff[], unsigned order, unsigned precision, unsigned bits_per_sample, int32 qlp_coeff[], int *shift)
+int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], unsigned order, unsigned precision, unsigned bits_per_sample, FLAC__int32 qlp_coeff[], int *shift)
{
unsigned i;
- real d, cmax = -1e32;
+ FLAC__real d, cmax = -1e32;
FLAC__ASSERT(bits_per_sample > 0);
- FLAC__ASSERT(bits_per_sample <= sizeof(int32)*8);
+ FLAC__ASSERT(bits_per_sample <= sizeof(FLAC__int32)*8);
FLAC__ASSERT(precision > 0);
FLAC__ASSERT(precision >= FLAC__MIN_QLP_COEFF_PRECISION);
- FLAC__ASSERT(precision + bits_per_sample < sizeof(int32)*8);
+ FLAC__ASSERT(precision + bits_per_sample < sizeof(FLAC__int32)*8);
#ifdef NDEBUG
(void)bits_per_sample; /* silence compiler warning about unused parameter */
#endif
if(*shift != 0) { /* just to avoid wasting time... */
for(i = 0; i < order; i++)
- qlp_coeff[i] = (int32)floor(lp_coeff[i] * (real)(1 << *shift));
+ qlp_coeff[i] = (FLAC__int32)floor(lp_coeff[i] * (FLAC__real)(1 << *shift));
}
return 0;
}
-void FLAC__lpc_compute_residual_from_qlp_coefficients(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[])
+void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[])
{
#ifdef FLAC__OVERFLOW_DETECT
- int64 sumo;
+ FLAC__int64 sumo;
#endif
unsigned i, j;
- int32 sum;
- const int32 *history;
+ FLAC__int32 sum;
+ const FLAC__int32 *history;
#ifdef FLAC__OVERFLOW_DETECT_VERBOSE
fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
for(j = 0; j < order; j++) {
sum += qlp_coeff[j] * (*(--history));
#ifdef FLAC__OVERFLOW_DETECT
- sumo += (int64)qlp_coeff[j] * (int64)(*history);
+ sumo += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*history);
if(sumo > 2147483647ll || sumo < -2147483648ll) {
fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%lld\n",i,j,qlp_coeff[j],*history,sumo);
}
*/
}
-void FLAC__lpc_restore_signal(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[])
+void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[])
{
#ifdef FLAC__OVERFLOW_DETECT
- int64 sumo;
+ FLAC__int64 sumo;
#endif
unsigned i, j;
- int32 sum;
- const int32 *history;
+ FLAC__int32 sum;
+ const FLAC__int32 *history;
#ifdef FLAC__OVERFLOW_DETECT_VERBOSE
fprintf(stderr,"FLAC__lpc_restore_signal: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
for(j = 0; j < order; j++) {
sum += qlp_coeff[j] * (*(--history));
#ifdef FLAC__OVERFLOW_DETECT
- sumo += (int64)qlp_coeff[j] * (int64)(*history);
+ sumo += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*history);
if(sumo > 2147483647ll || sumo < -2147483648ll) {
fprintf(stderr,"FLAC__lpc_restore_signal: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%lld\n",i,j,qlp_coeff[j],*history,sumo);
}
*/
}
-real FLAC__lpc_compute_expected_bits_per_residual_sample(real lpc_error, unsigned total_samples)
+FLAC__real FLAC__lpc_compute_expected_bits_per_residual_sample(FLAC__real lpc_error, unsigned total_samples)
{
- real error_scale;
+ FLAC__real error_scale;
FLAC__ASSERT(total_samples > 0);
- error_scale = 0.5 * M_LN2 * M_LN2 / (real)total_samples;
+ error_scale = 0.5 * M_LN2 * M_LN2 / (FLAC__real)total_samples;
if(lpc_error > 0.0) {
- real bps = 0.5 * log(error_scale * lpc_error) / M_LN2;
+ FLAC__real bps = 0.5 * log(error_scale * lpc_error) / M_LN2;
if(bps >= 0.0)
return bps;
else
}
}
-real FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(real lpc_error, real error_scale)
+FLAC__real FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(FLAC__real lpc_error, FLAC__real error_scale)
{
if(lpc_error > 0.0) {
- real bps = 0.5 * log(error_scale * lpc_error) / M_LN2;
+ FLAC__real bps = 0.5 * log(error_scale * lpc_error) / M_LN2;
if(bps >= 0.0)
return bps;
else
}
}
-unsigned FLAC__lpc_compute_best_order(const real lpc_error[], unsigned max_order, unsigned total_samples, unsigned bits_per_signal_sample)
+unsigned FLAC__lpc_compute_best_order(const FLAC__real lpc_error[], unsigned max_order, unsigned total_samples, unsigned bits_per_signal_sample)
{
unsigned order, best_order;
- real best_bits, tmp_bits, error_scale;
+ FLAC__real best_bits, tmp_bits, error_scale;
FLAC__ASSERT(max_order > 0);
FLAC__ASSERT(total_samples > 0);
- error_scale = 0.5 * M_LN2 * M_LN2 / (real)total_samples;
+ error_scale = 0.5 * M_LN2 * M_LN2 / (FLAC__real)total_samples;
best_order = 0;
- best_bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[0], error_scale) * (real)total_samples;
+ best_bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[0], error_scale) * (FLAC__real)total_samples;
for(order = 1; order < max_order; order++) {
- tmp_bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[order], error_scale) * (real)(total_samples - order) + (real)(order * bits_per_signal_sample);
+ tmp_bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[order], error_scale) * (FLAC__real)(total_samples - order) + (FLAC__real)(order * bits_per_signal_sample);
if(tmp_bits < best_bits) {
best_order = order;
best_bits = tmp_bits;
#include "private/md5.h"
-static bool is_big_endian_host_;
+static FLAC__bool is_big_endian_host_;
void
-byteSwap(uint32 *buf, unsigned words)
+byteSwap(FLAC__uint32 *buf, unsigned words)
{
md5byte *p = (md5byte *)buf;
if(!is_big_endian_host_)
return;
do {
- *buf++ = (uint32)((unsigned)p[3] << 8 | p[2]) << 16 | ((unsigned)p[1] << 8 | p[0]);
+ *buf++ = (FLAC__uint32)((unsigned)p[3] << 8 | p[2]) << 16 | ((unsigned)p[1] << 8 | p[0]);
p += 4;
} while (--words);
}
void
MD5Init(struct MD5Context *ctx)
{
- uint32 test = 1;
+ FLAC__uint32 test = 1;
- is_big_endian_host_ = (*((byte*)(&test)))? false : true;
+ is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
void
MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)
{
- uint32 t;
+ FLAC__uint32 t;
/* Update byte count */
/*
* Convert the incoming audio signal to a byte stream and MD5Update it.
*/
-bool
-FLAC__MD5Accumulate(struct MD5Context *ctx, const int32 *signal[], unsigned channels, unsigned samples, unsigned bytes_per_sample)
+FLAC__bool
+FLAC__MD5Accumulate(struct MD5Context *ctx, const FLAC__int32 *signal[], unsigned channels, unsigned samples, unsigned bytes_per_sample)
{
unsigned channel, sample, a_byte;
- int32 a_word;
- byte *buf_;
+ FLAC__int32 a_word;
+ FLAC__byte *buf_;
const unsigned bytes_needed = channels * samples * bytes_per_sample;
if(ctx->capacity < bytes_needed) {
- byte *tmp = realloc(ctx->internal_buf, bytes_needed);
+ FLAC__byte *tmp = realloc(ctx->internal_buf, bytes_needed);
if(0 == tmp) {
free(ctx->internal_buf);
if(0 == (ctx->internal_buf = malloc(bytes_needed)))
for(channel = 0; channel < channels; channel++) {
a_word = signal[channel][sample];
for(a_byte = 0; a_byte < bytes_per_sample; a_byte++) {
- *buf_++ = (byte)(a_word & 0xff);
+ *buf_++ = (FLAC__byte)(a_word & 0xff);
a_word >>= 8;
}
}
* the data and converts bytes into longwords for this routine.
*/
void
-MD5Transform(uint32 buf[4], uint32 const in[16])
+MD5Transform(FLAC__uint32 buf[4], FLAC__uint32 const in[16])
{
- register uint32 a, b, c, d;
+ register FLAC__uint32 a, b, c, d;
a = buf[0];
b = buf[1];
return x;
}
-bool FLAC__memory_alloc_aligned_int32_array(unsigned elements, int32 **unaligned_pointer, int32 **aligned_pointer)
+FLAC__bool FLAC__memory_alloc_aligned_int32_array(unsigned elements, FLAC__int32 **unaligned_pointer, FLAC__int32 **aligned_pointer)
{
- int32 *pa, *pu; /* aligned pointer, unaligned pointer */
+ FLAC__int32 *pa, *pu; /* aligned pointer, unaligned pointer */
FLAC__ASSERT(elements > 0);
FLAC__ASSERT(0 != unaligned_pointer);
FLAC__ASSERT(0 != aligned_pointer);
FLAC__ASSERT(unaligned_pointer != aligned_pointer);
- pu = (int32*)FLAC__memory_alloc_aligned(sizeof(int32) * elements, (void*)&pa);
+ pu = (FLAC__int32*)FLAC__memory_alloc_aligned(sizeof(FLAC__int32) * elements, (void*)&pa);
if(0 == pu) {
return false;
}
}
}
-bool FLAC__memory_alloc_aligned_uint32_array(unsigned elements, uint32 **unaligned_pointer, uint32 **aligned_pointer)
+FLAC__bool FLAC__memory_alloc_aligned_uint32_array(unsigned elements, FLAC__uint32 **unaligned_pointer, FLAC__uint32 **aligned_pointer)
{
- uint32 *pa, *pu; /* aligned pointer, unaligned pointer */
+ FLAC__uint32 *pa, *pu; /* aligned pointer, unaligned pointer */
FLAC__ASSERT(elements > 0);
FLAC__ASSERT(0 != unaligned_pointer);
FLAC__ASSERT(0 != aligned_pointer);
FLAC__ASSERT(unaligned_pointer != aligned_pointer);
- pu = (uint32*)FLAC__memory_alloc_aligned(sizeof(uint32) * elements, (void*)&pa);
+ pu = (FLAC__uint32*)FLAC__memory_alloc_aligned(sizeof(FLAC__uint32) * elements, (void*)&pa);
if(0 == pu) {
return false;
}
}
}
-bool FLAC__memory_alloc_aligned_unsigned_array(unsigned elements, unsigned **unaligned_pointer, unsigned **aligned_pointer)
+FLAC__bool FLAC__memory_alloc_aligned_unsigned_array(unsigned elements, unsigned **unaligned_pointer, unsigned **aligned_pointer)
{
unsigned *pa, *pu; /* aligned pointer, unaligned pointer */
}
}
-bool FLAC__memory_alloc_aligned_real_array(unsigned elements, real **unaligned_pointer, real **aligned_pointer)
+FLAC__bool FLAC__memory_alloc_aligned_real_array(unsigned elements, FLAC__real **unaligned_pointer, FLAC__real **aligned_pointer)
{
- real *pa, *pu; /* aligned pointer, unaligned pointer */
+ FLAC__real *pa, *pu; /* aligned pointer, unaligned pointer */
FLAC__ASSERT(elements > 0);
FLAC__ASSERT(0 != unaligned_pointer);
FLAC__ASSERT(0 != aligned_pointer);
FLAC__ASSERT(unaligned_pointer != aligned_pointer);
- pu = (real*)FLAC__memory_alloc_aligned(sizeof(real) * elements, (void*)&pa);
+ pu = (FLAC__real*)FLAC__memory_alloc_aligned(sizeof(FLAC__real) * elements, (void*)&pa);
if(0 == pu) {
return false;
}
#include "FLAC/seek_table.h"
-bool FLAC__seek_table_is_valid(const FLAC__StreamMetaData_SeekTable *seek_table)
+FLAC__bool FLAC__seek_table_is_valid(const FLAC__StreamMetaData_SeekTable *seek_table)
{
unsigned i;
- uint64 last_sample_number = 0;
- bool got_last = false;
+ FLAC__uint64 last_sample_number = 0;
+ FLAC__bool got_last = false;
for(i = 0; i < seek_table->num_points; i++) {
if(seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER) {
*
***********************************************************************/
-static byte ID3V2_TAG_[3] = { 'I', 'D', '3' };
+static FLAC__byte ID3V2_TAG_[3] = { 'I', 'D', '3' };
/***********************************************************************
*
*
***********************************************************************/
-static bool stream_decoder_allocate_output_(FLAC__StreamDecoder *decoder, unsigned size, unsigned channels);
-static bool stream_decoder_find_metadata_(FLAC__StreamDecoder *decoder);
-static bool stream_decoder_read_metadata_(FLAC__StreamDecoder *decoder);
-static bool stream_decoder_skip_id3v2_tag_(FLAC__StreamDecoder *decoder);
-static bool stream_decoder_frame_sync_(FLAC__StreamDecoder *decoder);
-static bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame);
-static bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder);
-static bool stream_decoder_read_subframe_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps);
-static bool stream_decoder_read_subframe_constant_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps);
-static bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order);
-static bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order);
-static bool stream_decoder_read_subframe_verbatim_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps);
-static bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order, int32 *residual);
-static bool stream_decoder_read_zero_padding_(FLAC__StreamDecoder *decoder);
-static bool read_callback_(byte buffer[], unsigned *bytes, void *client_data);
+static FLAC__bool stream_decoder_allocate_output_(FLAC__StreamDecoder *decoder, unsigned size, unsigned channels);
+static FLAC__bool stream_decoder_find_metadata_(FLAC__StreamDecoder *decoder);
+static FLAC__bool stream_decoder_read_metadata_(FLAC__StreamDecoder *decoder);
+static FLAC__bool stream_decoder_skip_id3v2_tag_(FLAC__StreamDecoder *decoder);
+static FLAC__bool stream_decoder_frame_sync_(FLAC__StreamDecoder *decoder);
+static FLAC__bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, FLAC__bool *got_a_frame);
+static FLAC__bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder);
+static FLAC__bool stream_decoder_read_subframe_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps);
+static FLAC__bool stream_decoder_read_subframe_constant_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps);
+static FLAC__bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order);
+static FLAC__bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order);
+static FLAC__bool stream_decoder_read_subframe_verbatim_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps);
+static FLAC__bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order, FLAC__int32 *residual);
+static FLAC__bool stream_decoder_read_zero_padding_(FLAC__StreamDecoder *decoder);
+static FLAC__bool read_callback_(FLAC__byte buffer[], unsigned *bytes, void *client_data);
/***********************************************************************
*
***********************************************************************/
typedef struct FLAC__StreamDecoderPrivate {
- FLAC__StreamDecoderReadStatus (*read_callback)(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data);
- FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+ FLAC__StreamDecoderReadStatus (*read_callback)(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
+ FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
void (*metadata_callback)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
void (*error_callback)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
- void (*local_lpc_restore_signal)(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[]);
- void (*local_lpc_restore_signal_16bit)(const int32 residual[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 data[]);
+ void (*local_lpc_restore_signal)(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
+ void (*local_lpc_restore_signal_16bit)(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
void *client_data;
FLAC__BitBuffer input;
- int32 *output[FLAC__MAX_CHANNELS];
- int32 *residual[FLAC__MAX_CHANNELS];
+ FLAC__int32 *output[FLAC__MAX_CHANNELS];
+ FLAC__int32 *residual[FLAC__MAX_CHANNELS];
unsigned output_capacity, output_channels;
- uint32 last_frame_number;
- uint64 samples_decoded;
- bool has_stream_info, has_seek_table;
+ FLAC__uint32 last_frame_number;
+ FLAC__uint64 samples_decoded;
+ FLAC__bool has_stream_info, has_seek_table;
FLAC__StreamMetaData stream_info;
FLAC__StreamMetaData seek_table;
FLAC__Frame frame;
- bool cached; /* true if there is a byte in lookahead */
+ FLAC__bool cached; /* true if there is a byte in lookahead */
FLAC__CPUInfo cpuinfo;
- byte header_warmup[2]; /* contains the sync code and reserved bits */
- byte lookahead; /* temp storage when we need to look ahead one byte in the stream */
+ FLAC__byte header_warmup[2]; /* contains the sync code and reserved bits */
+ FLAC__byte lookahead; /* temp storage when we need to look ahead one byte in the stream */
} FLAC__StreamDecoderPrivate;
/***********************************************************************
decoder->protected->state = FLAC__STREAM_DECODER_UNINITIALIZED;
}
-bool FLAC__stream_decoder_set_read_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderReadStatus (*value)(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data))
+FLAC__bool FLAC__stream_decoder_set_read_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderReadStatus (*value)(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_decoder_set_write_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data))
+FLAC__bool FLAC__stream_decoder_set_write_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_decoder_set_metadata_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
+FLAC__bool FLAC__stream_decoder_set_metadata_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_decoder_set_error_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
+FLAC__bool FLAC__stream_decoder_set_error_callback(const FLAC__StreamDecoder *decoder, void (*value)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_decoder_set_client_data(const FLAC__StreamDecoder *decoder, void *value)
+FLAC__bool FLAC__stream_decoder_set_client_data(const FLAC__StreamDecoder *decoder, void *value)
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
return decoder->protected->blocksize;
}
-bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder)
+FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder)
{
FLAC__ASSERT(decoder != 0);
return true;
}
-bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder)
+FLAC__bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder)
{
FLAC__ASSERT(decoder != 0);
return true;
}
-bool FLAC__stream_decoder_process_whole_stream(FLAC__StreamDecoder *decoder)
+FLAC__bool FLAC__stream_decoder_process_whole_stream(FLAC__StreamDecoder *decoder)
{
- bool dummy;
+ FLAC__bool dummy;
FLAC__ASSERT(decoder != 0);
if(decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
}
}
-bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder)
+FLAC__bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder)
{
FLAC__ASSERT(decoder != 0);
}
}
-bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder)
+FLAC__bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder)
{
- bool got_a_frame;
+ FLAC__bool got_a_frame;
FLAC__ASSERT(decoder != 0);
if(decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
}
}
-bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder)
+FLAC__bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder)
{
- bool dummy;
+ FLAC__bool dummy;
FLAC__ASSERT(decoder != 0);
if(decoder->protected->state == FLAC__STREAM_DECODER_END_OF_STREAM)
*
***********************************************************************/
-bool stream_decoder_allocate_output_(FLAC__StreamDecoder *decoder, unsigned size, unsigned channels)
+FLAC__bool stream_decoder_allocate_output_(FLAC__StreamDecoder *decoder, unsigned size, unsigned channels)
{
unsigned i;
- int32 *tmp;
+ FLAC__int32 *tmp;
if(size <= decoder->private->output_capacity && channels <= decoder->private->output_channels)
return true;
}
for(i = 0; i < channels; i++) {
- tmp = (int32*)malloc(sizeof(int32)*size);
+ tmp = (FLAC__int32*)malloc(sizeof(FLAC__int32)*size);
if(tmp == 0) {
decoder->protected->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
return false;
}
decoder->private->output[i] = tmp;
- tmp = (int32*)malloc(sizeof(int32)*size);
+ tmp = (FLAC__int32*)malloc(sizeof(FLAC__int32)*size);
if(tmp == 0) {
decoder->protected->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
return false;
return true;
}
-bool stream_decoder_find_metadata_(FLAC__StreamDecoder *decoder)
+FLAC__bool stream_decoder_find_metadata_(FLAC__StreamDecoder *decoder)
{
- uint32 x;
+ FLAC__uint32 x;
unsigned i, id;
- bool first = true;
+ FLAC__bool first = true;
FLAC__ASSERT(decoder->private->input.consumed_bits == 0); /* make sure we're byte aligned */
for(i = id = 0; i < 4; ) {
if(decoder->private->cached) {
- x = (uint32)decoder->private->lookahead;
+ x = (FLAC__uint32)decoder->private->lookahead;
decoder->private->cached = false;
}
else {
continue;
}
if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private->header_warmup[0] = (byte)x;
+ decoder->private->header_warmup[0] = (FLAC__byte)x;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
/* we have to check if we just read two 0xff's in a row; the second may actually be the beginning of the sync code */
/* else we have to check if the second byte is the end of a sync code */
if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private->lookahead = (byte)x;
+ decoder->private->lookahead = (FLAC__byte)x;
decoder->private->cached = true;
}
else if(x >> 2 == 0x3e) { /* MAGIC NUMBER for the last 6 sync bits */
- decoder->private->header_warmup[1] = (byte)x;
+ decoder->private->header_warmup[1] = (FLAC__byte)x;
decoder->protected->state = FLAC__STREAM_DECODER_READ_FRAME;
return true;
}
return true;
}
-bool stream_decoder_read_metadata_(FLAC__StreamDecoder *decoder)
+FLAC__bool stream_decoder_read_metadata_(FLAC__StreamDecoder *decoder)
{
- uint32 i, x, last_block, type, length;
- uint64 xx;
+ FLAC__uint32 i, x, last_block, type, length;
+ FLAC__uint64 xx;
FLAC__ASSERT(decoder->private->input.consumed_bits == 0); /* make sure we're byte aligned */
for(i = 0; i < 16; i++) {
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- decoder->private->stream_info.data.stream_info.md5sum[i] = (byte)x;
+ decoder->private->stream_info.data.stream_info.md5sum[i] = (FLAC__byte)x;
}
used_bits += i*8;
return true;
}
-bool stream_decoder_skip_id3v2_tag_(FLAC__StreamDecoder *decoder)
+FLAC__bool stream_decoder_skip_id3v2_tag_(FLAC__StreamDecoder *decoder)
{
- uint32 x;
+ FLAC__uint32 x;
unsigned i, skip;
/* skip the version and flags bytes */
return true;
}
-bool stream_decoder_frame_sync_(FLAC__StreamDecoder *decoder)
+FLAC__bool stream_decoder_frame_sync_(FLAC__StreamDecoder *decoder)
{
- uint32 x;
- bool first = true;
+ FLAC__uint32 x;
+ FLAC__bool first = true;
/* If we know the total number of samples in the stream, stop if we've read that many. */
/* This will stop us, for example, from wasting time trying to sync on an ID3V1 tag. */
while(1) {
if(decoder->private->cached) {
- x = (uint32)decoder->private->lookahead;
+ x = (FLAC__uint32)decoder->private->lookahead;
decoder->private->cached = false;
}
else {
return false; /* the read_callback_ sets the state for us */
}
if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private->header_warmup[0] = (byte)x;
+ decoder->private->header_warmup[0] = (FLAC__byte)x;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
/* we have to check if we just read two 0xff's in a row; the second may actually be the beginning of the sync code */
/* else we have to check if the second byte is the end of a sync code */
if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private->lookahead = (byte)x;
+ decoder->private->lookahead = (FLAC__byte)x;
decoder->private->cached = true;
}
else if(x >> 2 == 0x3e) { /* MAGIC NUMBER for the last 6 sync bits */
- decoder->private->header_warmup[1] = (byte)x;
+ decoder->private->header_warmup[1] = (FLAC__byte)x;
decoder->protected->state = FLAC__STREAM_DECODER_READ_FRAME;
return true;
}
return true;
}
-bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame)
+FLAC__bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, FLAC__bool *got_a_frame)
{
unsigned channel;
unsigned i;
- int32 mid, side, left, right;
- uint16 frame_crc; /* the one we calculate from the input stream */
- uint32 x;
+ FLAC__int32 mid, side, left, right;
+ FLAC__uint16 frame_crc; /* the one we calculate from the input stream */
+ FLAC__uint32 x;
*got_a_frame = false;
frame_crc = decoder->private->input.read_crc16;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, FLAC__FRAME_FOOTER_CRC_LEN, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- if(frame_crc == (uint16)x) {
+ if(frame_crc == (FLAC__uint16)x) {
/* Undo any special channel coding */
switch(decoder->private->frame.header.channel_assignment) {
case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
/* Bad frame, emit error and zero the output signal */
decoder->private->error_callback(decoder, FLAC__STREAM_DECODER_ERROR_FRAME_CRC_MISMATCH, decoder->private->client_data);
for(channel = 0; channel < decoder->private->frame.header.channels; channel++) {
- memset(decoder->private->output[channel], 0, sizeof(int32) * decoder->private->frame.header.blocksize);
+ memset(decoder->private->output[channel], 0, sizeof(FLAC__int32) * decoder->private->frame.header.blocksize);
}
}
return true;
}
-bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder)
+FLAC__bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder)
{
- uint32 x;
- uint64 xx;
+ FLAC__uint32 x;
+ FLAC__uint64 xx;
unsigned i, blocksize_hint = 0, sample_rate_hint = 0;
- byte crc8, raw_header[16]; /* MAGIC NUMBER based on the maximum frame header size, including CRC */
+ FLAC__byte crc8, raw_header[16]; /* MAGIC NUMBER based on the maximum frame header size, including CRC */
unsigned raw_header_len;
- bool is_unparseable = false;
- const bool is_known_variable_blocksize_stream = (decoder->private->has_stream_info && decoder->private->stream_info.data.stream_info.min_blocksize != decoder->private->stream_info.data.stream_info.max_blocksize);
- const bool is_known_fixed_blocksize_stream = (decoder->private->has_stream_info && decoder->private->stream_info.data.stream_info.min_blocksize == decoder->private->stream_info.data.stream_info.max_blocksize);
+ FLAC__bool is_unparseable = false;
+ const FLAC__bool is_known_variable_blocksize_stream = (decoder->private->has_stream_info && decoder->private->stream_info.data.stream_info.min_blocksize != decoder->private->stream_info.data.stream_info.max_blocksize);
+ const FLAC__bool is_known_fixed_blocksize_stream = (decoder->private->has_stream_info && decoder->private->stream_info.data.stream_info.min_blocksize == decoder->private->stream_info.data.stream_info.max_blocksize);
FLAC__ASSERT(decoder->private->input.consumed_bits == 0); /* make sure we're byte aligned */
return false; /* the read_callback_ sets the state for us */
if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
/* if we get here it means our original sync was erroneous since the sync code cannot appear in the header */
- decoder->private->lookahead = (byte)x;
+ decoder->private->lookahead = (FLAC__byte)x;
decoder->private->cached = true;
decoder->private->error_callback(decoder, FLAC__STREAM_DECODER_ERROR_BAD_HEADER, decoder->private->client_data);
decoder->protected->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
return true;
}
- raw_header[raw_header_len++] = (byte)x;
+ raw_header[raw_header_len++] = (FLAC__byte)x;
}
switch(x = raw_header[2] >> 4) {
}
decoder->private->last_frame_number = x;
if(decoder->private->has_stream_info) {
- decoder->private->frame.header.number.sample_number = (int64)decoder->private->stream_info.data.stream_info.min_blocksize * (int64)x;
+ decoder->private->frame.header.number.sample_number = (FLAC__int64)decoder->private->stream_info.data.stream_info.min_blocksize * (FLAC__int64)x;
}
else {
is_unparseable = true;
if(blocksize_hint) {
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (byte)x;
+ raw_header[raw_header_len++] = (FLAC__byte)x;
if(blocksize_hint == 7) {
- uint32 _x;
+ FLAC__uint32 _x;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &_x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (byte)_x;
+ raw_header[raw_header_len++] = (FLAC__byte)_x;
x = (x << 8) | _x;
}
decoder->private->frame.header.blocksize = x+1;
if(sample_rate_hint) {
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (byte)x;
+ raw_header[raw_header_len++] = (FLAC__byte)x;
if(sample_rate_hint != 12) {
- uint32 _x;
+ FLAC__uint32 _x;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &_x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (byte)_x;
+ raw_header[raw_header_len++] = (FLAC__byte)_x;
x = (x << 8) | _x;
}
if(sample_rate_hint == 12)
/* read the CRC-8 byte */
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
- crc8 = (byte)x;
+ crc8 = (FLAC__byte)x;
if(FLAC__crc8(raw_header, raw_header_len) != crc8) {
decoder->private->error_callback(decoder, FLAC__STREAM_DECODER_ERROR_BAD_HEADER, decoder->private->client_data);
return true;
}
-bool stream_decoder_read_subframe_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps)
+FLAC__bool stream_decoder_read_subframe_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps)
{
- uint32 x;
- bool wasted_bits;
+ FLAC__uint32 x;
+ FLAC__bool wasted_bits;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &x, 8, read_callback_, decoder)) /* MAGIC NUMBER */
return false; /* the read_callback_ sets the state for us */
return true;
}
-bool stream_decoder_read_subframe_constant_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps)
+FLAC__bool stream_decoder_read_subframe_constant_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps)
{
FLAC__Subframe_Constant *subframe = &decoder->private->frame.subframes[channel].data.constant;
- int32 x;
+ FLAC__int32 x;
unsigned i;
- int32 *output = decoder->private->output[channel];
+ FLAC__int32 *output = decoder->private->output[channel];
decoder->private->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT;
return true;
}
-bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order)
+FLAC__bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order)
{
FLAC__Subframe_Fixed *subframe = &decoder->private->frame.subframes[channel].data.fixed;
- int32 i32;
- uint32 u32;
+ FLAC__int32 i32;
+ FLAC__uint32 u32;
unsigned u;
decoder->private->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_FIXED;
}
/* decode the subframe */
- memcpy(decoder->private->output[channel], subframe->warmup, sizeof(int32) * order);
+ memcpy(decoder->private->output[channel], subframe->warmup, sizeof(FLAC__int32) * order);
FLAC__fixed_restore_signal(decoder->private->residual[channel], decoder->private->frame.header.blocksize-order, order, decoder->private->output[channel]+order);
return true;
}
-bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order)
+FLAC__bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps, const unsigned order)
{
FLAC__Subframe_LPC *subframe = &decoder->private->frame.subframes[channel].data.lpc;
- int32 i32;
- uint32 u32;
+ FLAC__int32 i32;
+ FLAC__uint32 u32;
unsigned u;
decoder->private->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_LPC;
}
/* decode the subframe */
- memcpy(decoder->private->output[channel], subframe->warmup, sizeof(int32) * order);
+ memcpy(decoder->private->output[channel], subframe->warmup, sizeof(FLAC__int32) * order);
if(bps <= 16 && subframe->qlp_coeff_precision <= 16)
decoder->private->local_lpc_restore_signal_16bit(decoder->private->residual[channel], decoder->private->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private->output[channel]+order);
else
return true;
}
-bool stream_decoder_read_subframe_verbatim_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps)
+FLAC__bool stream_decoder_read_subframe_verbatim_(FLAC__StreamDecoder *decoder, unsigned channel, unsigned bps)
{
FLAC__Subframe_Verbatim *subframe = &decoder->private->frame.subframes[channel].data.verbatim;
- int32 x, *residual = decoder->private->residual[channel];
+ FLAC__int32 x, *residual = decoder->private->residual[channel];
unsigned i;
decoder->private->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM;
}
/* decode the subframe */
- memcpy(decoder->private->output[channel], subframe->data, sizeof(int32) * decoder->private->frame.header.blocksize);
+ memcpy(decoder->private->output[channel], subframe->data, sizeof(FLAC__int32) * decoder->private->frame.header.blocksize);
return true;
}
-bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order, int32 *residual)
+FLAC__bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order, FLAC__int32 *residual)
{
- uint32 rice_parameter;
+ FLAC__uint32 rice_parameter;
int i;
unsigned partition, sample, u;
const unsigned partitions = 1u << partition_order;
return true;
}
-bool stream_decoder_read_zero_padding_(FLAC__StreamDecoder *decoder)
+FLAC__bool stream_decoder_read_zero_padding_(FLAC__StreamDecoder *decoder)
{
if(decoder->private->input.consumed_bits != 0) {
- uint32 zero = 0;
+ FLAC__uint32 zero = 0;
if(!FLAC__bitbuffer_read_raw_uint32(&decoder->private->input, &zero, 8-decoder->private->input.consumed_bits, read_callback_, decoder))
return false; /* the read_callback_ sets the state for us */
if(zero != 0) {
return true;
}
-bool read_callback_(byte buffer[], unsigned *bytes, void *client_data)
+FLAC__bool read_callback_(FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
FLAC__StreamDecoder *decoder = (FLAC__StreamDecoder *)client_data;
FLAC__StreamDecoderReadStatus status;
*
***********************************************************************/
-static bool stream_encoder_resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size);
-static bool stream_encoder_process_frame_(FLAC__StreamEncoder *encoder, bool is_last_frame);
-static bool stream_encoder_process_subframes_(FLAC__StreamEncoder *encoder, bool is_last_frame);
-static bool stream_encoder_process_subframe_(FLAC__StreamEncoder *encoder, unsigned min_partition_order, unsigned max_partition_order, bool verbatim_only, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const int32 integer_signal[], const real real_signal[], FLAC__Subframe *subframe[2], int32 *residual[2], unsigned *best_subframe, unsigned *best_bits);
-static bool stream_encoder_add_subframe_(FLAC__StreamEncoder *encoder, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__Subframe *subframe, FLAC__BitBuffer *frame);
-static unsigned stream_encoder_evaluate_constant_subframe_(const int32 signal, unsigned subframe_bps, FLAC__Subframe *subframe);
-static unsigned stream_encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe);
-static unsigned stream_encoder_evaluate_lpc_subframe_(FLAC__StreamEncoder *encoder, const int32 signal[], int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], const real lp_coeff[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe);
-static unsigned stream_encoder_evaluate_verbatim_subframe_(const int32 signal[], unsigned blocksize, unsigned subframe_bps, FLAC__Subframe *subframe);
-static unsigned stream_encoder_find_best_partition_order_(const int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, unsigned *best_partition_order, unsigned best_parameters[], unsigned best_raw_bits[]);
+static FLAC__bool stream_encoder_resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size);
+static FLAC__bool stream_encoder_process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
+static FLAC__bool stream_encoder_process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
+static FLAC__bool stream_encoder_process_subframe_(FLAC__StreamEncoder *encoder, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool verbatim_only, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__int32 integer_signal[], const FLAC__real real_signal[], FLAC__Subframe *subframe[2], FLAC__int32 *residual[2], unsigned *best_subframe, unsigned *best_bits);
+static FLAC__bool stream_encoder_add_subframe_(FLAC__StreamEncoder *encoder, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__Subframe *subframe, FLAC__BitBuffer *frame);
+static unsigned stream_encoder_evaluate_constant_subframe_(const FLAC__int32 signal, unsigned subframe_bps, FLAC__Subframe *subframe);
+static unsigned stream_encoder_evaluate_fixed_subframe_(const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe);
+static unsigned stream_encoder_evaluate_lpc_subframe_(FLAC__StreamEncoder *encoder, const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], const FLAC__real lp_coeff[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe);
+static unsigned stream_encoder_evaluate_verbatim_subframe_(const FLAC__int32 signal[], unsigned blocksize, unsigned subframe_bps, FLAC__Subframe *subframe);
+static unsigned stream_encoder_find_best_partition_order_(const FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, unsigned *best_partition_order, unsigned best_parameters[], unsigned best_raw_bits[]);
#if (defined FLAC__PRECOMPUTE_PARTITION_SUMS) || (defined FLAC__SEARCH_FOR_ESCAPES)
-static unsigned stream_encoder_precompute_partition_info_(const int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order);
+static unsigned stream_encoder_precompute_partition_info_(const FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order);
#endif
-static bool stream_encoder_set_partitioned_rice_(const uint32 abs_residual[], const uint32 abs_residual_partition_sums[], const unsigned raw_bits_per_partition[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, unsigned parameters[], unsigned raw_bits[], unsigned *bits);
-static unsigned stream_encoder_get_wasted_bits_(int32 signal[], unsigned samples);
+static FLAC__bool stream_encoder_set_partitioned_rice_(const FLAC__uint32 abs_residual[], const FLAC__uint32 abs_residual_partition_sums[], const unsigned raw_bits_per_partition[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, unsigned parameters[], unsigned raw_bits[], unsigned *bits);
+static unsigned stream_encoder_get_wasted_bits_(FLAC__int32 signal[], unsigned samples);
/***********************************************************************
*
typedef struct FLAC__StreamEncoderPrivate {
unsigned input_capacity; /* current size (in samples) of the signal and residual buffers */
- int32 *integer_signal[FLAC__MAX_CHANNELS]; /* the integer version of the input signal */
- int32 *integer_signal_mid_side[2]; /* the integer version of the mid-side input signal (stereo only) */
- real *real_signal[FLAC__MAX_CHANNELS]; /* the floating-point version of the input signal */
- real *real_signal_mid_side[2]; /* the floating-point version of the mid-side input signal (stereo only) */
+ FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS]; /* the integer version of the input signal */
+ FLAC__int32 *integer_signal_mid_side[2]; /* the integer version of the mid-side input signal (stereo only) */
+ FLAC__real *real_signal[FLAC__MAX_CHANNELS]; /* the floating-point version of the input signal */
+ FLAC__real *real_signal_mid_side[2]; /* the floating-point version of the mid-side input signal (stereo only) */
unsigned subframe_bps[FLAC__MAX_CHANNELS]; /* the effective bits per sample of the input signal (stream bps - wasted bits) */
unsigned subframe_bps_mid_side[2]; /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */
- int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
- int32 *residual_workspace_mid_side[2][2];
+ FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
+ FLAC__int32 *residual_workspace_mid_side[2][2];
FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2];
FLAC__Subframe subframe_workspace_mid_side[2][2];
FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2];
unsigned best_subframe_mid_side[2];
unsigned best_subframe_bits[FLAC__MAX_CHANNELS]; /* size in bits of the best subframe for each channel */
unsigned best_subframe_bits_mid_side[2];
- uint32 *abs_residual; /* workspace where abs(candidate residual) is stored */
- uint32 *abs_residual_partition_sums; /* workspace where the sum of abs(candidate residual) for each partition is stored */
+ FLAC__uint32 *abs_residual; /* workspace where abs(candidate residual) is stored */
+ FLAC__uint32 *abs_residual_partition_sums; /* workspace where the sum of abs(candidate residual) for each partition is stored */
unsigned *raw_bits_per_partition; /* workspace where the sum of silog2(candidate residual) for each partition is stored */
FLAC__BitBuffer frame; /* the current frame being worked on */
double loose_mid_side_stereo_frames_exact; /* exact number of frames the encoder will use before trying both independent and mid/side frames again */
unsigned current_frame_number;
struct MD5Context md5context;
FLAC__CPUInfo cpuinfo;
- unsigned (*local_fixed_compute_best_predictor)(const int32 data[], unsigned data_len, real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
- void (*local_lpc_compute_autocorrelation)(const real data[], unsigned data_len, unsigned lag, real autoc[]);
- void (*local_lpc_compute_residual_from_qlp_coefficients)(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[]);
- void (*local_lpc_compute_residual_from_qlp_coefficients_16bit)(const int32 data[], unsigned data_len, const int32 qlp_coeff[], unsigned order, int lp_quantization, int32 residual[]);
- bool use_slow; /* use slow 64-bit versions of some functions */
- FLAC__StreamEncoderWriteStatus (*write_callback)(const FLAC__StreamEncoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
+ unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
+ void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
+ void (*local_lpc_compute_residual_from_qlp_coefficients)(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
+ void (*local_lpc_compute_residual_from_qlp_coefficients_16bit)(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
+ FLAC__bool use_slow; /* use slow 64-bit versions of some functions */
+ FLAC__StreamEncoderWriteStatus (*write_callback)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
void (*metadata_callback)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data);
void *client_data;
/* unaligned (original) pointers to allocated data */
- int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS];
- int32 *integer_signal_mid_side_unaligned[2];
- real *real_signal_unaligned[FLAC__MAX_CHANNELS];
- real *real_signal_mid_side_unaligned[2];
- int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2];
- int32 *residual_workspace_mid_side_unaligned[2][2];
- uint32 *abs_residual_unaligned;
- uint32 *abs_residual_partition_sums_unaligned;
+ FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS];
+ FLAC__int32 *integer_signal_mid_side_unaligned[2];
+ FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS];
+ FLAC__real *real_signal_mid_side_unaligned[2];
+ FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2];
+ FLAC__int32 *residual_workspace_mid_side_unaligned[2][2];
+ FLAC__uint32 *abs_residual_unaligned;
+ FLAC__uint32 *abs_residual_partition_sums_unaligned;
unsigned *raw_bits_per_partition_unaligned;
} FLAC__StreamEncoderPrivate;
encoder->protected->qlp_coeff_precision = 13;
}
else {
- encoder->protected->qlp_coeff_precision = min(13, 8*sizeof(int32) - encoder->protected->bits_per_sample - 1);
+ encoder->protected->qlp_coeff_precision = min(13, 8*sizeof(FLAC__int32) - encoder->protected->bits_per_sample - 1);
}
}
- else if(encoder->protected->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected->qlp_coeff_precision + encoder->protected->bits_per_sample >= 8*sizeof(uint32) || encoder->protected->qlp_coeff_precision >= (1u<<FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
+ else if(encoder->protected->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected->qlp_coeff_precision + encoder->protected->bits_per_sample >= 8*sizeof(FLAC__uint32) || encoder->protected->qlp_coeff_precision >= (1u<<FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
return encoder->protected->state = FLAC__STREAM_ENCODER_INVALID_QLP_COEFF_PRECISION;
if(encoder->protected->streamable_subset) {
encoder->protected->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
}
-bool FLAC__stream_encoder_set_streamable_subset(const FLAC__StreamEncoder *encoder, bool value)
+FLAC__bool FLAC__stream_encoder_set_streamable_subset(const FLAC__StreamEncoder *encoder, FLAC__bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_do_mid_side_stereo(const FLAC__StreamEncoder *encoder, bool value)
+FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(const FLAC__StreamEncoder *encoder, FLAC__bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder, bool value)
+FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder, FLAC__bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_channels(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_channels(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_bits_per_sample(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_bits_per_sample(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_sample_rate(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_sample_rate(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_blocksize(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_blocksize(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_max_lpc_order(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_max_lpc_order(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_qlp_coeff_precision(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder, bool value)
+FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder, FLAC__bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder, bool value)
+FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder, FLAC__bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_min_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_max_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_total_samples_estimate(const FLAC__StreamEncoder *encoder, uint64 value)
+FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(const FLAC__StreamEncoder *encoder, FLAC__uint64 value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_seek_table(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData_SeekTable *value)
+FLAC__bool FLAC__stream_encoder_set_seek_table(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData_SeekTable *value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_padding(const FLAC__StreamEncoder *encoder, unsigned value)
+FLAC__bool FLAC__stream_encoder_set_padding(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_last_metadata_is_last(const FLAC__StreamEncoder *encoder, bool value)
+FLAC__bool FLAC__stream_encoder_set_last_metadata_is_last(const FLAC__StreamEncoder *encoder, FLAC__bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_write_callback(const FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteStatus (*value)(const FLAC__StreamEncoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data))
+FLAC__bool FLAC__stream_encoder_set_write_callback(const FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteStatus (*value)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data))
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_metadata_callback(const FLAC__StreamEncoder *encoder, void (*value)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data))
+FLAC__bool FLAC__stream_encoder_set_metadata_callback(const FLAC__StreamEncoder *encoder, void (*value)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data))
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return true;
}
-bool FLAC__stream_encoder_set_client_data(const FLAC__StreamEncoder *encoder, void *value)
+FLAC__bool FLAC__stream_encoder_set_client_data(const FLAC__StreamEncoder *encoder, void *value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
return encoder->protected->state;
}
-bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
+FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->streamable_subset;
}
-bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
+FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->do_mid_side_stereo;
}
-bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
+FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->loose_mid_side_stereo;
}
return encoder->protected->qlp_coeff_precision;
}
-bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
+FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->do_qlp_coeff_prec_search;
}
-bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
+FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->do_exhaustive_model_search;
}
return encoder->protected->rice_parameter_search_dist;
}
-bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const int32 *buf[], unsigned samples)
+FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 *buf[], unsigned samples)
{
unsigned i, j, channel;
- int32 x, mid, side;
+ FLAC__int32 x, mid, side;
const unsigned channels = encoder->protected->channels, blocksize = encoder->protected->blocksize;
FLAC__ASSERT(encoder != 0);
for(i = encoder->private->current_sample_number; i < blocksize && j < samples; i++, j++) {
x = mid = side = buf[0][j];
encoder->private->integer_signal[0][i] = x;
- encoder->private->real_signal[0][i] = (real)x;
+ encoder->private->real_signal[0][i] = (FLAC__real)x;
x = buf[1][j];
encoder->private->integer_signal[1][i] = x;
- encoder->private->real_signal[1][i] = (real)x;
+ encoder->private->real_signal[1][i] = (FLAC__real)x;
mid += x;
side -= x;
mid >>= 1; /* NOTE: not the same as 'mid = (buf[0][j] + buf[1][j]) / 2' ! */
encoder->private->integer_signal_mid_side[1][i] = side;
encoder->private->integer_signal_mid_side[0][i] = mid;
- encoder->private->real_signal_mid_side[1][i] = (real)side;
- encoder->private->real_signal_mid_side[0][i] = (real)mid;
+ encoder->private->real_signal_mid_side[1][i] = (FLAC__real)side;
+ encoder->private->real_signal_mid_side[0][i] = (FLAC__real)mid;
encoder->private->current_sample_number++;
}
if(i == blocksize) {
for(channel = 0; channel < channels; channel++) {
x = buf[channel][j];
encoder->private->integer_signal[channel][i] = x;
- encoder->private->real_signal[channel][i] = (real)x;
+ encoder->private->real_signal[channel][i] = (FLAC__real)x;
}
encoder->private->current_sample_number++;
}
}
/* 'samples' is channel-wide samples, e.g. for 1 second at 44100Hz, 'samples' = 44100 regardless of the number of channels */
-bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const int32 buf[], unsigned samples)
+FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buf[], unsigned samples)
{
unsigned i, j, k, channel;
- int32 x, mid, side;
+ FLAC__int32 x, mid, side;
const unsigned channels = encoder->protected->channels, blocksize = encoder->protected->blocksize;
FLAC__ASSERT(encoder != 0);
for(i = encoder->private->current_sample_number; i < blocksize && j < samples; i++, j++) {
x = mid = side = buf[k++];
encoder->private->integer_signal[0][i] = x;
- encoder->private->real_signal[0][i] = (real)x;
+ encoder->private->real_signal[0][i] = (FLAC__real)x;
x = buf[k++];
encoder->private->integer_signal[1][i] = x;
- encoder->private->real_signal[1][i] = (real)x;
+ encoder->private->real_signal[1][i] = (FLAC__real)x;
mid += x;
side -= x;
mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
encoder->private->integer_signal_mid_side[1][i] = side;
encoder->private->integer_signal_mid_side[0][i] = mid;
- encoder->private->real_signal_mid_side[1][i] = (real)side;
- encoder->private->real_signal_mid_side[0][i] = (real)mid;
+ encoder->private->real_signal_mid_side[1][i] = (FLAC__real)side;
+ encoder->private->real_signal_mid_side[0][i] = (FLAC__real)mid;
encoder->private->current_sample_number++;
}
if(i == blocksize) {
for(channel = 0; channel < channels; channel++) {
x = buf[k++];
encoder->private->integer_signal[channel][i] = x;
- encoder->private->real_signal[channel][i] = (real)x;
+ encoder->private->real_signal[channel][i] = (FLAC__real)x;
}
encoder->private->current_sample_number++;
}
return true;
}
-bool stream_encoder_resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size)
+FLAC__bool stream_encoder_resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size)
{
- bool ok;
+ FLAC__bool ok;
unsigned i, channel;
FLAC__ASSERT(new_size > 0);
*
***********************************************************************/
-bool stream_encoder_process_frame_(FLAC__StreamEncoder *encoder, bool is_last_frame)
+FLAC__bool stream_encoder_process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame)
{
FLAC__ASSERT(encoder->protected->state == FLAC__STREAM_ENCODER_OK);
*/
encoder->private->current_sample_number = 0;
encoder->private->current_frame_number++;
- encoder->private->metadata.data.stream_info.total_samples += (uint64)encoder->protected->blocksize;
+ encoder->private->metadata.data.stream_info.total_samples += (FLAC__uint64)encoder->protected->blocksize;
encoder->private->metadata.data.stream_info.min_framesize = min(encoder->private->frame.bytes, encoder->private->metadata.data.stream_info.min_framesize);
encoder->private->metadata.data.stream_info.max_framesize = max(encoder->private->frame.bytes, encoder->private->metadata.data.stream_info.max_framesize);
return true;
}
-bool stream_encoder_process_subframes_(FLAC__StreamEncoder *encoder, bool is_last_frame)
+FLAC__bool stream_encoder_process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame)
{
FLAC__FrameHeader frame_header;
unsigned channel, min_partition_order = encoder->protected->min_residual_partition_order, max_partition_order;
- bool do_independent, do_mid_side;
+ FLAC__bool do_independent, do_mid_side;
/*
* Calculate the min,max Rice partition orders
return true;
}
-bool stream_encoder_process_subframe_(FLAC__StreamEncoder *encoder, unsigned min_partition_order, unsigned max_partition_order, bool verbatim_only, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const int32 integer_signal[], const real real_signal[], FLAC__Subframe *subframe[2], int32 *residual[2], unsigned *best_subframe, unsigned *best_bits)
+FLAC__bool stream_encoder_process_subframe_(FLAC__StreamEncoder *encoder, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool verbatim_only, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__int32 integer_signal[], const FLAC__real real_signal[], FLAC__Subframe *subframe[2], FLAC__int32 *residual[2], unsigned *best_subframe, unsigned *best_bits)
{
- real fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
- real lpc_residual_bits_per_sample;
- real autoc[FLAC__MAX_LPC_ORDER+1]; /* WATCHOUT: the size is important even though encoder->protected->max_lpc_order might be less; some asm routines need all the space */
- real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER];
- real lpc_error[FLAC__MAX_LPC_ORDER];
+ FLAC__real fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
+ FLAC__real lpc_residual_bits_per_sample;
+ FLAC__real autoc[FLAC__MAX_LPC_ORDER+1]; /* WATCHOUT: the size is important even though encoder->protected->max_lpc_order might be less; some asm routines need all the space */
+ FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER];
+ FLAC__real lpc_error[FLAC__MAX_LPC_ORDER];
unsigned min_lpc_order, max_lpc_order, lpc_order;
unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order;
unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision;
min_fixed_order = max_fixed_order = guess_fixed_order;
}
for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) {
- if(fixed_residual_bits_per_sample[fixed_order] >= (real)subframe_bps)
+ if(fixed_residual_bits_per_sample[fixed_order] >= (FLAC__real)subframe_bps)
continue; /* don't even try */
rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > 0.0)? (unsigned)(fixed_residual_bits_per_sample[fixed_order]+0.5) : 0; /* 0.5 is for rounding */
#ifndef FLAC__SYMMETRIC_RICE
}
for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) {
lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order);
- if(lpc_residual_bits_per_sample >= (real)subframe_bps)
+ if(lpc_residual_bits_per_sample >= (FLAC__real)subframe_bps)
continue; /* don't even try */
rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+0.5) : 0; /* 0.5 is for rounding */
#ifndef FLAC__SYMMETRIC_RICE
return true;
}
-bool stream_encoder_add_subframe_(FLAC__StreamEncoder *encoder, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__Subframe *subframe, FLAC__BitBuffer *frame)
+FLAC__bool stream_encoder_add_subframe_(FLAC__StreamEncoder *encoder, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__Subframe *subframe, FLAC__BitBuffer *frame)
{
switch(subframe->type) {
case FLAC__SUBFRAME_TYPE_CONSTANT:
return true;
}
-unsigned stream_encoder_evaluate_constant_subframe_(const int32 signal, unsigned subframe_bps, FLAC__Subframe *subframe)
+unsigned stream_encoder_evaluate_constant_subframe_(const FLAC__int32 signal, unsigned subframe_bps, FLAC__Subframe *subframe)
{
subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT;
subframe->data.constant.value = signal;
return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe_bps;
}
-unsigned stream_encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe)
+unsigned stream_encoder_evaluate_fixed_subframe_(const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe)
{
unsigned i, residual_bits;
const unsigned residual_samples = blocksize - order;
return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (order * subframe_bps) + residual_bits;
}
-unsigned stream_encoder_evaluate_lpc_subframe_(FLAC__StreamEncoder *encoder, const int32 signal[], int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], const real lp_coeff[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe)
+unsigned stream_encoder_evaluate_lpc_subframe_(FLAC__StreamEncoder *encoder, const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], const FLAC__real lp_coeff[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe)
{
- int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
+ FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
unsigned i, residual_bits;
int quantization, ret;
const unsigned residual_samples = blocksize - order;
subframe->data.lpc.order = order;
subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision;
subframe->data.lpc.quantization_level = quantization;
- memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(int32)*FLAC__MAX_LPC_ORDER);
+ memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER);
for(i = 0; i < order; i++)
subframe->data.lpc.warmup[i] = signal[i];
return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + subframe_bps)) + residual_bits;
}
-unsigned stream_encoder_evaluate_verbatim_subframe_(const int32 signal[], unsigned blocksize, unsigned subframe_bps, FLAC__Subframe *subframe)
+unsigned stream_encoder_evaluate_verbatim_subframe_(const FLAC__int32 signal[], unsigned blocksize, unsigned subframe_bps, FLAC__Subframe *subframe)
{
subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM;
return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (blocksize * subframe_bps);
}
-unsigned stream_encoder_find_best_partition_order_(const int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, unsigned *best_partition_order, unsigned best_parameters[], unsigned best_raw_bits[])
+unsigned stream_encoder_find_best_partition_order_(const FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, unsigned rice_parameter_search_dist, unsigned *best_partition_order, unsigned best_parameters[], unsigned best_raw_bits[])
{
- int32 r;
+ FLAC__int32 r;
#if (defined FLAC__PRECOMPUTE_PARTITION_SUMS) || (defined FLAC__SEARCH_FOR_ESCAPES)
unsigned sum;
int partition_order;
/* compute abs(residual) for use later */
for(residual_sample = 0; residual_sample < residual_samples; residual_sample++) {
r = residual[residual_sample];
- abs_residual[residual_sample] = (uint32)(r<0? -r : r);
+ abs_residual[residual_sample] = (FLAC__uint32)(r<0? -r : r);
}
#if (defined FLAC__PRECOMPUTE_PARTITION_SUMS) || (defined FLAC__SEARCH_FOR_ESCAPES)
}
#if (defined FLAC__PRECOMPUTE_PARTITION_SUMS) || (defined FLAC__SEARCH_FOR_ESCAPES)
-unsigned stream_encoder_precompute_partition_info_(const int32 residual[], uint32 abs_residual[], uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order)
+unsigned stream_encoder_precompute_partition_info_(const FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint32 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order)
{
int partition_order;
unsigned from_partition, to_partition = 0;
/* first do max_partition_order */
for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) {
#ifdef FLAC__PRECOMPUTE_PARTITION_SUMS
- uint32 abs_residual_partition_sum;
+ FLAC__uint32 abs_residual_partition_sum;
#endif
#ifdef FLAC__SEARCH_FOR_ESCAPES
- uint32 abs_residual_partition_max;
+ FLAC__uint32 abs_residual_partition_max;
unsigned abs_residual_partition_max_index = 0; /* initialized to silence superfluous compiler warning */
#endif
- uint32 abs_r;
+ FLAC__uint32 abs_r;
unsigned partition, partition_sample, partition_samples, residual_sample;
const unsigned partitions = 1u << partition_order;
const unsigned default_partition_samples = blocksize >> partition_order;
/* now merge for lower orders */
for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) {
#ifdef FLAC__PRECOMPUTE_PARTITION_SUMS
- uint32 s;
+ FLAC__uint32 s;
#endif
#ifdef FLAC__SEARCH_FOR_ESCAPES
unsigned m;
#endif
#define VARIABLE_RICE_BITS(value, parameter) ((value) >> (parameter))
-bool stream_encoder_set_partitioned_rice_(const uint32 abs_residual[], const uint32 abs_residual_partition_sums[], const unsigned raw_bits_per_partition[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, unsigned parameters[], unsigned raw_bits[], unsigned *bits)
+FLAC__bool stream_encoder_set_partitioned_rice_(const FLAC__uint32 abs_residual[], const FLAC__uint32 abs_residual_partition_sums[], const unsigned raw_bits_per_partition[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, unsigned parameters[], unsigned raw_bits[], unsigned *bits)
{
unsigned rice_parameter, partition_bits;
#ifndef NO_RICE_SEARCH
return true;
}
-unsigned stream_encoder_get_wasted_bits_(int32 signal[], unsigned samples)
+unsigned stream_encoder_get_wasted_bits_(FLAC__int32 signal[], unsigned samples)
{
unsigned i, shift;
- int32 x = 0;
+ FLAC__int32 x = 0;
for(i = 0; i < samples && !(x&1); i++)
x |= signal[i];
#endif
#define max(x,y) ((x)>(y)?(x):(y))
-static bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method);
-static bool subframe_add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order);
+static FLAC__bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method);
+static FLAC__bool subframe_add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order);
-bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuffer *bb)
+FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuffer *bb)
{
unsigned i;
return true;
}
-bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_subset, bool is_last_block, FLAC__BitBuffer *bb)
+FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__bool streamable_subset, FLAC__bool is_last_block, FLAC__BitBuffer *bb)
{
unsigned u, crc8_start, blocksize_hint, sample_rate_hint;
- byte crc8;
+ FLAC__byte crc8;
FLAC__ASSERT(bb->bits == 0); /* assert that we're byte-aligned before writing */
return true;
}
-bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
+FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
{
- bool ok;
+ FLAC__bool ok;
ok =
FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN) &&
return ok;
}
-bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
+FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
{
unsigned i;
return true;
}
-bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
+FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
{
unsigned i;
return true;
}
-bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
+FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
{
unsigned i;
- const int32 *signal = subframe->data;
+ const FLAC__int32 *signal = subframe->data;
if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
return false;
return true;
}
-bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method)
+FLAC__bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method)
{
if(!FLAC__bitbuffer_write_raw_uint32(bb, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
return false;
return true;
}
-bool subframe_add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order)
+FLAC__bool subframe_add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order)
{
if(partition_order == 0) {
unsigned i;
static const unsigned SEEKPOINT_LEN_ = 18; /* DUPLICATE:FLAC__STREAM_METADATA_SEEKPOINT_LEN */
static int usage(const char *message, ...);
-static bool list(FILE *f, bool verbose);
-static uint32 unpack_uint32(byte *b, unsigned bytes);
-static uint64 unpack_uint64(byte *b, unsigned bytes);
-static void hexdump(const byte *buf, unsigned bytes);
+static FLAC__bool list(FILE *f, FLAC__bool verbose);
+static FLAC__uint32 unpack_uint32(FLAC__byte *b, unsigned bytes);
+static FLAC__uint64 unpack_uint64(FLAC__byte *b, unsigned bytes);
+static void hexdump(const FLAC__byte *buf, unsigned bytes);
int main(int argc, char *argv[])
{
int i;
- bool verbose = false, list_mode = true;
+ FLAC__bool verbose = false, list_mode = true;
if(argc <= 1)
return usage(0);
return 1;
}
-bool list(FILE *f, bool verbose)
+FLAC__bool list(FILE *f, FLAC__bool verbose)
{
- byte buf[65536];
- byte *b = buf;
+ FLAC__byte buf[65536];
+ FLAC__byte *b = buf;
FLAC__StreamMetaData metadata;
unsigned blocknum = 0, byte_offset = 0, i;
metadata.data.stream_info.sample_rate = (unpack_uint32(b, 2) << 4) | ((unsigned)(b[2] & 0xf0) >> 4);
metadata.data.stream_info.channels = (unsigned)((b[2] & 0x0e) >> 1) + 1;
metadata.data.stream_info.bits_per_sample = ((((unsigned)(b[2] & 0x01)) << 1) | (((unsigned)(b[3] & 0xf0)) >> 4)) + 1;
- metadata.data.stream_info.total_samples = (((uint64)(b[3] & 0x0f)) << 32) | unpack_uint64(b+4, 4);
+ metadata.data.stream_info.total_samples = (((FLAC__uint64)(b[3] & 0x0f)) << 32) | unpack_uint64(b+4, 4);
memcpy(metadata.data.stream_info.md5sum, b+8, 16);
break;
case FLAC__METADATA_TYPE_PADDING:
return true;
}
-uint32 unpack_uint32(byte *b, unsigned bytes)
+FLAC__uint32 unpack_uint32(FLAC__byte *b, unsigned bytes)
{
- uint32 ret = 0;
+ FLAC__uint32 ret = 0;
unsigned i;
for(i = 0; i < bytes; i++)
- ret = (ret << 8) | (uint32)(*b++);
+ ret = (ret << 8) | (FLAC__uint32)(*b++);
return ret;
}
-uint64 unpack_uint64(byte *b, unsigned bytes)
+FLAC__uint64 unpack_uint64(FLAC__byte *b, unsigned bytes)
{
- uint64 ret = 0;
+ FLAC__uint64 ret = 0;
unsigned i;
for(i = 0; i < bytes; i++)
- ret = (ret << 8) | (uint64)(*b++);
+ ret = (ret << 8) | (FLAC__uint64)(*b++);
return ret;
}
-void hexdump(const byte *buf, unsigned bytes)
+void hexdump(const FLAC__byte *buf, unsigned bytes)
{
unsigned i, left = bytes;
- const byte *b = buf;
+ const FLAC__byte *b = buf;
for(i = 0; i < bytes; i += 16) {
printf("%08X: "
#define WM_WA_MPEG_EOF WM_USER+2
typedef struct {
- bool abort_flag;
+ FLAC__bool abort_flag;
unsigned total_samples;
unsigned bits_per_sample;
unsigned channels;
unsigned length_in_ms;
} stream_info_struct;
-static bool stream_init(const char *infilename);
-static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+static FLAC__bool stream_init(const char *infilename);
+static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
static void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
static void error_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
int decode_pos_ms; /* current decoding position, in milliseconds */
int paused; /* are we paused? */
int seek_needed; /* if != -1, it is the point that the decode thread should seek to, in ms. */
-int16 reservoir[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max channels, another *2 for overflow */
+FLAC__int16 reservoir[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max channels, another *2 for overflow */
char sample_buffer[576 * 2 * (16/8) * 2]; /* 2 for max channels, (16/8) for max bytes per sample, and 2 for who knows what */
unsigned samples_in_reservoir;
static stream_info_struct stream_info;
if (seek_needed != -1) {
const double distance = (double)seek_needed / (double)getlength();
unsigned target_sample = (unsigned)(distance * (double)stream_info.total_samples);
- if(FLAC__file_decoder_seek_absolute(decoder, (uint64)target_sample)) {
+ if(FLAC__file_decoder_seek_absolute(decoder, (FLAC__uint64)target_sample)) {
decode_pos_ms = (int)(distance * (double)getlength());
seek_needed=-1;
done=0;
/***********************************************************************
* local routines
**********************************************************************/
-bool stream_init(const char *infilename)
+FLAC__bool stream_init(const char *infilename)
{
FLAC__file_decoder_set_md5_checking(decoder, false);
FLAC__file_decoder_set_filename(decoder, infilename);
return true;
}
-FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
{
stream_info_struct *stream_info = (stream_info_struct *)client_data;
const unsigned bps = stream_info->bits_per_sample, channels = stream_info->channels, wide_samples = frame->header.blocksize;
for(sample = samples_in_reservoir*channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- reservoir[sample] = (int16)buffer[channel][wide_sample];
+ reservoir[sample] = (FLAC__int16)buffer[channel][wide_sample];
samples_in_reservoir += wide_samples;
#include "FLAC/all.h"
typedef struct {
- byte raw[128];
+ FLAC__byte raw[128];
char title[31];
char artist[31];
char album[31];
} id3v1_struct;
typedef struct {
- bool abort_flag;
- bool is_playing;
- bool eof;
+ FLAC__bool abort_flag;
+ FLAC__bool is_playing;
+ FLAC__bool eof;
unsigned total_samples;
unsigned bits_per_sample;
unsigned channels;
unsigned length_in_msec;
} file_info_struct;
-static bool get_id3v1_tag_(const char *filename, id3v1_struct *tag);
-static bool decoder_init_(const char *filename);
-static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+static FLAC__bool get_id3v1_tag_(const char *filename, id3v1_struct *tag);
+static FLAC__bool decoder_init_(const char *filename);
+static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
static void metadata_callback_(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
static void error_callback_(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
private:
id3v1_struct tag_;
FLAC__FileDecoder *decoder_;
- int16 reservoir_[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max channels, another *2 for overflow */
+ FLAC__int16 reservoir_[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max channels, another *2 for overflow */
unsigned reservoir_samples_;
file_info_struct file_info_;
- bool audio_error_;
+ FLAC__bool audio_error_;
public:
FLAC_Source();
~FLAC_Source();
inline char *GetDescription(void) { return plugin_description_; }
inline int UsesOutputFilters(void) { return 1; }
- int Open(char *url, bool *killswitch);
- int GetSamples(char *sample_buffer, int bytes, int *bps, int *nch, int *srate, bool *killswitch);
+ int Open(char *url, FLAC__bool *killswitch);
+ int GetSamples(char *sample_buffer, int bytes, int *bps, int *nch, int *srate, FLAC__bool *killswitch);
int SetPosition(int); // sets position in ms
void GetTitle(char *buf, int maxlen);
void GetInfoString(char *buf, int maxlen);
buf[maxlen-1] = 0;
}
-int FLAC_Source::Open(char *url, bool *killswitch)
+int FLAC_Source::Open(char *url, FLAC__bool *killswitch)
{
const char *filename = url; /* @@@ right now we only handle files */
return 0;
}
-int FLAC_Source::GetSamples(char *sample_buffer, int bytes, int *bps, int *nch, int *srate, bool *killswitch)
+int FLAC_Source::GetSamples(char *sample_buffer, int bytes, int *bps, int *nch, int *srate, FLAC__bool *killswitch)
{
int return_bytes = 0;
}
if(reservoir_samples_ > 0) {
unsigned i, n = min(reservoir_samples_, wide_samples), delta;
- int16 output = (int16*)sample_buffer;
+ FLAC__int16 output = (FLAC__int16*)sample_buffer;
for(i = 0; i < n*channels; i++)
output[i] = reservoir_[i];
{
const double distance = (double)position * 1000.0 / (double)file_info_.length_in_msec;
unsigned target_sample = (unsigned)(distance * (double)file_info_.total_samples);
- if(FLAC__file_decoder_seek_absolute(decoder_, (uint64)target_sample)) {
+ if(FLAC__file_decoder_seek_absolute(decoder_, (FLAC__uint64)target_sample)) {
file_info_.eof = false;
reservoir_samples_ = 0;
return 0;
* local routines
**********************************************************************/
-bool get_id3v1_tag_(const char *filename, id3v1_struct *tag)
+FLAC__bool get_id3v1_tag_(const char *filename, id3v1_struct *tag)
{
const char *temp;
FILE *f = fopen(filename, "rb");
memcpy(tag->album, tag->raw+63, 30);
memcpy(year_str, tag->raw+93, 4); year_str[4] = '\0'; tag->year = atoi(year_str);
memcpy(tag->comment, tag->raw+97, 30);
- tag->genre = (unsigned)((byte)tag->raw[127]);
- tag->track = (unsigned)((byte)tag->raw[126]);
+ tag->genre = (unsigned)((FLAC__byte)tag->raw[127]);
+ tag->track = (unsigned)((FLAC__byte)tag->raw[126]);
sprintf(tag->description, "%s - %s", tag->artist, tag->title);
}
}
-bool decoder_init_(const char *filename)
+FLAC__bool decoder_init_(const char *filename)
{
if(decoder_ == 0)
return false;
return true;
}
-FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
{
file_info_struct *file_info = (file_info_struct *)client_data;
const unsigned bps = file_info->bits_per_sample, channels = file_info->channels, wide_samples = frame->header.blocksize;
for(sample = reservoir_samples_*channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- reservoir_[sample] = (int16)buffer[channel][wide_sample];
+ reservoir_[sample] = (FLAC__int16)buffer[channel][wide_sample];
reservoir_samples_ += wide_samples;
#define min(x,y) ((x)<(y)?(x):(y))
typedef struct {
- byte raw[128];
+ FLAC__byte raw[128];
char title[31];
char artist[31];
char album[31];
} id3v1_struct;
typedef struct {
- bool abort_flag;
- bool is_playing;
- bool eof;
+ FLAC__bool abort_flag;
+ FLAC__bool is_playing;
+ FLAC__bool eof;
unsigned total_samples;
unsigned bits_per_sample;
unsigned channels;
static void FLAC_XMMS__cleanup();
static void FLAC_XMMS__get_song_info(char *filename, char **title, int *length);
-static bool get_id3v1_tag_(const char *filename, id3v1_struct *tag);
+static FLAC__bool get_id3v1_tag_(const char *filename, id3v1_struct *tag);
static void *play_loop_(void *arg);
-static bool decoder_init_(const char *filename);
-static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
+static FLAC__bool decoder_init_(const char *filename);
+static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
static void metadata_callback_(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
static void error_callback_(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
};
#define SAMPLES_PER_WRITE 512
-static byte reservoir_[FLAC__MAX_BLOCK_SIZE * 2 * 2 * 2]; /* *2 for max bytes-per-sample, *2 for max channels, another *2 for overflow */
-static byte output_[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max bytes-per-sample, *2 for max channels */
+static FLAC__byte reservoir_[FLAC__MAX_BLOCK_SIZE * 2 * 2 * 2]; /* *2 for max bytes-per-sample, *2 for max channels, another *2 for overflow */
+static FLAC__byte output_[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max bytes-per-sample, *2 for max channels */
static unsigned reservoir_samples_;
static FLAC__FileDecoder *decoder_;
static file_info_struct file_info_;
static pthread_t decode_thread_;
-static bool audio_error_ = false;
+static FLAC__bool audio_error_ = false;
InputPlugin *get_iplugin_info()
{
* local routines
**********************************************************************/
-bool get_id3v1_tag_(const char *filename, id3v1_struct *tag)
+FLAC__bool get_id3v1_tag_(const char *filename, id3v1_struct *tag)
{
const char *temp;
FILE *f = fopen(filename, "rb");
memcpy(tag->album, tag->raw+63, 30);
memcpy(year_str, tag->raw+93, 4); year_str[4] = '\0'; tag->year = atoi(year_str);
memcpy(tag->comment, tag->raw+97, 30);
- tag->genre = (unsigned)((byte)tag->raw[127]);
- tag->track = (unsigned)((byte)tag->raw[126]);
+ tag->genre = (unsigned)((FLAC__byte)tag->raw[127]);
+ tag->track = (unsigned)((FLAC__byte)tag->raw[126]);
sprintf(tag->description, "%s - %s", tag->artist, tag->title);
if (file_info_.seek_to_in_sec != -1) {
const double distance = (double)file_info_.seek_to_in_sec * 1000.0 / (double)file_info_.length_in_msec;
unsigned target_sample = (unsigned)(distance * (double)file_info_.total_samples);
- if(FLAC__file_decoder_seek_absolute(decoder_, (uint64)target_sample)) {
+ if(FLAC__file_decoder_seek_absolute(decoder_, (FLAC__uint64)target_sample)) {
flac_ip.output->flush(file_info_.seek_to_in_sec * 1000);
file_info_.seek_to_in_sec = -1;
file_info_.eof = false;
return 0; /* to silence the compiler warning about not returning a value */
}
-bool decoder_init_(const char *filename)
+FLAC__bool decoder_init_(const char *filename)
{
if(decoder_ == 0)
return false;
return true;
}
-FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
{
file_info_struct *file_info = (file_info_struct *)client_data;
const unsigned bps = file_info->bits_per_sample, channels = file_info->channels, wide_samples = frame->header.blocksize;
unsigned wide_sample, sample, channel;
- int8 *scbuffer = (int8*)reservoir_;
- int16 *ssbuffer = (int16*)reservoir_;
+ FLAC__int8 *scbuffer = (FLAC__int8*)reservoir_;
+ FLAC__int16 *ssbuffer = (FLAC__int16*)reservoir_;
(void)decoder;
if(bps == 8) {
for(sample = reservoir_samples_*channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- scbuffer[sample] = (int8)buffer[channel][wide_sample];
+ scbuffer[sample] = (FLAC__int8)buffer[channel][wide_sample];
}
else if(bps == 16) {
for(sample = reservoir_samples_*channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
- ssbuffer[sample] = (int16)buffer[channel][wide_sample];
+ ssbuffer[sample] = (FLAC__int16)buffer[channel][wide_sample];
}
else {
file_info->abort_flag = true;
static const char *mode = "w";
#endif
-static bool is_big_endian_host;
+static FLAC__bool is_big_endian_host;
-static void swap16(int16 *i)
+static void swap16(FLAC__int16 *i)
{
unsigned char *x = (unsigned char *)i, b;
if(!is_big_endian_host) {
}
}
-static void swap24(byte *x)
+static void swap24(FLAC__byte *x)
{
if(is_big_endian_host) {
x[0] = x[1];
x[2] = x[3];
}
else {
- byte b = x[0];
+ FLAC__byte b = x[0];
x[0] = x[2];
x[2] = b;
}
}
/* a mono one-sample 16bps stream */
-static bool generate_01()
+static FLAC__bool generate_01()
{
FILE *f;
- int16 x = -32768;
+ FLAC__int16 x = -32768;
if(0 == (f = fopen("test01.raw", mode)))
return false;
}
/* a stereo one-sample 16bps stream */
-static bool generate_02()
+static FLAC__bool generate_02()
{
FILE *f;
- int16 xl = -32768, xr = 32767;
+ FLAC__int16 xl = -32768, xr = 32767;
if(0 == (f = fopen("test02.raw", mode)))
return false;
}
/* a mono five-sample 16bps stream */
-static bool generate_03()
+static FLAC__bool generate_03()
{
FILE *f;
- int16 x[] = { -25, 0, 25, 50, 100 };
+ FLAC__int16 x[] = { -25, 0, 25, 50, 100 };
unsigned i;
if(0 == (f = fopen("test03.raw", mode)))
for(i = 0; i < 5; i++)
swap16(x+i);
- if(fwrite(&x, sizeof(int16), 5, f) < 5)
+ if(fwrite(&x, sizeof(FLAC__int16), 5, f) < 5)
goto foo;
fclose(f);
}
/* a stereo five-sample 16bps stream */
-static bool generate_04()
+static FLAC__bool generate_04()
{
FILE *f;
- int16 x[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
+ FLAC__int16 x[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
unsigned i;
if(0 == (f = fopen("test04.raw", mode)))
for(i = 0; i < 10; i++)
swap16(x+i);
- if(fwrite(&x, sizeof(int16), 10, f) < 10)
+ if(fwrite(&x, sizeof(FLAC__int16), 10, f) < 10)
goto foo;
fclose(f);
}
/* a mono full-scale deflection 8bps stream */
-static bool generate_fsd8(const char *fn, const int pattern[], unsigned reps)
+static FLAC__bool generate_fsd8(const char *fn, const int pattern[], unsigned reps)
{
FILE *f;
unsigned rep, p;
}
/* a mono full-scale deflection 16bps stream */
-static bool generate_fsd16(const char *fn, const int pattern[], unsigned reps)
+static FLAC__bool generate_fsd16(const char *fn, const int pattern[], unsigned reps)
{
FILE *f;
unsigned rep, p;
for(rep = 0; rep < reps; rep++) {
for(p = 0; pattern[p]; p++) {
- int16 x = pattern[p] > 0? 32767 : -32768;
+ FLAC__int16 x = pattern[p] > 0? 32767 : -32768;
swap16(&x);
if(fwrite(&x, sizeof(x), 1, f) < 1)
goto foo;
}
/* a stereo wasted-bits-per-sample 16bps stream */
-static bool generate_wbps16(const char *fn, unsigned samples)
+static FLAC__bool generate_wbps16(const char *fn, unsigned samples)
{
FILE *f;
unsigned sample;
return false;
for(sample = 0; sample < samples; sample++) {
- int16 l = (sample % 2000) << 2;
- int16 r = (sample % 1000) << 3;
+ FLAC__int16 l = (sample % 2000) << 2;
+ FLAC__int16 r = (sample % 1000) << 3;
swap16(&l);
swap16(&r);
if(fwrite(&l, sizeof(l), 1, f) < 1)
}
/* a mono full-scale deflection 24bps stream */
-static bool generate_fsd24(const char *fn, const int pattern[], unsigned reps)
+static FLAC__bool generate_fsd24(const char *fn, const int pattern[], unsigned reps)
{
FILE *f;
unsigned rep, p;
for(rep = 0; rep < reps; rep++) {
for(p = 0; pattern[p]; p++) {
- int32 x = pattern[p] > 0? 8388607 : -8388608;
- byte *b = (byte*)(&x);
+ FLAC__int32 x = pattern[p] > 0? 8388607 : -8388608;
+ FLAC__byte *b = (FLAC__byte*)(&x);
swap24(b);
if(fwrite(b, 3, 1, f) < 1)
goto foo;
}
/* a mono sine-wave 16bps stream */
-static bool generate_sine16_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
+static FLAC__bool generate_sine16_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
{
- const int16 full_scale = 32767;
+ const FLAC__int16 full_scale = 32767;
const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
FILE *f;
for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
- int16 v = (int16)(val + 0.5);
+ FLAC__int16 v = (FLAC__int16)(val + 0.5);
swap16(&v);
if(fwrite(&v, sizeof(v), 1, f) < 1)
goto foo;
}
/* a stereo sine-wave 16bps stream */
-static bool generate_sine16_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
+static FLAC__bool generate_sine16_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
{
- const int16 full_scale = 32767;
+ const FLAC__int16 full_scale = 32767;
const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
FILE *f;
for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
- int16 v = (int16)(val + 0.5);
+ FLAC__int16 v = (FLAC__int16)(val + 0.5);
swap16(&v);
if(fwrite(&v, sizeof(v), 1, f) < 1)
goto foo;
val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
- v = (int16)(val + 0.5);
+ v = (FLAC__int16)(val + 0.5);
swap16(&v);
if(fwrite(&v, sizeof(v), 1, f) < 1)
goto foo;
}
/* a mono sine-wave 24bps stream */
-static bool generate_sine24_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
+static FLAC__bool generate_sine24_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
{
- const int32 full_scale = 0x7fffff;
+ const FLAC__int32 full_scale = 0x7fffff;
const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
FILE *f;
for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
- int32 v = (int32)(val + 0.5);
- byte *b = (byte*)(&v);
+ FLAC__int32 v = (FLAC__int32)(val + 0.5);
+ FLAC__byte *b = (FLAC__byte*)(&v);
swap24(b);
if(fwrite(b, 3, 1, f) < 1)
goto foo;
}
/* a stereo sine-wave 24bps stream */
-static bool generate_sine24_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
+static FLAC__bool generate_sine24_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
{
- const int32 full_scale = 0x7fffff;
+ const FLAC__int32 full_scale = 0x7fffff;
const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
FILE *f;
for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
- int32 v = (int32)(val + 0.5);
- byte *b = (byte*)(&v);
+ FLAC__int32 v = (FLAC__int32)(val + 0.5);
+ FLAC__byte *b = (FLAC__byte*)(&v);
swap24(b);
if(fwrite(b, 3, 1, f) < 1)
goto foo;
val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
- v = (int32)(val + 0.5);
+ v = (FLAC__int32)(val + 0.5);
swap24(b);
if(fwrite(b, 3, 1, f) < 1)
goto foo;
return false;
}
-static bool generate_noise(const char *fn, unsigned bytes)
+static FLAC__bool generate_noise(const char *fn, unsigned bytes)
{
FILE *f;
struct timeval tv;
return false;
for(b = 0; b < bytes; b++) {
- byte x = (byte)(((unsigned)random()) & 0xff);
+ FLAC__byte x = (FLAC__byte)(((unsigned)random()) & 0xff);
if(fwrite(&x, sizeof(x), 1, f) < 1)
goto foo;
}
return false;
}
-static bool generate_wackywavs()
+static FLAC__bool generate_wackywavs()
{
FILE *f;
- byte wav[] = {
+ FLAC__byte wav[] = {
'R', 'I', 'F', 'F', 76, 0, 0, 0,
'W', 'A', 'V', 'E', 'f', 'a', 'c', 't',
4, 0, 0, 0 , 'b', 'l', 'a', 'h',
int main(int argc, char *argv[])
{
- uint32 test = 1;
+ FLAC__uint32 test = 1;
int pattern01[] = { 1, -1, 0 };
int pattern02[] = { 1, 1, -1, 0 };
(void)argc;
(void)argv;
- is_big_endian_host = (*((byte*)(&test)))? false : true;
+ is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
if(!generate_01()) return 1;
if(!generate_02()) return 1;
#include "private/bitbuffer.h" /* from the libFLAC private include area */
-static bool dummy_read_callback(byte buffer[], unsigned *bytes, void *client_data)
+static FLAC__bool dummy_read_callback(FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
(void)buffer, (void)bytes, (void)client_data;
return true;
int test_bitbuffer()
{
FLAC__BitBuffer bb, bb_zero, bb_one, bbcopy;
- bool ok;
+ FLAC__bool ok;
unsigned i, j;
- static byte test_pattern1[19] = { 0xaa, 0xf0, 0xaa, 0xbe, 0xaa, 0xaa, 0xaa, 0xa8, 0x30, 0x0a, 0xaa, 0xaa, 0xaa, 0xad, 0xea, 0xdb, 0xee, 0xfa, 0xce };
+ static FLAC__byte test_pattern1[19] = { 0xaa, 0xf0, 0xaa, 0xbe, 0xaa, 0xaa, 0xaa, 0xa8, 0x30, 0x0a, 0xaa, 0xaa, 0xaa, 0xad, 0xea, 0xdb, 0xee, 0xfa, 0xce };
printf("testing init... OK\n");
FLAC__bitbuffer_init(&bb);
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x3d) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x3d) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x3d) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x3d) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x7b) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x7b) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes-1] != 0xf7) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes-1] != 0xf7) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x08) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes] != 0x08) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes-1] != 0x8a || bb.buffer[bb.bytes] != 0x0a) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes-1] != 0x8a || bb.buffer[bb.bytes] != 0x0a) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
}
- if(memcmp(bb.buffer, test_pattern1, sizeof(byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes-3] != 0x8a || bb.buffer[bb.bytes-2] != 0xaa || bb.buffer[bb.bytes-1] != 0xaa || bb.buffer[bb.bytes] != 0x15) {
+ if(memcmp(bb.buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb.buffer[bb.bytes-3] != 0x8a || bb.buffer[bb.bytes-2] != 0xaa || bb.buffer[bb.bytes-1] != 0xaa || bb.buffer[bb.bytes] != 0x15) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
return 1;
FLAC__bitbuffer_dump(&bbcopy, stdout);
return 1;
}
- if(memcmp(bb.buffer, bbcopy.buffer, sizeof(byte)*bb.capacity) != 0) {
+ if(memcmp(bb.buffer, bbcopy.buffer, sizeof(FLAC__byte)*bb.capacity) != 0) {
printf("FAILED pattern match\n");
FLAC__bitbuffer_dump(&bb, stdout);
FLAC__bitbuffer_dump(&bbcopy, stdout);
projects / platform / upstream / flac.git / commitdiff