Fixing a few bugs introduced in the energy interleaving changes and due to
[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 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)
88 {
89    int i, c;
90    unsigned bits;
91    unsigned bits_used = 0;
92    celt_word16_t prev[2] = {0,0};
93    celt_word16_t coef = m->ePredCoef;
94    celt_word16_t beta;
95    const int C = CHANNELS(m);
96
97    if (intra)
98    {
99       coef = 0;
100       prob += 2*m->nbEBands;
101    }
102    /* The .8 is a heuristic */
103    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
104    
105    bits = ec_enc_tell(enc, 0);
106    /* Encode at a fixed coarse resolution */
107    for (i=0;i<m->nbEBands;i++)
108    {
109       c=0;
110       do {
111          int qi;
112          celt_word16_t q;   /* dB */
113          celt_word16_t x;   /* dB */
114          celt_word16_t f;   /* Q8 */
115          celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
116          x = eBands[i+c*m->nbEBands];
117 #ifdef FIXED_POINT
118          f = x-mean -MULT16_16_Q15(coef,oldEBands[i+c*m->nbEBands])-prev[c];
119          /* Rounding to nearest integer here is really important! */
120          qi = (f+128)>>8;
121 #else
122          f = x-mean-coef*oldEBands[i+c*m->nbEBands]-prev[c];
123          /* Rounding to nearest integer here is really important! */
124          qi = (int)floor(.5f+f);
125 #endif
126          /* If we don't have enough bits to encode all the energy, just assume something safe.
127             We allow slightly busting the budget here */
128          bits_used=ec_enc_tell(enc, 0) - bits;
129          if (bits_used > budget)
130          {
131             qi = -1;
132             error[i+c*m->nbEBands] = 128;
133          } else {
134             ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
135             error[i+c*m->nbEBands] = f - SHL16(qi,8);
136          }
137          q = qi*DB_SCALING;
138          
139          oldEBands[i+c*m->nbEBands] = MULT16_16_Q15(coef,oldEBands[i+c*m->nbEBands])+(mean+prev[c]+q);
140          prev[c] = mean+prev[c]+MULT16_16_Q15(Q15ONE-beta,q);
141       } while (++c < C);
142    }
143    return bits_used;
144 }
145
146 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)
147 {
148    int i, c;
149    const int C = CHANNELS(m);
150
151    /* Encode finer resolution */
152    for (i=0;i<m->nbEBands;i++)
153    {
154       celt_int16_t frac = 1<<fine_quant[i];
155       if (fine_quant[i] <= 0)
156          continue;
157       c=0;
158       do {
159          int q2;
160          celt_word16_t offset;
161 #ifdef FIXED_POINT
162          /* Has to be without rounding */
163          q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,8))>>(8-fine_quant[i]);
164 #else
165          q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac);
166 #endif
167          if (q2 > frac-1)
168             q2 = frac-1;
169          ec_enc_bits(enc, q2, fine_quant[i]);
170 #ifdef FIXED_POINT
171          offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
172 #else
173          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
174 #endif
175          oldEBands[i+c*m->nbEBands] += offset;
176          error[i+c*m->nbEBands] -= offset;
177          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
178          /*printf ("%f ", error[i] - offset);*/
179       } while (++c < C);
180    }
181    for (i=0;i<C*m->nbEBands;i++)
182       eBands[i] = log2Amp(oldEBands[i]);
183 }
184
185 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)
186 {
187    int i, prio, c;
188    const int C = CHANNELS(m);
189
190    /* Use up the remaining bits */
191    for (prio=0;prio<2;prio++)
192    {
193       for (i=0;i<m->nbEBands && bits_left>=C ;i++)
194       {
195          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
196             continue;
197          c=0;
198          do {
199             int q2;
200             celt_word16_t offset;
201             q2 = error[i+c*m->nbEBands]<0 ? 0 : 1;
202             ec_enc_bits(enc, q2, 1);
203 #ifdef FIXED_POINT
204             offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
205 #else
206             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
207 #endif
208             oldEBands[i+c*m->nbEBands] += offset;
209             bits_left--;
210          } while (++c < C);
211       }
212    }
213    for (i=0;i<C*m->nbEBands;i++)
214    {
215       eBands[i] = log2Amp(oldEBands[i]);
216       if (oldEBands[i] < -QCONST16(7.f,8))
217          oldEBands[i] = -QCONST16(7.f,8);
218    }
219 }
220
221 void unquant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, ec_dec *dec)
222 {
223    int i, c;
224    unsigned bits;
225    celt_word16_t prev[2] = {0, 0};
226    celt_word16_t coef = m->ePredCoef;
227    celt_word16_t beta;
228    const int C = CHANNELS(m);
229
230    if (intra)
231    {
232       coef = 0;
233       prob += 2*m->nbEBands;
234    }
235    /* The .8 is a heuristic */
236    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
237    
238    bits = ec_dec_tell(dec, 0);
239    /* Decode at a fixed coarse resolution */
240    for (i=0;i<m->nbEBands;i++)
241    {
242       c=0; 
243       do {
244          int qi;
245          celt_word16_t q;
246          celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
247          /* If we didn't have enough bits to encode all the energy, just assume something safe.
248             We allow slightly busting the budget here */
249          if (ec_dec_tell(dec, 0) - bits > budget)
250             qi = -1;
251          else
252             qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
253          q = qi*DB_SCALING;
254
255          oldEBands[i+c*m->nbEBands] = MULT16_16_Q15(coef,oldEBands[i+c*m->nbEBands])+(mean+prev[c]+q);
256          prev[c] = mean+prev[c]+MULT16_16_Q15(Q15ONE-beta,q);
257       } while (++c < C);
258    }
259 }
260
261 void unquant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
262 {
263    int i, c;
264    const int C = CHANNELS(m);
265    /* Decode finer resolution */
266    for (i=0;i<m->nbEBands;i++)
267    {
268       if (fine_quant[i] <= 0)
269          continue;
270       c=0; 
271       do {
272          int q2;
273          celt_word16_t offset;
274          q2 = ec_dec_bits(dec, fine_quant[i]);
275 #ifdef FIXED_POINT
276          offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
277 #else
278          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
279 #endif
280          oldEBands[i+c*m->nbEBands] += offset;
281       } while (++c < C);
282    }
283    for (i=0;i<C*m->nbEBands;i++)
284       eBands[i] = log2Amp(oldEBands[i]);
285 }
286
287 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)
288 {
289    int i, prio, c;
290    const int C = CHANNELS(m);
291
292    /* Use up the remaining bits */
293    for (prio=0;prio<2;prio++)
294    {
295       for (i=0;i<m->nbEBands && bits_left>=C ;i++)
296       {
297          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
298             continue;
299          c=0;
300          do {
301             int q2;
302             celt_word16_t offset;
303             q2 = ec_dec_bits(dec, 1);
304 #ifdef FIXED_POINT
305             offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
306 #else
307             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
308 #endif
309             oldEBands[i+c*m->nbEBands] += offset;
310             bits_left--;
311          } while (++c < C);
312       }
313    }
314    for (i=0;i<C*m->nbEBands;i++)
315    {
316       eBands[i] = log2Amp(oldEBands[i]);
317       if (oldEBands[i] < -QCONST16(7.f,8))
318          oldEBands[i] = -QCONST16(7.f,8);
319    }
320 }