FFmpeg
ra144enc.c
Go to the documentation of this file.
1 /*
2  * Real Audio 1.0 (14.4K) encoder
3  * Copyright (c) 2010 Francesco Lavra <francescolavra@interfree.it>
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21 
22 /**
23  * @file
24  * Real Audio 1.0 (14.4K) encoder
25  * @author Francesco Lavra <francescolavra@interfree.it>
26  */
27 
28 #include <float.h>
29 
31 #include "avcodec.h"
32 #include "audio_frame_queue.h"
33 #include "celp_filters.h"
34 #include "encode.h"
35 #include "internal.h"
36 #include "mathops.h"
37 #include "put_bits.h"
38 #include "ra144.h"
39 
41 {
42  RA144Context *ractx = avctx->priv_data;
43  ff_lpc_end(&ractx->lpc_ctx);
44  ff_af_queue_close(&ractx->afq);
45  return 0;
46 }
47 
48 
50 {
51  RA144Context *ractx;
52  int ret;
53 
54  if (avctx->channels != 1) {
55  av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n",
56  avctx->channels);
57  return -1;
58  }
59  avctx->frame_size = NBLOCKS * BLOCKSIZE;
60  avctx->initial_padding = avctx->frame_size;
61  avctx->bit_rate = 8000;
62  ractx = avctx->priv_data;
63  ractx->lpc_coef[0] = ractx->lpc_tables[0];
64  ractx->lpc_coef[1] = ractx->lpc_tables[1];
65  ractx->avctx = avctx;
66  ff_audiodsp_init(&ractx->adsp);
67  ret = ff_lpc_init(&ractx->lpc_ctx, avctx->frame_size, LPC_ORDER,
69  if (ret < 0)
70  return ret;
71 
72  ff_af_queue_init(avctx, &ractx->afq);
73 
74  return 0;
75 }
76 
77 
78 /**
79  * Quantize a value by searching a sorted table for the element with the
80  * nearest value
81  *
82  * @param value value to quantize
83  * @param table array containing the quantization table
84  * @param size size of the quantization table
85  * @return index of the quantization table corresponding to the element with the
86  * nearest value
87  */
88 static int quantize(int value, const int16_t *table, unsigned int size)
89 {
90  unsigned int low = 0, high = size - 1;
91 
92  while (1) {
93  int index = (low + high) >> 1;
94  int error = table[index] - value;
95 
96  if (index == low)
97  return table[high] + error > value ? low : high;
98  if (error > 0) {
99  high = index;
100  } else {
101  low = index;
102  }
103  }
104 }
105 
106 
107 /**
108  * Orthogonalize a vector to another vector
109  *
110  * @param v vector to orthogonalize
111  * @param u vector against which orthogonalization is performed
112  */
113 static void orthogonalize(float *v, const float *u)
114 {
115  int i;
116  float num = 0, den = 0;
117 
118  for (i = 0; i < BLOCKSIZE; i++) {
119  num += v[i] * u[i];
120  den += u[i] * u[i];
121  }
122  num /= den;
123  for (i = 0; i < BLOCKSIZE; i++)
124  v[i] -= num * u[i];
125 }
126 
127 
128 /**
129  * Calculate match score and gain of an LPC-filtered vector with respect to
130  * input data, possibly orthogonalizing it to up to two other vectors.
131  *
132  * @param work array used to calculate the filtered vector
133  * @param coefs coefficients of the LPC filter
134  * @param vect original vector
135  * @param ortho1 first vector against which orthogonalization is performed
136  * @param ortho2 second vector against which orthogonalization is performed
137  * @param data input data
138  * @param score pointer to variable where match score is returned
139  * @param gain pointer to variable where gain is returned
140  */
141 static void get_match_score(float *work, const float *coefs, float *vect,
142  const float *ortho1, const float *ortho2,
143  const float *data, float *score, float *gain)
144 {
145  float c, g;
146  int i;
147 
149  if (ortho1)
150  orthogonalize(work, ortho1);
151  if (ortho2)
152  orthogonalize(work, ortho2);
153  c = g = 0;
154  for (i = 0; i < BLOCKSIZE; i++) {
155  g += work[i] * work[i];
156  c += data[i] * work[i];
157  }
158  if (c <= 0) {
159  *score = 0;
160  return;
161  }
162  *gain = c / g;
163  *score = *gain * c;
164 }
165 
166 
167 /**
168  * Create a vector from the adaptive codebook at a given lag value
169  *
170  * @param vect array where vector is stored
171  * @param cb adaptive codebook
172  * @param lag lag value
173  */
174 static void create_adapt_vect(float *vect, const int16_t *cb, int lag)
175 {
176  int i;
177 
178  cb += BUFFERSIZE - lag;
179  for (i = 0; i < FFMIN(BLOCKSIZE, lag); i++)
180  vect[i] = cb[i];
181  if (lag < BLOCKSIZE)
182  for (i = 0; i < BLOCKSIZE - lag; i++)
183  vect[lag + i] = cb[i];
184 }
185 
186 
187 /**
188  * Search the adaptive codebook for the best entry and gain and remove its
189  * contribution from input data
190  *
191  * @param adapt_cb array from which the adaptive codebook is extracted
192  * @param work array used to calculate LPC-filtered vectors
193  * @param coefs coefficients of the LPC filter
194  * @param data input data
195  * @return index of the best entry of the adaptive codebook
196  */
197 static int adaptive_cb_search(const int16_t *adapt_cb, float *work,
198  const float *coefs, float *data)
199 {
200  int i, av_uninit(best_vect);
201  float score, gain, best_score, av_uninit(best_gain);
202  float exc[BLOCKSIZE];
203 
204  gain = best_score = 0;
205  for (i = BLOCKSIZE / 2; i <= BUFFERSIZE; i++) {
206  create_adapt_vect(exc, adapt_cb, i);
207  get_match_score(work, coefs, exc, NULL, NULL, data, &score, &gain);
208  if (score > best_score) {
209  best_score = score;
210  best_vect = i;
211  best_gain = gain;
212  }
213  }
214  if (!best_score)
215  return 0;
216 
217  /**
218  * Re-calculate the filtered vector from the vector with maximum match score
219  * and remove its contribution from input data.
220  */
221  create_adapt_vect(exc, adapt_cb, best_vect);
223  for (i = 0; i < BLOCKSIZE; i++)
224  data[i] -= best_gain * work[i];
225  return best_vect - BLOCKSIZE / 2 + 1;
226 }
227 
228 
229 /**
230  * Find the best vector of a fixed codebook by applying an LPC filter to
231  * codebook entries, possibly orthogonalizing them to up to two other vectors
232  * and matching the results with input data.
233  *
234  * @param work array used to calculate the filtered vectors
235  * @param coefs coefficients of the LPC filter
236  * @param cb fixed codebook
237  * @param ortho1 first vector against which orthogonalization is performed
238  * @param ortho2 second vector against which orthogonalization is performed
239  * @param data input data
240  * @param idx pointer to variable where the index of the best codebook entry is
241  * returned
242  * @param gain pointer to variable where the gain of the best codebook entry is
243  * returned
244  */
245 static void find_best_vect(float *work, const float *coefs,
246  const int8_t cb[][BLOCKSIZE], const float *ortho1,
247  const float *ortho2, float *data, int *idx,
248  float *gain)
249 {
250  int i, j;
251  float g, score, best_score;
252  float vect[BLOCKSIZE];
253 
254  *idx = *gain = best_score = 0;
255  for (i = 0; i < FIXED_CB_SIZE; i++) {
256  for (j = 0; j < BLOCKSIZE; j++)
257  vect[j] = cb[i][j];
258  get_match_score(work, coefs, vect, ortho1, ortho2, data, &score, &g);
259  if (score > best_score) {
260  best_score = score;
261  *idx = i;
262  *gain = g;
263  }
264  }
265 }
266 
267 
268 /**
269  * Search the two fixed codebooks for the best entry and gain
270  *
271  * @param work array used to calculate LPC-filtered vectors
272  * @param coefs coefficients of the LPC filter
273  * @param data input data
274  * @param cba_idx index of the best entry of the adaptive codebook
275  * @param cb1_idx pointer to variable where the index of the best entry of the
276  * first fixed codebook is returned
277  * @param cb2_idx pointer to variable where the index of the best entry of the
278  * second fixed codebook is returned
279  */
280 static void fixed_cb_search(float *work, const float *coefs, float *data,
281  int cba_idx, int *cb1_idx, int *cb2_idx)
282 {
283  int i, ortho_cb1;
284  float gain;
285  float cba_vect[BLOCKSIZE], cb1_vect[BLOCKSIZE];
286  float vect[BLOCKSIZE];
287 
288  /**
289  * The filtered vector from the adaptive codebook can be retrieved from
290  * work, because this function is called just after adaptive_cb_search().
291  */
292  if (cba_idx)
293  memcpy(cba_vect, work, sizeof(cba_vect));
294 
295  find_best_vect(work, coefs, ff_cb1_vects, cba_idx ? cba_vect : NULL, NULL,
296  data, cb1_idx, &gain);
297 
298  /**
299  * Re-calculate the filtered vector from the vector with maximum match score
300  * and remove its contribution from input data.
301  */
302  if (gain) {
303  for (i = 0; i < BLOCKSIZE; i++)
304  vect[i] = ff_cb1_vects[*cb1_idx][i];
306  if (cba_idx)
307  orthogonalize(work, cba_vect);
308  for (i = 0; i < BLOCKSIZE; i++)
309  data[i] -= gain * work[i];
310  memcpy(cb1_vect, work, sizeof(cb1_vect));
311  ortho_cb1 = 1;
312  } else
313  ortho_cb1 = 0;
314 
315  find_best_vect(work, coefs, ff_cb2_vects, cba_idx ? cba_vect : NULL,
316  ortho_cb1 ? cb1_vect : NULL, data, cb2_idx, &gain);
317 }
318 
319 
320 /**
321  * Encode a subblock of the current frame
322  *
323  * @param ractx encoder context
324  * @param sblock_data input data of the subblock
325  * @param lpc_coefs coefficients of the LPC filter
326  * @param rms RMS of the reflection coefficients
327  * @param pb pointer to PutBitContext of the current frame
328  */
330  const int16_t *sblock_data,
331  const int16_t *lpc_coefs, unsigned int rms,
332  PutBitContext *pb)
333 {
334  float data[BLOCKSIZE] = { 0 }, work[LPC_ORDER + BLOCKSIZE];
335  float coefs[LPC_ORDER];
336  float zero[BLOCKSIZE], cba[BLOCKSIZE], cb1[BLOCKSIZE], cb2[BLOCKSIZE];
337  int cba_idx, cb1_idx, cb2_idx, gain;
338  int i, n;
339  unsigned m[3];
340  float g[3];
341  float error, best_error;
342 
343  for (i = 0; i < LPC_ORDER; i++) {
344  work[i] = ractx->curr_sblock[BLOCKSIZE + i];
345  coefs[i] = lpc_coefs[i] * (1/4096.0);
346  }
347 
348  /**
349  * Calculate the zero-input response of the LPC filter and subtract it from
350  * input data.
351  */
353  LPC_ORDER);
354  for (i = 0; i < BLOCKSIZE; i++) {
355  zero[i] = work[LPC_ORDER + i];
356  data[i] = sblock_data[i] - zero[i];
357  }
358 
359  /**
360  * Codebook search is performed without taking into account the contribution
361  * of the previous subblock, since it has been just subtracted from input
362  * data.
363  */
364  memset(work, 0, LPC_ORDER * sizeof(*work));
365 
366  cba_idx = adaptive_cb_search(ractx->adapt_cb, work + LPC_ORDER, coefs,
367  data);
368  if (cba_idx) {
369  /**
370  * The filtered vector from the adaptive codebook can be retrieved from
371  * work, see implementation of adaptive_cb_search().
372  */
373  memcpy(cba, work + LPC_ORDER, sizeof(cba));
374 
375  ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);
376  m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * rms) >> 12;
377  }
378  fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx);
379  for (i = 0; i < BLOCKSIZE; i++) {
380  cb1[i] = ff_cb1_vects[cb1_idx][i];
381  cb2[i] = ff_cb2_vects[cb2_idx][i];
382  }
384  LPC_ORDER);
385  memcpy(cb1, work + LPC_ORDER, sizeof(cb1));
386  m[1] = (ff_cb1_base[cb1_idx] * rms) >> 8;
388  LPC_ORDER);
389  memcpy(cb2, work + LPC_ORDER, sizeof(cb2));
390  m[2] = (ff_cb2_base[cb2_idx] * rms) >> 8;
391  best_error = FLT_MAX;
392  gain = 0;
393  for (n = 0; n < 256; n++) {
394  g[1] = ((ff_gain_val_tab[n][1] * m[1]) >> ff_gain_exp_tab[n]) *
395  (1/4096.0);
396  g[2] = ((ff_gain_val_tab[n][2] * m[2]) >> ff_gain_exp_tab[n]) *
397  (1/4096.0);
398  error = 0;
399  if (cba_idx) {
400  g[0] = ((ff_gain_val_tab[n][0] * m[0]) >> ff_gain_exp_tab[n]) *
401  (1/4096.0);
402  for (i = 0; i < BLOCKSIZE; i++) {
403  data[i] = zero[i] + g[0] * cba[i] + g[1] * cb1[i] +
404  g[2] * cb2[i];
405  error += (data[i] - sblock_data[i]) *
406  (data[i] - sblock_data[i]);
407  }
408  } else {
409  for (i = 0; i < BLOCKSIZE; i++) {
410  data[i] = zero[i] + g[1] * cb1[i] + g[2] * cb2[i];
411  error += (data[i] - sblock_data[i]) *
412  (data[i] - sblock_data[i]);
413  }
414  }
415  if (error < best_error) {
416  best_error = error;
417  gain = n;
418  }
419  }
420  put_bits(pb, 7, cba_idx);
421  put_bits(pb, 8, gain);
422  put_bits(pb, 7, cb1_idx);
423  put_bits(pb, 7, cb2_idx);
424  ff_subblock_synthesis(ractx, lpc_coefs, cba_idx, cb1_idx, cb2_idx, rms,
425  gain);
426 }
427 
428 
429 static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
430  const AVFrame *frame, int *got_packet_ptr)
431 {
432  static const uint8_t sizes[LPC_ORDER] = {64, 32, 32, 16, 16, 8, 8, 8, 8, 4};
433  static const uint8_t bit_sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
434  RA144Context *ractx = avctx->priv_data;
435  PutBitContext pb;
436  int32_t lpc_data[NBLOCKS * BLOCKSIZE];
437  int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER];
438  int shift[LPC_ORDER];
439  int16_t block_coefs[NBLOCKS][LPC_ORDER];
440  int lpc_refl[LPC_ORDER]; /**< reflection coefficients of the frame */
441  unsigned int refl_rms[NBLOCKS]; /**< RMS of the reflection coefficients */
442  const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;
443  int energy = 0;
444  int i, idx, ret;
445 
446  if (ractx->last_frame)
447  return 0;
448 
449  if ((ret = ff_get_encode_buffer(avctx, avpkt, FRAME_SIZE, 0)) < 0)
450  return ret;
451 
452  /**
453  * Since the LPC coefficients are calculated on a frame centered over the
454  * fourth subframe, to encode a given frame, data from the next frame is
455  * needed. In each call to this function, the previous frame (whose data are
456  * saved in the encoder context) is encoded, and data from the current frame
457  * are saved in the encoder context to be used in the next function call.
458  */
459  for (i = 0; i < (2 * BLOCKSIZE + BLOCKSIZE / 2); i++) {
460  lpc_data[i] = ractx->curr_block[BLOCKSIZE + BLOCKSIZE / 2 + i];
461  energy += (lpc_data[i] * lpc_data[i]) >> 4;
462  }
463  if (frame) {
464  int j;
465  for (j = 0; j < frame->nb_samples && i < NBLOCKS * BLOCKSIZE; i++, j++) {
466  lpc_data[i] = samples[j] >> 2;
467  energy += (lpc_data[i] * lpc_data[i]) >> 4;
468  }
469  }
470  if (i < NBLOCKS * BLOCKSIZE)
471  memset(&lpc_data[i], 0, (NBLOCKS * BLOCKSIZE - i) * sizeof(*lpc_data));
472  energy = ff_energy_tab[quantize(ff_t_sqrt(energy >> 5) >> 10, ff_energy_tab,
473  32)];
474 
475  ff_lpc_calc_coefs(&ractx->lpc_ctx, lpc_data, NBLOCKS * BLOCKSIZE, LPC_ORDER,
476  LPC_ORDER, 16, lpc_coefs, shift, FF_LPC_TYPE_LEVINSON,
477  0, ORDER_METHOD_EST, 0, 12, 0);
478  for (i = 0; i < LPC_ORDER; i++)
479  block_coefs[NBLOCKS - 1][i] = -lpc_coefs[LPC_ORDER - 1][i]
480  * (1 << (12 - shift[LPC_ORDER - 1]));
481 
482  /**
483  * TODO: apply perceptual weighting of the input speech through bandwidth
484  * expansion of the LPC filter.
485  */
486 
487  if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
488  /**
489  * The filter is unstable: use the coefficients of the previous frame.
490  */
491  ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]);
492  if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
493  /* the filter is still unstable. set reflection coeffs to zero. */
494  memset(lpc_refl, 0, sizeof(lpc_refl));
495  }
496  }
497  init_put_bits(&pb, avpkt->data, avpkt->size);
498  for (i = 0; i < LPC_ORDER; i++) {
499  idx = quantize(lpc_refl[i], ff_lpc_refl_cb[i], sizes[i]);
500  put_bits(&pb, bit_sizes[i], idx);
501  lpc_refl[i] = ff_lpc_refl_cb[i][idx];
502  }
503  ractx->lpc_refl_rms[0] = ff_rms(lpc_refl);
504  ff_eval_coefs(ractx->lpc_coef[0], lpc_refl);
505  refl_rms[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy);
506  refl_rms[1] = ff_interp(ractx, block_coefs[1], 2,
507  energy <= ractx->old_energy,
508  ff_t_sqrt(energy * ractx->old_energy) >> 12);
509  refl_rms[2] = ff_interp(ractx, block_coefs[2], 3, 0, energy);
510  refl_rms[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], energy);
511  ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[0]);
512  put_bits(&pb, 5, quantize(energy, ff_energy_tab, 32));
513  for (i = 0; i < NBLOCKS; i++)
514  ra144_encode_subblock(ractx, ractx->curr_block + i * BLOCKSIZE,
515  block_coefs[i], refl_rms[i], &pb);
516  flush_put_bits(&pb);
517  ractx->old_energy = energy;
518  ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0];
519  FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);
520 
521  /* copy input samples to current block for processing in next call */
522  i = 0;
523  if (frame) {
524  for (; i < frame->nb_samples; i++)
525  ractx->curr_block[i] = samples[i] >> 2;
526 
527  if ((ret = ff_af_queue_add(&ractx->afq, frame)) < 0)
528  return ret;
529  } else
530  ractx->last_frame = 1;
531  memset(&ractx->curr_block[i], 0,
532  (NBLOCKS * BLOCKSIZE - i) * sizeof(*ractx->curr_block));
533 
534  /* Get the next frame pts/duration */
535  ff_af_queue_remove(&ractx->afq, avctx->frame_size, &avpkt->pts,
536  &avpkt->duration);
537 
538  *got_packet_ptr = 1;
539  return 0;
540 }
541 
542 
544  .name = "real_144",
545  .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
546  .type = AVMEDIA_TYPE_AUDIO,
547  .id = AV_CODEC_ID_RA_144,
548  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
550  .priv_data_size = sizeof(RA144Context),
552  .encode2 = ra144_encode_frame,
553  .close = ra144_encode_close,
554  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
556  .supported_samplerates = (const int[]){ 8000, 0 },
557  .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, 0 },
558  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
559 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1012
AVCodec
AVCodec.
Definition: codec.h:202
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
NBLOCKS
#define NBLOCKS
number of subblocks within a block
Definition: ra144.h:33
ra144_encode_subblock
static void ra144_encode_subblock(RA144Context *ractx, const int16_t *sblock_data, const int16_t *lpc_coefs, unsigned int rms, PutBitContext *pb)
Encode a subblock of the current frame.
Definition: ra144enc.c:329
RA144Context::avctx
AVCodecContext * avctx
Definition: ra144.h:41
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
adaptive_cb_search
static int adaptive_cb_search(const int16_t *adapt_cb, float *work, const float *coefs, float *data)
Search the adaptive codebook for the best entry and gain and remove its contribution from input data.
Definition: ra144enc.c:197
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
ff_energy_tab
const int16_t ff_energy_tab[32]
Definition: ra144.c:1440
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
FRAME_SIZE
#define FRAME_SIZE
fixed_cb_search
static void fixed_cb_search(float *work, const float *coefs, float *data, int cba_idx, int *cb1_idx, int *cb2_idx)
Search the two fixed codebooks for the best entry and gain.
Definition: ra144enc.c:280
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:409
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
index
fg index
Definition: ffmpeg_filter.c:168
ff_eval_coefs
void ff_eval_coefs(int *coefs, const int *refl)
Evaluate the LPC filter coefficients from the reflection coefficients.
Definition: ra144.c:1593
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
encode.h
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:143
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
FIXED_CB_SIZE
#define FIXED_CB_SIZE
size of fixed codebooks
Definition: ra144.h:36
float.h
ff_cb2_vects
const int8_t ff_cb2_vects[128][40]
Definition: ra144.c:758
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
BUFFERSIZE
#define BUFFERSIZE
the size of the adaptive codebook
Definition: ra144.h:35
ff_celp_lp_synthesis_filterf
void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
Definition: celp_filters.c:85
ff_ra_144_encoder
const AVCodec ff_ra_144_encoder
Definition: ra144enc.c:543
get_match_score
static void get_match_score(float *work, const float *coefs, float *vect, const float *ortho1, const float *ortho2, const float *data, float *score, float *gain)
Calculate match score and gain of an LPC-filtered vector with respect to input data,...
Definition: ra144enc.c:141
RA144Context::buffer_a
int16_t buffer_a[FFALIGN(BLOCKSIZE, 16)]
Definition: ra144.h:66
ff_cb1_vects
const int8_t ff_cb1_vects[128][40]
Definition: ra144.c:114
audio_frame_queue.h
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1701
RA144Context::lpc_coef
unsigned int * lpc_coef[2]
LPC coefficients: lpc_coef[0] is the coefficients of the current frame and lpc_coef[1] of the previou...
Definition: ra144.h:53
create_adapt_vect
static void create_adapt_vect(float *vect, const int16_t *cb, int lag)
Create a vector from the adaptive codebook at a given lag value.
Definition: ra144enc.c:174
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
ff_eval_refl
int ff_eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx)
Evaluate the reflection coefficients from the filter coefficients.
Definition: ra144.c:1545
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_lpc_refl_cb
const int16_t *const ff_lpc_refl_cb[10]
Definition: ra144.c:1502
ff_irms
int ff_irms(AudioDSPContext *adsp, const int16_t *data)
inverse root mean square
Definition: ra144.c:1684
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
quantize
static int quantize(int value, const int16_t *table, unsigned int size)
Quantize a value by searching a sorted table for the element with the nearest value.
Definition: ra144enc.c:88
RA144Context::curr_block
int16_t curr_block[NBLOCKS *BLOCKSIZE]
Definition: ra144.h:57
PutBitContext
Definition: put_bits.h:49
LPC_ORDER
#define LPC_ORDER
Definition: g723_1.h:40
if
if(ret)
Definition: filter_design.txt:179
ff_rescale_rms
unsigned int ff_rescale_rms(unsigned int rms, unsigned int energy)
Definition: ra144.c:1678
ff_cb2_base
const uint16_t ff_cb2_base[128]
Definition: ra144.c:1421
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:53
RA144Context
Definition: ra144.h:40
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
work
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do and instead of the variable declarations the generated *_tables h file should be included Since that will be generated in the build the path must be i e not Makefile changes To make the automatic table creation work
Definition: tablegen.txt:66
mathops.h
RA144Context::adsp
AudioDSPContext adsp
Definition: ra144.h:42
RA144Context::lpc_tables
unsigned int lpc_tables[2][10]
Definition: ra144.h:49
celp_filters.h
ff_lpc_calc_coefs
int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)
Calculate LPC coefficients for multiple orders.
Definition: lpc.c:201
find_best_vect
static void find_best_vect(float *work, const float *coefs, const int8_t cb[][BLOCKSIZE], const float *ortho1, const float *ortho2, float *data, int *idx, float *gain)
Find the best vector of a fixed codebook by applying an LPC filter to codebook entries,...
Definition: ra144enc.c:245
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
RA144Context::curr_sblock
int16_t curr_sblock[50]
The current subblock padded by the last 10 values of the previous one.
Definition: ra144.h:60
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
MAX_LPC_ORDER
#define MAX_LPC_ORDER
Definition: lpc.h:38
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
size
int size
Definition: twinvq_data.h:10344
RA144Context::afq
AudioFrameQueue afq
Definition: ra144.h:44
ff_cb1_base
const uint16_t ff_cb1_base[128]
Definition: ra144.c:1402
ORDER_METHOD_EST
#define ORDER_METHOD_EST
Definition: lpc.h:30
ff_copy_and_dup
void ff_copy_and_dup(int16_t *target, const int16_t *source, int offset)
Copy the last offset values of *source to *target.
Definition: ra144.c:1530
ff_rms
unsigned int ff_rms(const int *data)
Definition: ra144.c:1636
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:323
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
ff_gain_val_tab
const int16_t ff_gain_val_tab[256][3]
Definition: ra144.c:28
ff_int_to_int16
void ff_int_to_int16(int16_t *out, const int *inp)
Definition: ra144.c:1613
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
RA144Context::old_energy
unsigned int old_energy
previous frame energy
Definition: ra144.h:47
ra144_encode_close
static av_cold int ra144_encode_close(AVCodecContext *avctx)
Definition: ra144enc.c:40
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
ff_subblock_synthesis
void ff_subblock_synthesis(RA144Context *ractx, const int16_t *lpc_coefs, int cba_idx, int cb1_idx, int cb2_idx, int gval, int gain)
Definition: ra144.c:1694
avcodec.h
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
ret
ret
Definition: filter_design.txt:187
orthogonalize
static void orthogonalize(float *v, const float *u)
Orthogonalize a vector to another vector.
Definition: ra144enc.c:113
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
RA144Context::adapt_cb
int16_t adapt_cb[146+2]
Adaptive codebook, its size is two units bigger to avoid a buffer overflow.
Definition: ra144.h:64
AVCodecContext
main external API structure.
Definition: avcodec.h:383
channel_layout.h
ff_t_sqrt
int ff_t_sqrt(unsigned int x)
Evaluate sqrt(x << 24).
Definition: ra144.c:1625
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
ff_interp
int ff_interp(RA144Context *ractx, int16_t *out, int a, int copyold, int energy)
Definition: ra144.c:1657
ra144.h
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ra144_encode_frame
static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: ra144enc.c:429
shift
static int shift(int a, int b)
Definition: sonic.c:83
zero
#define zero
Definition: regdef.h:64
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
RA144Context::last_frame
int last_frame
Definition: ra144.h:45
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
RA144Context::lpc_refl_rms
unsigned int lpc_refl_rms[2]
Definition: ra144.h:55
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:87
put_bits.h
BLOCKSIZE
#define BLOCKSIZE
subblock size in 16-bit words
Definition: ra144.h:34
FF_LPC_TYPE_LEVINSON
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
Definition: lpc.h:47
ff_gain_exp_tab
const uint8_t ff_gain_exp_tab[256]
Definition: ra144.c:95
ra144_encode_init
static av_cold int ra144_encode_init(AVCodecContext *avctx)
Definition: ra144enc.c:49
RA144Context::lpc_ctx
LPCContext lpc_ctx
Definition: ra144.h:43
ff_lpc_init
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
Definition: lpc.c:301