Mercurial > libavcodec.hg
annotate sipr.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | ff7c1c90b6f5 |
children | c2e19a511e26 |
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 /** | |
187 * Extracts decoding parameters from the input bitstream. | |
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 /** | |
257 * Evaluates the adaptative impulse response. | |
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 /** | |
279 * Evaluates the convolution of a vector with a sparse vector. | |
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); | |
482 ff_adaptative_gain_control(&synth[i * SUBFR_SIZE], energy, | |
483 SUBFR_SIZE, 0.9, &ctx->postfilter_agc); | |
484 } | |
485 | |
486 memcpy(ctx->postfilter_syn5k0, ctx->postfilter_syn5k0 + frame_size, | |
487 LP_FILTER_ORDER*sizeof(float)); | |
488 } | |
489 memcpy(ctx->excitation, excitation - PITCH_DELAY_MAX - L_INTERPOL, | |
490 (PITCH_DELAY_MAX + L_INTERPOL) * sizeof(float)); | |
491 | |
492 ff_acelp_apply_order_2_transfer_function(synth, | |
493 (const float[2]) {-1.99997 , 1.000000000}, | |
494 (const float[2]) {-1.93307352, 0.935891986}, | |
495 0.939805806, | |
496 ctx->highpass_filt_mem, | |
497 frame_size); | |
498 | |
499 ctx->dsp.vector_clipf(out_data, synth, -1, 32767./(1<<15), frame_size); | |
500 | |
501 } | |
502 | |
503 static av_cold int sipr_decoder_init(AVCodecContext * avctx) | |
504 { | |
505 SiprContext *ctx = avctx->priv_data; | |
506 int i; | |
507 | |
508 if (avctx->bit_rate > 12200) ctx->mode = MODE_16k; | |
509 else if (avctx->bit_rate > 7500 ) ctx->mode = MODE_8k5; | |
510 else if (avctx->bit_rate > 5750 ) ctx->mode = MODE_6k5; | |
511 else ctx->mode = MODE_5k0; | |
512 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
513 av_log(avctx, AV_LOG_DEBUG, "Mode: %s\n", modes[ctx->mode].mode_name); |
10836 | 514 |
10891 | 515 if (ctx->mode == MODE_16k) |
516 ff_sipr_init_16k(ctx); | |
517 | |
10836 | 518 for (i = 0; i < LP_FILTER_ORDER; i++) |
519 ctx->lsp_history[i] = cos((i+1) * M_PI / (LP_FILTER_ORDER + 1)); | |
520 | |
521 for (i = 0; i < 4; i++) | |
522 ctx->energy_history[i] = -14; | |
523 | |
524 avctx->sample_fmt = SAMPLE_FMT_FLT; | |
525 | |
526 dsputil_init(&ctx->dsp, avctx); | |
527 | |
528 return 0; | |
529 } | |
530 | |
531 static int sipr_decode_frame(AVCodecContext *avctx, void *datap, | |
532 int *data_size, AVPacket *avpkt) | |
533 { | |
534 SiprContext *ctx = avctx->priv_data; | |
535 const uint8_t *buf=avpkt->data; | |
536 SiprParameters parm; | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
537 const SiprModeParam *mode_par = &modes[ctx->mode]; |
10836 | 538 GetBitContext gb; |
539 float *data = datap; | |
10891 | 540 int subframe_size = ctx->mode == MODE_16k ? L_SUBFR_16k : SUBFR_SIZE; |
10836 | 541 int i; |
542 | |
543 ctx->avctx = avctx; | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
544 if (avpkt->size < (mode_par->bits_per_frame >> 3)) { |
10836 | 545 av_log(avctx, AV_LOG_ERROR, |
546 "Error processing packet: packet size (%d) too small\n", | |
547 avpkt->size); | |
548 | |
549 *data_size = 0; | |
550 return -1; | |
551 } | |
10891 | 552 if (*data_size < subframe_size * mode_par->subframe_count * sizeof(float)) { |
10836 | 553 av_log(avctx, AV_LOG_ERROR, |
554 "Error processing packet: output buffer (%d) too small\n", | |
555 *data_size); | |
556 | |
557 *data_size = 0; | |
558 return -1; | |
559 } | |
560 | |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
561 init_get_bits(&gb, buf, mode_par->bits_per_frame); |
10836 | 562 |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
563 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
|
564 decode_parameters(&parm, &gb, mode_par); |
10836 | 565 |
10891 | 566 if (ctx->mode == MODE_16k) |
567 ff_sipr_decode_frame_16k(ctx, &parm, data); | |
568 else | |
569 decode_frame(ctx, &parm, data); | |
570 | |
571 data += subframe_size * mode_par->subframe_count; | |
10836 | 572 } |
573 | |
10891 | 574 *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
|
575 mode_par->subframe_count * sizeof(float); |
10836 | 576 |
10872
a4fbfc917c2e
Remove the struct SiprModeParam of the context. This will simplify splitting
vitor
parents:
10871
diff
changeset
|
577 return mode_par->bits_per_frame >> 3; |
10836 | 578 }; |
579 | |
580 AVCodec sipr_decoder = { | |
581 "sipr", | |
582 CODEC_TYPE_AUDIO, | |
583 CODEC_ID_SIPR, | |
584 sizeof(SiprContext), | |
585 sipr_decoder_init, | |
586 NULL, | |
587 NULL, | |
588 sipr_decode_frame, | |
589 .long_name = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"), | |
590 }; |