add FLAC__stream_encoder_set_compression_level()

4 files changed, 135 insertions, 64 deletions

diff --git a/src/libFLAC++/stream_encoder.cpp b/src/libFLAC++/stream_encoder.cpp
index 6ab9ed03..a95b4f89 100644
--- a/src/libFLAC++/stream_encoder.cpp
+++ b/src/libFLAC++/stream_encoder.cpp
@@ -82,18 +82,6 @@ namespace FLAC {
 			return (bool)::FLAC__stream_encoder_set_streamable_subset(encoder_, value);
 		}
 
-		bool Stream::set_do_mid_side_stereo(bool value)
-		{
-			FLAC__ASSERT(is_valid());
-			return (bool)::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value);
-		}
-
-		bool Stream::set_loose_mid_side_stereo(bool value)
-		{
-			FLAC__ASSERT(is_valid());
-			return (bool)::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value);
-		}
-
 		bool Stream::set_channels(unsigned value)
 		{
 			FLAC__ASSERT(is_valid());
@@ -112,12 +100,30 @@ namespace FLAC {
 			return (bool)::FLAC__stream_encoder_set_sample_rate(encoder_, value);
 		}
 
+		bool Stream::set_compression_level(unsigned value)
+		{
+			FLAC__ASSERT(is_valid());
+			return (bool)::FLAC__stream_encoder_set_compression_level(encoder_, value);
+		}
+
 		bool Stream::set_blocksize(unsigned value)
 		{
 			FLAC__ASSERT(is_valid());
 			return (bool)::FLAC__stream_encoder_set_blocksize(encoder_, value);
 		}
 
+		bool Stream::set_do_mid_side_stereo(bool value)
+		{
+			FLAC__ASSERT(is_valid());
+			return (bool)::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value);
+		}
+
+		bool Stream::set_loose_mid_side_stereo(bool value)
+		{
+			FLAC__ASSERT(is_valid());
+			return (bool)::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value);
+		}
+
 		bool Stream::set_apodization(const char *specification)
 		{
 			FLAC__ASSERT(is_valid());
diff --git a/src/libFLAC/stream_encoder.c b/src/libFLAC/stream_encoder.c
index 51d9c392..702fa896 100644
--- a/src/libFLAC/stream_encoder.c
+++ b/src/libFLAC/stream_encoder.c
@@ -98,6 +98,31 @@ typedef enum {
 	ENCODER_IN_AUDIO = 2
 } EncoderStateHint;
 
+static struct CompressionLevels {
+	FLAC__bool do_mid_side_stereo;
+	FLAC__bool loose_mid_side_stereo;
+	const char *apodization;
+	unsigned max_lpc_order;
+	unsigned qlp_coeff_precision;
+	FLAC__bool do_qlp_coeff_prec_search;
+	FLAC__bool do_escape_coding;
+	FLAC__bool do_exhaustive_model_search;
+	unsigned min_residual_partition_order;
+	unsigned max_residual_partition_order;
+	unsigned rice_parameter_search_dist;
+} compression_levels_[] = {
+	{ false, false, "tukey(0.5)",  0, 0, false, false, false, 2, 2, 0 },
+	{ true , true , "tukey(0.5)",  0, 0, false, false, false, 2, 2, 0 },
+	{ true , false, "tukey(0.5)",  0, 0, false, false, false, 0, 3, 0 },
+	{ false, false, "tukey(0.5)",  6, 0, false, false, false, 3, 3, 0 },
+	{ true , true , "tukey(0.5)",  8, 0, false, false, false, 3, 3, 0 },
+	{ true , false, "tukey(0.5)",  8, 0, false, false, false, 3, 3, 0 },
+	{ true , false, "tukey(0.5)",  8, 0, false, false, false, 0, 4, 0 },
+	{ true , false, "tukey(0.5)",  8, 0, false, false, true , 0, 6, 0 },
+	{ true , false, "tukey(0.5)", 12, 0, false, false, true , 0, 6, 0 }
+};
+
+
 /***********************************************************************
  *
  * Private class method prototypes
@@ -469,8 +494,6 @@ FLAC_API const char * const FLAC__StreamEncoderInitStatusString[] = {
 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE",
 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER",
 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION",
-	"FLAC__STREAM_ENCODER_INIT_STATUS_MID_SIDE_CHANNELS_MISMATCH",
-	"FLAC__STREAM_ENCODER_INIT_STATUS_ILLEGAL_MID_SIDE_FORCE",
 	"FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
 	"FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE",
 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA",
@@ -647,11 +670,12 @@ static FLAC__StreamEncoderInitStatus init_stream_internal_(
 	if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS;
 
-	if(encoder->protected_->do_mid_side_stereo && encoder->protected_->channels != 2)
-		return FLAC__STREAM_ENCODER_INIT_STATUS_MID_SIDE_CHANNELS_MISMATCH;
-
-	if(encoder->protected_->loose_mid_side_stereo && !encoder->protected_->do_mid_side_stereo)
-		return FLAC__STREAM_ENCODER_INIT_STATUS_ILLEGAL_MID_SIDE_FORCE;
+	if(encoder->protected_->channels != 2) {
+		encoder->protected_->do_mid_side_stereo = false;
+		encoder->protected_->loose_mid_side_stereo = false;
+	}
+	else if(!encoder->protected_->do_mid_side_stereo)
+		encoder->protected_->loose_mid_side_stereo = false;
 
 	if(encoder->protected_->bits_per_sample >= 32)
 		encoder->protected_->do_mid_side_stereo = false; /* since we currenty do 32-bit math, the side channel would have 33 bps and overflow */
@@ -662,6 +686,13 @@ static FLAC__StreamEncoderInitStatus init_stream_internal_(
 	if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE;
 
+	if(encoder->protected_->blocksize == 0) {
+		if(encoder->protected_->max_lpc_order == 0)
+			encoder->protected_->blocksize = 1152;
+		else
+			encoder->protected_->blocksize = 4608;
+	}
+
 	if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE;
 
@@ -1411,69 +1442,93 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncod
 	return true;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
+FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
 		return false;
-	encoder->protected_->do_mid_side_stereo = value;
+	encoder->protected_->channels = value;
 	return true;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
+FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
 		return false;
-	encoder->protected_->loose_mid_side_stereo = value;
+	encoder->protected_->bits_per_sample = value;
 	return true;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
+FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
 		return false;
-	encoder->protected_->channels = value;
+	encoder->protected_->sample_rate = value;
 	return true;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
+FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value)
 {
+	FLAC__bool ok = true;
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
 		return false;
-	encoder->protected_->bits_per_sample = value;
+	if(value >= sizeof(compression_levels_)/sizeof(compression_levels_[0]))
+		value = sizeof(compression_levels_)/sizeof(compression_levels_[0]) - 1;
+	ok &= FLAC__stream_encoder_set_do_mid_side_stereo          (encoder, compression_levels_[value].do_mid_side_stereo);
+	ok &= FLAC__stream_encoder_set_loose_mid_side_stereo       (encoder, compression_levels_[value].loose_mid_side_stereo);
+	ok &= FLAC__stream_encoder_set_apodization                 (encoder, compression_levels_[value].apodization);
+	ok &= FLAC__stream_encoder_set_max_lpc_order               (encoder, compression_levels_[value].max_lpc_order);
+	ok &= FLAC__stream_encoder_set_qlp_coeff_precision         (encoder, compression_levels_[value].qlp_coeff_precision);
+	ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search    (encoder, compression_levels_[value].do_qlp_coeff_prec_search);
+	ok &= FLAC__stream_encoder_set_do_escape_coding            (encoder, compression_levels_[value].do_escape_coding);
+	ok &= FLAC__stream_encoder_set_do_exhaustive_model_search  (encoder, compression_levels_[value].do_exhaustive_model_search);
+	ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order);
+	ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order);
+	ok &= FLAC__stream_encoder_set_rice_parameter_search_dist  (encoder, compression_levels_[value].rice_parameter_search_dist);
+	return ok;
+}
+
+FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
+{
+	FLAC__ASSERT(0 != encoder);
+	FLAC__ASSERT(0 != encoder->private_);
+	FLAC__ASSERT(0 != encoder->protected_);
+	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
+		return false;
+	encoder->protected_->blocksize = value;
 	return true;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
+FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
 		return false;
-	encoder->protected_->sample_rate = value;
+	encoder->protected_->do_mid_side_stereo = value;
 	return true;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
+FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
 		return false;
-	encoder->protected_->blocksize = value;
+	encoder->protected_->loose_mid_side_stereo = value;
 	return true;
 }
 
