Improved quality of small frame sizes at low bitrate.
[opus.git] / libcelt / quant_bands.c
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    - Neither the name of the Xiph.org Foundation nor the names of its
17    contributors may be used to endorse or promote products derived from
18    this software without specific prior written permission.
19    
20    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
24    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #include "quant_bands.h"
38 #include "laplace.h"
39 #include <math.h>
40 #include "os_support.h"
41 #include "arch.h"
42 #include "mathops.h"
43 #include "stack_alloc.h"
44
45 #define E_MEANS_SIZE (5)
46
47 const celt_word16 eMeans[E_MEANS_SIZE] = {QCONST16(7.5f,DB_SHIFT), -QCONST16(1.33f,DB_SHIFT), -QCONST16(2.f,DB_SHIFT), -QCONST16(0.42f,DB_SHIFT), QCONST16(0.17f,DB_SHIFT)};
48
49 /* FIXME: Implement for stereo */
50 int intra_decision(celt_word16 *eBands, celt_word16 *oldEBands, int len)
51 {
52    int i;
53    celt_word32 dist = 0;
54    for (i=0;i<len;i++)
55    {
56       celt_word16 d = SUB16(eBands[i], oldEBands[i]);
57       dist = MAC16_16(dist, d,d);
58    }
59    return SHR32(dist,2*DB_SHIFT) > 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 unsigned quant_coarse_energy(const CELTMode *m, int start, const celt_word16 *eBands, celt_word16 *oldEBands, int budget, int intra, int *prob, celt_word16 *error, ec_enc *enc, int _C, celt_word16 max_decay)
88 {
89    int i, c;
90    unsigned bits_used = 0;
91    celt_word32 prev[2] = {0,0};
92    celt_word16 coef = m->ePredCoef;
93    celt_word16 beta;
94    const int C = CHANNELS(_C);
95
96    if (intra)
97    {
98       coef = 0;
99       prob += 2*m->nbEBands;
100    }
101    /* The .8 is a heuristic */
102    beta = MULT16_16_P15(QCONST16(.8f,15),coef);
103
104    /* Encode at a fixed coarse resolution */
105    for (i=start;i<m->nbEBands;i++)
106    {
107       c=0;
108       do {
109          int qi;
110          celt_word16 q;
111          celt_word16 x;
112          celt_word32 f;
113          celt_word32 mean =  (i-start < E_MEANS_SIZE) ? SUB32(SHL32(EXTEND32(eMeans[i-start]),15), MULT16_16(coef,eMeans[i-start])) : 0;
114          x = eBands[i+c*m->nbEBands];
115 #ifdef FIXED_POINT
116          f = SHL32(EXTEND32(x),15)-mean -MULT16_16(coef,oldEBands[i+c*m->nbEBands])-prev[c];
117          /* Rounding to nearest integer here is really important! */
118          qi = (f+QCONST32(.5,DB_SHIFT+15))>>(DB_SHIFT+15);
119 #else
120          f = x-mean-coef*oldEBands[i+c*m->nbEBands]-prev[c];
121          /* Rounding to nearest integer here is really important! */
122          qi = (int)floor(.5f+f);
123 #endif
124          if (qi < 0 && x < oldEBands[i+c*m->nbEBands]-max_decay)
125          {
126             qi += SHR16(oldEBands[i+c*m->nbEBands]-max_decay-x, DB_SHIFT);
127             if (qi > 0)
128                qi = 0;
129          }
130          /* If we don't have enough bits to encode all the energy, just assume something safe.
131             We allow slightly busting the budget here */
132          bits_used=ec_enc_tell(enc, 0);
133          if (bits_used > budget)
134          {
135             qi = -1;
136             error[i+c*m->nbEBands] = QCONST16(.5f,DB_SHIFT);
137          } else {
138             ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
139             error[i+c*m->nbEBands] = PSHR32(f,15) - SHL16(qi,DB_SHIFT);
140          }
141          q = SHL16(qi,DB_SHIFT);
142          
143          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + mean + prev[c] + SHL32(EXTEND32(q),15), 15);
144          prev[c] = mean + prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
145       } while (++c < C);
146    }
147    return bits_used;
148 }
149
150 void quant_fine_energy(const CELTMode *m, int start, celt_ener *eBands, celt_word16 *oldEBands, celt_word16 *error, int *fine_quant, ec_enc *enc, int _C)
151 {
152    int i, c;
153    const int C = CHANNELS(_C);
154
155    /* Encode finer resolution */
156    for (i=start;i<m->nbEBands;i++)
157    {
158       celt_int16 frac = 1<<fine_quant[i];
159       if (fine_quant[i] <= 0)
160          continue;
161       c=0;
162       do {
163          int q2;
164          celt_word16 offset;
165 #ifdef FIXED_POINT
166          /* Has to be without rounding */
167          q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT))>>(DB_SHIFT-fine_quant[i]);
168 #else
169          q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac);
170 #endif
171          if (q2 > frac-1)
172             q2 = frac-1;
173          if (q2<0)
174             q2 = 0;
175          ec_enc_bits(enc, q2, fine_quant[i]);
176 #ifdef FIXED_POINT
177          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
178 #else
179          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
180 #endif
181          oldEBands[i+c*m->nbEBands] += offset;
182          error[i+c*m->nbEBands] -= offset;
183          /*printf ("%f ", error[i] - offset);*/
184       } while (++c < C);
185    }
186 }
187
188 void quant_energy_finalise(const CELTMode *m, int start, celt_ener *eBands, celt_word16 *oldEBands, celt_word16 *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc, int _C)
189 {
190    int i, prio, c;
191    const int C = CHANNELS(_C);
192
193    /* Use up the remaining bits */
194    for (prio=0;prio<2;prio++)
195    {
196       for (i=start;i<m->nbEBands && bits_left>=C ;i++)
197       {
198          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
199             continue;
200          c=0;
201          do {
202             int q2;
203             celt_word16 offset;
204             q2 = error[i+c*m->nbEBands]<0 ? 0 : 1;
205             ec_enc_bits(enc, q2, 1);
206 #ifdef FIXED_POINT
207             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
208 #else
209             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
210 #endif
211             oldEBands[i+c*m->nbEBands] += offset;
212             bits_left--;
213          } while (++c < C);
214       }
215    }
216    c=0;
217    do {
218       for (i=start;i<m->nbEBands;i++)
219       {
220          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
221          if (oldEBands[i+c*m->nbEBands] < -QCONST16(7.f,DB_SHIFT))
222             oldEBands[i+c*m->nbEBands] = -QCONST16(7.f,DB_SHIFT);
223       }
224    } while (++c < C);
225 }
226
227 void unquant_coarse_energy(const CELTMode *m, int start, celt_ener *eBands, celt_word16 *oldEBands, int budget, int intra, int *prob, ec_dec *dec, int _C)
228 {
229    int i, c;
230    celt_word32 prev[2] = {0, 0};
231    celt_word16 coef = m->ePredCoef;
232    celt_word16 beta;
233    const int C = CHANNELS(_C);
234
235    if (intra)
236    {
237       coef = 0;
238       prob += 2*m->nbEBands;
239    }
240    /* The .8 is a heuristic */
241    beta = MULT16_16_P15(QCONST16(.8f,15),coef);
242
243    /* Decode at a fixed coarse resolution */
244    for (i=start;i<m->nbEBands;i++)
245    {
246       c=0;
247       do {
248          int qi;
249          celt_word16 q;
250          celt_word32 mean =  (i-start < E_MEANS_SIZE) ? SUB32(SHL32(EXTEND32(eMeans[i-start]),15), MULT16_16(coef,eMeans[i-start])) : 0;
251          /* If we didn't have enough bits to encode all the energy, just assume something safe.
252             We allow slightly busting the budget here */
253          if (ec_dec_tell(dec, 0) > budget)
254             qi = -1;
255          else
256             qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
257          q = SHL16(qi,DB_SHIFT);
258
259          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + mean + prev[c] + SHL32(EXTEND32(q),15), 15);
260          prev[c] = mean + prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
261       } while (++c < C);
262    }
263 }
264
265 void unquant_fine_energy(const CELTMode *m, int start, celt_ener *eBands, celt_word16 *oldEBands, int *fine_quant, ec_dec *dec, int _C)
266 {
267    int i, c;
268    const int C = CHANNELS(_C);
269    /* Decode finer resolution */
270    for (i=start;i<m->nbEBands;i++)
271    {
272       if (fine_quant[i] <= 0)
273          continue;
274       c=0; 
275       do {
276          int q2;
277          celt_word16 offset;
278          q2 = ec_dec_bits(dec, fine_quant[i]);
279 #ifdef FIXED_POINT
280          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
281 #else
282          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
283 #endif
284          oldEBands[i+c*m->nbEBands] += offset;
285       } while (++c < C);
286    }
287 }
288
289 void unquant_energy_finalise(const CELTMode *m, int start, celt_ener *eBands, celt_word16 *oldEBands, int *fine_quant,  int *fine_priority, int bits_left, ec_dec *dec, int _C)
290 {
291    int i, prio, c;
292    const int C = CHANNELS(_C);
293
294    /* Use up the remaining bits */
295    for (prio=0;prio<2;prio++)
296    {
297       for (i=start;i<m->nbEBands && bits_left>=C ;i++)
298       {
299          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
300             continue;
301          c=0;
302          do {
303             int q2;
304             celt_word16 offset;
305             q2 = ec_dec_bits(dec, 1);
306 #ifdef FIXED_POINT
307             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
308 #else
309             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
310 #endif
311             oldEBands[i+c*m->nbEBands] += offset;
312             bits_left--;
313          } while (++c < C);
314       }
315    }
316    c=0;
317    do {
318       for (i=start;i<m->nbEBands;i++)
319       {
320          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
321          if (oldEBands[i+c*m->nbEBands] < -QCONST16(7.f,DB_SHIFT))
322             oldEBands[i+c*m->nbEBands] = -QCONST16(7.f,DB_SHIFT);
323       }
324    } while (++c < C);
325 }