File: | libs/opus-1.1-p2/celt/quant_bands.c |
Location: | line 482, column 69 |
Description: | The right operand of '+' is a garbage value |
1 | /* Copyright (c) 2007-2008 CSIRO | |||
2 | Copyright (c) 2007-2009 Xiph.Org Foundation | |||
3 | Written by Jean-Marc Valin */ | |||
4 | /* | |||
5 | Redistribution and use in source and binary forms, with or without | |||
6 | modification, are permitted provided that the following conditions | |||
7 | are met: | |||
8 | ||||
9 | - Redistributions of source code must retain the above copyright | |||
10 | notice, this list of conditions and the following disclaimer. | |||
11 | ||||
12 | - Redistributions in binary form must reproduce the above copyright | |||
13 | notice, this list of conditions and the following disclaimer in the | |||
14 | documentation and/or other materials provided with the distribution. | |||
15 | ||||
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||
17 | ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||
18 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||
19 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER | |||
20 | OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |||
21 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |||
22 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |||
23 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |||
24 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |||
25 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |||
26 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||
27 | */ | |||
28 | ||||
29 | #ifdef HAVE_CONFIG_H1 | |||
30 | #include "config.h" | |||
31 | #endif | |||
32 | ||||
33 | #include "quant_bands.h" | |||
34 | #include "laplace.h" | |||
35 | #include <math.h> | |||
36 | #include "os_support.h" | |||
37 | #include "arch.h" | |||
38 | #include "mathops.h" | |||
39 | #include "stack_alloc.h" | |||
40 | #include "rate.h" | |||
41 | ||||
42 | #ifdef FIXED_POINT | |||
43 | /* Mean energy in each band quantized in Q4 */ | |||
44 | const signed char eMeans[25] = { | |||
45 | 103,100, 92, 85, 81, | |||
46 | 77, 72, 70, 78, 75, | |||
47 | 73, 71, 78, 74, 69, | |||
48 | 72, 70, 74, 76, 71, | |||
49 | 60, 60, 60, 60, 60 | |||
50 | }; | |||
51 | #else | |||
52 | /* Mean energy in each band quantized in Q4 and converted back to float */ | |||
53 | const opus_val16 eMeans[25] = { | |||
54 | 6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f, | |||
55 | 4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f, | |||
56 | 4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f, | |||
57 | 4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f, | |||
58 | 3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f | |||
59 | }; | |||
60 | #endif | |||
61 | /* prediction coefficients: 0.9, 0.8, 0.65, 0.5 */ | |||
62 | #ifdef FIXED_POINT | |||
63 | static const opus_val16 pred_coef[4] = {29440, 26112, 21248, 16384}; | |||
64 | static const opus_val16 beta_coef[4] = {30147, 22282, 12124, 6554}; | |||
65 | static const opus_val16 beta_intra = 4915; | |||
66 | #else | |||
67 | static const opus_val16 pred_coef[4] = {29440/32768., 26112/32768., 21248/32768., 16384/32768.}; | |||
68 | static const opus_val16 beta_coef[4] = {30147/32768., 22282/32768., 12124/32768., 6554/32768.}; | |||
69 | static const opus_val16 beta_intra = 4915/32768.; | |||
70 | #endif | |||
71 | ||||
72 | /*Parameters of the Laplace-like probability models used for the coarse energy. | |||
73 | There is one pair of parameters for each frame size, prediction type | |||
74 | (inter/intra), and band number. | |||
75 | The first number of each pair is the probability of 0, and the second is the | |||
76 | decay rate, both in Q8 precision.*/ | |||
77 | static const unsigned char e_prob_model[4][2][42] = { | |||
78 | /*120 sample frames.*/ | |||
79 | { | |||
80 | /*Inter*/ | |||
81 | { | |||
82 | 72, 127, 65, 129, 66, 128, 65, 128, 64, 128, 62, 128, 64, 128, | |||
83 | 64, 128, 92, 78, 92, 79, 92, 78, 90, 79, 116, 41, 115, 40, | |||
84 | 114, 40, 132, 26, 132, 26, 145, 17, 161, 12, 176, 10, 177, 11 | |||
85 | }, | |||
86 | /*Intra*/ | |||
87 | { | |||
88 | 24, 179, 48, 138, 54, 135, 54, 132, 53, 134, 56, 133, 55, 132, | |||
89 | 55, 132, 61, 114, 70, 96, 74, 88, 75, 88, 87, 74, 89, 66, | |||
90 | 91, 67, 100, 59, 108, 50, 120, 40, 122, 37, 97, 43, 78, 50 | |||
91 | } | |||
92 | }, | |||
93 | /*240 sample frames.*/ | |||
94 | { | |||
95 | /*Inter*/ | |||
96 | { | |||
97 | 83, 78, 84, 81, 88, 75, 86, 74, 87, 71, 90, 73, 93, 74, | |||
98 | 93, 74, 109, 40, 114, 36, 117, 34, 117, 34, 143, 17, 145, 18, | |||
99 | 146, 19, 162, 12, 165, 10, 178, 7, 189, 6, 190, 8, 177, 9 | |||
100 | }, | |||
101 | /*Intra*/ | |||
102 | { | |||
103 | 23, 178, 54, 115, 63, 102, 66, 98, 69, 99, 74, 89, 71, 91, | |||
104 | 73, 91, 78, 89, 86, 80, 92, 66, 93, 64, 102, 59, 103, 60, | |||
105 | 104, 60, 117, 52, 123, 44, 138, 35, 133, 31, 97, 38, 77, 45 | |||
106 | } | |||
107 | }, | |||
108 | /*480 sample frames.*/ | |||
109 | { | |||
110 | /*Inter*/ | |||
111 | { | |||
112 | 61, 90, 93, 60, 105, 42, 107, 41, 110, 45, 116, 38, 113, 38, | |||
113 | 112, 38, 124, 26, 132, 27, 136, 19, 140, 20, 155, 14, 159, 16, | |||
114 | 158, 18, 170, 13, 177, 10, 187, 8, 192, 6, 175, 9, 159, 10 | |||
115 | }, | |||
116 | /*Intra*/ | |||
117 | { | |||
118 | 21, 178, 59, 110, 71, 86, 75, 85, 84, 83, 91, 66, 88, 73, | |||
119 | 87, 72, 92, 75, 98, 72, 105, 58, 107, 54, 115, 52, 114, 55, | |||
120 | 112, 56, 129, 51, 132, 40, 150, 33, 140, 29, 98, 35, 77, 42 | |||
121 | } | |||
122 | }, | |||
123 | /*960 sample frames.*/ | |||
124 | { | |||
125 | /*Inter*/ | |||
126 | { | |||
127 | 42, 121, 96, 66, 108, 43, 111, 40, 117, 44, 123, 32, 120, 36, | |||
128 | 119, 33, 127, 33, 134, 34, 139, 21, 147, 23, 152, 20, 158, 25, | |||
129 | 154, 26, 166, 21, 173, 16, 184, 13, 184, 10, 150, 13, 139, 15 | |||
130 | }, | |||
131 | /*Intra*/ | |||
132 | { | |||
133 | 22, 178, 63, 114, 74, 82, 84, 83, 92, 82, 103, 62, 96, 72, | |||
134 | 96, 67, 101, 73, 107, 72, 113, 55, 118, 52, 125, 52, 118, 52, | |||
135 | 117, 55, 135, 49, 137, 39, 157, 32, 145, 29, 97, 33, 77, 40 | |||
136 | } | |||
137 | } | |||
138 | }; | |||
139 | ||||
140 | static const unsigned char small_energy_icdf[3]={2,1,0}; | |||
141 | ||||
142 | static opus_val32 loss_distortion(const opus_val16 *eBands, opus_val16 *oldEBands, int start, int end, int len, int C) | |||
143 | { | |||
144 | int c, i; | |||
145 | opus_val32 dist = 0; | |||
146 | c=0; do { | |||
147 | for (i=start;i<end;i++) | |||
148 | { | |||
149 | opus_val16 d = SUB16(SHR16(eBands[i+c*len], 3), SHR16(oldEBands[i+c*len], 3))(((eBands[i+c*len]))-((oldEBands[i+c*len]))); | |||
150 | dist = MAC16_16(dist, d,d)((dist)+(opus_val32)(d)*(opus_val32)(d)); | |||
151 | } | |||
152 | } while (++c<C); | |||
153 | return MIN32(200,SHR32(dist,2*DB_SHIFT-6))((200) < ((dist)) ? (200) : ((dist))); | |||
154 | } | |||
155 | ||||
156 | static int quant_coarse_energy_impl(const CELTModeOpusCustomMode *m, int start, int end, | |||
157 | const opus_val16 *eBands, opus_val16 *oldEBands, | |||
158 | opus_int32 budget, opus_int32 tell, | |||
159 | const unsigned char *prob_model, opus_val16 *error, ec_enc *enc, | |||
160 | int C, int LM, int intra, opus_val16 max_decay, int lfe) | |||
161 | { | |||
162 | int i, c; | |||
163 | int badness = 0; | |||
164 | opus_val32 prev[2] = {0,0}; | |||
165 | opus_val16 coef; | |||
166 | opus_val16 beta; | |||
167 | ||||
168 | if (tell+3 <= budget) | |||
169 | ec_enc_bit_logp(enc, intra, 3); | |||
170 | if (intra) | |||
171 | { | |||
172 | coef = 0; | |||
173 | beta = beta_intra; | |||
174 | } else { | |||
175 | beta = beta_coef[LM]; | |||
176 | coef = pred_coef[LM]; | |||
177 | } | |||
178 | ||||
179 | /* Encode at a fixed coarse resolution */ | |||
180 | for (i=start;i<end;i++) | |||
181 | { | |||
182 | c=0; | |||
183 | do { | |||
184 | int bits_left; | |||
185 | int qi, qi0; | |||
186 | opus_val32 q; | |||
187 | opus_val16 x; | |||
188 | opus_val32 f, tmp; | |||
189 | opus_val16 oldE; | |||
190 | opus_val16 decay_bound; | |||
191 | x = eBands[i+c*m->nbEBands]; | |||
192 | oldE = MAX16(-QCONST16(9.f,DB_SHIFT), oldEBands[i+c*m->nbEBands])((-(9.f)) > (oldEBands[i+c*m->nbEBands]) ? (-(9.f)) : ( oldEBands[i+c*m->nbEBands])); | |||
193 | #ifdef FIXED_POINT | |||
194 | f = SHL32(EXTEND32(x),7)((x)) - PSHR32(MULT16_16(coef,oldE), 8)(((opus_val32)(coef)*(opus_val32)(oldE))) - prev[c]; | |||
195 | /* Rounding to nearest integer here is really important! */ | |||
196 | qi = (f+QCONST32(.5f,DB_SHIFT+7)(.5f))>>(DB_SHIFT+7); | |||
197 | decay_bound = EXTRACT16(MAX32(-QCONST16(28.f,DB_SHIFT),(((-(28.f)) > ((((opus_val32)oldEBands[i+c*m->nbEBands] )-(max_decay))) ? (-(28.f)) : ((((opus_val32)oldEBands[i+c*m-> nbEBands])-(max_decay))))) | |||
198 | SUB32((opus_val32)oldEBands[i+c*m->nbEBands],max_decay)))(((-(28.f)) > ((((opus_val32)oldEBands[i+c*m->nbEBands] )-(max_decay))) ? (-(28.f)) : ((((opus_val32)oldEBands[i+c*m-> nbEBands])-(max_decay))))); | |||
199 | #else | |||
200 | f = x-coef*oldE-prev[c]; | |||
201 | /* Rounding to nearest integer here is really important! */ | |||
202 | qi = (int)floor(.5f+f); | |||
203 | decay_bound = MAX16(-QCONST16(28.f,DB_SHIFT), oldEBands[i+c*m->nbEBands])((-(28.f)) > (oldEBands[i+c*m->nbEBands]) ? (-(28.f)) : (oldEBands[i+c*m->nbEBands])) - max_decay; | |||
204 | #endif | |||
205 | /* Prevent the energy from going down too quickly (e.g. for bands | |||
206 | that have just one bin) */ | |||
207 | if (qi < 0 && x < decay_bound) | |||
208 | { | |||
209 | qi += (int)SHR16(SUB16(decay_bound,x), DB_SHIFT)(((decay_bound)-(x))); | |||
210 | if (qi > 0) | |||
211 | qi = 0; | |||
212 | } | |||
213 | qi0 = qi; | |||
214 | /* If we don't have enough bits to encode all the energy, just assume | |||
215 | something safe. */ | |||
216 | tell = ec_tell(enc); | |||
217 | bits_left = budget-tell-3*C*(end-i); | |||
218 | if (i!=start && bits_left < 30) | |||
219 | { | |||
220 | if (bits_left < 24) | |||
221 | qi = IMIN(1, qi)((1) < (qi) ? (1) : (qi)); | |||
222 | if (bits_left < 16) | |||
223 | qi = IMAX(-1, qi)((-1) > (qi) ? (-1) : (qi)); | |||
224 | } | |||
225 | if (lfe && i>=2) | |||
226 | qi = IMIN(qi, 0)((qi) < (0) ? (qi) : (0)); | |||
227 | if (budget-tell >= 15) | |||
228 | { | |||
229 | int pi; | |||
230 | pi = 2*IMIN(i,20)((i) < (20) ? (i) : (20)); | |||
231 | ec_laplace_encode(enc, &qi, | |||
232 | prob_model[pi]<<7, prob_model[pi+1]<<6); | |||
233 | } | |||
234 | else if(budget-tell >= 2) | |||
235 | { | |||
236 | qi = IMAX(-1, IMIN(qi, 1))((-1) > (((qi) < (1) ? (qi) : (1))) ? (-1) : (((qi) < (1) ? (qi) : (1)))); | |||
237 | ec_enc_icdf(enc, 2*qi^-(qi<0), small_energy_icdf, 2); | |||
238 | } | |||
239 | else if(budget-tell >= 1) | |||
240 | { | |||
241 | qi = IMIN(0, qi)((0) < (qi) ? (0) : (qi)); | |||
242 | ec_enc_bit_logp(enc, -qi, 1); | |||
243 | } | |||
244 | else | |||
245 | qi = -1; | |||
246 | error[i+c*m->nbEBands] = PSHR32(f,7)(f) - SHL16(qi,DB_SHIFT)(qi); | |||
247 | badness += abs(qi0-qi); | |||
248 | q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT)((qi)); | |||
249 | ||||
250 | tmp = PSHR32(MULT16_16(coef,oldE),8)(((opus_val32)(coef)*(opus_val32)(oldE))) + prev[c] + SHL32(q,7)(q); | |||
251 | #ifdef FIXED_POINT | |||
252 | tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp)((-(28.f)) > (tmp) ? (-(28.f)) : (tmp)); | |||
253 | #endif | |||
254 | oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7)(tmp); | |||
255 | prev[c] = prev[c] + SHL32(q,7)(q) - MULT16_16(beta,PSHR32(q,8))((opus_val32)(beta)*(opus_val32)((q))); | |||
256 | } while (++c < C); | |||
257 | } | |||
258 | return lfe ? 0 : badness; | |||
259 | } | |||
260 | ||||
261 | void quant_coarse_energy(const CELTModeOpusCustomMode *m, int start, int end, int effEnd, | |||
262 | const opus_val16 *eBands, opus_val16 *oldEBands, opus_uint32 budget, | |||
263 | opus_val16 *error, ec_enc *enc, int C, int LM, int nbAvailableBytes, | |||
264 | int force_intra, opus_val32 *delayedIntra, int two_pass, int loss_rate, int lfe) | |||
265 | { | |||
266 | int intra; | |||
267 | opus_val16 max_decay; | |||
268 | VARDECL(opus_val16, oldEBands_intra); | |||
269 | VARDECL(opus_val16, error_intra); | |||
270 | ec_enc enc_start_state; | |||
271 | opus_uint32 tell; | |||
272 | int badness1=0; | |||
273 | opus_int32 intra_bias; | |||
274 | opus_val32 new_distortion; | |||
275 | SAVE_STACK; | |||
276 | ||||
277 | intra = force_intra || (!two_pass && *delayedIntra>2*C*(end-start) && nbAvailableBytes > (end-start)*C); | |||
278 | intra_bias = (opus_int32)((budget**delayedIntra*loss_rate)/(C*512)); | |||
279 | new_distortion = loss_distortion(eBands, oldEBands, start, effEnd, m->nbEBands, C); | |||
280 | ||||
281 | tell = ec_tell(enc); | |||
282 | if (tell+3 > budget) | |||
283 | two_pass = intra = 0; | |||
284 | ||||
285 | max_decay = QCONST16(16.f,DB_SHIFT)(16.f); | |||
286 | if (end-start>10) | |||
287 | { | |||
288 | #ifdef FIXED_POINT | |||
289 | max_decay = MIN32(max_decay, SHL32(EXTEND32(nbAvailableBytes),DB_SHIFT-3))((max_decay) < (((nbAvailableBytes))) ? (max_decay) : (((nbAvailableBytes )))); | |||
290 | #else | |||
291 | max_decay = MIN32(max_decay, .125f*nbAvailableBytes)((max_decay) < (.125f*nbAvailableBytes) ? (max_decay) : (.125f *nbAvailableBytes)); | |||
292 | #endif | |||
293 | } | |||
294 | if (lfe) | |||
295 | max_decay=3; | |||
296 | enc_start_state = *enc; | |||
297 | ||||
298 | ALLOC(oldEBands_intra, C*m->nbEBands, opus_val16)opus_val16 oldEBands_intra[C*m->nbEBands]; | |||
299 | ALLOC(error_intra, C*m->nbEBands, opus_val16)opus_val16 error_intra[C*m->nbEBands]; | |||
300 | OPUS_COPY(oldEBands_intra, oldEBands, C*m->nbEBands)(memcpy((oldEBands_intra), (oldEBands), (C*m->nbEBands)*sizeof (*(oldEBands_intra)) + 0*((oldEBands_intra)-(oldEBands)) )); | |||
301 | ||||
302 | if (two_pass || intra) | |||
303 | { | |||
304 | badness1 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands_intra, budget, | |||
305 | tell, e_prob_model[LM][1], error_intra, enc, C, LM, 1, max_decay, lfe); | |||
306 | } | |||
307 | ||||
308 | if (!intra) | |||
309 | { | |||
310 | unsigned char *intra_buf; | |||
311 | ec_enc enc_intra_state; | |||
312 | opus_int32 tell_intra; | |||
313 | opus_uint32 nstart_bytes; | |||
314 | opus_uint32 nintra_bytes; | |||
315 | opus_uint32 save_bytes; | |||
316 | int badness2; | |||
317 | VARDECL(unsigned char, intra_bits); | |||
318 | ||||
319 | tell_intra = ec_tell_frac(enc); | |||
320 | ||||
321 | enc_intra_state = *enc; | |||
322 | ||||
323 | nstart_bytes = ec_range_bytes(&enc_start_state); | |||
324 | nintra_bytes = ec_range_bytes(&enc_intra_state); | |||
325 | intra_buf = ec_get_buffer(&enc_intra_state) + nstart_bytes; | |||
326 | save_bytes = nintra_bytes-nstart_bytes; | |||
327 | if (save_bytes == 0) | |||
328 | save_bytes = ALLOC_NONE1; | |||
329 | ALLOC(intra_bits, save_bytes, unsigned char)unsigned char intra_bits[save_bytes]; | |||
330 | /* Copy bits from intra bit-stream */ | |||
331 | OPUS_COPY(intra_bits, intra_buf, nintra_bytes - nstart_bytes)(memcpy((intra_bits), (intra_buf), (nintra_bytes - nstart_bytes )*sizeof(*(intra_bits)) + 0*((intra_bits)-(intra_buf)) )); | |||
332 | ||||
333 | *enc = enc_start_state; | |||
334 | ||||
335 | badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget, | |||
336 | tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay, lfe); | |||
337 | ||||
338 | if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ((opus_int32)ec_tell_frac(enc))+intra_bias > tell_intra))) | |||
339 | { | |||
340 | *enc = enc_intra_state; | |||
341 | /* Copy intra bits to bit-stream */ | |||
342 | OPUS_COPY(intra_buf, intra_bits, nintra_bytes - nstart_bytes)(memcpy((intra_buf), (intra_bits), (nintra_bytes - nstart_bytes )*sizeof(*(intra_buf)) + 0*((intra_buf)-(intra_bits)) )); | |||
343 | OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands)(memcpy((oldEBands), (oldEBands_intra), (C*m->nbEBands)*sizeof (*(oldEBands)) + 0*((oldEBands)-(oldEBands_intra)) )); | |||
344 | OPUS_COPY(error, error_intra, C*m->nbEBands)(memcpy((error), (error_intra), (C*m->nbEBands)*sizeof(*(error )) + 0*((error)-(error_intra)) )); | |||
345 | intra = 1; | |||
346 | } | |||
347 | } else { | |||
348 | OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands)(memcpy((oldEBands), (oldEBands_intra), (C*m->nbEBands)*sizeof (*(oldEBands)) + 0*((oldEBands)-(oldEBands_intra)) )); | |||
349 | OPUS_COPY(error, error_intra, C*m->nbEBands)(memcpy((error), (error_intra), (C*m->nbEBands)*sizeof(*(error )) + 0*((error)-(error_intra)) )); | |||
350 | } | |||
351 | ||||
352 | if (intra) | |||
353 | *delayedIntra = new_distortion; | |||
354 | else | |||
355 | *delayedIntra = ADD32(MULT16_32_Q15(MULT16_16_Q15(pred_coef[LM], pred_coef[LM]),*delayedIntra),((((((pred_coef[LM])*(pred_coef[LM])))*(*delayedIntra)))+(new_distortion )) | |||
356 | new_distortion)((((((pred_coef[LM])*(pred_coef[LM])))*(*delayedIntra)))+(new_distortion )); | |||
357 | ||||
358 | RESTORE_STACK; | |||
359 | } | |||
360 | ||||
361 | void quant_fine_energy(const CELTModeOpusCustomMode *m, int start, int end, opus_val16 *oldEBands, opus_val16 *error, int *fine_quant, ec_enc *enc, int C) | |||
362 | { | |||
363 | int i, c; | |||
364 | ||||
365 | /* Encode finer resolution */ | |||
366 | for (i=start;i<end;i++) | |||
367 | { | |||
368 | opus_int16 frac = 1<<fine_quant[i]; | |||
369 | if (fine_quant[i] <= 0) | |||
370 | continue; | |||
371 | c=0; | |||
372 | do { | |||
373 | int q2; | |||
374 | opus_val16 offset; | |||
375 | #ifdef FIXED_POINT | |||
376 | /* Has to be without rounding */ | |||
377 | q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT)(.5f))>>(DB_SHIFT-fine_quant[i]); | |||
378 | #else | |||
379 | q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac); | |||
380 | #endif | |||
381 | if (q2 > frac-1) | |||
382 | q2 = frac-1; | |||
383 | if (q2<0) | |||
384 | q2 = 0; | |||
385 | ec_enc_bits(enc, q2, fine_quant[i]); | |||
386 | #ifdef FIXED_POINT | |||
387 | offset = SUB16(SHR32(SHL32(EXTEND32(q2),DB_SHIFT)+QCONST16(.5f,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT))(((((q2))+(.5f)))-((.5f))); | |||
388 | #else | |||
389 | offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f; | |||
390 | #endif | |||
391 | oldEBands[i+c*m->nbEBands] += offset; | |||
392 | error[i+c*m->nbEBands] -= offset; | |||
393 | /*printf ("%f ", error[i] - offset);*/ | |||
394 | } while (++c < C); | |||
395 | } | |||
396 | } | |||
397 | ||||
398 | void quant_energy_finalise(const CELTModeOpusCustomMode *m, int start, int end, opus_val16 *oldEBands, opus_val16 *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc, int C) | |||
399 | { | |||
400 | int i, prio, c; | |||
401 | ||||
402 | /* Use up the remaining bits */ | |||
403 | for (prio=0;prio<2;prio++) | |||
404 | { | |||
405 | for (i=start;i<end && bits_left>=C ;i++) | |||
406 | { | |||
407 | if (fine_quant[i] >= MAX_FINE_BITS8 || fine_priority[i]!=prio) | |||
408 | continue; | |||
409 | c=0; | |||
410 | do { | |||
411 | int q2; | |||
412 | opus_val16 offset; | |||
413 | q2 = error[i+c*m->nbEBands]<0 ? 0 : 1; | |||
414 | ec_enc_bits(enc, q2, 1); | |||
415 | #ifdef FIXED_POINT | |||
416 | offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5f,DB_SHIFT),fine_quant[i]+1)((q2)-(.5f)); | |||
417 | #else | |||
418 | offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384); | |||
419 | #endif | |||
420 | oldEBands[i+c*m->nbEBands] += offset; | |||
421 | bits_left--; | |||
422 | } while (++c < C); | |||
423 | } | |||
424 | } | |||
425 | } | |||
426 | ||||
427 | void unquant_coarse_energy(const CELTModeOpusCustomMode *m, int start, int end, opus_val16 *oldEBands, int intra, ec_dec *dec, int C, int LM) | |||
428 | { | |||
429 | const unsigned char *prob_model = e_prob_model[LM][intra]; | |||
430 | int i, c; | |||
431 | opus_val32 prev[2] = {0, 0}; | |||
432 | opus_val16 coef; | |||
433 | opus_val16 beta; | |||
434 | opus_int32 budget; | |||
435 | opus_int32 tell; | |||
436 | ||||
437 | if (intra) | |||
| ||||
438 | { | |||
439 | coef = 0; | |||
440 | beta = beta_intra; | |||
441 | } else { | |||
442 | beta = beta_coef[LM]; | |||
443 | coef = pred_coef[LM]; | |||
444 | } | |||
445 | ||||
446 | budget = dec->storage*8; | |||
447 | ||||
448 | /* Decode at a fixed coarse resolution */ | |||
449 | for (i=start;i<end;i++) | |||
450 | { | |||
451 | c=0; | |||
452 | do { | |||
453 | int qi; | |||
454 | opus_val32 q; | |||
455 | opus_val32 tmp; | |||
456 | /* It would be better to express this invariant as a | |||
457 | test on C at function entry, but that isn't enough | |||
458 | to make the static analyzer happy. */ | |||
459 | celt_assert(c<2); | |||
460 | tell = ec_tell(dec); | |||
461 | if(budget-tell>=15) | |||
462 | { | |||
463 | int pi; | |||
464 | pi = 2*IMIN(i,20)((i) < (20) ? (i) : (20)); | |||
465 | qi = ec_laplace_decode(dec, | |||
466 | prob_model[pi]<<7, prob_model[pi+1]<<6); | |||
467 | } | |||
468 | else if(budget-tell>=2) | |||
469 | { | |||
470 | qi = ec_dec_icdf(dec, small_energy_icdf, 2); | |||
471 | qi = (qi>>1)^-(qi&1); | |||
472 | } | |||
473 | else if(budget-tell>=1) | |||
474 | { | |||
475 | qi = -ec_dec_bit_logp(dec, 1); | |||
476 | } | |||
477 | else | |||
478 | qi = -1; | |||
479 | q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT)((qi)); | |||
480 | ||||
481 | oldEBands[i+c*m->nbEBands] = MAX16(-QCONST16(9.f,DB_SHIFT), oldEBands[i+c*m->nbEBands])((-(9.f)) > (oldEBands[i+c*m->nbEBands]) ? (-(9.f)) : ( oldEBands[i+c*m->nbEBands])); | |||
482 | tmp = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]),8)(((opus_val32)(coef)*(opus_val32)(oldEBands[i+c*m->nbEBands ]))) + prev[c] + SHL32(q,7)(q); | |||
| ||||
483 | #ifdef FIXED_POINT | |||
484 | tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp)((-(28.f)) > (tmp) ? (-(28.f)) : (tmp)); | |||
485 | #endif | |||
486 | oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7)(tmp); | |||
487 | prev[c] = prev[c] + SHL32(q,7)(q) - MULT16_16(beta,PSHR32(q,8))((opus_val32)(beta)*(opus_val32)((q))); | |||
488 | } while (++c < C); | |||
489 | } | |||
490 | } | |||
491 | ||||
492 | void unquant_fine_energy(const CELTModeOpusCustomMode *m, int start, int end, opus_val16 *oldEBands, int *fine_quant, ec_dec *dec, int C) | |||
493 | { | |||
494 | int i, c; | |||
495 | /* Decode finer resolution */ | |||
496 | for (i=start;i<end;i++) | |||
497 | { | |||
498 | if (fine_quant[i] <= 0) | |||
499 | continue; | |||
500 | c=0; | |||
501 | do { | |||
502 | int q2; | |||
503 | opus_val16 offset; | |||
504 | q2 = ec_dec_bits(dec, fine_quant[i]); | |||
505 | #ifdef FIXED_POINT | |||
506 | offset = SUB16(SHR32(SHL32(EXTEND32(q2),DB_SHIFT)+QCONST16(.5f,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT))(((((q2))+(.5f)))-((.5f))); | |||
507 | #else | |||
508 | offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f; | |||
509 | #endif | |||
510 | oldEBands[i+c*m->nbEBands] += offset; | |||
511 | } while (++c < C); | |||
512 | } | |||
513 | } | |||
514 | ||||
515 | void unquant_energy_finalise(const CELTModeOpusCustomMode *m, int start, int end, opus_val16 *oldEBands, int *fine_quant, int *fine_priority, int bits_left, ec_dec *dec, int C) | |||
516 | { | |||
517 | int i, prio, c; | |||
518 | ||||
519 | /* Use up the remaining bits */ | |||
520 | for (prio=0;prio<2;prio++) | |||
521 | { | |||
522 | for (i=start;i<end && bits_left>=C ;i++) | |||
523 | { | |||
524 | if (fine_quant[i] >= MAX_FINE_BITS8 || fine_priority[i]!=prio) | |||
525 | continue; | |||
526 | c=0; | |||
527 | do { | |||
528 | int q2; | |||
529 | opus_val16 offset; | |||
530 | q2 = ec_dec_bits(dec, 1); | |||
531 | #ifdef FIXED_POINT | |||
532 | offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5f,DB_SHIFT),fine_quant[i]+1)((q2)-(.5f)); | |||
533 | #else | |||
534 | offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384); | |||
535 | #endif | |||
536 | oldEBands[i+c*m->nbEBands] += offset; | |||
537 | bits_left--; | |||
538 | } while (++c < C); | |||
539 | } | |||
540 | } | |||
541 | } | |||
542 | ||||
543 | void amp2Log2(const CELTModeOpusCustomMode *m, int effEnd, int end, | |||
544 | celt_ener *bandE, opus_val16 *bandLogE, int C) | |||
545 | { | |||
546 | int c, i; | |||
547 | c=0; | |||
548 | do { | |||
549 | for (i=0;i<effEnd;i++) | |||
550 | bandLogE[i+c*m->nbEBands] = | |||
551 | celt_log2(SHL32(bandE[i+c*m->nbEBands],2))((float)(1.442695040888963387*log((bandE[i+c*m->nbEBands]) ))) | |||
552 | - SHL16((opus_val16)eMeans[i],6)((opus_val16)eMeans[i]); | |||
553 | for (i=effEnd;i<end;i++) | |||
554 | bandLogE[c*m->nbEBands+i] = -QCONST16(14.f,DB_SHIFT)(14.f); | |||
555 | } while (++c < C); | |||
556 | } |