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 
30 #include "avcodec.h"
31 #include "audio_frame_queue.h"
32 #include "celp_filters.h"
33 #include "internal.h"
34 #include "mathops.h"
35 #include "put_bits.h"
36 #include "ra144.h"
37 
39 {
40  RA144Context *ractx = avctx->priv_data;
41  ff_lpc_end(&ractx->lpc_ctx);
42  ff_af_queue_close(&ractx->afq);
43  return 0;
44 }
45 
46 
48 {
49  RA144Context *ractx;
50  int ret;
51 
52  if (avctx->channels != 1) {
53  av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n",
54  avctx->channels);
55  return -1;
56  }
57  avctx->frame_size = NBLOCKS * BLOCKSIZE;
58  avctx->initial_padding = avctx->frame_size;
59  avctx->bit_rate = 8000;
60  ractx = avctx->priv_data;
61  ractx->lpc_coef[0] = ractx->lpc_tables[0];
62  ractx->lpc_coef[1] = ractx->lpc_tables[1];
63  ractx->avctx = avctx;
64  ff_audiodsp_init(&ractx->adsp);
65  ret = ff_lpc_init(&ractx->lpc_ctx, avctx->frame_size, LPC_ORDER,
67  if (ret < 0)
68  goto error;
69 
70  ff_af_queue_init(avctx, &ractx->afq);
71 
72  return 0;
73 error:
74  ra144_encode_close(avctx);
75  return ret;
76 }
77 
78 
79 /**
80  * Quantize a value by searching a sorted table for the element with the
81  * nearest value
82  *
83  * @param value value to quantize
84  * @param table array containing the quantization table
85  * @param size size of the quantization table
86  * @return index of the quantization table corresponding to the element with the
87  * nearest value
88  */
89 static int quantize(int value, const int16_t *table, unsigned int size)
90 {
91  unsigned int low = 0, high = size - 1;
92 
93  while (1) {
94  int index = (low + high) >> 1;
95  int error = table[index] - value;
96 
97  if (index == low)
98  return table[high] + error > value ? low : high;
99  if (error > 0) {
100  high = index;
101  } else {
102  low = index;
103  }
104  }
105 }
106 
107 
108 /**
109  * Orthogonalize a vector to another vector
110  *
111  * @param v vector to orthogonalize
112  * @param u vector against which orthogonalization is performed
113  */
114 static void orthogonalize(float *v, const float *u)
115 {
116  int i;
117  float num = 0, den = 0;
118 
119  for (i = 0; i < BLOCKSIZE; i++) {
120  num += v[i] * u[i];
121  den += u[i] * u[i];
122  }
123  num /= den;
124  for (i = 0; i < BLOCKSIZE; i++)
125  v[i] -= num * u[i];
126 }
127 
128 
129 /**
130  * Calculate match score and gain of an LPC-filtered vector with respect to
131  * input data, possibly orthogonalizing it to up to two other vectors.
132  *
133  * @param work array used to calculate the filtered vector
134  * @param coefs coefficients of the LPC filter
135  * @param vect original vector
136  * @param ortho1 first vector against which orthogonalization is performed
137  * @param ortho2 second vector against which orthogonalization is performed
138  * @param data input data
139  * @param score pointer to variable where match score is returned
140  * @param gain pointer to variable where gain is returned
141  */
142 static void get_match_score(float *work, const float *coefs, float *vect,
143  const float *ortho1, const float *ortho2,
144  const float *data, float *score, float *gain)
145 {
146  float c, g;
147  int i;
148 
149  ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER);
150  if (ortho1)
151  orthogonalize(work, ortho1);
152  if (ortho2)
153  orthogonalize(work, ortho2);
154  c = g = 0;
155  for (i = 0; i < BLOCKSIZE; i++) {
156  g += work[i] * work[i];
157  c += data[i] * work[i];
158  }
159  if (c <= 0) {
160  *score = 0;
161  return;
162  }
163  *gain = c / g;
164  *score = *gain * c;
165 }
166 
167 
168 /**
169  * Create a vector from the adaptive codebook at a given lag value
170  *
171  * @param vect array where vector is stored
172  * @param cb adaptive codebook
173  * @param lag lag value
174  */
175 static void create_adapt_vect(float *vect, const int16_t *cb, int lag)
176 {
177  int i;
178 
179  cb += BUFFERSIZE - lag;
180  for (i = 0; i < FFMIN(BLOCKSIZE, lag); i++)
181  vect[i] = cb[i];
182  if (lag < BLOCKSIZE)
183  for (i = 0; i < BLOCKSIZE - lag; i++)
184  vect[lag + i] = cb[i];
185 }
186 
187 
188 /**
189  * Search the adaptive codebook for the best entry and gain and remove its
190  * contribution from input data
191  *
192  * @param adapt_cb array from which the adaptive codebook is extracted
193  * @param work array used to calculate LPC-filtered vectors
194  * @param coefs coefficients of the LPC filter
195  * @param data input data
196  * @return index of the best entry of the adaptive codebook
197  */
198 static int adaptive_cb_search(const int16_t *adapt_cb, float *work,
199  const float *coefs, float *data)
200 {
201  int i, av_uninit(best_vect);
202  float score, gain, best_score, av_uninit(best_gain);
203  float exc[BLOCKSIZE];
204 
205  gain = best_score = 0;
206  for (i = BLOCKSIZE / 2; i <= BUFFERSIZE; i++) {
207  create_adapt_vect(exc, adapt_cb, i);
208  get_match_score(work, coefs, exc, NULL, NULL, data, &score, &gain);
209  if (score > best_score) {
210  best_score = score;
211  best_vect = i;
212  best_gain = gain;
213  }
214  }
215  if (!best_score)
216  return 0;
217 
218  /**
219  * Re-calculate the filtered vector from the vector with maximum match score
220  * and remove its contribution from input data.
221  */
222  create_adapt_vect(exc, adapt_cb, best_vect);
224  for (i = 0; i < BLOCKSIZE; i++)
225  data[i] -= best_gain * work[i];
226  return best_vect - BLOCKSIZE / 2 + 1;
227 }
228 
229 
230 /**
231  * Find the best vector of a fixed codebook by applying an LPC filter to
232  * codebook entries, possibly orthogonalizing them to up to two other vectors
233  * and matching the results with input data.
234  *
235  * @param work array used to calculate the filtered vectors
236  * @param coefs coefficients of the LPC filter
237  * @param cb fixed codebook
238  * @param ortho1 first vector against which orthogonalization is performed
239  * @param ortho2 second vector against which orthogonalization is performed
240  * @param data input data
241  * @param idx pointer to variable where the index of the best codebook entry is
242  * returned
243  * @param gain pointer to variable where the gain of the best codebook entry is
244  * returned
245  */
246 static void find_best_vect(float *work, const float *coefs,
247  const int8_t cb[][BLOCKSIZE], const float *ortho1,
248  const float *ortho2, float *data, int *idx,
249  float *gain)
250 {
251  int i, j;
252  float g, score, best_score;
253  float vect[BLOCKSIZE];
254 
255  *idx = *gain = best_score = 0;
256  for (i = 0; i < FIXED_CB_SIZE; i++) {
257  for (j = 0; j < BLOCKSIZE; j++)
258  vect[j] = cb[i][j];
259  get_match_score(work, coefs, vect, ortho1, ortho2, data, &score, &g);
260  if (score > best_score) {
261  best_score = score;
262  *idx = i;
263  *gain = g;
264  }
265  }
266 }
267 
268 
269 /**
270  * Search the two fixed codebooks for the best entry and gain
271  *
272  * @param work array used to calculate LPC-filtered vectors
273  * @param coefs coefficients of the LPC filter
274  * @param data input data
275  * @param cba_idx index of the best entry of the adaptive codebook
276  * @param cb1_idx pointer to variable where the index of the best entry of the
277  * first fixed codebook is returned
278  * @param cb2_idx pointer to variable where the index of the best entry of the
279  * second fixed codebook is returned
280  */
281 static void fixed_cb_search(float *work, const float *coefs, float *data,
282  int cba_idx, int *cb1_idx, int *cb2_idx)
283 {
284  int i, ortho_cb1;
285  float gain;
286  float cba_vect[BLOCKSIZE], cb1_vect[BLOCKSIZE];
287  float vect[BLOCKSIZE];
288 
289  /**
290  * The filtered vector from the adaptive codebook can be retrieved from
291  * work, because this function is called just after adaptive_cb_search().
292  */
293  if (cba_idx)
294  memcpy(cba_vect, work, sizeof(cba_vect));
295 
296  find_best_vect(work, coefs, ff_cb1_vects, cba_idx ? cba_vect : NULL, NULL,
297  data, cb1_idx, &gain);
298 
299  /**
300  * Re-calculate the filtered vector from the vector with maximum match score
301  * and remove its contribution from input data.
302  */
303  if (gain) {
304  for (i = 0; i < BLOCKSIZE; i++)
305  vect[i] = ff_cb1_vects[*cb1_idx][i];
306  ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER);
307  if (cba_idx)
308  orthogonalize(work, cba_vect);
309  for (i = 0; i < BLOCKSIZE; i++)
310  data[i] -= gain * work[i];
311  memcpy(cb1_vect, work, sizeof(cb1_vect));
312  ortho_cb1 = 1;
313  } else
314  ortho_cb1 = 0;
315 
316  find_best_vect(work, coefs, ff_cb2_vects, cba_idx ? cba_vect : NULL,
317  ortho_cb1 ? cb1_vect : NULL, data, cb2_idx, &gain);
318 }
319 
320 
321 /**
322  * Encode a subblock of the current frame
323  *
324  * @param ractx encoder context
325  * @param sblock_data input data of the subblock
326  * @param lpc_coefs coefficients of the LPC filter
327  * @param rms RMS of the reflection coefficients
328  * @param pb pointer to PutBitContext of the current frame
329  */
331  const int16_t *sblock_data,
332  const int16_t *lpc_coefs, unsigned int rms,
333  PutBitContext *pb)
334 {
335  float data[BLOCKSIZE] = { 0 }, work[LPC_ORDER + BLOCKSIZE];
336  float coefs[LPC_ORDER];
337  float zero[BLOCKSIZE], cba[BLOCKSIZE], cb1[BLOCKSIZE], cb2[BLOCKSIZE];
338  int cba_idx, cb1_idx, cb2_idx, gain;
339  int i, n;
340  unsigned m[3];
341  float g[3];
342  float error, best_error;
343 
344  for (i = 0; i < LPC_ORDER; i++) {
345  work[i] = ractx->curr_sblock[BLOCKSIZE + i];
346  coefs[i] = lpc_coefs[i] * (1/4096.0);
347  }
348 
349  /**
350  * Calculate the zero-input response of the LPC filter and subtract it from
351  * input data.
352  */
353  ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, data, BLOCKSIZE,
354  LPC_ORDER);
355  for (i = 0; i < BLOCKSIZE; i++) {
356  zero[i] = work[LPC_ORDER + i];
357  data[i] = sblock_data[i] - zero[i];
358  }
359 
360  /**
361  * Codebook search is performed without taking into account the contribution
362  * of the previous subblock, since it has been just subtracted from input
363  * data.
364  */
365  memset(work, 0, LPC_ORDER * sizeof(*work));
366 
367  cba_idx = adaptive_cb_search(ractx->adapt_cb, work + LPC_ORDER, coefs,
368  data);
369  if (cba_idx) {
370  /**
371  * The filtered vector from the adaptive codebook can be retrieved from
372  * work, see implementation of adaptive_cb_search().
373  */
374  memcpy(cba, work + LPC_ORDER, sizeof(cba));
375 
376  ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);
377  m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * rms) >> 12;
378  }
379  fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx);
380  for (i = 0; i < BLOCKSIZE; i++) {
381  cb1[i] = ff_cb1_vects[cb1_idx][i];
382  cb2[i] = ff_cb2_vects[cb2_idx][i];
383  }
384  ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb1, BLOCKSIZE,
385  LPC_ORDER);
386  memcpy(cb1, work + LPC_ORDER, sizeof(cb1));
387  m[1] = (ff_cb1_base[cb1_idx] * rms) >> 8;
388  ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb2, BLOCKSIZE,
389  LPC_ORDER);
390  memcpy(cb2, work + LPC_ORDER, sizeof(cb2));
391  m[2] = (ff_cb2_base[cb2_idx] * rms) >> 8;
392  best_error = FLT_MAX;
393  gain = 0;
394  for (n = 0; n < 256; n++) {
395  g[1] = ((ff_gain_val_tab[n][1] * m[1]) >> ff_gain_exp_tab[n]) *
396  (1/4096.0);
397  g[2] = ((ff_gain_val_tab[n][2] * m[2]) >> ff_gain_exp_tab[n]) *
398  (1/4096.0);
399  error = 0;
400  if (cba_idx) {
401  g[0] = ((ff_gain_val_tab[n][0] * m[0]) >> ff_gain_exp_tab[n]) *
402  (1/4096.0);
403  for (i = 0; i < BLOCKSIZE; i++) {
404  data[i] = zero[i] + g[0] * cba[i] + g[1] * cb1[i] +
405  g[2] * cb2[i];
406  error += (data[i] - sblock_data[i]) *
407  (data[i] - sblock_data[i]);
408  }
409  } else {
410  for (i = 0; i < BLOCKSIZE; i++) {
411  data[i] = zero[i] + g[1] * cb1[i] + g[2] * cb2[i];
412  error += (data[i] - sblock_data[i]) *
413  (data[i] - sblock_data[i]);
414  }
415  }
416  if (error < best_error) {
417  best_error = error;
418  gain = n;
419  }
420  }
421  put_bits(pb, 7, cba_idx);
422  put_bits(pb, 8, gain);
423  put_bits(pb, 7, cb1_idx);
424  put_bits(pb, 7, cb2_idx);
425  ff_subblock_synthesis(ractx, lpc_coefs, cba_idx, cb1_idx, cb2_idx, rms,
426  gain);
427 }
428 
429 
430 static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
431  const AVFrame *frame, int *got_packet_ptr)
432 {
433  static const uint8_t sizes[LPC_ORDER] = {64, 32, 32, 16, 16, 8, 8, 8, 8, 4};
434  static const uint8_t bit_sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
435  RA144Context *ractx = avctx->priv_data;
436  PutBitContext pb;
437  int32_t lpc_data[NBLOCKS * BLOCKSIZE];
438  int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER];
439  int shift[LPC_ORDER];
440  int16_t block_coefs[NBLOCKS][LPC_ORDER];
441  int lpc_refl[LPC_ORDER]; /**< reflection coefficients of the frame */
442  unsigned int refl_rms[NBLOCKS]; /**< RMS of the reflection coefficients */
443  const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;
444  int energy = 0;
445  int i, idx, ret;
446 
447  if (ractx->last_frame)
448  return 0;
449 
450  if ((ret = ff_alloc_packet2(avctx, avpkt, FRAME_SIZE, 0)) < 0)
451  return ret;
452 
453  /**
454  * Since the LPC coefficients are calculated on a frame centered over the
455  * fourth subframe, to encode a given frame, data from the next frame is
456  * needed. In each call to this function, the previous frame (whose data are
457  * saved in the encoder context) is encoded, and data from the current frame
458  * are saved in the encoder context to be used in the next function call.
459  */
460  for (i = 0; i < (2 * BLOCKSIZE + BLOCKSIZE / 2); i++) {
461  lpc_data[i] = ractx->curr_block[BLOCKSIZE + BLOCKSIZE / 2 + i];
462  energy += (lpc_data[i] * lpc_data[i]) >> 4;
463  }
464  if (frame) {
465  int j;
466  for (j = 0; j < frame->nb_samples && i < NBLOCKS * BLOCKSIZE; i++, j++) {
467  lpc_data[i] = samples[j] >> 2;
468  energy += (lpc_data[i] * lpc_data[i]) >> 4;
469  }
470  }
471  if (i < NBLOCKS * BLOCKSIZE)
472  memset(&lpc_data[i], 0, (NBLOCKS * BLOCKSIZE - i) * sizeof(*lpc_data));
473  energy = ff_energy_tab[quantize(ff_t_sqrt(energy >> 5) >> 10, ff_energy_tab,
474  32)];
475 
476  ff_lpc_calc_coefs(&ractx->lpc_ctx, lpc_data, NBLOCKS * BLOCKSIZE, LPC_ORDER,
477  LPC_ORDER, 16, lpc_coefs, shift, FF_LPC_TYPE_LEVINSON,
478  0, ORDER_METHOD_EST, 0, 12, 0);
479  for (i = 0; i < LPC_ORDER; i++)
480  block_coefs[NBLOCKS - 1][i] = -(lpc_coefs[LPC_ORDER - 1][i] <<
481  (12 - shift[LPC_ORDER - 1]));
482 
483  /**
484  * TODO: apply perceptual weighting of the input speech through bandwidth
485  * expansion of the LPC filter.
486  */
487 
488  if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
489  /**
490  * The filter is unstable: use the coefficients of the previous frame.
491  */
492  ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]);
493  if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
494  /* the filter is still unstable. set reflection coeffs to zero. */
495  memset(lpc_refl, 0, sizeof(lpc_refl));
496  }
497  }
498  init_put_bits(&pb, avpkt->data, avpkt->size);
499  for (i = 0; i < LPC_ORDER; i++) {
500  idx = quantize(lpc_refl[i], ff_lpc_refl_cb[i], sizes[i]);
501  put_bits(&pb, bit_sizes[i], idx);
502  lpc_refl[i] = ff_lpc_refl_cb[i][idx];
503  }
504  ractx->lpc_refl_rms[0] = ff_rms(lpc_refl);
505  ff_eval_coefs(ractx->lpc_coef[0], lpc_refl);
506  refl_rms[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy);
507  refl_rms[1] = ff_interp(ractx, block_coefs[1], 2,
508  energy <= ractx->old_energy,
509  ff_t_sqrt(energy * ractx->old_energy) >> 12);
510  refl_rms[2] = ff_interp(ractx, block_coefs[2], 3, 0, energy);
511  refl_rms[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], energy);
512  ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[0]);
513  put_bits(&pb, 5, quantize(energy, ff_energy_tab, 32));
514  for (i = 0; i < NBLOCKS; i++)
515  ra144_encode_subblock(ractx, ractx->curr_block + i * BLOCKSIZE,
516  block_coefs[i], refl_rms[i], &pb);
517  flush_put_bits(&pb);
518  ractx->old_energy = energy;
519  ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0];
520  FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);
521 
522  /* copy input samples to current block for processing in next call */
523  i = 0;
524  if (frame) {
525  for (; i < frame->nb_samples; i++)
526  ractx->curr_block[i] = samples[i] >> 2;
527 
528  if ((ret = ff_af_queue_add(&ractx->afq, frame)) < 0)
529  return ret;
530  } else
531  ractx->last_frame = 1;
532  memset(&ractx->curr_block[i], 0,
533  (NBLOCKS * BLOCKSIZE - i) * sizeof(*ractx->curr_block));
534 
535  /* Get the next frame pts/duration */
536  ff_af_queue_remove(&ractx->afq, avctx->frame_size, &avpkt->pts,
537  &avpkt->duration);
538 
539  avpkt->size = FRAME_SIZE;
540  *got_packet_ptr = 1;
541  return 0;
542 }
543 
544 
546  .name = "real_144",
547  .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
548  .type = AVMEDIA_TYPE_AUDIO,
549  .id = AV_CODEC_ID_RA_144,
550  .priv_data_size = sizeof(RA144Context),
552  .encode2 = ra144_encode_frame,
553  .close = ra144_encode_close,
555  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
557  .supported_samplerates = (const int[]){ 8000, 0 },
558  .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, 0 },
559 };
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
#define NULL
Definition: coverity.c:32
unsigned int lpc_tables[2][10]
Definition: ra144.h:46
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:84
static int shift(int a, int b)
Definition: sonic.c:82
int ff_t_sqrt(unsigned int x)
Evaluate sqrt(x << 24).
Definition: ra144.c:1625
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
const int16_t *const ff_lpc_refl_cb[10]
Definition: ra144.c:1502
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:45
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:198
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
#define MAX_LPC_ORDER
Definition: lpc.h:38
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:89
int size
Definition: avcodec.h:1481
static av_cold int ra144_encode_close(AVCodecContext *avctx)
Definition: ra144enc.c:38
int16_t adapt_cb[146+2]
Adaptive codebook, its size is two units bigger to avoid a buffer overflow.
Definition: ra144.h:61
static void orthogonalize(float *v, const float *u)
Orthogonalize a vector to another vector.
Definition: ra144enc.c:114
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, possibly orthogonalizing it to up to two other vectors.
Definition: ra144enc.c:142
AVCodec.
Definition: avcodec.h:3492
AVCodec ff_ra_144_encoder
Definition: ra144enc.c:545
static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: ra144enc.c:430
#define NBLOCKS
number of subblocks within a block
Definition: ra144.h:30
#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: avcodec.h:1009
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:139
uint8_t
#define av_cold
Definition: attributes.h:82
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
#define FRAME_SIZE
unsigned int lpc_refl_rms[2]
Definition: ra144.h:52
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
#define LPC_ORDER
Definition: g723_1.h:40
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1498
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
unsigned int ff_rms(const int *data)
Definition: ra144.c:1636
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
#define FIXED_CB_SIZE
size of fixed codebooks
Definition: ra144.h:33
uint8_t * data
Definition: avcodec.h:1480
const uint16_t ff_cb2_base[128]
Definition: ra144.c:1421
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
AVCodecContext * avctx
Definition: ra144.h:38
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:50
static const int sizes[][2]
Definition: img2dec.c:53
const int8_t ff_cb1_vects[128][40]
Definition: ra144.c:114
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int initial_padding
Audio only.
Definition: avcodec.h:3099
#define zero
Definition: regdef.h:64
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
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:281
AudioFrameQueue afq
Definition: ra144.h:41
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:322
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:1014
#define FFMIN(a, b)
Definition: common.h:96
int ff_interp(RA144Context *ractx, int16_t *out, int a, int copyold, int energy)
Definition: ra144.c:1657
int32_t
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
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
int n
Definition: avisynth_c.h:760
int last_frame
Definition: ra144.h:42
void ff_int_to_int16(int16_t *out, const int *inp)
Definition: ra144.c:1613
static void error(const char *err)
const int16_t ff_gain_val_tab[256][3]
Definition: ra144.c:28
if(ret)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2248
#define BLOCKSIZE
subblock size in 16-bit words
Definition: ra144.h:31
void ff_eval_coefs(int *coefs, const int *refl)
Evaluate the LPC filter coefficients from the reflection coefficients.
Definition: ra144.c:1593
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
main external API structure.
Definition: avcodec.h:1568
static av_cold int ra144_encode_init(AVCodecContext *avctx)
Definition: ra144enc.c:47
Levinson-Durbin recursion.
Definition: lpc.h:47
#define ORDER_METHOD_EST
Definition: lpc.h:30
LPCContext lpc_ctx
Definition: ra144.h:40
int index
Definition: gxfenc.c:89
int16_t buffer_a[FFALIGN(BLOCKSIZE, 16)]
Definition: ra144.h:63
int ff_eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx)
Evaluate the reflection coefficients from the filter coefficients.
Definition: ra144.c:1545
#define BUFFERSIZE
the size of the adaptive codebook
Definition: ra144.h:32
unsigned int ff_rescale_rms(unsigned int rms, unsigned int energy)
Definition: ra144.c:1678
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:200
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
Definition: lpc.c:300
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
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, possibly orthogonalizing them to up to two other vectors and matching the results with input data.
Definition: ra144enc.c:246
const int8_t ff_cb2_vects[128][40]
Definition: ra144.c:758
AudioDSPContext adsp
Definition: ra144.h:39
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
unsigned int old_energy
previous frame energy
Definition: ra144.h:44
const int16_t ff_energy_tab[32]
Definition: ra144.c:1440
signed 16 bits
Definition: samplefmt.h:61
const uint8_t ff_gain_exp_tab[256]
Definition: ra144.c:95
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
int16_t curr_sblock[50]
The current subblock padded by the last 10 values of the previous one.
Definition: ra144.h:57
void * priv_data
Definition: avcodec.h:1595
int channels
number of audio channels
Definition: avcodec.h:2229
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define av_uninit(x)
Definition: attributes.h:148
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
Filter the word “frame” indicates either a video frame or a group of audio samples
const uint16_t ff_cb1_base[128]
Definition: ra144.c:1402
int16_t curr_block[NBLOCKS *BLOCKSIZE]
Definition: ra144.h:54
#define FFSWAP(type, a, b)
Definition: common.h:99
int ff_irms(AudioDSPContext *adsp, const int16_t *data)
inverse root mean square
Definition: ra144.c:1684
#define AV_CH_LAYOUT_MONO
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:175
This structure stores compressed data.
Definition: avcodec.h:1457
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
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:330
bitstream writer API