intealeaving the left and right coarse 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 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 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]+.5f)*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 *fine_priority, int bits_left, ec_enc *enc)
180 {
181    int i, prio;
182    /* Use up the remaining bits */
183    for (prio=0;prio<2;prio++)
184    {
185       for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
186       {
187          int q2;
188          celt_word16_t offset;
189          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
190             continue;
191          q2 = error[i]<0 ? 0 : 1;
192          ec_enc_bits(enc, q2, 1);
193 #ifdef FIXED_POINT
194          offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
195 #else
196          offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
197 #endif
198          oldEBands[i] += offset;
199          eBands[i] = log2Amp(oldEBands[i]);
200          bits_left--;
201       }
202    }
203    for (i=0;i<m->nbEBands;i++)
204    {
205       if (oldEBands[i] < -QCONST16(7.f,8))
206          oldEBands[i] = -QCONST16(7.f,8);
207    }
208 }
209
210 void unquant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, ec_dec *dec)
211 {
212    int i, c;
213    unsigned bits;
214    celt_word16_t prev[2] = {0, 0};
215    celt_word16_t coef = m->ePredCoef;
216    celt_word16_t beta;
217    const int C = CHANNELS(m);
218
219    if (intra)
220    {
221       coef = 0;
222       prob += 2*m->nbEBands;
223    }
224    /* The .8 is a heuristic */
225    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
226    
227    bits = ec_dec_tell(dec, 0);
228    /* Decode at a fixed coarse resolution */
229    for (i=0;i<m->nbEBands;i++)
230    {
231       c=0; 
232       do {
233          int qi;
234          celt_word16_t q;
235          celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
236          /* If we didn't have enough bits to encode all the energy, just assume something safe.
237             We allow slightly busting the budget here */
238          if (ec_dec_tell(dec, 0) - bits > budget)
239             qi = -1;
240          else
241             qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
242          q = qi*DB_SCALING;
243
244          oldEBands[i+c*m->nbEBands] = MULT16_16_Q15(coef,oldEBands[i+c*m->nbEBands])+(mean+prev[c]+q);
245          prev[c] = mean+prev[c]+MULT16_16_Q15(Q15ONE-beta,q);
246       } while (++c < C);
247    }
248 }
249
250 static void unquant_fine_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
251 {
252    int i;
253    /* Decode finer resolution */
254    for (i=0;i<m->nbEBands;i++)
255    {
256       int q2;
257       celt_word16_t offset;
258       if (fine_quant[i] <= 0)
259          continue;
260       q2 = ec_dec_bits(dec, fine_quant[i]);
261 #ifdef FIXED_POINT
262       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
263 #else
264       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
265 #endif
266       oldEBands[i] += offset;
267    }
268    for (i=0;i<m->nbEBands;i++)
269       eBands[i] = log2Amp(oldEBands[i]);
270 }
271
272 static void unquant_energy_finalise_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant,  int *fine_priority, int bits_left, ec_dec *dec)
273 {
274    int i, prio;
275    /* Use up the remaining bits */
276    for (prio=0;prio<2;prio++)
277    {
278       for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
279       {
280          int q2;
281          celt_word16_t offset;
282          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
283             continue;
284          q2 = ec_dec_bits(dec, 1);
285 #ifdef FIXED_POINT
286          offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
287 #else
288          offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
289 #endif
290          oldEBands[i] += offset;
291          eBands[i] = log2Amp(oldEBands[i]);
292          bits_left--;
293       }
294    }
295    for (i=0;i<m->nbEBands;i++)
296    {
297       if (oldEBands[i] < -QCONST16(7.f,8))
298          oldEBands[i] = -QCONST16(7.f,8);
299    }
300 }
301
302 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)
303 {
304    int C, c;
305    C = m->nbChannels;
306
307    for (c=0;c<C;c++)
308       quant_fine_energy_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, enc);
309 }
310
311 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)
312 {
313    int C, c;
314    C = m->nbChannels;
315
316    for (c=0;c<C;c++)
317       quant_energy_finalise_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, fine_priority, bits_left/C, enc);
318 }
319
320 void unquant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
321 {
322    int C, c;
323    C = m->nbChannels;
324
325    for (c=0;c<C;c++)
326       unquant_fine_energy_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, fine_quant, dec);
327 }
328
329 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)
330 {
331    int C, c;
332
333    C = m->nbChannels;
334
335    for (c=0;c<C;c++)
336       unquant_energy_finalise_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, fine_quant, fine_priority, bits_left/C, dec);
337 }