ffmpeg / libavcodec / lpc.c @ 1be0fc29
History  View  Annotate  Download (4.99 KB)
1 
/**


2 
* LPC utility code

3 
* Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
#include "libavutil/lls.h" 
23 
#include "dsputil.h" 
24  
25 
#define LPC_USE_DOUBLE

26 
#include "lpc.h" 
27  
28  
29 
/**

30 
* Quantize LPC coefficients

31 
*/

32 
static void quantize_lpc_coefs(double *lpc_in, int order, int precision, 
33 
int32_t *lpc_out, int *shift, int max_shift, int zero_shift) 
34 
{ 
35 
int i;

36 
double cmax, error;

37 
int32_t qmax; 
38 
int sh;

39  
40 
/* define maximum levels */

41 
qmax = (1 << (precision  1))  1; 
42  
43 
/* find maximum coefficient value */

44 
cmax = 0.0; 
45 
for(i=0; i<order; i++) { 
46 
cmax= FFMAX(cmax, fabs(lpc_in[i])); 
47 
} 
48  
49 
/* if maximum value quantizes to zero, return all zeros */

50 
if(cmax * (1 << max_shift) < 1.0) { 
51 
*shift = zero_shift; 
52 
memset(lpc_out, 0, sizeof(int32_t) * order); 
53 
return;

54 
} 
55  
56 
/* calculate level shift which scales max coeff to available bits */

57 
sh = max_shift; 
58 
while((cmax * (1 << sh) > qmax) && (sh > 0)) { 
59 
sh; 
60 
} 
61  
62 
/* since negative shift values are unsupported in decoder, scale down

63 
coefficients instead */

64 
if(sh == 0 && cmax > qmax) { 
65 
double scale = ((double)qmax) / cmax; 
66 
for(i=0; i<order; i++) { 
67 
lpc_in[i] *= scale; 
68 
} 
69 
} 
70  
71 
/* output quantized coefficients and level shift */

72 
error=0;

73 
for(i=0; i<order; i++) { 
74 
error = lpc_in[i] * (1 << sh);

75 
lpc_out[i] = av_clip(lrintf(error), qmax, qmax); 
76 
error = lpc_out[i]; 
77 
} 
78 
*shift = sh; 
79 
} 
80  
81 
static int estimate_best_order(double *ref, int min_order, int max_order) 
82 
{ 
83 
int i, est;

84  
85 
est = min_order; 
86 
for(i=max_order1; i>=min_order1; i) { 
87 
if(ref[i] > 0.10) { 
88 
est = i+1;

89 
break;

90 
} 
91 
} 
92 
return est;

93 
} 
94  
95 
/**

96 
* Calculate LPC coefficients for multiple orders

97 
*/

98 
int ff_lpc_calc_coefs(DSPContext *s,

99 
const int32_t *samples, int blocksize, int min_order, 
100 
int max_order, int precision, 
101 
int32_t coefs[][MAX_LPC_ORDER], int *shift, int use_lpc, 
102 
int omethod, int max_shift, int zero_shift) 
103 
{ 
104 
double autoc[MAX_LPC_ORDER+1]; 
105 
double ref[MAX_LPC_ORDER];

106 
double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];

107 
int i, j, pass;

108 
int opt_order;

109  
110 
assert(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER); 
111  
112 
if(use_lpc == 1){ 
113 
s>flac_compute_autocorr(samples, blocksize, max_order, autoc); 
114  
115 
compute_lpc_coefs(autoc, max_order, &lpc[0][0], MAX_LPC_ORDER, 0, 1); 
116  
117 
for(i=0; i<max_order; i++) 
118 
ref[i] = fabs(lpc[i][i]); 
119 
}else{

120 
LLSModel m[2];

121 
double var[MAX_LPC_ORDER+1], weight; 
122  
123 
for(pass=0; pass<use_lpc1; pass++){ 
124 
av_init_lls(&m[pass&1], max_order);

125  
126 
weight=0;

127 
for(i=max_order; i<blocksize; i++){

128 
for(j=0; j<=max_order; j++) 
129 
var[j]= samples[ij]; 
130  
131 
if(pass){

132 
double eval, inv, rinv;

133 
eval= av_evaluate_lls(&m[(pass1)&1], var+1, max_order1); 
134 
eval= (512>>pass) + fabs(eval  var[0]); 
135 
inv = 1/eval;

136 
rinv = sqrt(inv); 
137 
for(j=0; j<=max_order; j++) 
138 
var[j] *= rinv; 
139 
weight += inv; 
140 
}else

141 
weight++; 
142  
143 
av_update_lls(&m[pass&1], var, 1.0); 
144 
} 
145 
av_solve_lls(&m[pass&1], 0.001, 0); 
146 
} 
147  
148 
for(i=0; i<max_order; i++){ 
149 
for(j=0; j<max_order; j++) 
150 
lpc[i][j]=m[(pass1)&1].coeff[i][j]; 
151 
ref[i]= sqrt(m[(pass1)&1].variance[i] / weight) * (blocksize  max_order) / 4000; 
152 
} 
153 
for(i=max_order1; i>0; i) 
154 
ref[i] = ref[i1]  ref[i];

155 
} 
156 
opt_order = max_order; 
157  
158 
if(omethod == ORDER_METHOD_EST) {

159 
opt_order = estimate_best_order(ref, min_order, max_order); 
160 
i = opt_order1;

161 
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);

162 
} else {

163 
for(i=min_order1; i<max_order; i++) { 
164 
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);

165 
} 
166 
} 
167  
168 
return opt_order;

169 
} 