FFmpeg
bonk.c
Go to the documentation of this file.
1 /*
2  * Bonk audio decoder
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/internal.h"
22 #include "libavutil/intreadwrite.h"
23 #include "avcodec.h"
24 #include "codec_internal.h"
25 #include "decode.h"
26 #define BITSTREAM_READER_LE
27 #include "get_bits.h"
28 #include "bytestream.h"
29 
30 typedef struct BitCount {
31  uint8_t bit;
32  unsigned count;
33 } BitCount;
34 
35 typedef struct BonkContext {
37  int skip;
38 
39  uint8_t *bitstream;
40  int64_t max_framesize;
43 
44  uint64_t nb_samples;
45  int lossless;
46  int mid_side;
47  int n_taps;
50 
51  int state[2][2048], k[2048];
52  int *samples[2];
54  uint8_t quant[2048];
56 } BonkContext;
57 
58 static av_cold int bonk_close(AVCodecContext *avctx)
59 {
60  BonkContext *s = avctx->priv_data;
61 
62  av_freep(&s->bitstream);
63  av_freep(&s->input_samples);
64  av_freep(&s->samples[0]);
65  av_freep(&s->samples[1]);
66  av_freep(&s->bits);
67  s->bitstream_size = 0;
68 
69  return 0;
70 }
71 
72 static av_cold int bonk_init(AVCodecContext *avctx)
73 {
74  BonkContext *s = avctx->priv_data;
75 
77  if (avctx->extradata_size < 17)
78  return AVERROR(EINVAL);
79 
80  if (avctx->extradata[0]) {
81  av_log(avctx, AV_LOG_ERROR, "Unsupported version.\n");
82  return AVERROR_INVALIDDATA;
83  }
84 
85  if (avctx->ch_layout.nb_channels < 1 || avctx->ch_layout.nb_channels > 2)
86  return AVERROR_INVALIDDATA;
87 
88  s->nb_samples = AV_RL32(avctx->extradata + 1) / avctx->ch_layout.nb_channels;
89  if (!s->nb_samples)
90  s->nb_samples = UINT64_MAX;
91  s->lossless = avctx->extradata[10] != 0;
92  s->mid_side = avctx->extradata[11] != 0;
93  s->n_taps = AV_RL16(avctx->extradata + 12);
94  if (!s->n_taps || s->n_taps > 2048)
95  return AVERROR(EINVAL);
96 
97  s->down_sampling = avctx->extradata[14];
98  if (!s->down_sampling)
99  return AVERROR(EINVAL);
100 
101  s->samples_per_packet = AV_RL16(avctx->extradata + 15);
102  if (!s->samples_per_packet)
103  return AVERROR(EINVAL);
104 
105  if (s->down_sampling * s->samples_per_packet < s->n_taps)
106  return AVERROR_INVALIDDATA;
107 
108  s->max_framesize = s->samples_per_packet * avctx->ch_layout.nb_channels * s->down_sampling * 16LL;
109  if (s->max_framesize > (INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 8)
110  return AVERROR_INVALIDDATA;
111 
112  s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE, sizeof(*s->bitstream));
113  if (!s->bitstream)
114  return AVERROR(ENOMEM);
115 
116  s->input_samples = av_calloc(s->samples_per_packet, sizeof(*s->input_samples));
117  if (!s->input_samples)
118  return AVERROR(ENOMEM);
119 
120  s->samples[0] = av_calloc(s->samples_per_packet * s->down_sampling, sizeof(*s->samples[0]));
121  s->samples[1] = av_calloc(s->samples_per_packet * s->down_sampling, sizeof(*s->samples[0]));
122  if (!s->samples[0] || !s->samples[1])
123  return AVERROR(ENOMEM);
124 
125  s->bits = av_calloc(s->max_framesize * 8, sizeof(*s->bits));
126  if (!s->bits)
127  return AVERROR(ENOMEM);
128 
129  for (int i = 0; i < 512; i++) {
130  s->quant[i] = sqrt(i + 1);
131  }
132 
133  return 0;
134 }
135 
136 static unsigned read_uint_max(BonkContext *s, uint32_t max)
137 {
138  unsigned value = 0;
139 
140  if (max == 0)
141  return 0;
142 
143  av_assert0(max >> 31 == 0);
144 
145  for (unsigned i = 1; i <= max - value; i+=i)
146  if (get_bits1(&s->gb))
147  value += i;
148 
149  return value;
150 }
151 
152 static int intlist_read(BonkContext *s, int *buf, int entries, int base_2_part)
153 {
154  int i, low_bits = 0, x = 0, max_x;
155  int n_zeros = 0, step = 256, dominant = 0;
156  int pos = 0, level = 0;
157  BitCount *bits = s->bits;
158  int passes = 1;
159 
160  memset(buf, 0, entries * sizeof(*buf));
161  if (base_2_part) {
162  low_bits = get_bits(&s->gb, 4);
163 
164  if (low_bits)
165  for (i = 0; i < entries; i++)
166  buf[i] = get_bits(&s->gb, low_bits);
167  }
168 
169  while (n_zeros < entries) {
170  int steplet = step >> 8;
171 
172  if (get_bits_left(&s->gb) <= 0)
173  return AVERROR_INVALIDDATA;
174 
175  if (!get_bits1(&s->gb)) {
176  av_assert0(steplet >= 0);
177 
178  if (steplet > 0) {
179  bits[x ].bit = dominant;
180  bits[x++].count = steplet;
181  }
182 
183  if (!dominant)
184  n_zeros += steplet;
185 
186  if (step > INT32_MAX*8LL/9 + 1)
187  return AVERROR_INVALIDDATA;
188  step += step / 8;
189  } else if (steplet > 0) {
190  int actual_run = read_uint_max(s, steplet - 1);
191 
192  av_assert0(actual_run >= 0);
193 
194  if (actual_run > 0) {
195  bits[x ].bit = dominant;
196  bits[x++].count = actual_run;
197  }
198 
199  bits[x ].bit = !dominant;
200  bits[x++].count = 1;
201 
202  if (!dominant)
203  n_zeros += actual_run;
204  else
205  n_zeros++;
206 
207  step -= step / 8;
208  }
209 
210  if (step < 256) {
211  step = 65536 / step;
212  dominant = !dominant;
213  }
214  }
215 
216  max_x = x;
217  x = 0;
218  n_zeros = 0;
219  for (i = 0; n_zeros < entries; i++) {
220  if (x >= max_x)
221  return AVERROR_INVALIDDATA;
222 
223  if (pos >= entries) {
224  pos = 0;
225  level += passes << low_bits;
226  passes = 1;
227  if (bits[x].bit && bits[x].count > entries - n_zeros)
228  passes = bits[x].count / (entries - n_zeros);
229  }
230 
231  if (level > 1 << 16)
232  return AVERROR_INVALIDDATA;
233 
234  if (buf[pos] >= level) {
235  if (bits[x].bit)
236  buf[pos] += passes << low_bits;
237  else
238  n_zeros++;
239 
240  av_assert1(bits[x].count >= passes);
241  bits[x].count -= passes;
242  x += bits[x].count == 0;
243  }
244 
245  pos++;
246  }
247 
248  for (i = 0; i < entries; i++) {
249  if (buf[i] && get_bits1(&s->gb)) {
250  buf[i] = -buf[i];
251  }
252  }
253 
254  return 0;
255 }
256 
257 static inline int shift_down(int a, int b)
258 {
259  return (a >> b) + (a < 0);
260 }
261 
262 static inline int shift(int a, int b)
263 {
264  return a + (1 << b - 1) >> b;
265 }
266 
267 #define LATTICE_SHIFT 10
268 #define SAMPLE_SHIFT 4
269 #define SAMPLE_FACTOR (1 << SAMPLE_SHIFT)
270 
271 static int predictor_calc_error(int *k, int *state, int order, int error)
272 {
273  int i, x = error - (unsigned)shift_down(k[order-1] * (unsigned)state[order-1], LATTICE_SHIFT);
274  int *k_ptr = &(k[order-2]),
275  *state_ptr = &(state[order-2]);
276 
277  for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--) {
278  unsigned k_value = *k_ptr, state_value = *state_ptr;
279 
280  x -= (unsigned) shift_down(k_value * (unsigned)state_value, LATTICE_SHIFT);
281  state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT);
282  }
283 
284  // don't drift too far, to avoid overflows
285  x = av_clip(x, -(SAMPLE_FACTOR << 16), SAMPLE_FACTOR << 16);
286 
287  state[0] = x;
288 
289  return x;
290 }
291 
292 static void predictor_init_state(int *k, unsigned *state, int order)
293 {
294  for (int i = order - 2; i >= 0; i--) {
295  unsigned x = state[i];
296 
297  for (int j = 0, p = i + 1; p < order; j++, p++) {
298  int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
299 
300  state[p] += shift_down(k[j] * x, LATTICE_SHIFT);
301  x = tmp;
302  }
303  }
304 }
305 
307  int *got_frame_ptr, AVPacket *pkt)
308 {
309  BonkContext *s = avctx->priv_data;
310  GetBitContext *gb = &s->gb;
311  const uint8_t *buf;
312  int quant, n, buf_size, input_buf_size;
313  int ret = AVERROR_INVALIDDATA;
314 
315  if ((!pkt->size && !s->bitstream_size) || s->nb_samples == 0) {
316  *got_frame_ptr = 0;
317  return pkt->size;
318  }
319 
320  buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
321  input_buf_size = buf_size;
322  if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE > s->max_framesize) {
323  memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
324  s->bitstream_index = 0;
325  }
326  if (pkt->data)
327  memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
328  buf = &s->bitstream[s->bitstream_index];
329  buf_size += s->bitstream_size;
330  s->bitstream_size = buf_size;
331  if (buf_size < s->max_framesize && pkt->data) {
332  *got_frame_ptr = 0;
333  return input_buf_size;
334  }
335 
336  frame->nb_samples = FFMIN(s->samples_per_packet * s->down_sampling, s->nb_samples);
337  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
338  goto fail;
339 
340  if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
341  goto fail;
342 
343  skip_bits(gb, s->skip);
344  if ((ret = intlist_read(s, s->k, s->n_taps, 0)) < 0)
345  goto fail;
346 
347  for (int i = 0; i < s->n_taps; i++)
348  s->k[i] *= s->quant[i];
349  quant = s->lossless ? 1 : get_bits(&s->gb, 16) * SAMPLE_FACTOR;
350 
351  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
352  const int samples_per_packet = s->samples_per_packet;
353  const int down_sampling = s->down_sampling;
354  const int offset = samples_per_packet * down_sampling - 1;
355  int *state = s->state[ch];
356  int *sample = s->samples[ch];
357 
358  predictor_init_state(s->k, state, s->n_taps);
359  if ((ret = intlist_read(s, s->input_samples, samples_per_packet, 1)) < 0)
360  goto fail;
361 
362  for (int i = 0; i < samples_per_packet; i++) {
363  for (int j = 0; j < s->down_sampling - 1; j++) {
364  sample[0] = predictor_calc_error(s->k, state, s->n_taps, 0);
365  sample++;
366  }
367 
368  sample[0] = predictor_calc_error(s->k, state, s->n_taps, s->input_samples[i] * (unsigned)quant);
369  sample++;
370  }
371 
372  sample = s->samples[ch];
373  for (int i = 0; i < s->n_taps; i++)
374  state[i] = sample[offset - i];
375  }
376 
377  if (s->mid_side && avctx->ch_layout.nb_channels == 2) {
378  for (int i = 0; i < frame->nb_samples; i++) {
379  s->samples[1][i] += shift(s->samples[0][i], 1);
380  s->samples[0][i] -= s->samples[1][i];
381  }
382  }
383 
384  if (!s->lossless) {
385  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
386  int *samples = s->samples[ch];
387  for (int i = 0; i < frame->nb_samples; i++)
388  samples[i] = shift(samples[i], 4);
389  }
390  }
391 
392  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
393  int16_t *osamples = (int16_t *)frame->extended_data[ch];
394  int *samples = s->samples[ch];
395  for (int i = 0; i < frame->nb_samples; i++)
396  osamples[i] = av_clip_int16(samples[i]);
397  }
398 
399  s->nb_samples -= frame->nb_samples;
400 
401  s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
402  n = get_bits_count(gb) / 8;
403 
404  if (n > buf_size) {
405 fail:
406  s->bitstream_size = 0;
407  s->bitstream_index = 0;
408  return AVERROR_INVALIDDATA;
409  }
410 
411  *got_frame_ptr = 1;
412 
413  if (s->bitstream_size) {
414  s->bitstream_index += n;
415  s->bitstream_size -= n;
416  return input_buf_size;
417  }
418  return n;
419 }
420 
422  .p.name = "bonk",
423  CODEC_LONG_NAME("Bonk audio"),
424  .p.type = AVMEDIA_TYPE_AUDIO,
425  .p.id = AV_CODEC_ID_BONK,
426  .priv_data_size = sizeof(BonkContext),
427  .init = bonk_init,
429  .close = bonk_close,
430  .p.capabilities = AV_CODEC_CAP_DELAY |
431 #if FF_API_SUBFRAMES
432  AV_CODEC_CAP_SUBFRAMES |
433 #endif
435  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
436  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
438 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:98
SAMPLE_FACTOR
#define SAMPLE_FACTOR
Definition: bonk.c:269
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
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
BonkContext::gb
GetBitContext gb
Definition: bonk.c:36
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
shift_down
static int shift_down(int a, int b)
Definition: bonk.c:257
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AVPacket::data
uint8_t * data
Definition: packet.h:522
read_uint_max
static unsigned read_uint_max(BonkContext *s, uint32_t max)
Definition: bonk.c:136
b
#define b
Definition: input.c:41
BonkContext::samples_per_packet
int samples_per_packet
Definition: bonk.c:49
FFCodec
Definition: codec_internal.h:127
BitCount::count
unsigned count
Definition: bonk.c:32
max
#define max(a, b)
Definition: cuda_runtime.h:33
BonkContext::mid_side
int mid_side
Definition: bonk.c:46
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
BitCount::bit
uint8_t bit
Definition: bonk.c:31
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2111
fail
#define fail()
Definition: checkasm.h:179
predictor_calc_error
static int predictor_calc_error(int *k, int *state, int order, int error)
Definition: bonk.c:271
state
static struct @377 state
GetBitContext
Definition: get_bits.h:108
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
bonk_decode
static int bonk_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *pkt)
Definition: bonk.c:306
LATTICE_SHIFT
#define LATTICE_SHIFT
Definition: bonk.c:267
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
BonkContext
Definition: bonk.c:35
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
BonkContext::bitstream_index
int bitstream_index
Definition: bonk.c:42
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
BonkContext::samples
int * samples[2]
Definition: bonk.c:52
bonk_init
static av_cold int bonk_init(AVCodecContext *avctx)
Definition: bonk.c:72
decode.h
get_bits.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
av_clip_int16
#define av_clip_int16
Definition: common.h:113
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
BonkContext::input_samples
int * input_samples
Definition: bonk.c:53
BonkContext::k
int k[2048]
Definition: bonk.c:51
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:262
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1084
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
sample
#define sample
Definition: flacdsp_template.c:44
BonkContext::down_sampling
int down_sampling
Definition: bonk.c:48
BonkContext::n_taps
int n_taps
Definition: bonk.c:47
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
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 offset
Definition: writing_filters.txt:86
BonkContext::lossless
int lossless
Definition: bonk.c:45
BonkContext::bits
BitCount * bits
Definition: bonk.c:55
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
BonkContext::quant
uint8_t quant[2048]
Definition: bonk.c:54
internal.h
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AV_CODEC_ID_BONK
@ AV_CODEC_ID_BONK
Definition: codec_id.h:540
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
BonkContext::max_framesize
int64_t max_framesize
Definition: bonk.c:40
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
avcodec.h
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:413
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
ff_bonk_decoder
const FFCodec ff_bonk_decoder
Definition: bonk.c:421
BitCount
Definition: bonk.c:30
AVCodecContext
main external API structure.
Definition: avcodec.h:445
BonkContext::skip
int skip
Definition: bonk.c:37
BonkContext::state
int state[2][2048]
Definition: bonk.c:51
intlist_read
static int intlist_read(BonkContext *s, int *buf, int entries, int base_2_part)
Definition: bonk.c:152
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
BonkContext::nb_samples
uint64_t nb_samples
Definition: bonk.c:44
BonkContext::bitstream
uint8_t * bitstream
Definition: bonk.c:39
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
bytestream.h
BonkContext::bitstream_size
int bitstream_size
Definition: bonk.c:41
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
bonk_close
static av_cold int bonk_close(AVCodecContext *avctx)
Definition: bonk.c:58
samples_per_packet
static uint32_t samples_per_packet(const AVCodecParameters *par)
Definition: cafenc.c:56
predictor_init_state
static void predictor_init_state(int *k, unsigned *state, int order)
Definition: bonk.c:292