The coarse energy budget is no longer part of the bit-stream.
[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 void 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    celt_word32 prev[2] = {0,0};
91    celt_word16 coef = m->ePredCoef;
92    celt_word16 beta;
93    const int C = CHANNELS(_C);
94
95    if (intra)
96    {
97       coef = 0;
98       prob += 2*m->nbEBands;
99    }
100    /* The .8 is a heuristic */
101    beta = MULT16_16_P15(QCONST16(.8f,15),coef);
102
103    /* Encode at a fixed coarse resolution */
104    for (i=start;i<end;i++)
105    {
106       c=0;
107       do {
108          int bits_left;
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_left = budget-(int)ec_enc_tell(enc, 0)-2*C*(end-i);
135          if (bits_left < 24)
136          {
137             if (qi > 1)
138                qi = 1;
139             if (qi < -1)
140                qi = -1;
141             if (bits_left<8)
142                qi = 0;
143          }
144          ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
145          error[i+c*m->nbEBands] = PSHR32(f,15) - SHL16(qi,DB_SHIFT);
146          q = SHL16(qi,DB_SHIFT);
147          
148          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + mean + prev[c] + SHL32(EXTEND32(q),15), 15);
149          prev[c] = mean + prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
150       } while (++c < C);
151    }
152 }
153
154 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)
155 {
156    int i, c;
157    const int C = CHANNELS(_C);
158
159    /* Encode finer resolution */
160    for (i=start;i<end;i++)
161    {
162       celt_int16 frac = 1<<fine_quant[i];
163       if (fine_quant[i] <= 0)
164          continue;
165       c=0;
166       do {
167          int q2;
168          celt_word16 offset;
169 #ifdef FIXED_POINT
170          /* Has to be without rounding */
171          q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT))>>(DB_SHIFT-fine_quant[i]);
172 #else
173          q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac);
174 #endif
175          if (q2 > frac-1)
176             q2 = frac-1;
177          if (q2<0)
178             q2 = 0;
179          ec_enc_bits(enc, q2, fine_quant[i]);
180 #ifdef FIXED_POINT
181          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
182 #else
183          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
184 #endif
185          oldEBands[i+c*m->nbEBands] += offset;
186          error[i+c*m->nbEBands] -= offset;
187          /*printf ("%f ", error[i] - offset);*/
188       } while (++c < C);
189    }
190 }
191
192 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)
193 {
194    int i, prio, c;
195    const int C = CHANNELS(_C);
196
197    /* Use up the remaining bits */
198    for (prio=0;prio<2;prio++)
199    {
200       for (i=start;i<end && bits_left>=C ;i++)
201       {
202          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
203             continue;
204          c=0;
205          do {
206             int q2;
207             celt_word16 offset;
208             q2 = error[i+c*m->nbEBands]<0 ? 0 : 1;
209             ec_enc_bits(enc, q2, 1);
210 #ifdef FIXED_POINT
211             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
212 #else
213             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
214 #endif
215             oldEBands[i+c*m->nbEBands] += offset;
216             bits_left--;
217          } while (++c < C);
218       }
219    }
220    c=0;
221    do {
222       for (i=start;i<m->nbEBands;i++)
223       {
224          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
225          if (oldEBands[i+c*m->nbEBands] < -QCONST16(7.f,DB_SHIFT))
226             oldEBands[i+c*m->nbEBands] = -QCONST16(7.f,DB_SHIFT);
227       }
228    } while (++c < C);
229 }
230
231 void unquant_coarse_energy(const CELTMode *m, int start, int end, celt_ener *eBands, celt_word16 *oldEBands, int intra, int *prob, ec_dec *dec, int _C)
232 {
233    int i, c;
234    celt_word32 prev[2] = {0, 0};
235    celt_word16 coef = m->ePredCoef;
236    celt_word16 beta;
237    const int C = CHANNELS(_C);
238
239    if (intra)
240    {
241       coef = 0;
242       prob += 2*m->nbEBands;
243    }
244    /* The .8 is a heuristic */
245    beta = MULT16_16_P15(QCONST16(.8f,15),coef);
246
247    /* Decode at a fixed coarse resolution */
248    for (i=start;i<end;i++)
249    {
250       c=0;
251       do {
252          int qi;
253          celt_word16 q;
254          celt_word32 mean =  (i-start < E_MEANS_SIZE) ? SUB32(SHL32(EXTEND32(eMeans[i-start]),15), MULT16_16(coef,eMeans[i-start])) : 0;
255          qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
256          q = SHL16(qi,DB_SHIFT);
257
258          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + mean + prev[c] + SHL32(EXTEND32(q),15), 15);
259          prev[c] = mean + prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
260       } while (++c < C);
261    }
262 }
263
264 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)
265 {
266    int i, c;
267    const int C = CHANNELS(_C);
268    /* Decode finer resolution */
269    for (i=start;i<end;i++)
270    {
271       if (fine_quant[i] <= 0)
272          continue;
273       c=0; 
274       do {
275          int q2;
276          celt_word16 offset;
277          q2 = ec_dec_bits(dec, fine_quant[i]);
278 #ifdef FIXED_POINT
279          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
280 #else
281          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
282 #endif
283          oldEBands[i+c*m->nbEBands] += offset;
284       } while (++c < C);
285    }
286 }
287
288 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)
289 {
290    int i, prio, c;
291    const int C = CHANNELS(_C);
292
293    /* Use up the remaining bits */
294    for (prio=0;prio<2;prio++)
295    {
296       for (i=start;i<end && bits_left>=C ;i++)
297       {
298          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
299             continue;
300          c=0;
301          do {
302             int q2;
303             celt_word16 offset;
304             q2 = ec_dec_bits(dec, 1);
305 #ifdef FIXED_POINT
306             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
307 #else
308             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
309 #endif
310             oldEBands[i+c*m->nbEBands] += offset;
311             bits_left--;
312          } while (++c < C);
313       }
314    }
315    c=0;
316    do {
317       for (i=start;i<m->nbEBands;i++)
318       {
319          eBands[i+c*m->nbEBands] = log2Amp(oldEBands[i+c*m->nbEBands]);
320          if (oldEBands[i+c*m->nbEBands] < -QCONST16(7.f,DB_SHIFT))
321             oldEBands[i+c*m->nbEBands] = -QCONST16(7.f,DB_SHIFT);
322       }
323    } while (++c < C);
324 }