Simplifying the stereo energy quantisation functions now that energy is
[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 static unsigned quant_coarse_energy_mono(const CELTMode *m, celt_word16_t *eBands, celt_word16_t *oldEBands, unsigned budget, int intra, int *prob, celt_word16_t *error, ec_enc *enc)
88 {
89    int i;
90    unsigned bits;
91    unsigned bits_used = 0;
92    celt_word16_t prev = 0;
93    celt_word16_t coef = m->ePredCoef;
94    celt_word16_t beta;
95    
96    if (intra)
97    {
98       coef = 0;
99       prob += 2*m->nbEBands;
100    }
101    /* The .8 is a heuristic */
102    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
103    
104    bits = ec_enc_tell(enc, 0);
105    /* Encode at a fixed coarse resolution */
106    for (i=0;i<m->nbEBands;i++)
107    {
108       int qi;
109       celt_word16_t q;   /* dB */
110       celt_word16_t x;   /* dB */
111       celt_word16_t f;   /* Q8 */
112       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
113       x = eBands[i];
114 #ifdef FIXED_POINT
115       f = x-mean -MULT16_16_Q15(coef,oldEBands[i])-prev;
116       /* Rounding to nearest integer here is really important! */
117       qi = (f+128)>>8;
118 #else
119       f = x-mean-coef*oldEBands[i]-prev;
120       /* Rounding to nearest integer here is really important! */
121       qi = (int)floor(.5f+f);
122 #endif
123       /* If we don't have enough bits to encode all the energy, just assume something safe.
124          We allow slightly busting the budget here */
125       bits_used=ec_enc_tell(enc, 0) - bits;
126       if (bits_used > budget)
127       {
128          qi = -1;
129          error[i] = 128;
130       } else {
131          ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
132          error[i] = f - SHL16(qi,8);
133       }
134       q = qi*DB_SCALING;
135
136       oldEBands[i] = MULT16_16_Q15(coef,oldEBands[i])+(mean+prev+q);
137       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
138    }
139    return bits_used;
140 }
141
142 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)
143 {
144    int i;
145    /* Encode finer resolution */
146    for (i=0;i<m->nbEBands;i++)
147    {
148       int q2;
149       celt_int16_t frac = 1<<fine_quant[i];
150       celt_word16_t offset;
151       if (fine_quant[i] <= 0)
152          continue;
153 #ifdef FIXED_POINT
154       /* Has to be without rounding */
155       q2 = (error[i]+QCONST16(.5f,8))>>(8-fine_quant[i]);
156 #else
157       q2 = (int)floor((error[i]+.5f)*frac);
158 #endif
159       if (q2 > frac-1)
160          q2 = frac-1;
161       ec_enc_bits(enc, q2, fine_quant[i]);
162 #ifdef FIXED_POINT
163       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
164 #else
165       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
166 #endif
167       oldEBands[i] += offset;
168       error[i] -= offset;
169       /*printf ("%f ", error[i] - offset);*/
170    }
171    for (i=0;i<m->nbEBands;i++)
172       eBands[i] = log2Amp(oldEBands[i]);
173 }
174
175 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)
176 {
177    int i, prio;
178    /* Use up the remaining bits */
179    for (prio=0;prio<2;prio++)
180    {
181       for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
182       {
183          int q2;
184          celt_word16_t offset;
185          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
186             continue;
187          q2 = error[i]<0 ? 0 : 1;
188          ec_enc_bits(enc, q2, 1);
189 #ifdef FIXED_POINT
190          offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
191 #else
192          offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
193 #endif
194          oldEBands[i] += offset;
195          bits_left--;
196       }
197    }
198    for (i=0;i<m->nbEBands;i++)
199    {
200       eBands[i] = log2Amp(oldEBands[i]);
201       if (oldEBands[i] < -QCONST16(7.f,8))
202          oldEBands[i] = -QCONST16(7.f,8);
203    }
204 }
205
206 static void unquant_coarse_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, unsigned budget, int intra, int *prob, ec_dec *dec)
207 {
208    int i;
209    unsigned bits;
210    celt_word16_t prev = 0;
211    celt_word16_t coef = m->ePredCoef;
212    celt_word16_t beta;
213    
214    if (intra)
215    {
216       coef = 0;
217       prob += 2*m->nbEBands;
218    }
219    /* The .8 is a heuristic */
220    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
221    
222    bits = ec_dec_tell(dec, 0);
223    /* Decode at a fixed coarse resolution */
224    for (i=0;i<m->nbEBands;i++)
225    {
226       int qi;
227       celt_word16_t q;
228       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
229       /* If we didn't have enough bits to encode all the energy, just assume something safe.
230          We allow slightly busting the budget here */
231       if (ec_dec_tell(dec, 0) - bits > budget)
232          qi = -1;
233       else
234          qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
235       q = qi*DB_SCALING;
236
237       oldEBands[i] = MULT16_16_Q15(coef,oldEBands[i])+(mean+prev+q);
238       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
239    }
240 }
241
242 static void unquant_fine_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
243 {
244    int i;
245    /* Decode finer resolution */
246    for (i=0;i<m->nbEBands;i++)
247    {
248       int q2;
249       celt_word16_t offset;
250       if (fine_quant[i] <= 0)
251          continue;
252       q2 = ec_dec_bits(dec, fine_quant[i]);
253 #ifdef FIXED_POINT
254       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
255 #else
256       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
257 #endif
258       oldEBands[i] += offset;
259    }
260    for (i=0;i<m->nbEBands;i++)
261       eBands[i] = log2Amp(oldEBands[i]);
262 }
263
264 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)
265 {
266    int i, prio;
267    /* Use up the remaining bits */
268    for (prio=0;prio<2;prio++)
269    {
270       for (i=0;i<m->nbEBands && bits_left!=0 ;i++)
271       {
272          int q2;
273          celt_word16_t offset;
274          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
275             continue;
276          q2 = ec_dec_bits(dec, 1);
277 #ifdef FIXED_POINT
278          offset = SHR16(SHL16(q2,8)-QCONST16(.5,8),fine_quant[i]+1);
279 #else
280          offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
281 #endif
282          oldEBands[i] += offset;
283          bits_left--;
284       }
285    }
286    for (i=0;i<m->nbEBands;i++)
287    {
288       eBands[i] = log2Amp(oldEBands[i]);
289       if (oldEBands[i] < -QCONST16(7.f,8))
290          oldEBands[i] = -QCONST16(7.f,8);
291    }
292 }
293
294
295 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)
296 {
297    int C, c;
298    unsigned maxBudget=0;
299    
300    C = m->nbChannels;
301
302    for (c=0;c<C;c++)
303    {
304       unsigned coarse_needed;
305       coarse_needed=quant_coarse_energy_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, budget/C, intra, prob, error+c*m->nbEBands, enc);
306       maxBudget=IMAX(maxBudget,coarse_needed);
307    }
308    return maxBudget*C;
309 }
310
311 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)
312 {
313    int C, c;
314    C = m->nbChannels;
315
316    for (c=0;c<C;c++)
317       quant_fine_energy_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, enc);
318 }
319
320 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)
321 {
322    int C, c;
323    C = m->nbChannels;
324
325    for (c=0;c<C;c++)
326       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);
327 }
328
329 void unquant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, ec_dec *dec)
330 {
331    int C, c;
332
333    C = m->nbChannels;
334    for (c=0;c<C;c++)
335       unquant_coarse_energy_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, budget/C, intra, prob, dec);
336 }
337
338 void unquant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
339 {
340    int C, c;
341    C = m->nbChannels;
342
343    for (c=0;c<C;c++)
344       unquant_fine_energy_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, fine_quant, dec);
345 }
346
347 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)
348 {
349    int C, c;
350
351    C = m->nbChannels;
352
353    for (c=0;c<C;c++)
354       unquant_energy_finalise_mono(m, eBands+c*m->nbEBands, oldEBands+c*m->nbEBands, fine_quant, fine_priority, bits_left/C, dec);
355 }