Encoder now has a way to check whether an error has occurred
[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, int end, 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<end;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          /* Prevent the energy from going down too quickly (e.g. for bands
125             that have just one bin) */
126          if (qi < 0 && x < oldEBands[i+c*m->nbEBands]-max_decay)
127          {
128             qi += SHR16(oldEBands[i+c*m->nbEBands]-max_decay-x, DB_SHIFT);
129             if (qi > 0)
130                qi = 0;
131          }
132          /* If we don't have enough bits to encode all the energy, just assume something safe.
133             We allow slightly busting the budget here */
134          bits_used=ec_enc_tell(enc, 0);
135          if (bits_used > budget)
136          {
137             qi = -1;
138             error[i+c*m->nbEBands] = QCONST16(.5f,DB_SHIFT);
139          } else {
140             ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
141             error[i+c*m->nbEBands] = PSHR32(f,15) - SHL16(qi,DB_SHIFT);
142          }
143          q = SHL16(qi,DB_SHIFT);
144          
145          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + mean + prev[c] + SHL32(EXTEND32(q),15), 15);
146          prev[c] = mean + prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
147       } while (++c < C);
148    }
149    return bits_used;
150 }
151
152 void quant_fine_energy(const CELTMode *m, int start, int end, celt_ener *eBands, celt_word16 *oldEBands, celt_word16 *error, int *fine_quant, ec_enc *enc, int _C)
153 {
154    int i, c;
155    const int C = CHANNELS(_C);
156
157    /* Encode finer resolution */
158    for (i=start;i<end;i++)
159    {
160       celt_int16 frac = 1<<fine_quant[i];
161       if (fine_quant[i] <= 0)
162          continue;
163       c=0;
164       do {
165          int q2;
166          celt_word16 offset;
167 #ifdef FIXED_POINT
168          /* Has to be without rounding */
169          q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT))>>(DB_SHIFT-fine_quant[i]);
170 #else
171          q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac);
172 #endif
173          if (q2 > frac-1)
174             q2 = frac-1;
175          if (q2<0)
176             q2 = 0;
177          ec_enc_bits(enc, q2, fine_quant[i]);
178 #ifdef FIXED_POINT
179          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
180 #else
181          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
182 #endif
183          oldEBands[i+c*m->nbEBands] += offset;
184          error[i+c*m->nbEBands] -= offset;
185          /*printf ("%f ", error[i] - offset);*/
186       } while (++c < C);
187    }
188 }
189
190 void quant_energy_finalise(const CELTMode *m, int start, int end, celt_ener *eBands, celt_word16 *oldEBands, celt_word16 *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc, int _C)
191 {
192    int i, prio, c;
193    const int C = CHANNELS(_C);
194
195    /* Use up the remaining bits */
196    for (prio=0;prio<2;prio++)
197    {
198       for (i=start;i<end && bits_left>=C ;i++)
199       {
200          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
201             continue;
202          c=0;
203          do {
204             int q2;
205             celt_word16 offset;
206             q2 = error[i+c*m->nbEBands]<0 ? 0 : 1;
207             ec_enc_bits(enc, q2, 1);
208 #ifdef FIXED_POINT
209             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
210 #else
211             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
212 #endif
213             oldEBands[i+c*m->nbEBands] += offset;
214             bits_left--;
215          } while (++c < C);
216       }
217    }
218    c=0;
219    do {
220       for (i=start;i<m->nbEBands;i++)
221       {
222          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
223          if (oldEBands[i+c*m->nbEBands] < -QCONST16(7.f,DB_SHIFT))
224             oldEBands[i+c*m->nbEBands] = -QCONST16(7.f,DB_SHIFT);
225       }
226    } while (++c < C);
227 }
228
229 void unquant_coarse_energy(const CELTMode *m, int start, int end, celt_ener *eBands, celt_word16 *oldEBands, int budget, int intra, int *prob, ec_dec *dec, int _C)
230 {
231    int i, c;
232    celt_word32 prev[2] = {0, 0};
233    celt_word16 coef = m->ePredCoef;
234    celt_word16 beta;
235    const int C = CHANNELS(_C);
236
237    if (intra)
238    {
239       coef = 0;
240       prob += 2*m->nbEBands;
241    }
242    /* The .8 is a heuristic */
243    beta = MULT16_16_P15(QCONST16(.8f,15),coef);
244
245    /* Decode at a fixed coarse resolution */
246    for (i=start;i<end;i++)
247    {
248       c=0;
249       do {
250          int qi;
251          celt_word16 q;
252          celt_word32 mean =  (i-start < E_MEANS_SIZE) ? SUB32(SHL32(EXTEND32(eMeans[i-start]),15), MULT16_16(coef,eMeans[i-start])) : 0;
253          /* If we didn't have enough bits to encode all the energy, just assume something safe.
254             We allow slightly busting the budget here */
255          if (ec_dec_tell(dec, 0) > budget)
256             qi = -1;
257          else
258             qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
259          q = SHL16(qi,DB_SHIFT);
260
261          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + mean + prev[c] + SHL32(EXTEND32(q),15), 15);
262          prev[c] = mean + prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
263       } while (++c < C);
264    }
265 }
266
267 void unquant_fine_energy(const CELTMode *m, int start, int end, celt_ener *eBands, celt_word16 *oldEBands, int *fine_quant, ec_dec *dec, int _C)
268 {
269    int i, c;
270    const int C = CHANNELS(_C);
271    /* Decode finer resolution */
272    for (i=start;i<end;i++)
273    {
274       if (fine_quant[i] <= 0)
275          continue;
276       c=0; 
277       do {
278          int q2;
279          celt_word16 offset;
280          q2 = ec_dec_bits(dec, fine_quant[i]);
281 #ifdef FIXED_POINT
282          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
283 #else
284          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
285 #endif
286          oldEBands[i+c*m->nbEBands] += offset;
287       } while (++c < C);
288    }
289 }
290
291 void unquant_energy_finalise(const CELTMode *m, int start, int end, celt_ener *eBands, celt_word16 *oldEBands, int *fine_quant,  int *fine_priority, int bits_left, ec_dec *dec, int _C)
292 {
293    int i, prio, c;
294    const int C = CHANNELS(_C);
295
296    /* Use up the remaining bits */
297    for (prio=0;prio<2;prio++)
298    {
299       for (i=start;i<end && bits_left>=C ;i++)
300       {
301          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
302             continue;
303          c=0;
304          do {
305             int q2;
306             celt_word16 offset;
307             q2 = ec_dec_bits(dec, 1);
308 #ifdef FIXED_POINT
309             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
310 #else
311             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
312 #endif
313             oldEBands[i+c*m->nbEBands] += offset;
314             bits_left--;
315          } while (++c < C);
316       }
317    }
318    c=0;
319    do {
320       for (i=start;i<m->nbEBands;i++)
321       {
322          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
323          if (oldEBands[i+c*m->nbEBands] < -QCONST16(7.f,DB_SHIFT))
324             oldEBands[i+c*m->nbEBands] = -QCONST16(7.f,DB_SHIFT);
325       }
326    } while (++c < C);
327 }