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 #include <limits.h>
25 
27 #include "libavutil/opt.h"
28 #include "avcodec.h"
29 #include "internal.h"
30 #include "get_bits.h"
31 #include "put_bits.h"
32 
33 /**
34  * G.726 11-bit float.
35  * G.726 Standard uses rather odd 11-bit floating point arithmetic for
36  * numerous occasions. It's a mystery to me why they did it this way
37  * instead of simply using 32-bit integer arithmetic.
38  */
39 typedef struct Float11 {
40  uint8_t sign; /**< 1 bit sign */
41  uint8_t exp; /**< 4 bits exponent */
42  uint8_t mant; /**< 6 bits mantissa */
43 } Float11;
44 
45 static inline Float11* i2f(int i, Float11* f)
46 {
47  f->sign = (i < 0);
48  if (f->sign)
49  i = -i;
50  f->exp = av_log2_16bit(i) + !!i;
51  f->mant = i? (i<<6) >> f->exp : 1<<5;
52  return f;
53 }
54 
55 static inline int16_t mult(Float11* f1, Float11* f2)
56 {
57  int res, exp;
58 
59  exp = f1->exp + f2->exp;
60  res = (((f1->mant * f2->mant) + 0x30) >> 4);
61  res = exp > 19 ? res << (exp - 19) : res >> (19 - exp);
62  return (f1->sign ^ f2->sign) ? -res : res;
63 }
64 
65 static inline int sgn(int value)
66 {
67  return (value < 0) ? -1 : 1;
68 }
69 
70 typedef struct G726Tables {
71  const int* quant; /**< quantization table */
72  const int16_t* iquant; /**< inverse quantization table */
73  const int16_t* W; /**< special table #1 ;-) */
74  const uint8_t* F; /**< special table #2 */
75 } G726Tables;
76 
77 typedef struct G726Context {
78  AVClass *class;
79  G726Tables tbls; /**< static tables needed for computation */
80 
81  Float11 sr[2]; /**< prev. reconstructed samples */
82  Float11 dq[6]; /**< prev. difference */
83  int a[2]; /**< second order predictor coeffs */
84  int b[6]; /**< sixth order predictor coeffs */
85  int pk[2]; /**< signs of prev. 2 sez + dq */
86 
87  int ap; /**< scale factor control */
88  int yu; /**< fast scale factor */
89  int yl; /**< slow scale factor */
90  int dms; /**< short average magnitude of F[i] */
91  int dml; /**< long average magnitude of F[i] */
92  int td; /**< tone detect */
93 
94  int se; /**< estimated signal for the next iteration */
95  int sez; /**< estimated second order prediction */
96  int y; /**< quantizer scaling factor for the next iteration */
97  int code_size;
98  int little_endian; /**< little-endian bitstream as used in aiff and Sun AU */
99 } G726Context;
100 
101 static const int quant_tbl16[] = /**< 16kbit/s 2 bits per sample */
102  { 260, INT_MAX };
103 static const int16_t iquant_tbl16[] =
104  { 116, 365, 365, 116 };
105 static const int16_t W_tbl16[] =
106  { -22, 439, 439, -22 };
107 static const uint8_t F_tbl16[] =
108  { 0, 7, 7, 0 };
109 
110 static const int quant_tbl24[] = /**< 24kbit/s 3 bits per sample */
111  { 7, 217, 330, INT_MAX };
112 static const int16_t iquant_tbl24[] =
113  { INT16_MIN, 135, 273, 373, 373, 273, 135, INT16_MIN };
114 static const int16_t W_tbl24[] =
115  { -4, 30, 137, 582, 582, 137, 30, -4 };
116 static const uint8_t F_tbl24[] =
117  { 0, 1, 2, 7, 7, 2, 1, 0 };
118 
119 static const int quant_tbl32[] = /**< 32kbit/s 4 bits per sample */
120  { -125, 79, 177, 245, 299, 348, 399, INT_MAX };
121 static const int16_t iquant_tbl32[] =
122  { INT16_MIN, 4, 135, 213, 273, 323, 373, 425,
123  425, 373, 323, 273, 213, 135, 4, INT16_MIN };
124 static const int16_t W_tbl32[] =
125  { -12, 18, 41, 64, 112, 198, 355, 1122,
126  1122, 355, 198, 112, 64, 41, 18, -12};
127 static const uint8_t F_tbl32[] =
128  { 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 };
129 
130 static const int quant_tbl40[] = /**< 40kbit/s 5 bits per sample */
131  { -122, -16, 67, 138, 197, 249, 297, 338,
132  377, 412, 444, 474, 501, 527, 552, INT_MAX };
133 static const int16_t iquant_tbl40[] =
134  { INT16_MIN, -66, 28, 104, 169, 224, 274, 318,
135  358, 395, 429, 459, 488, 514, 539, 566,
136  566, 539, 514, 488, 459, 429, 395, 358,
137  318, 274, 224, 169, 104, 28, -66, INT16_MIN };
138 static const int16_t W_tbl40[] =
139  { 14, 14, 24, 39, 40, 41, 58, 100,
140  141, 179, 219, 280, 358, 440, 529, 696,
141  696, 529, 440, 358, 280, 219, 179, 141,
142  100, 58, 41, 40, 39, 24, 14, 14 };
143 static const uint8_t F_tbl40[] =
144  { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6,
145  6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
146 
147 static const G726Tables G726Tables_pool[] =
152 
153 
154 /**
155  * Paragraph 4.2.2 page 18: Adaptive quantizer.
156  */
157 static inline uint8_t quant(G726Context* c, int d)
158 {
159  int sign, exp, i, dln;
160 
161  sign = i = 0;
162  if (d < 0) {
163  sign = 1;
164  d = -d;
165  }
166  exp = av_log2_16bit(d);
167  dln = ((exp<<7) + (((d<<7)>>exp)&0x7f)) - (c->y>>2);
168 
169  while (c->tbls.quant[i] < INT_MAX && c->tbls.quant[i] < dln)
170  ++i;
171 
172  if (sign)
173  i = ~i;
174  if (c->code_size != 2 && i == 0) /* I'm not sure this is a good idea */
175  i = 0xff;
176 
177  return i;
178 }
179 
180 /**
181  * Paragraph 4.2.3 page 22: Inverse adaptive quantizer.
182  */
183 static inline int16_t inverse_quant(G726Context* c, int i)
184 {
185  int dql, dex, dqt;
186 
187  dql = c->tbls.iquant[i] + (c->y >> 2);
188  dex = (dql>>7) & 0xf; /* 4-bit exponent */
189  dqt = (1<<7) + (dql & 0x7f); /* log2 -> linear */
190  return (dql < 0) ? 0 : ((dqt<<dex) >> 7);
191 }
192 
193 static int16_t g726_decode(G726Context* c, int I)
194 {
195  int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0;
196  Float11 f;
197  int I_sig= I >> (c->code_size - 1);
198 
199  dq = inverse_quant(c, I);
200 
201  /* Transition detect */
202  ylint = (c->yl >> 15);
203  ylfrac = (c->yl >> 10) & 0x1f;
204  thr2 = (ylint > 9) ? 0x1f << 10 : (0x20 + ylfrac) << ylint;
205  tr= (c->td == 1 && dq > ((3*thr2)>>2));
206 
207  if (I_sig) /* get the sign */
208  dq = -dq;
209  re_signal = (int16_t)(c->se + dq);
210 
211  /* Update second order predictor coefficient A2 and A1 */
212  pk0 = (c->sez + dq) ? sgn(c->sez + dq) : 0;
213  dq0 = dq ? sgn(dq) : 0;
214  if (tr) {
215  c->a[0] = 0;
216  c->a[1] = 0;
217  for (i=0; i<6; i++)
218  c->b[i] = 0;
219  } else {
220  /* This is a bit crazy, but it really is +255 not +256 */
221  fa1 = av_clip_intp2((-c->a[0]*c->pk[0]*pk0)>>5, 8);
222 
223  c->a[1] += 128*pk0*c->pk[1] + fa1 - (c->a[1]>>7);
224  c->a[1] = av_clip(c->a[1], -12288, 12288);
225  c->a[0] += 64*3*pk0*c->pk[0] - (c->a[0] >> 8);
226  c->a[0] = av_clip(c->a[0], -(15360 - c->a[1]), 15360 - c->a[1]);
227 
228  for (i=0; i<6; i++)
229  c->b[i] += 128*dq0*sgn(-c->dq[i].sign) - (c->b[i]>>8);
230  }
231 
232  /* Update Dq and Sr and Pk */
233  c->pk[1] = c->pk[0];
234  c->pk[0] = pk0 ? pk0 : 1;
235  c->sr[1] = c->sr[0];
236  i2f(re_signal, &c->sr[0]);
237  for (i=5; i>0; i--)
238  c->dq[i] = c->dq[i-1];
239  i2f(dq, &c->dq[0]);
240  c->dq[0].sign = I_sig; /* Isn't it crazy ?!?! */
241 
242  c->td = c->a[1] < -11776;
243 
244  /* Update Ap */
245  c->dms += (c->tbls.F[I]<<4) + ((- c->dms) >> 5);
246  c->dml += (c->tbls.F[I]<<4) + ((- c->dml) >> 7);
247  if (tr)
248  c->ap = 256;
249  else {
250  c->ap += (-c->ap) >> 4;
251  if (c->y <= 1535 || c->td || abs((c->dms << 2) - c->dml) >= (c->dml >> 3))
252  c->ap += 0x20;
253  }
254 
255  /* Update Yu and Yl */
256  c->yu = av_clip(c->y + c->tbls.W[I] + ((-c->y)>>5), 544, 5120);
257  c->yl += c->yu + ((-c->yl)>>6);
258 
259  /* Next iteration for Y */
260  al = (c->ap >= 256) ? 1<<6 : c->ap >> 2;
261  c->y = (c->yl + (c->yu - (c->yl>>6))*al) >> 6;
262 
263  /* Next iteration for SE and SEZ */
264  c->se = 0;
265  for (i=0; i<6; i++)
266  c->se += mult(i2f(c->b[i] >> 2, &f), &c->dq[i]);
267  c->sez = c->se >> 1;
268  for (i=0; i<2; i++)
269  c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]);
270  c->se >>= 1;
271 
272  return av_clip(re_signal * 4, -0xffff, 0xffff);
273 }
274 
276 {
277  int i;
278 
279  c->tbls = G726Tables_pool[c->code_size - 2];
280  for (i=0; i<2; i++) {
281  c->sr[i].mant = 1<<5;
282  c->pk[i] = 1;
283  }
284  for (i=0; i<6; i++) {
285  c->dq[i].mant = 1<<5;
286  }
287  c->yu = 544;
288  c->yl = 34816;
289 
290  c->y = 544;
291 
292  return 0;
293 }
294 
295 #if CONFIG_ADPCM_G726_ENCODER || CONFIG_ADPCM_G726LE_ENCODER
296 static int16_t g726_encode(G726Context* c, int16_t sig)
297 {
298  uint8_t i;
299 
300  i = av_mod_uintp2(quant(c, sig/4 - c->se), c->code_size);
301  g726_decode(c, i);
302  return i;
303 }
304 
305 /* Interfacing to the libavcodec */
306 
307 static av_cold int g726_encode_init(AVCodecContext *avctx)
308 {
309  G726Context* c = avctx->priv_data;
310 
311  c->little_endian = !strcmp(avctx->codec->name, "g726le");
312 
314  avctx->sample_rate != 8000) {
315  av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not "
316  "allowed when the compliance level is higher than unofficial. "
317  "Resample or reduce the compliance level.\n");
318  return AVERROR(EINVAL);
319  }
320  if (avctx->sample_rate <= 0) {
321  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate %d\n",
322  avctx->sample_rate);
323  return AVERROR(EINVAL);
324  }
325 
326  if(avctx->channels != 1){
327  av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n");
328  return AVERROR(EINVAL);
329  }
330 
331  if (avctx->bit_rate)
332  c->code_size = (avctx->bit_rate + avctx->sample_rate/2) / avctx->sample_rate;
333 
334  c->code_size = av_clip(c->code_size, 2, 5);
335  avctx->bit_rate = c->code_size * avctx->sample_rate;
336  avctx->bits_per_coded_sample = c->code_size;
337 
338  g726_reset(c);
339 
340  /* select a frame size that will end on a byte boundary and have a size of
341  approximately 1024 bytes */
342  avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2];
343 
344  return 0;
345 }
346 
347 static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
348  const AVFrame *frame, int *got_packet_ptr)
349 {
350  G726Context *c = avctx->priv_data;
351  const int16_t *samples = (const int16_t *)frame->data[0];
352  PutBitContext pb;
353  int i, ret, out_size;
354 
355  out_size = (frame->nb_samples * c->code_size + 7) / 8;
356  if ((ret = ff_alloc_packet2(avctx, avpkt, out_size, 0)) < 0)
357  return ret;
358  init_put_bits(&pb, avpkt->data, avpkt->size);
359 
360  for (i = 0; i < frame->nb_samples; i++)
361  if (c->little_endian) {
362  put_bits_le(&pb, c->code_size, g726_encode(c, *samples++));
363  } else {
364  put_bits(&pb, c->code_size, g726_encode(c, *samples++));
365  }
366 
367  if (c->little_endian) {
368  flush_put_bits_le(&pb);
369  } else {
370  flush_put_bits(&pb);
371  }
372 
373  avpkt->size = out_size;
374  *got_packet_ptr = 1;
375  return 0;
376 }
377 
378 #define OFFSET(x) offsetof(G726Context, x)
379 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
380 static const AVOption options[] = {
381  { "code_size", "Bits per code", OFFSET(code_size), AV_OPT_TYPE_INT, { .i64 = 4 }, 2, 5, AE },
382  { NULL },
383 };
384 
385 static const AVCodecDefault defaults[] = {
386  { "b", "0" },
387  { NULL },
388 };
389 #endif
390 
391 #if CONFIG_ADPCM_G726_ENCODER
392 static const AVClass g726_class = {
393  .class_name = "g726",
394  .item_name = av_default_item_name,
395  .option = options,
396  .version = LIBAVUTIL_VERSION_INT,
397 };
398 
400  .name = "g726",
401  .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
402  .type = AVMEDIA_TYPE_AUDIO,
404  .priv_data_size = sizeof(G726Context),
405  .init = g726_encode_init,
406  .encode2 = g726_encode_frame,
407  .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
408  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
410  .priv_class = &g726_class,
411  .defaults = defaults,
412 };
413 #endif
414 
415 #if CONFIG_ADPCM_G726LE_ENCODER
416 static const AVClass g726le_class = {
417  .class_name = "g726le",
418  .item_name = av_default_item_name,
419  .option = options,
420  .version = LIBAVUTIL_VERSION_INT,
421 };
422 
424  .name = "g726le",
425  .long_name = NULL_IF_CONFIG_SMALL("G.726 little endian ADPCM (\"right-justified\")"),
426  .type = AVMEDIA_TYPE_AUDIO,
428  .priv_data_size = sizeof(G726Context),
429  .init = g726_encode_init,
430  .encode2 = g726_encode_frame,
431  .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
432  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
434  .priv_class = &g726le_class,
435  .defaults = defaults,
436 };
437 #endif
438 
439 #if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER
440 static av_cold int g726_decode_init(AVCodecContext *avctx)
441 {
442  G726Context* c = avctx->priv_data;
443 
444  if(avctx->channels > 1){
445  avpriv_request_sample(avctx, "Decoding more than one channel");
446  return AVERROR_PATCHWELCOME;
447  }
448  avctx->channels = 1;
450 
451  c->little_endian = !strcmp(avctx->codec->name, "g726le");
452 
453  c->code_size = avctx->bits_per_coded_sample;
454  if (c->code_size < 2 || c->code_size > 5) {
455  av_log(avctx, AV_LOG_ERROR, "Invalid number of bits %d\n", c->code_size);
456  return AVERROR(EINVAL);
457  }
458  g726_reset(c);
459 
460  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
461 
462  return 0;
463 }
464 
465 static int g726_decode_frame(AVCodecContext *avctx, void *data,
466  int *got_frame_ptr, AVPacket *avpkt)
467 {
468  AVFrame *frame = data;
469  const uint8_t *buf = avpkt->data;
470  int buf_size = avpkt->size;
471  G726Context *c = avctx->priv_data;
472  int16_t *samples;
473  GetBitContext gb;
474  int out_samples, ret;
475 
476  out_samples = buf_size * 8 / c->code_size;
477 
478  /* get output buffer */
479  frame->nb_samples = out_samples;
480  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
481  return ret;
482  samples = (int16_t *)frame->data[0];
483 
484  init_get_bits(&gb, buf, buf_size * 8);
485 
486  while (out_samples--)
487  *samples++ = g726_decode(c, c->little_endian ?
488  get_bits_le(&gb, c->code_size) :
489  get_bits(&gb, c->code_size));
490 
491  if (get_bits_left(&gb) > 0)
492  av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");
493 
494  *got_frame_ptr = 1;
495 
496  return buf_size;
497 }
498 
499 static void g726_decode_flush(AVCodecContext *avctx)
500 {
501  G726Context *c = avctx->priv_data;
502  g726_reset(c);
503 }
504 #endif
505 
506 #if CONFIG_ADPCM_G726_DECODER
508  .name = "g726",
509  .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
510  .type = AVMEDIA_TYPE_AUDIO,
512  .priv_data_size = sizeof(G726Context),
513  .init = g726_decode_init,
514  .decode = g726_decode_frame,
515  .flush = g726_decode_flush,
516  .capabilities = AV_CODEC_CAP_DR1,
517 };
518 #endif
519 
520 #if CONFIG_ADPCM_G726LE_DECODER
522  .name = "g726le",
523  .type = AVMEDIA_TYPE_AUDIO,
525  .priv_data_size = sizeof(G726Context),
526  .init = g726_decode_init,
527  .decode = g726_decode_frame,
528  .flush = g726_decode_flush,
529  .capabilities = AV_CODEC_CAP_DR1,
530  .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM little-endian"),
531 };
532 #endif
sgn
static int sgn(int value)
Definition: g726.c:65
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
AVCodec
AVCodec.
Definition: codec.h:190
G726Context
Definition: g726.c:77
G726Context::tbls
G726Tables tbls
static tables needed for computation
Definition: g726.c:79
W_tbl16
static const int16_t W_tbl16[]
Definition: g726.c:105
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
iquant_tbl32
static const int16_t iquant_tbl32[]
Definition: g726.c:121
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
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
put_bits_le
static void put_bits_le(PutBitContext *s, int n, unsigned int value)
Definition: put_bits.h:212
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
Float11::mant
uint8_t mant
6 bits mantissa
Definition: g726.c:42
G726Tables::F
const uint8_t * F
special table #2
Definition: g726.c:74
G726Tables
Definition: g726.c:70
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
W_tbl32
static const int16_t W_tbl32[]
Definition: g726.c:124
G726Context::dml
int dml
long average magnitude of F[i]
Definition: g726.c:91
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
G726Context::td
int td
tone detect
Definition: g726.c:92
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:300
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
ff_adpcm_g726_encoder
AVCodec ff_adpcm_g726_encoder
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
iquant_tbl40
static const int16_t iquant_tbl40[]
Definition: g726.c:133
AVOption
AVOption.
Definition: opt.h:246
data
const char data[16]
Definition: mxf.c:91
G726Context::yl
int yl
slow scale factor
Definition: g726.c:89
iquant_tbl16
static const int16_t iquant_tbl16[]
Definition: g726.c:103
G726Tables::quant
const int * quant
quantization table
Definition: g726.c:71
quant_tbl24
static const int quant_tbl24[]
24kbit/s 3 bits per sample
Definition: g726.c:110
quant_tbl16
static const int quant_tbl16[]
16kbit/s 2 bits per sample
Definition: g726.c:101
F_tbl40
static const uint8_t F_tbl40[]
Definition: g726.c:143
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1593
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:535
g726_reset
static av_cold int g726_reset(G726Context *c)
Definition: g726.c:275
GetBitContext
Definition: get_bits.h:61
defaults
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
g726_decode
static int16_t g726_decode(G726Context *c, int I)
Definition: g726.c:193
G726Context::a
int a[2]
second order predictor coeffs
Definition: g726.c:83
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
G726Context::yu
int yu
fast scale factor
Definition: g726.c:88
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:98
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
G726Context::dq
Float11 dq[6]
prev.
Definition: g726.c:82
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:351
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
quant_tbl40
static const int quant_tbl40[]
40kbit/s 5 bits per sample
Definition: g726.c:130
quant
static uint8_t quant(G726Context *c, int d)
Paragraph 4.2.2 page 18: Adaptive quantizer.
Definition: g726.c:157
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:119
get_bits.h
limits.h
W_tbl24
static const int16_t W_tbl24[]
Definition: g726.c:114
F_tbl16
static const uint8_t F_tbl16[]
Definition: g726.c:107
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:35
G726Context::dms
int dms
short average magnitude of F[i]
Definition: g726.c:90
AVCodecDefault
Definition: internal.h:201
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
G726Tables_pool
static const G726Tables G726Tables_pool[]
Definition: g726.c:147
G726Context::sez
int sez
estimated second order prediction
Definition: g726.c:95
Float11
G.726 11-bit float.
Definition: g726.c:39
flush_put_bits_le
static void flush_put_bits_le(PutBitContext *s)
Definition: put_bits.h:122
abs
#define abs(x)
Definition: cuda_runtime.h:35
AE
#define AE
Definition: alacenc.c:655
W_tbl40
static const int16_t W_tbl40[]
Definition: g726.c:138
iquant_tbl24
static const int16_t iquant_tbl24[]
Definition: g726.c:112
exp
int8_t exp
Definition: eval.c:72
F_tbl32
static const uint8_t F_tbl32[]
Definition: g726.c:127
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
options
const OptionDef options[]
G726Context::y
int y
quantizer scaling factor for the next iteration
Definition: g726.c:96
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
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:188
i2f
static Float11 * i2f(int i, Float11 *f)
Definition: g726.c:45
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
G726Context::code_size
int code_size
Definition: g726.c:97
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
G726Context::ap
int ap
scale factor control
Definition: g726.c:87
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:668
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
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
avcodec.h
F_tbl24
static const uint8_t F_tbl24[]
Definition: g726.c:116
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:72
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:1589
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:526
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:376
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
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:72
ff_adpcm_g726_decoder
AVCodec ff_adpcm_g726_decoder
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:85
G726Context::sr
Float11 sr[2]
prev.
Definition: g726.c:81
Float11::exp
uint8_t exp
4 bits exponent
Definition: g726.c:41
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
ff_adpcm_g726le_encoder
AVCodec ff_adpcm_g726le_encoder
G726Tables::W
const int16_t * W
special table #1 ;-)
Definition: g726.c:73
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:80
G726Context::b
int b[6]
sixth order predictor coeffs
Definition: g726.c:84
Float11::sign
uint8_t sign
1 bit sign
Definition: g726.c:40
ff_alloc_packet2
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
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:183
G726Context::se
int se
estimated signal for the next iteration
Definition: g726.c:94
ff_adpcm_g726le_decoder
AVCodec ff_adpcm_g726le_decoder