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