3 * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * @author Reynaldo H. Verdejo Pinochet
26 * @remark FFmpeg merging spearheaded by Kenan Gillet
27 * @remark Development mentored by Benjamin Larson
32 #include "libavutil/avassert.h"
33 #include "libavutil/channel_layout.h"
34 #include "libavutil/float_dsp.h"
38 #include "qcelpdata.h"
39 #include "celp_filters.h"
40 #include "acelp_filters.h"
41 #include "acelp_vectors.h"
45 I_F_Q
= -1, /**< insufficient frame quality */
55 qcelp_packet_rate bitrate
;
56 QCELPFrame frame
; /**< unpacked data frame */
58 uint8_t erasure_count
;
59 uint8_t octave_count
; /**< count the consecutive RATE_OCTAVE frames */
61 float predictor_lspf
[10];/**< LSP predictor for RATE_OCTAVE and I_F_Q */
62 float pitch_synthesis_filter_mem
[303];
63 float pitch_pre_filter_mem
[303];
64 float rnd_fir_filter_mem
[180];
65 float formant_mem
[170];
66 float last_codebook_gain
;
72 uint8_t warned_buf_mismatch_bitrate
;
75 float postfilter_synth_mem
[10];
76 float postfilter_agc_mem
;
77 float postfilter_tilt_mem
;
81 * Initialize the speech codec according to the specification.
83 * TIA/EIA/IS-733 2.4.9
85 static av_cold
int qcelp_decode_init(AVCodecContext
*avctx
)
87 QCELPContext
*q
= avctx
->priv_data
;
91 avctx
->channel_layout
= AV_CH_LAYOUT_MONO
;
92 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLT
;
94 for (i
= 0; i
< 10; i
++)
95 q
->prev_lspf
[i
] = (i
+ 1) / 11.0;
101 * Decode the 10 quantized LSP frequencies from the LSPV/LSP
102 * transmission codes of any bitrate and check for badly received packets.
104 * @param q the context
105 * @param lspf line spectral pair frequencies
107 * @return 0 on success, -1 if the packet is badly received
109 * TIA/EIA/IS-733 2.4.3.2.6.2-2, 2.4.8.7.3
111 static int decode_lspf(QCELPContext
*q
, float *lspf
)
114 float tmp_lspf
, smooth
, erasure_coeff
;
115 const float *predictors
;
117 if (q
->bitrate
== RATE_OCTAVE
|| q
->bitrate
== I_F_Q
) {
118 predictors
= q
->prev_bitrate
!= RATE_OCTAVE
&&
119 q
->prev_bitrate
!= I_F_Q
? q
->prev_lspf
122 if (q
->bitrate
== RATE_OCTAVE
) {
125 for (i
= 0; i
< 10; i
++) {
126 q
->predictor_lspf
[i
] =
127 lspf
[i
] = (q
->frame
.lspv
[i
] ? QCELP_LSP_SPREAD_FACTOR
128 : -QCELP_LSP_SPREAD_FACTOR
) +
129 predictors
[i
] * QCELP_LSP_OCTAVE_PREDICTOR
+
130 (i
+ 1) * ((1 - QCELP_LSP_OCTAVE_PREDICTOR
) / 11);
132 smooth
= q
->octave_count
< 10 ? .875 : 0.1;
134 erasure_coeff
= QCELP_LSP_OCTAVE_PREDICTOR
;
136 av_assert2(q
->bitrate
== I_F_Q
);
138 if (q
->erasure_count
> 1)
139 erasure_coeff
*= q
->erasure_count
< 4 ? 0.9 : 0.7;
141 for (i
= 0; i
< 10; i
++) {
142 q
->predictor_lspf
[i
] =
143 lspf
[i
] = (i
+ 1) * (1 - erasure_coeff
) / 11 +
144 erasure_coeff
* predictors
[i
];
149 // Check the stability of the LSP frequencies.
150 lspf
[0] = FFMAX(lspf
[0], QCELP_LSP_SPREAD_FACTOR
);
151 for (i
= 1; i
< 10; i
++)
152 lspf
[i
] = FFMAX(lspf
[i
], lspf
[i
- 1] + QCELP_LSP_SPREAD_FACTOR
);
154 lspf
[9] = FFMIN(lspf
[9], 1.0 - QCELP_LSP_SPREAD_FACTOR
);
155 for (i
= 9; i
> 0; i
--)
156 lspf
[i
- 1] = FFMIN(lspf
[i
- 1], lspf
[i
] - QCELP_LSP_SPREAD_FACTOR
);
158 // Low-pass filter the LSP frequencies.
159 ff_weighted_vector_sumf(lspf
, lspf
, q
->prev_lspf
, smooth
, 1.0 - smooth
, 10);
164 for (i
= 0; i
< 5; i
++) {
165 lspf
[2 * i
+ 0] = tmp_lspf
+= qcelp_lspvq
[i
][q
->frame
.lspv
[i
]][0] * 0.0001;
166 lspf
[2 * i
+ 1] = tmp_lspf
+= qcelp_lspvq
[i
][q
->frame
.lspv
[i
]][1] * 0.0001;
169 // Check for badly received packets.
170 if (q
->bitrate
== RATE_QUARTER
) {
171 if (lspf
[9] <= .70 || lspf
[9] >= .97)
173 for (i
= 3; i
< 10; i
++)
174 if (fabs(lspf
[i
] - lspf
[i
- 2]) < .08)
177 if (lspf
[9] <= .66 || lspf
[9] >= .985)
179 for (i
= 4; i
< 10; i
++)
180 if (fabs(lspf
[i
] - lspf
[i
- 4]) < .0931)
188 * Convert codebook transmission codes to GAIN and INDEX.
190 * @param q the context
191 * @param gain array holding the decoded gain
193 * TIA/EIA/IS-733 2.4.6.2
195 static void decode_gain_and_index(QCELPContext
*q
, float *gain
)
197 int i
, subframes_count
, g1
[16];
200 if (q
->bitrate
>= RATE_QUARTER
) {
201 switch (q
->bitrate
) {
202 case RATE_FULL
: subframes_count
= 16; break;
203 case RATE_HALF
: subframes_count
= 4; break;
204 default: subframes_count
= 5;
206 for (i
= 0; i
< subframes_count
; i
++) {
207 g1
[i
] = 4 * q
->frame
.cbgain
[i
];
208 if (q
->bitrate
== RATE_FULL
&& !((i
+ 1) & 3)) {
209 g1
[i
] += av_clip((g1
[i
- 1] + g1
[i
- 2] + g1
[i
- 3]) / 3 - 6, 0, 32);
212 gain
[i
] = qcelp_g12ga
[g1
[i
]];
214 if (q
->frame
.cbsign
[i
]) {
216 q
->frame
.cindex
[i
] = (q
->frame
.cindex
[i
] - 89) & 127;
220 q
->prev_g1
[0] = g1
[i
- 2];
221 q
->prev_g1
[1] = g1
[i
- 1];
222 q
->last_codebook_gain
= qcelp_g12ga
[g1
[i
- 1]];
224 if (q
->bitrate
== RATE_QUARTER
) {
225 // Provide smoothing of the unvoiced excitation energy.
227 gain
[6] = 0.4 * gain
[3] + 0.6 * gain
[4];
229 gain
[4] = 0.8 * gain
[2] + 0.2 * gain
[3];
230 gain
[3] = 0.2 * gain
[1] + 0.8 * gain
[2];
232 gain
[1] = 0.6 * gain
[0] + 0.4 * gain
[1];
234 } else if (q
->bitrate
!= SILENCE
) {
235 if (q
->bitrate
== RATE_OCTAVE
) {
236 g1
[0] = 2 * q
->frame
.cbgain
[0] +
237 av_clip((q
->prev_g1
[0] + q
->prev_g1
[1]) / 2 - 5, 0, 54);
240 av_assert2(q
->bitrate
== I_F_Q
);
242 g1
[0] = q
->prev_g1
[1];
243 switch (q
->erasure_count
) {
245 case 2 : g1
[0] -= 1; break;
246 case 3 : g1
[0] -= 2; break;
253 // This interpolation is done to produce smoother background noise.
254 slope
= 0.5 * (qcelp_g12ga
[g1
[0]] - q
->last_codebook_gain
) / subframes_count
;
255 for (i
= 1; i
<= subframes_count
; i
++)
256 gain
[i
- 1] = q
->last_codebook_gain
+ slope
* i
;
258 q
->last_codebook_gain
= gain
[i
- 2];
259 q
->prev_g1
[0] = q
->prev_g1
[1];
260 q
->prev_g1
[1] = g1
[0];
265 * If the received packet is Rate 1/4 a further sanity check is made of the
268 * @param cbgain the unpacked cbgain array
269 * @return -1 if the sanity check fails, 0 otherwise
271 * TIA/EIA/IS-733 2.4.8.7.3
273 static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain
)
275 int i
, diff
, prev_diff
= 0;
277 for (i
= 1; i
< 5; i
++) {
278 diff
= cbgain
[i
] - cbgain
[i
-1];
279 if (FFABS(diff
) > 10)
281 else if (FFABS(diff
- prev_diff
) > 12)
289 * Compute the scaled codebook vector Cdn From INDEX and GAIN
292 * The specification lacks some information here.
294 * TIA/EIA/IS-733 has an omission on the codebook index determination
295 * formula for RATE_FULL and RATE_HALF frames at section 2.4.8.1.1. It says
296 * you have to subtract the decoded index parameter from the given scaled
297 * codebook vector index 'n' to get the desired circular codebook index, but
298 * it does not mention that you have to clamp 'n' to [0-9] in order to get
299 * RI-compliant results.
301 * The reason for this mistake seems to be the fact they forgot to mention you
302 * have to do these calculations per codebook subframe and adjust given
303 * equation values accordingly.
305 * @param q the context
306 * @param gain array holding the 4 pitch subframe gain values
307 * @param cdn_vector array for the generated scaled codebook vector
309 static void compute_svector(QCELPContext
*q
, const float *gain
,
313 uint16_t cbseed
, cindex
;
314 float *rnd
, tmp_gain
, fir_filter_value
;
316 switch (q
->bitrate
) {
318 for (i
= 0; i
< 16; i
++) {
319 tmp_gain
= gain
[i
] * QCELP_RATE_FULL_CODEBOOK_RATIO
;
320 cindex
= -q
->frame
.cindex
[i
];
321 for (j
= 0; j
< 10; j
++)
322 *cdn_vector
++ = tmp_gain
*
323 qcelp_rate_full_codebook
[cindex
++ & 127];
327 for (i
= 0; i
< 4; i
++) {
328 tmp_gain
= gain
[i
] * QCELP_RATE_HALF_CODEBOOK_RATIO
;
329 cindex
= -q
->frame
.cindex
[i
];
330 for (j
= 0; j
< 40; j
++)
331 *cdn_vector
++ = tmp_gain
*
332 qcelp_rate_half_codebook
[cindex
++ & 127];
336 cbseed
= (0x0003 & q
->frame
.lspv
[4]) << 14 |
337 (0x003F & q
->frame
.lspv
[3]) << 8 |
338 (0x0060 & q
->frame
.lspv
[2]) << 1 |
339 (0x0007 & q
->frame
.lspv
[1]) << 3 |
340 (0x0038 & q
->frame
.lspv
[0]) >> 3;
341 rnd
= q
->rnd_fir_filter_mem
+ 20;
342 for (i
= 0; i
< 8; i
++) {
343 tmp_gain
= gain
[i
] * (QCELP_SQRT1887
/ 32768.0);
344 for (k
= 0; k
< 20; k
++) {
345 cbseed
= 521 * cbseed
+ 259;
346 *rnd
= (int16_t) cbseed
;
349 fir_filter_value
= 0.0;
350 for (j
= 0; j
< 10; j
++)
351 fir_filter_value
+= qcelp_rnd_fir_coefs
[j
] *
352 (rnd
[-j
] + rnd
[-20+j
]);
354 fir_filter_value
+= qcelp_rnd_fir_coefs
[10] * rnd
[-10];
355 *cdn_vector
++ = tmp_gain
* fir_filter_value
;
359 memcpy(q
->rnd_fir_filter_mem
, q
->rnd_fir_filter_mem
+ 160,
363 cbseed
= q
->first16bits
;
364 for (i
= 0; i
< 8; i
++) {
365 tmp_gain
= gain
[i
] * (QCELP_SQRT1887
/ 32768.0);
366 for (j
= 0; j
< 20; j
++) {
367 cbseed
= 521 * cbseed
+ 259;
368 *cdn_vector
++ = tmp_gain
* (int16_t) cbseed
;
373 cbseed
= -44; // random codebook index
374 for (i
= 0; i
< 4; i
++) {
375 tmp_gain
= gain
[i
] * QCELP_RATE_FULL_CODEBOOK_RATIO
;
376 for (j
= 0; j
< 40; j
++)
377 *cdn_vector
++ = tmp_gain
*
378 qcelp_rate_full_codebook
[cbseed
++ & 127];
382 memset(cdn_vector
, 0, 160 * sizeof(float));
388 * Apply generic gain control.
390 * @param v_out output vector
391 * @param v_in gain-controlled vector
392 * @param v_ref vector to control gain of
394 * TIA/EIA/IS-733 2.4.8.3, 2.4.8.6
396 static void apply_gain_ctrl(float *v_out
, const float *v_ref
, const float *v_in
)
400 for (i
= 0; i
< 160; i
+= 40) {
401 float res
= avpriv_scalarproduct_float_c(v_ref
+ i
, v_ref
+ i
, 40);
402 ff_scale_vector_to_given_sum_of_squares(v_out
+ i
, v_in
+ i
, res
, 40);
407 * Apply filter in pitch-subframe steps.
409 * @param memory buffer for the previous state of the filter
410 * - must be able to contain 303 elements
411 * - the 143 first elements are from the previous state
412 * - the next 160 are for output
413 * @param v_in input filter vector
414 * @param gain per-subframe gain array, each element is between 0.0 and 2.0
415 * @param lag per-subframe lag array, each element is
416 * - between 16 and 143 if its corresponding pfrac is 0,
417 * - between 16 and 139 otherwise
418 * @param pfrac per-subframe boolean array, 1 if the lag is fractional, 0
421 * @return filter output vector
423 static const float *do_pitchfilter(float memory
[303], const float v_in
[160],
424 const float gain
[4], const uint8_t *lag
,
425 const uint8_t pfrac
[4])
428 float *v_lag
, *v_out
;
431 v_out
= memory
+ 143; // Output vector starts at memory[143].
433 for (i
= 0; i
< 4; i
++) {
435 v_lag
= memory
+ 143 + 40 * i
- lag
[i
];
436 for (v_len
= v_in
+ 40; v_in
< v_len
; v_in
++) {
437 if (pfrac
[i
]) { // If it is a fractional lag...
438 for (j
= 0, *v_out
= 0.0; j
< 4; j
++)
439 *v_out
+= qcelp_hammsinc_table
[j
] *
440 (v_lag
[j
- 4] + v_lag
[3 - j
]);
444 *v_out
= *v_in
+ gain
[i
] * *v_out
;
450 memcpy(v_out
, v_in
, 40 * sizeof(float));
456 memmove(memory
, memory
+ 160, 143 * sizeof(float));
461 * Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector.
462 * TIA/EIA/IS-733 2.4.5.2, 2.4.8.7.2
464 * @param q the context
465 * @param cdn_vector the scaled codebook vector
467 static void apply_pitch_filters(QCELPContext
*q
, float *cdn_vector
)
470 const float *v_synthesis_filtered
, *v_pre_filtered
;
472 if (q
->bitrate
>= RATE_HALF
|| q
->bitrate
== SILENCE
||
473 (q
->bitrate
== I_F_Q
&& (q
->prev_bitrate
>= RATE_HALF
))) {
475 if (q
->bitrate
>= RATE_HALF
) {
476 // Compute gain & lag for the whole frame.
477 for (i
= 0; i
< 4; i
++) {
478 q
->pitch_gain
[i
] = q
->frame
.plag
[i
] ? (q
->frame
.pgain
[i
] + 1) * 0.25 : 0.0;
480 q
->pitch_lag
[i
] = q
->frame
.plag
[i
] + 16;
483 float max_pitch_gain
;
485 if (q
->bitrate
== I_F_Q
) {
486 if (q
->erasure_count
< 3)
487 max_pitch_gain
= 0.9 - 0.3 * (q
->erasure_count
- 1);
489 max_pitch_gain
= 0.0;
491 av_assert2(q
->bitrate
== SILENCE
);
492 max_pitch_gain
= 1.0;
494 for (i
= 0; i
< 4; i
++)
495 q
->pitch_gain
[i
] = FFMIN(q
->pitch_gain
[i
], max_pitch_gain
);
497 memset(q
->frame
.pfrac
, 0, sizeof(q
->frame
.pfrac
));
500 // pitch synthesis filter
501 v_synthesis_filtered
= do_pitchfilter(q
->pitch_synthesis_filter_mem
,
502 cdn_vector
, q
->pitch_gain
,
503 q
->pitch_lag
, q
->frame
.pfrac
);
505 // pitch prefilter update
506 for (i
= 0; i
< 4; i
++)
507 q
->pitch_gain
[i
] = 0.5 * FFMIN(q
->pitch_gain
[i
], 1.0);
509 v_pre_filtered
= do_pitchfilter(q
->pitch_pre_filter_mem
,
510 v_synthesis_filtered
,
511 q
->pitch_gain
, q
->pitch_lag
,
514 apply_gain_ctrl(cdn_vector
, v_synthesis_filtered
, v_pre_filtered
);
516 memcpy(q
->pitch_synthesis_filter_mem
,
517 cdn_vector
+ 17, 143 * sizeof(float));
518 memcpy(q
->pitch_pre_filter_mem
, cdn_vector
+ 17, 143 * sizeof(float));
519 memset(q
->pitch_gain
, 0, sizeof(q
->pitch_gain
));
520 memset(q
->pitch_lag
, 0, sizeof(q
->pitch_lag
));
525 * Reconstruct LPC coefficients from the line spectral pair frequencies
526 * and perform bandwidth expansion.
528 * @param lspf line spectral pair frequencies
529 * @param lpc linear predictive coding coefficients
531 * @note: bandwidth_expansion_coeff could be precalculated into a table
532 * but it seems to be slower on x86
534 * TIA/EIA/IS-733 2.4.3.3.5
536 static void lspf2lpc(const float *lspf
, float *lpc
)
539 double bandwidth_expansion_coeff
= QCELP_BANDWIDTH_EXPANSION_COEFF
;
542 for (i
= 0; i
< 10; i
++)
543 lsp
[i
] = cos(M_PI
* lspf
[i
]);
545 ff_acelp_lspd2lpc(lsp
, lpc
, 5);
547 for (i
= 0; i
< 10; i
++) {
548 lpc
[i
] *= bandwidth_expansion_coeff
;
549 bandwidth_expansion_coeff
*= QCELP_BANDWIDTH_EXPANSION_COEFF
;
554 * Interpolate LSP frequencies and compute LPC coefficients
555 * for a given bitrate & pitch subframe.
557 * TIA/EIA/IS-733 2.4.3.3.4, 2.4.8.7.2
559 * @param q the context
560 * @param curr_lspf LSP frequencies vector of the current frame
561 * @param lpc float vector for the resulting LPC
562 * @param subframe_num frame number in decoded stream
564 static void interpolate_lpc(QCELPContext
*q
, const float *curr_lspf
,
565 float *lpc
, const int subframe_num
)
567 float interpolated_lspf
[10];
570 if (q
->bitrate
>= RATE_QUARTER
)
571 weight
= 0.25 * (subframe_num
+ 1);
572 else if (q
->bitrate
== RATE_OCTAVE
&& !subframe_num
)
578 ff_weighted_vector_sumf(interpolated_lspf
, curr_lspf
, q
->prev_lspf
,
579 weight
, 1.0 - weight
, 10);
580 lspf2lpc(interpolated_lspf
, lpc
);
581 } else if (q
->bitrate
>= RATE_QUARTER
||
582 (q
->bitrate
== I_F_Q
&& !subframe_num
))
583 lspf2lpc(curr_lspf
, lpc
);
584 else if (q
->bitrate
== SILENCE
&& !subframe_num
)
585 lspf2lpc(q
->prev_lspf
, lpc
);
588 static qcelp_packet_rate
buf_size2bitrate(const int buf_size
)
591 case 35: return RATE_FULL
;
592 case 17: return RATE_HALF
;
593 case 8: return RATE_QUARTER
;
594 case 4: return RATE_OCTAVE
;
595 case 1: return SILENCE
;
602 * Determine the bitrate from the frame size and/or the first byte of the frame.
604 * @param avctx the AV codec context
605 * @param buf_size length of the buffer
606 * @param buf the bufffer
608 * @return the bitrate on success,
609 * I_F_Q if the bitrate cannot be satisfactorily determined
611 * TIA/EIA/IS-733 2.4.8.7.1
613 static qcelp_packet_rate
determine_bitrate(AVCodecContext
*avctx
,
617 qcelp_packet_rate bitrate
;
619 if ((bitrate
= buf_size2bitrate(buf_size
)) >= 0) {
620 if (bitrate
> **buf
) {
621 QCELPContext
*q
= avctx
->priv_data
;
622 if (!q
->warned_buf_mismatch_bitrate
) {
623 av_log(avctx
, AV_LOG_WARNING
,
624 "Claimed bitrate and buffer size mismatch.\n");
625 q
->warned_buf_mismatch_bitrate
= 1;
628 } else if (bitrate
< **buf
) {
629 av_log(avctx
, AV_LOG_ERROR
,
630 "Buffer is too small for the claimed bitrate.\n");
634 } else if ((bitrate
= buf_size2bitrate(buf_size
+ 1)) >= 0) {
635 av_log(avctx
, AV_LOG_WARNING
,
636 "Bitrate byte missing, guessing bitrate from packet size.\n");
640 if (bitrate
== SILENCE
) {
641 // FIXME: Remove this warning when tested with samples.
642 avpriv_request_sample(avctx
, "Blank frame handling");
647 static void warn_insufficient_frame_quality(AVCodecContext
*avctx
,
650 av_log(avctx
, AV_LOG_WARNING
, "Frame #%d, IFQ: %s\n",
651 avctx
->frame_number
, message
);
654 static void postfilter(QCELPContext
*q
, float *samples
, float *lpc
)
656 static const float pow_0_775
[10] = {
657 0.775000, 0.600625, 0.465484, 0.360750, 0.279582,
658 0.216676, 0.167924, 0.130141, 0.100859, 0.078166
660 0.625000, 0.390625, 0.244141, 0.152588, 0.095367,
661 0.059605, 0.037253, 0.023283, 0.014552, 0.009095
663 float lpc_s
[10], lpc_p
[10], pole_out
[170], zero_out
[160];
666 for (n
= 0; n
< 10; n
++) {
667 lpc_s
[n
] = lpc
[n
] * pow_0_625
[n
];
668 lpc_p
[n
] = lpc
[n
] * pow_0_775
[n
];
671 ff_celp_lp_zero_synthesis_filterf(zero_out
, lpc_s
,
672 q
->formant_mem
+ 10, 160, 10);
673 memcpy(pole_out
, q
->postfilter_synth_mem
, sizeof(float) * 10);
674 ff_celp_lp_synthesis_filterf(pole_out
+ 10, lpc_p
, zero_out
, 160, 10);
675 memcpy(q
->postfilter_synth_mem
, pole_out
+ 160, sizeof(float) * 10);
677 ff_tilt_compensation(&q
->postfilter_tilt_mem
, 0.3, pole_out
+ 10, 160);
679 ff_adaptive_gain_control(samples
, pole_out
+ 10,
680 avpriv_scalarproduct_float_c(q
->formant_mem
+ 10,
683 160, 0.9375, &q
->postfilter_agc_mem
);
686 static int qcelp_decode_frame(AVCodecContext
*avctx
, void *data
,
687 int *got_frame_ptr
, AVPacket
*avpkt
)
689 const uint8_t *buf
= avpkt
->data
;
690 int buf_size
= avpkt
->size
;
691 QCELPContext
*q
= avctx
->priv_data
;
692 AVFrame
*frame
= data
;
695 float quantized_lspf
[10], lpc
[10];
699 /* get output buffer */
700 frame
->nb_samples
= 160;
701 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
703 outbuffer
= (float *)frame
->data
[0];
705 if ((q
->bitrate
= determine_bitrate(avctx
, buf_size
, &buf
)) == I_F_Q
) {
706 warn_insufficient_frame_quality(avctx
, "Bitrate cannot be determined.");
710 if (q
->bitrate
== RATE_OCTAVE
&&
711 (q
->first16bits
= AV_RB16(buf
)) == 0xFFFF) {
712 warn_insufficient_frame_quality(avctx
, "Bitrate is 1/8 and first 16 bits are on.");
716 if (q
->bitrate
> SILENCE
) {
717 const QCELPBitmap
*bitmaps
= qcelp_unpacking_bitmaps_per_rate
[q
->bitrate
];
718 const QCELPBitmap
*bitmaps_end
= qcelp_unpacking_bitmaps_per_rate
[q
->bitrate
] +
719 qcelp_unpacking_bitmaps_lengths
[q
->bitrate
];
720 uint8_t *unpacked_data
= (uint8_t *)&q
->frame
;
722 init_get_bits(&q
->gb
, buf
, 8 * buf_size
);
724 memset(&q
->frame
, 0, sizeof(QCELPFrame
));
726 for (; bitmaps
< bitmaps_end
; bitmaps
++)
727 unpacked_data
[bitmaps
->index
] |= get_bits(&q
->gb
, bitmaps
->bitlen
) << bitmaps
->bitpos
;
729 // Check for erasures/blanks on rates 1, 1/4 and 1/8.
730 if (q
->frame
.reserved
) {
731 warn_insufficient_frame_quality(avctx
, "Wrong data in reserved frame area.");
734 if (q
->bitrate
== RATE_QUARTER
&&
735 codebook_sanity_check_for_rate_quarter(q
->frame
.cbgain
)) {
736 warn_insufficient_frame_quality(avctx
, "Codebook gain sanity check failed.");
740 if (q
->bitrate
>= RATE_HALF
) {
741 for (i
= 0; i
< 4; i
++) {
742 if (q
->frame
.pfrac
[i
] && q
->frame
.plag
[i
] >= 124) {
743 warn_insufficient_frame_quality(avctx
, "Cannot initialize pitch filter.");
750 decode_gain_and_index(q
, gain
);
751 compute_svector(q
, gain
, outbuffer
);
753 if (decode_lspf(q
, quantized_lspf
) < 0) {
754 warn_insufficient_frame_quality(avctx
, "Badly received packets in frame.");
758 apply_pitch_filters(q
, outbuffer
);
760 if (q
->bitrate
== I_F_Q
) {
764 decode_gain_and_index(q
, gain
);
765 compute_svector(q
, gain
, outbuffer
);
766 decode_lspf(q
, quantized_lspf
);
767 apply_pitch_filters(q
, outbuffer
);
769 q
->erasure_count
= 0;
771 formant_mem
= q
->formant_mem
+ 10;
772 for (i
= 0; i
< 4; i
++) {
773 interpolate_lpc(q
, quantized_lspf
, lpc
, i
);
774 ff_celp_lp_synthesis_filterf(formant_mem
, lpc
,
775 outbuffer
+ i
* 40, 40, 10);
779 // postfilter, as per TIA/EIA/IS-733 2.4.8.6
780 postfilter(q
, outbuffer
, lpc
);
782 memcpy(q
->formant_mem
, q
->formant_mem
+ 160, 10 * sizeof(float));
784 memcpy(q
->prev_lspf
, quantized_lspf
, sizeof(q
->prev_lspf
));
785 q
->prev_bitrate
= q
->bitrate
;
792 AVCodec ff_qcelp_decoder
= {
794 .long_name
= NULL_IF_CONFIG_SMALL("QCELP / PureVoice"),
795 .type
= AVMEDIA_TYPE_AUDIO
,
796 .id
= AV_CODEC_ID_QCELP
,
797 .init
= qcelp_decode_init
,
798 .decode
= qcelp_decode_frame
,
799 .capabilities
= CODEC_CAP_DR1
,
800 .priv_data_size
= sizeof(QCELPContext
),