Mercurial > libavcodec.hg
annotate sipr.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | fdafbcef52f5 |
children | 1921e24d5886 |
rev | line source |
---|---|
10836 | 1 /* |
2 * SIPR / ACELP.NET decoder | |
3 * | |
4 * Copyright (c) 2008 Vladimir Voroshilov | |
5 * Copyright (c) 2009 Vitor Sessak | |
6 * | |
7 * This file is part of FFmpeg. | |
8 * | |
9 * FFmpeg is free software; you can redistribute it and/or | |
10 * modify it under the terms of the GNU Lesser General Public | |
11 * License as published by the Free Software Foundation; either | |
12 * version 2.1 of the License, or (at your option) any later version. | |
13 * | |
14 * FFmpeg is distributed in the hope that it will be useful, | |
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 * Lesser General Public License for more details. | |
18 * | |
19 * You should have received a copy of the GNU Lesser General Public | |
20 * License along with FFmpeg; if not, write to the Free Software | |
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
22 */ | |
23 | |
24 #include <math.h> | |
25 #include <stdint.h> | |
26 | |
10873 | 27 #include "libavutil/mathematics.h" |
10836 | 28 #include "avcodec.h" |
29 #define ALT_BITSTREAM_READER_LE | |
30 #include "get_bits.h" | |
31 #include "dsputil.h" | |
32 | |
33 #include "lsp.h" | |
34 #include "celp_math.h" | |
35 #include "acelp_vectors.h" | |
36 #include "acelp_pitch_delay.h" | |
37 #include "acelp_filters.h" | |
38 #include "celp_filters.h" | |
39 | |
10871 | 40 #define MAX_SUBFRAME_COUNT 5 |
41 | |
10889
de32bff741ea
Split some SIPR structs to a header file for the upcoming SIPR16k commit
vitor
parents:
10873
diff
changeset
|
42 #include "sipr.h" |
10836 | 43 #include "siprdata.h" |
44 | |
45 typedef struct { | |
46 const char *mode_name; | |
47 uint16_t bits_per_frame; | |
48 uint8_t subframe_count; | |
49 uint8_t frames_per_packet; | |
50 float pitch_sharp_factor; | |
51 | |
52 /* bitstream parameters */ | |
53 uint8_t number_of_fc_indexes; | |
10891 | 54 uint8_t ma_predictor_bits; ///< size in bits of the switched MA predictor |
10836 | 55 |
56 /** size in bits of the i-th stage vector of quantizer */ | |
57 uint8_t vq_indexes_bits[5]; | |
58 | |
59 /** size in bits of the adaptive-codebook index for every subframe */ | |
60 uint8_t pitch_delay_bits[5]; | |
61 | |
62 uint8_t gp_index_bits; | |
63 uint8_t fc_index_bits[10]; ///< size in bits of the fixed codebook indexes | |
64 uint8_t gc_index_bits; ///< size in bits of the gain codebook indexes | |
65 } SiprModeParam; | |
66 | |
67 static const SiprModeParam modes[MODE_COUNT] = { | |
10891 | 68 [MODE_16k] = { |
69 .mode_name = "16k", | |
70 .bits_per_frame = 160, | |
71 .subframe_count = SUBFRAME_COUNT_16k, | |
72 .frames_per_packet = 1, | |
73 .pitch_sharp_factor = 0.00, | |
74 | |
75 .number_of_fc_indexes = 10, | |
76 .ma_predictor_bits = 1, | |
77 .vq_indexes_bits = {7, 8, 7, 7, 7}, | |
78 .pitch_delay_bits = {9, 6}, | |
79 .gp_index_bits = 4, | |
80 .fc_index_bits = {4, 5, 4, 5, 4, 5, 4, 5, 4, 5}, | |
81 .gc_index_bits = 5 | |
82 }, | |
83 | |
10836 | 84 [MODE_8k5] = { |
85 .mode_name = "8k5", | |
86 .bits_per_frame = 152, | |
87 .subframe_count = 3, | |
88 .frames_per_packet = 1, | |
89 .pitch_sharp_factor = 0.8, | |
90 | |
91 .number_of_fc_indexes = 3, | |
10891 | 92 .ma_predictor_bits = 0, |
10836 | 93 .vq_indexes_bits = {6, 7, 7, 7, 5}, |
94 .pitch_delay_bits = {8, 5, 5}, | |
95 .gp_index_bits = 0, | |
96 .fc_index_bits = {9, 9, 9}, | |
97 .gc_index_bits = 7 | |
98 }, | |
99 | |
100 [MODE_6k5] = { | |
101 .mode_name = "6k5", | |
102 .bits_per_frame = 232, | |
103 .subframe_count = 3, | |
104 .frames_per_packet = 2, | |
105 .pitch_sharp_factor = 0.8, | |
106 | |
107 .number_of_fc_indexes = 3, | |
10891 | 108 .ma_predictor_bits = 0, |
10836 | 109 .vq_indexes_bits = {6, 7, 7, 7, 5}, |
110 .pitch_delay_bits = {8, 5, 5}, | |
111 .gp_index_bits = 0, | |
112 .fc_index_bits = {5, 5, 5}, | |
113 .gc_index_bits = 7 | |
114 }, | |
115 | |
116 [MODE_5k0] = { | |
117 .mode_name = "5k0", | |
118 .bits_per_frame = 296, | |
119 .subframe_count = 5, | |
120 .frames_per_packet = 2, | |
121 .pitch_sharp_factor = 0.85, | |
122 | |
123 .number_of_fc_indexes = 1, | |
10891 | 124 .ma_predictor_bits = 0, |
10836 | 125 .vq_indexes_bits = {6, 7, 7, 7, 5}, |
126 .pitch_delay_bits = {8, 5, 8, 5, 5}, | |
127 .gp_index_bits = 0, | |
128 .fc_index_bits = {10}, | |
129 .gc_index_bits = 7 | |
130 } | |
131 }; | |
132 | |
10890
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
133 const float ff_pow_0_5[] = { |
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
134 1.0/(1 << 1), 1.0/(1 << 2), 1.0/(1 << 3), 1.0/(1 << 4), |
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
135 1.0/(1 << 5), 1.0/(1 << 6), 1.0/(1 << 7), 1.0/(1 << 8), |
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
136 1.0/(1 << 9), 1.0/(1 << 10), 1.0/(1 << 11), 1.0/(1 << 12), |
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
137 1.0/(1 << 13), 1.0/(1 << 14), 1.0/(1 << 15), 1.0/(1 << 16) |
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
138 }; |
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
139 |
10836 | 140 static void dequant(float *out, const int *idx, const float *cbs[]) |
141 { | |
142 int i; | |
143 int stride = 2; | |
144 int num_vec = 5; | |
145 | |
146 for (i = 0; i < num_vec; i++) | |
147 memcpy(out + stride*i, cbs[i] + stride*idx[i], stride*sizeof(float)); | |
148 | |
149 } | |
150 | |
151 static void lsf_decode_fp(float *lsfnew, float *lsf_history, | |
152 const SiprParameters *parm) | |
153 { | |
154 int i; | |
155 float lsf_tmp[LP_FILTER_ORDER]; | |
156 | |
157 dequant(lsf_tmp, parm->vq_indexes, lsf_codebooks); | |
158 | |
159 for (i = 0; i < LP_FILTER_ORDER; i++) | |
160 lsfnew[i] = lsf_history[i] * 0.33 + lsf_tmp[i] + mean_lsf[i]; | |
161 | |
162 ff_sort_nearly_sorted_floats(lsfnew, LP_FILTER_ORDER - 1); | |
163 | |
164 /* Note that a minimum distance is not enforced between the last value and | |
165 the previous one, contrary to what is done in ff_acelp_reorder_lsf() */ | |
166 ff_set_min_dist_lsf(lsfnew, LSFQ_DIFF_MIN, LP_FILTER_ORDER - 1); | |
167 lsfnew[9] = FFMIN(lsfnew[LP_FILTER_ORDER - 1], 1.3 * M_PI); | |
168 | |
169 memcpy(lsf_history, lsf_tmp, LP_FILTER_ORDER * sizeof(*lsf_history)); | |
170 | |
171 for (i = 0; i < LP_FILTER_ORDER - 1; i++) | |
172 lsfnew[i] = cos(lsfnew[i]); | |
173 lsfnew[LP_FILTER_ORDER - 1] *= 6.153848 / M_PI; | |
174 } | |
175 | |
176 /** Apply pitch lag to the fixed vector (AMR section 6.1.2). */ | |
177 static void pitch_sharpening(int pitch_lag_int, float beta, | |
178 float *fixed_vector) | |
179 { | |
180 int i; | |
181 | |
182 for (i = pitch_lag_int; i < SUBFR_SIZE; i++) | |
183 fixed_vector[i] += beta * fixed_vector[i - pitch_lag_int]; | |
184 } | |
185 | |
186 /** | |
12024 | 187 * Extract decoding parameters from the input bitstream. |
10836 | 188 * @param parms parameters structure |
189 * @param pgb pointer to initialized GetBitContext structure | |
190 */ | |
191 static void decode_parameters(SiprParameters* parms, GetBitContext *pgb, | |
192 const SiprModeParam *p) | |
193 { | |
194 int i, j; | |
195 | |
10891 | 196 parms->ma_pred_switch = get_bits(pgb, p->ma_predictor_bits); |
197 | |
10836 | 198 for (i = 0; i < 5; i++) |
199 parms->vq_indexes[i] = get_bits(pgb, p->vq_indexes_bits[i]); | |
200 | |
201 for (i = 0; i < p->subframe_count; i++) { | |
202 parms->pitch_delay[i] = get_bits(pgb, p->pitch_delay_bits[i]); | |
203 parms->gp_index[i] = get_bits(pgb, p->gp_index_bits); | |
204 | |
205 for (j = 0; j < p->number_of_fc_indexes; j++) | |
206 parms->fc_indexes[i][j] = get_bits(pgb, p->fc_index_bits[j]); | |
207 | |
208 parms->gc_index[i] = get_bits(pgb, p->gc_index_bits); | |
209 } | |
210 } | |
211 | |
212 static void lsp2lpc_sipr(const double *lsp, float *Az) | |
213 { | |
214 int lp_half_order = LP_FILTER_ORDER >> 1; | |
10871 | 215 double buf[(LP_FILTER_ORDER >> 1) + 1]; |
216 double pa[(LP_FILTER_ORDER >> 1) + 1]; | |
10836 | 217 double *qa = buf + 1; |
218 int i,j; | |
219 | |
220 qa[-1] = 0.0; | |
221 | |
222 ff_lsp2polyf(lsp , pa, lp_half_order ); | |
223 ff_lsp2polyf(lsp + 1, qa, lp_half_order - 1); | |
224 | |
225 for (i = 1, j = LP_FILTER_ORDER - 1; i < lp_half_order; i++, j--) { | |
226 double paf = pa[i] * (1 + lsp[LP_FILTER_ORDER - 1]); | |
227 double qaf = (qa[i] - qa[i-2]) * (1 - lsp[LP_FILTER_ORDER - 1]); | |
228 Az[i-1] = (paf + qaf) * 0.5; | |
229 Az[j-1] = (paf - qaf) * 0.5; | |
230 } | |
231 | |
232 Az[lp_half_order - 1] = (1.0 + lsp[LP_FILTER_ORDER - 1]) * | |
233 pa[lp_half_order] * 0.5; | |
234 | |
235 Az[LP_FILTER_ORDER - 1] = lsp[LP_FILTER_ORDER - 1]; | |
236 } | |
237 | |
238 static void sipr_decode_lp(float *lsfnew, const float *lsfold, float *Az, | |
239 int num_subfr) | |
240 { | |
241 double lsfint[LP_FILTER_ORDER]; | |
242 int i,j; | |
243 float t, t0 = 1.0 / num_subfr; | |
244 | |
245 t = t0 * 0.5; | |
246 for (i = 0; i < num_subfr; i++) { | |
247 for (j = 0; j < LP_FILTER_ORDER; j++) | |
248 lsfint[j] = lsfold[j] * (1 - t) + t * lsfnew[j]; | |
249 | |
250 lsp2lpc_sipr(lsfint, Az); | |
251 Az += LP_FILTER_ORDER; | |
252 t += t0; | |
253 } | |
254 } | |
255 | |
256 /** | |
12024 | 257 * Evaluate the adaptive impulse response. |
10836 | 258 */ |
259 static void eval_ir(const float *Az, int pitch_lag, float *freq, | |
260 float pitch_sharp_factor) | |
261 { | |
262 float tmp1[SUBFR_SIZE+1], tmp2[LP_FILTER_ORDER+1]; | |
263 int i; | |
264 | |
265 tmp1[0] = 1.; | |
266 for (i = 0; i < LP_FILTER_ORDER; i++) { | |
267 tmp1[i+1] = Az[i] * ff_pow_0_55[i]; | |
268 tmp2[i ] = Az[i] * ff_pow_0_7 [i]; | |
269 } | |
270 memset(tmp1 + 11, 0, 37 * sizeof(float)); | |
271 | |
272 ff_celp_lp_synthesis_filterf(freq, tmp2, tmp1, SUBFR_SIZE, | |
273 LP_FILTER_ORDER); | |
274 | |
275 pitch_sharpening(pitch_lag, pitch_sharp_factor, freq); | |
276 } | |
277 | |
278 /** | |
12024 | 279 * Evaluate the convolution of a vector with a sparse vector. |
10836 | 280 */ |
281 static void convolute_with_sparse(float *out, const AMRFixed *pulses, | |
282 const float *shape, int length) | |
283 { | |
284 int i, j; | |
285 | |
286 memset(out, 0, length*sizeof(float)); | |
287 for (i = 0; i < pulses->n; i++) | |
288 for (j = pulses->x[i]; j < length; j++) | |
289 out[j] += pulses->y[i] * shape[j - pulses->x[i]]; | |
290 } | |
291 | |
292 /** | |
293 * Apply postfilter, very similar to AMR one. | |
294 */ | |
295 static void postfilter_5k0(SiprContext *ctx, const float *lpc, float *samples) | |
296 { | |
297 float buf[SUBFR_SIZE + LP_FILTER_ORDER]; | |
298 float *pole_out = buf + LP_FILTER_ORDER; | |
299 float lpc_n[LP_FILTER_ORDER]; | |
300 float lpc_d[LP_FILTER_ORDER]; | |
301 int i; | |
302 | |
303 for (i = 0; i < LP_FILTER_ORDER; i++) { | |
304 lpc_d[i] = lpc[i] * ff_pow_0_75[i]; | |
10890
36587d8c1201
Allow a SIPR table to be used by the upcoming SIPR16k decoder
vitor
parents:
10889
diff
changeset
|
305 lpc_n[i] = lpc[i] * ff_pow_0_5 [i]; |
10836 | 306 }; |
307 | |
308 memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem, | |
309 LP_FILTER_ORDER*sizeof(float)); | |
310 | |
311 ff_celp_lp_synthesis_filterf(pole_out, lpc_d, samples, SUBFR_SIZE, | |
312 LP_FILTER_ORDER); | |
313 | |
314 memcpy(ctx->postfilter_mem, pole_out + SUBFR_SIZE - LP_FILTER_ORDER, | |
315 LP_FILTER_ORDER*sizeof(float)); | |
316 | |
317 ff_tilt_compensation(&ctx->tilt_mem, 0.4, pole_out, SUBFR_SIZE); | |
318 | |
319 memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem5k0, | |
320 LP_FILTER_ORDER*sizeof(*pole_out)); | |
321 | |
322 memcpy(ctx->postfilter_mem5k0, pole_out + SUBFR_SIZE - LP_FILTER_ORDER, | |
323 LP_FILTER_ORDER*sizeof(*pole_out)); | |
324 | |
325 ff_celp_lp_zero_synthesis_filterf(samples, lpc_n, pole_out, SUBFR_SIZE, | |
326 LP_FILTER_ORDER); | |
327 | |
328 } | |
329 | |
330 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const int16_t *pulses, | |
331 SiprMode mode, int low_gain) | |
332 { | |
333 int i; | |
334 | |
335 switch (mode) { | |
336 case MODE_6k5: | |
337 for (i = 0; i < 3; i++) { | |
338 fixed_sparse->x[i] = 3 * (pulses[i] & 0xf) + i; | |
339 fixed_sparse->y[i] = pulses[i] & 0x10 ? -1 : 1; | |
340 } | |
341 fixed_sparse->n = 3; | |
342 break; | |
343 case MODE_8k5: | |
344 for (i = 0; i < 3; i++) { | |
345 fixed_sparse->x[2*i ] = 3 * ((pulses[i] >> 4) & 0xf) + i; | |
346 fixed_sparse->x[2*i + 1] = 3 * ( pulses[i] & 0xf) + i; | |
347 | |
348 fixed_sparse->y[2*i ] = (pulses[i] & 0x100) ? -1.0: 1.0; | |
349 | |
350 fixed_sparse->y[2*i + 1] = | |
351 (fixed_sparse->x[2*i + 1] < fixed_sparse->x[2*i]) ? | |
352 -fixed_sparse->y[2*i ] : fixed_sparse->y[2*i]; | |
353 } | |
354 | |
355 fixed_sparse->n = 6; | |
356 break; | |
357 case MODE_5k0: | |
358 default: | |
359 if (low_gain) { | |
360 int offset = (pulses[0] & 0x200) ? 2 : 0; | |
361 int val = pulses[0]; | |
362 | |
363 for (i = 0; i < 3; i++) { | |
364 int index = (val & 0x7) * 6 + 4 - i*2; | |
365 | |
366 fixed_sparse->y[i] = (offset + index) & 0x3 ? -1 : 1; | |
367 fixed_sparse->x[i] = index; | |
368 | |
369 val >>= 3; | |
370 } | |
371 fixed_sparse->n = 3; | |
372 } else { | |
373 int pulse_subset = (pulses[0] >> 8) & 1; | |
374 | |
375 fixed_sparse->x[0] = ((pulses[0] >> 4) & 15) * 3 + pulse_subset; | |
376 fixed_sparse->x[1] = ( pulses[0] & 15) * 3 + pulse_subset + 1; | |
377 | |
378 fixed_sparse->y[0] = pulses[0] & 0x200 ? -1 : 1; | |
379 fixed_sparse->y[1] = -fixed_sparse->y[0]; | |
380 fixed_sparse->n = 2; | |
381 } | |
382 break; | |
383 } | |
384 } | |
385 | |
386 static void decode_frame(SiprContext *ctx, SiprParameters *params, | |
387 float *out_data) | |
388 { | |
389 int i, j; | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
390 int subframe_count = modes[ctx->mode].subframe_count; |
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
391 int frame_size = subframe_count * SUBFR_SIZE; |
10871 | 392 float Az[LP_FILTER_ORDER * MAX_SUBFRAME_COUNT]; |
10836 | 393 float *excitation; |
394 float ir_buf[SUBFR_SIZE + LP_FILTER_ORDER]; | |
395 float lsf_new[LP_FILTER_ORDER]; | |
396 float *impulse_response = ir_buf + LP_FILTER_ORDER; | |
397 float *synth = ctx->synth_buf + 16; // 16 instead of LP_FILTER_ORDER for | |
398 // memory alignment | |
399 int t0_first = 0; | |
400 AMRFixed fixed_cb; | |
401 | |
402 memset(ir_buf, 0, LP_FILTER_ORDER * sizeof(float)); | |
403 lsf_decode_fp(lsf_new, ctx->lsf_history, params); | |
404 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
405 sipr_decode_lp(lsf_new, ctx->lsp_history, Az, subframe_count); |
10836 | 406 |
407 memcpy(ctx->lsp_history, lsf_new, LP_FILTER_ORDER * sizeof(float)); | |
408 | |
409 excitation = ctx->excitation + PITCH_DELAY_MAX + L_INTERPOL; | |
410 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
411 for (i = 0; i < subframe_count; i++) { |
10836 | 412 float *pAz = Az + i*LP_FILTER_ORDER; |
413 float fixed_vector[SUBFR_SIZE]; | |
414 int T0,T0_frac; | |
415 float pitch_gain, gain_code, avg_energy; | |
416 | |
417 ff_decode_pitch_lag(&T0, &T0_frac, params->pitch_delay[i], t0_first, i, | |
418 ctx->mode == MODE_5k0, 6); | |
419 | |
420 if (i == 0 || (i == 2 && ctx->mode == MODE_5k0)) | |
421 t0_first = T0; | |
422 | |
423 ff_acelp_interpolatef(excitation, excitation - T0 + (T0_frac <= 0), | |
424 ff_b60_sinc, 6, | |
425 2 * ((2 + T0_frac)%3 + 1), LP_FILTER_ORDER, | |
426 SUBFR_SIZE); | |
427 | |
428 decode_fixed_sparse(&fixed_cb, params->fc_indexes[i], ctx->mode, | |
429 ctx->past_pitch_gain < 0.8); | |
430 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
431 eval_ir(pAz, T0, impulse_response, modes[ctx->mode].pitch_sharp_factor); |
10836 | 432 |
433 convolute_with_sparse(fixed_vector, &fixed_cb, impulse_response, | |
434 SUBFR_SIZE); | |
435 | |
436 avg_energy = | |
437 (0.01 + ff_dot_productf(fixed_vector, fixed_vector, SUBFR_SIZE))/ | |
438 SUBFR_SIZE; | |
439 | |
440 ctx->past_pitch_gain = pitch_gain = gain_cb[params->gc_index[i]][0]; | |
441 | |
442 gain_code = ff_amr_set_fixed_gain(gain_cb[params->gc_index[i]][1], | |
443 avg_energy, ctx->energy_history, | |
10873 | 444 34 - 15.0/(0.05*M_LN10/M_LN2), |
10836 | 445 pred); |
446 | |
447 ff_weighted_vector_sumf(excitation, excitation, fixed_vector, | |
448 pitch_gain, gain_code, SUBFR_SIZE); | |
449 | |
450 pitch_gain *= 0.5 * pitch_gain; | |
451 pitch_gain = FFMIN(pitch_gain, 0.4); | |
452 | |
453 ctx->gain_mem = 0.7 * ctx->gain_mem + 0.3 * pitch_gain; | |
454 ctx->gain_mem = FFMIN(ctx->gain_mem, pitch_gain); | |
455 gain_code *= ctx->gain_mem; | |
456 | |
457 for (j = 0; j < SUBFR_SIZE; j++) | |
458 fixed_vector[j] = excitation[j] - gain_code * fixed_vector[j]; | |
459 | |
460 if (ctx->mode == MODE_5k0) { | |
461 postfilter_5k0(ctx, pAz, fixed_vector); | |
462 | |
463 ff_celp_lp_synthesis_filterf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE, | |
464 pAz, excitation, SUBFR_SIZE, | |
465 LP_FILTER_ORDER); | |
466 } | |
467 | |
468 ff_celp_lp_synthesis_filterf(synth + i*SUBFR_SIZE, pAz, fixed_vector, | |
469 SUBFR_SIZE, LP_FILTER_ORDER); | |
470 | |
471 excitation += SUBFR_SIZE; | |
472 } | |
473 | |
474 memcpy(synth - LP_FILTER_ORDER, synth + frame_size - LP_FILTER_ORDER, | |
475 LP_FILTER_ORDER * sizeof(float)); | |
476 | |
477 if (ctx->mode == MODE_5k0) { | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
478 for (i = 0; i < subframe_count; i++) { |
10836 | 479 float energy = ff_dot_productf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE, |
480 ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE, | |
481 SUBFR_SIZE); | |
11647
26aabf52f578
Split the input/output data arguments to ff_adaptive_gain_control().
rbultje
parents:
11560
diff
changeset
|
482 ff_adaptive_gain_control(&synth[i * SUBFR_SIZE], |
26aabf52f578
Split the input/output data arguments to ff_adaptive_gain_control().
rbultje
parents:
11560
diff
changeset
|
483 &synth[i * SUBFR_SIZE], energy, |
11462 | 484 SUBFR_SIZE, 0.9, &ctx->postfilter_agc); |
10836 | 485 } |
486 | |
487 memcpy(ctx->postfilter_syn5k0, ctx->postfilter_syn5k0 + frame_size, | |
488 LP_FILTER_ORDER*sizeof(float)); | |
489 } | |
490 memcpy(ctx->excitation, excitation - PITCH_DELAY_MAX - L_INTERPOL, | |
491 (PITCH_DELAY_MAX + L_INTERPOL) * sizeof(float)); | |
492 | |
11648
0516f4062307
Split input/output data arguments to ff_acelp_apply_order_2_transfer_function().
rbultje
parents:
11647
diff
changeset
|
493 ff_acelp_apply_order_2_transfer_function(out_data, synth, |
10836 | 494 (const float[2]) {-1.99997 , 1.000000000}, |
495 (const float[2]) {-1.93307352, 0.935891986}, | |
496 0.939805806, | |
497 ctx->highpass_filt_mem, | |
498 frame_size); | |
499 } | |
500 | |
501 static av_cold int sipr_decoder_init(AVCodecContext * avctx) | |
502 { | |
503 SiprContext *ctx = avctx->priv_data; | |
504 int i; | |
505 | |
506 if (avctx->bit_rate > 12200) ctx->mode = MODE_16k; | |
507 else if (avctx->bit_rate > 7500 ) ctx->mode = MODE_8k5; | |
508 else if (avctx->bit_rate > 5750 ) ctx->mode = MODE_6k5; | |
509 else ctx->mode = MODE_5k0; | |
510 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
511 av_log(avctx, AV_LOG_DEBUG, "Mode: %s\n", modes[ctx->mode].mode_name); |
10836 | 512 |
10891 | 513 if (ctx->mode == MODE_16k) |
514 ff_sipr_init_16k(ctx); | |
515 | |
10836 | 516 for (i = 0; i < LP_FILTER_ORDER; i++) |
517 ctx->lsp_history[i] = cos((i+1) * M_PI / (LP_FILTER_ORDER + 1)); | |
518 | |
519 for (i = 0; i < 4; i++) | |
520 ctx->energy_history[i] = -14; | |
521 | |
522 avctx->sample_fmt = SAMPLE_FMT_FLT; | |
523 | |
524 dsputil_init(&ctx->dsp, avctx); | |
525 | |
526 return 0; | |
527 } | |
528 | |
529 static int sipr_decode_frame(AVCodecContext *avctx, void *datap, | |
530 int *data_size, AVPacket *avpkt) | |
531 { | |
532 SiprContext *ctx = avctx->priv_data; | |
533 const uint8_t *buf=avpkt->data; | |
534 SiprParameters parm; | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
535 const SiprModeParam *mode_par = &modes[ctx->mode]; |
10836 | 536 GetBitContext gb; |
537 float *data = datap; | |
10891 | 538 int subframe_size = ctx->mode == MODE_16k ? L_SUBFR_16k : SUBFR_SIZE; |
10836 | 539 int i; |
540 | |
541 ctx->avctx = avctx; | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
542 if (avpkt->size < (mode_par->bits_per_frame >> 3)) { |
10836 | 543 av_log(avctx, AV_LOG_ERROR, |
544 "Error processing packet: packet size (%d) too small\n", | |
545 avpkt->size); | |
546 | |
547 *data_size = 0; | |
548 return -1; | |
549 } | |
10891 | 550 if (*data_size < subframe_size * mode_par->subframe_count * sizeof(float)) { |
10836 | 551 av_log(avctx, AV_LOG_ERROR, |
552 "Error processing packet: output buffer (%d) too small\n", | |
553 *data_size); | |
554 | |
555 *data_size = 0; | |
556 return -1; | |
557 } | |
558 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
559 init_get_bits(&gb, buf, mode_par->bits_per_frame); |
10836 | 560 |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
561 for (i = 0; i < mode_par->frames_per_packet; i++) { |
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
562 decode_parameters(&parm, &gb, mode_par); |
10836 | 563 |
10891 | 564 if (ctx->mode == MODE_16k) |
565 ff_sipr_decode_frame_16k(ctx, &parm, data); | |
566 else | |
567 decode_frame(ctx, &parm, data); | |
568 | |
569 data += subframe_size * mode_par->subframe_count; | |
10836 | 570 } |
571 | |
10891 | 572 *data_size = mode_par->frames_per_packet * subframe_size * |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
573 mode_par->subframe_count * sizeof(float); |
10836 | 574 |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
575 return mode_par->bits_per_frame >> 3; |
10836 | 576 }; |
577 | |
578 AVCodec sipr_decoder = { | |
579 "sipr", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11462
diff
changeset
|
580 AVMEDIA_TYPE_AUDIO, |
10836 | 581 CODEC_ID_SIPR, |
582 sizeof(SiprContext), | |
583 sipr_decoder_init, | |
584 NULL, | |
585 NULL, | |
586 sipr_decode_frame, | |
587 .long_name = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"), | |
588 }; |