1/* libFLAC - Free Lossless Audio Codec library 2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * - Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 11 * - Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * - Neither the name of the Xiph.org Foundation nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR 23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32#ifndef FLAC__PRIVATE__LPC_H 33#define FLAC__PRIVATE__LPC_H 34 35#ifdef HAVE_CONFIG_H 36#include <config.h> 37#endif 38 39#include "private/float.h" 40#include "FLAC/format.h" 41 42#ifndef FLAC__INTEGER_ONLY_LIBRARY 43 44/* 45 * FLAC__lpc_window_data() 46 * -------------------------------------------------------------------- 47 * Applies the given window to the data. 48 * OPT: asm implementation 49 * 50 * IN in[0,data_len-1] 51 * IN window[0,data_len-1] 52 * OUT out[0,lag-1] 53 * IN data_len 54 */ 55void FLAC__lpc_window_data(const FLAC__int32 in[], const FLAC__real window[], FLAC__real out[], unsigned data_len); 56 57/* 58 * FLAC__lpc_compute_autocorrelation() 59 * -------------------------------------------------------------------- 60 * Compute the autocorrelation for lags between 0 and lag-1. 61 * Assumes data[] outside of [0,data_len-1] == 0. 62 * Asserts that lag > 0. 63 * 64 * IN data[0,data_len-1] 65 * IN data_len 66 * IN 0 < lag <= data_len 67 * OUT autoc[0,lag-1] 68 */ 69void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 70#ifndef FLAC__NO_ASM 71# ifdef FLAC__CPU_IA32 72# ifdef FLAC__HAS_NASM 73void FLAC__lpc_compute_autocorrelation_asm_ia32(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 74void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 75void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 76void FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 77void FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 78# endif 79# endif 80#endif 81 82/* 83 * FLAC__lpc_compute_lp_coefficients() 84 * -------------------------------------------------------------------- 85 * Computes LP coefficients for orders 1..max_order. 86 * Do not call if autoc[0] == 0.0. This means the signal is zero 87 * and there is no point in calculating a predictor. 88 * 89 * IN autoc[0,max_order] autocorrelation values 90 * IN 0 < max_order <= FLAC__MAX_LPC_ORDER max LP order to compute 91 * OUT lp_coeff[0,max_order-1][0,max_order-1] LP coefficients for each order 92 * *** IMPORTANT: 93 * *** lp_coeff[0,max_order-1][max_order,FLAC__MAX_LPC_ORDER-1] are untouched 94 * OUT error[0,max_order-1] error for each order (more 95 * specifically, the variance of 96 * the error signal times # of 97 * samples in the signal) 98 * 99 * Example: if max_order is 9, the LP coefficients for order 9 will be 100 * in lp_coeff[8][0,8], the LP coefficients for order 8 will be 101 * in lp_coeff[7][0,7], etc. 102 */ 103void FLAC__lpc_compute_lp_coefficients(const FLAC__real autoc[], unsigned *max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], FLAC__double error[]); 104 105/* 106 * FLAC__lpc_quantize_coefficients() 107 * -------------------------------------------------------------------- 108 * Quantizes the LP coefficients. NOTE: precision + bits_per_sample 109 * must be less than 32 (sizeof(FLAC__int32)*8). 110 * 111 * IN lp_coeff[0,order-1] LP coefficients 112 * IN order LP order 113 * IN FLAC__MIN_QLP_COEFF_PRECISION < precision 114 * desired precision (in bits, including sign 115 * bit) of largest coefficient 116 * OUT qlp_coeff[0,order-1] quantized coefficients 117 * OUT shift # of bits to shift right to get approximated 118 * LP coefficients. NOTE: could be negative. 119 * RETURN 0 => quantization OK 120 * 1 => coefficients require too much shifting for *shift to 121 * fit in the LPC subframe header. 'shift' is unset. 122 * 2 => coefficients are all zero, which is bad. 'shift' is 123 * unset. 124 */ 125int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], unsigned order, unsigned precision, FLAC__int32 qlp_coeff[], int *shift); 126 127/* 128 * FLAC__lpc_compute_residual_from_qlp_coefficients() 129 * -------------------------------------------------------------------- 130 * Compute the residual signal obtained from sutracting the predicted 131 * signal from the original. 132 * 133 * IN data[-order,data_len-1] original signal (NOTE THE INDICES!) 134 * IN data_len length of original signal 135 * IN qlp_coeff[0,order-1] quantized LP coefficients 136 * IN order > 0 LP order 137 * IN lp_quantization quantization of LP coefficients in bits 138 * OUT residual[0,data_len-1] residual signal 139 */ 140void 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[]); 141void FLAC__lpc_compute_residual_from_qlp_coefficients_wide(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]); 142#ifndef FLAC__NO_ASM 143# ifdef FLAC__CPU_IA32 144# ifdef FLAC__HAS_NASM 145void 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[]); 146void 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[]); 147# endif 148# endif 149#endif 150 151#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */ 152 153/* 154 * FLAC__lpc_restore_signal() 155 * -------------------------------------------------------------------- 156 * Restore the original signal by summing the residual and the 157 * predictor. 158 * 159 * IN residual[0,data_len-1] residual signal 160 * IN data_len length of original signal 161 * IN qlp_coeff[0,order-1] quantized LP coefficients 162 * IN order > 0 LP order 163 * IN lp_quantization quantization of LP coefficients in bits 164 * *** IMPORTANT: the caller must pass in the historical samples: 165 * IN data[-order,-1] previously-reconstructed historical samples 166 * OUT data[0,data_len-1] original signal 167 */ 168void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]); 169void FLAC__lpc_restore_signal_wide(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]); 170#ifndef FLAC__NO_ASM 171# ifdef FLAC__CPU_IA32 172# ifdef FLAC__HAS_NASM 173void 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[]); 174void 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[]); 175# endif /* FLAC__HAS_NASM */ 176# elif defined FLAC__CPU_PPC 177void FLAC__lpc_restore_signal_asm_ppc_altivec_16(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]); 178void FLAC__lpc_restore_signal_asm_ppc_altivec_16_order8(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[]); 179# endif/* FLAC__CPU_IA32 || FLAC__CPU_PPC */ 180#endif /* FLAC__NO_ASM */ 181 182#ifndef FLAC__INTEGER_ONLY_LIBRARY 183 184/* 185 * FLAC__lpc_compute_expected_bits_per_residual_sample() 186 * -------------------------------------------------------------------- 187 * Compute the expected number of bits per residual signal sample 188 * based on the LP error (which is related to the residual variance). 189 * 190 * IN lpc_error >= 0.0 error returned from calculating LP coefficients 191 * IN total_samples > 0 # of samples in residual signal 192 * RETURN expected bits per sample 193 */ 194FLAC__double FLAC__lpc_compute_expected_bits_per_residual_sample(FLAC__double lpc_error, unsigned total_samples); 195FLAC__double FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(FLAC__double lpc_error, FLAC__double error_scale); 196 197/* 198 * FLAC__lpc_compute_best_order() 199 * -------------------------------------------------------------------- 200 * Compute the best order from the array of signal errors returned 201 * during coefficient computation. 202 * 203 * IN lpc_error[0,max_order-1] >= 0.0 error returned from calculating LP coefficients 204 * IN max_order > 0 max LP order 205 * IN total_samples > 0 # of samples in residual signal 206 * IN overhead_bits_per_order # of bits overhead for each increased LP order 207 * (includes warmup sample size and quantized LP coefficient) 208 * RETURN [1,max_order] best order 209 */ 210unsigned FLAC__lpc_compute_best_order(const FLAC__double lpc_error[], unsigned max_order, unsigned total_samples, unsigned overhead_bits_per_order); 211 212#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */ 213 214#endif 215