3 * Copyright (c) 2009 Vitor Sessak
5 * This file is part of FFmpeg.
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.
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.
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
25 #include "libavutil/channel_layout.h"
26 #include "libavutil/float_dsp.h"
35 * Evaluate a single LPC amplitude spectrum envelope coefficient from the line
38 * @param lsp a vector of the cosine of the LSP values
39 * @param cos_val cos(PI*i/N) where i is the index of the LPC amplitude
40 * @param order the order of the LSP (and the size of the *lsp buffer). Must
41 * be a multiple of four.
42 * @return the LPC value
44 * @todo reuse code from Vorbis decoder: vorbis_floor0_decode
46 static float eval_lpc_spectrum(const float *lsp
, float cos_val
, int order
)
51 float two_cos_w
= 2.0f
* cos_val
;
53 for (j
= 0; j
+ 1 < order
; j
+= 2 * 2) {
54 // Unroll the loop once since order is a multiple of four
55 q
*= lsp
[j
] - two_cos_w
;
56 p
*= lsp
[j
+ 1] - two_cos_w
;
58 q
*= lsp
[j
+ 2] - two_cos_w
;
59 p
*= lsp
[j
+ 3] - two_cos_w
;
62 p
*= p
* (2.0f
- two_cos_w
);
63 q
*= q
* (2.0f
+ two_cos_w
);
69 * Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
71 static void eval_lpcenv(TwinVQContext
*tctx
, const float *cos_vals
, float *lpc
)
74 const TwinVQModeTab
*mtab
= tctx
->mtab
;
75 int size_s
= mtab
->size
/ mtab
->fmode
[TWINVQ_FT_SHORT
].sub
;
77 for (i
= 0; i
< size_s
/ 2; i
++) {
78 float cos_i
= tctx
->cos_tabs
[0][i
];
79 lpc
[i
] = eval_lpc_spectrum(cos_vals
, cos_i
, mtab
->n_lsp
);
80 lpc
[size_s
- i
- 1] = eval_lpc_spectrum(cos_vals
, -cos_i
, mtab
->n_lsp
);
84 static void interpolate(float *out
, float v1
, float v2
, int size
)
87 float step
= (v1
- v2
) / (size
+ 1);
89 for (i
= 0; i
< size
; i
++) {
95 static inline float get_cos(int idx
, int part
, const float *cos_tab
, int size
)
97 return part
? -cos_tab
[size
- idx
- 1]
102 * Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
103 * Probably for speed reasons, the coefficients are evaluated as
104 * siiiibiiiisiiiibiiiisiiiibiiiisiiiibiiiis ...
105 * where s is an evaluated value, i is a value interpolated from the others
106 * and b might be either calculated or interpolated, depending on an
107 * unexplained condition.
109 * @param step the size of a block "siiiibiiii"
110 * @param in the cosine of the LSP data
111 * @param part is 0 for 0...PI (positive cosine values) and 1 for PI...2PI
112 * (negative cosine values)
113 * @param size the size of the whole output
115 static inline void eval_lpcenv_or_interp(TwinVQContext
*tctx
,
116 enum TwinVQFrameType ftype
,
117 float *out
, const float *in
,
118 int size
, int step
, int part
)
121 const TwinVQModeTab
*mtab
= tctx
->mtab
;
122 const float *cos_tab
= tctx
->cos_tabs
[ftype
];
125 for (i
= 0; i
< size
; i
+= step
)
127 eval_lpc_spectrum(in
,
128 get_cos(i
, part
, cos_tab
, size
),
131 // Fill the 'iiiibiiii'
132 for (i
= step
; i
<= size
- 2 * step
; i
+= step
) {
133 if (out
[i
+ step
] + out
[i
- step
] > 1.95 * out
[i
] ||
134 out
[i
+ step
] >= out
[i
- step
]) {
135 interpolate(out
+ i
- step
+ 1, out
[i
], out
[i
- step
], step
- 1);
138 eval_lpc_spectrum(in
,
139 get_cos(i
- step
/ 2, part
, cos_tab
, size
),
141 interpolate(out
+ i
- step
+ 1, out
[i
- step
/ 2],
142 out
[i
- step
], step
/ 2 - 1);
143 interpolate(out
+ i
- step
/ 2 + 1, out
[i
],
144 out
[i
- step
/ 2], step
/ 2 - 1);
148 interpolate(out
+ size
- 2 * step
+ 1, out
[size
- step
],
149 out
[size
- 2 * step
], step
- 1);
152 static void eval_lpcenv_2parts(TwinVQContext
*tctx
, enum TwinVQFrameType ftype
,
153 const float *buf
, float *lpc
,
156 eval_lpcenv_or_interp(tctx
, ftype
, lpc
, buf
, size
/ 2, step
, 0);
157 eval_lpcenv_or_interp(tctx
, ftype
, lpc
+ size
/ 2, buf
, size
/ 2,
160 interpolate(lpc
+ size
/ 2 - step
+ 1, lpc
[size
/ 2],
161 lpc
[size
/ 2 - step
], step
);
163 twinvq_memset_float(lpc
+ size
- 2 * step
+ 1, lpc
[size
- 2 * step
],
168 * Inverse quantization. Read CB coefficients for cb1 and cb2 from the
169 * bitstream, sum the corresponding vectors and write the result to *out
172 static void dequant(TwinVQContext
*tctx
, const uint8_t *cb_bits
, float *out
,
173 enum TwinVQFrameType ftype
,
174 const int16_t *cb0
, const int16_t *cb1
, int cb_len
)
179 for (i
= 0; i
< tctx
->n_div
[ftype
]; i
++) {
183 const int16_t *tab0
, *tab1
;
184 int length
= tctx
->length
[ftype
][i
>= tctx
->length_change
[ftype
]];
185 int bitstream_second_part
= (i
>= tctx
->bits_main_spec_change
[ftype
]);
187 int bits
= tctx
->bits_main_spec
[0][ftype
][bitstream_second_part
];
195 bits
= tctx
->bits_main_spec
[1][ftype
][bitstream_second_part
];
203 tab0
= cb0
+ tmp0
* cb_len
;
204 tab1
= cb1
+ tmp1
* cb_len
;
206 for (j
= 0; j
< length
; j
++)
207 out
[tctx
->permut
[ftype
][pos
+ j
]] = sign0
* tab0
[j
] +
214 static void dec_gain(TwinVQContext
*tctx
,
215 enum TwinVQFrameType ftype
, float *out
)
217 const TwinVQModeTab
*mtab
= tctx
->mtab
;
218 const TwinVQFrameData
*bits
= &tctx
->bits
[tctx
->cur_frame
];
220 int sub
= mtab
->fmode
[ftype
].sub
;
221 float step
= TWINVQ_AMP_MAX
/ ((1 << TWINVQ_GAIN_BITS
) - 1);
222 float sub_step
= TWINVQ_SUB_AMP_MAX
/ ((1 << TWINVQ_SUB_GAIN_BITS
) - 1);
224 if (ftype
== TWINVQ_FT_LONG
) {
225 for (i
= 0; i
< tctx
->avctx
->channels
; i
++)
226 out
[i
] = (1.0 / (1 << 13)) *
227 twinvq_mulawinv(step
* 0.5 + step
* bits
->gain_bits
[i
],
228 TWINVQ_AMP_MAX
, TWINVQ_MULAW_MU
);
230 for (i
= 0; i
< tctx
->avctx
->channels
; i
++) {
231 float val
= (1.0 / (1 << 23)) *
232 twinvq_mulawinv(step
* 0.5 + step
* bits
->gain_bits
[i
],
233 TWINVQ_AMP_MAX
, TWINVQ_MULAW_MU
);
235 for (j
= 0; j
< sub
; j
++)
237 val
* twinvq_mulawinv(sub_step
* 0.5 +
238 sub_step
* bits
->sub_gain_bits
[i
* sub
+ j
],
239 TWINVQ_SUB_AMP_MAX
, TWINVQ_MULAW_MU
);
245 * Rearrange the LSP coefficients so that they have a minimum distance of
246 * min_dist. This function does it exactly as described in section of 3.2.4
247 * of the G.729 specification (but interestingly is different from what the
248 * reference decoder actually does).
250 static void rearrange_lsp(int order
, float *lsp
, float min_dist
)
253 float min_dist2
= min_dist
* 0.5;
254 for (i
= 1; i
< order
; i
++)
255 if (lsp
[i
] - lsp
[i
- 1] < min_dist
) {
256 float avg
= (lsp
[i
] + lsp
[i
- 1]) * 0.5;
258 lsp
[i
- 1] = avg
- min_dist2
;
259 lsp
[i
] = avg
+ min_dist2
;
263 static void decode_lsp(TwinVQContext
*tctx
, int lpc_idx1
, uint8_t *lpc_idx2
,
264 int lpc_hist_idx
, float *lsp
, float *hist
)
266 const TwinVQModeTab
*mtab
= tctx
->mtab
;
269 const float *cb
= mtab
->lspcodebook
;
270 const float *cb2
= cb
+ (1 << mtab
->lsp_bit1
) * mtab
->n_lsp
;
271 const float *cb3
= cb2
+ (1 << mtab
->lsp_bit2
) * mtab
->n_lsp
;
273 const int8_t funny_rounding
[4] = {
275 mtab
->lsp_split
== 4 ? -2 : 1,
276 mtab
->lsp_split
== 4 ? -2 : 1,
281 for (i
= 0; i
< mtab
->lsp_split
; i
++) {
282 int chunk_end
= ((i
+ 1) * mtab
->n_lsp
+ funny_rounding
[i
]) /
284 for (; j
< chunk_end
; j
++)
285 lsp
[j
] = cb
[lpc_idx1
* mtab
->n_lsp
+ j
] +
286 cb2
[lpc_idx2
[i
] * mtab
->n_lsp
+ j
];
289 rearrange_lsp(mtab
->n_lsp
, lsp
, 0.0001);
291 for (i
= 0; i
< mtab
->n_lsp
; i
++) {
292 float tmp1
= 1.0 - cb3
[lpc_hist_idx
* mtab
->n_lsp
+ i
];
293 float tmp2
= hist
[i
] * cb3
[lpc_hist_idx
* mtab
->n_lsp
+ i
];
295 lsp
[i
] = lsp
[i
] * tmp1
+ tmp2
;
298 rearrange_lsp(mtab
->n_lsp
, lsp
, 0.0001);
299 rearrange_lsp(mtab
->n_lsp
, lsp
, 0.000095);
300 ff_sort_nearly_sorted_floats(lsp
, mtab
->n_lsp
);
303 static void dec_lpc_spectrum_inv(TwinVQContext
*tctx
, float *lsp
,
304 enum TwinVQFrameType ftype
, float *lpc
)
307 int size
= tctx
->mtab
->size
/ tctx
->mtab
->fmode
[ftype
].sub
;
309 for (i
= 0; i
< tctx
->mtab
->n_lsp
; i
++)
310 lsp
[i
] = 2 * cos(lsp
[i
]);
314 eval_lpcenv_2parts(tctx
, ftype
, lsp
, lpc
, size
, 8);
316 case TWINVQ_FT_MEDIUM
:
317 eval_lpcenv_2parts(tctx
, ftype
, lsp
, lpc
, size
, 2);
319 case TWINVQ_FT_SHORT
:
320 eval_lpcenv(tctx
, lsp
, lpc
);
325 static const uint8_t wtype_to_wsize
[] = { 0, 0, 2, 2, 2, 1, 0, 1, 1 };
327 static void imdct_and_window(TwinVQContext
*tctx
, enum TwinVQFrameType ftype
,
328 int wtype
, float *in
, float *prev
, int ch
)
330 FFTContext
*mdct
= &tctx
->mdct_ctx
[ftype
];
331 const TwinVQModeTab
*mtab
= tctx
->mtab
;
332 int bsize
= mtab
->size
/ mtab
->fmode
[ftype
].sub
;
333 int size
= mtab
->size
;
334 float *buf1
= tctx
->tmp_buf
;
335 int j
, first_wsize
, wsize
; // Window size
336 float *out
= tctx
->curr_frame
+ 2 * ch
* mtab
->size
;
339 int types_sizes
[] = {
340 mtab
->size
/ mtab
->fmode
[TWINVQ_FT_LONG
].sub
,
341 mtab
->size
/ mtab
->fmode
[TWINVQ_FT_MEDIUM
].sub
,
342 mtab
->size
/ (mtab
->fmode
[TWINVQ_FT_SHORT
].sub
* 2),
345 wsize
= types_sizes
[wtype_to_wsize
[wtype
]];
347 prev_buf
= prev
+ (size
- bsize
) / 2;
349 for (j
= 0; j
< mtab
->fmode
[ftype
].sub
; j
++) {
350 int sub_wtype
= ftype
== TWINVQ_FT_MEDIUM
? 8 : wtype
;
352 if (!j
&& wtype
== 4)
354 else if (j
== mtab
->fmode
[ftype
].sub
- 1 && wtype
== 7)
357 wsize
= types_sizes
[wtype_to_wsize
[sub_wtype
]];
359 mdct
->imdct_half(mdct
, buf1
+ bsize
* j
, in
+ bsize
* j
);
361 tctx
->fdsp
->vector_fmul_window(out2
, prev_buf
+ (bsize
- wsize
) / 2,
363 ff_sine_windows
[av_log2(wsize
)],
367 memcpy(out2
, buf1
+ bsize
* j
+ wsize
/ 2,
368 (bsize
- wsize
/ 2) * sizeof(float));
370 out2
+= ftype
== TWINVQ_FT_MEDIUM
? (bsize
- wsize
) / 2 : bsize
- wsize
;
372 prev_buf
= buf1
+ bsize
* j
+ bsize
/ 2;
375 tctx
->last_block_pos
[ch
] = (size
+ first_wsize
) / 2;
378 static void imdct_output(TwinVQContext
*tctx
, enum TwinVQFrameType ftype
,
379 int wtype
, float **out
, int offset
)
381 const TwinVQModeTab
*mtab
= tctx
->mtab
;
382 float *prev_buf
= tctx
->prev_frame
+ tctx
->last_block_pos
[0];
386 for (i
= 0; i
< tctx
->avctx
->channels
; i
++)
387 imdct_and_window(tctx
, ftype
, wtype
,
388 tctx
->spectrum
+ i
* mtab
->size
,
389 prev_buf
+ 2 * i
* mtab
->size
,
395 size2
= tctx
->last_block_pos
[0];
396 size1
= mtab
->size
- size2
;
398 out1
= &out
[0][0] + offset
;
399 memcpy(out1
, prev_buf
, size1
* sizeof(*out1
));
400 memcpy(out1
+ size1
, tctx
->curr_frame
, size2
* sizeof(*out1
));
402 if (tctx
->avctx
->channels
== 2) {
403 out2
= &out
[1][0] + offset
;
404 memcpy(out2
, &prev_buf
[2 * mtab
->size
],
405 size1
* sizeof(*out2
));
406 memcpy(out2
+ size1
, &tctx
->curr_frame
[2 * mtab
->size
],
407 size2
* sizeof(*out2
));
408 tctx
->fdsp
->butterflies_float(out1
, out2
, mtab
->size
);
412 static void read_and_decode_spectrum(TwinVQContext
*tctx
, float *out
,
413 enum TwinVQFrameType ftype
)
415 const TwinVQModeTab
*mtab
= tctx
->mtab
;
416 TwinVQFrameData
*bits
= &tctx
->bits
[tctx
->cur_frame
];
417 int channels
= tctx
->avctx
->channels
;
418 int sub
= mtab
->fmode
[ftype
].sub
;
419 int block_size
= mtab
->size
/ sub
;
420 float gain
[TWINVQ_CHANNELS_MAX
* TWINVQ_SUBBLOCKS_MAX
];
421 float ppc_shape
[TWINVQ_PPC_SHAPE_LEN_MAX
* TWINVQ_CHANNELS_MAX
* 4];
425 dequant(tctx
, bits
->main_coeffs
, out
, ftype
,
426 mtab
->fmode
[ftype
].cb0
, mtab
->fmode
[ftype
].cb1
,
427 mtab
->fmode
[ftype
].cb_len_read
);
429 dec_gain(tctx
, ftype
, gain
);
431 if (ftype
== TWINVQ_FT_LONG
) {
432 int cb_len_p
= (tctx
->n_div
[3] + mtab
->ppc_shape_len
* channels
- 1) /
434 dequant(tctx
, bits
->ppc_coeffs
, ppc_shape
,
435 TWINVQ_FT_PPC
, mtab
->ppc_shape_cb
,
436 mtab
->ppc_shape_cb
+ cb_len_p
* TWINVQ_PPC_SHAPE_CB_SIZE
,
440 for (i
= 0; i
< channels
; i
++) {
441 float *chunk
= out
+ mtab
->size
* i
;
442 float lsp
[TWINVQ_LSP_COEFS_MAX
];
444 for (j
= 0; j
< sub
; j
++) {
445 tctx
->dec_bark_env(tctx
, bits
->bark1
[i
][j
],
446 bits
->bark_use_hist
[i
][j
], i
,
447 tctx
->tmp_buf
, gain
[sub
* i
+ j
], ftype
);
449 tctx
->fdsp
->vector_fmul(chunk
+ block_size
* j
,
450 chunk
+ block_size
* j
,
451 tctx
->tmp_buf
, block_size
);
454 if (ftype
== TWINVQ_FT_LONG
)
455 tctx
->decode_ppc(tctx
, bits
->p_coef
[i
], bits
->g_coef
[i
],
456 ppc_shape
+ i
* mtab
->ppc_shape_len
, chunk
);
458 decode_lsp(tctx
, bits
->lpc_idx1
[i
], bits
->lpc_idx2
[i
],
459 bits
->lpc_hist_idx
[i
], lsp
, tctx
->lsp_hist
[i
]);
461 dec_lpc_spectrum_inv(tctx
, lsp
, ftype
, tctx
->tmp_buf
);
463 for (j
= 0; j
< mtab
->fmode
[ftype
].sub
; j
++) {
464 tctx
->fdsp
->vector_fmul(chunk
, chunk
, tctx
->tmp_buf
, block_size
);
470 const enum TwinVQFrameType ff_twinvq_wtype_to_ftype_table
[] = {
471 TWINVQ_FT_LONG
, TWINVQ_FT_LONG
, TWINVQ_FT_SHORT
, TWINVQ_FT_LONG
,
472 TWINVQ_FT_MEDIUM
, TWINVQ_FT_LONG
, TWINVQ_FT_LONG
, TWINVQ_FT_MEDIUM
,
476 int ff_twinvq_decode_frame(AVCodecContext
*avctx
, void *data
,
477 int *got_frame_ptr
, AVPacket
*avpkt
)
479 AVFrame
*frame
= data
;
480 const uint8_t *buf
= avpkt
->data
;
481 int buf_size
= avpkt
->size
;
482 TwinVQContext
*tctx
= avctx
->priv_data
;
483 const TwinVQModeTab
*mtab
= tctx
->mtab
;
487 /* get output buffer */
488 if (tctx
->discarded_packets
>= 2) {
489 frame
->nb_samples
= mtab
->size
* tctx
->frames_per_packet
;
490 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
492 out
= (float **)frame
->extended_data
;
495 if (buf_size
< avctx
->block_align
) {
496 av_log(avctx
, AV_LOG_ERROR
,
497 "Frame too small (%d bytes). Truncated file?\n", buf_size
);
498 return AVERROR(EINVAL
);
501 if ((ret
= tctx
->read_bitstream(avctx
, tctx
, buf
, buf_size
)) < 0)
504 for (tctx
->cur_frame
= 0; tctx
->cur_frame
< tctx
->frames_per_packet
;
506 read_and_decode_spectrum(tctx
, tctx
->spectrum
,
507 tctx
->bits
[tctx
->cur_frame
].ftype
);
509 imdct_output(tctx
, tctx
->bits
[tctx
->cur_frame
].ftype
,
510 tctx
->bits
[tctx
->cur_frame
].window_type
, out
,
511 tctx
->cur_frame
* mtab
->size
);
513 FFSWAP(float *, tctx
->curr_frame
, tctx
->prev_frame
);
516 if (tctx
->discarded_packets
< 2) {
517 tctx
->discarded_packets
++;
524 // VQF can deliver packets 1 byte greater than block align
525 if (buf_size
== avctx
->block_align
+ 1)
527 return avctx
->block_align
;
531 * Init IMDCT and windowing tables
533 static av_cold
int init_mdct_win(TwinVQContext
*tctx
)
536 const TwinVQModeTab
*mtab
= tctx
->mtab
;
537 int size_s
= mtab
->size
/ mtab
->fmode
[TWINVQ_FT_SHORT
].sub
;
538 int size_m
= mtab
->size
/ mtab
->fmode
[TWINVQ_FT_MEDIUM
].sub
;
539 int channels
= tctx
->avctx
->channels
;
540 float norm
= channels
== 1 ? 2.0 : 1.0;
542 for (i
= 0; i
< 3; i
++) {
543 int bsize
= tctx
->mtab
->size
/ tctx
->mtab
->fmode
[i
].sub
;
544 if ((ret
= ff_mdct_init(&tctx
->mdct_ctx
[i
], av_log2(bsize
) + 1, 1,
545 -sqrt(norm
/ bsize
) / (1 << 15))))
549 FF_ALLOC_ARRAY_OR_GOTO(tctx
->avctx
, tctx
->tmp_buf
,
550 mtab
->size
, sizeof(*tctx
->tmp_buf
), alloc_fail
);
552 FF_ALLOC_ARRAY_OR_GOTO(tctx
->avctx
, tctx
->spectrum
,
553 2 * mtab
->size
, channels
* sizeof(*tctx
->spectrum
),
555 FF_ALLOC_ARRAY_OR_GOTO(tctx
->avctx
, tctx
->curr_frame
,
556 2 * mtab
->size
, channels
* sizeof(*tctx
->curr_frame
),
558 FF_ALLOC_ARRAY_OR_GOTO(tctx
->avctx
, tctx
->prev_frame
,
559 2 * mtab
->size
, channels
* sizeof(*tctx
->prev_frame
),
562 for (i
= 0; i
< 3; i
++) {
563 int m
= 4 * mtab
->size
/ mtab
->fmode
[i
].sub
;
564 double freq
= 2 * M_PI
/ m
;
565 FF_ALLOC_ARRAY_OR_GOTO(tctx
->avctx
, tctx
->cos_tabs
[i
],
566 (m
/ 4), sizeof(*tctx
->cos_tabs
[i
]), alloc_fail
);
568 for (j
= 0; j
<= m
/ 8; j
++)
569 tctx
->cos_tabs
[i
][j
] = cos((2 * j
+ 1) * freq
);
570 for (j
= 1; j
< m
/ 8; j
++)
571 tctx
->cos_tabs
[i
][m
/ 4 - j
] = tctx
->cos_tabs
[i
][j
];
574 ff_init_ff_sine_windows(av_log2(size_m
));
575 ff_init_ff_sine_windows(av_log2(size_s
/ 2));
576 ff_init_ff_sine_windows(av_log2(mtab
->size
));
581 return AVERROR(ENOMEM
);
585 * Interpret the data as if it were a num_blocks x line_len[0] matrix and for
586 * each line do a cyclic permutation, i.e.
587 * abcdefghijklm -> defghijklmabc
588 * where the amount to be shifted is evaluated depending on the column.
590 static void permutate_in_line(int16_t *tab
, int num_vect
, int num_blocks
,
592 const uint8_t line_len
[2], int length_div
,
593 enum TwinVQFrameType ftype
)
597 for (i
= 0; i
< line_len
[0]; i
++) {
600 if (num_blocks
== 1 ||
601 (ftype
== TWINVQ_FT_LONG
&& num_vect
% num_blocks
) ||
602 (ftype
!= TWINVQ_FT_LONG
&& num_vect
& 1) ||
605 } else if (ftype
== TWINVQ_FT_LONG
) {
610 for (j
= 0; j
< num_vect
&& (j
+ num_vect
* i
< block_size
* num_blocks
); j
++)
611 tab
[i
* num_vect
+ j
] = i
* num_vect
+ (j
+ shift
) % num_vect
;
616 * Interpret the input data as in the following table:
627 * and transpose it, giving the output
628 * aiqxbjr1cks2dlt3emu4fvn5gow6hp
630 static void transpose_perm(int16_t *out
, int16_t *in
, int num_vect
,
631 const uint8_t line_len
[2], int length_div
)
636 for (i
= 0; i
< num_vect
; i
++)
637 for (j
= 0; j
< line_len
[i
>= length_div
]; j
++)
638 out
[cont
++] = in
[j
* num_vect
+ i
];
641 static void linear_perm(int16_t *out
, int16_t *in
, int n_blocks
, int size
)
643 int block_size
= size
/ n_blocks
;
646 for (i
= 0; i
< size
; i
++)
647 out
[i
] = block_size
* (in
[i
] % n_blocks
) + in
[i
] / n_blocks
;
650 static av_cold
void construct_perm_table(TwinVQContext
*tctx
,
651 enum TwinVQFrameType ftype
)
653 int block_size
, size
;
654 const TwinVQModeTab
*mtab
= tctx
->mtab
;
655 int16_t *tmp_perm
= (int16_t *)tctx
->tmp_buf
;
657 if (ftype
== TWINVQ_FT_PPC
) {
658 size
= tctx
->avctx
->channels
;
659 block_size
= mtab
->ppc_shape_len
;
661 size
= tctx
->avctx
->channels
* mtab
->fmode
[ftype
].sub
;
662 block_size
= mtab
->size
/ mtab
->fmode
[ftype
].sub
;
665 permutate_in_line(tmp_perm
, tctx
->n_div
[ftype
], size
,
666 block_size
, tctx
->length
[ftype
],
667 tctx
->length_change
[ftype
], ftype
);
669 transpose_perm(tctx
->permut
[ftype
], tmp_perm
, tctx
->n_div
[ftype
],
670 tctx
->length
[ftype
], tctx
->length_change
[ftype
]);
672 linear_perm(tctx
->permut
[ftype
], tctx
->permut
[ftype
], size
,
676 static av_cold
void init_bitstream_params(TwinVQContext
*tctx
)
678 const TwinVQModeTab
*mtab
= tctx
->mtab
;
679 int n_ch
= tctx
->avctx
->channels
;
680 int total_fr_bits
= tctx
->avctx
->bit_rate
* mtab
->size
/
681 tctx
->avctx
->sample_rate
;
683 int lsp_bits_per_block
= n_ch
* (mtab
->lsp_bit0
+ mtab
->lsp_bit1
+
684 mtab
->lsp_split
* mtab
->lsp_bit2
);
686 int ppc_bits
= n_ch
* (mtab
->pgain_bit
+ mtab
->ppc_shape_bit
+
687 mtab
->ppc_period_bit
);
689 int bsize_no_main_cb
[3], bse_bits
[3], i
;
690 enum TwinVQFrameType frametype
;
692 for (i
= 0; i
< 3; i
++)
693 // +1 for history usage switch
695 (mtab
->fmode
[i
].bark_n_coef
*
696 mtab
->fmode
[i
].bark_n_bit
+ 1);
698 bsize_no_main_cb
[2] = bse_bits
[2] + lsp_bits_per_block
+ ppc_bits
+
699 TWINVQ_WINDOW_TYPE_BITS
+ n_ch
* TWINVQ_GAIN_BITS
;
701 for (i
= 0; i
< 2; i
++)
702 bsize_no_main_cb
[i
] =
703 lsp_bits_per_block
+ n_ch
* TWINVQ_GAIN_BITS
+
704 TWINVQ_WINDOW_TYPE_BITS
+
705 mtab
->fmode
[i
].sub
* (bse_bits
[i
] + n_ch
* TWINVQ_SUB_GAIN_BITS
);
707 if (tctx
->codec
== TWINVQ_CODEC_METASOUND
&& !tctx
->is_6kbps
) {
708 bsize_no_main_cb
[1] += 2;
709 bsize_no_main_cb
[2] += 2;
712 // The remaining bits are all used for the main spectrum coefficients
713 for (i
= 0; i
< 4; i
++) {
714 int bit_size
, vect_size
;
715 int rounded_up
, rounded_down
, num_rounded_down
, num_rounded_up
;
717 bit_size
= n_ch
* mtab
->ppc_shape_bit
;
718 vect_size
= n_ch
* mtab
->ppc_shape_len
;
720 bit_size
= total_fr_bits
- bsize_no_main_cb
[i
];
721 vect_size
= n_ch
* mtab
->size
;
724 tctx
->n_div
[i
] = (bit_size
+ 13) / 14;
726 rounded_up
= (bit_size
+ tctx
->n_div
[i
] - 1) /
728 rounded_down
= (bit_size
) / tctx
->n_div
[i
];
729 num_rounded_down
= rounded_up
* tctx
->n_div
[i
] - bit_size
;
730 num_rounded_up
= tctx
->n_div
[i
] - num_rounded_down
;
731 tctx
->bits_main_spec
[0][i
][0] = (rounded_up
+ 1) / 2;
732 tctx
->bits_main_spec
[1][i
][0] = rounded_up
/ 2;
733 tctx
->bits_main_spec
[0][i
][1] = (rounded_down
+ 1) / 2;
734 tctx
->bits_main_spec
[1][i
][1] = rounded_down
/ 2;
735 tctx
->bits_main_spec_change
[i
] = num_rounded_up
;
737 rounded_up
= (vect_size
+ tctx
->n_div
[i
] - 1) /
739 rounded_down
= (vect_size
) / tctx
->n_div
[i
];
740 num_rounded_down
= rounded_up
* tctx
->n_div
[i
] - vect_size
;
741 num_rounded_up
= tctx
->n_div
[i
] - num_rounded_down
;
742 tctx
->length
[i
][0] = rounded_up
;
743 tctx
->length
[i
][1] = rounded_down
;
744 tctx
->length_change
[i
] = num_rounded_up
;
747 for (frametype
= TWINVQ_FT_SHORT
; frametype
<= TWINVQ_FT_PPC
; frametype
++)
748 construct_perm_table(tctx
, frametype
);
751 av_cold
int ff_twinvq_decode_close(AVCodecContext
*avctx
)
753 TwinVQContext
*tctx
= avctx
->priv_data
;
756 for (i
= 0; i
< 3; i
++) {
757 ff_mdct_end(&tctx
->mdct_ctx
[i
]);
758 av_freep(&tctx
->cos_tabs
[i
]);
761 av_freep(&tctx
->curr_frame
);
762 av_freep(&tctx
->spectrum
);
763 av_freep(&tctx
->prev_frame
);
764 av_freep(&tctx
->tmp_buf
);
765 av_freep(&tctx
->fdsp
);
770 av_cold
int ff_twinvq_decode_init(AVCodecContext
*avctx
)
773 TwinVQContext
*tctx
= avctx
->priv_data
;
776 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLTP
;
778 if (!avctx
->block_align
) {
779 avctx
->block_align
= tctx
->frame_size
+ 7 >> 3;
780 } else if (avctx
->block_align
* 8 < tctx
->frame_size
) {
781 av_log(avctx
, AV_LOG_ERROR
, "Block align is %d bits, expected %d\n",
782 avctx
->block_align
* 8, tctx
->frame_size
);
783 return AVERROR_INVALIDDATA
;
785 tctx
->frames_per_packet
= avctx
->block_align
* 8 / tctx
->frame_size
;
786 if (tctx
->frames_per_packet
> TWINVQ_MAX_FRAMES_PER_PACKET
) {
787 av_log(avctx
, AV_LOG_ERROR
, "Too many frames per packet (%d)\n",
788 tctx
->frames_per_packet
);
789 return AVERROR_INVALIDDATA
;
792 tctx
->fdsp
= avpriv_float_dsp_alloc(avctx
->flags
& CODEC_FLAG_BITEXACT
);
794 ff_twinvq_decode_close(avctx
);
795 return AVERROR(ENOMEM
);
797 if ((ret
= init_mdct_win(tctx
))) {
798 av_log(avctx
, AV_LOG_ERROR
, "Error initializing MDCT\n");
799 ff_twinvq_decode_close(avctx
);
802 init_bitstream_params(tctx
);
804 twinvq_memset_float(tctx
->bark_hist
[0][0], 0.1,
805 FF_ARRAY_ELEMS(tctx
->bark_hist
));