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