51 float two_cos_w = 2.0f * cos_val;
53 for (j = 0; j + 1 < order; j += 2 * 2) {
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);
77 for (
i = 0;
i < size_s / 2;
i++) {
87 float step = (v1 - v2) / (
size + 1);
117 float *
out,
const float *
in,
118 int size,
int step,
int part)
125 for (
i = 0;
i <
size;
i += step)
132 for (
i = step;
i <=
size - 2 * step;
i += step) {
142 out[
i - step], step / 2 - 1);
144 out[
i - step / 2], step / 2 - 1);
149 out[
size - 2 * step], step - 1);
153 const float *buf,
float *lpc,
161 lpc[
size / 2 - step], step);
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;
203 tab0 = cb0 + tmp0 * cb_len;
204 tab1 = cb1 + tmp1 * cb_len;
206 for (j = 0; j < length; j++)
226 out[
i] = (1.0 / (1 << 13)) *
231 float val = (1.0 / (1 << 23)) *
235 for (j = 0; j <
sub; j++)
238 sub_step *
bits->sub_gain_bits[
i *
sub + j],
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;
264 int lpc_hist_idx,
float *lsp,
float *hist)
271 const float *cb3 = cb2 + (1 << mtab->
lsp_bit2) * mtab->
n_lsp;
273 const int8_t funny_rounding[4] = {
285 lsp[j] =
cb[lpc_idx1 * mtab->
n_lsp + j] +
286 cb2[lpc_idx2[
i] * mtab->
n_lsp + j];
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;
310 lsp[
i] = 2 * cos(lsp[
i]);
328 int wtype,
float *
in,
float *prev,
int ch)
335 int j, first_wsize, wsize;
339 int types_sizes[] = {
347 prev_buf = prev + (
size - bsize) / 2;
349 for (j = 0; j < mtab->
fmode[ftype].
sub; j++) {
352 if (!j && wtype == 4)
354 else if (j == mtab->
fmode[ftype].
sub - 1 && wtype == 7)
359 mdct->
imdct_half(mdct, buf1 + bsize * j,
in + bsize * j);
367 memcpy(out2, buf1 + bsize * j + wsize / 2,
368 (bsize - wsize / 2) *
sizeof(
float));
372 prev_buf = buf1 + bsize * j + bsize / 2;
389 prev_buf + 2 *
i * mtab->
size,
396 size1 = mtab->
size - size2;
399 memcpy(out1, prev_buf, size1 *
sizeof(*out1));
400 memcpy(out1 + size1, tctx->
curr_frame, size2 *
sizeof(*out1));
404 memcpy(out2, &prev_buf[2 * mtab->
size],
405 size1 *
sizeof(*out2));
407 size2 *
sizeof(*out2));
419 int block_size = mtab->
size /
sub;
441 float *chunk =
out + mtab->
size *
i;
444 for (j = 0; j <
sub; j++) {
446 bits->bark_use_hist[
i][j],
i,
450 chunk + block_size * j,
463 for (j = 0; j < mtab->
fmode[ftype].
sub; j++) {
477 int *got_frame_ptr,
AVPacket *avpkt)
481 int buf_size = avpkt->
size;
495 if (buf_size < avctx->block_align) {
497 "Frame too small (%d bytes). Truncated file?\n", buf_size);
540 float norm =
channels == 1 ? 2.0 : 1.0;
543 for (
i = 0;
i < 3;
i++) {
546 -sqrt(norm / bsize) / (1 << 15))))
556 for (
i = 0;
i < 3;
i++) {
558 double freq = 2 *
M_PI / m;
561 for (j = 0; j <= m / 8; j++)
562 tctx->
cos_tabs[
i][j] = cos((2 * j + 1) * freq);
563 for (j = 1; j < m / 8; j++)
582 const uint8_t line_len[2],
int length_div,
587 for (
i = 0;
i < line_len[0];
i++) {
590 if (num_blocks == 1 ||
600 for (j = 0; j < num_vect && (j + num_vect *
i < block_size * num_blocks); j++)
601 tab[
i * num_vect + j] =
i * num_vect + (j +
shift) % num_vect;
621 const uint8_t line_len[2],
int length_div)
626 for (
i = 0;
i < num_vect;
i++)
627 for (j = 0; j < line_len[i >= length_div]; j++)
628 out[cont++] =
in[j * num_vect +
i];
633 int block_size =
size / n_blocks;
637 out[
i] = block_size * (
in[
i] % n_blocks) +
in[
i] / n_blocks;
643 int block_size,
size;
645 int16_t *tmp_perm = (int16_t *)tctx->
tmp_buf;
656 block_size, tctx->
length[ftype],
679 int bsize_no_main_cb[3], bse_bits[3],
i;
682 for (
i = 0;
i < 3;
i++)
688 bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits +
691 for (
i = 0;
i < 2;
i++)
692 bsize_no_main_cb[
i] =
698 bsize_no_main_cb[1] += 2;
699 bsize_no_main_cb[2] += 2;
703 for (
i = 0;
i < 4;
i++) {
704 int bit_size, vect_size;
705 int rounded_up, rounded_down, num_rounded_down, num_rounded_up;
710 bit_size = total_fr_bits - bsize_no_main_cb[
i];
711 vect_size = n_ch * mtab->
size;
714 tctx->
n_div[
i] = (bit_size + 13) / 14;
716 rounded_up = (bit_size + tctx->
n_div[
i] - 1) /
718 rounded_down = (bit_size) / tctx->
n_div[
i];
719 num_rounded_down = rounded_up * tctx->
n_div[
i] - bit_size;
720 num_rounded_up = tctx->
n_div[
i] - num_rounded_down;
727 rounded_up = (vect_size + tctx->
n_div[
i] - 1) /
729 rounded_down = (vect_size) / tctx->
n_div[
i];
730 num_rounded_down = rounded_up * tctx->
n_div[
i] - vect_size;
731 num_rounded_up = tctx->
n_div[
i] - num_rounded_down;
732 tctx->
length[
i][0] = rounded_up;
733 tctx->
length[
i][1] = rounded_down;
746 for (
i = 0;
i < 3;
i++) {
773 if (frames_per_packet <= 0) {
static double val(void *priv, double ch)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Libavcodec external API header.
audio channel layout utility functions
#define FFSWAP(type, a, b)
static float cos_tab[256]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static float sub(float src0, float src1)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
@ AV_SAMPLE_FMT_FLTP
float, planar
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
common internal API header
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
void ff_sort_nearly_sorted_floats(float *vals, int len)
Sort values in ascending order.
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
SINETABLE_CONST float *const ff_sine_windows[]
#define FF_ARRAY_ELEMS(a)
static int shift(int a, int b)
main external API structure.
enum AVSampleFormat sample_fmt
audio sample format
int64_t bit_rate
the average bitrate
int sample_rate
samples per second
int flags
AV_CODEC_FLAG_*.
int channels
number of audio channels
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
float bark_hist[3][2][40]
BSE coefficients of last frame.
uint8_t length[4][2]
main codebook stride
const TwinVQModeTab * mtab
int(* read_bitstream)(AVCodecContext *avctx, struct TwinVQContext *tctx, const uint8_t *buf, int buf_size)
void(* dec_bark_env)(struct TwinVQContext *tctx, const uint8_t *in, int use_hist, int ch, float *out, float gain, enum TwinVQFrameType ftype)
TwinVQFrameData bits[TWINVQ_MAX_FRAMES_PER_PACKET]
float lsp_hist[2][20]
LSP coefficients of the last frame.
float * prev_frame
non-interleaved previous frame
void(* decode_ppc)(struct TwinVQContext *tctx, int period_coef, int g_coef, const float *shape, float *speech)
float * curr_frame
non-interleaved output
uint8_t bits_main_spec[2][4][2]
bits for the main codebook
int bits_main_spec_change[4]
enum TwinVQFrameType ftype
uint8_t bark_n_bit
number of bits of the BSE coefs
uint8_t bark_n_coef
number of BSE CB coefficients to read
uint8_t sub
Number subblocks in each frame.
uint8_t cb_len_read
number of spectrum coefficients to read
const int16_t * cb0
main codebooks for spectrum data
Parameters and tables that are different for every combination of bitrate/sample rate.
uint8_t ppc_shape_bit
number of bits of the PPC shape CB coeffs
uint8_t ppc_shape_len
size of PPC shape CB
uint8_t lsp_split
number of CB entries for the LSP decoding
uint8_t n_lsp
number of lsp coefficients
struct TwinVQFrameMode fmode[3]
frame type-dependent parameters
const float * lspcodebook
uint8_t ppc_period_bit
number of the bits for the PPC period value
const int16_t * ppc_shape_cb
PPC shape CB.
uint16_t size
frame size in samples
uint8_t pgain_bit
bits for PPC gain
static av_cold void construct_perm_table(TwinVQContext *tctx, enum TwinVQFrameType ftype)
static av_cold int init_mdct_win(TwinVQContext *tctx)
Init IMDCT and windowing tables.
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:
enum TwinVQFrameType ff_twinvq_wtype_to_ftype_table[]
static void eval_lpcenv(TwinVQContext *tctx, const float *cos_vals, float *lpc)
Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
static void dec_lpc_spectrum_inv(TwinVQContext *tctx, float *lsp, enum TwinVQFrameType ftype, float *lpc)
static void imdct_and_window(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float *in, float *prev, int ch)
static void eval_lpcenv_or_interp(TwinVQContext *tctx, enum TwinVQFrameType ftype, float *out, const float *in, int size, int step, int part)
Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
int ff_twinvq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static void dequant(TwinVQContext *tctx, const uint8_t *cb_bits, float *out, enum TwinVQFrameType ftype, const int16_t *cb0, const int16_t *cb1, int cb_len)
Inverse quantization.
static void dec_gain(TwinVQContext *tctx, enum TwinVQFrameType ftype, float *out)
static void decode_lsp(TwinVQContext *tctx, int lpc_idx1, uint8_t *lpc_idx2, int lpc_hist_idx, float *lsp, float *hist)
static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
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 TwinVQFrameType 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 av_cold void init_bitstream_params(TwinVQContext *tctx)
static float get_cos(int idx, int part, const float *cos_tab, int size)
static const uint8_t wtype_to_wsize[]
av_cold int ff_twinvq_decode_close(AVCodecContext *avctx)
static void imdct_output(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float **out, int offset)
static void interpolate(float *out, float v1, float v2, 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.
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.
av_cold int ff_twinvq_decode_init(AVCodecContext *avctx)
static void read_and_decode_spectrum(TwinVQContext *tctx, float *out, enum TwinVQFrameType ftype)
static void eval_lpcenv_2parts(TwinVQContext *tctx, enum TwinVQFrameType ftype, const float *buf, float *lpc, int size, int step)
#define TWINVQ_PPC_SHAPE_LEN_MAX
#define TWINVQ_CHANNELS_MAX
#define TWINVQ_MAX_FRAMES_PER_PACKET
#define TWINVQ_SUB_GAIN_BITS
#define TWINVQ_WINDOW_TYPE_BITS
#define TWINVQ_PPC_SHAPE_CB_SIZE
#define TWINVQ_LSP_COEFS_MAX
@ TWINVQ_FT_MEDIUM
Medium frame (divided in m<n sub-blocks)
@ TWINVQ_FT_LONG
Long frame (single sub-block + PPC)
@ TWINVQ_FT_SHORT
Short frame (divided in n sub-blocks)
@ TWINVQ_FT_PPC
Periodic Peak Component (part of the long frame)
#define TWINVQ_SUBBLOCKS_MAX
#define TWINVQ_SUB_AMP_MAX
static float twinvq_mulawinv(float y, float clip, float mu)
static void twinvq_memset_float(float *buf, float val, int size)
static const struct twinvq_data tab
static double cb(void *priv, double x, double y)
static const uint8_t offset[127][2]
static int chunk_end(AVFormatContext *s, int flush)