62 #define AMR_BLOCK_SIZE 160 63 #define AMR_SAMPLE_BOUND 32768.0
74 #define AMR_SAMPLE_SCALE (2.0 / 32768.0) 77 #define PRED_FAC_MODE_12k2 0.65 79 #define LSF_R_FAC (8000.0 / 32768.0) 80 #define MIN_LSF_SPACING (50.0488 / 8000.0)
81 #define PITCH_LAG_MIN_MODE_12k2 18
84 #define MIN_ENERGY -14.0 91 #define SHARP_MAX 0.79449462890625 94 #define AMR_TILT_RESPONSE 22 96 #define AMR_TILT_GAMMA_T 0.8 98 #define AMR_AGC_ALPHA 0.9 150 const double *in_b,
double weight_coeff_a,
151 double weight_coeff_b,
int length)
155 for (i = 0; i <
length; i++)
156 out[i] = weight_coeff_a * in_a[i]
157 + weight_coeff_b * in_b[i];
184 for (i = 0; i < 4; i++)
213 mode = buf[0] >> 3 & 0x0F;
243 for (i = 0; i < 4; i++)
245 0.25 * (3 - i), 0.25 * (i + 1),
261 const float lsf_no_r[LP_FILTER_ORDER],
262 const int16_t *lsf_quantizer[5],
263 const int quantizer_offset,
264 const int sign,
const int update)
270 for (i = 0; i < LP_FILTER_ORDER >> 1; i++)
271 memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset],
280 memcpy(p->
prev_lsf_r, lsf_r, LP_FILTER_ORDER *
sizeof(*lsf_r));
283 lsf_q[i] = lsf_r[i] * (
LSF_R_FAC / 8000.0) + lsf_no_r[
i] * (1.0 / 8000.0);
300 const uint16_t *lsf_param = p->
frame.
lsf;
302 const int16_t *lsf_quantizer[5];
305 lsf_quantizer[0] =
lsf_5_1[lsf_param[0]];
306 lsf_quantizer[1] =
lsf_5_2[lsf_param[1]];
307 lsf_quantizer[2] =
lsf_5_3[lsf_param[2] >> 1];
308 lsf_quantizer[3] =
lsf_5_4[lsf_param[3]];
309 lsf_quantizer[4] =
lsf_5_5[lsf_param[4]];
329 const uint16_t *lsf_param = p->
frame.
lsf;
332 const int16_t *lsf_quantizer;
336 memcpy(lsf_r, lsf_quantizer, 3 *
sizeof(*lsf_r));
339 memcpy(lsf_r + 3, lsf_quantizer, 3 *
sizeof(*lsf_r));
342 memcpy(lsf_r + 6, lsf_quantizer, 4 *
sizeof(*lsf_r));
352 memcpy(p->
prev_lsf_r, lsf_r, LP_FILTER_ORDER *
sizeof(*lsf_r));
357 for (i = 1; i <= 3; i++)
373 const int prev_lag_int,
const int subframe)
375 if (subframe == 0 || subframe == 2) {
376 if (pitch_index < 463) {
377 *lag_int = (pitch_index + 107) * 10923 >> 16;
378 *lag_frac = pitch_index - *lag_int * 6 + 105;
380 *lag_int = pitch_index - 368;
384 *lag_int = ((pitch_index + 5) * 10923 >> 16) - 1;
385 *lag_frac = pitch_index - *lag_int * 6 - 3;
413 pitch_lag_int += pitch_lag_frac > 0;
420 pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0),
436 int i1,
int i2,
int i3)
441 pulse_position[i1] = (positions[2] << 1) + ( code & 1);
442 pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1);
443 pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1);
456 int pulse_position[8];
464 temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5;
465 pulse_position[3] = temp % 5;
466 pulse_position[7] = temp / 5;
467 if (pulse_position[7] & 1)
468 pulse_position[3] = 4 - pulse_position[3];
469 pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6] & 1);
470 pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1);
473 for (i = 0; i < 4; i++) {
474 const int pos1 = (pulse_position[
i] << 2) + i;
475 const int pos2 = (pulse_position[i + 4] << 2) + i;
476 const float sign = fixed_index[
i] ? -1.0 : 1.0;
477 fixed_sparse->
x[
i ] = pos1;
478 fixed_sparse->
x[i + 4] = pos2;
479 fixed_sparse->
y[
i ] = sign;
480 fixed_sparse->
y[i + 4] = pos2 < pos1 ? -sign : sign;
500 const enum Mode mode,
const int subframe)
509 int *pulse_position = fixed_sparse->
x;
511 const int fixed_index = pulses[0];
514 pulse_subset = ((fixed_index >> 3) & 8) + (subframe << 1);
515 pulse_position[0] = ( fixed_index & 7) * 5 +
track_position[pulse_subset];
516 pulse_position[1] = ((fixed_index >> 3) & 7) * 5 +
track_position[pulse_subset + 1];
519 pulse_subset = ((fixed_index & 1) << 1) + 1;
520 pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset;
521 pulse_subset = (fixed_index >> 4) & 3;
522 pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0);
523 fixed_sparse->
n = pulse_position[0] == pulse_position[1] ? 1 : 2;
525 pulse_position[0] = (fixed_index & 7) * 5;
526 pulse_subset = (fixed_index >> 2) & 2;
527 pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1;
528 pulse_subset = (fixed_index >> 6) & 2;
529 pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2;
533 pulse_position[1] =
gray_decode[(fixed_index >> 3) & 7] + 1;
534 pulse_position[2] =
gray_decode[(fixed_index >> 6) & 7] + 2;
535 pulse_subset = (fixed_index >> 9) & 1;
536 pulse_position[3] =
gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3;
539 for (i = 0; i < fixed_sparse->
n; i++)
540 fixed_sparse->
y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0;
595 diff +=
fabs(lsf_avg[i] - lsf[i]) / lsf_avg[
i];
611 const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0);
616 (1.0 - smoothing_factor) * fixed_gain_mean;
631 const enum Mode mode,
const int subframe,
632 float *fixed_gain_factor)
640 const uint16_t *gains;
651 p->
pitch_gain[4] = gains[0] * (1.0 / 16384.0);
652 *fixed_gain_factor = gains[1] * (1.0 / 4096.0);
685 if (lag < AMR_SUBFRAME_SIZE >> 1)
691 for (i = 0; i < in->
n; i++) {
694 const float *filterp;
696 if (x >= AMR_SUBFRAME_SIZE - lag) {
698 }
else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) {
741 for (i = 0; i < 5; i++)
749 }
else if (ir_filter_nr < 2)
755 if (fixed_gain < 5.0)
759 && ir_filter_nr < 2) {
804 p->
pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE);
883 memcpy(hf + 1, lpc_n,
sizeof(
float) * LP_FILTER_ORDER);
913 const float *gamma_n, *gamma_d;
925 lpc_n[
i] = lpc[
i] * gamma_n[
i];
926 lpc_d[
i] = lpc[
i] * gamma_d[
i];
929 memcpy(pole_out, p->
postfilter_mem,
sizeof(
float) * LP_FILTER_ORDER);
933 sizeof(
float) * LP_FILTER_ORDER);
936 pole_out + LP_FILTER_ORDER,
949 int *got_frame_ptr,
AVPacket *avpkt)
955 int buf_size = avpkt->
size;
957 int i, subframe,
ret;
958 float fixed_gain_factor;
961 float synth_fixed_gain;
962 const float *synth_fixed_vector;
968 buf_out = (
float *)frame->
data[0];
986 for (i = 0; i < 4; i++)
989 for (subframe = 0; subframe < 4; subframe++) {
1002 &fixed_gain_factor);
1007 av_log(avctx,
AV_LOG_ERROR,
"The file is corrupted, pitch_lag = 0 is not allowed\n");
1044 synth_fixed_gain, spare_vector);
1054 postfilter(p, p->
lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE);
#define AMR_SAMPLE_SCALE
Scale from constructed speech to [-1,1].
void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe, int third_as_first, int resolution)
Decode the adaptive codebook index to the integer and fractional parts of the pitch lag for one subfr...
#define AMR_BLOCK_SIZE
samples per frame
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
float lsf_avg[LP_FILTER_ORDER]
vector of averaged lsf vector
ptrdiff_t const GLvoid * data
void ff_decode_10_pulses_35bits(const int16_t *fixed_index, AMRFixed *fixed_sparse, const uint8_t *gray_decode, int half_pulse_count, int bits)
Decode the algebraic codebook index to pulse positions and signs and construct the algebraic codebook...
static int amrnb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode, AMRFixed *fixed_sparse)
Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
static av_cold int init(AVCodecContext *avctx)
AMRNB unpacked data frame.
void(* acelp_interpolatef)(float *out, const float *in, const float *filter_coeffs, int precision, int frac_pos, int filter_length, int length)
Floating point version of ff_acelp_interpolate()
float(* dot_productf)(const float *a, const float *b, int length)
Return the dot product.
void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size)
Clear array values set by set_fixed_vector.
static const uint8_t base_five_table[128][3]
Base-5 representation for values 0-124.
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
static const int16_t lsf_3_1[256][3]
static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses, const enum Mode mode, const int subframe)
Decode the algebraic codebook index to pulse positions and signs, then construct the algebraic codebo...
static const uint8_t track_position[16]
track start positions for algebraic code book routines
uint8_t bad_frame_indicator
bad frame ? 1 : 0
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
Add fixed vector to an array from a sparse representation.
static float fixed_gain_smooth(AMRContext *p, const float *lsf, const float *lsf_avg, const enum Mode mode)
fixed gain smoothing Note that where the spec specifies the "spectrum in the q domain" in section 6...
static const int16_t lsf_3_2[512][3]
static int synthesis(AMRContext *p, float *lpc, float fixed_gain, const float *fixed_vector, float *samples, uint8_t overflow)
Conduct 10th order linear predictive coding synthesis.
static void weighted_vector_sumd(double *out, const double *in_a, const double *in_b, double weight_coeff_a, double weight_coeff_b, int length)
Double version of ff_weighted_vector_sumf()
Undefined Behavior In the C some operations are like signed integer overflow
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static av_cold int amrnb_decode_init(AVCodecContext *avctx)
double prev_lsp_sub4[LP_FILTER_ORDER]
lsp vector for the 4th subframe of the previous frame
static void postfilter(AMRContext *p, float *lpc, float *buf_out)
Perform adaptive post-filtering to enhance the quality of the speech.
void(* celp_lp_zero_synthesis_filterf)(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP zero synthesis filter.
static const int16_t lsf_5_1[128][4]
float postfilter_agc
previous factor used for adaptive gain control
enum AVSampleFormat sample_fmt
audio sample format
Sparse representation for the algebraic codebook (fixed) vector.
static const uint16_t qua_gain_code[32]
scalar quantized fixed gain table for 7.95 and 12.2 kbps modes
Mode
Frame type (Table 1a in 3GPP TS 26.101)
static const uint16_t qua_gain_pit[16]
scalar quantized pitch gain table for 7.95 and 12.2 kbps modes
static void lsf2lsp_3(AMRContext *p)
Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
static const float energy_pred_fac[4]
4-tap moving average prediction coefficients in reverse order
uint16_t fixed_gain
index to decode the fixed gain factor, for MODE_12k2 and MODE_7k95
static const int8_t lsp_sub4_init[LP_FILTER_ORDER]
Values for the lsp vector from the 4th subframe of the previous subframe values.
double lsp[4][LP_FILTER_ORDER]
lsp vectors from current frame
static void apply_ir_filter(float *out, const AMRFixed *in, const float *filter)
Circularly convolve a sparse fixed vector with a phase dispersion impulse response filter (D...
AMRNBFrame frame
decoded AMR parameters (lsf coefficients, codebook indexes, etc)
void ff_adaptive_gain_control(float *out, const float *in, float speech_energ, int size, float alpha, float *gain_mem)
Adaptive gain control (as used in AMR postfiltering)
static void filter1(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
static void ff_amr_bit_reorder(uint16_t *out, int size, const uint8_t *data, const R_TABLE_TYPE *ord_table)
Fill the frame structure variables from bitstream by parsing the given reordering table that uses the...
static __device__ float fabsf(float a)
uint16_t lsf[5]
lsf parameters: 5 parameters for MODE_12k2, only 3 for other modes
void(* weighted_vector_sumf)(float *out, const float *in_a, const float *in_b, float weight_coeff_a, float weight_coeff_b, int length)
float implementation of weighted sum of two vectors.
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void decode_pitch_vector(AMRContext *p, const AMRNBSubframe *amr_subframe, const int subframe)
static void update_state(AMRContext *p)
Update buffers and history at the end of decoding a subframe.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
static const uint16_t positions[][14][3]
static __device__ float fabs(float a)
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
float fixed_vector[AMR_SUBFRAME_SIZE]
algebraic codebook (fixed) vector (must be kept zero between frames)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
AMRNBSubframe subframe[4]
unpacked data for each subframe
void(* celp_lp_synthesis_filterf)(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
const float ff_pow_0_7[10]
Table of pow(0.7,n)
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
int16_t prev_lsf_r[LP_FILTER_ORDER]
residual LSF vector from previous subframe
static const uint8_t frame_sizes_nb[N_MODES]
number of bytes for each mode
void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in, float sum_of_squares, const int n)
Set the sum of squares of a signal by scaling.
const float ff_pow_0_75[10]
Table of pow(0.75,n)
float pitch_gain[5]
quantified pitch gains for the current and previous four subframes
#define LP_FILTER_ORDER
linear predictive coding filter order
static const int16_t lsf_3_3_MODE_5k15[128][4]
float * excitation
pointer to the current excitation vector in excitation_buf
uint64_t channel_layout
Audio channel layout.
#define AMR_SAMPLE_BOUND
threshold for synthesis overflow
uint8_t ir_filter_onset
flag for impulse response filter strength
static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
Interpolate the LSF vector (used for fixed gain smoothing).
#define AMR_SUBFRAME_SIZE
samples per subframe
static const float *const ir_filters_lookup_MODE_7k95[2]
AMRNB unpacked data subframe.
audio channel layout utility functions
#define MIN_ENERGY
Initial energy in dB.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static const float highpass_poles[2]
float samples_in[LP_FILTER_ORDER+AMR_SUBFRAME_SIZE]
floating point samples
static const int16_t lsf_3_1_MODE_7k95[512][3]
static const int16_t lsf_5_5[64][4]
uint16_t p_lag
index to decode the pitch lag
static const float highpass_zeros[2]
static const uint16_t gains_MODE_4k75[512][2]
gain table for 4.75 kbps mode
float pitch_vector[AMR_SUBFRAME_SIZE]
adaptive code book (pitch) vector
void(* acelp_apply_order_2_transfer_function)(float *out, const float *in, const float zero_coeffs[2], const float pole_coeffs[2], float gain, float mem[2], int n)
Apply an order 2 rational transfer function in-place.
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
#define MIN_LSF_SPACING
Ensures stability of LPC filter.
static const float lsf_3_mean[LP_FILTER_ORDER]
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const float * anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse, const float *fixed_vector, float fixed_gain, float *out)
Reduce fixed vector sparseness by smoothing with one of three IR filters.
uint8_t pitch_lag_int
integer part of pitch lag from current subframe
#define AV_LOG_INFO
Standard information.
float tilt_mem
previous input to tilt compensation filter
float lsf_q[4][LP_FILTER_ORDER]
Interpolated LSF vector for fixed gain smoothing.
Libavcodec external API header.
#define PRED_FAC_MODE_12k2
Prediction factor for 12.2kbit/s mode.
AVSampleFormat
Audio sample formats.
void ff_celp_circ_addf(float *out, const float *in, const float *lagged, int lag, float fac, int n)
Add an array to a rotated array.
int sample_rate
samples per second
float high_pass_mem[2]
previous intermediate values in the high-pass filter
main external API structure.
static const float lsf_5_mean[LP_FILTER_ORDER]
uint16_t p_gain
index to decode the pitch gain
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
void ff_celp_math_init(CELPMContext *c)
Initialize CELPMContext.
uint8_t diff_count
the number of subframes for which diff has been above 0.65
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
static const uint8_t *const amr_unpacking_bitmaps_per_mode[N_MODES]
position of the bitmapping data for each packet type in the AMRNBFrame
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
void ff_celp_filter_init(CELPFContext *c)
Initialize CELPFContext.
static const float highpass_gain
static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d)
Get the tilt factor of a formant filter from its transfer function.
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
float fixed_gain[5]
quantified fixed gains for the current and previous four subframes
float lpc[4][LP_FILTER_ORDER]
lpc coefficient vectors for 4 subframes
float beta
previous pitch_gain, bounded by [0.0,SHARP_MAX]
#define SHARP_MAX
Maximum sharpening factor.
#define AMR_TILT_RESPONSE
Number of impulse response coefficients used for tilt factor.
static const float *const ir_filters_lookup[2]
CELPFContext celpf_ctx
context for filters for CELP-based codecs
void ff_acelp_vectors_init(ACELPVContext *c)
Initialize ACELPVContext.
static void decode_8_pulses_31bits(const int16_t *fixed_index, AMRFixed *fixed_sparse)
Decode the algebraic codebook index to pulse positions and signs and construct the algebraic codebook...
static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe)
Like ff_decode_pitch_lag(), but with 1/6 resolution.
static const int16_t lsf_5_4[256][4]
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static void decode_10bit_pulse(int code, int pulse_position[8], int i1, int i2, int i3)
Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static const int16_t lsf_3_3[512][4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static const int16_t lsf_5_2[256][4]
static const uint8_t gray_decode[8]
3-bit Gray code to binary lookup table
static __device__ float truncf(float a)
static const float pred_fac[LP_FILTER_ORDER]
Prediction factor table for modes other than 12.2kbit/s.
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness processing to determine "onset"
float postfilter_mem[10]
previous intermediate values in the formant filter
#define AMR_AGC_ALPHA
Adaptive gain control factor used in post-filter.
common internal api header.
common internal and external API header
static void lsf2lsp_5(AMRContext *p)
Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER], const float lsf_no_r[LP_FILTER_ORDER], const int16_t *lsf_quantizer[5], const int quantizer_offset, const int sign, const int update)
Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
static const uint16_t gains_low[64][2]
gain table for 5.15 and 5.90 kbps modes
static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe, const enum Mode mode, const int subframe, float *fixed_gain_factor)
Decode pitch gain and fixed gain factor (part of section 6.1.3).
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
void ff_acelp_filter_init(ACELPFContext *c)
Initialize ACELPFContext.
#define LSF_R_FAC
LSF residual tables to Hertz.
const float ff_b60_sinc[61]
b60 hamming windowed sinc function coefficients
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const uint16_t gains_high[128][2]
gain table for 6.70, 7.40 and 10.2 kbps modes
uint8_t hang_count
the number of subframes since a hangover period started
int channels
number of audio channels
AMR narrowband data and definitions.
static const float energy_mean[8]
desired mean innovation energy, indexed by active mode
static enum AVSampleFormat sample_fmts[]
#define PITCH_LAG_MIN_MODE_12k2
Lower bound on decoded lag search in 12.2kbit/s mode.
CELPMContext celpm_ctx
context for fixed point math operations
Filter the word “frame” indicates either a video frame or a group of audio samples
uint16_t pulses[10]
pulses: 10 for MODE_12k2, 7 for MODE_10k2, and index and sign for others
float excitation_buf[PITCH_DELAY_MAX+LP_FILTER_ORDER+1+AMR_SUBFRAME_SIZE]
current excitation and all necessary excitation history
static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf, int buf_size)
Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
const float ff_pow_0_55[10]
Table of pow(0.55,n)
ACELPFContext acelpf_ctx
context for filters for ACELP-based codecs
static const int16_t lsf_5_3[256][4]
#define AMR_TILT_GAMMA_T
Tilt factor = 1st reflection coefficient * gamma_t.
mode
Use these values in ebur128_init (or'ed).
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)
Calculate fixed gain (part of section 6.1.3 of AMR spec)
ACELPVContext acelpv_ctx
context for vector operations for ACELP-based codecs
static const int16_t lsp_avg_init[LP_FILTER_ORDER]
Mean lsp values.