@@ -1775,52 +1830,52 @@ FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__Strea
 	return encoder->protected_->streamable_subset;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
+FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
-	return encoder->protected_->do_mid_side_stereo;
+	return encoder->protected_->channels;
 }
 
-FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
+FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
-	return encoder->protected_->loose_mid_side_stereo;
+	return encoder->protected_->bits_per_sample;
 }
 
-FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
+FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
-	return encoder->protected_->channels;
+	return encoder->protected_->sample_rate;
 }
 
-FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
+FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
-	return encoder->protected_->bits_per_sample;
+	return encoder->protected_->blocksize;
 }
 
-FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
+FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
-	return encoder->protected_->sample_rate;
+	return encoder->protected_->do_mid_side_stereo;
 }
 
-FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
+FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
 {
 	FLAC__ASSERT(0 != encoder);
 	FLAC__ASSERT(0 != encoder->private_);
 	FLAC__ASSERT(0 != encoder->protected_);
-	return encoder->protected_->blocksize;
+	return encoder->protected_->loose_mid_side_stereo;
 }
 
 FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
@@ -2180,7 +2235,7 @@ void set_defaults_(FLAC__StreamEncoder *encoder)
 	encoder->protected_->channels = 2;
 	encoder->protected_->bits_per_sample = 16;
 	encoder->protected_->sample_rate = 44100;
