Choosing intra frame energy when it's cheaper than inter
[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 #ifdef FIXED_POINT
46 /* Mean energy in each band quantized in Q6 */
47 const signed char eMeans[25] = {
48      124,122,115,106,100,
49       95, 91, 90, 99, 96,
50       94, 93, 98, 91, 86,
51       90, 88, 88, 90, 85,
52       64, 64, 64, 64, 64};
53 #else
54 /* Mean energy in each band quantized in Q6 and converted back to float */
55 const celt_word16 eMeans[25] = {
56       7.750000f, 7.625000f, 7.187500f, 6.625000f, 6.250000f,
57       5.937500f, 5.687500f, 5.625000f, 6.187500f, 6.000000f,
58       5.875000f, 5.812500f, 6.125000f, 5.687500f, 5.375000f,
59       5.625000f, 5.500000f, 5.500000f, 5.625000f, 5.312500f,
60       4.000000f, 4.000000f, 4.000000f, 4.000000f, 4.000000f};
61 #endif
62 /* prediction coefficients: 0.9, 0.8, 0.65, 0.5 */
63 #ifdef FIXED_POINT
64 static const celt_word16 pred_coef[4] = {29440, 26112, 21248, 16384};
65 #else
66 static const celt_word16 pred_coef[4] = {29440/32768., 26112/32768., 21248/32768., 16384/32768.};
67 #endif
68
69 static int intra_decision(const celt_word16 *eBands, celt_word16 *oldEBands, int start, int end, int len, int C)
70 {
71    int c, i;
72    celt_word32 dist = 0;
73    for (c=0;c<C;c++)
74    {
75       for (i=start;i<end;i++)
76       {
77          celt_word16 d = SUB16(eBands[i+c*len], oldEBands[i+c*len]);
78          dist = MAC16_16(dist, d,d);
79       }
80    }
81    return SHR32(dist,2*DB_SHIFT) > 2*C*(end-start);
82 }
83
84 int *quant_prob_alloc(const CELTMode *m)
85 {
86    int i;
87    int *prob;
88    prob = celt_alloc(4*m->nbEBands*sizeof(int));
89    if (prob==NULL)
90      return NULL;
91    for (i=0;i<m->nbEBands;i++)
92    {
93       prob[2*i] = 7000-i*200;
94       prob[2*i+1] = ec_laplace_get_start_freq(prob[2*i]);
95    }
96    for (i=0;i<m->nbEBands;i++)
97    {
98       prob[2*m->nbEBands+2*i] = 9000-i*220;
99       prob[2*m->nbEBands+2*i+1] = ec_laplace_get_start_freq(prob[2*m->nbEBands+2*i]);
100    }
101    return prob;
102 }
103
104 void quant_prob_free(int *freq)
105 {
106    celt_free(freq);
107 }
108
109 static void quant_coarse_energy_impl(const CELTMode *m, int start, int end,
110       const celt_word16 *eBands, celt_word16 *oldEBands, int budget,
111       int *prob, celt_word16 *error, ec_enc *enc, int _C, int LM,
112       int intra, celt_word16 max_decay)
113 {
114    const int C = CHANNELS(_C);
115    int i, c;
116    celt_word32 prev[2] = {0,0};
117    celt_word16 coef;
118    celt_word16 beta;
119
120    coef = pred_coef[LM];
121
122    ec_enc_bit_prob(enc, intra, 8192);
123    if (intra)
124    {
125       coef = 0;
126       prob += 2*m->nbEBands;
127    }
128    /* No theoretical justification for this, it just works */
129    beta = MULT16_16_P15(coef,coef);
130    /* Encode at a fixed coarse resolution */
131    for (i=start;i<end;i++)
132    {
133       c=0;
134       do {
135          int bits_left;
136          int qi;
137          celt_word16 q;
138          celt_word16 x;
139          celt_word32 f;
140          x = eBands[i+c*m->nbEBands];
141 #ifdef FIXED_POINT
142          f = SHL32(EXTEND32(x),15) -MULT16_16(coef,oldEBands[i+c*m->nbEBands])-prev[c];
143          /* Rounding to nearest integer here is really important! */
144          qi = (f+QCONST32(.5,DB_SHIFT+15))>>(DB_SHIFT+15);
145 #else
146          f = x-coef*oldEBands[i+c*m->nbEBands]-prev[c];
147          /* Rounding to nearest integer here is really important! */
148          qi = (int)floor(.5f+f);
149 #endif
150          /* Prevent the energy from going down too quickly (e.g. for bands
151             that have just one bin) */
152          if (qi < 0 && x < oldEBands[i+c*m->nbEBands]-max_decay)
153          {
154             qi += SHR16(oldEBands[i+c*m->nbEBands]-max_decay-x, DB_SHIFT);
155             if (qi > 0)
156                qi = 0;
157          }
158          /* If we don't have enough bits to encode all the energy, just assume something safe.
159             We allow slightly busting the budget here */
160          bits_left = budget-(int)ec_enc_tell(enc, 0)-2*C*(end-i);
161          if (bits_left < 24)
162          {
163             if (qi > 1)
164                qi = 1;
165             if (qi < -1)
166                qi = -1;
167             if (bits_left<8)
168                qi = 0;
169          }
170          ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
171          error[i+c*m->nbEBands] = PSHR32(f,15) - SHL16(qi,DB_SHIFT);
172          q = SHL16(qi,DB_SHIFT);
173          
174          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + prev[c] + SHL32(EXTEND32(q),15), 15);
175          prev[c] = prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
176       } while (++c < C);
177    }
178 }
179
180 void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
181       const celt_word16 *eBands, celt_word16 *oldEBands, int budget,
182       int *prob, celt_word16 *error, ec_enc *enc, int _C, int LM,
183       int nbAvailableBytes, int force_intra, int *delayedIntra)
184 {
185    const int C = CHANNELS(_C);
186    int intra;
187    celt_word16 max_decay;
188    VARDECL(celt_word16, oldEBands_intra);
189    VARDECL(celt_word16, error_intra);
190    ec_enc enc_start_state;
191    ec_byte_buffer buf_start_state;
192    SAVE_STACK;
193
194    intra = force_intra || (*delayedIntra && nbAvailableBytes > end);
195    if (/*shortBlocks || */intra_decision(eBands, oldEBands, start, effEnd, m->nbEBands, C))
196       *delayedIntra = 1;
197    else
198       *delayedIntra = 0;
199
200    /* Encode the global flags using a simple probability model
201       (first symbols in the stream) */
202
203 #ifdef FIXED_POINT
204       max_decay = MIN32(QCONST16(16,DB_SHIFT), SHL32(EXTEND32(nbAvailableBytes),DB_SHIFT-3));
205 #else
206    max_decay = MIN32(16.f, .125f*nbAvailableBytes);
207 #endif
208
209    enc_start_state = *enc;
210    buf_start_state = *(enc->buf);
211
212    ALLOC(oldEBands_intra, C*m->nbEBands, celt_word16);
213    ALLOC(error_intra, m->nbEBands, celt_word16);
214    CELT_COPY(oldEBands_intra, oldEBands, C*end);
215
216    quant_coarse_energy_impl(m, start, end, eBands, oldEBands_intra, budget,
217          prob, error_intra, enc, C, LM, 1, max_decay);
218
219    if (!intra)
220    {
221       ec_enc enc_intra_state;
222       ec_byte_buffer buf_intra_state;
223       int tell_intra;
224       VARDECL(unsigned char, intra_bits);
225
226       tell_intra = ec_enc_tell(enc, 3);
227
228       enc_intra_state = *enc;
229       buf_intra_state = *(enc->buf);
230
231       ALLOC(intra_bits, buf_intra_state.ptr-buf_start_state.ptr, unsigned char);
232       /* Copy bits from intra bit-stream */
233       CELT_COPY(intra_bits, buf_start_state.ptr, buf_intra_state.ptr-buf_start_state.ptr);
234
235       *enc = enc_start_state;
236       *(enc->buf) = buf_start_state;
237
238       quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget,
239             prob, error, enc, C, LM, 0, max_decay);
240
241       if (ec_enc_tell(enc, 3) > tell_intra)
242       {
243          *enc = enc_intra_state;
244          *(enc->buf) = buf_intra_state;
245          /* Copy bits from to bit-stream */
246          CELT_COPY(buf_start_state.ptr, intra_bits, buf_intra_state.ptr-buf_start_state.ptr);
247          CELT_COPY(oldEBands, oldEBands_intra, C*end);
248          CELT_COPY(error, error_intra, C*end);
249       }
250    } else {
251       CELT_COPY(oldEBands, oldEBands_intra, C*end);
252       CELT_COPY(error, error_intra, C*end);
253    }
254    RESTORE_STACK;
255 }
256
257 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)
258 {
259    int i, c;
260    const int C = CHANNELS(_C);
261
262    /* Encode finer resolution */
263    for (i=start;i<end;i++)
264    {
265       celt_int16 frac = 1<<fine_quant[i];
266       if (fine_quant[i] <= 0)
267          continue;
268       c=0;
269       do {
270          int q2;
271          celt_word16 offset;
272 #ifdef FIXED_POINT
273          /* Has to be without rounding */
274          q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT))>>(DB_SHIFT-fine_quant[i]);
275 #else
276          q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac);
277 #endif
278          if (q2 > frac-1)
279             q2 = frac-1;
280          if (q2<0)
281             q2 = 0;
282          ec_enc_bits(enc, q2, fine_quant[i]);
283 #ifdef FIXED_POINT
284          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
285 #else
286          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
287 #endif
288          oldEBands[i+c*m->nbEBands] += offset;
289          error[i+c*m->nbEBands] -= offset;
290          /*printf ("%f ", error[i] - offset);*/
291       } while (++c < C);
292    }
293 }
294
295 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)
296 {
297    int i, prio, c;
298    const int C = CHANNELS(_C);
299
300    /* Use up the remaining bits */
301    for (prio=0;prio<2;prio++)
302    {
303       for (i=start;i<end && bits_left>=C ;i++)
304       {
305          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
306             continue;
307          c=0;
308          do {
309             int q2;
310             celt_word16 offset;
311             q2 = error[i+c*m->nbEBands]<0 ? 0 : 1;
312             ec_enc_bits(enc, q2, 1);
313 #ifdef FIXED_POINT
314             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
315 #else
316             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
317 #endif
318             oldEBands[i+c*m->nbEBands] += offset;
319             bits_left--;
320          } while (++c < C);
321       }
322    }
323 }
324
325 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, int LM)
326 {
327    int i, c;
328    celt_word32 prev[2] = {0, 0};
329    celt_word16 coef;
330    celt_word16 beta;
331    const int C = CHANNELS(_C);
332
333    coef = pred_coef[LM];
334
335    if (intra)
336    {
337       coef = 0;
338       prob += 2*m->nbEBands;
339    }
340    /* No theoretical justification for this, it just works */
341    beta = MULT16_16_P15(coef,coef);
342
343    /* Decode at a fixed coarse resolution */
344    for (i=start;i<end;i++)
345    {
346       c=0;
347       do {
348          int qi;
349          celt_word16 q;
350          qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
351          q = SHL16(qi,DB_SHIFT);
352
353          oldEBands[i+c*m->nbEBands] = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]) + prev[c] + SHL32(EXTEND32(q),15), 15);
354          prev[c] = prev[c] + SHL32(EXTEND32(q),15) - MULT16_16(beta,q);
355       } while (++c < C);
356    }
357 }
358
359 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)
360 {
361    int i, c;
362    const int C = CHANNELS(_C);
363    /* Decode finer resolution */
364    for (i=start;i<end;i++)
365    {
366       if (fine_quant[i] <= 0)
367          continue;
368       c=0; 
369       do {
370          int q2;
371          celt_word16 offset;
372          q2 = ec_dec_bits(dec, fine_quant[i]);
373 #ifdef FIXED_POINT
374          offset = SUB16(SHR16(SHL16(q2,DB_SHIFT)+QCONST16(.5,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
375 #else
376          offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
377 #endif
378          oldEBands[i+c*m->nbEBands] += offset;
379       } while (++c < C);
380    }
381 }
382
383 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)
384 {
385    int i, prio, c;
386    const int C = CHANNELS(_C);
387
388    /* Use up the remaining bits */
389    for (prio=0;prio<2;prio++)
390    {
391       for (i=start;i<end && bits_left>=C ;i++)
392       {
393          if (fine_quant[i] >= 7 || fine_priority[i]!=prio)
394             continue;
395          c=0;
396          do {
397             int q2;
398             celt_word16 offset;
399             q2 = ec_dec_bits(dec, 1);
400 #ifdef FIXED_POINT
401             offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5,DB_SHIFT),fine_quant[i]+1);
402 #else
403             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
404 #endif
405             oldEBands[i+c*m->nbEBands] += offset;
406             bits_left--;
407          } while (++c < C);
408       }
409    }
410 }
411
412 void log2Amp(const CELTMode *m, int start, int end,
413       celt_ener *eBands, celt_word16 *oldEBands, int _C)
414 {
415    int c, i;
416    const int C = CHANNELS(_C);
417    c=0;
418    do {
419       for (i=start;i<m->nbEBands;i++)
420       {
421          celt_word16 lg = oldEBands[i+c*m->nbEBands]
422                         + SHL16((celt_word16)eMeans[i],6);
423          eBands[i+c*m->nbEBands] = PSHR32(celt_exp2(SHL16(lg,11-DB_SHIFT)),4);
424          if (oldEBands[i+c*m->nbEBands] < -QCONST16(14.f,DB_SHIFT))
425             oldEBands[i+c*m->nbEBands] = -QCONST16(14.f,DB_SHIFT);
426       }
427    } while (++c < C);
428 }
429
430 void amp2Log2(const CELTMode *m, int effEnd, int end,
431       celt_ener *bandE, celt_word16 *bandLogE, int _C)
432 {
433    int c, i;
434    const int C = CHANNELS(_C);
435    c=0;
436    do {
437       for (i=0;i<effEnd;i++)
438          bandLogE[i+c*m->nbEBands] =
439                celt_log2(MAX32(QCONST32(.001f,14),SHL32(bandE[i+c*m->nbEBands],2)))
440                - SHL16((celt_word16)eMeans[i],6);
441       for (i=effEnd;i<end;i++)
442          bandLogE[c*m->nbEBands+i] = -QCONST16(14.f,DB_SHIFT);
443    } while (++c < C);
444 }