101 512 , 12,
tab.lsp08, 1, 5, 3, 3,
tab.shape08 , 8, 28, 20, 6, 40
110 512 , 16,
tab.lsp11, 1, 6, 4, 3,
tab.shape11 , 9, 36, 30, 7, 90
119 512 , 16,
tab.lsp11, 1, 6, 4, 3,
tab.shape11 , 9, 36, 30, 7, 90
128 1024, 16,
tab.lsp16, 1, 6, 4, 3,
tab.shape16 , 9, 56, 60, 7, 180
137 1024, 16,
tab.lsp22_1, 1, 6, 4, 3,
tab.shape22_1, 9, 56, 36, 7, 144
146 1024, 16,
tab.lsp22_1, 1, 6, 4, 3,
tab.shape22_1, 9, 56, 36, 7, 144
155 512 , 16,
tab.lsp22_2, 1, 6, 4, 4,
tab.shape22_2, 9, 56, 36, 7, 72
164 2048, 20,
tab.lsp44, 1, 6, 4, 4,
tab.shape44 , 9, 84, 54, 7, 432
173 2048, 20,
tab.lsp44, 1, 6, 4, 4,
tab.shape44 , 9, 84, 54, 7, 432
208 #define PPC_SHAPE_CB_SIZE 64
209 #define PPC_SHAPE_LEN_MAX 60
210 #define SUB_AMP_MAX 4500.0
211 #define MULAW_MU 100.0
213 #define AMP_MAX 13000.0
214 #define SUB_GAIN_BITS 5
215 #define WINDOW_TYPE_BITS 4
217 #define LSP_COEFS_MAX 20
218 #define LSP_SPLIT_MAX 4
219 #define CHANNELS_MAX 2
220 #define SUBBLOCKS_MAX 16
221 #define BARK_N_COEF_MAX 4
247 float two_cos_w = 2.0f*cos_val;
249 for (j = 0; j + 1 < order; j += 2*2) {
251 q *= lsp[j ] - two_cos_w;
252 p *= lsp[j+1] - two_cos_w;
254 q *= lsp[j+2] - two_cos_w;
255 p *= lsp[j+3] - two_cos_w;
258 p *= p * (2.0f - two_cos_w);
259 q *= q * (2.0f + two_cos_w);
261 return 0.5 / (p + q);
273 for (i = 0; i < size_s/2; i++) {
283 float step = (v1 - v2)/(size + 1);
285 for (i = 0; i <
size; i++) {
291 static inline float get_cos(
int idx,
int part,
const float *cos_tab,
int size)
293 return part ? -cos_tab[size - idx - 1] :
313 float *out,
const float *in,
318 const float *cos_tab = tctx->
cos_tabs[ftype];
324 get_cos(i, part, cos_tab, size),
328 for (i = step; i <= size - 2*
step; i +=
step) {
329 if (out[i + step] + out[i - step] > 1.95*out[i] ||
330 out[i + step] >= out[i - step]) {
331 interpolate(out + i - step + 1, out[i], out[i-step], step - 1);
335 get_cos(i-step/2, part, cos_tab, size),
337 interpolate(out + i - step + 1, out[i-step/2], out[i-step ], step/2 - 1);
338 interpolate(out + i - step/2 + 1, out[i ], out[i-step/2], step/2 - 1);
342 interpolate(out + size - 2*step + 1, out[size-step], out[size - 2*step], step - 1);
346 const float *buf,
float *lpc,
352 interpolate(lpc+size/2-step+1, lpc[size/2], lpc[size/2-step], step);
354 memset_float(lpc + size - 2*step + 1, lpc[size - 2*step], 2*step - 1);
364 const int16_t *cb0,
const int16_t *cb1,
int cb_len)
369 for (i = 0; i < tctx->
n_div[ftype]; i++) {
373 const int16_t *tab0, *
tab1;
395 tab0 = cb0 + tmp0*cb_len;
396 tab1 = cb1 + tmp1*cb_len;
398 for (j = 0; j < length; j++)
399 out[tctx->
permut[ftype][pos+j]] = sign0*tab0[j] + sign1*tab1[j];
408 y = av_clipf(y/clip, -1, 1);
409 return clip *
FFSIGN(y) * (exp(log(1+mu) * fabs(y)) - 1) / mu;
443 size =
tabs[b/5].size;
444 rtab =
tabs[b/5].tab;
445 return x - rtab[size*av_log2(2*(x - 1)/size)+(x - 1)%size];
454 float ppc_gain,
float *speech,
int len)
458 const float *shape_end = shape +
len;
462 for (i = 0; i < width/2; i++)
463 speech[i] += ppc_gain * *shape++;
467 for (j = -width/2; j < (width+1)/2; j++)
468 speech[j+center] += ppc_gain * *shape++;
473 for (j = -width/2; j < (width + 1)/2 && shape < shape_end; j++)
474 speech[j+center] += ppc_gain * *shape++;
478 float ppc_gain,
float *speech)
485 int period_range = max_period - min_period;
489 int period = min_period +
493 if (isampf == 22 && ibps == 32) {
513 out[i] = (1./(1<<13)) *
518 float val = (1./(1<<23)) *
522 for (j = 0; j < sub; j++) {
541 float min_dist2 = min_dist * 0.5;
542 for (i = 1; i < order; i++)
543 if (lsp[i] - lsp[i-1] < min_dist) {
544 float avg = (lsp[i] + lsp[i-1]) * 0.5;
546 lsp[i-1] = avg - min_dist2;
547 lsp[i ] = avg + min_dist2;
552 int lpc_hist_idx,
float *lsp,
float *hist)
561 const int8_t funny_rounding[4] = {
570 int chunk_end = ((i + 1)*mtab->
n_lsp + funny_rounding[i])/mtab->
lsp_split;
571 for (; j < chunk_end; j++)
572 lsp[j] = cb [lpc_idx1 * mtab->
n_lsp + j] +
573 cb2[lpc_idx2[i] * mtab->
n_lsp + j];
578 for (i = 0; i < mtab->
n_lsp; i++) {
579 float tmp1 = 1. - cb3[lpc_hist_idx*mtab->
n_lsp + i];
580 float tmp2 = hist[i] * cb3[lpc_hist_idx*mtab->
n_lsp + i];
582 lsp[i] = lsp[i] * tmp1 + tmp2;
597 lsp[i] = 2*cos(lsp[i]);
613 float *in,
float *prev,
int ch)
627 static const uint8_t wtype_to_wsize[] = {0, 0, 2, 2, 2, 1, 0, 1, 1};
628 int types_sizes[] = {
634 wsize = types_sizes[wtype_to_wsize[wtype]];
636 prev_buf = prev + (size - bsize)/2;
638 for (j = 0; j < mtab->
fmode[ftype].
sub; j++) {
639 int sub_wtype = ftype ==
FT_MEDIUM ? 8 : wtype;
641 if (!j && wtype == 4)
643 else if (j == mtab->
fmode[ftype].
sub-1 && wtype == 7)
646 wsize = types_sizes[wtype_to_wsize[sub_wtype]];
648 mdct->
imdct_half(mdct, buf1 + bsize*j, in + bsize*j);
651 prev_buf + (bsize-wsize)/2,
657 memcpy(out2, buf1 + bsize*j + wsize/2, (bsize - wsize/2)*
sizeof(
float));
659 out2 += ftype ==
FT_MEDIUM ? (bsize-wsize)/2 : bsize - wsize;
661 prev_buf = buf1 + bsize*j + bsize/2;
678 prev_buf + 2*i*mtab->
size,
686 size1 = mtab->
size - size2;
689 &prev_buf[2*mtab->
size],
698 memcpy(out, prev_buf, size1 *
sizeof(*out));
702 memcpy(out, tctx->
curr_frame, size2 *
sizeof(*out));
708 int ch,
float *out,
float gain,
enum FrameType ftype)
712 float *hist = tctx->
bark_hist[ftype][ch];
713 float val = ((
const float []) {0.4, 0.35, 0.28})[ftype];
718 for (i = 0; i < fw_cb_len; i++)
719 for (j = 0; j < bark_n_coef; j++, idx++) {
721 mtab->
fmode[ftype].
bark_cb[fw_cb_len*in[j] + i] * (1./4096);
722 float st = use_hist ?
723 (1. - val) * tmp2 + val*hist[idx] + 1. : tmp2 + 1.;
726 if (st < -1.) st = 1.;
740 int block_size = mtab->
size / sub;
756 for (i = 0; i < channels; i++)
757 for (j = 0; j < sub; j++)
762 for (i = 0; i < channels; i++)
763 for (j = 0; j < sub; j++)
768 for (i = 0; i < channels; i++) {
783 for (i = 0; i < channels; i++) {
784 float *chunk = out + mtab->
size * i;
787 for (j = 0; j < sub; j++) {
789 tctx->
tmp_buf, gain[sub*i+j], ftype);
797 float pgain_step = 25000. / ((1 << mtab->
pgain_bit) - 1);
807 decode_lsp(tctx, lpc_idx1[i], lpc_idx2[i], lpc_hist_idx[i], lsp,
812 for (j = 0; j < mtab->
fmode[ftype].
sub; j++) {
820 int *got_frame_ptr,
AVPacket *avpkt)
822 const uint8_t *buf = avpkt->
data;
823 int buf_size = avpkt->
size;
829 int window_type, ret;
830 static const enum FrameType wtype_to_ftype_table[] = {
837 "Frame too small (%d bytes). Truncated file?\n", buf_size);
855 if (window_type > 8) {
860 ftype = wtype_to_ftype_table[window_type];
890 float norm = channels == 1 ? 2. : 1.;
892 for (i = 0; i < 3; i++) {
895 -sqrt(norm/bsize) / (1<<15))))
912 for (i = 0; i < 3; i++) {
914 double freq = 2*
M_PI/m;
916 (m / 4) *
sizeof(*tctx->
cos_tabs[i]), alloc_fail);
918 for (j = 0; j <= m/8; j++)
919 tctx->
cos_tabs[i][j] = cos((2*j + 1)*freq);
920 for (j = 1; j < m/8; j++)
942 const uint8_t line_len[2],
int length_div,
948 for (i = 0; i < line_len[0]; i++) {
951 if (num_blocks == 1 ||
952 (ftype ==
FT_LONG && num_vect % num_blocks) ||
953 (ftype !=
FT_LONG && num_vect & 1 ) ||
961 for (j = 0; j < num_vect && (j+num_vect*i < block_size*num_blocks); j++)
962 tab[i*num_vect+j] = i*num_vect + (j + shift) % num_vect;
982 const uint8_t line_len[2],
int length_div)
986 for (i = 0; i < num_vect; i++)
987 for (j = 0; j < line_len[i >= length_div]; j++)
988 out[cont++] = in[j*num_vect + i];
991 static void linear_perm(int16_t *out, int16_t *in,
int n_blocks,
int size)
993 int block_size = size/n_blocks;
996 for (i = 0; i <
size; i++)
997 out[i] = block_size * (in[i] % n_blocks) + in[i] / n_blocks;
1005 int16_t *tmp_perm = (int16_t *) tctx->
tmp_buf;
1016 block_size, tctx->
length[ftype],
1039 int bsize_no_main_cb[3];
1044 for (i = 0; i < 3; i++)
1046 bse_bits[i] = n_ch *
1049 bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits +
1052 for (i = 0; i < 2; i++)
1053 bsize_no_main_cb[i] =
1058 for (i = 0; i < 4; i++) {
1061 int rounded_up, rounded_down, num_rounded_down, num_rounded_up;
1066 bit_size = total_fr_bits - bsize_no_main_cb[i];
1067 vect_size = n_ch * mtab->
size;
1070 tctx->
n_div[i] = (bit_size + 13) / 14;
1072 rounded_up = (bit_size + tctx->
n_div[i] - 1)/tctx->
n_div[i];
1073 rounded_down = (bit_size )/tctx->
n_div[i];
1074 num_rounded_down = rounded_up * tctx->
n_div[i] - bit_size;
1075 num_rounded_up = tctx->
n_div[i] - num_rounded_down;
1082 rounded_up = (vect_size + tctx->
n_div[i] - 1)/tctx->
n_div[i];
1083 rounded_down = (vect_size )/tctx->
n_div[i];
1084 num_rounded_down = rounded_up * tctx->
n_div[i] - vect_size;
1085 num_rounded_up = tctx->
n_div[i] - num_rounded_down;
1086 tctx->
length[i][0] = rounded_up;
1087 tctx->
length[i][1] = rounded_down;
1100 for (i = 0; i < 3; i++) {
1120 tctx->
avctx = avctx;
1134 default: avctx->
sample_rate = isampf * 1000;
break;
1143 if (ibps < 8 || ibps > 48) {
1148 switch ((isampf << 8) + ibps) {
1159 av_log(avctx,
AV_LOG_ERROR,
"This version does not support %d kHz - %d kbit/s/ch mode.\n", isampf, isampf);
static const ModeTab mode_44_40
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
static av_cold void init_bitstream_params(TwinContext *tctx)
static void read_and_decode_spectrum(TwinContext *tctx, GetBitContext *gb, float *out, enum FrameType ftype)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static av_cold int twin_decode_close(AVCodecContext *avctx)
int bits_main_spec_change[4]
static const ModeTab mode_11_10
uint8_t bits_main_spec[2][4][2]
bits for the main codebook
static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
static av_cold void construct_perm_table(TwinContext *tctx, int ftype)
AV_WL32 AV_WL24 AV_WL16 AV_RB32
static void dec_lpc_spectrum_inv(TwinContext *tctx, float *lsp, enum FrameType ftype, float *lpc)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Parameters and tables that are different for every combination of bitrate/sample rate.
AVFrame * coded_frame
the picture in the bitstream
const int16_t * ppc_shape_cb
PPC shape CB.
static const uint16_t bark_tab_m44_512[]
float * prev_frame
non-interleaved previous frame
static const ModeTab mode_22_32
static const uint16_t bark_tab_m08_256[]
#define FF_ARRAY_ELEMS(a)
uint8_t sub
Number subblocks in each frame.
SINETABLE_CONST float *const ff_sine_windows[13]
static const ModeTab mode_16_16
uint8_t ppc_period_bit
number of the bits for the PPC period value
struct TwinContext TwinContext
const int16_t * cb0
main codebooks for spectrum data
uint16_t peak_per2wid
constant for peak period to peak width conversion
const uint16_t * bark_tab
Short frame (divided in n sub-blocks)
uint8_t ppc_shape_len
size of PPC shape CB
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
enum AVSampleFormat sample_fmt
audio sample format
uint8_t bark_n_coef
number of BSE CB coefficients to read
static const uint16_t bark_tab_s11_64[]
static const uint16_t bark_tab_s22_128[]
static const uint16_t bark_tab_l11_512[]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
const float * lspcodebook
static void interpolate(float *out, float v1, float v2, int size)
static const uint16_t bark_tab_l22_1024[]
bitstream reader API header.
static const uint16_t bark_tab_l44_2048[]
static const uint16_t bark_tab_s08_64[]
uint8_t ppc_shape_bit
number of bits of the PPC shape CB coeffs
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
static int init(AVCodecParserContext *s)
#define ROUNDED_DIV(a, b)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
uint8_t n_lsp
number of lsp coefficients
static const struct @41 tabs[]
static const ModeTab mode_08_08
uint8_t bark_n_bit
number of bits of the BSE coefs
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static const uint16_t bark_tab_m11_256[]
Long frame (single sub-block + PPC)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static const ModeTab mode_11_08
static av_cold int init_mdct_win(TwinContext *tctx)
Init IMDCT and windowing tables.
static const uint16_t bark_tab_m22_256[]
static const uint16_t bark_tab_m22_512[]
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static const uint16_t bark_tab_s44_128[]
static const uint16_t bark_tab_l22_512[]
static const ModeTab mode_22_24
static void dequant(TwinContext *tctx, GetBitContext *gb, float *out, enum FrameType ftype, const int16_t *cb0, const int16_t *cb1, int cb_len)
Inverse quantization.
#define PPC_SHAPE_CB_SIZE
Parameters and tables that are different for each frame type.
int bit_rate
the average bitrate
static void imdct_and_window(TwinContext *tctx, enum FrameType ftype, int wtype, float *in, float *prev, int ch)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
static float mulawinv(float y, float clip, float mu)
static int very_broken_op(int a, int b)
Evaluate a*b/400 rounded to the nearest integer.
static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks, int block_size, const uint8_t line_len[2], int length_div, enum FrameType ftype)
Interpret the data as if it were a num_blocks x line_len[0] matrix and for each line do a cyclic perm...
static void rearrange_lsp(int order, float *lsp, float min_dist)
Rearrange the LSP coefficients so that they have a minimum distance of min_dist.
static void add_peak(int period, int width, const float *shape, float ppc_gain, float *speech, int len)
Sum to data a periodic peak of a given period, width and shape.
float * curr_frame
non-interleaved output
static const ModeTab mode_22_20
float bark_hist[3][2][40]
BSE coefficients of last frame.
static const ModeTab mode_44_48
int sample_rate
samples per second
main external API structure.
static void close(AVCodecParserContext *s)
static const uint16_t bark_tab_m16_512[]
static void decode_lsp(TwinContext *tctx, int lpc_idx1, uint8_t *lpc_idx2, int lpc_hist_idx, float *lsp, float *hist)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void dec_bark_env(TwinContext *tctx, const uint8_t *in, int use_hist, int ch, float *out, float gain, enum FrameType ftype)
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
uint8_t length[4][2]
main codebook stride
AVCodec ff_twinvq_decoder
static unsigned int get_bits1(GetBitContext *s)
float lsp_hist[2][20]
LSP coefficients of the last frame.
static void skip_bits(GetBitContext *s, int n)
Periodic Peak Component (part of the long frame)
static const uint16_t bark_tab_l16_1024[]
static int twin_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define PPC_SHAPE_LEN_MAX
static void memset_float(float *buf, float val, int size)
static float eval_lpc_spectrum(const float *lsp, float cos_val, int order)
Evaluate a single LPC amplitude spectrum envelope coefficient from the line spectrum pairs...
uint8_t bark_env_size
number of distinct bark scale envelope values
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void decode_ppc(TwinContext *tctx, int period_coef, const float *shape, float ppc_gain, float *speech)
uint8_t pgain_bit
bits for PPC gain
static void eval_lpcenv_or_interp(TwinContext *tctx, enum FrameType ftype, float *out, const float *in, int size, int step, int part)
Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
common internal api header.
static const uint16_t bark_tab_s16_128[]
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
void ff_sort_nearly_sorted_floats(float *vals, int len)
Sort values in ascending order.
static av_cold int twin_decode_init(AVCodecContext *avctx)
static void eval_lpcenv(TwinContext *tctx, const float *cos_vals, float *lpc)
Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
static void dec_gain(TwinContext *tctx, GetBitContext *gb, enum FrameType ftype, float *out)
void(* butterflies_float_interleave)(float *dst, const float *src0, const float *src1, int len)
Calculate the sum and difference of two vectors of floats and interleave results into a separate outp...
int channels
number of audio channels
static void transpose_perm(int16_t *out, int16_t *in, int num_vect, const uint8_t line_len[2], int length_div)
Interpret the input data as in the following table:
static const struct @46 tab
TwinVQ codebooks.
static const uint16_t bark_tab_l08_512[]
static float get_cos(int idx, int part, const float *cos_tab, int size)
uint16_t size
frame size in samples
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
static void imdct_output(TwinContext *tctx, enum FrameType ftype, int wtype, float *out)
#define FFSWAP(type, a, b)
Medium frame (divided in m
struct FrameMode fmode[3]
frame type-dependant parameters
const int16_t * bark_cb
codebook for the bark scale envelope (BSE)
int nb_samples
number of audio samples (per channel) described by this frame
static void eval_lpcenv_2parts(TwinContext *tctx, enum FrameType ftype, const float *buf, float *lpc, int size, int step)
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
uint8_t lsp_split
number of CB entries for the LSP decoding
uint8_t cb_len_read
number of spectrum coefficients to read