-	encoder->protected_->blocksize = 1152;
+	encoder->protected_->blocksize = 0;
 #ifndef FLAC__INTEGER_ONLY_LIBRARY
 	encoder->protected_->num_apodizations = 1;
 	encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
diff --git a/src/test_libFLAC++/encoders.cpp b/src/test_libFLAC++/encoders.cpp
index 71803bc5..14364988 100644
--- a/src/test_libFLAC++/encoders.cpp
+++ b/src/test_libFLAC++/encoders.cpp
@@ -201,16 +201,6 @@ static bool test_stream_encoder(Layer layer, bool is_ogg)
 		return die_s_("returned false", encoder);
 	printf("OK\n");
 
-	printf("testing set_do_mid_side_stereo()... ");
-	if(!encoder->set_do_mid_side_stereo(false))
-		return die_s_("returned false", encoder);
-	printf("OK\n");
-
-	printf("testing set_loose_mid_side_stereo()... ");
-	if(!encoder->set_loose_mid_side_stereo(false))
-		return die_s_("returned false", encoder);
-	printf("OK\n");
-
 	printf("testing set_channels()... ");
 	if(!encoder->set_channels(streaminfo_.data.stream_info.channels))
 		return die_s_("returned false", encoder);
@@ -226,11 +216,26 @@ static bool test_stream_encoder(Layer layer, bool is_ogg)
 		return die_s_("returned false", encoder);
 	printf("OK\n");
 
+	printf("testing set_compression_level()... ");
+	if(!encoder->set_compression_level((unsigned)(-1)))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
 	printf("testing set_blocksize()... ");
 	if(!encoder->set_blocksize(streaminfo_.data.stream_info.min_blocksize))
 		return die_s_("returned false", encoder);
 	printf("OK\n");
 
+	printf("testing set_do_mid_side_stereo()... ");
+	if(!encoder->set_do_mid_side_stereo(false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing set_loose_mid_side_stereo()... ");
+	if(!encoder->set_loose_mid_side_stereo(false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
 	printf("testing set_max_lpc_order()... ");
 	if(!encoder->set_max_lpc_order(0))
 		return die_s_("returned false", encoder);
diff --git a/src/test_libFLAC/encoders.c b/src/test_libFLAC/encoders.c
index 686cc17f..ea945b0d 100644
--- a/src/test_libFLAC/encoders.c
+++ b/src/test_libFLAC/encoders.c
@@ -164,16 +164,6 @@ static FLAC__bool test_stream_encoder(Layer layer, FLAC__bool is_ogg)
 		return die_s_("returned false", encoder);
 	printf("OK\n");
 
-	printf("testing FLAC__stream_encoder_set_do_mid_side_stereo()... ");
-	if(!FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false))
-		return die_s_("returned false", encoder);
-	printf("OK\n");
-
-	printf("testing FLAC__stream_encoder_set_loose_mid_side_stereo()... ");
-	if(!FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false))
-		return die_s_("returned false", encoder);
-	printf("OK\n");
-
 	printf("testing FLAC__stream_encoder_set_channels()... ");
 	if(!FLAC__stream_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
 		return die_s_("returned false", encoder);
@@ -189,11 +179,26 @@ static FLAC__bool test_stream_encoder(Layer layer, FLAC__bool is_ogg)
 		return die_s_("returned false", encoder);
 	printf("OK\n");
 
+	printf("testing FLAC__stream_encoder_set_compression_level()... ");
+	if(!FLAC__stream_encoder_set_compression_level(encoder, (unsigned)(-1)))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
 	printf("testing FLAC__stream_encoder_set_blocksize()... ");
 	if(!FLAC__stream_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
 		return die_s_("returned false", encoder);
 	printf("OK\n");
 
+	printf("testing FLAC__stream_encoder_set_do_mid_side_stereo()... ");
+	if(!FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_loose_mid_side_stereo()... ");
+	if(!FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
 	printf("testing FLAC__stream_encoder_set_max_lpc_order()... ");
 	if(!FLAC__stream_encoder_set_max_lpc_order(encoder, 0))
 		return die_s_("returned false", encoder);