add 3DNOW stuff from Miroslav
[flac.git] / src / libFLAC / include / private / lpc.h
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000,2001  Josh Coalson
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA  02111-1307, USA.
18  */
19
20 #ifndef FLAC__PRIVATE__LPC_H
21 #define FLAC__PRIVATE__LPC_H
22
23 #include "FLAC/ordinals.h"
24
25 #define FLAC__MAX_LPC_ORDER (32u)
26
27 /*
28  *      FLAC__lpc_compute_autocorrelation()
29  *      --------------------------------------------------------------------
30  *      Compute the autocorrelation for lags between 0 and lag-1.
31  *      Assumes data[] outside of [0,data_len-1] == 0.
32  *      Asserts that lag > 0.
33  *
34  *      IN data[0,data_len-1]
35  *      IN data_len
36  *      IN 0 < lag <= data_len
37  *      OUT autoc[0,lag-1]
38  */
39 void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
40 #ifndef FLAC__NO_ASM
41 #ifdef FLAC__CPU_IA32
42 #ifdef FLAC__HAS_NASM
43 void FLAC__lpc_compute_autocorrelation_asm_ia32(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
44 void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
45 void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
46 void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
47 void FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
48 #endif
49 #endif
50 #endif
51
52 /*
53  *      FLAC__lpc_compute_lp_coefficients()
54  *      --------------------------------------------------------------------
55  *      Computes LP coefficients for orders 1..max_order.
56  *      Do not call if autoc[0] == 0.0.  This means the signal is zero
57  *      and there is no point in calculating a predictor.
58  *
59  *      IN autoc[0,max_order]                      autocorrelation values
60  *      IN 0 < max_order <= FLAC__MAX_LPC_ORDER    max LP order to compute
61  *      OUT lp_coeff[0,max_order-1][0,max_order-1] LP coefficients for each order
62  *      *** IMPORTANT:
63  *      *** lp_coeff[0,max_order-1][max_order,FLAC__MAX_LPC_ORDER-1] are untouched
64  *      OUT error[0,max_order-1]                   error for each order
65  *
66  *      Example: if max_order is 9, the LP coefficients for order 9 will be
67  *               in lp_coeff[8][0,8], the LP coefficients for order 8 will be
68  *                       in lp_coeff[7][0,7], etc.
69  */
70 void FLAC__lpc_compute_lp_coefficients(const FLAC__real autoc[], unsigned max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], FLAC__real error[]);
71
72 /*
73  *      FLAC__lpc_quantize_coefficients()
74  *      --------------------------------------------------------------------
75  *      Quantizes the LP coefficients.  NOTE: precision + bits_per_sample
76  *      must be less than 32 (sizeof(FLAC__int32)*8).
77  *
78  *      IN lp_coeff[0,order-1]    LP coefficients
79  *      IN order                  LP order
80  *      IN FLAC__MIN_QLP_COEFF_PRECISION < precision
81  *                                desired precision (in bits, including sign
82  *                                bit) of largest coefficient
83  *      IN bits_per_sample > 0    bits per sample of the originial signal
84  *      OUT qlp_coeff[0,order-1]  quantized coefficients
85  *      OUT shift                 # of bits to shift right to get approximated
86  *                                LP coefficients.  NOTE: could be negative.
87  *      RETURN 0 => quantization OK
88  *             1 => coefficients require too much shifting for *shift to
89  *              fit in the LPC subframe header.  'shift' is unset.
90  *         2 => coefficients are all zero, which is bad.  'shift' is
91  *              unset.
92  */
93 int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], unsigned order, unsigned precision, unsigned bits_per_sample, FLAC__int32 qlp_coeff[], int *shift);
94
95 /*
96  *      FLAC__lpc_compute_residual_from_qlp_coefficients()
97  *      --------------------------------------------------------------------
98  *      Compute the residual signal obtained from sutracting the predicted
99  *      signal from the original.
100  *
101  *      IN data[-order,data_len-1] original signal (NOTE THE INDICES!)
102  *      IN data_len                length of original signal
103  *      IN qlp_coeff[0,order-1]    quantized LP coefficients
104  *      IN order > 0               LP order
105  *      IN lp_quantization         quantization of LP coefficients in bits
106  *      OUT residual[0,data_len-1] residual signal
107  */
108 void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
109 #ifndef FLAC__NO_ASM
110 #ifdef FLAC__CPU_IA32
111 #ifdef FLAC__HAS_NASM
112 void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
113 void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx(const FLAC__int32 data[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
114 #endif
115 #endif
116 #endif
117
118 /*
119  *      FLAC__lpc_restore_signal()
120  *      --------------------------------------------------------------------
121  *      Restore the original signal by summing the residual and the
122  *      predictor.
123  *
124  *      IN residual[0,data_len-1]  residual signal
125  *      IN data_len                length of original signal
126  *      IN qlp_coeff[0,order-1]    quantized LP coefficients
127  *      IN order > 0               LP order
128  *      IN lp_quantization         quantization of LP coefficients in bits
129  *      *** IMPORTANT: the caller must pass in the historical samples:
130  *      IN  data[-order,-1]        previously-reconstructed historical samples
131  *      OUT data[0,data_len-1]     original signal
132  */
133 void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
134 #ifndef FLAC__NO_ASM
135 #ifdef FLAC__CPU_IA32
136 #ifdef FLAC__HAS_NASM
137 void FLAC__lpc_restore_signal_asm_ia32(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
138 void FLAC__lpc_restore_signal_asm_ia32_mmx(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]);
139 #endif
140 #endif
141 #endif
142
143 /*
144  *      FLAC__lpc_compute_expected_bits_per_residual_sample()
145  *      --------------------------------------------------------------------
146  *      Compute the expected number of bits per residual signal sample
147  *      based on the LP error (which is related to the residual variance).
148  *
149  *      IN lpc_error >= 0.0   error returned from calculating LP coefficients
150  *      IN total_samples > 0  # of samples in residual signal
151  *      RETURN                expected bits per sample
152  */
153 FLAC__real FLAC__lpc_compute_expected_bits_per_residual_sample(FLAC__real lpc_error, unsigned total_samples);
154 FLAC__real FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(FLAC__real lpc_error, double error_scale);
155
156 /*
157  *      FLAC__lpc_compute_best_order()
158  *      --------------------------------------------------------------------
159  *      Compute the best order from the array of signal errors returned
160  *      during coefficient computation.
161  *
162  *      IN lpc_error[0,max_order-1] >= 0.0  error returned from calculating LP coefficients
163  *      IN max_order > 0                    max LP order
164  *      IN total_samples > 0                # of samples in residual signal
165  *      IN bits_per_signal_sample           # of bits per sample in the original signal
166  *      RETURN [1,max_order]                best order
167  */
168 unsigned FLAC__lpc_compute_best_order(const FLAC__real lpc_error[], unsigned max_order, unsigned total_samples, unsigned bits_per_signal_sample);
169
170 #endif