Handle malloc failure in mode_create gracefully without leaking memory.
[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] = {11520, -2048, -3072, -640, 256, 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] = {45.f, -8.f, -12.f, -2.5f, 1.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, 0.f};
48 #endif
49
50
51 #ifdef FIXED_POINT
52 static inline celt_ener_t dB2Amp(celt_ener_t dB)
53 {
54    celt_ener_t amp;
55    if (dB>24659)
56       dB=24659;
57    amp = PSHR32(celt_exp2(MULT16_16_Q14(21771,dB)),2);
58    if (amp < 0)
59       amp = 0;
60    return PSHR32(amp,2);
61 }
62
63 #define DBofTWO 24661
64 static inline celt_word16_t amp2dB(celt_ener_t amp)
65 {
66    /* equivalent to return 6.0207*log2(.3+amp) */
67    return ROUND16(MULT16_16(24661,celt_log2(MAX32(QCONST32(.001f,14),SHL32(amp,2)))),12);
68    /* return DB_SCALING*20*log10(.3+ENER_SCALING_1*amp); */
69 }
70 #else
71 static inline celt_ener_t dB2Amp(celt_ener_t dB)
72 {
73    celt_ener_t amp;
74    /*amp = pow(10, .05*dB)-.3;*/
75    amp = exp(0.115129f*dB);
76    if (amp < 0)
77       amp = 0;
78    return amp;
79 }
80 static inline celt_word16_t amp2dB(celt_ener_t amp)
81 {
82    /*return 20*log10(.3+amp);*/
83    return 8.68589f*log(MAX32(.001f,amp));
84 }
85 #endif
86
87 int intra_decision(celt_ener_t *eBands, celt_word16_t *oldEBands, int len)
88 {
89    int i;
90    celt_word32_t dist = 0;
91    for (i=0;i<len;i++)
92    {
93       celt_word16_t d = SUB16(amp2dB(eBands[i]), oldEBands[i]);
94       dist = MAC16_16(dist, d,d);
95    }
96    return SHR32(dist,16) > 64*len;
97 }
98
99 static const celt_word16_t base_resolution = QCONST16(6.f,8);
100 static const celt_word16_t base_resolution_1 = QCONST16(0.1666667f,15);
101
102 int *quant_prob_alloc(const CELTMode *m)
103 {
104    int i;
105    int *prob;
106    prob = celt_alloc(4*m->nbEBands*sizeof(int));
107    if (prob==NULL)
108      return NULL;
109    for (i=0;i<m->nbEBands;i++)
110    {
111       prob[2*i] = 6000-i*200;
112       prob[2*i+1] = ec_laplace_get_start_freq(prob[2*i]);
113    }
114    for (i=0;i<m->nbEBands;i++)
115    {
116       prob[2*m->nbEBands+2*i] = 9000-i*240;
117       prob[2*m->nbEBands+2*i+1] = ec_laplace_get_start_freq(prob[2*m->nbEBands+2*i]);
118    }
119    return prob;
120 }
121
122 void quant_prob_free(int *freq)
123 {
124    celt_free(freq);
125 }
126
127 static unsigned quant_coarse_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, unsigned budget, int intra, int *prob, celt_word16_t *error, ec_enc *enc)
128 {
129    int i;
130    unsigned bits;
131    unsigned bits_used = 0;
132    celt_word16_t prev = 0;
133    celt_word16_t coef = m->ePredCoef;
134    celt_word16_t beta;
135    
136    if (intra)
137    {
138       coef = 0;
139       prob += 2*m->nbEBands;
140    }
141    /* The .8 is a heuristic */
142    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
143    
144    bits = ec_enc_tell(enc, 0);
145    /* Encode at a fixed coarse resolution */
146    for (i=0;i<m->nbEBands;i++)
147    {
148       int qi;
149       celt_word16_t q;   /* dB */
150       celt_word16_t x;   /* dB */
151       celt_word16_t f;   /* Q8 */
152       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
153       x = amp2dB(eBands[i]);
154 #ifdef FIXED_POINT
155       f = MULT16_16_Q15(x-mean-MULT16_16_Q15(coef,oldEBands[i])-prev,base_resolution_1);
156       /* Rounding to nearest integer here is really important! */
157       qi = (f+128)>>8;
158 #else
159       f = (x-mean-coef*oldEBands[i]-prev)*base_resolution_1;
160       /* Rounding to nearest integer here is really important! */
161       qi = (int)floor(.5+f);
162 #endif
163       /* If we don't have enough bits to encode all the energy, just assume something safe.
164          We allow slightly busting the budget here */
165       bits_used=ec_enc_tell(enc, 0) - bits;
166       if (bits_used > budget)
167       {
168          qi = -1;
169          error[i] = 128;
170       } else {
171          ec_laplace_encode_start(enc, &qi, prob[2*i], prob[2*i+1]);
172          error[i] = f - SHL16(qi,8);
173       }
174       q = qi*base_resolution;
175       
176       oldEBands[i] = mean+MULT16_16_Q15(coef,oldEBands[i])+prev+q;
177       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
178    }
179    return bits_used;
180 }
181
182 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)
183 {
184    int i;
185    /* Encode finer resolution */
186    for (i=0;i<m->nbEBands;i++)
187    {
188       int q2;
189       celt_int16_t frac = 1<<fine_quant[i];
190       celt_word16_t offset = (error[i]+QCONST16(.5f,8))*frac;
191       if (fine_quant[i] <= 0)
192          continue;
193 #ifdef FIXED_POINT
194       /* Has to be without rounding */
195       q2 = offset>>8;
196 #else
197       q2 = (int)floor(offset);
198 #endif
199       if (q2 > frac-1)
200          q2 = frac-1;
201       ec_enc_bits(enc, q2, fine_quant[i]);
202 #ifdef FIXED_POINT
203       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
204 #else
205       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
206 #endif
207       oldEBands[i] += PSHR32(MULT16_16(DB_SCALING*6,offset),8);
208       /*printf ("%f ", error[i] - offset);*/
209    }
210    for (i=0;i<m->nbEBands;i++)
211    {
212       eBands[i] = dB2Amp(oldEBands[i]);
213       if (oldEBands[i] < -QCONST16(40.f,8))
214          oldEBands[i] = -QCONST16(40.f,8);
215    }
216    /*printf ("%d\n", ec_enc_tell(enc, 0)-9);*/
217
218    /*printf ("\n");*/
219 }
220
221 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)
222 {
223    int i;
224    unsigned bits;
225    celt_word16_t prev = 0;
226    celt_word16_t coef = m->ePredCoef;
227    celt_word16_t beta;
228    
229    if (intra)
230    {
231       coef = 0;
232       prob += 2*m->nbEBands;
233    }
234    /* The .8 is a heuristic */
235    beta = MULT16_16_Q15(QCONST16(.8f,15),coef);
236    
237    bits = ec_dec_tell(dec, 0);
238    /* Decode at a fixed coarse resolution */
239    for (i=0;i<m->nbEBands;i++)
240    {
241       int qi;
242       celt_word16_t q;
243       celt_word16_t mean = MULT16_16_Q15(Q15ONE-coef,eMeans[i]);
244       /* If we didn't have enough bits to encode all the energy, just assume something safe.
245          We allow slightly busting the budget here */
246       if (ec_dec_tell(dec, 0) - bits > budget)
247          qi = -1;
248       else
249          qi = ec_laplace_decode_start(dec, prob[2*i], prob[2*i+1]);
250       q = qi*base_resolution;
251       
252       oldEBands[i] = mean+MULT16_16_Q15(coef,oldEBands[i])+prev+q;
253       
254       prev = mean+prev+MULT16_16_Q15(Q15ONE-beta,q);
255    }
256 }
257
258 static void unquant_fine_energy_mono(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
259 {
260    int i;
261    /* Decode finer resolution */
262    for (i=0;i<m->nbEBands;i++)
263    {
264       int q2;
265       celt_word16_t offset;
266       if (fine_quant[i] <= 0)
267          continue;
268       q2 = ec_dec_bits(dec, fine_quant[i]);
269 #ifdef FIXED_POINT
270       offset = SUB16(SHR16(SHL16(q2,8)+QCONST16(.5,8),fine_quant[i]),QCONST16(.5f,8));
271 #else
272       offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
273 #endif
274       oldEBands[i] += PSHR32(MULT16_16(DB_SCALING*6,offset),8);
275    }
276    for (i=0;i<m->nbEBands;i++)
277    {
278       eBands[i] = dB2Amp(oldEBands[i]);
279       if (oldEBands[i] < -QCONST16(40.f,8))
280          oldEBands[i] = -QCONST16(40.f,8);
281    }
282    /*printf ("\n");*/
283 }
284
285
286
287 unsigned quant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, celt_word16_t *error, ec_enc *enc)
288 {
289    int C;
290    C = m->nbChannels;
291
292    if (C==1)
293    {
294       return quant_coarse_energy_mono(m, eBands, oldEBands, budget, intra, prob, error, enc);
295    } else {
296       int c;
297       unsigned maxBudget=0;
298       for (c=0;c<C;c++)
299       {
300          int i;
301          unsigned coarse_needed;
302          VARDECL(celt_ener_t, E);
303          SAVE_STACK;
304          ALLOC(E, m->nbEBands, celt_ener_t);
305          for (i=0;i<m->nbEBands;i++)
306             E[i] = eBands[C*i+c];
307          coarse_needed=quant_coarse_energy_mono(m, E, oldEBands+c*m->nbEBands, budget/C, intra, prob, error+c*m->nbEBands, enc);
308          maxBudget=IMAX(maxBudget,coarse_needed);
309          RESTORE_STACK;
310       }
311       return maxBudget*C;
312    }
313 }
314
315 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)
316 {
317    int C;
318    C = m->nbChannels;
319
320    if (C==1)
321    {
322       quant_fine_energy_mono(m, eBands, oldEBands, error, fine_quant, enc);
323
324    } else {
325       int c;
326       VARDECL(celt_ener_t, E);
327       ALLOC(E, m->nbEBands, celt_ener_t);
328       for (c=0;c<C;c++)
329       {
330          int i;
331          SAVE_STACK;
332          quant_fine_energy_mono(m, E, oldEBands+c*m->nbEBands, error+c*m->nbEBands, fine_quant, enc);
333          for (i=0;i<m->nbEBands;i++)
334             eBands[C*i+c] = E[i];
335          RESTORE_STACK;
336       }
337    }
338 }
339
340
341 void unquant_coarse_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int budget, int intra, int *prob, ec_dec *dec)
342 {
343    int C;   
344
345    C = m->nbChannels;
346    if (C==1)
347    {
348       unquant_coarse_energy_mono(m, eBands, oldEBands, budget, intra, prob, dec);
349    }
350    else {
351       int c;
352       VARDECL(celt_ener_t, E);
353       SAVE_STACK;
354       ALLOC(E, m->nbEBands, celt_ener_t);
355       for (c=0;c<C;c++)
356       {
357          unquant_coarse_energy_mono(m, E, oldEBands+c*m->nbEBands, budget/C, intra, prob, dec);
358       }
359       RESTORE_STACK;
360    }
361 }
362
363 void unquant_fine_energy(const CELTMode *m, celt_ener_t *eBands, celt_word16_t *oldEBands, int *fine_quant, ec_dec *dec)
364 {
365    int C;   
366
367    C = m->nbChannels;
368
369    if (C==1)
370    {
371       unquant_fine_energy_mono(m, eBands, oldEBands, fine_quant, dec);
372    }
373    else {
374       int c;
375       VARDECL(celt_ener_t, E);
376       SAVE_STACK;
377       ALLOC(E, m->nbEBands, celt_ener_t);
378       for (c=0;c<C;c++)
379       {
380          int i;
381          unquant_fine_energy_mono(m, E, oldEBands+c*m->nbEBands, fine_quant, dec);
382          for (i=0;i<m->nbEBands;i++)
383             eBands[C*i+c] = E[i];
384       }
385       RESTORE_STACK;
386    }
387 }