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_zero_extend(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,
408  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME |
410  .priv_data_size = sizeof(G726Context),
411  .init = g726_encode_init,
412  FF_CODEC_ENCODE_CB(g726_encode_frame),
413  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
415  .p.priv_class = &g726_class,
416  .defaults = defaults,
417 };
418 #endif
419 
420 #if CONFIG_ADPCM_G726LE_ENCODER
422  .p.name = "g726le",
423  CODEC_LONG_NAME("G.726 little endian ADPCM (\"right-justified\")"),
424  .p.type = AVMEDIA_TYPE_AUDIO,
425  .p.id = AV_CODEC_ID_ADPCM_G726LE,
426  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME |
428  .priv_data_size = sizeof(G726Context),
429  .init = g726_encode_init,
430  FF_CODEC_ENCODE_CB(g726_encode_frame),
431  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
433  .p.priv_class = &g726_class,
434  .defaults = defaults,
435 };
436 #endif
437 
438 #if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER
439 static av_cold int g726_decode_init(AVCodecContext *avctx)
440 {
441  G726Context* c = avctx->priv_data;
442 
443  if (avctx->ch_layout.nb_channels > 1){
444  avpriv_request_sample(avctx, "Decoding more than one channel");
445  return AVERROR_PATCHWELCOME;
446  }
449 
450  c->little_endian = !strcmp(avctx->codec->name, "g726le");
451 
452  c->code_size = avctx->bits_per_coded_sample;
453  if (c->code_size < 2 || c->code_size > 5) {
454  av_log(avctx, AV_LOG_ERROR, "Invalid number of bits %d\n", c->code_size);
455  return AVERROR(EINVAL);
456  }
457  g726_reset(c);
458 
459  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
460 
461  return 0;
462 }
463 
464 static int g726_decode_frame(AVCodecContext *avctx, AVFrame *frame,
465  int *got_frame_ptr, AVPacket *avpkt)
466 {
467  const uint8_t *buf = avpkt->data;
468  int buf_size = avpkt->size;
469  G726Context *c = avctx->priv_data;
470  int16_t *samples;
471  GetBitContext gb;
472  int out_samples, ret;
473 
474  out_samples = buf_size * 8 / c->code_size;
475 
476  /* get output buffer */
477  frame->nb_samples = out_samples;
478  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
479  return ret;
480  samples = (int16_t *)frame->data[0];
481 
482  init_get_bits(&gb, buf, buf_size * 8);
483 
484  while (out_samples--)
485  *samples++ = g726_decode(c, c->little_endian ?
486  get_bits_le(&gb, c->code_size) :
487  get_bits(&gb, c->code_size));
488 
489  if (get_bits_left(&gb) > 0)
490  av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");
491 
492  *got_frame_ptr = 1;
493 
494  return buf_size;
495 }
496 
497 static void g726_decode_flush(AVCodecContext *avctx)
498 {
499  G726Context *c = avctx->priv_data;
500  g726_reset(c);
501 }
502 #endif
503 
504 #if CONFIG_ADPCM_G726_DECODER
506  .p.name = "g726",
507  CODEC_LONG_NAME("G.726 ADPCM"),
508  .p.type = AVMEDIA_TYPE_AUDIO,
509  .p.id = AV_CODEC_ID_ADPCM_G726,
510  .priv_data_size = sizeof(G726Context),
511  .init = g726_decode_init,
512  FF_CODEC_DECODE_CB(g726_decode_frame),
513  .flush = g726_decode_flush,
514  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
515 };
516 #endif
517 
518 #if CONFIG_ADPCM_G726LE_DECODER
520  .p.name = "g726le",
521  .p.type = AVMEDIA_TYPE_AUDIO,
522  .p.id = AV_CODEC_ID_ADPCM_G726LE,
523  .priv_data_size = sizeof(G726Context),
524  .init = g726_decode_init,
525  FF_CODEC_DECODE_CB(g726_decode_frame),
526  .flush = g726_decode_flush,
527  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
528  CODEC_LONG_NAME("G.726 ADPCM little-endian"),
529 };
530 #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:1077
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:100
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:695
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:1050
defaults
static const FFCodecDefault defaults[]
Definition: amfenc_av1.c:488
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
out_size
int out_size
Definition: movenc.c:56
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:374
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
AVPacket::data
uint8_t * data
Definition: packet.h:520
iquant_tbl40
static const int16_t iquant_tbl40[]
Definition: g726.c:138
AVOption
AVOption.
Definition: opt.h:357
encode.h
FFCodec
Definition: codec_internal.h:126
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:321
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:514
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
g726_reset
static av_cold int g726_reset(G726Context *c)
Definition: g726.c:280
GetBitContext
Definition: get_bits.h:108
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:295
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:378
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
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:356
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:271
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:121
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:495
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:622
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:73
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_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
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:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:521
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:311
codec_internal.h
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
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
av_zero_extend
#define av_zero_extend
Definition: common.h:151
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:1568
G726Context::ap
int ap
scale factor control
Definition: g726.c:92
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:590
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:194
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:1379
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:445
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:402
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:106
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
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:437
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
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:386
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
d
d
Definition: ffmpeg_filter.c:424
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:81
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