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 "codec_internal.h"
35 #include "encode.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  avctx->frame_size = NBLOCKS * BLOCKSIZE;
55  avctx->initial_padding = avctx->frame_size;
56  avctx->bit_rate = 8000;
57  ractx = avctx->priv_data;
58  ractx->lpc_coef[0] = ractx->lpc_tables[0];
59  ractx->lpc_coef[1] = ractx->lpc_tables[1];
60  ractx->avctx = avctx;
61  ff_audiodsp_init(&ractx->adsp);
62  ret = ff_lpc_init(&ractx->lpc_ctx, avctx->frame_size, LPC_ORDER,
64  if (ret < 0)
65  return ret;
66 
67  ff_af_queue_init(avctx, &ractx->afq);
68 
69  return 0;
70 }
71 
72 
73 /**
74  * Quantize a value by searching a sorted table for the element with the
75  * nearest value
76  *
77  * @param value value to quantize
78  * @param table array containing the quantization table
79  * @param size size of the quantization table
80  * @return index of the quantization table corresponding to the element with the
81  * nearest value
82  */
83 static int quantize(int value, const int16_t *table, unsigned int size)
84 {
85  unsigned int low = 0, high = size - 1;
86 
87  while (1) {
88  int index = (low + high) >> 1;
89  int error = table[index] - value;
90 
91  if (index == low)
92  return table[high] + error > value ? low : high;
93  if (error > 0) {
94  high = index;
95  } else {
96  low = index;
97  }
98  }
99 }
100 
101 
102 /**
103  * Orthogonalize a vector to another vector
104  *
105  * @param v vector to orthogonalize
106  * @param u vector against which orthogonalization is performed
107  */
108 static void orthogonalize(float *v, const float *u)
109 {
110  int i;
111  float num = 0, den = 0;
112 
113  for (i = 0; i < BLOCKSIZE; i++) {
114  num += v[i] * u[i];
115  den += u[i] * u[i];
116  }
117  num /= den;
118  for (i = 0; i < BLOCKSIZE; i++)
119  v[i] -= num * u[i];
120 }
121 
122 
123 /**
124  * Calculate match score and gain of an LPC-filtered vector with respect to
125  * input data, possibly orthogonalizing it to up to two other vectors.
126  *
127  * @param work array used to calculate the filtered vector
128  * @param coefs coefficients of the LPC filter
129  * @param vect original vector
130  * @param ortho1 first vector against which orthogonalization is performed
131  * @param ortho2 second vector against which orthogonalization is performed
132  * @param data input data
133  * @param score pointer to variable where match score is returned
134  * @param gain pointer to variable where gain is returned
135  */
136 static void get_match_score(float *work, const float *coefs, float *vect,
137  const float *ortho1, const float *ortho2,
138  const float *data, float *score, float *gain)
139 {
140  float c, g;
141  int i;
142 
144  if (ortho1)
145  orthogonalize(work, ortho1);
146  if (ortho2)
147  orthogonalize(work, ortho2);
148  c = g = 0;
149  for (i = 0; i < BLOCKSIZE; i++) {
150  g += work[i] * work[i];
151  c += data[i] * work[i];
152  }
153  if (c <= 0) {
154  *score = 0;
155  return;
156  }
157  *gain = c / g;
158  *score = *gain * c;
159 }
160 
161 
162 /**
163  * Create a vector from the adaptive codebook at a given lag value
164  *
165  * @param vect array where vector is stored
166  * @param cb adaptive codebook
167  * @param lag lag value
168  */
169 static void create_adapt_vect(float *vect, const int16_t *cb, int lag)
170 {
171  int i;
172 
173  cb += BUFFERSIZE - lag;
174  for (i = 0; i < FFMIN(BLOCKSIZE, lag); i++)
175  vect[i] = cb[i];
176  if (lag < BLOCKSIZE)
177  for (i = 0; i < BLOCKSIZE - lag; i++)
178  vect[lag + i] = cb[i];
179 }
180 
181 
182 /**
183  * Search the adaptive codebook for the best entry and gain and remove its
184  * contribution from input data
185  *
186  * @param adapt_cb array from which the adaptive codebook is extracted
187  * @param work array used to calculate LPC-filtered vectors
188  * @param coefs coefficients of the LPC filter
189  * @param data input data
190  * @return index of the best entry of the adaptive codebook
191  */
192 static int adaptive_cb_search(const int16_t *adapt_cb, float *work,
193  const float *coefs, float *data)
194 {
195  int i, av_uninit(best_vect);
196  float score, gain, best_score, av_uninit(best_gain);
197  float exc[BLOCKSIZE];
198 
199  gain = best_score = 0;
200  for (i = BLOCKSIZE / 2; i <= BUFFERSIZE; i++) {
201  create_adapt_vect(exc, adapt_cb, i);
202  get_match_score(work, coefs, exc, NULL, NULL, data, &score, &gain);
203  if (score > best_score) {
204  best_score = score;
205  best_vect = i;
206  best_gain = gain;
207  }
208  }
209  if (!best_score)
210  return 0;
211 
212  /**
213  * Re-calculate the filtered vector from the vector with maximum match score
214  * and remove its contribution from input data.
215  */
216  create_adapt_vect(exc, adapt_cb, best_vect);
218  for (i = 0; i < BLOCKSIZE; i++)
219  data[i] -= best_gain * work[i];
220  return best_vect - BLOCKSIZE / 2 + 1;
221 }
222 
223 
224 /**
225  * Find the best vector of a fixed codebook by applying an LPC filter to
226  * codebook entries, possibly orthogonalizing them to up to two other vectors
227  * and matching the results with input data.
228  *
229  * @param work array used to calculate the filtered vectors
230  * @param coefs coefficients of the LPC filter
231  * @param cb fixed codebook
232  * @param ortho1 first vector against which orthogonalization is performed
233  * @param ortho2 second vector against which orthogonalization is performed
234  * @param data input data
235  * @param idx pointer to variable where the index of the best codebook entry is
236  * returned
237  * @param gain pointer to variable where the gain of the best codebook entry is
238  * returned
239  */
240 static void find_best_vect(float *work, const float *coefs,
241  const int8_t cb[][BLOCKSIZE], const float *ortho1,
242  const float *ortho2, float *data, int *idx,
243  float *gain)
244 {
245  int i, j;
246  float g, score, best_score;
247  float vect[BLOCKSIZE];
248 
249  *idx = *gain = best_score = 0;
250  for (i = 0; i < FIXED_CB_SIZE; i++) {
251  for (j = 0; j < BLOCKSIZE; j++)
252  vect[j] = cb[i][j];
253  get_match_score(work, coefs, vect, ortho1, ortho2, data, &score, &g);
254  if (score > best_score) {
255  best_score = score;
256  *idx = i;
257  *gain = g;
258  }
259  }
260 }
261 
262 
263 /**
264  * Search the two fixed codebooks for the best entry and gain
265  *
266  * @param work array used to calculate LPC-filtered vectors
267  * @param coefs coefficients of the LPC filter
268  * @param data input data
269  * @param cba_idx index of the best entry of the adaptive codebook
270  * @param cb1_idx pointer to variable where the index of the best entry of the
271  * first fixed codebook is returned
272  * @param cb2_idx pointer to variable where the index of the best entry of the
273  * second fixed codebook is returned
274  */
275 static void fixed_cb_search(float *work, const float *coefs, float *data,
276  int cba_idx, int *cb1_idx, int *cb2_idx)
277 {
278  int i, ortho_cb1;
279  float gain;
280  float cba_vect[BLOCKSIZE], cb1_vect[BLOCKSIZE];
281  float vect[BLOCKSIZE];
282 
283  /**
284  * The filtered vector from the adaptive codebook can be retrieved from
285  * work, because this function is called just after adaptive_cb_search().
286  */
287  if (cba_idx)
288  memcpy(cba_vect, work, sizeof(cba_vect));
289 
290  find_best_vect(work, coefs, ff_cb1_vects, cba_idx ? cba_vect : NULL, NULL,
291  data, cb1_idx, &gain);
292 
293  /**
294  * Re-calculate the filtered vector from the vector with maximum match score
295  * and remove its contribution from input data.
296  */
297  if (gain) {
298  for (i = 0; i < BLOCKSIZE; i++)
299  vect[i] = ff_cb1_vects[*cb1_idx][i];
301  if (cba_idx)
302  orthogonalize(work, cba_vect);
303  for (i = 0; i < BLOCKSIZE; i++)
304  data[i] -= gain * work[i];
305  memcpy(cb1_vect, work, sizeof(cb1_vect));
306  ortho_cb1 = 1;
307  } else
308  ortho_cb1 = 0;
309 
310  find_best_vect(work, coefs, ff_cb2_vects, cba_idx ? cba_vect : NULL,
311  ortho_cb1 ? cb1_vect : NULL, data, cb2_idx, &gain);
312 }
313 
314 
315 /**
316  * Encode a subblock of the current frame
317  *
318  * @param ractx encoder context
319  * @param sblock_data input data of the subblock
320  * @param lpc_coefs coefficients of the LPC filter
321  * @param rms RMS of the reflection coefficients
322  * @param pb pointer to PutBitContext of the current frame
323  */
325  const int16_t *sblock_data,
326  const int16_t *lpc_coefs, unsigned int rms,
327  PutBitContext *pb)
328 {
329  float data[BLOCKSIZE] = { 0 }, work[LPC_ORDER + BLOCKSIZE];
330  float coefs[LPC_ORDER];
331  float zero[BLOCKSIZE], cba[BLOCKSIZE], cb1[BLOCKSIZE], cb2[BLOCKSIZE];
332  int cba_idx, cb1_idx, cb2_idx, gain;
333  int i, n;
334  unsigned m[3];
335  float g[3];
336  float error, best_error;
337 
338  for (i = 0; i < LPC_ORDER; i++) {
339  work[i] = ractx->curr_sblock[BLOCKSIZE + i];
340  coefs[i] = lpc_coefs[i] * (1/4096.0);
341  }
342 
343  /**
344  * Calculate the zero-input response of the LPC filter and subtract it from
345  * input data.
346  */
348  LPC_ORDER);
349  for (i = 0; i < BLOCKSIZE; i++) {
350  zero[i] = work[LPC_ORDER + i];
351  data[i] = sblock_data[i] - zero[i];
352  }
353 
354  /**
355  * Codebook search is performed without taking into account the contribution
356  * of the previous subblock, since it has been just subtracted from input
357  * data.
358  */
359  memset(work, 0, LPC_ORDER * sizeof(*work));
360 
361  cba_idx = adaptive_cb_search(ractx->adapt_cb, work + LPC_ORDER, coefs,
362  data);
363  if (cba_idx) {
364  /**
365  * The filtered vector from the adaptive codebook can be retrieved from
366  * work, see implementation of adaptive_cb_search().
367  */
368  memcpy(cba, work + LPC_ORDER, sizeof(cba));
369 
370  ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);
371  m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * rms) >> 12;
372  }
373  fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx);
374  for (i = 0; i < BLOCKSIZE; i++) {
375  cb1[i] = ff_cb1_vects[cb1_idx][i];
376  cb2[i] = ff_cb2_vects[cb2_idx][i];
377  }
379  LPC_ORDER);
380  memcpy(cb1, work + LPC_ORDER, sizeof(cb1));
381  m[1] = (ff_cb1_base[cb1_idx] * rms) >> 8;
383  LPC_ORDER);
384  memcpy(cb2, work + LPC_ORDER, sizeof(cb2));
385  m[2] = (ff_cb2_base[cb2_idx] * rms) >> 8;
386  best_error = FLT_MAX;
387  gain = 0;
388  for (n = 0; n < 256; n++) {
389  g[1] = ((ff_gain_val_tab[n][1] * m[1]) >> ff_gain_exp_tab[n]) *
390  (1/4096.0);
391  g[2] = ((ff_gain_val_tab[n][2] * m[2]) >> ff_gain_exp_tab[n]) *
392  (1/4096.0);
393  error = 0;
394  if (cba_idx) {
395  g[0] = ((ff_gain_val_tab[n][0] * m[0]) >> ff_gain_exp_tab[n]) *
396  (1/4096.0);
397  for (i = 0; i < BLOCKSIZE; i++) {
398  data[i] = zero[i] + g[0] * cba[i] + g[1] * cb1[i] +
399  g[2] * cb2[i];
400  error += (data[i] - sblock_data[i]) *
401  (data[i] - sblock_data[i]);
402  }
403  } else {
404  for (i = 0; i < BLOCKSIZE; i++) {
405  data[i] = zero[i] + g[1] * cb1[i] + g[2] * cb2[i];
406  error += (data[i] - sblock_data[i]) *
407  (data[i] - sblock_data[i]);
408  }
409  }
410  if (error < best_error) {
411  best_error = error;
412  gain = n;
413  }
414  }
415  put_bits(pb, 7, cba_idx);
416  put_bits(pb, 8, gain);
417  put_bits(pb, 7, cb1_idx);
418  put_bits(pb, 7, cb2_idx);
419  ff_subblock_synthesis(ractx, lpc_coefs, cba_idx, cb1_idx, cb2_idx, rms,
420  gain);
421 }
422 
423 
424 static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
425  const AVFrame *frame, int *got_packet_ptr)
426 {
427  static const uint8_t sizes[LPC_ORDER] = {64, 32, 32, 16, 16, 8, 8, 8, 8, 4};
428  static const uint8_t bit_sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
429  RA144Context *ractx = avctx->priv_data;
430  PutBitContext pb;
431  int32_t lpc_data[NBLOCKS * BLOCKSIZE];
432  int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER];
433  int shift[LPC_ORDER];
434  int16_t block_coefs[NBLOCKS][LPC_ORDER];
435  int lpc_refl[LPC_ORDER]; /**< reflection coefficients of the frame */
436  unsigned int refl_rms[NBLOCKS]; /**< RMS of the reflection coefficients */
437  const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;
438  int energy = 0;
439  int i, idx, ret;
440 
441  if (ractx->last_frame)
442  return 0;
443 
444  if ((ret = ff_get_encode_buffer(avctx, avpkt, FRAME_SIZE, 0)) < 0)
445  return ret;
446 
447  /**
448  * Since the LPC coefficients are calculated on a frame centered over the
449  * fourth subframe, to encode a given frame, data from the next frame is
450  * needed. In each call to this function, the previous frame (whose data are
451  * saved in the encoder context) is encoded, and data from the current frame
452  * are saved in the encoder context to be used in the next function call.
453  */
454  for (i = 0; i < (2 * BLOCKSIZE + BLOCKSIZE / 2); i++) {
455  lpc_data[i] = ractx->curr_block[BLOCKSIZE + BLOCKSIZE / 2 + i];
456  energy += (lpc_data[i] * lpc_data[i]) >> 4;
457  }
458  if (frame) {
459  int j;
460  for (j = 0; j < frame->nb_samples && i < NBLOCKS * BLOCKSIZE; i++, j++) {
461  lpc_data[i] = samples[j] >> 2;
462  energy += (lpc_data[i] * lpc_data[i]) >> 4;
463  }
464  }
465  if (i < NBLOCKS * BLOCKSIZE)
466  memset(&lpc_data[i], 0, (NBLOCKS * BLOCKSIZE - i) * sizeof(*lpc_data));
467  energy = ff_energy_tab[quantize(ff_t_sqrt(energy >> 5) >> 10, ff_energy_tab,
468  32)];
469 
470  ff_lpc_calc_coefs(&ractx->lpc_ctx, lpc_data, NBLOCKS * BLOCKSIZE, LPC_ORDER,
471  LPC_ORDER, 16, lpc_coefs, shift, FF_LPC_TYPE_LEVINSON,
472  0, ORDER_METHOD_EST, 0, 12, 0);
473  for (i = 0; i < LPC_ORDER; i++)
474  block_coefs[NBLOCKS - 1][i] = -lpc_coefs[LPC_ORDER - 1][i]
475  * (1 << (12 - shift[LPC_ORDER - 1]));
476 
477  /**
478  * TODO: apply perceptual weighting of the input speech through bandwidth
479  * expansion of the LPC filter.
480  */
481 
482  if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
483  /**
484  * The filter is unstable: use the coefficients of the previous frame.
485  */
486  ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]);
487  if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
488  /* the filter is still unstable. set reflection coeffs to zero. */
489  memset(lpc_refl, 0, sizeof(lpc_refl));
490  }
491  }
492  init_put_bits(&pb, avpkt->data, avpkt->size);
493  for (i = 0; i < LPC_ORDER; i++) {
494  idx = quantize(lpc_refl[i], ff_lpc_refl_cb[i], sizes[i]);
495  put_bits(&pb, bit_sizes[i], idx);
496  lpc_refl[i] = ff_lpc_refl_cb[i][idx];
497  }
498  ractx->lpc_refl_rms[0] = ff_rms(lpc_refl);
499  ff_eval_coefs(ractx->lpc_coef[0], lpc_refl);
500  refl_rms[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy);
501  refl_rms[1] = ff_interp(ractx, block_coefs[1], 2,
502  energy <= ractx->old_energy,
503  ff_t_sqrt(energy * ractx->old_energy) >> 12);
504  refl_rms[2] = ff_interp(ractx, block_coefs[2], 3, 0, energy);
505  refl_rms[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], energy);
506  ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[0]);
507  put_bits(&pb, 5, quantize(energy, ff_energy_tab, 32));
508  for (i = 0; i < NBLOCKS; i++)
509  ra144_encode_subblock(ractx, ractx->curr_block + i * BLOCKSIZE,
510  block_coefs[i], refl_rms[i], &pb);
511  flush_put_bits(&pb);
512  ractx->old_energy = energy;
513  ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0];
514  FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);
515 
516  /* copy input samples to current block for processing in next call */
517  i = 0;
518  if (frame) {
519  for (; i < frame->nb_samples; i++)
520  ractx->curr_block[i] = samples[i] >> 2;
521 
522  if ((ret = ff_af_queue_add(&ractx->afq, frame)) < 0)
523  return ret;
524  } else
525  ractx->last_frame = 1;
526  memset(&ractx->curr_block[i], 0,
527  (NBLOCKS * BLOCKSIZE - i) * sizeof(*ractx->curr_block));
528 
529  /* Get the next frame pts/duration */
530  ff_af_queue_remove(&ractx->afq, avctx->frame_size, &avpkt->pts,
531  &avpkt->duration);
532 
533  *got_packet_ptr = 1;
534  return 0;
535 }
536 
537 
539  .p.name = "real_144",
540  .p.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
541  .p.type = AVMEDIA_TYPE_AUDIO,
542  .p.id = AV_CODEC_ID_RA_144,
543  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
545  .priv_data_size = sizeof(RA144Context),
548  .close = ra144_encode_close,
549  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
551  .p.supported_samplerates = (const int[]){ 8000, 0 },
552 #if FF_API_OLD_CHANNEL_LAYOUT
553  .p.channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, 0 },
554 #endif
555  .p.ch_layouts = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO, { 0 } },
556 };
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:1035
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:324
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:239
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:262
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:192
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:204
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:62
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:275
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:416
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
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
AVPacket::data
uint8_t * data
Definition: packet.h:374
encode.h
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:146
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
FFCodec
Definition: codec_internal.h:118
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:392
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
init
static int init
Definition: av_tx.c:47
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:136
RA144Context::buffer_a
int16_t buffer_a[FFALIGN(BLOCKSIZE, 16)]
Definition: ra144.h:66
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
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:1732
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:169
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
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_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
ff_ra_144_encoder
const FFCodec ff_ra_144_encoder
Definition: ra144enc.c:538
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:83
RA144Context::curr_block
int16_t curr_block[NBLOCKS *BLOCKSIZE]
Definition: ra144.h:57
PutBitContext
Definition: put_bits.h:50
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:57
RA144Context
Definition: ra144.h:40
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
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:240
index
int index
Definition: gxfenc.c:89
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:375
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
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
MAX_LPC_ORDER
#define MAX_LPC_ORDER
Definition: lpc.h:38
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
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:324
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:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
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:55
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:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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:108
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:398
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:79
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:424
shift
static int shift(int a, int b)
Definition: sonic.c:88
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:143
RA144Context::last_frame
int last_frame
Definition: ra144.h:45
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
int32_t
int32_t
Definition: audioconvert.c:56
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