FFmpeg
g726.c
Go to the documentation of this file.
1 /*
2  * G.726 ADPCM audio codec
3  * Copyright (c) 2004 Roman Shaposhnik
4  *
5  * This is a very straightforward rendition of the G.726
6  * Section 4 "Computational Details".
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include "config_components.h"
26 
27 #include <limits.h>
28 
30 #include "libavutil/opt.h"
31 #include "avcodec.h"
32 #include "codec_internal.h"
33 #include "decode.h"
34 #include "encode.h"
35 #include "get_bits.h"
36 #include "put_bits.h"
37 
38 /**
39  * G.726 11-bit float.
40  * G.726 Standard uses rather odd 11-bit floating point arithmetic for
41  * numerous occasions. It's a mystery to me why they did it this way
42  * instead of simply using 32-bit integer arithmetic.
43  */
44 typedef struct Float11 {
45  uint8_t sign; /**< 1 bit sign */
46  uint8_t exp; /**< 4 bits exponent */
47  uint8_t mant; /**< 6 bits mantissa */
48 } Float11;
49 
50 static inline Float11* i2f(int i, Float11* f)
51 {
52  f->sign = (i < 0);
53  if (f->sign)
54  i = -i;
55  f->exp = av_log2_16bit(i) + !!i;
56  f->mant = i? (i<<6) >> f->exp : 1<<5;
57  return f;
58 }
59 
60 static inline int16_t mult(Float11* f1, Float11* f2)
61 {
62  int res, exp;
63 
64  exp = f1->exp + f2->exp;
65  res = (((f1->mant * f2->mant) + 0x30) >> 4);
66  res = exp > 19 ? res << (exp - 19) : res >> (19 - exp);
67  return (f1->sign ^ f2->sign) ? -res : res;
68 }
69 
70 static inline int sgn(int value)
71 {
72  return (value < 0) ? -1 : 1;
73 }
74 
75 typedef struct G726Tables {
76  const int* quant; /**< quantization table */
77  const int16_t* iquant; /**< inverse quantization table */
78  const int16_t* W; /**< special table #1 ;-) */
79  const uint8_t* F; /**< special table #2 */
80 } G726Tables;
81 
82 typedef struct G726Context {
83  AVClass *class;
84  G726Tables tbls; /**< static tables needed for computation */
85 
86  Float11 sr[2]; /**< prev. reconstructed samples */
87  Float11 dq[6]; /**< prev. difference */
88  int a[2]; /**< second order predictor coeffs */
89  int b[6]; /**< sixth order predictor coeffs */
90  int pk[2]; /**< signs of prev. 2 sez + dq */
91 
92  int ap; /**< scale factor control */
93  int yu; /**< fast scale factor */
94  int yl; /**< slow scale factor */
95  int dms; /**< short average magnitude of F[i] */
96  int dml; /**< long average magnitude of F[i] */
97  int td; /**< tone detect */
98 
99  int se; /**< estimated signal for the next iteration */
100  int sez; /**< estimated second order prediction */
101  int y; /**< quantizer scaling factor for the next iteration */
103  int little_endian; /**< little-endian bitstream as used in aiff and Sun AU */
104 } G726Context;
105 
106 static const int quant_tbl16[] = /**< 16kbit/s 2 bits per sample */
107  { 260, INT_MAX };
108 static const int16_t iquant_tbl16[] =
109  { 116, 365, 365, 116 };
110 static const int16_t W_tbl16[] =
111  { -22, 439, 439, -22 };
112 static const uint8_t F_tbl16[] =
113  { 0, 7, 7, 0 };
114 
115 static const int quant_tbl24[] = /**< 24kbit/s 3 bits per sample */
116  { 7, 217, 330, INT_MAX };
117 static const int16_t iquant_tbl24[] =
118  { INT16_MIN, 135, 273, 373, 373, 273, 135, INT16_MIN };
119 static const int16_t W_tbl24[] =
120  { -4, 30, 137, 582, 582, 137, 30, -4 };
121 static const uint8_t F_tbl24[] =
122  { 0, 1, 2, 7, 7, 2, 1, 0 };
123 
124 static const int quant_tbl32[] = /**< 32kbit/s 4 bits per sample */
125  { -125, 79, 177, 245, 299, 348, 399, INT_MAX };
126 static const int16_t iquant_tbl32[] =
127  { INT16_MIN, 4, 135, 213, 273, 323, 373, 425,
128  425, 373, 323, 273, 213, 135, 4, INT16_MIN };
129 static const int16_t W_tbl32[] =
130  { -12, 18, 41, 64, 112, 198, 355, 1122,
131  1122, 355, 198, 112, 64, 41, 18, -12};
132 static const uint8_t F_tbl32[] =
133  { 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 };
134 
135 static const int quant_tbl40[] = /**< 40kbit/s 5 bits per sample */
136  { -122, -16, 67, 138, 197, 249, 297, 338,
137  377, 412, 444, 474, 501, 527, 552, INT_MAX };
138 static const int16_t iquant_tbl40[] =
139  { INT16_MIN, -66, 28, 104, 169, 224, 274, 318,
140  358, 395, 429, 459, 488, 514, 539, 566,
141  566, 539, 514, 488, 459, 429, 395, 358,
142  318, 274, 224, 169, 104, 28, -66, INT16_MIN };
143 static const int16_t W_tbl40[] =
144  { 14, 14, 24, 39, 40, 41, 58, 100,
145  141, 179, 219, 280, 358, 440, 529, 696,
146  696, 529, 440, 358, 280, 219, 179, 141,
147  100, 58, 41, 40, 39, 24, 14, 14 };
148 static const uint8_t F_tbl40[] =
149  { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6,
150  6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
151 
152 static const G726Tables G726Tables_pool[] =
157 
158 
159 /**
160  * Paragraph 4.2.2 page 18: Adaptive quantizer.
161  */
162 static inline uint8_t quant(G726Context* c, int d)
163 {
164  int sign, exp, i, dln;
165 
166  sign = i = 0;
167  if (d < 0) {
168  sign = 1;
169  d = -d;
170  }
171  exp = av_log2_16bit(d);
172  dln = ((exp<<7) + (((d<<7)>>exp)&0x7f)) - (c->y>>2);
173 
174  while (c->tbls.quant[i] < INT_MAX && c->tbls.quant[i] < dln)
175  ++i;
176 
177  if (sign)
178  i = ~i;
179  if (c->code_size != 2 && i == 0) /* I'm not sure this is a good idea */
180  i = 0xff;
181 
182  return i;
183 }
184 
185 /**
186  * Paragraph 4.2.3 page 22: Inverse adaptive quantizer.
187  */
188 static inline int16_t inverse_quant(G726Context* c, int i)
189 {
190  int dql, dex, dqt;
191 
192  dql = c->tbls.iquant[i] + (c->y >> 2);
193  dex = (dql>>7) & 0xf; /* 4-bit exponent */
194  dqt = (1<<7) + (dql & 0x7f); /* log2 -> linear */
195  return (dql < 0) ? 0 : ((dqt<<dex) >> 7);
196 }
197 
198 static int16_t g726_decode(G726Context* c, int I)
199 {
200  int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0;
201  Float11 f;
202  int I_sig= I >> (c->code_size - 1);
203 
204  dq = inverse_quant(c, I);
205 
206  /* Transition detect */
207  ylint = (c->yl >> 15);
208  ylfrac = (c->yl >> 10) & 0x1f;
209  thr2 = (ylint > 9) ? 0x1f << 10 : (0x20 + ylfrac) << ylint;
210  tr= (c->td == 1 && dq > ((3*thr2)>>2));
211 
212  if (I_sig) /* get the sign */
213  dq = -dq;
214  re_signal = (int16_t)(c->se + dq);
215 
216  /* Update second order predictor coefficient A2 and A1 */
217  pk0 = (c->sez + dq) ? sgn(c->sez + dq) : 0;
218  dq0 = dq ? sgn(dq) : 0;
219  if (tr) {
220  c->a[0] = 0;
221  c->a[1] = 0;
222  for (i=0; i<6; i++)
223  c->b[i] = 0;
224  } else {
225  /* This is a bit crazy, but it really is +255 not +256 */
226  fa1 = av_clip_intp2((-c->a[0]*c->pk[0]*pk0)>>5, 8);
227 
228  c->a[1] += 128*pk0*c->pk[1] + fa1 - (c->a[1]>>7);
229  c->a[1] = av_clip(c->a[1], -12288, 12288);
230  c->a[0] += 64*3*pk0*c->pk[0] - (c->a[0] >> 8);
231  c->a[0] = av_clip(c->a[0], -(15360 - c->a[1]), 15360 - c->a[1]);
232 
233  for (i=0; i<6; i++)
234  c->b[i] += 128*dq0*sgn(-c->dq[i].sign) - (c->b[i]>>8);
235  }
236 
237  /* Update Dq and Sr and Pk */
238  c->pk[1] = c->pk[0];
239  c->pk[0] = pk0 ? pk0 : 1;
240  c->sr[1] = c->sr[0];
241  i2f(re_signal, &c->sr[0]);
242  for (i=5; i>0; i--)
243  c->dq[i] = c->dq[i-1];
244  i2f(dq, &c->dq[0]);
245  c->dq[0].sign = I_sig; /* Isn't it crazy ?!?! */
246 
247  c->td = c->a[1] < -11776;
248 
249  /* Update Ap */
250  c->dms += (c->tbls.F[I]<<4) + ((- c->dms) >> 5);
251  c->dml += (c->tbls.F[I]<<4) + ((- c->dml) >> 7);
252  if (tr)
253  c->ap = 256;
254  else {
255  c->ap += (-c->ap) >> 4;
256  if (c->y <= 1535 || c->td || abs((c->dms << 2) - c->dml) >= (c->dml >> 3))
257  c->ap += 0x20;
258  }
259 
260  /* Update Yu and Yl */
261  c->yu = av_clip(c->y + c->tbls.W[I] + ((-c->y)>>5), 544, 5120);
262  c->yl += c->yu + ((-c->yl)>>6);
263 
264  /* Next iteration for Y */
265  al = (c->ap >= 256) ? 1<<6 : c->ap >> 2;
266  c->y = (c->yl + (c->yu - (c->yl>>6))*al) >> 6;
267 
268  /* Next iteration for SE and SEZ */
269  c->se = 0;
270  for (i=0; i<6; i++)
271  c->se += mult(i2f(c->b[i] >> 2, &f), &c->dq[i]);
272  c->sez = c->se >> 1;
273  for (i=0; i<2; i++)
274  c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]);
275  c->se >>= 1;
276 
277  return av_clip(re_signal * 4, -0xffff, 0xffff);
278 }
279 
281 {
282  int i;
283 
284  c->tbls = G726Tables_pool[c->code_size - 2];
285  for (i=0; i<2; i++) {
286  c->sr[i].mant = 1<<5;
287  c->pk[i] = 1;
288  }
289  for (i=0; i<6; i++) {
290  c->dq[i].mant = 1<<5;
291  }
292  c->yu = 544;
293  c->yl = 34816;
294 
295  c->y = 544;
296 
297  return 0;
298 }
299 
300 #if CONFIG_ADPCM_G726_ENCODER || CONFIG_ADPCM_G726LE_ENCODER
301 static int16_t g726_encode(G726Context* c, int16_t sig)
302 {
303  uint8_t i;
304 
305  i = av_mod_uintp2(quant(c, sig/4 - c->se), c->code_size);
306  g726_decode(c, i);
307  return i;
308 }
309 
310 /* Interfacing to the libavcodec */
311 
312 static av_cold int g726_encode_init(AVCodecContext *avctx)
313 {
314  G726Context* c = avctx->priv_data;
315 
316  c->little_endian = !strcmp(avctx->codec->name, "g726le");
317 
319  avctx->sample_rate != 8000) {
320  av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not "
321  "allowed when the compliance level is higher than unofficial. "
322  "Resample or reduce the compliance level.\n");
323  return AVERROR(EINVAL);
324  }
325  if (avctx->sample_rate <= 0) {
326  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate %d\n",
327  avctx->sample_rate);
328  return AVERROR(EINVAL);
329  }
330 
331  if (avctx->ch_layout.nb_channels != 1) {
332  av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n");
333  return AVERROR(EINVAL);
334  }
335 
336  if (avctx->bit_rate)
337  c->code_size = (avctx->bit_rate + avctx->sample_rate/2) / avctx->sample_rate;
338 
339  c->code_size = av_clip(c->code_size, 2, 5);
340  avctx->bit_rate = c->code_size * avctx->sample_rate;
341  avctx->bits_per_coded_sample = c->code_size;
342 
343  g726_reset(c);
344 
345  /* select a frame size that will end on a byte boundary and have a size of
346  approximately 1024 bytes */
347  avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2];
348 
349  return 0;
350 }
351 
352 static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
353  const AVFrame *frame, int *got_packet_ptr)
354 {
355  G726Context *c = avctx->priv_data;
356  const int16_t *samples = (const int16_t *)frame->data[0];
357  PutBitContext pb;
358  int i, ret, out_size;
359 
360  out_size = (frame->nb_samples * c->code_size + 7) / 8;
361  if ((ret = ff_get_encode_buffer(avctx, avpkt, out_size, 0)) < 0)
362  return ret;
363  init_put_bits(&pb, avpkt->data, avpkt->size);
364 
365  for (i = 0; i < frame->nb_samples; i++)
366  if (c->little_endian) {
367  put_bits_le(&pb, c->code_size, g726_encode(c, *samples++));
368  } else {
369  put_bits(&pb, c->code_size, g726_encode(c, *samples++));
370  }
371 
372  if (c->little_endian) {
373  flush_put_bits_le(&pb);
374  } else {
375  flush_put_bits(&pb);
376  }
377 
378  *got_packet_ptr = 1;
379  return 0;
380 }
381 
382 #define OFFSET(x) offsetof(G726Context, x)
383 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
384 static const AVOption options[] = {
385  { "code_size", "Bits per code", OFFSET(code_size), AV_OPT_TYPE_INT, { .i64 = 4 }, 2, 5, AE },
386  { NULL },
387 };
388 
389 static const AVClass g726_class = {
390  .class_name = "g726",
391  .item_name = av_default_item_name,
392  .option = options,
393  .version = LIBAVUTIL_VERSION_INT,
394 };
395 
396 static const FFCodecDefault defaults[] = {
397  { "b", "0" },
398  { NULL },
399 };
400 #endif
401 
402 #if CONFIG_ADPCM_G726_ENCODER
404  .p.name = "g726",
405  CODEC_LONG_NAME("G.726 ADPCM"),
406  .p.type = AVMEDIA_TYPE_AUDIO,
407  .p.id = AV_CODEC_ID_ADPCM_G726,
409  .priv_data_size = sizeof(G726Context),
410  .init = g726_encode_init,
411  FF_CODEC_ENCODE_CB(g726_encode_frame),
412  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
414  .p.priv_class = &g726_class,
415  .defaults = defaults,
416 };
417 #endif
418 
419 #if CONFIG_ADPCM_G726LE_ENCODER
421  .p.name = "g726le",
422  CODEC_LONG_NAME("G.726 little endian ADPCM (\"right-justified\")"),
423  .p.type = AVMEDIA_TYPE_AUDIO,
424  .p.id = AV_CODEC_ID_ADPCM_G726LE,
426  .priv_data_size = sizeof(G726Context),
427  .init = g726_encode_init,
428  FF_CODEC_ENCODE_CB(g726_encode_frame),
429  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
431  .p.priv_class = &g726_class,
432  .defaults = defaults,
433 };
434 #endif
435 
436 #if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER
437 static av_cold int g726_decode_init(AVCodecContext *avctx)
438 {
439  G726Context* c = avctx->priv_data;
440 
441  if (avctx->ch_layout.nb_channels > 1){
442  avpriv_request_sample(avctx, "Decoding more than one channel");
443  return AVERROR_PATCHWELCOME;
444  }
447 
448  c->little_endian = !strcmp(avctx->codec->name, "g726le");
449 
450  c->code_size = avctx->bits_per_coded_sample;
451  if (c->code_size < 2 || c->code_size > 5) {
452  av_log(avctx, AV_LOG_ERROR, "Invalid number of bits %d\n", c->code_size);
453  return AVERROR(EINVAL);
454  }
455  g726_reset(c);
456 
457  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
458 
459  return 0;
460 }
461 
462 static int g726_decode_frame(AVCodecContext *avctx, AVFrame *frame,
463  int *got_frame_ptr, AVPacket *avpkt)
464 {
465  const uint8_t *buf = avpkt->data;
466  int buf_size = avpkt->size;
467  G726Context *c = avctx->priv_data;
468  int16_t *samples;
469  GetBitContext gb;
470  int out_samples, ret;
471 
472  out_samples = buf_size * 8 / c->code_size;
473 
474  /* get output buffer */
475  frame->nb_samples = out_samples;
476  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
477  return ret;
478  samples = (int16_t *)frame->data[0];
479 
480  init_get_bits(&gb, buf, buf_size * 8);
481 
482  while (out_samples--)
483  *samples++ = g726_decode(c, c->little_endian ?
484  get_bits_le(&gb, c->code_size) :
485  get_bits(&gb, c->code_size));
486 
487  if (get_bits_left(&gb) > 0)
488  av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");
489 
490  *got_frame_ptr = 1;
491 
492  return buf_size;
493 }
494 
495 static void g726_decode_flush(AVCodecContext *avctx)
496 {
497  G726Context *c = avctx->priv_data;
498  g726_reset(c);
499 }
500 #endif
501 
502 #if CONFIG_ADPCM_G726_DECODER
504  .p.name = "g726",
505  CODEC_LONG_NAME("G.726 ADPCM"),
506  .p.type = AVMEDIA_TYPE_AUDIO,
507  .p.id = AV_CODEC_ID_ADPCM_G726,
508  .priv_data_size = sizeof(G726Context),
509  .init = g726_decode_init,
510  FF_CODEC_DECODE_CB(g726_decode_frame),
511  .flush = g726_decode_flush,
512  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
513 };
514 #endif
515 
516 #if CONFIG_ADPCM_G726LE_DECODER
518  .p.name = "g726le",
519  .p.type = AVMEDIA_TYPE_AUDIO,
520  .p.id = AV_CODEC_ID_ADPCM_G726LE,
521  .priv_data_size = sizeof(G726Context),
522  .init = g726_decode_init,
523  FF_CODEC_DECODE_CB(g726_decode_frame),
524  .flush = g726_decode_flush,
525  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
526  CODEC_LONG_NAME("G.726 ADPCM little-endian"),
527 };
528 #endif
sgn
static int sgn(int value)
Definition: g726.c:70
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1035
G726Context
Definition: g726.c:82
G726Context::tbls
G726Tables tbls
static tables needed for computation
Definition: g726.c:84
av_clip
#define av_clip
Definition: common.h:95
W_tbl16
static const int16_t W_tbl16[]
Definition: g726.c:110
iquant_tbl32
static const int16_t iquant_tbl32[]
Definition: g726.c:126
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
Float11::mant
uint8_t mant
6 bits mantissa
Definition: g726.c:47
G726Tables::F
const uint8_t * F
special table #2
Definition: g726.c:79
G726Tables
Definition: g726.c:75
W_tbl32
static const int16_t W_tbl32[]
Definition: g726.c:129
G726Context::dml
int dml
long average magnitude of F[i]
Definition: g726.c:96
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
G726Context::td
int td
tone detect
Definition: g726.c:97
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:122
out_size
int out_size
Definition: movenc.c:55
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
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
AVPacket::data
uint8_t * data
Definition: packet.h:374
iquant_tbl40
static const int16_t iquant_tbl40[]
Definition: g726.c:138
AVOption
AVOption.
Definition: opt.h:251
encode.h
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:356
FFCodec
Definition: codec_internal.h:119
G726Context::yl
int yl
slow scale factor
Definition: g726.c:94
iquant_tbl16
static const int16_t iquant_tbl16[]
Definition: g726.c:108
G726Tables::quant
const int * quant
quantization table
Definition: g726.c:76
quant_tbl24
static const int quant_tbl24[]
24kbit/s 3 bits per sample
Definition: g726.c:115
quant_tbl16
static const int quant_tbl16[]
16kbit/s 2 bits per sample
Definition: g726.c:106
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:303
F_tbl40
static const uint8_t F_tbl40[]
Definition: g726.c:148
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
init
static int init
Definition: av_tx.c:47
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodecDefault
Definition: codec_internal.h:89
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:407
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2059
g726_reset
static av_cold int g726_reset(G726Context *c)
Definition: g726.c:280
GetBitContext
Definition: get_bits.h:61
g726_decode
static int16_t g726_decode(G726Context *c, int I)
Definition: g726.c:198
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:288
G726Context::a
int a[2]
second order predictor coeffs
Definition: g726.c:88
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
G726Context::yu
int yu
fast scale factor
Definition: g726.c:93
av_cold
#define av_cold
Definition: attributes.h:90
G726Context::little_endian
int little_endian
little-endian bitstream as used in aiff and Sun AU
Definition: g726.c:103
G726Context::dq
Float11 dq[6]
prev.
Definition: g726.c:87
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:374
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:279
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_adpcm_g726le_decoder
const FFCodec ff_adpcm_g726le_decoder
quant_tbl40
static const int quant_tbl40[]
40kbit/s 5 bits per sample
Definition: g726.c:135
quant
static uint8_t quant(G726Context *c, int d)
Paragraph 4.2.2 page 18: Adaptive quantizer.
Definition: g726.c:162
get_bits_le
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
quant_tbl32
static const int quant_tbl32[]
32kbit/s 4 bits per sample
Definition: g726.c:124
decode.h
get_bits.h
limits.h
W_tbl24
static const int16_t W_tbl24[]
Definition: g726.c:119
F_tbl16
static const uint8_t F_tbl16[]
Definition: g726.c:112
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
G726Context::dms
int dms
short average magnitude of F[i]
Definition: g726.c:95
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:116
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
G726Tables_pool
static const G726Tables G726Tables_pool[]
Definition: g726.c:152
G726Context::sez
int sez
estimated second order prediction
Definition: g726.c:100
Float11
G.726 11-bit float.
Definition: g726.c:44
flush_put_bits_le
static void flush_put_bits_le(PutBitContext *s)
Definition: put_bits.h:164
abs
#define abs(x)
Definition: cuda_runtime.h:35
AE
#define AE
Definition: alacenc.c:636
W_tbl40
static const int16_t W_tbl40[]
Definition: g726.c:143
iquant_tbl24
static const int16_t iquant_tbl24[]
Definition: g726.c:117
exp
int8_t exp
Definition: eval.c:72
F_tbl32
static const uint8_t F_tbl32[]
Definition: g726.c:132
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
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
options
const OptionDef options[]
G726Context::y
int y
quantizer scaling factor for the next iteration
Definition: g726.c:101
f
f
Definition: af_crystalizer.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1450
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
defaults
static const FFCodecDefault defaults[]
Definition: amfenc_h264.c:362
i2f
static Float11 * i2f(int i, Float11 *f)
Definition: g726.c:50
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:293
codec_internal.h
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
G726Context::code_size
int code_size
Definition: g726.c:102
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1444
G726Context::ap
int ap
scale factor control
Definition: g726.c:92
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
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
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
ff_adpcm_g726le_encoder
const FFCodec ff_adpcm_g726le_encoder
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
avcodec.h
F_tbl24
static const uint8_t F_tbl24[]
Definition: g726.c:121
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1310
OFFSET
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 minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:398
channel_layout.h
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
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
G726Tables::iquant
const int16_t * iquant
inverse quantization table
Definition: g726.c:77
dqt
static int FUNC() dqt(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawQuantisationTableSpecification *current)
Definition: cbs_jpeg_syntax_template.c:62
G726Context::pk
int pk[2]
signs of prev.
Definition: g726.c:90
ff_adpcm_g726_encoder
const FFCodec ff_adpcm_g726_encoder
G726Context::sr
Float11 sr[2]
prev.
Definition: g726.c:86
Float11::exp
uint8_t exp
4 bits exponent
Definition: g726.c:46
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
d
d
Definition: ffmpeg_filter.c:156
G726Tables::W
const int16_t * W
special table #1 ;-)
Definition: g726.c:78
put_bits_le
static void put_bits_le(PutBitContext *s, int n, BitBuf value)
Definition: put_bits.h:253
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_adpcm_g726_decoder
const FFCodec ff_adpcm_g726_decoder
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
G726Context::b
int b[6]
sixth order predictor coeffs
Definition: g726.c:89
Float11::sign
uint8_t sign
1 bit sign
Definition: g726.c:45
put_bits.h
inverse_quant
static int16_t inverse_quant(G726Context *c, int i)
Paragraph 4.2.3 page 22: Inverse adaptive quantizer.
Definition: g726.c:188
G726Context::se
int se
estimated signal for the next iteration
Definition: g726.c:99