From b1939f8ec377c737394a2f25fa66dbc5e604253a Mon Sep 17 00:00:00 2001
From: Josh Coalson
Date: Mon, 16 Jul 2001 18:01:38 +0000
Subject: [PATCH] add docs for -E option
---
doc/documentation.html | 15 ++++++++++++---
man/flac.sgml | 14 +++++++++++++-
2 files changed, 25 insertions(+), 4 deletions(-)
diff --git a/doc/documentation.html b/doc/documentation.html
index 0a8aee33..ca712ee9 100644
--- a/doc/documentation.html
+++ b/doc/documentation.html
@@ -146,7 +146,7 @@
In the next stage, the encoder tries to approximate the signal with a function in such a way that when the approximation is subracted, the result (called the residual, residue, or error) requires fewer bits-per-sample to encode. The function's parameters also have to be transmitted so they should not be so complex as to eat up the savings. FLAC has two methods of forming approximations: 1) fitting a simple polynomial to the signal; and 2) general linear predictive coding (LPC). I will not go into the details here, only some generalities that involve the encoding options.

- First, fixed polynomial prediction (specified with -l 0) is much faster, but less accurate than LPC. The higher the maximum LPC order, the slower, but more accurate, the model will be. However, there are diminishing returns with increasing orders. Also, at some point (around order 9) the part of the encoder that guesses what is the best order to use will start to get it wrong and the compression will actually decrease slightly; at that point you will have to you will have to use the exhaustive search option -e to overcome this, which is significantly slower.
+ First, fixed polynomial prediction (specified with -l 0) is much faster, but less accurate than LPC. The higher the maximum LPC order, the slower, but more accurate, the model will be. However, there are diminishing returns with increasing orders. Also, at some point (usually around order 9) the part of the encoder that guesses what is the best order to use will start to get it wrong and the compression will actually decrease slightly; at that point you will have to you will have to use the exhaustive search option -e to overcome this, which is significantly slower.

Second, the parameters for the fixed predictors can be transmitted in 3 bits whereas the parameters for the LPC model depend on the bits-per-sample and LPC order. This means the frame header length varies depending on the method and order you choose and can affect the optimal block size.
@@ -528,7 +528,7 @@
-9
- Synonymous with -l 32 -b 4608 -m -e -r 16 -p. This is painfully slow but gives you the maximum compression flac can do for the given block size. It is more of a theoretical option without much practical use, since -8 will get you within tiny fractions of a percent of -9 and much faster.
+ Synonymous with -l 32 -b 4608 -m -e -E -r 16 -p. This is painfully slow but gives you the maximum compression flac can do for the given block size. It is more of a theoretical option without much practical use, since -8 will get you within tiny fractions of a percent of -9 and much faster.
@@ -541,6 +541,14 @@
+ -E
+
+
+ Do escape coding in the entropy coder. This causes the encoder to use an unencoded representation of the residual in a partition if it is smaller. It increases the runtime and usually results in an improvement of less than 1%.
+
+
+
+
-l #
@@ -592,7 +600,7 @@
- -S-, -m-, -e-, -p-, -V-, --delete-input-file-, --lax-, --sector-align- can all be used to turn off a particular option.
+ -S-, -m-, -e-, -E-, -p-, -V-, --delete-input-file-, --lax-, --sector-align- can all be used to turn off a particular option.
@@ -845,6 +853,7 @@

max_lpc_order - 0 implies encoder will not try general LPC, only fixed predictors; must be <= FLAC__MAX_LPC_ORDER.

qlp_coeff_precision - must be >= FLAC__MIN_QLP_COEFF_PRECISION, or 0 to let encoder select based on blocksize. In the current imlementation qlp_coeff_precision+bits_per_sample must be < 32.

do_qlp_coeff_prec_search - false to use qlp_coeff_precision; true to search around qlp_coeff_precision and take best.

+

do_escape_coding - true => search for escape codes in the entropy coding stage for slightly better compression.

do_exhaustive_model_search - false to use estimated bits per residual for scoring; true to generate all and take shortest.

min_residual_partition_order, max_residual_partition_order - 0 to estimate Rice parameter based on residual variance; > 0 to partition the residual and use parameter for each based on mean; min_residual_partition_order and max_residual_partition_order specify the min and max Rice partition order.

rice_parameter_search_dist - 0 to try only calculated parameter k; else try all [k-rice_parameter_search_dist..k+rice_parameter_search_dist] parameters and use the best.

diff --git a/man/flac.sgml b/man/flac.sgml
index d1c02825..d8501bd7 100644
--- a/man/flac.sgml
+++ b/man/flac.sgml
@@ -363,7 +363,7 @@
- Synonymous with -l 32 -b 4608 -m -e -r 16 -p
+ Synonymous with -l 32 -b 4608 -m -e -E -r 16 -p
(very slow!)
@@ -384,6 +384,18 @@
+
+
+
+ Do escape coding in the entropy coder. This
+ causes the encoder to use an unencoded representation
+ of the residual in a partition if it is smaller. It
+ increases the runtime and usually results in an
+ improvement of less than 1%.
+
+
+
+ max_lpc_order
--
2.11.0