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
23 * @file libavcodec/qcelpdec.c
25 * @author Reynaldo H. Verdejo Pinochet
26 * @remark FFmpeg merging spearheaded by Kenan Gillet
27 * @remark Development mentored by Benjamin Larson
36 #include "qcelpdata.h"
38 #include "celp_math.h"
39 #include "celp_filters.h"
40 #include "acelp_vectors.h"
48 I_F_Q
= -1, /*!< insufficient frame quality */
59 qcelp_packet_rate bitrate
;
60 QCELPFrame frame
; /*!< unpacked data frame */
62 uint8_t erasure_count
;
63 uint8_t octave_count
; /*!< count the consecutive RATE_OCTAVE frames */
65 float predictor_lspf
[10];/*!< LSP predictor for RATE_OCTAVE and I_F_Q */
66 float pitch_synthesis_filter_mem
[303];
67 float pitch_pre_filter_mem
[303];
68 float rnd_fir_filter_mem
[180];
69 float formant_mem
[170];
70 float last_codebook_gain
;
76 uint8_t warned_buf_mismatch_bitrate
;
80 * Initialize the speech codec according to the specification.
82 * TIA/EIA/IS-733 2.4.9
84 static av_cold
int qcelp_decode_init(AVCodecContext
*avctx
)
86 QCELPContext
*q
= avctx
->priv_data
;
89 avctx
->sample_fmt
= SAMPLE_FMT_FLT
;
92 q
->prev_lspf
[i
] = (i
+1)/11.;
98 * Decodes the 10 quantized LSP frequencies from the LSPV/LSP
99 * transmission codes of any bitrate and checks for badly received packets.
101 * @param q the context
102 * @param lspf line spectral pair frequencies
104 * @return 0 on success, -1 if the packet is badly received
106 * TIA/EIA/IS-733 2.4.3.2.6.2-2, 2.4.8.7.3
108 static int decode_lspf(QCELPContext
*q
, float *lspf
)
111 float tmp_lspf
, smooth
, erasure_coeff
;
112 const float *predictors
;
114 if(q
->bitrate
== RATE_OCTAVE
|| q
->bitrate
== I_F_Q
)
116 predictors
= (q
->prev_bitrate
!= RATE_OCTAVE
&&
117 q
->prev_bitrate
!= I_F_Q
?
118 q
->prev_lspf
: q
->predictor_lspf
);
120 if(q
->bitrate
== RATE_OCTAVE
)
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);
135 erasure_coeff
= QCELP_LSP_OCTAVE_PREDICTOR
;
137 assert(q
->bitrate
== I_F_Q
);
139 if(q
->erasure_count
> 1)
140 erasure_coeff
*= (q
->erasure_count
< 4 ? 0.9 : 0.7);
144 q
->predictor_lspf
[i
] =
145 lspf
[i
] = (i
+ 1) * ( 1 - erasure_coeff
)/11
146 + erasure_coeff
* predictors
[i
];
151 // Check the stability of the LSP frequencies.
152 lspf
[0] = FFMAX(lspf
[0], QCELP_LSP_SPREAD_FACTOR
);
154 lspf
[i
] = FFMAX(lspf
[i
], (lspf
[i
-1] + QCELP_LSP_SPREAD_FACTOR
));
156 lspf
[9] = FFMIN(lspf
[9], (1.0 - QCELP_LSP_SPREAD_FACTOR
));
158 lspf
[i
-1] = FFMIN(lspf
[i
-1], (lspf
[i
] - QCELP_LSP_SPREAD_FACTOR
));
160 // Low-pass filter the LSP frequencies.
161 ff_weighted_vector_sumf(lspf
, lspf
, q
->prev_lspf
, smooth
, 1.0-smooth
, 10);
169 lspf
[2*i
+0] = tmp_lspf
+= qcelp_lspvq
[i
][q
->frame
.lspv
[i
]][0] * 0.0001;
170 lspf
[2*i
+1] = tmp_lspf
+= qcelp_lspvq
[i
][q
->frame
.lspv
[i
]][1] * 0.0001;
173 // Check for badly received packets.
174 if(q
->bitrate
== RATE_QUARTER
)
176 if(lspf
[9] <= .70 || lspf
[9] >= .97)
179 if(fabs(lspf
[i
] - lspf
[i
-2]) < .08)
183 if(lspf
[9] <= .66 || lspf
[9] >= .985)
186 if (fabs(lspf
[i
] - lspf
[i
-4]) < .0931)
194 * Converts codebook transmission codes to GAIN and INDEX.
196 * @param q the context
197 * @param gain array holding the decoded gain
199 * TIA/EIA/IS-733 2.4.6.2
201 static void decode_gain_and_index(QCELPContext
*q
,
203 int i
, subframes_count
, g1
[16];
206 if(q
->bitrate
>= RATE_QUARTER
)
210 case RATE_FULL
: subframes_count
= 16; break;
211 case RATE_HALF
: subframes_count
= 4; break;
212 default: subframes_count
= 5;
214 for(i
=0; i
<subframes_count
; i
++)
216 g1
[i
] = 4 * q
->frame
.cbgain
[i
];
217 if(q
->bitrate
== RATE_FULL
&& !((i
+1) & 3))
219 g1
[i
] += av_clip((g1
[i
-1] + g1
[i
-2] + g1
[i
-3]) / 3 - 6, 0, 32);
222 gain
[i
] = qcelp_g12ga
[g1
[i
]];
224 if(q
->frame
.cbsign
[i
])
227 q
->frame
.cindex
[i
] = (q
->frame
.cindex
[i
]-89) & 127;
231 q
->prev_g1
[0] = g1
[i
-2];
232 q
->prev_g1
[1] = g1
[i
-1];
233 q
->last_codebook_gain
= qcelp_g12ga
[g1
[i
-1]];
235 if(q
->bitrate
== RATE_QUARTER
)
237 // Provide smoothing of the unvoiced excitation energy.
239 gain
[6] = 0.4*gain
[3] + 0.6*gain
[4];
241 gain
[4] = 0.8*gain
[2] + 0.2*gain
[3];
242 gain
[3] = 0.2*gain
[1] + 0.8*gain
[2];
244 gain
[1] = 0.6*gain
[0] + 0.4*gain
[1];
246 }else if (q
->bitrate
!= SILENCE
)
248 if(q
->bitrate
== RATE_OCTAVE
)
250 g1
[0] = 2 * q
->frame
.cbgain
[0]
251 + av_clip((q
->prev_g1
[0] + q
->prev_g1
[1]) / 2 - 5, 0, 54);
255 assert(q
->bitrate
== I_F_Q
);
257 g1
[0] = q
->prev_g1
[1];
258 switch(q
->erasure_count
)
261 case 2 : g1
[0] -= 1; break;
262 case 3 : g1
[0] -= 2; break;
269 // This interpolation is done to produce smoother background noise.
270 slope
= 0.5*(qcelp_g12ga
[g1
[0]] - q
->last_codebook_gain
) / subframes_count
;
271 for(i
=1; i
<=subframes_count
; i
++)
272 gain
[i
-1] = q
->last_codebook_gain
+ slope
* i
;
274 q
->last_codebook_gain
= gain
[i
-2];
275 q
->prev_g1
[0] = q
->prev_g1
[1];
276 q
->prev_g1
[1] = g1
[0];
281 * If the received packet is Rate 1/4 a further sanity check is made of the
284 * @param cbgain the unpacked cbgain array
285 * @return -1 if the sanity check fails, 0 otherwise
287 * TIA/EIA/IS-733 2.4.8.7.3
289 static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain
)
291 int i
, diff
, prev_diff
=0;
295 diff
= cbgain
[i
] - cbgain
[i
-1];
298 else if(FFABS(diff
- prev_diff
) > 12)
306 * Computes the scaled codebook vector Cdn From INDEX and GAIN
309 * The specification lacks some information here.
311 * TIA/EIA/IS-733 has an omission on the codebook index determination
312 * formula for RATE_FULL and RATE_HALF frames at section 2.4.8.1.1. It says
313 * you have to subtract the decoded index parameter from the given scaled
314 * codebook vector index 'n' to get the desired circular codebook index, but
315 * it does not mention that you have to clamp 'n' to [0-9] in order to get
316 * RI-compliant results.
318 * The reason for this mistake seems to be the fact they forgot to mention you
319 * have to do these calculations per codebook subframe and adjust given
320 * equation values accordingly.
322 * @param q the context
323 * @param gain array holding the 4 pitch subframe gain values
324 * @param cdn_vector array for the generated scaled codebook vector
326 static void compute_svector(QCELPContext
*q
, const float *gain
,
330 uint16_t cbseed
, cindex
;
331 float *rnd
, tmp_gain
, fir_filter_value
;
338 tmp_gain
= gain
[i
] * QCELP_RATE_FULL_CODEBOOK_RATIO
;
339 cindex
= -q
->frame
.cindex
[i
];
341 *cdn_vector
++ = tmp_gain
* qcelp_rate_full_codebook
[cindex
++ & 127];
347 tmp_gain
= gain
[i
] * QCELP_RATE_HALF_CODEBOOK_RATIO
;
348 cindex
= -q
->frame
.cindex
[i
];
349 for (j
= 0; j
< 40; j
++)
350 *cdn_vector
++ = tmp_gain
* qcelp_rate_half_codebook
[cindex
++ & 127];
354 cbseed
= (0x0003 & q
->frame
.lspv
[4])<<14 |
355 (0x003F & q
->frame
.lspv
[3])<< 8 |
356 (0x0060 & q
->frame
.lspv
[2])<< 1 |
357 (0x0007 & q
->frame
.lspv
[1])<< 3 |
358 (0x0038 & q
->frame
.lspv
[0])>> 3 ;
359 rnd
= q
->rnd_fir_filter_mem
+ 20;
362 tmp_gain
= gain
[i
] * (QCELP_SQRT1887
/ 32768.0);
365 cbseed
= 521 * cbseed
+ 259;
366 *rnd
= (int16_t)cbseed
;
369 fir_filter_value
= 0.0;
371 fir_filter_value
+= qcelp_rnd_fir_coefs
[j
]
372 * (rnd
[-j
] + rnd
[-20+j
]);
374 fir_filter_value
+= qcelp_rnd_fir_coefs
[10] * rnd
[-10];
375 *cdn_vector
++ = tmp_gain
* fir_filter_value
;
379 memcpy(q
->rnd_fir_filter_mem
, q
->rnd_fir_filter_mem
+ 160, 20 * sizeof(float));
382 cbseed
= q
->first16bits
;
385 tmp_gain
= gain
[i
] * (QCELP_SQRT1887
/ 32768.0);
388 cbseed
= 521 * cbseed
+ 259;
389 *cdn_vector
++ = tmp_gain
* (int16_t)cbseed
;
394 cbseed
= -44; // random codebook index
397 tmp_gain
= gain
[i
] * QCELP_RATE_FULL_CODEBOOK_RATIO
;
399 *cdn_vector
++ = tmp_gain
* qcelp_rate_full_codebook
[cbseed
++ & 127];
403 memset(cdn_vector
, 0, 160 * sizeof(float));
409 * Apply generic gain control.
411 * @param v_out output vector
412 * @param v_in gain-controlled vector
413 * @param v_ref vector to control gain of
415 * TIA/EIA/IS-733 2.4.8.3, 2.4.8.6
417 static void apply_gain_ctrl(float *v_out
, const float *v_ref
,
422 for (i
= 0; i
< 160; i
+= 40)
423 ff_scale_vector_to_given_sum_of_squares(v_out
+ i
, v_in
+ i
,
424 ff_dot_productf(v_ref
+ i
,
430 * Apply filter in pitch-subframe steps.
432 * @param memory buffer for the previous state of the filter
433 * - must be able to contain 303 elements
434 * - the 143 first elements are from the previous state
435 * - the next 160 are for output
436 * @param v_in input filter vector
437 * @param gain per-subframe gain array, each element is between 0.0 and 2.0
438 * @param lag per-subframe lag array, each element is
439 * - between 16 and 143 if its corresponding pfrac is 0,
440 * - between 16 and 139 otherwise
441 * @param pfrac per-subframe boolean array, 1 if the lag is fractional, 0
444 * @return filter output vector
446 static const float *do_pitchfilter(float memory
[303], const float v_in
[160],
447 const float gain
[4], const uint8_t *lag
,
448 const uint8_t pfrac
[4])
451 float *v_lag
, *v_out
;
454 v_out
= memory
+ 143; // Output vector starts at memory[143].
460 v_lag
= memory
+ 143 + 40 * i
- lag
[i
];
461 for(v_len
=v_in
+40; v_in
<v_len
; v_in
++)
463 if(pfrac
[i
]) // If it is a fractional lag...
465 for(j
=0, *v_out
=0.; j
<4; j
++)
466 *v_out
+= qcelp_hammsinc_table
[j
] * (v_lag
[j
-4] + v_lag
[3-j
]);
470 *v_out
= *v_in
+ gain
[i
] * *v_out
;
477 memcpy(v_out
, v_in
, 40 * sizeof(float));
483 memmove(memory
, memory
+ 160, 143 * sizeof(float));
488 * Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector.
489 * TIA/EIA/IS-733 2.4.5.2, 2.4.8.7.2
491 * @param q the context
492 * @param cdn_vector the scaled codebook vector
494 static void apply_pitch_filters(QCELPContext
*q
, float *cdn_vector
)
497 const float *v_synthesis_filtered
, *v_pre_filtered
;
499 if(q
->bitrate
>= RATE_HALF
||
500 q
->bitrate
== SILENCE
||
501 (q
->bitrate
== I_F_Q
&& (q
->prev_bitrate
>= RATE_HALF
)))
504 if(q
->bitrate
>= RATE_HALF
)
507 // Compute gain & lag for the whole frame.
510 q
->pitch_gain
[i
] = q
->frame
.plag
[i
] ? (q
->frame
.pgain
[i
] + 1) * 0.25 : 0.0;
512 q
->pitch_lag
[i
] = q
->frame
.plag
[i
] + 16;
516 float max_pitch_gain
;
518 if (q
->bitrate
== I_F_Q
)
520 if (q
->erasure_count
< 3)
521 max_pitch_gain
= 0.9 - 0.3 * (q
->erasure_count
- 1);
523 max_pitch_gain
= 0.0;
526 assert(q
->bitrate
== SILENCE
);
527 max_pitch_gain
= 1.0;
530 q
->pitch_gain
[i
] = FFMIN(q
->pitch_gain
[i
], max_pitch_gain
);
532 memset(q
->frame
.pfrac
, 0, sizeof(q
->frame
.pfrac
));
535 // pitch synthesis filter
536 v_synthesis_filtered
= do_pitchfilter(q
->pitch_synthesis_filter_mem
,
537 cdn_vector
, q
->pitch_gain
,
538 q
->pitch_lag
, q
->frame
.pfrac
);
540 // pitch prefilter update
542 q
->pitch_gain
[i
] = 0.5 * FFMIN(q
->pitch_gain
[i
], 1.0);
544 v_pre_filtered
= do_pitchfilter(q
->pitch_pre_filter_mem
,
545 v_synthesis_filtered
,
546 q
->pitch_gain
, q
->pitch_lag
,
549 apply_gain_ctrl(cdn_vector
, v_synthesis_filtered
, v_pre_filtered
);
552 memcpy(q
->pitch_synthesis_filter_mem
, cdn_vector
+ 17,
553 143 * sizeof(float));
554 memcpy(q
->pitch_pre_filter_mem
, cdn_vector
+ 17, 143 * sizeof(float));
555 memset(q
->pitch_gain
, 0, sizeof(q
->pitch_gain
));
556 memset(q
->pitch_lag
, 0, sizeof(q
->pitch_lag
));
561 * Reconstructs LPC coefficients from the line spectral pair frequencies
562 * and performs bandwidth expansion.
564 * @param lspf line spectral pair frequencies
565 * @param lpc linear predictive coding coefficients
567 * @note: bandwidth_expansion_coeff could be precalculated into a table
568 * but it seems to be slower on x86
570 * TIA/EIA/IS-733 2.4.3.3.5
572 static void lspf2lpc(const float *lspf
, float *lpc
)
575 double bandwidth_expansion_coeff
= QCELP_BANDWIDTH_EXPANSION_COEFF
;
579 lsp
[i
] = cos(M_PI
* lspf
[i
]);
581 ff_acelp_lspd2lpc(lsp
, lpc
, 5);
585 lpc
[i
] *= bandwidth_expansion_coeff
;
586 bandwidth_expansion_coeff
*= QCELP_BANDWIDTH_EXPANSION_COEFF
;
591 * Interpolates LSP frequencies and computes LPC coefficients
592 * for a given bitrate & pitch subframe.
594 * TIA/EIA/IS-733 2.4.3.3.4, 2.4.8.7.2
596 * @param q the context
597 * @param curr_lspf LSP frequencies vector of the current frame
598 * @param lpc float vector for the resulting LPC
599 * @param subframe_num frame number in decoded stream
601 void interpolate_lpc(QCELPContext
*q
, const float *curr_lspf
, float *lpc
,
602 const int subframe_num
)
604 float interpolated_lspf
[10];
607 if(q
->bitrate
>= RATE_QUARTER
)
608 weight
= 0.25 * (subframe_num
+ 1);
609 else if(q
->bitrate
== RATE_OCTAVE
&& !subframe_num
)
616 ff_weighted_vector_sumf(interpolated_lspf
, curr_lspf
, q
->prev_lspf
,
617 weight
, 1.0 - weight
, 10);
618 lspf2lpc(interpolated_lspf
, lpc
);
619 }else if(q
->bitrate
>= RATE_QUARTER
||
620 (q
->bitrate
== I_F_Q
&& !subframe_num
))
621 lspf2lpc(curr_lspf
, lpc
);
622 else if(q
->bitrate
== SILENCE
&& !subframe_num
)
623 lspf2lpc(q
->prev_lspf
, lpc
);
626 static qcelp_packet_rate
buf_size2bitrate(const int buf_size
)
630 case 35: return RATE_FULL
;
631 case 17: return RATE_HALF
;
632 case 8: return RATE_QUARTER
;
633 case 4: return RATE_OCTAVE
;
634 case 1: return SILENCE
;
641 * Determine the bitrate from the frame size and/or the first byte of the frame.
643 * @param avctx the AV codec context
644 * @param buf_size length of the buffer
645 * @param buf the bufffer
647 * @return the bitrate on success,
648 * I_F_Q if the bitrate cannot be satisfactorily determined
650 * TIA/EIA/IS-733 2.4.8.7.1
652 static qcelp_packet_rate
determine_bitrate(AVCodecContext
*avctx
, const int buf_size
,
655 qcelp_packet_rate bitrate
;
657 if((bitrate
= buf_size2bitrate(buf_size
)) >= 0)
661 QCELPContext
*q
= avctx
->priv_data
;
662 if (!q
->warned_buf_mismatch_bitrate
)
664 av_log(avctx
, AV_LOG_WARNING
,
665 "Claimed bitrate and buffer size mismatch.\n");
666 q
->warned_buf_mismatch_bitrate
= 1;
669 }else if(bitrate
< **buf
)
671 av_log(avctx
, AV_LOG_ERROR
,
672 "Buffer is too small for the claimed bitrate.\n");
676 }else if((bitrate
= buf_size2bitrate(buf_size
+ 1)) >= 0)
678 av_log(avctx
, AV_LOG_WARNING
,
679 "Bitrate byte is missing, guessing the bitrate from packet size.\n");
683 if(bitrate
== SILENCE
)
685 //FIXME: Remove experimental warning when tested with samples.
686 av_log_ask_for_sample(avctx
, "'Blank frame handling is experimental.");
691 static void warn_insufficient_frame_quality(AVCodecContext
*avctx
,
694 av_log(avctx
, AV_LOG_WARNING
, "Frame #%d, IFQ: %s\n", avctx
->frame_number
,
698 static int qcelp_decode_frame(AVCodecContext
*avctx
, void *data
, int *data_size
,
701 const uint8_t *buf
= avpkt
->data
;
702 int buf_size
= avpkt
->size
;
703 QCELPContext
*q
= avctx
->priv_data
;
704 float *outbuffer
= data
;
706 float quantized_lspf
[10], lpc
[10];
710 if((q
->bitrate
= determine_bitrate(avctx
, buf_size
, &buf
)) == I_F_Q
)
712 warn_insufficient_frame_quality(avctx
, "bitrate cannot be determined.");
716 if(q
->bitrate
== RATE_OCTAVE
&&
717 (q
->first16bits
= AV_RB16(buf
)) == 0xFFFF)
719 warn_insufficient_frame_quality(avctx
, "Bitrate is 1/8 and first 16 bits are on.");
723 if(q
->bitrate
> SILENCE
)
725 const QCELPBitmap
*bitmaps
= qcelp_unpacking_bitmaps_per_rate
[q
->bitrate
];
726 const QCELPBitmap
*bitmaps_end
= qcelp_unpacking_bitmaps_per_rate
[q
->bitrate
]
727 + qcelp_unpacking_bitmaps_lengths
[q
->bitrate
];
728 uint8_t *unpacked_data
= (uint8_t *)&q
->frame
;
730 init_get_bits(&q
->gb
, buf
, 8*buf_size
);
732 memset(&q
->frame
, 0, sizeof(QCELPFrame
));
734 for(; bitmaps
< bitmaps_end
; bitmaps
++)
735 unpacked_data
[bitmaps
->index
] |= get_bits(&q
->gb
, bitmaps
->bitlen
) << bitmaps
->bitpos
;
737 // Check for erasures/blanks on rates 1, 1/4 and 1/8.
738 if(q
->frame
.reserved
)
740 warn_insufficient_frame_quality(avctx
, "Wrong data in reserved frame area.");
743 if(q
->bitrate
== RATE_QUARTER
&&
744 codebook_sanity_check_for_rate_quarter(q
->frame
.cbgain
))
746 warn_insufficient_frame_quality(avctx
, "Codebook gain sanity check failed.");
750 if(q
->bitrate
>= RATE_HALF
)
754 if(q
->frame
.pfrac
[i
] && q
->frame
.plag
[i
] >= 124)
756 warn_insufficient_frame_quality(avctx
, "Cannot initialize pitch filter.");
763 decode_gain_and_index(q
, gain
);
764 compute_svector(q
, gain
, outbuffer
);
766 if(decode_lspf(q
, quantized_lspf
) < 0)
768 warn_insufficient_frame_quality(avctx
, "Badly received packets in frame.");
773 apply_pitch_filters(q
, outbuffer
);
775 if(q
->bitrate
== I_F_Q
)
780 decode_gain_and_index(q
, gain
);
781 compute_svector(q
, gain
, outbuffer
);
782 decode_lspf(q
, quantized_lspf
);
783 apply_pitch_filters(q
, outbuffer
);
785 q
->erasure_count
= 0;
787 formant_mem
= q
->formant_mem
+ 10;
790 interpolate_lpc(q
, quantized_lspf
, lpc
, i
);
791 ff_celp_lp_synthesis_filterf(formant_mem
, lpc
, outbuffer
+ i
* 40, 40,
795 memcpy(q
->formant_mem
, q
->formant_mem
+ 160, 10 * sizeof(float));
797 // FIXME: postfilter and final gain control should be here.
798 // TIA/EIA/IS-733 2.4.8.6
800 formant_mem
= q
->formant_mem
+ 10;
802 *outbuffer
++ = av_clipf(*formant_mem
++, QCELP_CLIP_LOWER_BOUND
,
803 QCELP_CLIP_UPPER_BOUND
);
805 memcpy(q
->prev_lspf
, quantized_lspf
, sizeof(q
->prev_lspf
));
806 q
->prev_bitrate
= q
->bitrate
;
808 *data_size
= 160 * sizeof(*outbuffer
);
813 AVCodec qcelp_decoder
=
816 .type
= CODEC_TYPE_AUDIO
,
817 .id
= CODEC_ID_QCELP
,
818 .init
= qcelp_decode_init
,
819 .decode
= qcelp_decode_frame
,
820 .priv_data_size
= sizeof(QCELPContext
),
821 .long_name
= NULL_IF_CONFIG_SMALL("QCELP / PureVoice"),