claunia/flac
1
0
Fork 0
mirror of https://github.com/claunia/flac.git synced 2025-12-16 18:54:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

revamp encoder/decoder interface to use set methods instead on args to init

Browse Source
This commit is contained in:
Josh Coalson
2001-06-16 07:32:25 +00:00
parent c84e95b6a2
commit 00e53874cd
15 changed files with 699 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
src/libFLAC/file_decoder.c
View File

@@ -78,6 +78,7 @@ const char *FLAC__FileDecoderStateString[] = {
"FLAC__FILE_DECODER_STREAM_ERROR",
"FLAC__FILE_DECODER_STREAM_DECODER_ERROR",
"FLAC__FILE_DECODER_ALREADY_INITIALIZED",
"FLAC__FILE_DECODER_INVALID_CALLBACK",
"FLAC__FILE_DECODER_UNINITIALIZED"
};
@@ -111,6 +112,12 @@ FLAC__FileDecoder *FLAC__file_decoder_new()
decoder->protected->state = FLAC__FILE_DECODER_UNINITIALIZED;
decoder->private->filename = 0;
decoder->private->write_callback = 0;
decoder->private->metadata_callback = 0;
decoder->private->error_callback = 0;
decoder->private->client_data = 0;
return decoder;
}
@@ -131,52 +138,32 @@ void FLAC__file_decoder_delete(FLAC__FileDecoder *decoder)
*
***********************************************************************/
FLAC__FileDecoderState FLAC__file_decoder_init(
FLAC__FileDecoder *decoder,
bool check_md5,
const char *filename,
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
)
FLAC__FileDecoderState FLAC__file_decoder_init(FLAC__FileDecoder *decoder)
{
FLAC__ASSERT(decoder != 0);
FLAC__ASSERT(write_callback != 0);
FLAC__ASSERT(metadata_callback != 0);
FLAC__ASSERT(error_callback != 0);
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return decoder->protected->state = FLAC__FILE_DECODER_ALREADY_INITIALIZED;
decoder->protected->state = FLAC__FILE_DECODER_OK;
decoder->protected->check_md5 = check_md5;
if(0 == decoder->private->write_callback || 0 == decoder->private->metadata_callback || 0 == decoder->private->error_callback)
return decoder->protected->state = FLAC__FILE_DECODER_INVALID_CALLBACK;
decoder->private->write_callback = write_callback;
decoder->private->metadata_callback = metadata_callback;
decoder->private->error_callback = error_callback;
decoder->private->client_data = client_data;
decoder->private->file = 0;
decoder->private->stream_decoder = 0;
decoder->private->filename = 0;
decoder->private->seek_table = 0;
if(0 == strcmp(filename, "-")) {
if(0 == strcmp(decoder->private->filename, "-"))
decoder->private->file = stdin;
}
else {
if(0 == (decoder->private->filename = (char*)malloc(strlen(filename)+1)))
return decoder->protected->state = FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
strcpy(decoder->private->filename, filename);
decoder->private->file = fopen(filename, "rb");
}
else
decoder->private->file = fopen(decoder->private->filename, "rb");
if(decoder->private->file == 0)
return decoder->protected->state = FLAC__FILE_DECODER_ERROR_OPENING_FILE;
/* We initialize the MD5Context even though we may never use it. This is
* because check_md5 may be turned on to start and then turned off if a
* because md5_checking may be turned on to start and then turned off if a
* seek occurs. So we always init the context here and finalize it in
* FLAC__file_decoder_finish() to make sure things are always cleaned up
* properly.
@@ -184,7 +171,14 @@ FLAC__FileDecoderState FLAC__file_decoder_init(
MD5Init(&decoder->private->md5context);
decoder->private->stream_decoder = FLAC__stream_decoder_new();
if(FLAC__stream_decoder_init(decoder->private->stream_decoder, read_callback_, write_callback_, metadata_callback_, error_callback_, decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
FLAC__stream_decoder_set_read_callback(decoder->private->stream_decoder, read_callback_);
FLAC__stream_decoder_set_write_callback(decoder->private->stream_decoder, write_callback_);
FLAC__stream_decoder_set_metadata_callback(decoder->private->stream_decoder, metadata_callback_);
FLAC__stream_decoder_set_error_callback(decoder->private->stream_decoder, error_callback_);
FLAC__stream_decoder_set_client_data(decoder->private->stream_decoder, decoder);
if(FLAC__stream_decoder_init(decoder->private->stream_decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
return decoder->protected->state = FLAC__FILE_DECODER_STREAM_DECODER_ERROR;
return decoder->protected->state;
@@ -209,7 +203,7 @@ bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
FLAC__stream_decoder_finish(decoder->private->stream_decoder);
FLAC__stream_decoder_delete(decoder->private->stream_decoder);
}
if(decoder->protected->check_md5) {
if(decoder->protected->md5_checking) {
if(memcmp(decoder->private->stored_md5sum, decoder->private->computed_md5sum, 16))
md5_failed = true;
}
@@ -217,14 +211,66 @@ bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
return !md5_failed;
}
FLAC__FileDecoderState FLAC__file_decoder_state(const FLAC__FileDecoder *decoder)
bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, bool value)
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
decoder->protected->md5_checking = value;
return true;
}
bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value)
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
if(0 == (decoder->private->filename = (char*)malloc(strlen(value)+1))) {
decoder->protected->state = FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
return false;
}
strcpy(decoder->private->filename, value);
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))
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
decoder->private->write_callback = value;
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))
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
decoder->private->metadata_callback = value;
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))
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
decoder->private->error_callback = value;
return true;
}
bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value)
{
if(decoder->protected->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
decoder->private->client_data = value;
return true;
}
FLAC__FileDecoderState FLAC__file_decoder_get_state(const FLAC__FileDecoder *decoder)
{
return decoder->protected->state;
}
bool FLAC__file_decoder_check_md5(const FLAC__FileDecoder *decoder)
bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
{
return decoder->protected->check_md5;
return decoder->protected->md5_checking;
}
bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder)
@@ -329,7 +375,7 @@ bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, uint64 sample)
decoder->protected->state = FLAC__FILE_DECODER_SEEKING;
/* turn off md5 checking if a seek is attempted */
decoder->protected->check_md5 = false;
decoder->protected->md5_checking = false;
if(!FLAC__stream_decoder_reset(decoder->private->stream_decoder)) {
decoder->protected->state = FLAC__FILE_DECODER_STREAM_ERROR;
@@ -421,7 +467,7 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decode
}
}
else {
if(file_decoder->protected->check_md5) {
if(file_decoder->protected->md5_checking) {
if(!FLAC__MD5Accumulate(&file_decoder->private->md5context, buffer, frame->header.channels, frame->header.blocksize, (frame->header.bits_per_sample+7) / 8))
return FLAC__STREAM_DECODER_WRITE_ABORT;
}
@@ -439,7 +485,7 @@ void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMe
/* save the MD5 signature for comparison later */
memcpy(file_decoder->private->stored_md5sum, metadata->data.stream_info.md5sum, 16);
if(0 == memcmp(file_decoder->private->stored_md5sum, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16))
file_decoder->protected->check_md5 = false;
file_decoder->protected->md5_checking = false;
}
else if(metadata->type == FLAC__METADATA_TYPE_SEEKTABLE) {
file_decoder->private->seek_table = &metadata->data.seek_table;
@@ -488,7 +534,7 @@ bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64
decoder->protected->state = FLAC__FILE_DECODER_SEEK_ERROR;
return false;
}
first_frame_offset -= FLAC__stream_decoder_input_bytes_unconsumed(decoder->private->stream_decoder);
first_frame_offset -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private->stream_decoder);
FLAC__ASSERT(first_frame_offset >= 0);
/*
@@ -610,7 +656,7 @@ bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64
decoder->protected->state = FLAC__FILE_DECODER_SEEK_ERROR;
return false;
}
pos -= FLAC__stream_decoder_input_bytes_unconsumed(decoder->private->stream_decoder);
pos -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private->stream_decoder);
needs_seek = false;
}
}

2
src/libFLAC/include/protected/file_decoder.h
View File

@@ -23,7 +23,7 @@
#include "FLAC/file_decoder.h"
typedef struct FLAC__FileDecoderProtected {
bool check_md5; /* if true, generate MD5 signature of decoded data and compare against signature in the Encoding metadata block */
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;

