From 6dcea51cd127b575de699986515f472265bb1471 Mon Sep 17 00:00:00 2001 From: Josh Coalson Date: Tue, 23 Jan 2001 23:07:36 +0000 Subject: [PATCH] revamp in anticipation of new analysis mode --- include/FLAC/file_decoder.h | 2 +- include/FLAC/format.h | 44 ++-- include/FLAC/stream_decoder.h | 2 +- src/flac/decode.c | 6 +- src/flac/encode.c | 8 +- src/libFLAC/encoder.c | 68 ++--- src/libFLAC/encoder_framing.c | 47 ++-- src/libFLAC/file_decoder.c | 34 +-- src/libFLAC/format.c | 16 +- src/libFLAC/include/private/encoder_framing.h | 8 +- src/libFLAC/stream_decoder.c | 237 ++++++++++-------- 11 files changed, 236 insertions(+), 236 deletions(-) diff --git a/include/FLAC/file_decoder.h b/include/FLAC/file_decoder.h index 770e369c..f54e698a 100644 --- a/include/FLAC/file_decoder.h +++ b/include/FLAC/file_decoder.h @@ -49,7 +49,7 @@ void FLAC__file_decoder_free_instance(FLAC__FileDecoder *decoder); FLAC__FileDecoderState FLAC__file_decoder_init( FLAC__FileDecoder *decoder, const char *filename, - FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data), + FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const 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 diff --git a/include/FLAC/format.h b/include/FLAC/format.h index e5b4c361..77e65b78 100644 --- a/include/FLAC/format.h +++ b/include/FLAC/format.h @@ -109,13 +109,15 @@ typedef enum { */ typedef struct { int32 value; -} FLAC__SubframeHeader_Constant; +} FLAC__Subframe_Constant; /***************************************************************************** * * n*i: unencoded signal; n = frame's bits-per-sample, i = frame's blocksize */ -/* There is no (trivial) for structure FLAC__SubframeHeader_Verbatim */ +typedef struct { + int32 *data; +} FLAC__Subframe_Verbatim; /***************************************************************************** * @@ -128,7 +130,8 @@ typedef struct { FLAC__EntropyCodingMethod entropy_coding_method; unsigned order; int32 warmup[FLAC__MAX_FIXED_ORDER]; -} FLAC__SubframeHeader_Fixed; + int32 *residual; +} FLAC__Subframe_Fixed; /***************************************************************************** * @@ -147,10 +150,11 @@ typedef struct { int quantization_level; int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; int32 warmup[FLAC__MAX_LPC_ORDER]; -} FLAC__SubframeHeader_LPC; + int32 *residual; +} FLAC__Subframe_LPC; -extern const unsigned FLAC__SUBFRAME_HEADER_LPC_QLP_COEFF_PRECISION_LEN; /* = 4 bits */ -extern const unsigned FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN; /* = 5 bits */ +extern const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /* = 4 bits */ +extern const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN; /* = 5 bits */ /***************************************************************************** * @@ -164,28 +168,24 @@ extern const unsigned FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN; /* = 5 bits */ * 001xxxx0: reserved * 01xxxxx0: lpc, xxxxx=order-1 * 1xxxxxxx: invalid, to prevent sync-fooling string of 1s (use to check for erroneous sync) - * ?: subframe-specific header (c.f. FLAC__SubframeHeader_*) + * ?: subframe-specific data (c.f. FLAC__Subframe_*) */ typedef struct { FLAC__SubframeType type; union { - FLAC__SubframeHeader_Constant constant; - FLAC__SubframeHeader_Fixed fixed; - FLAC__SubframeHeader_LPC lpc; - } data; /* data will be undefined for FLAC__SUBFRAME_TYPE_VERBATIM */ -} FLAC__SubframeHeader; - -extern const unsigned FLAC__SUBFRAME_HEADER_TYPE_CONSTANT; /* = 0x00 */ -extern const unsigned FLAC__SUBFRAME_HEADER_TYPE_VERBATIM; /* = 0x02 */ -extern const unsigned FLAC__SUBFRAME_HEADER_TYPE_FIXED; /* = 0x10 */ -extern const unsigned FLAC__SUBFRAME_HEADER_TYPE_LPC; /* = 0x40 */ -extern const unsigned FLAC__SUBFRAME_HEADER_TYPE_LEN; /* = 8 bits */ - -typedef struct { - FLAC__SubframeHeader header; - const int32 *data; + FLAC__Subframe_Constant constant; + FLAC__Subframe_Fixed fixed; + FLAC__Subframe_LPC lpc; + FLAC__Subframe_Verbatim verbatim; + } data; } FLAC__Subframe; +extern const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BITS; /* = 0x00 */ +extern const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BITS; /* = 0x02 */ +extern const unsigned FLAC__SUBFRAME_TYPE_FIXED_BITS; /* = 0x10 */ +extern const unsigned FLAC__SUBFRAME_TYPE_LPC_BITS; /* = 0x40 */ +extern const unsigned FLAC__SUBFRAME_TYPE_LEN; /* = 8 bits */ + /*****************************************************************************/ diff --git a/include/FLAC/stream_decoder.h b/include/FLAC/stream_decoder.h index 92405c6a..da72a797 100644 --- a/include/FLAC/stream_decoder.h +++ b/include/FLAC/stream_decoder.h @@ -71,7 +71,7 @@ void FLAC__stream_decoder_free_instance(FLAC__StreamDecoder *decoder); FLAC__StreamDecoderState FLAC__stream_decoder_init( FLAC__StreamDecoder *decoder, 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__FrameHeader *header, const int32 *buffer[], void *client_data), + FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const 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 *client_data diff --git a/src/flac/decode.c b/src/flac/decode.c index ca11898e..e5016436 100644 --- a/src/flac/decode.c +++ b/src/flac/decode.c @@ -51,7 +51,7 @@ static bool is_big_endian_host; static bool init(const char *infile, 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__FrameHeader *header, const int32 *buffer[], void *client_data); +static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const 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); @@ -290,14 +290,14 @@ bool write_little_endian_uint32(FILE *f, uint32 val) return fwrite(b, 1, 4, f) == 4; } -FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data) +FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const 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); - unsigned wide_samples = header->blocksize, wide_sample, sample, channel, byte; + unsigned wide_samples = frame->header.blocksize, wide_sample, sample, channel, byte; static signed char scbuffer[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * ((FLAC__MAX_BITS_PER_SAMPLE+7)>>3)]; /* WATCHOUT: can be up to 2 megs */ unsigned char *ucbuffer = (unsigned char *)scbuffer; signed short *ssbuffer = (signed short *)scbuffer; diff --git a/src/flac/encode.c b/src/flac/encode.c index 78446437..148962f7 100644 --- a/src/flac/encode.c +++ b/src/flac/encode.c @@ -86,7 +86,7 @@ static void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsi static FLAC__EncoderWriteStatus write_callback(const FLAC__Encoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data); static void metadata_callback(const FLAC__Encoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data); static FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *decoder, byte buffer[], unsigned *bytes, void *client_data); -static FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data); +static FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data); static void verify_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data); static void verify_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); static void print_stats(const encoder_wrapper_struct *encoder_wrapper); @@ -688,7 +688,7 @@ FLAC__StreamDecoderReadStatus verify_read_callback(const FLAC__StreamDecoder *de return FLAC__STREAM_DECODER_READ_CONTINUE; } -FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data) +FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data) { encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data; unsigned channel, l, r; @@ -702,11 +702,11 @@ FLAC__StreamDecoderWriteStatus verify_write_callback(const FLAC__StreamDecoder * } /* dequeue the frame from the fifo */ for(channel = 0; channel < decoder->channels; channel++) { - for(l = 0, r = header->blocksize; r < encoder_wrapper->verify_fifo.tail; l++, r++) { + for(l = 0, r = frame->header.blocksize; r < encoder_wrapper->verify_fifo.tail; l++, r++) { encoder_wrapper->verify_fifo.original[channel][l] = encoder_wrapper->verify_fifo.original[channel][r]; } } - encoder_wrapper->verify_fifo.tail -= header->blocksize; + encoder_wrapper->verify_fifo.tail -= frame->header.blocksize; return FLAC__STREAM_DECODER_WRITE_CONTINUE; } diff --git a/src/libFLAC/encoder.c b/src/libFLAC/encoder.c index a28ff510..9f0d4dfa 100644 --- a/src/libFLAC/encoder.c +++ b/src/libFLAC/encoder.c @@ -51,7 +51,7 @@ typedef struct FLAC__EncoderPrivate { FLAC__BitBuffer frame_mid_side; /* special parallel workspace for the mid-side coded version of the current frame */ FLAC__BitBuffer frame_left_side; /* special parallel workspace for the left-side coded version of the current frame */ FLAC__BitBuffer frame_right_side; /* special parallel workspace for the right-side coded version of the current frame */ - FLAC__SubframeHeader best_subframe, candidate_subframe; + FLAC__Subframe best_subframe, candidate_subframe; bool current_frame_can_do_mid_side; /* encoder sets this false when any given sample of a frame's side channel exceeds 16 bits */ FLAC__StreamMetaData metadata; unsigned current_sample_number; @@ -65,15 +65,11 @@ typedef struct FLAC__EncoderPrivate { static bool encoder_resize_buffers_(FLAC__Encoder *encoder, unsigned new_size); static bool encoder_process_frame_(FLAC__Encoder *encoder, bool is_last_frame); static bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame, const FLAC__FrameHeader *frame_header, unsigned channels, const int32 *integer_signal[], const real *real_signal[], FLAC__BitBuffer *bitbuffer); -static unsigned encoder_evaluate_constant_subframe_(const int32 signal, unsigned bits_per_sample, FLAC__SubframeHeader *subframe); -static unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe); -static unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], const real lp_coeff[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe); -static unsigned encoder_evaluate_verbatim_subframe_(unsigned blocksize, unsigned bits_per_sample, FLAC__SubframeHeader *subframe); +static unsigned encoder_evaluate_constant_subframe_(const int32 signal, unsigned bits_per_sample, FLAC__Subframe *subframe); +static unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned rice_parameter, unsigned max_partition_order, FLAC__Subframe *subframe); +static unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], const real lp_coeff[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned max_partition_order, FLAC__Subframe *subframe); +static unsigned encoder_evaluate_verbatim_subframe_(unsigned blocksize, unsigned bits_per_sample, FLAC__Subframe *subframe); static unsigned encoder_find_best_partition_order_(const int32 residual[], uint32 abs_residual[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned max_partition_order, unsigned *best_partition_order, unsigned best_parameters[]); -static bool encoder_generate_constant_subframe_(const FLAC__SubframeHeader *header, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer); -static bool encoder_generate_fixed_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer); -static bool encoder_generate_lpc_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer); -static bool encoder_generate_verbatim_subframe_(const FLAC__SubframeHeader *header, const int32 signal[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer); static void encoder_promote_candidate_subframe_(FLAC__Encoder *encoder); static bool encoder_set_partitioned_rice_(const uint32 abs_residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameter, const unsigned partition_order, unsigned parameters[], unsigned *bits); @@ -765,25 +761,28 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame, cons /* add the best subframe */ switch(encoder->guts->best_subframe.type) { case FLAC__SUBFRAME_TYPE_CONSTANT: - if(!encoder_generate_constant_subframe_(&(encoder->guts->best_subframe), frame_header->bits_per_sample, frame)) { + if(!FLAC__subframe_add_constant(&(encoder->guts->best_subframe.data.constant), frame_header->bits_per_sample, frame)) { encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING; return false; } break; case FLAC__SUBFRAME_TYPE_FIXED: - if(!encoder_generate_fixed_subframe_(&(encoder->guts->best_subframe), encoder->guts->residual[encoder->guts->best_residual], frame_header->blocksize, frame_header->bits_per_sample, frame)) { + encoder->guts->best_subframe.data.fixed.residual = encoder->guts->residual[encoder->guts->best_residual]; + if(!FLAC__subframe_add_fixed(&(encoder->guts->best_subframe.data.fixed), frame_header->blocksize - encoder->guts->best_subframe.data.fixed.order, frame_header->bits_per_sample, frame)) { encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING; return false; } break; case FLAC__SUBFRAME_TYPE_LPC: - if(!encoder_generate_lpc_subframe_(&(encoder->guts->best_subframe), encoder->guts->residual[encoder->guts->best_residual], frame_header->blocksize, frame_header->bits_per_sample, frame)) { + encoder->guts->best_subframe.data.lpc.residual = encoder->guts->residual[encoder->guts->best_residual]; + if(!FLAC__subframe_add_lpc(&(encoder->guts->best_subframe.data.lpc), frame_header->blocksize - encoder->guts->best_subframe.data.lpc.order, frame_header->bits_per_sample, frame)) { encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING; return false; } break; case FLAC__SUBFRAME_TYPE_VERBATIM: - if(!encoder_generate_verbatim_subframe_(&(encoder->guts->best_subframe), integer_signal[channel], frame_header->blocksize, frame_header->bits_per_sample, frame)) { + encoder->guts->best_subframe.data.verbatim.data = integer_signal[channel]; + if(!FLAC__subframe_add_verbatim(&(encoder->guts->best_subframe.data.verbatim), frame_header->blocksize, frame_header->bits_per_sample, frame)) { encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING; return false; } @@ -794,15 +793,15 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame, cons return true; } -unsigned encoder_evaluate_constant_subframe_(const int32 signal, unsigned bits_per_sample, FLAC__SubframeHeader *subframe) +unsigned encoder_evaluate_constant_subframe_(const int32 signal, unsigned bits_per_sample, FLAC__Subframe *subframe) { subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT; subframe->data.constant.value = signal; - return FLAC__SUBFRAME_HEADER_TYPE_LEN + bits_per_sample; + return FLAC__SUBFRAME_TYPE_LEN + bits_per_sample; } -unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe) +unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned rice_parameter, unsigned max_partition_order, FLAC__Subframe *subframe) { unsigned i, residual_bits; const unsigned residual_samples = blocksize - order; @@ -819,10 +818,10 @@ unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[] for(i = 0; i < order; i++) subframe->data.fixed.warmup[i] = signal[i]; - return FLAC__SUBFRAME_HEADER_TYPE_LEN + (order * bits_per_sample) + residual_bits; + return FLAC__SUBFRAME_TYPE_LEN + (order * bits_per_sample) + residual_bits; } -unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], const real lp_coeff[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe) +unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], uint32 abs_residual[], const real lp_coeff[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned max_partition_order, FLAC__Subframe *subframe) { int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; unsigned i, residual_bits; @@ -848,14 +847,14 @@ unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], for(i = 0; i < order; i++) subframe->data.lpc.warmup[i] = signal[i]; - return FLAC__SUBFRAME_HEADER_TYPE_LEN + FLAC__SUBFRAME_HEADER_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + bits_per_sample)) + residual_bits; + return FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + bits_per_sample)) + residual_bits; } -unsigned encoder_evaluate_verbatim_subframe_(unsigned blocksize, unsigned bits_per_sample, FLAC__SubframeHeader *subframe) +unsigned encoder_evaluate_verbatim_subframe_(unsigned blocksize, unsigned bits_per_sample, FLAC__Subframe *subframe) { subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM; - return FLAC__SUBFRAME_HEADER_TYPE_LEN + (blocksize * bits_per_sample); + return FLAC__SUBFRAME_TYPE_LEN + (blocksize * bits_per_sample); } unsigned encoder_find_best_partition_order_(const int32 residual[], uint32 abs_residual[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned max_partition_order, unsigned *best_partition_order, unsigned best_parameters[]) @@ -887,33 +886,6 @@ unsigned encoder_find_best_partition_order_(const int32 residual[], uint32 abs_r return best_residual_bits; } -bool encoder_generate_constant_subframe_(const FLAC__SubframeHeader *header, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer) -{ - assert(header->type == FLAC__SUBFRAME_TYPE_CONSTANT); - return FLAC__subframe_add_constant(bits_per_sample, header, bitbuffer); -} - -bool encoder_generate_fixed_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer) -{ - assert(header->type == FLAC__SUBFRAME_TYPE_FIXED); - return FLAC__subframe_add_fixed(residual, blocksize - header->data.fixed.order, bits_per_sample, header, bitbuffer); -} - -bool encoder_generate_lpc_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer) -{ - assert(header->type == FLAC__SUBFRAME_TYPE_LPC); - return FLAC__subframe_add_lpc(residual, blocksize - header->data.lpc.order, bits_per_sample, header, bitbuffer); -} - -bool encoder_generate_verbatim_subframe_(const FLAC__SubframeHeader *header, const int32 signal[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer) -{ - assert(header->type == FLAC__SUBFRAME_TYPE_VERBATIM); -#ifdef NDEBUG - (void)header; /* silence compiler warning about unused parameter */ -#endif - return FLAC__subframe_add_verbatim(signal, blocksize, bits_per_sample, bitbuffer); -} - void encoder_promote_candidate_subframe_(FLAC__Encoder *encoder) { assert(encoder->state == FLAC__ENCODER_OK); diff --git a/src/libFLAC/encoder_framing.c b/src/libFLAC/encoder_framing.c index 7a60e6f3..d28c3b69 100644 --- a/src/libFLAC/encoder_framing.c +++ b/src/libFLAC/encoder_framing.c @@ -215,34 +215,34 @@ bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_sub return true; } -bool FLAC__subframe_add_constant(unsigned bits_per_sample, const FLAC__SubframeHeader *subframe, FLAC__BitBuffer *bb) +bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned bits_per_sample, FLAC__BitBuffer *bb) { bool ok; ok = - FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_HEADER_TYPE_CONSTANT, FLAC__SUBFRAME_HEADER_TYPE_LEN) && - FLAC__bitbuffer_write_raw_int32(bb, subframe->data.constant.value, bits_per_sample) + FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_CONSTANT_BITS, FLAC__SUBFRAME_TYPE_LEN) && + FLAC__bitbuffer_write_raw_int32(bb, subframe->value, bits_per_sample) ; return ok; } -bool FLAC__subframe_add_fixed(const int32 residual[], unsigned residual_samples, unsigned bits_per_sample, const FLAC__SubframeHeader *subframe, FLAC__BitBuffer *bb) +bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned bits_per_sample, FLAC__BitBuffer *bb) { unsigned i; - if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_HEADER_TYPE_FIXED | (subframe->data.fixed.order<<1), FLAC__SUBFRAME_HEADER_TYPE_LEN)) + if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_FIXED_BITS | (subframe->order<<1), FLAC__SUBFRAME_TYPE_LEN)) return false; - for(i = 0; i < subframe->data.fixed.order; i++) - if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->data.fixed.warmup[i], bits_per_sample)) + for(i = 0; i < subframe->order; i++) + if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], bits_per_sample)) return false; - if(!subframe_add_entropy_coding_method_(bb, &subframe->data.fixed.entropy_coding_method)) + if(!subframe_add_entropy_coding_method_(bb, &subframe->entropy_coding_method)) return false; - switch(subframe->data.fixed.entropy_coding_method.type) { + switch(subframe->entropy_coding_method.type) { case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: - if(!subframe_add_residual_partitioned_rice_(bb, residual, residual_samples, subframe->data.fixed.order, subframe->data.fixed.entropy_coding_method.data.partitioned_rice.parameters, subframe->data.fixed.entropy_coding_method.data.partitioned_rice.order)) + if(!subframe_add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.parameters, subframe->entropy_coding_method.data.partitioned_rice.order)) return false; break; default: @@ -252,30 +252,30 @@ bool FLAC__subframe_add_fixed(const int32 residual[], unsigned residual_samples, return true; } -bool FLAC__subframe_add_lpc(const int32 residual[], unsigned residual_samples, unsigned bits_per_sample, const FLAC__SubframeHeader *subframe, FLAC__BitBuffer *bb) +bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned bits_per_sample, FLAC__BitBuffer *bb) { unsigned i; - if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_HEADER_TYPE_LPC | ((subframe->data.lpc.order-1)<<1), FLAC__SUBFRAME_HEADER_TYPE_LEN)) + if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_LPC_BITS | ((subframe->order-1)<<1), FLAC__SUBFRAME_TYPE_LEN)) return false; - for(i = 0; i < subframe->data.lpc.order; i++) - if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->data.lpc.warmup[i], bits_per_sample)) + for(i = 0; i < subframe->order; i++) + if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], bits_per_sample)) return false; - if(!FLAC__bitbuffer_write_raw_uint32(bb, subframe->data.lpc.qlp_coeff_precision-1, FLAC__SUBFRAME_HEADER_LPC_QLP_COEFF_PRECISION_LEN)) + if(!FLAC__bitbuffer_write_raw_uint32(bb, subframe->qlp_coeff_precision-1, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN)) return false; - if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->data.lpc.quantization_level, FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN)) + if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN)) return false; - for(i = 0; i < subframe->data.lpc.order; i++) - if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->data.lpc.qlp_coeff[i], subframe->data.lpc.qlp_coeff_precision)) + for(i = 0; i < subframe->order; i++) + if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->qlp_coeff[i], subframe->qlp_coeff_precision)) return false; - if(!subframe_add_entropy_coding_method_(bb, &subframe->data.lpc.entropy_coding_method)) + if(!subframe_add_entropy_coding_method_(bb, &subframe->entropy_coding_method)) return false; - switch(subframe->data.lpc.entropy_coding_method.type) { + switch(subframe->entropy_coding_method.type) { case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: - if(!subframe_add_residual_partitioned_rice_(bb, residual, residual_samples, subframe->data.lpc.order, subframe->data.fixed.entropy_coding_method.data.partitioned_rice.parameters, subframe->data.lpc.entropy_coding_method.data.partitioned_rice.order)) + if(!subframe_add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.parameters, subframe->entropy_coding_method.data.partitioned_rice.order)) return false; break; default: @@ -285,11 +285,12 @@ bool FLAC__subframe_add_lpc(const int32 residual[], unsigned residual_samples, u return true; } -bool FLAC__subframe_add_verbatim(const int32 signal[], unsigned samples, unsigned bits_per_sample, FLAC__BitBuffer *bb) +bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned bits_per_sample, FLAC__BitBuffer *bb) { unsigned i; + const int32 *signal = subframe->data; - if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_HEADER_TYPE_VERBATIM, FLAC__SUBFRAME_HEADER_TYPE_LEN)) + if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_VERBATIM_BITS, FLAC__SUBFRAME_TYPE_LEN)) return false; for(i = 0; i < samples; i++) diff --git a/src/libFLAC/file_decoder.c b/src/libFLAC/file_decoder.c index 693d1ab2..1b5a7d47 100644 --- a/src/libFLAC/file_decoder.c +++ b/src/libFLAC/file_decoder.c @@ -26,7 +26,7 @@ #include "private/md5.h" typedef struct FLAC__FileDecoderPrivate { - FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data); + FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const 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; @@ -37,12 +37,12 @@ typedef struct FLAC__FileDecoderPrivate { 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_Encoding metadata; /* we keep this around so we can figure out how to seek quickly */ - FLAC__FrameHeader last_frame_header; /* holds the info of the last frame we seeked to */ + FLAC__Frame last_frame; /* holds the info of the last frame we seeked to */ uint64 target_sample; } FLAC__FileDecoderPrivate; 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__FrameHeader *header, const int32 *buffer[], void *client_data); +static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const 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); @@ -76,7 +76,7 @@ void FLAC__file_decoder_free_instance(FLAC__FileDecoder *decoder) FLAC__FileDecoderState FLAC__file_decoder_init( FLAC__FileDecoder *decoder, const char *filename, - FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data), + FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const 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 @@ -291,17 +291,17 @@ FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, return FLAC__STREAM_DECODER_READ_ABORT; /* abort to avoid a deadlock */ } -FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__FrameHeader *header, const int32 *buffer[], void *client_data) +FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data) { FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data; (void)decoder; if(file_decoder->state == FLAC__FILE_DECODER_SEEKING) { - uint64 this_frame_sample = header->number.sample_number; - uint64 next_frame_sample = this_frame_sample + (uint64)header->blocksize; + 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->guts->target_sample; - file_decoder->guts->last_frame_header = *header; /* save the header in the guts */ + file_decoder->guts->last_frame = *frame; /* save the frame in the guts */ if(this_frame_sample <= target_sample && target_sample < next_frame_sample) { /* we hit our target frame */ unsigned delta = (unsigned)(target_sample - this_frame_sample); /* kick out of seek mode */ @@ -310,16 +310,16 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decode if(delta > 0) { unsigned channel; const int32 *newbuffer[FLAC__MAX_CHANNELS]; - for(channel = 0; channel < header->channels; channel++) + for(channel = 0; channel < frame->header.channels; channel++) newbuffer[channel] = buffer[channel] + delta; - file_decoder->guts->last_frame_header.blocksize -= delta; - file_decoder->guts->last_frame_header.number.sample_number += (uint64)delta; + file_decoder->guts->last_frame.header.blocksize -= delta; + file_decoder->guts->last_frame.header.number.sample_number += (uint64)delta; /* write the relevant samples */ - return file_decoder->guts->write_callback(file_decoder, &file_decoder->guts->last_frame_header, newbuffer, file_decoder->guts->client_data); + return file_decoder->guts->write_callback(file_decoder, &file_decoder->guts->last_frame, newbuffer, file_decoder->guts->client_data); } else { /* write the relevant samples */ - return file_decoder->guts->write_callback(file_decoder, header, buffer, file_decoder->guts->client_data); + return file_decoder->guts->write_callback(file_decoder, frame, buffer, file_decoder->guts->client_data); } } else { @@ -328,10 +328,10 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decode } else { if(file_decoder->check_md5) { - if(!FLAC__MD5Accumulate(&file_decoder->guts->md5context, buffer, header->channels, header->blocksize, (header->bits_per_sample+7) / 8)) + if(!FLAC__MD5Accumulate(&file_decoder->guts->md5context, buffer, frame->header.channels, frame->header.blocksize, (frame->header.bits_per_sample+7) / 8)) return FLAC__STREAM_DECODER_WRITE_ABORT; } - return file_decoder->guts->write_callback(file_decoder, header, buffer, file_decoder->guts->client_data); + return file_decoder->guts->write_callback(file_decoder, frame, buffer, file_decoder->guts->client_data); } } @@ -416,7 +416,7 @@ bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64 break; } else { /* we need to narrow the search */ - uint64 this_frame_sample = decoder->guts->last_frame_header.number.sample_number; + uint64 this_frame_sample = decoder->guts->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); @@ -425,7 +425,7 @@ bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64 else { if(target_sample < this_frame_sample) { last_pos = pos; - approx_bytes_per_frame = decoder->guts->last_frame_header.blocksize * decoder->guts->last_frame_header.channels * decoder->guts->last_frame_header.bits_per_sample/8 + 64; + approx_bytes_per_frame = decoder->guts->last_frame.header.blocksize * decoder->guts->last_frame.header.channels * decoder->guts->last_frame.header.bits_per_sample/8 + 64; pos -= approx_bytes_per_frame; needs_seek = true; } diff --git a/src/libFLAC/format.c b/src/libFLAC/format.c index 0e584276..f7cf9f44 100644 --- a/src/libFLAC/format.c +++ b/src/libFLAC/format.c @@ -56,12 +56,12 @@ const unsigned FLAC__ENTROPY_CODING_METHOD_TYPE_LEN = 2; /* bits */ const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN = 4; /* bits */ const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN = 4; /* bits */ -const unsigned FLAC__SUBFRAME_HEADER_LPC_QLP_COEFF_PRECISION_LEN = 4; /* bits */ -const unsigned FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN = 5; /* bits */ -const unsigned FLAC__SUBFRAME_HEADER_LPC_RICE_PARAMETER_LEN = 4; /* bits */ +const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN = 4; /* bits */ +const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN = 5; /* bits */ +const unsigned FLAC__SUBFRAME_LPC_RICE_PARAMETER_LEN = 4; /* bits */ -const unsigned FLAC__SUBFRAME_HEADER_TYPE_CONSTANT = 0x00; -const unsigned FLAC__SUBFRAME_HEADER_TYPE_VERBATIM = 0x02; -const unsigned FLAC__SUBFRAME_HEADER_TYPE_FIXED = 0x10; -const unsigned FLAC__SUBFRAME_HEADER_TYPE_LPC = 0x40; -const unsigned FLAC__SUBFRAME_HEADER_TYPE_LEN = 8; /* bits */ +const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BITS = 0x00; +const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BITS = 0x02; +const unsigned FLAC__SUBFRAME_TYPE_FIXED_BITS = 0x10; +const unsigned FLAC__SUBFRAME_TYPE_LPC_BITS = 0x40; +const unsigned FLAC__SUBFRAME_TYPE_LEN = 8; /* bits */ diff --git a/src/libFLAC/include/private/encoder_framing.h b/src/libFLAC/include/private/encoder_framing.h index 33649b4c..0a365e14 100644 --- a/src/libFLAC/include/private/encoder_framing.h +++ b/src/libFLAC/include/private/encoder_framing.h @@ -25,9 +25,9 @@ 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(unsigned bits_per_sample, const FLAC__SubframeHeader *subframe, FLAC__BitBuffer *bb); -bool FLAC__subframe_add_fixed(const int32 residual[], unsigned residual_samples, unsigned bits_per_sample, const FLAC__SubframeHeader *subframe, FLAC__BitBuffer *bb); -bool FLAC__subframe_add_lpc(const int32 residual[], unsigned residual_samples, unsigned bits_per_sample, const FLAC__SubframeHeader *subframe, FLAC__BitBuffer *bb); -bool FLAC__subframe_add_verbatim(const int32 signal[], unsigned samples, unsigned bits_per_sample, FLAC__BitBuffer *bb); +bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned bits_per_sample, FLAC__BitBuffer *bb); +bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned bits_per_sample, FLAC__BitBuffer *bb); +bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned bits_per_sample, FLAC__BitBuffer *bb); +bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned bits_per_sample, FLAC__BitBuffer *bb); #endif diff --git a/src/libFLAC/stream_decoder.c b/src/libFLAC/stream_decoder.c index 56fb4865..611a0255 100644 --- a/src/libFLAC/stream_decoder.c +++ b/src/libFLAC/stream_decoder.c @@ -28,19 +28,19 @@ 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__FrameHeader *header, const int32 *buffer[], void *client_data); + FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const 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 *client_data; FLAC__BitBuffer input; int32 *output[FLAC__MAX_CHANNELS]; - int32 *residual; + int32 *residual[FLAC__MAX_CHANNELS]; unsigned output_capacity; uint32 last_frame_number; uint64 samples_decoded; bool has_stream_header; FLAC__StreamMetaData stream_header; - FLAC__FrameHeader frame_header; + FLAC__Frame frame; } FLAC__StreamDecoderPrivate; static byte ID3V2_TAG_[3] = { 'I', 'D', '3' }; @@ -57,7 +57,7 @@ static bool stream_decoder_read_subframe_constant_(FLAC__StreamDecoder *decoder, static bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned channel, const unsigned order); static bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned channel, const unsigned order); static bool stream_decoder_read_subframe_verbatim_(FLAC__StreamDecoder *decoder, unsigned channel); -static bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order); +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); @@ -107,7 +107,7 @@ void FLAC__stream_decoder_free_instance(FLAC__StreamDecoder *decoder) FLAC__StreamDecoderState FLAC__stream_decoder_init( FLAC__StreamDecoder *decoder, 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__FrameHeader *header, const int32 *buffer[], void *client_data), + FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const 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 *client_data @@ -138,9 +138,10 @@ FLAC__StreamDecoderState FLAC__stream_decoder_init( FLAC__bitbuffer_init(&decoder->guts->input); - for(i = 0; i < FLAC__MAX_CHANNELS; i++) + for(i = 0; i < FLAC__MAX_CHANNELS; i++) { decoder->guts->output[i] = 0; - decoder->guts->residual = 0; + decoder->guts->residual[i] = 0; + } decoder->guts->output_capacity = 0; decoder->guts->last_frame_number = 0; @@ -163,10 +164,10 @@ void FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder) free(decoder->guts->output[i]); decoder->guts->output[i] = 0; } - } - if(decoder->guts->residual != 0) { - free(decoder->guts->residual); - decoder->guts->residual = 0; + if(decoder->guts->residual[i] != 0) { + free(decoder->guts->residual[i]); + decoder->guts->residual[i] = 0; + } } free(decoder->guts); decoder->guts = 0; @@ -347,31 +348,34 @@ bool stream_decoder_allocate_output_(FLAC__StreamDecoder *decoder, unsigned size if(size <= decoder->guts->output_capacity) return true; + /* @@@ should change to use realloc() */ + for(i = 0; i < FLAC__MAX_CHANNELS; i++) { if(decoder->guts->output[i] != 0) { free(decoder->guts->output[i]); decoder->guts->output[i] = 0; } - } - if(decoder->guts->residual != 0) { - free(decoder->guts->residual); - decoder->guts->residual = 0; + if(decoder->guts->residual[i] != 0) { + free(decoder->guts->residual[i]); + decoder->guts->residual[i] = 0; + } } - for(i = 0; i < decoder->guts->frame_header.channels; i++) { + for(i = 0; i < decoder->guts->frame.header.channels; i++) { tmp = (int32*)malloc(sizeof(int32)*size); if(tmp == 0) { decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; return false; } decoder->guts->output[i] = tmp; + + tmp = (int32*)malloc(sizeof(int32)*size); + if(tmp == 0) { + decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; + return false; + } + decoder->guts->residual[i] = tmp; } - tmp = (int32*)malloc(sizeof(int32)*size); - if(tmp == 0) { - decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; - return false; - } - decoder->guts->residual = tmp; decoder->guts->output_capacity = size; @@ -595,9 +599,9 @@ bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame) decoder->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; return true; } - if(!stream_decoder_allocate_output_(decoder, decoder->guts->frame_header.blocksize)) + if(!stream_decoder_allocate_output_(decoder, decoder->guts->frame.header.blocksize)) return false; - for(channel = 0; channel < decoder->guts->frame_header.channels; channel++) { + for(channel = 0; channel < decoder->guts->frame.header.channels; channel++) { if(!stream_decoder_read_subframe_(decoder, channel)) return false; if(decoder->state != FLAC__STREAM_DECODER_READ_FRAME) { @@ -609,23 +613,23 @@ bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame) return false; /* Undo any special channel coding */ - switch(decoder->guts->frame_header.channel_assignment) { + switch(decoder->guts->frame.header.channel_assignment) { case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: /* do nothing */ break; case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: - assert(decoder->guts->frame_header.channels == 2); - for(i = 0; i < decoder->guts->frame_header.blocksize; i++) + assert(decoder->guts->frame.header.channels == 2); + for(i = 0; i < decoder->guts->frame.header.blocksize; i++) decoder->guts->output[1][i] = decoder->guts->output[0][i] - decoder->guts->output[1][i]; break; case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: - assert(decoder->guts->frame_header.channels == 2); - for(i = 0; i < decoder->guts->frame_header.blocksize; i++) + assert(decoder->guts->frame.header.channels == 2); + for(i = 0; i < decoder->guts->frame.header.blocksize; i++) decoder->guts->output[0][i] += decoder->guts->output[1][i]; break; case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: - assert(decoder->guts->frame_header.channels == 2); - for(i = 0; i < decoder->guts->frame_header.blocksize; i++) { + assert(decoder->guts->frame.header.channels == 2); + for(i = 0; i < decoder->guts->frame.header.blocksize; i++) { mid = decoder->guts->output[0][i]; side = decoder->guts->output[1][i]; mid <<= 1; @@ -645,16 +649,16 @@ bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame) *got_a_frame = true; /* put the latest values into the public section of the decoder instance */ - decoder->channels = decoder->guts->frame_header.channels; - decoder->channel_assignment = decoder->guts->frame_header.channel_assignment; - decoder->bits_per_sample = decoder->guts->frame_header.bits_per_sample; - decoder->sample_rate = decoder->guts->frame_header.sample_rate; - decoder->blocksize = decoder->guts->frame_header.blocksize; + decoder->channels = decoder->guts->frame.header.channels; + decoder->channel_assignment = decoder->guts->frame.header.channel_assignment; + decoder->bits_per_sample = decoder->guts->frame.header.bits_per_sample; + decoder->sample_rate = decoder->guts->frame.header.sample_rate; + decoder->blocksize = decoder->guts->frame.header.blocksize; - decoder->guts->samples_decoded += decoder->guts->frame_header.blocksize; + decoder->guts->samples_decoded += decoder->guts->frame.header.blocksize; /* write it */ - if(decoder->guts->write_callback(decoder, &decoder->guts->frame_header, decoder->guts->output, decoder->guts->client_data) != FLAC__STREAM_DECODER_WRITE_CONTINUE) + if(decoder->guts->write_callback(decoder, &decoder->guts->frame, decoder->guts->output, decoder->guts->client_data) != FLAC__STREAM_DECODER_WRITE_CONTINUE) return false; decoder->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; @@ -704,18 +708,18 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) switch(x = raw_header[1] >> 4) { case 0: if(decoder->guts->has_stream_header && decoder->guts->stream_header.data.encoding.min_blocksize == decoder->guts->stream_header.data.encoding.max_blocksize) /* i.e. it's a fixed-blocksize stream */ - decoder->guts->frame_header.blocksize = decoder->guts->stream_header.data.encoding.min_blocksize; + decoder->guts->frame.header.blocksize = decoder->guts->stream_header.data.encoding.min_blocksize; else is_unparseable = true; break; case 1: - decoder->guts->frame_header.blocksize = 192; + decoder->guts->frame.header.blocksize = 192; break; case 2: case 3: case 4: case 5: - decoder->guts->frame_header.blocksize = 576 << (x-2); + decoder->guts->frame.header.blocksize = 576 << (x-2); break; case 6: case 7: @@ -729,7 +733,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) switch(x = raw_header[1] & 0x0f) { case 0: if(decoder->guts->has_stream_header) - decoder->guts->frame_header.sample_rate = decoder->guts->stream_header.data.encoding.sample_rate; + decoder->guts->frame.header.sample_rate = decoder->guts->stream_header.data.encoding.sample_rate; else is_unparseable = true; break; @@ -739,28 +743,28 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) is_unparseable = true; break; case 4: - decoder->guts->frame_header.sample_rate = 8000; + decoder->guts->frame.header.sample_rate = 8000; break; case 5: - decoder->guts->frame_header.sample_rate = 16000; + decoder->guts->frame.header.sample_rate = 16000; break; case 6: - decoder->guts->frame_header.sample_rate = 22050; + decoder->guts->frame.header.sample_rate = 22050; break; case 7: - decoder->guts->frame_header.sample_rate = 24000; + decoder->guts->frame.header.sample_rate = 24000; break; case 8: - decoder->guts->frame_header.sample_rate = 32000; + decoder->guts->frame.header.sample_rate = 32000; break; case 9: - decoder->guts->frame_header.sample_rate = 44100; + decoder->guts->frame.header.sample_rate = 44100; break; case 10: - decoder->guts->frame_header.sample_rate = 48000; + decoder->guts->frame.header.sample_rate = 48000; break; case 11: - decoder->guts->frame_header.sample_rate = 96000; + decoder->guts->frame.header.sample_rate = 96000; break; case 12: case 13: @@ -777,16 +781,16 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) x = (unsigned)(raw_header[2] >> 4); if(x & 8) { - decoder->guts->frame_header.channels = 2; + decoder->guts->frame.header.channels = 2; switch(x & 7) { case 0: - decoder->guts->frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE; + decoder->guts->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE; break; case 1: - decoder->guts->frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE; + decoder->guts->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE; break; case 2: - decoder->guts->frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE; + decoder->guts->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE; break; default: is_unparseable = true; @@ -794,31 +798,31 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) } } else { - decoder->guts->frame_header.channels = (unsigned)x + 1; - decoder->guts->frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; + decoder->guts->frame.header.channels = (unsigned)x + 1; + decoder->guts->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; } switch(x = (unsigned)(raw_header[2] & 0x0e) >> 1) { case 0: if(decoder->guts->has_stream_header) - decoder->guts->frame_header.bits_per_sample = decoder->guts->stream_header.data.encoding.bits_per_sample; + decoder->guts->frame.header.bits_per_sample = decoder->guts->stream_header.data.encoding.bits_per_sample; else is_unparseable = true; break; case 1: - decoder->guts->frame_header.bits_per_sample = 8; + decoder->guts->frame.header.bits_per_sample = 8; break; case 2: - decoder->guts->frame_header.bits_per_sample = 12; + decoder->guts->frame.header.bits_per_sample = 12; break; case 4: - decoder->guts->frame_header.bits_per_sample = 16; + decoder->guts->frame.header.bits_per_sample = 16; break; case 5: - decoder->guts->frame_header.bits_per_sample = 20; + decoder->guts->frame.header.bits_per_sample = 20; break; case 6: - decoder->guts->frame_header.bits_per_sample = 24; + decoder->guts->frame.header.bits_per_sample = 24; break; case 3: case 7: @@ -860,9 +864,9 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) } } if(decoder->guts->has_stream_header && decoder->guts->stream_header.data.encoding.min_blocksize == decoder->guts->stream_header.data.encoding.max_blocksize) /* i.e. it's a fixed-blocksize stream */ - decoder->guts->frame_header.number.sample_number = (uint64)decoder->guts->last_frame_number * (int64)decoder->guts->stream_header.data.encoding.min_blocksize + xx; + decoder->guts->frame.header.number.sample_number = (uint64)decoder->guts->last_frame_number * (int64)decoder->guts->stream_header.data.encoding.min_blocksize + xx; else - decoder->guts->frame_header.number.sample_number = xx; + decoder->guts->frame.header.number.sample_number = xx; } else { if(!FLAC__bitbuffer_read_utf8_uint32(&decoder->guts->input, &x, read_callback_, decoder, raw_header, &raw_header_len)) @@ -890,7 +894,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) } decoder->guts->last_frame_number = x; if(decoder->guts->has_stream_header) { - decoder->guts->frame_header.number.sample_number = (int64)decoder->guts->stream_header.data.encoding.min_blocksize * (int64)x; + decoder->guts->frame.header.number.sample_number = (int64)decoder->guts->stream_header.data.encoding.min_blocksize * (int64)x; } else { is_unparseable = true; @@ -908,7 +912,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) raw_header[raw_header_len++] = (byte)_x; x = (x << 8) | _x; } - decoder->guts->frame_header.blocksize = x+1; + decoder->guts->frame.header.blocksize = x+1; } if(sample_rate_hint) { @@ -923,11 +927,11 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) x = (x << 8) | _x; } if(sample_rate_hint == 12) - decoder->guts->frame_header.sample_rate = x*1000; + decoder->guts->frame.header.sample_rate = x*1000; else if(sample_rate_hint == 13) - decoder->guts->frame_header.sample_rate = x; + decoder->guts->frame.header.sample_rate = x; else - decoder->guts->frame_header.sample_rate = x*10; + decoder->guts->frame.header.sample_rate = x*10; } /* read the crc byte */ @@ -953,7 +957,7 @@ bool stream_decoder_read_subframe_(FLAC__StreamDecoder *decoder, unsigned channe { uint32 x; - if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &x, FLAC__SUBFRAME_HEADER_TYPE_LEN, read_callback_, decoder)) + if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &x, FLAC__SUBFRAME_TYPE_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ if(x & 0x01 || x & 0x80) { decoder->guts->error_callback(decoder, FLAC__STREAM_DECODER_ERROR_LOST_SYNC, decoder->guts->client_data); @@ -984,43 +988,53 @@ bool stream_decoder_read_subframe_(FLAC__StreamDecoder *decoder, unsigned channe bool stream_decoder_read_subframe_constant_(FLAC__StreamDecoder *decoder, unsigned channel) { + FLAC__Subframe_Constant *subframe = &decoder->guts->frame.subframes[channel].data.constant; int32 x; unsigned i; + int32 *output = decoder->guts->output[channel]; - if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &x, decoder->guts->frame_header.bits_per_sample, read_callback_, decoder)) + decoder->guts->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT; + + if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &x, decoder->guts->frame.header.bits_per_sample, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - for(i = 0; i < decoder->guts->frame_header.blocksize; i++) - decoder->guts->output[channel][i] = x; + subframe->value = x; + + /* decode the subframe */ + for(i = 0; i < decoder->guts->frame.header.blocksize; i++) + output[i] = x; return true; } bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned channel, const unsigned order) { - FLAC__SubframeHeader_Fixed subframe_header; + FLAC__Subframe_Fixed *subframe = &decoder->guts->frame.subframes[channel].data.fixed; int32 i32; uint32 u32; unsigned u; - subframe_header.order = order; + decoder->guts->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_FIXED; + + subframe->residual = decoder->guts->residual[channel]; + subframe->order = order; /* read warm-up samples */ for(u = 0; u < order; u++) { - if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, decoder->guts->frame_header.bits_per_sample, read_callback_, decoder)) + if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, decoder->guts->frame.header.bits_per_sample, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - decoder->guts->output[channel][u] = i32; + subframe->warmup[u] = i32; } /* read entropy coding method info */ if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - subframe_header.entropy_coding_method.type = u32; - switch(subframe_header.entropy_coding_method.type) { + subframe->entropy_coding_method.type = u32; + switch(subframe->entropy_coding_method.type) { case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - subframe_header.entropy_coding_method.data.partitioned_rice.order = u32; + subframe->entropy_coding_method.data.partitioned_rice.order = u32; break; default: decoder->state = FLAC__STREAM_DECODER_UNPARSEABLE_STREAM; @@ -1028,9 +1042,9 @@ bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned } /* read residual */ - switch(subframe_header.entropy_coding_method.type) { + switch(subframe->entropy_coding_method.type) { case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: - if(!stream_decoder_read_residual_partitioned_rice_(decoder, order, subframe_header.entropy_coding_method.data.partitioned_rice.order)) + if(!stream_decoder_read_residual_partitioned_rice_(decoder, order, subframe->entropy_coding_method.data.partitioned_rice.order, subframe->residual)) return false; break; default: @@ -1038,58 +1052,62 @@ bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned } /* decode the subframe */ - FLAC__fixed_restore_signal(decoder->guts->residual, decoder->guts->frame_header.blocksize-order, order, decoder->guts->output[channel]+order); + memcpy(decoder->guts->output[channel], subframe->warmup, sizeof(int32) * order); + FLAC__fixed_restore_signal(decoder->guts->residual[channel], decoder->guts->frame.header.blocksize-order, order, decoder->guts->output[channel]+order); return true; } bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned channel, const unsigned order) { - FLAC__SubframeHeader_LPC subframe_header; + FLAC__Subframe_LPC *subframe = &decoder->guts->frame.subframes[channel].data.lpc; int32 i32; uint32 u32; unsigned u; - subframe_header.order = order; + decoder->guts->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_LPC; + + subframe->residual = decoder->guts->residual[channel]; + subframe->order = order; /* read warm-up samples */ for(u = 0; u < order; u++) { - if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, decoder->guts->frame_header.bits_per_sample, read_callback_, decoder)) + if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, decoder->guts->frame.header.bits_per_sample, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - decoder->guts->output[channel][u] = i32; + subframe->warmup[u] = i32; } /* read qlp coeff precision */ - if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &u32, FLAC__SUBFRAME_HEADER_LPC_QLP_COEFF_PRECISION_LEN, read_callback_, decoder)) + if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &u32, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ if(u32 == 15) { decoder->guts->error_callback(decoder, FLAC__STREAM_DECODER_ERROR_LOST_SYNC, decoder->guts->client_data); decoder->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; return true; } - subframe_header.qlp_coeff_precision = u32+1; + subframe->qlp_coeff_precision = u32+1; /* read qlp shift */ - if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN, read_callback_, decoder)) + if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - subframe_header.quantization_level = i32; + subframe->quantization_level = i32; /* read quantized lp coefficiencts */ for(u = 0; u < order; u++) { - if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, subframe_header.qlp_coeff_precision, read_callback_, decoder)) + if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &i32, subframe->qlp_coeff_precision, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - subframe_header.qlp_coeff[u] = i32; + subframe->qlp_coeff[u] = i32; } /* read entropy coding method info */ if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - subframe_header.entropy_coding_method.type = u32; - switch(subframe_header.entropy_coding_method.type) { + subframe->entropy_coding_method.type = u32; + switch(subframe->entropy_coding_method.type) { case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - subframe_header.entropy_coding_method.data.partitioned_rice.order = u32; + subframe->entropy_coding_method.data.partitioned_rice.order = u32; break; default: decoder->state = FLAC__STREAM_DECODER_UNPARSEABLE_STREAM; @@ -1097,9 +1115,9 @@ bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned ch } /* read residual */ - switch(subframe_header.entropy_coding_method.type) { + switch(subframe->entropy_coding_method.type) { case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: - if(!stream_decoder_read_residual_partitioned_rice_(decoder, order, subframe_header.entropy_coding_method.data.partitioned_rice.order)) + if(!stream_decoder_read_residual_partitioned_rice_(decoder, order, subframe->entropy_coding_method.data.partitioned_rice.order, subframe->residual)) return false; break; default: @@ -1107,32 +1125,41 @@ bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned ch } /* decode the subframe */ - FLAC__lpc_restore_signal(decoder->guts->residual, decoder->guts->frame_header.blocksize-order, subframe_header.qlp_coeff, order, subframe_header.quantization_level, decoder->guts->output[channel]+order); + memcpy(decoder->guts->output[channel], subframe->warmup, sizeof(int32) * order); + FLAC__lpc_restore_signal(decoder->guts->residual[channel], decoder->guts->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->guts->output[channel]+order); return true; } bool stream_decoder_read_subframe_verbatim_(FLAC__StreamDecoder *decoder, unsigned channel) { + FLAC__Subframe_Verbatim *subframe = &decoder->guts->frame.subframes[channel].data.verbatim; int32 x; unsigned i; - for(i = 0; i < decoder->guts->frame_header.blocksize; i++) { - if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &x, decoder->guts->frame_header.bits_per_sample, read_callback_, decoder)) + decoder->guts->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM; + + subframe->data = decoder->guts->residual[channel]; + + for(i = 0; i < decoder->guts->frame.header.blocksize; i++) { + if(!FLAC__bitbuffer_read_raw_int32(&decoder->guts->input, &x, decoder->guts->frame.header.bits_per_sample, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - decoder->guts->output[channel][i] = x; + subframe->data[i] = x; } + /* decode the subframe */ + memcpy(decoder->guts->output[channel], subframe->data, sizeof(int32) * decoder->guts->frame.header.blocksize); + return true; } -bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order) +bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, unsigned predictor_order, unsigned partition_order, int32 *residual) { uint32 rice_parameter; int i; unsigned partition, sample, u; const unsigned partitions = 1u << partition_order; - const unsigned partition_samples = partition_order > 0? decoder->guts->frame_header.blocksize >> partition_order : decoder->guts->frame_header.blocksize - predictor_order; + const unsigned partition_samples = partition_order > 0? decoder->guts->frame.header.blocksize >> partition_order : decoder->guts->frame.header.blocksize - predictor_order; sample = 0; for(partition = 0; partition < partitions; partition++) { @@ -1141,7 +1168,7 @@ bool stream_decoder_read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder for(u = (partition_order == 0 || partition > 0)? 0 : predictor_order; u < partition_samples; u++, sample++) { if(!FLAC__bitbuffer_read_rice_signed(&decoder->guts->input, &i, rice_parameter, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ - decoder->guts->residual[sample] = i; + residual[sample] = i; } }