removing redundant calls to log2()
[opus.git] / libcelt / quant_bands.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2 */
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 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include "quant_bands.h"
37 #include "laplace.h"
38 #include <math.h>
39 #include "os_support.h"
40 #include "arch.h"
41 #include "mathops.h"
42 #include "stack_alloc.h"
43
44 #ifdef FIXED_POINT
45 const celt_word16_t eMeans[24] = {1920, -341, -512, -107, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
46 #else
47 const celt_word16_t eMeans[24] = {7.5f, -1.33f, -2.f, -0.42f, 0.17f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
48 #endif
49
50 int intra_decision(celt_word16_t *eBands, celt_word16_t *oldEBands, int len)
51 {
52    int i;
53    celt_word32_t dist = 0;
54    for (i=0;i<len;i++)
55    {
56       celt_word16_t d = SUB16(eBands[i], oldEBands[i]);
57       dist = MAC16_16(dist, d,d);
58    }
59    return SHR32(dist,16) > 2*len;
60 }
61
62 int *quant_prob_alloc(const CELTMode *m)
63 {
64    int i;
65    int *prob;
66    prob = celt_alloc(4*m->nbEBands*sizeof(int));
67    if (prob==NULL)
68      return NULL;
69    for (i=0;i<m->nbEBands;i++)
70    {
71       prob[2*i] = 6000-i*200;
72       prob[2*i+1] = ec_laplace_get_start_freq(prob[2*i]);
73    }
74    for (i=0;i<m->nbEBands;i++)
75    {
76       prob[2*m->nbEBands+2*i] = 9000-i*240;
77       prob[2*m->nbEBands+2*i+1] = ec_laplace_get_start_freq(prob[2*m->nbEBands+2*i]);
78    }
79    return prob;
80 }
81
82 void quant_prob_free(int *freq)
83 {
84    celt_free(freq);
85 }
86
87 static unsigned quant_coarse_energy_mono(const CELTMode *m, celt_word16_t *eBands, celt_word16_t *oldEBands, unsigned budget, int intra, int *prob, celt_word16_t *error, ec_enc *enc)
88 {
89    int i;
90    unsigned bits;
91    unsigned bits_used = 0;
92    celt_word16_t prev = 0;
93    celt_word16_t coef = m->ePredCoef;
94    celt_word16_t beta;
95    
96    if (intra)
97    {
98       coef = 0;
99       prob += 2*m->nbEBands;
100    }
101    /* The .8 is a heuristic */
102    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
103    
104    bits = ec_enc_tell(enc, 0);
105    /* Encode at a fixed coarse resolution */
106    for (i=0;i<m->nbEBands;i++)
107    {
108       int qi;
109       celt_word16_t q;   /* dB */
110       celt_word16_t x;   /* dB */
111       celt_word16_t f;   /* Q8 */
112       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
113       x = eBands[i];
114 #ifdef FIXED_POINT
115       f = x-mean -MULT16_16_Q15(coef,oldEBands[i])-prev;
116       /* Rounding to nearest integer here is really important! */
117       qi = (f+128)>>8;
118 #else
119       f = x-mean-coef*oldEBands[i]-prev;
120       /* Rounding to nearest integer here is really important! */
121       qi = (int)floor(.5f+f);
122 #endif
123       /* If we don't have enough bits to encode all the energy, just assume something safe.
124          We allow slightly busting the budget here */
125       bits_used=ec_enc_tell(enc, 0) - bits;
126       if (bits_used > budget)
127       {
128          qi = -1;
129          error[i] = 128;
130       } else {
131          ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
132          error[i] = f - SHL16(qi,8);
133       }
134       q = qi*DB_SCALING;
135
136       oldEBands[i] = MULT16_16_Q15(coef,oldEBands[i])+(mean+prev+q);
137       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
138    }
139    return bits_used;
140 }
141
142 static void quant_fine_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, celt_word16_t *error, int *fine_quant, ec_enc *enc)
143 {
144    int i;
145    /* Encode finer resolution */
146    for (i=0;i<m->nbEBands;i++)
147    {
148       int q2;
149       celt_int16_t frac = 1<<fine_quant[i];
150       celt_word16_t offset;
151       if (fine_quant[i] <= 0)
152          continue;
153 #ifdef FIXED_POINT
154       /* Has to be without rounding */
155       q2 = (error[i]+QCONST16(.5f,8))>>(8-fine_quant[i]);
156 #else
157       q2 = (int)floor((error[i]+.5f)*frac);
158 #endif
159       if (q2 > frac-1)
160          q2 = frac-1;
161       ec_enc_bits(enc, q2, fine_quant[i]);
162 #ifdef FIXED_POINT
163       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
164 #else
165       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
166 #endif
167       oldEBands[i] += offset;
168       error[i] -= offset;
169       /*printf ("%f ", error[i] - offset);*/
170    }
171    for (i=0;i<m->nbEBands;i++)
172       eBands[i] = log2Amp(oldEBands[i]);
173 }
174
175 static void quant_energy_finalise_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, celt_word16_t *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc)
176 {
177    int i, prio;
178    /* Use up the remaining bits */
179    for (prio=0;prio<2;prio++)
180    {
181       for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
182       {
183          int q2;
184          celt_word16_t offset;
185          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
186             continue;
187          q2 = error[i]<0 ? 0 : 1;
188          ec_enc_bits(enc, q2, 1);
189 #ifdef FIXED_POINT
190          offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
191 #else
192          offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
193 #endif
194          oldEBands[i] += offset;
195          bits_left--;
196       }
197    }
198    for (i=0;i<m->nbEBands;i++)
199    {
200       eBands[i] = log2Amp(oldEBands[i]);
201       if (oldEBands[i] < -QCONST16(7.f,8))
202          oldEBands[i] = -QCONST16(7.f,8);
203    }
204 }
205
206 static void unquant_coarse_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, unsigned budget, int intra, int *prob, ec_dec *dec)
207 {
208    int i;
209    unsigned bits;
210    celt_word16_t prev = 0;
211    celt_word16_t coef = m->ePredCoef;
212    celt_word16_t beta;
213    
214    if (intra)
215    {
216       coef = 0;
217       prob += 2*m->nbEBands;
218    }
219    /* The .8 is a heuristic */
220    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
221    
222    bits = ec_dec_tell(dec, 0);
223    /* Decode at a fixed coarse resolution */
224    for (i=0;i<m->nbEBands;i++)
225    {
226       int qi;
227       celt_word16_t q;
228       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
229       /* If we didn't have enough bits to encode all the energy, just assume something safe.
230          We allow slightly busting the budget here */
231       if (ec_dec_tell(dec, 0) - bits > budget)
232          qi = -1;
233       else
234          qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
235       q = qi*DB_SCALING;
236
237       oldEBands[i] = MULT16_16_Q15(coef,oldEBands[i])+(mean+prev+q);
238       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
239    }
240 }
241
242 static void unquant_fine_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
243 {
244    int i;
245    /* Decode finer resolution */
246    for (i=0;i<m->nbEBands;i++)
247    {
248       int q2;
249       celt_word16_t offset;
250       if (fine_quant[i] <= 0)
251          continue;
252       q2 = ec_dec_bits(dec, fine_quant[i]);
253 #ifdef FIXED_POINT
254       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
255 #else
256       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
257 #endif
258       oldEBands[i] += offset;
259    }
260    for (i=0;i<m->nbEBands;i++)
261       eBands[i] = log2Amp(oldEBands[i]);
262 }
263
264 static void unquant_energy_finalise_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant,  int *fine_priority, int bits_left, ec_dec *dec)
265 {
266    int i, prio;
267    /* Use up the remaining bits */
268    for (prio=0;prio<2;prio++)
269    {
270       for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
271       {
272          int q2;
273          celt_word16_t offset;
274          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
275             continue;
276          q2 = ec_dec_bits(dec, 1);
277 #ifdef FIXED_POINT
278          offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
279 #else
280          offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
281 #endif
282          oldEBands[i] += offset;
283          bits_left--;
284       }
285    }
286    for (i=0;i<m->nbEBands;i++)
287    {
288       eBands[i] = log2Amp(oldEBands[i]);
289       if (oldEBands[i] < -QCONST16(7.f,8))
290          oldEBands[i] = -QCONST16(7.f,8);
291    }
292 }
293
294
295 unsigned quant_coarse_energy(const CELTMode *m, celt_word16_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, celt_word16_t *error, ec_enc *enc)
296 {
297    int C;
298    C = m->nbChannels;
299
300    if (C==1)
301    {
302       return quant_coarse_energy_mono(m, eBands, oldEBands, budget, intra, prob, error, enc);
303    } else {
304       int c;
305       unsigned maxBudget=0;
306       for (c=0;c<C;c++)
307       {
308          int i;
309          unsigned coarse_needed;
310          VARDECL(celt_word16_t, E);
311          SAVE_STACK;
312          ALLOC(E, m->nbEBands, celt_word16_t);
313          for (i=0;i<m->nbEBands;i++)
314             E[i] = eBands[C*i+c];
315          coarse_needed=quant_coarse_energy_mono(m, E, oldEBands+c*m->nbEBands, budget/C, intra, prob, error+c*m->nbEBands, enc);
316          maxBudget=IMAX(maxBudget,coarse_needed);
317          RESTORE_STACK;
318       }
319       return maxBudget*C;
320    }
321 }
322
323 void quant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, celt_word16_t *error, int *fine_quant, ec_enc *enc)
324 {
325    int C;
326    C = m->nbChannels;
327
328    if (C==1)
329    {
330       quant_fine_energy_mono(m, eBands, oldEBands, error, fine_quant, enc);
331
332    } else {
333       int c;
334       VARDECL(celt_ener_t, E);
335       ALLOC(E, m->nbEBands, celt_ener_t);
336       for (c=0;c<C;c++)
337       {
338          int i;
339          SAVE_STACK;
340          quant_fine_energy_mono(m, E, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, enc);
341          for (i=0;i<m->nbEBands;i++)
342             eBands[C*i+c] = E[i];
343          RESTORE_STACK;
344       }
345    }
346 }
347
348 void quant_energy_finalise(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, celt_word16_t *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc)
349 {
350    int C;
351    C = m->nbChannels;
352
353    if (C==1)
354    {
355       quant_energy_finalise_mono(m, eBands, oldEBands, error, fine_quant, fine_priority, bits_left, enc);
356
357    } else {
358       int c;
359       VARDECL(celt_ener_t, E);
360       ALLOC(E, m->nbEBands, celt_ener_t);
361       for (c=0;c<C;c++)
362       {
363          int i;
364          SAVE_STACK;
365          quant_energy_finalise_mono(m, E, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, fine_priority, bits_left/C, enc);
366          for (i=0;i<m->nbEBands;i++)
367             eBands[C*i+c] = E[i];
368          RESTORE_STACK;
369       }
370    }
371 }
372
373 void unquant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, ec_dec *dec)
374 {
375    int C;   
376
377    C = m->nbChannels;
378    if (C==1)
379    {
380       unquant_coarse_energy_mono(m, eBands, oldEBands, budget, intra, prob, dec);
381    }
382    else {
383       int c;
384       VARDECL(celt_ener_t, E);
385       SAVE_STACK;
386       ALLOC(E, m->nbEBands, celt_ener_t);
387       for (c=0;c<C;c++)
388       {
389          unquant_coarse_energy_mono(m, E, oldEBands+c*m->nbEBands, budget/C, intra, prob, dec);
390       }
391       RESTORE_STACK;
392    }
393 }
394
395 void unquant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
396 {
397    int C;   
398
399    C = m->nbChannels;
400
401    if (C==1)
402    {
403       unquant_fine_energy_mono(m, eBands, oldEBands, fine_quant, dec);
404    }
405    else {
406       int c;
407       VARDECL(celt_ener_t, E);
408       SAVE_STACK;
409       ALLOC(E, m->nbEBands, celt_ener_t);
410       for (c=0;c<C;c++)
411       {
412          int i;
413          unquant_fine_energy_mono(m, E, oldEBands+c*m->nbEBands, fine_quant, dec);
414          for (i=0;i<m->nbEBands;i++)
415             eBands[C*i+c] = E[i];
416       }
417       RESTORE_STACK;
418    }
419 }
420
421 void unquant_energy_finalise(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, int *fine_priority, int bits_left, ec_dec *dec)
422 {
423    int C;
424
425    C = m->nbChannels;
426
427    if (C==1)
428    {
429       unquant_energy_finalise_mono(m, eBands, oldEBands, fine_quant, fine_priority, bits_left, dec);
430    }
431    else {
432       int c;
433       VARDECL(celt_ener_t, E);
434       SAVE_STACK;
435       ALLOC(E, m->nbEBands, celt_ener_t);
436       for (c=0;c<C;c++)
437       {
438          int i;
439          unquant_energy_finalise_mono(m, E, oldEBands+c*m->nbEBands, fine_quant, fine_priority, bits_left/C, dec);
440          for (i=0;i<m->nbEBands;i++)
441             eBands[C*i+c] = E[i];
442       }
443       RESTORE_STACK;
444    }
445 }