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