Mercurial > libavcodec.hg
annotate twinvq.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 3d011a01a6a0 |
children | 4b3da727d832 |
rev | line source |
---|---|
10075 | 1 /* |
2 * TwinVQ decoder | |
3 * Copyright (c) 2009 Vitor Sessak | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 #include "avcodec.h" | |
23 #include "get_bits.h" | |
24 #include "dsputil.h" | |
10562
51b5f85c5064
Add missing include. Fix the following compiler warnings:
vitor
parents:
10557
diff
changeset
|
25 #include "lsp.h" |
10075 | 26 |
27 #include <math.h> | |
28 #include <stdint.h> | |
29 | |
30 #include "twinvq_data.h" | |
31 | |
32 enum FrameType { | |
33 FT_SHORT = 0, ///< Short frame (divided in n sub-blocks) | |
34 FT_MEDIUM, ///< Medium frame (divided in m<n sub-blocks) | |
35 FT_LONG, ///< Long frame (single sub-block + PPC) | |
36 FT_PPC, ///< Periodic Peak Component (part of the long frame) | |
37 }; | |
38 | |
39 /** | |
40 * Parameters and tables that are different for each frame type | |
41 */ | |
42 struct FrameMode { | |
43 uint8_t sub; ///< Number subblocks in each frame | |
44 const uint16_t *bark_tab; | |
45 | |
46 /** number of distinct bark scale envelope values */ | |
47 uint8_t bark_env_size; | |
48 | |
49 const int16_t *bark_cb; ///< codebook for the bark scale envelope (BSE) | |
50 uint8_t bark_n_coef;///< number of BSE CB coefficients to read | |
51 uint8_t bark_n_bit; ///< number of bits of the BSE coefs | |
52 | |
53 //@{ | |
54 /** main codebooks for spectrum data */ | |
55 const int16_t *cb0; | |
56 const int16_t *cb1; | |
57 //@} | |
58 | |
59 uint8_t cb_len_read; ///< number of spectrum coefficients to read | |
60 }; | |
61 | |
62 /** | |
63 * Parameters and tables that are different for every combination of | |
64 * bitrate/sample rate | |
65 */ | |
66 typedef struct { | |
67 struct FrameMode fmode[3]; ///< frame type-dependant parameters | |
68 | |
69 uint16_t size; ///< frame size in samples | |
70 uint8_t n_lsp; ///< number of lsp coefficients | |
71 const float *lspcodebook; | |
72 | |
73 /* number of bits of the different LSP CB coefficients */ | |
74 uint8_t lsp_bit0; | |
75 uint8_t lsp_bit1; | |
76 uint8_t lsp_bit2; | |
77 | |
78 uint8_t lsp_split; ///< number of CB entries for the LSP decoding | |
79 const int16_t *ppc_shape_cb; ///< PPC shape CB | |
80 | |
81 /** number of the bits for the PPC period value */ | |
82 uint8_t ppc_period_bit; | |
83 | |
84 uint8_t ppc_shape_bit; ///< number of bits of the PPC shape CB coeffs | |
85 uint8_t ppc_shape_len; ///< size of PPC shape CB | |
86 uint8_t pgain_bit; ///< bits for PPC gain | |
87 | |
88 /** constant for peak period to peak width conversion */ | |
89 uint16_t peak_per2wid; | |
90 } ModeTab; | |
91 | |
92 static const ModeTab mode_08_08 = { | |
93 { | |
94 { 8, bark_tab_s08_64, 10, tab.fcb08s , 1, 5, tab.cb0808s0, tab.cb0808s1, 18}, | |
95 { 2, bark_tab_m08_256, 20, tab.fcb08m , 2, 5, tab.cb0808m0, tab.cb0808m1, 16}, | |
96 { 1, bark_tab_l08_512, 30, tab.fcb08l , 3, 6, tab.cb0808l0, tab.cb0808l1, 17} | |
97 }, | |
98 512 , 12, tab.lsp08, 1, 5, 3, 3, tab.shape08 , 8, 28, 20, 6, 40 | |
99 }; | |
100 | |
101 static const ModeTab mode_11_08 = { | |
102 { | |
103 { 8, bark_tab_s11_64, 10, tab.fcb11s , 1, 5, tab.cb1108s0, tab.cb1108s1, 29}, | |
104 { 2, bark_tab_m11_256, 20, tab.fcb11m , 2, 5, tab.cb1108m0, tab.cb1108m1, 24}, | |
105 { 1, bark_tab_l11_512, 30, tab.fcb11l , 3, 6, tab.cb1108l0, tab.cb1108l1, 27} | |
106 }, | |
107 512 , 16, tab.lsp11, 1, 6, 4, 3, tab.shape11 , 9, 36, 30, 7, 90 | |
108 }; | |
109 | |
110 static const ModeTab mode_11_10 = { | |
111 { | |
112 { 8, bark_tab_s11_64, 10, tab.fcb11s , 1, 5, tab.cb1110s0, tab.cb1110s1, 21}, | |
113 { 2, bark_tab_m11_256, 20, tab.fcb11m , 2, 5, tab.cb1110m0, tab.cb1110m1, 18}, | |
114 { 1, bark_tab_l11_512, 30, tab.fcb11l , 3, 6, tab.cb1110l0, tab.cb1110l1, 20} | |
115 }, | |
116 512 , 16, tab.lsp11, 1, 6, 4, 3, tab.shape11 , 9, 36, 30, 7, 90 | |
117 }; | |
118 | |
119 static const ModeTab mode_16_16 = { | |
120 { | |
121 { 8, bark_tab_s16_128, 10, tab.fcb16s , 1, 5, tab.cb1616s0, tab.cb1616s1, 16}, | |
122 { 2, bark_tab_m16_512, 20, tab.fcb16m , 2, 5, tab.cb1616m0, tab.cb1616m1, 15}, | |
123 { 1, bark_tab_l16_1024,30, tab.fcb16l , 3, 6, tab.cb1616l0, tab.cb1616l1, 16} | |
124 }, | |
125 1024, 16, tab.lsp16, 1, 6, 4, 3, tab.shape16 , 9, 56, 60, 7, 180 | |
126 }; | |
127 | |
128 static const ModeTab mode_22_20 = { | |
129 { | |
130 { 8, bark_tab_s22_128, 10, tab.fcb22s_1, 1, 6, tab.cb2220s0, tab.cb2220s1, 18}, | |
131 { 2, bark_tab_m22_512, 20, tab.fcb22m_1, 2, 6, tab.cb2220m0, tab.cb2220m1, 17}, | |
132 { 1, bark_tab_l22_1024,32, tab.fcb22l_1, 4, 6, tab.cb2220l0, tab.cb2220l1, 18} | |
133 }, | |
134 1024, 16, tab.lsp22_1, 1, 6, 4, 3, tab.shape22_1, 9, 56, 36, 7, 144 | |
135 }; | |
136 | |
137 static const ModeTab mode_22_24 = { | |
138 { | |
139 { 8, bark_tab_s22_128, 10, tab.fcb22s_1, 1, 6, tab.cb2224s0, tab.cb2224s1, 15}, | |
140 { 2, bark_tab_m22_512, 20, tab.fcb22m_1, 2, 6, tab.cb2224m0, tab.cb2224m1, 14}, | |
141 { 1, bark_tab_l22_1024,32, tab.fcb22l_1, 4, 6, tab.cb2224l0, tab.cb2224l1, 15} | |
142 }, | |
143 1024, 16, tab.lsp22_1, 1, 6, 4, 3, tab.shape22_1, 9, 56, 36, 7, 144 | |
144 }; | |
145 | |
146 static const ModeTab mode_22_32 = { | |
147 { | |
148 { 4, bark_tab_s22_128, 10, tab.fcb22s_2, 1, 6, tab.cb2232s0, tab.cb2232s1, 11}, | |
149 { 2, bark_tab_m22_256, 20, tab.fcb22m_2, 2, 6, tab.cb2232m0, tab.cb2232m1, 11}, | |
150 { 1, bark_tab_l22_512, 32, tab.fcb22l_2, 4, 6, tab.cb2232l0, tab.cb2232l1, 12} | |
151 }, | |
152 512 , 16, tab.lsp22_2, 1, 6, 4, 4, tab.shape22_2, 9, 56, 36, 7, 72 | |
153 }; | |
154 | |
155 static const ModeTab mode_44_40 = { | |
156 { | |
157 {16, bark_tab_s44_128, 10, tab.fcb44s , 1, 6, tab.cb4440s0, tab.cb4440s1, 18}, | |
158 { 4, bark_tab_m44_512, 20, tab.fcb44m , 2, 6, tab.cb4440m0, tab.cb4440m1, 17}, | |
159 { 1, bark_tab_l44_2048,40, tab.fcb44l , 4, 6, tab.cb4440l0, tab.cb4440l1, 17} | |
160 }, | |
161 2048, 20, tab.lsp44, 1, 6, 4, 4, tab.shape44 , 9, 84, 54, 7, 432 | |
162 }; | |
163 | |
164 static const ModeTab mode_44_48 = { | |
165 { | |
166 {16, bark_tab_s44_128, 10, tab.fcb44s , 1, 6, tab.cb4448s0, tab.cb4448s1, 15}, | |
167 { 4, bark_tab_m44_512, 20, tab.fcb44m , 2, 6, tab.cb4448m0, tab.cb4448m1, 14}, | |
168 { 1, bark_tab_l44_2048,40, tab.fcb44l , 4, 6, tab.cb4448l0, tab.cb4448l1, 14} | |
169 }, | |
170 2048, 20, tab.lsp44, 1, 6, 4, 4, tab.shape44 , 9, 84, 54, 7, 432 | |
171 }; | |
172 | |
173 typedef struct TwinContext { | |
174 AVCodecContext *avctx; | |
175 DSPContext dsp; | |
10199 | 176 FFTContext mdct_ctx[3]; |
10075 | 177 |
178 const ModeTab *mtab; | |
179 | |
180 // history | |
181 float lsp_hist[2][20]; ///< LSP coefficients of the last frame | |
182 float bark_hist[3][2][40]; ///< BSE coefficients of last frame | |
183 | |
184 // bitstream parameters | |
185 int16_t permut[4][4096]; | |
186 uint8_t length[4][2]; ///< main codebook stride | |
187 uint8_t length_change[4]; | |
188 uint8_t bits_main_spec[2][4][2]; ///< bits for the main codebook | |
189 int bits_main_spec_change[4]; | |
190 int n_div[4]; | |
191 | |
192 float *spectrum; | |
193 float *curr_frame; ///< non-interleaved output | |
194 float *prev_frame; ///< non-interleaved previous frame | |
195 int last_block_pos[2]; | |
196 | |
197 float *cos_tabs[3]; | |
198 | |
199 // scratch buffers | |
200 float *tmp_buf; | |
201 } TwinContext; | |
202 | |
203 #define PPC_SHAPE_CB_SIZE 64 | |
204 #define SUB_AMP_MAX 4500.0 | |
205 #define MULAW_MU 100.0 | |
206 #define GAIN_BITS 8 | |
207 #define AMP_MAX 13000.0 | |
208 #define SUB_GAIN_BITS 5 | |
209 #define WINDOW_TYPE_BITS 4 | |
210 #define PGAIN_MU 200 | |
211 | |
212 /** @note not speed critical, hence not optimized */ | |
213 static void memset_float(float *buf, float val, int size) | |
214 { | |
215 while (size--) | |
216 *buf++ = val; | |
217 } | |
218 | |
219 /** | |
220 * Evaluate a single LPC amplitude spectrum envelope coefficient from the line | |
221 * spectrum pairs. | |
222 * | |
223 * @param lsp a vector of the cosinus of the LSP values | |
224 * @param cos_val cos(PI*i/N) where i is the index of the LPC amplitude | |
225 * @param order the order of the LSP (and the size of the *lsp buffer). Must | |
226 * be a multiple of four. | |
227 * @return the LPC value | |
228 * | |
229 * @todo reuse code from vorbis_dec.c: vorbis_floor0_decode | |
230 */ | |
231 static float eval_lpc_spectrum(const float *lsp, float cos_val, int order) | |
232 { | |
233 int j; | |
234 float p = 0.5f; | |
235 float q = 0.5f; | |
236 float two_cos_w = 2.0f*cos_val; | |
237 | |
10108 | 238 for (j = 0; j + 1 < order; j += 2*2) { |
10075 | 239 // Unroll the loop once since order is a multiple of four |
240 q *= lsp[j ] - two_cos_w; | |
241 p *= lsp[j+1] - two_cos_w; | |
242 | |
243 q *= lsp[j+2] - two_cos_w; | |
244 p *= lsp[j+3] - two_cos_w; | |
245 } | |
246 | |
247 p *= p * (2.0f - two_cos_w); | |
248 q *= q * (2.0f + two_cos_w); | |
249 | |
250 return 0.5 / (p + q); | |
251 } | |
252 | |
253 /** | |
254 * Evaluates the LPC amplitude spectrum envelope from the line spectrum pairs. | |
255 */ | |
256 static void eval_lpcenv(TwinContext *tctx, const float *cos_vals, float *lpc) | |
257 { | |
258 int i; | |
259 const ModeTab *mtab = tctx->mtab; | |
260 int size_s = mtab->size / mtab->fmode[FT_SHORT].sub; | |
261 | |
10108 | 262 for (i = 0; i < size_s/2; i++) { |
10075 | 263 float cos_i = tctx->cos_tabs[0][i]; |
264 lpc[i] = eval_lpc_spectrum(cos_vals, cos_i, mtab->n_lsp); | |
265 lpc[size_s-i-1] = eval_lpc_spectrum(cos_vals, -cos_i, mtab->n_lsp); | |
266 } | |
267 } | |
268 | |
269 static void interpolate(float *out, float v1, float v2, int size) | |
270 { | |
271 int i; | |
272 float step = (v1 - v2)/(size + 1); | |
273 | |
10108 | 274 for (i = 0; i < size; i++) { |
10075 | 275 v2 += step; |
276 out[i] = v2; | |
277 } | |
278 } | |
279 | |
280 static inline float get_cos(int idx, int part, const float *cos_tab, int size) | |
281 { | |
282 return part ? -cos_tab[size - idx - 1] : | |
283 cos_tab[ idx ]; | |
284 } | |
285 | |
286 /** | |
287 * Evaluates the LPC amplitude spectrum envelope from the line spectrum pairs. | |
288 * Probably for speed reasons, the coefficients are evaluated as | |
289 * siiiibiiiisiiiibiiiisiiiibiiiisiiiibiiiis ... | |
290 * where s is an evaluated value, i is a value interpolated from the others | |
291 * and b might be either calculated or interpolated, depending on an | |
292 * unexplained condition. | |
293 * | |
294 * @param step the size of a block "siiiibiiii" | |
295 * @param in the cosinus of the LSP data | |
296 * @param part is 0 for 0...PI (positive cossinus values) and 1 for PI...2PI | |
297 (negative cossinus values) | |
298 * @param size the size of the whole output | |
299 */ | |
300 static inline void eval_lpcenv_or_interp(TwinContext *tctx, | |
301 enum FrameType ftype, | |
302 float *out, const float *in, | |
303 int size, int step, int part) | |
304 { | |
305 int i; | |
306 const ModeTab *mtab = tctx->mtab; | |
307 const float *cos_tab = tctx->cos_tabs[ftype]; | |
308 | |
309 // Fill the 's' | |
10108 | 310 for (i = 0; i < size; i += step) |
10075 | 311 out[i] = |
312 eval_lpc_spectrum(in, | |
313 get_cos(i, part, cos_tab, size), | |
314 mtab->n_lsp); | |
315 | |
316 // Fill the 'iiiibiiii' | |
10108 | 317 for (i = step; i <= size - 2*step; i += step) { |
10075 | 318 if (out[i + step] + out[i - step] > 1.95*out[i] || |
319 out[i + step] >= out[i - step]) { | |
320 interpolate(out + i - step + 1, out[i], out[i-step], step - 1); | |
321 } else { | |
322 out[i - step/2] = | |
323 eval_lpc_spectrum(in, | |
324 get_cos(i-step/2, part, cos_tab, size), | |
325 mtab->n_lsp); | |
326 interpolate(out + i - step + 1, out[i-step/2], out[i-step ], step/2 - 1); | |
327 interpolate(out + i - step/2 + 1, out[i ], out[i-step/2], step/2 - 1); | |
328 } | |
329 } | |
330 | |
331 interpolate(out + size - 2*step + 1, out[size-step], out[size - 2*step], step - 1); | |
332 } | |
333 | |
334 static void eval_lpcenv_2parts(TwinContext *tctx, enum FrameType ftype, | |
335 const float *buf, float *lpc, | |
336 int size, int step) | |
337 { | |
338 eval_lpcenv_or_interp(tctx, ftype, lpc , buf, size/2, step, 0); | |
339 eval_lpcenv_or_interp(tctx, ftype, lpc + size/2, buf, size/2, 2*step, 1); | |
340 | |
341 interpolate(lpc+size/2-step+1, lpc[size/2], lpc[size/2-step], step); | |
342 | |
343 memset_float(lpc + size - 2*step + 1, lpc[size - 2*step], 2*step - 1); | |
344 } | |
345 | |
346 /** | |
347 * Inverse quantization. Read CB coefficients for cb1 and cb2 from the | |
348 * bitstream, sum the corresponding vectors and write the result to *out | |
349 * after permutation. | |
350 */ | |
351 static void dequant(TwinContext *tctx, GetBitContext *gb, float *out, | |
352 enum FrameType ftype, | |
353 const int16_t *cb0, const int16_t *cb1, int cb_len) | |
354 { | |
355 int pos = 0; | |
356 int i, j; | |
357 | |
10108 | 358 for (i = 0; i < tctx->n_div[ftype]; i++) { |
10075 | 359 int tmp0, tmp1; |
360 int sign0 = 1; | |
361 int sign1 = 1; | |
362 const int16_t *tab0, *tab1; | |
363 int length = tctx->length[ftype][i >= tctx->length_change[ftype]]; | |
364 int bitstream_second_part = (i >= tctx->bits_main_spec_change[ftype]); | |
365 | |
366 int bits = tctx->bits_main_spec[0][ftype][bitstream_second_part]; | |
367 if (bits == 7) { | |
368 if (get_bits1(gb)) | |
369 sign0 = -1; | |
370 bits = 6; | |
371 } | |
372 tmp0 = get_bits(gb, bits); | |
373 | |
374 bits = tctx->bits_main_spec[1][ftype][bitstream_second_part]; | |
375 | |
376 if (bits == 7) { | |
377 if (get_bits1(gb)) | |
378 sign1 = -1; | |
379 | |
380 bits = 6; | |
381 } | |
382 tmp1 = get_bits(gb, bits); | |
383 | |
384 tab0 = cb0 + tmp0*cb_len; | |
385 tab1 = cb1 + tmp1*cb_len; | |
386 | |
10108 | 387 for (j = 0; j < length; j++) |
10075 | 388 out[tctx->permut[ftype][pos+j]] = sign0*tab0[j] + sign1*tab1[j]; |
389 | |
390 pos += length; | |
391 } | |
392 | |
393 } | |
394 | |
395 static inline float mulawinv(float y, float clip, float mu) | |
396 { | |
397 y = av_clipf(y/clip, -1, 1); | |
398 return clip * FFSIGN(y) * (exp(log(1+mu) * fabs(y)) - 1) / mu; | |
399 } | |
400 | |
401 /** | |
402 * Evaluate a*b/400 rounded to the nearest integer. When, for example, | |
403 * a*b == 200 and the nearest integer is ill-defined, use a table to emulate | |
404 * the following broken float-based implementation used by the binary decoder: | |
405 * | |
406 * \code | |
407 * static int very_broken_op(int a, int b) | |
408 * { | |
409 * static float test; // Ugh, force gcc to do the division first... | |
410 * | |
411 * test = a/400.; | |
412 * return b * test + 0.5; | |
413 * } | |
414 * \endcode | |
415 * | |
416 * @note if this function is replaced by just ROUNDED_DIV(a*b,400.), the stddev | |
417 * between the original file (before encoding with Yamaha encoder) and the | |
418 * decoded output increases, which leads one to believe that the encoder expects | |
419 * exactly this broken calculation. | |
420 */ | |
421 static int very_broken_op(int a, int b) | |
422 { | |
423 int x = a*b + 200; | |
424 int size; | |
425 const uint8_t *rtab; | |
426 | |
427 if (x%400 || b%5) | |
428 return x/400; | |
429 | |
430 x /= 400; | |
431 | |
432 size = tabs[b/5].size; | |
433 rtab = tabs[b/5].tab; | |
434 return x - rtab[size*av_log2(2*(x - 1)/size)+(x - 1)%size]; | |
435 } | |
436 | |
437 /** | |
438 * Sum to data a periodic peak of a given period, width and shape. | |
439 * | |
440 * @param period the period of the peak divised by 400.0 | |
441 */ | |
442 static void add_peak(int period, int width, const float *shape, | |
443 float ppc_gain, float *speech, int len) | |
444 { | |
445 int i, j; | |
446 | |
447 const float *shape_end = shape + len; | |
448 int center; | |
449 | |
450 // First peak centered around zero | |
10108 | 451 for (i = 0; i < width/2; i++) |
10075 | 452 speech[i] += ppc_gain * *shape++; |
453 | |
10108 | 454 for (i = 1; i < ROUNDED_DIV(len,width) ; i++) { |
10075 | 455 center = very_broken_op(period, i); |
10108 | 456 for (j = -width/2; j < (width+1)/2; j++) |
10075 | 457 speech[j+center] += ppc_gain * *shape++; |
458 } | |
459 | |
460 // For the last block, be careful not to go beyond the end of the buffer | |
461 center = very_broken_op(period, i); | |
10108 | 462 for (j = -width/2; j < (width + 1)/2 && shape < shape_end; j++) |
10075 | 463 speech[j+center] += ppc_gain * *shape++; |
464 } | |
465 | |
466 static void decode_ppc(TwinContext *tctx, int period_coef, const float *shape, | |
467 float ppc_gain, float *speech) | |
468 { | |
469 const ModeTab *mtab = tctx->mtab; | |
470 int isampf = tctx->avctx->sample_rate/1000; | |
471 int ibps = tctx->avctx->bit_rate/(1000 * tctx->avctx->channels); | |
472 int min_period = ROUNDED_DIV( 40*2*mtab->size, isampf); | |
473 int max_period = ROUNDED_DIV(6*40*2*mtab->size, isampf); | |
474 int period_range = max_period - min_period; | |
475 | |
476 // This is actually the period multiplied by 400. It is just linearly coded | |
477 // between its maximum and minimum value. | |
478 int period = min_period + | |
479 ROUNDED_DIV(period_coef*period_range, (1 << mtab->ppc_period_bit) - 1); | |
480 int width; | |
481 | |
482 if (isampf == 22 && ibps == 32) { | |
483 // For some unknown reason, NTT decided to code this case differently... | |
484 width = ROUNDED_DIV((period + 800)* mtab->peak_per2wid, 400*mtab->size); | |
485 } else | |
486 width = (period )* mtab->peak_per2wid/(400*mtab->size); | |
487 | |
488 add_peak(period, width, shape, ppc_gain, speech, mtab->ppc_shape_len); | |
489 } | |
490 | |
491 static void dec_gain(TwinContext *tctx, GetBitContext *gb, enum FrameType ftype, | |
492 float *out) | |
493 { | |
494 const ModeTab *mtab = tctx->mtab; | |
495 int i, j; | |
496 int sub = mtab->fmode[ftype].sub; | |
497 float step = AMP_MAX / ((1 << GAIN_BITS) - 1); | |
498 float sub_step = SUB_AMP_MAX / ((1 << SUB_GAIN_BITS) - 1); | |
499 | |
500 if (ftype == FT_LONG) { | |
10108 | 501 for (i = 0; i < tctx->avctx->channels; i++) |
10075 | 502 out[i] = (1./(1<<13)) * |
503 mulawinv(step * 0.5 + step * get_bits(gb, GAIN_BITS), | |
504 AMP_MAX, MULAW_MU); | |
505 } else { | |
10108 | 506 for (i = 0; i < tctx->avctx->channels; i++) { |
10075 | 507 float val = (1./(1<<23)) * |
508 mulawinv(step * 0.5 + step * get_bits(gb, GAIN_BITS), | |
509 AMP_MAX, MULAW_MU); | |
510 | |
10108 | 511 for (j = 0; j < sub; j++) { |
10075 | 512 out[i*sub + j] = |
513 val*mulawinv(sub_step* 0.5 + | |
514 sub_step* get_bits(gb, SUB_GAIN_BITS), | |
515 SUB_AMP_MAX, MULAW_MU); | |
516 } | |
517 } | |
518 } | |
519 } | |
520 | |
521 /** | |
522 * Rearrange the LSP coefficients so that they have a minimum distance of | |
523 * min_dist. This function does it exactly as described in section of 3.2.4 | |
524 * of the G.729 specification (but interestingly is different from what the | |
525 * reference decoder actually does). | |
526 */ | |
527 static void rearrange_lsp(int order, float *lsp, float min_dist) | |
528 { | |
529 int i; | |
530 float min_dist2 = min_dist * 0.5; | |
10108 | 531 for (i = 1; i < order; i++) |
10075 | 532 if (lsp[i] - lsp[i-1] < min_dist) { |
533 float avg = (lsp[i] + lsp[i-1]) * 0.5; | |
534 | |
535 lsp[i-1] = avg - min_dist2; | |
536 lsp[i ] = avg + min_dist2; | |
537 } | |
538 } | |
539 | |
540 static void decode_lsp(TwinContext *tctx, int lpc_idx1, uint8_t *lpc_idx2, | |
541 int lpc_hist_idx, float *lsp, float *hist) | |
542 { | |
543 const ModeTab *mtab = tctx->mtab; | |
544 int i, j; | |
545 | |
546 const float *cb = mtab->lspcodebook; | |
547 const float *cb2 = cb + (1 << mtab->lsp_bit1)*mtab->n_lsp; | |
548 const float *cb3 = cb2 + (1 << mtab->lsp_bit2)*mtab->n_lsp; | |
549 | |
550 const int8_t funny_rounding[4] = { | |
551 -2, | |
552 mtab->lsp_split == 4 ? -2 : 1, | |
553 mtab->lsp_split == 4 ? -2 : 1, | |
554 0 | |
555 }; | |
556 | |
10108 | 557 j = 0; |
558 for (i = 0; i < mtab->lsp_split; i++) { | |
10075 | 559 int chunk_end = ((i + 1)*mtab->n_lsp + funny_rounding[i])/mtab->lsp_split; |
560 for (; j < chunk_end; j++) | |
561 lsp[j] = cb [lpc_idx1 * mtab->n_lsp + j] + | |
562 cb2[lpc_idx2[i] * mtab->n_lsp + j]; | |
563 } | |
564 | |
565 rearrange_lsp(mtab->n_lsp, lsp, 0.0001); | |
566 | |
10108 | 567 for (i = 0; i < mtab->n_lsp; i++) { |
10075 | 568 float tmp1 = 1. - cb3[lpc_hist_idx*mtab->n_lsp + i]; |
569 float tmp2 = hist[i] * cb3[lpc_hist_idx*mtab->n_lsp + i]; | |
570 hist[i] = lsp[i]; | |
571 lsp[i] = lsp[i] * tmp1 + tmp2; | |
572 } | |
573 | |
574 rearrange_lsp(mtab->n_lsp, lsp, 0.0001); | |
575 rearrange_lsp(mtab->n_lsp, lsp, 0.000095); | |
10557
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10500
diff
changeset
|
576 ff_sort_nearly_sorted_floats(lsp, mtab->n_lsp); |
10075 | 577 } |
578 | |
579 static void dec_lpc_spectrum_inv(TwinContext *tctx, float *lsp, | |
580 enum FrameType ftype, float *lpc) | |
581 { | |
582 int i; | |
583 int size = tctx->mtab->size / tctx->mtab->fmode[ftype].sub; | |
584 | |
10108 | 585 for (i = 0; i < tctx->mtab->n_lsp; i++) |
10075 | 586 lsp[i] = 2*cos(lsp[i]); |
587 | |
588 switch (ftype) { | |
589 case FT_LONG: | |
590 eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 8); | |
591 break; | |
592 case FT_MEDIUM: | |
593 eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 2); | |
594 break; | |
595 case FT_SHORT: | |
596 eval_lpcenv(tctx, lsp, lpc); | |
597 break; | |
598 } | |
599 } | |
600 | |
601 static void imdct_and_window(TwinContext *tctx, enum FrameType ftype, int wtype, | |
602 float *in, float *prev, int ch) | |
603 { | |
604 const ModeTab *mtab = tctx->mtab; | |
605 int bsize = mtab->size / mtab->fmode[ftype].sub; | |
606 int size = mtab->size; | |
607 float *buf1 = tctx->tmp_buf; | |
608 int j; | |
609 int wsize; // Window size | |
610 float *out = tctx->curr_frame + 2*ch*mtab->size; | |
611 float *out2 = out; | |
612 float *prev_buf; | |
613 int first_wsize; | |
614 | |
615 static const uint8_t wtype_to_wsize[] = {0, 0, 2, 2, 2, 1, 0, 1, 1}; | |
616 int types_sizes[] = { | |
617 mtab->size / mtab->fmode[FT_LONG ].sub, | |
618 mtab->size / mtab->fmode[FT_MEDIUM].sub, | |
619 mtab->size / (2*mtab->fmode[FT_SHORT ].sub), | |
620 }; | |
621 | |
622 wsize = types_sizes[wtype_to_wsize[wtype]]; | |
623 first_wsize = wsize; | |
624 prev_buf = prev + (size - bsize)/2; | |
625 | |
10108 | 626 for (j = 0; j < mtab->fmode[ftype].sub; j++) { |
10075 | 627 int sub_wtype = ftype == FT_MEDIUM ? 8 : wtype; |
628 | |
629 if (!j && wtype == 4) | |
630 sub_wtype = 4; | |
631 else if (j == mtab->fmode[ftype].sub-1 && wtype == 7) | |
632 sub_wtype = 7; | |
633 | |
634 wsize = types_sizes[wtype_to_wsize[sub_wtype]]; | |
635 | |
636 ff_imdct_half(&tctx->mdct_ctx[ftype], buf1 + bsize*j, in + bsize*j); | |
637 | |
638 tctx->dsp.vector_fmul_window(out2, | |
639 prev_buf + (bsize-wsize)/2, | |
640 buf1 + bsize*j, | |
10174
89cd870ca180
Add two more sizes to ff_sine_windows[] and also pad it with NULLs so
vitor
parents:
10108
diff
changeset
|
641 ff_sine_windows[av_log2(wsize)], |
10075 | 642 0.0, |
643 wsize/2); | |
644 out2 += wsize; | |
645 | |
646 memcpy(out2, buf1 + bsize*j + wsize/2, (bsize - wsize/2)*sizeof(float)); | |
647 | |
648 out2 += ftype == FT_MEDIUM ? (bsize-wsize)/2 : bsize - wsize; | |
649 | |
650 prev_buf = buf1 + bsize*j + bsize/2; | |
651 } | |
652 | |
653 tctx->last_block_pos[ch] = (size + first_wsize)/2; | |
654 } | |
655 | |
656 static void imdct_output(TwinContext *tctx, enum FrameType ftype, int wtype, | |
657 float *out) | |
658 { | |
659 const ModeTab *mtab = tctx->mtab; | |
660 float *prev_buf = tctx->prev_frame + tctx->last_block_pos[0]; | |
661 int i, j; | |
662 | |
10108 | 663 for (i = 0; i < tctx->avctx->channels; i++) { |
10075 | 664 imdct_and_window(tctx, ftype, wtype, |
665 tctx->spectrum + i*mtab->size, | |
666 prev_buf + 2*i*mtab->size, | |
667 i); | |
668 } | |
669 | |
670 if (tctx->avctx->channels == 2) { | |
10108 | 671 for (i = 0; i < mtab->size - tctx->last_block_pos[0]; i++) { |
10075 | 672 float f1 = prev_buf[ i]; |
673 float f2 = prev_buf[2*mtab->size + i]; | |
674 out[2*i ] = f1 + f2; | |
675 out[2*i + 1] = f1 - f2; | |
676 } | |
10108 | 677 for (j = 0; i < mtab->size; j++,i++) { |
10075 | 678 float f1 = tctx->curr_frame[ j]; |
679 float f2 = tctx->curr_frame[2*mtab->size + j]; | |
680 out[2*i ] = f1 + f2; | |
681 out[2*i + 1] = f1 - f2; | |
682 } | |
683 } else { | |
684 memcpy(out, prev_buf, | |
685 (mtab->size - tctx->last_block_pos[0]) * sizeof(*out)); | |
686 | |
687 out += mtab->size - tctx->last_block_pos[0]; | |
688 | |
689 memcpy(out, tctx->curr_frame, | |
690 (tctx->last_block_pos[0]) * sizeof(*out)); | |
691 } | |
692 | |
693 } | |
694 | |
695 static void dec_bark_env(TwinContext *tctx, const uint8_t *in, int use_hist, | |
696 int ch, float *out, float gain, enum FrameType ftype) | |
697 { | |
698 const ModeTab *mtab = tctx->mtab; | |
699 int i,j; | |
700 float *hist = tctx->bark_hist[ftype][ch]; | |
701 float val = ((const float []) {0.4, 0.35, 0.28})[ftype]; | |
702 int bark_n_coef = mtab->fmode[ftype].bark_n_coef; | |
703 int fw_cb_len = mtab->fmode[ftype].bark_env_size / bark_n_coef; | |
704 int idx = 0; | |
705 | |
10108 | 706 for (i = 0; i < fw_cb_len; i++) |
707 for (j = 0; j < bark_n_coef; j++, idx++) { | |
10075 | 708 float tmp2 = |
709 mtab->fmode[ftype].bark_cb[fw_cb_len*in[j] + i] * (1./4096); | |
710 float st = use_hist ? | |
711 (1. - val) * tmp2 + val*hist[idx] + 1. : tmp2 + 1.; | |
712 | |
713 hist[idx] = tmp2; | |
714 if (st < -1.) st = 1.; | |
715 | |
716 memset_float(out, st * gain, mtab->fmode[ftype].bark_tab[idx]); | |
717 out += mtab->fmode[ftype].bark_tab[idx]; | |
718 } | |
719 | |
720 } | |
721 | |
722 static void read_and_decode_spectrum(TwinContext *tctx, GetBitContext *gb, | |
723 float *out, enum FrameType ftype) | |
724 { | |
725 const ModeTab *mtab = tctx->mtab; | |
726 int channels = tctx->avctx->channels; | |
727 int sub = mtab->fmode[ftype].sub; | |
728 int block_size = mtab->size / sub; | |
729 float gain[channels*sub]; | |
730 float ppc_shape[mtab->ppc_shape_len * channels * 4]; | |
731 uint8_t bark1[channels][sub][mtab->fmode[ftype].bark_n_coef]; | |
732 uint8_t bark_use_hist[channels][sub]; | |
733 | |
734 uint8_t lpc_idx1[channels]; | |
735 uint8_t lpc_idx2[channels][tctx->mtab->lsp_split]; | |
736 uint8_t lpc_hist_idx[channels]; | |
737 | |
738 int i, j, k; | |
739 | |
740 dequant(tctx, gb, out, ftype, | |
741 mtab->fmode[ftype].cb0, mtab->fmode[ftype].cb1, | |
742 mtab->fmode[ftype].cb_len_read); | |
743 | |
10108 | 744 for (i = 0; i < channels; i++) |
745 for (j = 0; j < sub; j++) | |
746 for (k = 0; k < mtab->fmode[ftype].bark_n_coef; k++) | |
10075 | 747 bark1[i][j][k] = |
748 get_bits(gb, mtab->fmode[ftype].bark_n_bit); | |
749 | |
10108 | 750 for (i = 0; i < channels; i++) |
751 for (j = 0; j < sub; j++) | |
10075 | 752 bark_use_hist[i][j] = get_bits1(gb); |
753 | |
754 dec_gain(tctx, gb, ftype, gain); | |
755 | |
10108 | 756 for (i = 0; i < channels; i++) { |
10075 | 757 lpc_hist_idx[i] = get_bits(gb, tctx->mtab->lsp_bit0); |
758 lpc_idx1 [i] = get_bits(gb, tctx->mtab->lsp_bit1); | |
759 | |
10108 | 760 for (j = 0; j < tctx->mtab->lsp_split; j++) |
10075 | 761 lpc_idx2[i][j] = get_bits(gb, tctx->mtab->lsp_bit2); |
762 } | |
763 | |
764 if (ftype == FT_LONG) { | |
765 int cb_len_p = (tctx->n_div[3] + mtab->ppc_shape_len*channels - 1)/ | |
766 tctx->n_div[3]; | |
767 dequant(tctx, gb, ppc_shape, FT_PPC, mtab->ppc_shape_cb, | |
768 mtab->ppc_shape_cb + cb_len_p*PPC_SHAPE_CB_SIZE, cb_len_p); | |
769 } | |
770 | |
10108 | 771 for (i = 0; i < channels; i++) { |
10075 | 772 float *chunk = out + mtab->size * i; |
773 float lsp[tctx->mtab->n_lsp]; | |
774 | |
10108 | 775 for (j = 0; j < sub; j++) { |
10075 | 776 dec_bark_env(tctx, bark1[i][j], bark_use_hist[i][j], i, |
777 tctx->tmp_buf, gain[sub*i+j], ftype); | |
778 | |
779 tctx->dsp.vector_fmul(chunk + block_size*j, tctx->tmp_buf, | |
780 block_size); | |
781 | |
782 } | |
783 | |
784 if (ftype == FT_LONG) { | |
785 float pgain_step = 25000. / ((1 << mtab->pgain_bit) - 1); | |
786 int p_coef = get_bits(gb, tctx->mtab->ppc_period_bit); | |
787 int g_coef = get_bits(gb, tctx->mtab->pgain_bit); | |
788 float v = 1./8192* | |
789 mulawinv(pgain_step*g_coef+ pgain_step/2, 25000., PGAIN_MU); | |
790 | |
791 decode_ppc(tctx, p_coef, ppc_shape + i*mtab->ppc_shape_len, v, | |
792 chunk); | |
793 } | |
794 | |
795 decode_lsp(tctx, lpc_idx1[i], lpc_idx2[i], lpc_hist_idx[i], lsp, | |
796 tctx->lsp_hist[i]); | |
797 | |
798 dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf); | |
799 | |
10108 | 800 for (j = 0; j < mtab->fmode[ftype].sub; j++) { |
10075 | 801 tctx->dsp.vector_fmul(chunk, tctx->tmp_buf, block_size); |
802 chunk += block_size; | |
803 } | |
804 } | |
805 } | |
806 | |
807 static int twin_decode_frame(AVCodecContext * avctx, void *data, | |
808 int *data_size, AVPacket *avpkt) | |
809 { | |
810 const uint8_t *buf = avpkt->data; | |
811 int buf_size = avpkt->size; | |
812 TwinContext *tctx = avctx->priv_data; | |
813 GetBitContext gb; | |
814 const ModeTab *mtab = tctx->mtab; | |
815 float *out = data; | |
816 enum FrameType ftype; | |
817 int window_type; | |
818 static const enum FrameType wtype_to_ftype_table[] = { | |
819 FT_LONG, FT_LONG, FT_SHORT, FT_LONG, | |
820 FT_MEDIUM, FT_LONG, FT_LONG, FT_MEDIUM, FT_MEDIUM | |
821 }; | |
822 | |
823 if (buf_size*8 < avctx->bit_rate*mtab->size/avctx->sample_rate + 8) { | |
824 av_log(avctx, AV_LOG_ERROR, | |
825 "Frame too small (%d bytes). Truncated file?\n", buf_size); | |
826 *data_size = 0; | |
827 return buf_size; | |
828 } | |
829 | |
830 init_get_bits(&gb, buf, buf_size * 8); | |
831 skip_bits(&gb, get_bits(&gb, 8)); | |
832 window_type = get_bits(&gb, WINDOW_TYPE_BITS); | |
833 | |
834 if (window_type > 8) { | |
835 av_log(avctx, AV_LOG_ERROR, "Invalid window type, broken sample?\n"); | |
836 return -1; | |
837 } | |
838 | |
839 ftype = wtype_to_ftype_table[window_type]; | |
840 | |
841 read_and_decode_spectrum(tctx, &gb, tctx->spectrum, ftype); | |
842 | |
843 imdct_output(tctx, ftype, window_type, out); | |
844 | |
845 FFSWAP(float*, tctx->curr_frame, tctx->prev_frame); | |
846 | |
847 if (tctx->avctx->frame_number < 2) { | |
848 *data_size=0; | |
849 return buf_size; | |
850 } | |
851 | |
10104
0fa3d21b317e
SSE optimized vector_clipf(). 10% faster TwinVQ decoding.
vitor
parents:
10081
diff
changeset
|
852 tctx->dsp.vector_clipf(out, out, -32700./(1<<15), 32700./(1<<15), |
10106
a04aca5587a7
100l, revision 19728 added a bug that broke twinvq decoding. I forgot to
vitor
parents:
10104
diff
changeset
|
853 avctx->channels * mtab->size); |
10075 | 854 |
855 *data_size = mtab->size*avctx->channels*4; | |
856 | |
857 return buf_size; | |
858 } | |
859 | |
860 /** | |
861 * Init IMDCT and windowing tables | |
862 */ | |
863 static av_cold void init_mdct_win(TwinContext *tctx) | |
864 { | |
865 int i,j; | |
866 const ModeTab *mtab = tctx->mtab; | |
867 int size_s = mtab->size / mtab->fmode[FT_SHORT].sub; | |
868 int size_m = mtab->size / mtab->fmode[FT_MEDIUM].sub; | |
869 int channels = tctx->avctx->channels; | |
870 float norm = channels == 1 ? 2. : 1.; | |
871 | |
10108 | 872 for (i = 0; i < 3; i++) { |
10075 | 873 int bsize = tctx->mtab->size/tctx->mtab->fmode[i].sub; |
874 ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1, | |
875 -sqrt(norm/bsize) / (1<<15)); | |
876 } | |
877 | |
878 tctx->tmp_buf = av_malloc(mtab->size * sizeof(*tctx->tmp_buf)); | |
879 | |
880 tctx->spectrum = av_malloc(2*mtab->size*channels*sizeof(float)); | |
881 tctx->curr_frame = av_malloc(2*mtab->size*channels*sizeof(float)); | |
882 tctx->prev_frame = av_malloc(2*mtab->size*channels*sizeof(float)); | |
883 | |
10108 | 884 for (i = 0; i < 3; i++) { |
10075 | 885 int m = 4*mtab->size/mtab->fmode[i].sub; |
886 double freq = 2*M_PI/m; | |
887 tctx->cos_tabs[i] = av_malloc((m/4)*sizeof(*tctx->cos_tabs)); | |
888 | |
10108 | 889 for (j = 0; j <= m/8; j++) |
10075 | 890 tctx->cos_tabs[i][j] = cos((2*j + 1)*freq); |
10108 | 891 for (j = 1; j < m/8; j++) |
10075 | 892 tctx->cos_tabs[i][m/4-j] = tctx->cos_tabs[i][j]; |
893 } | |
894 | |
895 | |
10827
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10562
diff
changeset
|
896 ff_init_ff_sine_windows(av_log2(size_m)); |
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10562
diff
changeset
|
897 ff_init_ff_sine_windows(av_log2(size_s/2)); |
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10562
diff
changeset
|
898 ff_init_ff_sine_windows(av_log2(mtab->size)); |
10075 | 899 } |
900 | |
901 /** | |
902 * Interpret the data as if it were a num_blocks x line_len[0] matrix and for | |
903 * each line do a cyclic permutation, i.e. | |
904 * abcdefghijklm -> defghijklmabc | |
905 * where the amount to be shifted is evaluated depending on the column. | |
906 */ | |
907 static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks, | |
908 int block_size, | |
909 const uint8_t line_len[2], int length_div, | |
910 enum FrameType ftype) | |
911 | |
912 { | |
913 int i,j; | |
914 | |
10108 | 915 for (i = 0; i < line_len[0]; i++) { |
10075 | 916 int shift; |
917 | |
918 if (num_blocks == 1 || | |
919 (ftype == FT_LONG && num_vect % num_blocks) || | |
920 (ftype != FT_LONG && num_vect & 1 ) || | |
921 i == line_len[1]) { | |
922 shift = 0; | |
923 } else if (ftype == FT_LONG) { | |
924 shift = i; | |
925 } else | |
926 shift = i*i; | |
927 | |
10108 | 928 for (j = 0; j < num_vect && (j+num_vect*i < block_size*num_blocks); j++) |
10075 | 929 tab[i*num_vect+j] = i*num_vect + (j + shift) % num_vect; |
930 } | |
931 } | |
932 | |
933 /** | |
934 * Interpret the input data as in the following table: | |
935 * | |
936 * \verbatim | |
937 * | |
938 * abcdefgh | |
939 * ijklmnop | |
940 * qrstuvw | |
941 * x123456 | |
942 * | |
943 * \endverbatim | |
944 * | |
945 * and transpose it, giving the output | |
946 * aiqxbjr1cks2dlt3emu4fvn5gow6hp | |
947 */ | |
948 static void transpose_perm(int16_t *out, int16_t *in, int num_vect, | |
949 const uint8_t line_len[2], int length_div) | |
950 { | |
951 int i,j; | |
952 int cont= 0; | |
10108 | 953 for (i = 0; i < num_vect; i++) |
954 for (j = 0; j < line_len[i >= length_div]; j++) | |
10075 | 955 out[cont++] = in[j*num_vect + i]; |
956 } | |
957 | |
958 static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size) | |
959 { | |
960 int block_size = size/n_blocks; | |
961 int i; | |
962 | |
10108 | 963 for (i = 0; i < size; i++) |
10075 | 964 out[i] = block_size * (in[i] % n_blocks) + in[i] / n_blocks; |
965 } | |
966 | |
967 static av_cold void construct_perm_table(TwinContext *tctx,enum FrameType ftype) | |
968 { | |
969 int block_size; | |
970 const ModeTab *mtab = tctx->mtab; | |
971 int size = tctx->avctx->channels*mtab->fmode[ftype].sub; | |
972 int16_t *tmp_perm = (int16_t *) tctx->tmp_buf; | |
973 | |
974 if (ftype == FT_PPC) { | |
975 size = tctx->avctx->channels; | |
976 block_size = mtab->ppc_shape_len; | |
977 } else | |
978 block_size = mtab->size / mtab->fmode[ftype].sub; | |
979 | |
980 permutate_in_line(tmp_perm, tctx->n_div[ftype], size, | |
981 block_size, tctx->length[ftype], | |
982 tctx->length_change[ftype], ftype); | |
983 | |
984 transpose_perm(tctx->permut[ftype], tmp_perm, tctx->n_div[ftype], | |
985 tctx->length[ftype], tctx->length_change[ftype]); | |
986 | |
987 linear_perm(tctx->permut[ftype], tctx->permut[ftype], size, | |
988 size*block_size); | |
989 } | |
990 | |
991 static av_cold void init_bitstream_params(TwinContext *tctx) | |
992 { | |
993 const ModeTab *mtab = tctx->mtab; | |
994 int n_ch = tctx->avctx->channels; | |
995 int total_fr_bits = tctx->avctx->bit_rate*mtab->size/ | |
996 tctx->avctx->sample_rate; | |
997 | |
998 int lsp_bits_per_block = n_ch*(mtab->lsp_bit0 + mtab->lsp_bit1 + | |
999 mtab->lsp_split*mtab->lsp_bit2); | |
1000 | |
1001 int ppc_bits = n_ch*(mtab->pgain_bit + mtab->ppc_shape_bit + | |
1002 mtab->ppc_period_bit); | |
1003 | |
1004 int bsize_no_main_cb[3]; | |
1005 int bse_bits[3]; | |
1006 int i; | |
10500
6d653bb57c58
Use enum FrameType as parameter to construct_perm_table().
cehoyos
parents:
10199
diff
changeset
|
1007 enum FrameType frametype; |
10075 | 1008 |
10108 | 1009 for (i = 0; i < 3; i++) |
10075 | 1010 // +1 for history usage switch |
1011 bse_bits[i] = n_ch * | |
1012 (mtab->fmode[i].bark_n_coef * mtab->fmode[i].bark_n_bit + 1); | |
1013 | |
1014 bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits + | |
1015 WINDOW_TYPE_BITS + n_ch*GAIN_BITS; | |
1016 | |
10108 | 1017 for (i = 0; i < 2; i++) |
10075 | 1018 bsize_no_main_cb[i] = |
1019 lsp_bits_per_block + n_ch*GAIN_BITS + WINDOW_TYPE_BITS + | |
1020 mtab->fmode[i].sub*(bse_bits[i] + n_ch*SUB_GAIN_BITS); | |
1021 | |
1022 // The remaining bits are all used for the main spectrum coefficients | |
10108 | 1023 for (i = 0; i < 4; i++) { |
10075 | 1024 int bit_size; |
1025 int vect_size; | |
1026 int rounded_up, rounded_down, num_rounded_down, num_rounded_up; | |
1027 if (i == 3) { | |
1028 bit_size = n_ch * mtab->ppc_shape_bit; | |
1029 vect_size = n_ch * mtab->ppc_shape_len; | |
1030 } else { | |
1031 bit_size = total_fr_bits - bsize_no_main_cb[i]; | |
1032 vect_size = n_ch * mtab->size; | |
1033 } | |
1034 | |
1035 tctx->n_div[i] = (bit_size + 13) / 14; | |
1036 | |
1037 rounded_up = (bit_size + tctx->n_div[i] - 1)/tctx->n_div[i]; | |
1038 rounded_down = (bit_size )/tctx->n_div[i]; | |
1039 num_rounded_down = rounded_up * tctx->n_div[i] - bit_size; | |
1040 num_rounded_up = tctx->n_div[i] - num_rounded_down; | |
1041 tctx->bits_main_spec[0][i][0] = (rounded_up + 1)/2; | |
1042 tctx->bits_main_spec[1][i][0] = (rounded_up )/2; | |
1043 tctx->bits_main_spec[0][i][1] = (rounded_down + 1)/2; | |
1044 tctx->bits_main_spec[1][i][1] = (rounded_down )/2; | |
1045 tctx->bits_main_spec_change[i] = num_rounded_up; | |
1046 | |
1047 rounded_up = (vect_size + tctx->n_div[i] - 1)/tctx->n_div[i]; | |
1048 rounded_down = (vect_size )/tctx->n_div[i]; | |
1049 num_rounded_down = rounded_up * tctx->n_div[i] - vect_size; | |
1050 num_rounded_up = tctx->n_div[i] - num_rounded_down; | |
1051 tctx->length[i][0] = rounded_up; | |
1052 tctx->length[i][1] = rounded_down; | |
1053 tctx->length_change[i] = num_rounded_up; | |
1054 } | |
1055 | |
10500
6d653bb57c58
Use enum FrameType as parameter to construct_perm_table().
cehoyos
parents:
10199
diff
changeset
|
1056 for (frametype = FT_SHORT; frametype <= FT_PPC; frametype++) |
6d653bb57c58
Use enum FrameType as parameter to construct_perm_table().
cehoyos
parents:
10199
diff
changeset
|
1057 construct_perm_table(tctx, frametype); |
10075 | 1058 } |
1059 | |
1060 static av_cold int twin_decode_init(AVCodecContext *avctx) | |
1061 { | |
1062 TwinContext *tctx = avctx->priv_data; | |
1063 int isampf = avctx->sample_rate/1000; | |
1064 int ibps = avctx->bit_rate/(1000 * avctx->channels); | |
1065 | |
1066 tctx->avctx = avctx; | |
1067 avctx->sample_fmt = SAMPLE_FMT_FLT; | |
1068 | |
1069 if (avctx->channels > 2) { | |
1070 av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %i\n", | |
1071 avctx->channels); | |
1072 return -1; | |
1073 } | |
1074 | |
1075 switch ((isampf << 8) + ibps) { | |
1076 case (8 <<8) + 8: tctx->mtab = &mode_08_08; break; | |
1077 case (11<<8) + 8: tctx->mtab = &mode_11_08; break; | |
1078 case (11<<8) + 10: tctx->mtab = &mode_11_10; break; | |
1079 case (16<<8) + 16: tctx->mtab = &mode_16_16; break; | |
1080 case (22<<8) + 20: tctx->mtab = &mode_22_20; break; | |
1081 case (22<<8) + 24: tctx->mtab = &mode_22_24; break; | |
1082 case (22<<8) + 32: tctx->mtab = &mode_22_32; break; | |
1083 case (44<<8) + 40: tctx->mtab = &mode_44_40; break; | |
1084 case (44<<8) + 48: tctx->mtab = &mode_44_48; break; | |
1085 default: | |
1086 av_log(avctx, AV_LOG_ERROR, "This version does not support %d kHz - %d kbit/s/ch mode.\n", isampf, isampf); | |
1087 return -1; | |
1088 } | |
1089 | |
1090 dsputil_init(&tctx->dsp, avctx); | |
1091 init_mdct_win(tctx); | |
1092 init_bitstream_params(tctx); | |
1093 | |
1094 memset_float(tctx->bark_hist[0][0], 0.1, FF_ARRAY_ELEMS(tctx->bark_hist)); | |
1095 | |
1096 return 0; | |
1097 } | |
1098 | |
1099 static av_cold int twin_decode_close(AVCodecContext *avctx) | |
1100 { | |
1101 TwinContext *tctx = avctx->priv_data; | |
1102 int i; | |
1103 | |
10108 | 1104 for (i = 0; i < 3; i++) { |
10075 | 1105 ff_mdct_end(&tctx->mdct_ctx[i]); |
1106 av_free(tctx->cos_tabs[i]); | |
1107 } | |
1108 | |
1109 | |
1110 av_free(tctx->curr_frame); | |
1111 av_free(tctx->spectrum); | |
1112 av_free(tctx->prev_frame); | |
1113 av_free(tctx->tmp_buf); | |
1114 | |
1115 return 0; | |
1116 } | |
1117 | |
1118 AVCodec twinvq_decoder = | |
1119 { | |
1120 "twinvq", | |
1121 CODEC_TYPE_AUDIO, | |
1122 CODEC_ID_TWINVQ, | |
1123 sizeof(TwinContext), | |
1124 twin_decode_init, | |
1125 NULL, | |
1126 twin_decode_close, | |
1127 twin_decode_frame, | |
1128 .long_name = NULL_IF_CONFIG_SMALL("VQF TwinVQ"), | |
1129 }; |