Folding, coarse energy, source cleanup
[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_ener_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(amp2Log(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_ener_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 = amp2Log(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(.5+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]+.5)*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 bits_left, ec_enc *enc)
176 {
177    int i;
178    /* Use up the remaining bits */
179    for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
180    {
181       int q2;
182       celt_word16_t offset;
183       if (fine_quant[i] >= 7)
184          continue;
185       q2 = error[i]<0 ? 0 : 1;
186       ec_enc_bits(enc, q2, 1);
187 #ifdef FIXED_POINT
188       offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
189 #else
190       offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
191 #endif
192       oldEBands[i] += offset;
193       bits_left--;
194    }
195    for (i=0;i<m->nbEBands;i++)
196    {
197       eBands[i] = log2Amp(oldEBands[i]);
198       if (oldEBands[i] < -QCONST16(7.f,8))
199          oldEBands[i] = -QCONST16(7.f,8);
200    }
201 }
202
203 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)
204 {
205    int i;
206    unsigned bits;
207    celt_word16_t prev = 0;
208    celt_word16_t coef = m->ePredCoef;
209    celt_word16_t beta;
210    
211    if (intra)
212    {
213       coef = 0;
214       prob += 2*m->nbEBands;
215    }
216    /* The .8 is a heuristic */
217    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
218    
219    bits = ec_dec_tell(dec, 0);
220    /* Decode at a fixed coarse resolution */
221    for (i=0;i<m->nbEBands;i++)
222    {
223       int qi;
224       celt_word16_t q;
225       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
226       /* If we didn't have enough bits to encode all the energy, just assume something safe.
227          We allow slightly busting the budget here */
228       if (ec_dec_tell(dec, 0) - bits > budget)
229          qi = -1;
230       else
231          qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
232       q = qi*DB_SCALING;
233
234       oldEBands[i] = MULT16_16_Q15(coef,oldEBands[i])+(mean+prev+q);
235       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
236    }
237 }
238
239 static void unquant_fine_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
240 {
241    int i;
242    /* Decode finer resolution */
243    for (i=0;i<m->nbEBands;i++)
244    {
245       int q2;
246       celt_word16_t offset;
247       if (fine_quant[i] <= 0)
248          continue;
249       q2 = ec_dec_bits(dec, fine_quant[i]);
250 #ifdef FIXED_POINT
251       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
252 #else
253       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
254 #endif
255       oldEBands[i] += offset;
256    }
257    for (i=0;i<m->nbEBands;i++)
258       eBands[i] = log2Amp(oldEBands[i]);
259 }
260
261 static void unquant_energy_finalise_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, int bits_left, ec_dec *dec)
262 {
263    int i;
264    /* Use up the remaining bits */
265    for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
266    {
267       int q2;
268       celt_word16_t offset;
269       if (fine_quant[i] >= 7)
270          continue;
271       q2 = ec_dec_bits(dec, 1);
272 #ifdef FIXED_POINT
273       offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
274 #else
275       offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
276 #endif
277       oldEBands[i] += offset;
278       bits_left--;
279    }
280    for (i=0;i<m->nbEBands;i++)
281    {
282       eBands[i] = log2Amp(oldEBands[i]);
283       if (oldEBands[i] < -QCONST16(7.f,8))
284          oldEBands[i] = -QCONST16(7.f,8);
285    }
286 }
287
288
289 unsigned quant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, celt_word16_t *error, ec_enc *enc)
290 {
291    int C;
292    C = m->nbChannels;
293
294    if (C==1)
295    {
296       return quant_coarse_energy_mono(m, eBands, oldEBands, budget, intra, prob, error, enc);
297    } else {
298       int c;
299       unsigned maxBudget=0;
300       for (c=0;c<C;c++)
301       {
302          int i;
303          unsigned coarse_needed;
304          VARDECL(celt_ener_t, E);
305          SAVE_STACK;
306          ALLOC(E, m->nbEBands, celt_ener_t);
307          for (i=0;i<m->nbEBands;i++)
308             E[i] = eBands[C*i+c];
309          coarse_needed=quant_coarse_energy_mono(m, E, oldEBands+c*m->nbEBands, budget/C, intra, prob, error+c*m->nbEBands, enc);
310          maxBudget=IMAX(maxBudget,coarse_needed);
311          RESTORE_STACK;
312       }
313       return maxBudget*C;
314    }
315 }
316
317 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)
318 {
319    int C;
320    C = m->nbChannels;
321
322    if (C==1)
323    {
324       quant_fine_energy_mono(m, eBands, oldEBands, error, fine_quant, enc);
325
326    } else {
327       int c;
328       VARDECL(celt_ener_t, E);
329       ALLOC(E, m->nbEBands, celt_ener_t);
330       for (c=0;c<C;c++)
331       {
332          int i;
333          SAVE_STACK;
334          quant_fine_energy_mono(m, E, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, enc);
335          for (i=0;i<m->nbEBands;i++)
336             eBands[C*i+c] = E[i];
337          RESTORE_STACK;
338       }
339    }
340 }
341
342 void quant_energy_finalise(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, celt_word16_t *error, int *fine_quant, int bits_left, ec_enc *enc)
343 {
344    int C;
345    C = m->nbChannels;
346
347    if (C==1)
348    {
349       quant_energy_finalise_mono(m, eBands, oldEBands, error, fine_quant, bits_left, enc);
350
351    } else {
352       int c;
353       VARDECL(celt_ener_t, E);
354       ALLOC(E, m->nbEBands, celt_ener_t);
355       for (c=0;c<C;c++)
356       {
357          int i;
358          SAVE_STACK;
359          quant_energy_finalise_mono(m, E, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, bits_left/C, enc);
360          for (i=0;i<m->nbEBands;i++)
361             eBands[C*i+c] = E[i];
362          RESTORE_STACK;
363       }
364    }
365 }
366
367 void unquant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, ec_dec *dec)
368 {
369    int C;   
370
371    C = m->nbChannels;
372    if (C==1)
373    {
374       unquant_coarse_energy_mono(m, eBands, oldEBands, budget, intra, prob, dec);
375    }
376    else {
377       int c;
378       VARDECL(celt_ener_t, E);
379       SAVE_STACK;
380       ALLOC(E, m->nbEBands, celt_ener_t);
381       for (c=0;c<C;c++)
382       {
383          unquant_coarse_energy_mono(m, E, oldEBands+c*m->nbEBands, budget/C, intra, prob, dec);
384       }
385       RESTORE_STACK;
386    }
387 }
388
389 void unquant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
390 {
391    int C;   
392
393    C = m->nbChannels;
394
395    if (C==1)
396    {
397       unquant_fine_energy_mono(m, eBands, oldEBands, fine_quant, dec);
398    }
399    else {
400       int c;
401       VARDECL(celt_ener_t, E);
402       SAVE_STACK;
403       ALLOC(E, m->nbEBands, celt_ener_t);
404       for (c=0;c<C;c++)
405       {
406          int i;
407          unquant_fine_energy_mono(m, E, oldEBands+c*m->nbEBands, fine_quant, dec);
408          for (i=0;i<m->nbEBands;i++)
409             eBands[C*i+c] = E[i];
410       }
411       RESTORE_STACK;
412    }
413 }
414
415 void unquant_energy_finalise(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, int bits_left, ec_dec *dec)
416 {
417    int C;
418
419    C = m->nbChannels;
420
421    if (C==1)
422    {
423       unquant_energy_finalise_mono(m, eBands, oldEBands, fine_quant, bits_left, dec);
424    }
425    else {
426       int c;
427       VARDECL(celt_ener_t, E);
428       SAVE_STACK;
429       ALLOC(E, m->nbEBands, celt_ener_t);
430       for (c=0;c<C;c++)
431       {
432          int i;
433          unquant_energy_finalise_mono(m, E, oldEBands+c*m->nbEBands, fine_quant, bits_left/C, dec);
434          for (i=0;i<m->nbEBands;i++)
435             eBands[C*i+c] = E[i];
436       }
437       RESTORE_STACK;
438    }
439 }