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