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