2
src/libFLAC/include/protected/stream_decoder.h
View File

@@ -34,6 +34,6 @@ typedef struct FLAC__StreamDecoderProtected {
/*
* return the number of input bytes consumed
*/
unsigned FLAC__stream_decoder_input_bytes_unconsumed(const FLAC__StreamDecoder *decoder);
unsigned FLAC__stream_decoder_get_input_bytes_unconsumed(const FLAC__StreamDecoder *decoder);
#endif

2
src/libFLAC/include/protected/stream_encoder.h
View File

@@ -40,6 +40,8 @@ typedef struct FLAC__StreamEncoderProtected {
unsigned rice_parameter_search_dist;
uint64 total_samples_estimate;
const FLAC__StreamMetaData_SeekTable *seek_table;
unsigned padding;
bool last_metadata_is_last;
} FLAC__StreamEncoderProtected;
#endif

80
src/libFLAC/stream_decoder.c
View File

@@ -104,6 +104,7 @@ const char *FLAC__StreamDecoderStateString[] = {
"FLAC__STREAM_DECODER_UNPARSEABLE_STREAM",
"FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR",
"FLAC__STREAM_DECODER_ALREADY_INITIALIZED",
"FLAC__STREAM_DECODER_INVALID_CALLBACK",
"FLAC__STREAM_DECODER_UNINITIALIZED"
};
@@ -153,6 +154,12 @@ FLAC__StreamDecoder *FLAC__stream_decoder_new()
decoder->protected->state = FLAC__STREAM_DECODER_UNINITIALIZED;
decoder->private->read_callback = 0;
decoder->private->write_callback = 0;
decoder->private->metadata_callback = 0;
decoder->private->error_callback = 0;
decoder->private->client_data = 0;
return decoder;
}
@@ -173,32 +180,19 @@ void FLAC__stream_decoder_delete(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__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__StreamDecoderState FLAC__stream_decoder_init(FLAC__StreamDecoder *decoder)
{
unsigned i;
FLAC__ASSERT(decoder != 0);
FLAC__ASSERT(read_callback != 0);
FLAC__ASSERT(write_callback != 0);
FLAC__ASSERT(metadata_callback != 0);
FLAC__ASSERT(error_callback != 0);
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return decoder->protected->state = FLAC__STREAM_DECODER_ALREADY_INITIALIZED;
decoder->protected->state = FLAC__STREAM_DECODER_SEARCH_FOR_METADATA;
decoder->private->read_callback = read_callback;
decoder->private->write_callback = write_callback;
decoder->private->metadata_callback = metadata_callback;
decoder->private->error_callback = error_callback;
decoder->private->client_data = client_data;
if(0 == decoder->private->read_callback || 0 == decoder->private->write_callback || 0 == decoder->private->metadata_callback || 0 == decoder->private->error_callback)
return decoder->protected->state = FLAC__STREAM_DECODER_INVALID_CALLBACK;
FLAC__bitbuffer_init(&decoder->private->input);
@@ -267,32 +261,72 @@ void FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder)
decoder->protected->state = FLAC__STREAM_DECODER_UNINITIALIZED;
}
FLAC__StreamDecoderState FLAC__stream_decoder_state(const FLAC__StreamDecoder *decoder)
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))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
decoder->private->read_callback = value;
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))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
decoder->private->write_callback = value;
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))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
decoder->private->metadata_callback = value;
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))
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
decoder->private->error_callback = value;
return true;
}
bool FLAC__stream_decoder_set_client_data(const FLAC__StreamDecoder *decoder, void *value)
{
if(decoder->protected->state != FLAC__STREAM_DECODER_UNINITIALIZED)
return false;
decoder->private->client_data = value;
return true;
}
FLAC__StreamDecoderState FLAC__stream_decoder_get_state(const FLAC__StreamDecoder *decoder)
{
return decoder->protected->state;
}
unsigned FLAC__stream_decoder_channels(const FLAC__StreamDecoder *decoder)
unsigned FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder)
{
return decoder->protected->channels;
}
FLAC__ChannelAssignment FLAC__stream_decoder_channel_assignment(const FLAC__StreamDecoder *decoder)
FLAC__ChannelAssignment FLAC__stream_decoder_get_channel_assignment(const FLAC__StreamDecoder *decoder)
{
return decoder->protected->channel_assignment;
}
unsigned FLAC__stream_decoder_bits_per_sample(const FLAC__StreamDecoder *decoder)
unsigned FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder)
{
return decoder->protected->bits_per_sample;
}
unsigned FLAC__stream_decoder_sample_rate(const FLAC__StreamDecoder *decoder)
unsigned FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder)
{
return decoder->protected->sample_rate;
}
unsigned FLAC__stream_decoder_blocksize(const FLAC__StreamDecoder *decoder)
unsigned FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder)
{
return decoder->protected->blocksize;
}
@@ -464,7 +498,7 @@ bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder)
*
***********************************************************************/
unsigned FLAC__stream_decoder_input_bytes_unconsumed(const FLAC__StreamDecoder *decoder)
unsigned FLAC__stream_decoder_get_input_bytes_unconsumed(const FLAC__StreamDecoder *decoder)
{
FLAC__ASSERT(decoder != 0);
return decoder->private->input.bytes - decoder->private->input.consumed_bytes;

280
src/libFLAC/stream_encoder.c
View File

@@ -130,6 +130,7 @@ typedef struct FLAC__StreamEncoderPrivate {
const char *FLAC__StreamEncoderStateString[] = {
"FLAC__STREAM_ENCODER_OK",
"FLAC__STREAM_ENCODER_INVALID_CALLBACK",
"FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS",
"FLAC__STREAM_ENCODER_INVALID_BITS_PER_SAMPLE",
"FLAC__STREAM_ENCODER_INVALID_SAMPLE_RATE",
@@ -182,6 +183,29 @@ FLAC__StreamEncoder *FLAC__stream_encoder_new()
encoder->protected->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
encoder->protected->streamable_subset = true;
encoder->protected->do_mid_side_stereo = false;
encoder->protected->loose_mid_side_stereo = false;
encoder->protected->channels = 2;
encoder->protected->bits_per_sample = 16;
encoder->protected->sample_rate = 44100;
encoder->protected->blocksize = 1152;
encoder->protected->max_lpc_order = 0;
encoder->protected->qlp_coeff_precision = 0;
encoder->protected->do_qlp_coeff_prec_search = false;
encoder->protected->do_exhaustive_model_search = false;
encoder->protected->min_residual_partition_order = 0;
encoder->protected->max_residual_partition_order = 0;
encoder->protected->rice_parameter_search_dist = 0;
encoder->protected->total_samples_estimate = 0;
encoder->protected->seek_table = 0;
encoder->protected->padding = 0;
encoder->protected->last_metadata_is_last = true;
encoder->private->write_callback = 0;
encoder->private->metadata_callback = 0;
encoder->private->client_data = 0;
return encoder;
}
@@ -202,59 +226,21 @@ void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
*
***********************************************************************/
FLAC__StreamEncoderState FLAC__stream_encoder_init(
FLAC__StreamEncoder *encoder,
bool streamable_subset,
bool do_mid_side_stereo,
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,
unsigned min_residual_partition_order,
unsigned max_residual_partition_order,
unsigned rice_parameter_search_dist,
uint64 total_samples_estimate,
const FLAC__StreamMetaData_SeekTable *seek_table,
unsigned padding,
bool last_metadata_is_last,
FLAC__StreamEncoderWriteStatus (*write_callback)(const FLAC__StreamEncoder *encoder, const 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)
FLAC__StreamEncoderState FLAC__stream_encoder_init(FLAC__StreamEncoder *encoder)
{
unsigned i;
FLAC__StreamMetaData padding_block;
FLAC__StreamMetaData seek_table_block;
FLAC__ASSERT(encoder != 0);
FLAC__ASSERT(write_callback != 0);
FLAC__ASSERT(metadata_callback != 0);
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return encoder->protected->state = FLAC__STREAM_ENCODER_ALREADY_INITIALIZED;
encoder->protected->state = FLAC__STREAM_ENCODER_OK;
encoder->protected->streamable_subset = streamable_subset;
encoder->protected->do_mid_side_stereo = do_mid_side_stereo;
encoder->protected->loose_mid_side_stereo = loose_mid_side_stereo;
encoder->protected->channels = channels;
encoder->protected->bits_per_sample = bits_per_sample;
encoder->protected->sample_rate = sample_rate;
encoder->protected->blocksize = blocksize;
encoder->protected->max_lpc_order = max_lpc_order;
encoder->protected->qlp_coeff_precision = qlp_coeff_precision;
encoder->protected->do_qlp_coeff_prec_search = do_qlp_coeff_prec_search;
encoder->protected->do_exhaustive_model_search = do_exhaustive_model_search;
encoder->protected->min_residual_partition_order = min_residual_partition_order;
encoder->protected->max_residual_partition_order = max_residual_partition_order;
encoder->protected->rice_parameter_search_dist = rice_parameter_search_dist;
encoder->protected->total_samples_estimate = total_samples_estimate;
encoder->protected->seek_table = seek_table;
if(0 == encoder->private->write_callback || 0 == encoder->private->metadata_callback)
return encoder->protected->state = FLAC__STREAM_ENCODER_INVALID_CALLBACK;
if(encoder->protected->channels == 0 || encoder->protected->channels > FLAC__MAX_CHANNELS)
return encoder->protected->state = FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS;
@@ -411,9 +397,6 @@ FLAC__StreamEncoderState FLAC__stream_encoder_init(
return encoder->protected->state;
}
FLAC__bitbuffer_init(&encoder->private->frame);
encoder->private->write_callback = write_callback;
encoder->private->metadata_callback = metadata_callback;
encoder->private->client_data = client_data;
/*
* write the stream header
@@ -425,7 +408,7 @@ FLAC__StreamEncoderState FLAC__stream_encoder_init(
return encoder->protected->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
encoder->private->metadata.type = FLAC__METADATA_TYPE_STREAMINFO;
encoder->private->metadata.is_last = (encoder->protected->seek_table == 0 && padding == 0 && last_metadata_is_last);
encoder->private->metadata.is_last = (encoder->protected->seek_table == 0 && encoder->protected->padding == 0 && encoder->protected->last_metadata_is_last);
encoder->private->metadata.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
encoder->private->metadata.data.stream_info.min_blocksize = encoder->protected->blocksize; /* this encoder uses the same blocksize for the whole stream */
encoder->private->metadata.data.stream_info.max_blocksize = encoder->protected->blocksize;
@@ -444,7 +427,7 @@ FLAC__StreamEncoderState FLAC__stream_encoder_init(
if(!FLAC__seek_table_is_valid(encoder->protected->seek_table))
return encoder->protected->state = FLAC__STREAM_ENCODER_INVALID_SEEK_TABLE;
seek_table_block.type = FLAC__METADATA_TYPE_SEEKTABLE;
seek_table_block.is_last = (padding == 0 && last_metadata_is_last);
seek_table_block.is_last = (encoder->protected->padding == 0 && encoder->protected->last_metadata_is_last);
seek_table_block.length = encoder->protected->seek_table->num_points * FLAC__STREAM_METADATA_SEEKPOINT_LEN;
seek_table_block.data.seek_table = *encoder->protected->seek_table;
if(!FLAC__add_metadata_block(&seek_table_block, &encoder->private->frame))
@@ -452,10 +435,10 @@ FLAC__StreamEncoderState FLAC__stream_encoder_init(
}
/* add a PADDING block if requested */
if(padding > 0) {
if(encoder->protected->padding > 0) {
padding_block.type = FLAC__METADATA_TYPE_PADDING;
padding_block.is_last = last_metadata_is_last;
padding_block.length = padding;
padding_block.is_last = encoder->protected->last_metadata_is_last;
padding_block.length = encoder->protected->padding;
if(!FLAC__add_metadata_block(&padding_block, &encoder->private->frame))
return encoder->protected->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
}
@@ -539,77 +522,245 @@ void FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
encoder->protected->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
}
FLAC__StreamEncoderState FLAC__stream_encoder_state(const FLAC__StreamEncoder *encoder)
bool FLAC__stream_encoder_set_streamable_subset(const FLAC__StreamEncoder *encoder, bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->streamable_subset = value;
return true;
}
bool FLAC__stream_encoder_set_do_mid_side_stereo(const FLAC__StreamEncoder *encoder, bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->do_mid_side_stereo = value;
return true;
}
bool FLAC__stream_encoder_set_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder, bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->loose_mid_side_stereo = value;
return true;
}
bool FLAC__stream_encoder_set_channels(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->channels = value;
return true;
}
bool FLAC__stream_encoder_set_bits_per_sample(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->bits_per_sample = value;
return true;
}
bool FLAC__stream_encoder_set_sample_rate(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->sample_rate = value;
return true;
}
bool FLAC__stream_encoder_set_blocksize(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->blocksize = value;
return true;
}
bool FLAC__stream_encoder_set_max_lpc_order(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->max_lpc_order = value;
return true;
}
bool FLAC__stream_encoder_set_qlp_coeff_precision(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->qlp_coeff_precision = value;
return true;
}
bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder, bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->do_qlp_coeff_prec_search = value;
return true;
}
bool FLAC__stream_encoder_set_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder, bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->do_exhaustive_model_search = value;
return true;
}
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;
encoder->protected->min_residual_partition_order = value;
return true;
}
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;
encoder->protected->max_residual_partition_order = value;
return true;
}
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;
encoder->protected->rice_parameter_search_dist = value;
return true;
}
bool FLAC__stream_encoder_set_total_samples_estimate(const FLAC__StreamEncoder *encoder, uint64 value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->total_samples_estimate = value;
return true;
}
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;
encoder->protected->seek_table = value;
return true;
}
bool FLAC__stream_encoder_set_padding(const FLAC__StreamEncoder *encoder, unsigned value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->padding = value;
return true;
}
bool FLAC__stream_encoder_set_last_metadata_is_last(const FLAC__StreamEncoder *encoder, bool value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->protected->last_metadata_is_last = value;
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))
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->private->write_callback = value;
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))
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->private->metadata_callback = value;
return true;
}
bool FLAC__stream_encoder_set_client_data(const FLAC__StreamEncoder *encoder, void *value)
{
if(encoder->protected->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
return false;
encoder->private->client_data = value;
return true;
}
FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->state;
}
bool FLAC__stream_encoder_streamable_subset(const FLAC__StreamEncoder *encoder)
bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->streamable_subset;
}
bool FLAC__stream_encoder_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->do_mid_side_stereo;
}
bool FLAC__stream_encoder_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->loose_mid_side_stereo;
}
unsigned FLAC__stream_encoder_channels(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->channels;
}
unsigned FLAC__stream_encoder_bits_per_sample(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->bits_per_sample;
}
unsigned FLAC__stream_encoder_sample_rate(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->sample_rate;
}
unsigned FLAC__stream_encoder_blocksize(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->blocksize;
}
unsigned FLAC__stream_encoder_max_lpc_order(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->max_lpc_order;
}
unsigned FLAC__stream_encoder_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->qlp_coeff_precision;
}
bool FLAC__stream_encoder_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
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_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->do_exhaustive_model_search;
}
unsigned FLAC__stream_encoder_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->min_residual_partition_order;
}
unsigned FLAC__stream_encoder_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->max_residual_partition_order;
}
unsigned FLAC__stream_encoder_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
{
return encoder->protected->rice_parameter_search_dist;
}
@@ -1637,4 +1788,3 @@ unsigned stream_encoder_get_wasted_bits_(int32 signal[], unsigned samples)
return shift;
}