FFmpeg
osq.c
Go to the documentation of this file.
1 /*
2  * OSQ audio decoder
3  * Copyright (c) 2023 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/internal.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/mem.h"
25 #include "avcodec.h"
26 #include "codec_internal.h"
27 #include "decode.h"
28 #include "internal.h"
29 #define BITSTREAM_READER_LE
30 #include "get_bits.h"
31 #include "unary.h"
32 
33 #define OFFSET 5
34 
35 typedef struct OSQChannel {
36  unsigned prediction;
37  unsigned coding_mode;
39  unsigned residue_bits;
40  unsigned history[3];
41  unsigned pos, count;
42  double sum;
44 } OSQChannel;
45 
46 typedef struct OSQContext {
49 
50  uint8_t *bitstream;
51  size_t max_framesize;
53 
54  int factor;
57  uint64_t nb_samples;
58 
60 
63 } OSQContext;
64 
65 static void osq_flush(AVCodecContext *avctx)
66 {
67  OSQContext *s = avctx->priv_data;
68 
69  s->bitstream_size = 0;
70  s->pkt_offset = 0;
71 }
72 
73 static av_cold int osq_close(AVCodecContext *avctx)
74 {
75  OSQContext *s = avctx->priv_data;
76 
77  av_freep(&s->bitstream);
78  s->bitstream_size = 0;
79 
80  for (int ch = 0; ch < FF_ARRAY_ELEMS(s->decode_buffer); ch++)
81  av_freep(&s->decode_buffer[ch]);
82 
83  return 0;
84 }
85 
86 static av_cold int osq_init(AVCodecContext *avctx)
87 {
88  OSQContext *s = avctx->priv_data;
89 
90  if (avctx->extradata_size < 48)
91  return AVERROR(EINVAL);
92 
93  if (avctx->extradata[0] != 1) {
94  av_log(avctx, AV_LOG_ERROR, "Unsupported version.\n");
95  return AVERROR_INVALIDDATA;
96  }
97 
98  avctx->sample_rate = AV_RL32(avctx->extradata + 4);
99  if (avctx->sample_rate < 1)
100  return AVERROR_INVALIDDATA;
101 
104  avctx->ch_layout.nb_channels = avctx->extradata[3];
105  if (avctx->ch_layout.nb_channels < 1)
106  return AVERROR_INVALIDDATA;
107  if (avctx->ch_layout.nb_channels > FF_ARRAY_ELEMS(s->decode_buffer))
108  return AVERROR_INVALIDDATA;
109 
110  s->factor = 1;
111  switch (avctx->extradata[2]) {
112  case 8: avctx->sample_fmt = AV_SAMPLE_FMT_U8P; break;
113  case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P; break;
114  case 20:
115  case 24: s->factor = 256;
116  avctx->sample_fmt = AV_SAMPLE_FMT_S32P; break;
117  default: return AVERROR_INVALIDDATA;
118  }
119 
120  avctx->bits_per_raw_sample = avctx->extradata[2];
121  s->nb_samples = AV_RL64(avctx->extradata + 16);
122  s->frame_samples = AV_RL16(avctx->extradata + 8);
123  s->max_framesize = (s->frame_samples * 16 + 1024) * avctx->ch_layout.nb_channels;
124 
125  s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE, sizeof(*s->bitstream));
126  if (!s->bitstream)
127  return AVERROR(ENOMEM);
128 
129  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
130  s->decode_buffer[ch] = av_calloc(s->frame_samples + OFFSET,
131  sizeof(*s->decode_buffer[ch]));
132  if (!s->decode_buffer[ch])
133  return AVERROR(ENOMEM);
134  }
135 
136  s->pkt = avctx->internal->in_pkt;
137 
138  return 0;
139 }
140 
141 static void reset_stats(OSQChannel *cb)
142 {
143  memset(cb->history, 0, sizeof(cb->history));
144  cb->pos = cb->count = cb->sum = 0;
145 }
146 
147 static void update_stats(OSQChannel *cb, int val)
148 {
149  cb->sum += FFABS(val) - cb->history[cb->pos];
150  cb->history[cb->pos] = FFABS(val);
151  cb->pos++;
152  cb->count++;
153  if (cb->pos >= FF_ARRAY_ELEMS(cb->history))
154  cb->pos = 0;
155 }
156 
158 {
159  double sum, x;
160  int rice_k;
161 
162  sum = cb->sum;
163  x = sum / cb->count;
164  rice_k = av_ceil_log2(x);
165  if (rice_k >= 30) {
166  rice_k = floor(sum / 1.4426952 + 0.5);
167  if (rice_k < 1)
168  rice_k = 1;
169  }
170 
171  return rice_k;
172 }
173 
174 static uint32_t get_urice(GetBitContext *gb, int k)
175 {
176  uint32_t z, x, b;
177 
178  x = get_unary(gb, 1, 512);
179  b = get_bits_long(gb, k);
180  z = b | x << k;
181 
182  return z;
183 }
184 
185 static int32_t get_srice(GetBitContext *gb, int x)
186 {
187  int32_t y = get_urice(gb, x);
188  return get_bits1(gb) ? -y : y;
189 }
190 
191 static int osq_channel_parameters(AVCodecContext *avctx, int ch)
192 {
193  OSQContext *s = avctx->priv_data;
194  OSQChannel *cb = &s->ch[ch];
195  GetBitContext *gb = &s->gb;
196 
197  cb->prev = 0;
198  cb->prediction = get_urice(gb, 5);
199  cb->coding_mode = get_urice(gb, 3);
200  if (cb->prediction >= 15)
201  return AVERROR_INVALIDDATA;
202  if (cb->coding_mode > 0 && cb->coding_mode < 3) {
203  cb->residue_parameter = get_urice(gb, 4);
204  if (!cb->residue_parameter || cb->residue_parameter >= 31)
205  return AVERROR_INVALIDDATA;
206  } else if (cb->coding_mode == 3) {
207  cb->residue_bits = get_urice(gb, 4);
208  if (!cb->residue_bits || cb->residue_bits >= 31)
209  return AVERROR_INVALIDDATA;
210  } else if (cb->coding_mode) {
211  return AVERROR_INVALIDDATA;
212  }
213 
214  if (cb->coding_mode == 2)
215  reset_stats(cb);
216 
217  return 0;
218 }
219 
220 #define A (-1)
221 #define B (-2)
222 #define C (-3)
223 #define D (-4)
224 #define E (-5)
225 #define P2 (((unsigned)dst[A] + dst[A]) - dst[B])
226 #define P3 (((unsigned)dst[A] - dst[B]) * 3 + dst[C])
227 
228 static int do_decode(AVCodecContext *avctx, AVFrame *frame, int decorrelate, int downsample)
229 {
230  OSQContext *s = avctx->priv_data;
231  const int nb_channels = avctx->ch_layout.nb_channels;
232  const int nb_samples = frame->nb_samples;
233  GetBitContext *gb = &s->gb;
234 
235  for (int n = 0; n < nb_samples; n++) {
236  for (int ch = 0; ch < nb_channels; ch++) {
237  OSQChannel *cb = &s->ch[ch];
238  int32_t *dst = s->decode_buffer[ch] + OFFSET;
239  int32_t p, prev = cb->prev;
240 
241  if (nb_channels == 2 && ch == 1 && decorrelate != s->decorrelate) {
242  if (!decorrelate) {
243  s->decode_buffer[1][OFFSET+A] += s->decode_buffer[0][OFFSET+B];
244  s->decode_buffer[1][OFFSET+B] += s->decode_buffer[0][OFFSET+C];
245  s->decode_buffer[1][OFFSET+C] += s->decode_buffer[0][OFFSET+D];
246  s->decode_buffer[1][OFFSET+D] += s->decode_buffer[0][OFFSET+E];
247  } else {
248  s->decode_buffer[1][OFFSET+A] -= s->decode_buffer[0][OFFSET+B];
249  s->decode_buffer[1][OFFSET+B] -= s->decode_buffer[0][OFFSET+C];
250  s->decode_buffer[1][OFFSET+C] -= s->decode_buffer[0][OFFSET+D];
251  s->decode_buffer[1][OFFSET+D] -= s->decode_buffer[0][OFFSET+E];
252  }
253  s->decorrelate = decorrelate;
254  }
255 
256  if (!cb->coding_mode) {
257  dst[n] = 0;
258  } else if (cb->coding_mode == 3) {
259  dst[n] = get_sbits_long(gb, cb->residue_bits);
260  } else {
261  dst[n] = get_srice(gb, cb->residue_parameter);
262  }
263 
264  if (get_bits_left(gb) < 0) {
265  av_log(avctx, AV_LOG_ERROR, "overread!\n");
266  return AVERROR_INVALIDDATA;
267  }
268 
269  p = prev / 2;
270  prev = dst[n];
271 
272  switch (cb->prediction) {
273  case 0:
274  break;
275  case 1:
276  dst[n] += (unsigned)dst[A];
277  break;
278  case 2:
279  dst[n] += (unsigned)dst[A] + p;
280  break;
281  case 3:
282  dst[n] += P2;
283  break;
284  case 4:
285  dst[n] += P2 + p;
286  break;
287  case 5:
288  dst[n] += P3;
289  break;
290  case 6:
291  dst[n] += P3 + p;
292  break;
293  case 7:
294  dst[n] += (int)(P2 + P3) / 2 + (unsigned)p;
295  break;
296  case 8:
297  dst[n] += (int)(P2 + P3) / 2;
298  break;
299  case 9:
300  dst[n] += (int)(P2 * 2 + P3) / 3 + (unsigned)p;
301  break;
302  case 10:
303  dst[n] += (int)(P2 + P3 * 2) / 3 + (unsigned)p;
304  break;
305  case 11:
306  dst[n] += (int)((unsigned)dst[A] + dst[B]) / 2;
307  break;
308  case 12:
309  dst[n] += (unsigned)dst[B];
310  break;
311  case 13:
312  dst[n] += (int)(unsigned)(dst[D] + dst[B]) / 2;
313  break;
314  case 14:
315  dst[n] += (int)((unsigned)P2 + dst[A]) / 2 + (unsigned)p;
316  break;
317  default:
318  return AVERROR_INVALIDDATA;
319  }
320 
321  cb->prev = prev;
322 
323  if (downsample)
324  dst[n] *= 256;
325 
326  dst[E] = dst[D];
327  dst[D] = dst[C];
328  dst[C] = dst[B];
329  dst[B] = dst[A];
330  dst[A] = dst[n];
331 
332  if (cb->coding_mode == 2) {
333  update_stats(cb, dst[n]);
334  cb->residue_parameter = update_residue_parameter(cb);
335  }
336 
337  if (nb_channels == 2 && ch == 1) {
338  if (decorrelate)
339  dst[n] += s->decode_buffer[0][OFFSET+n];
340  }
341 
342  if (downsample)
343  dst[A] /= 256;
344  }
345  }
346 
347  return 0;
348 }
349 
351 {
352  const int nb_channels = avctx->ch_layout.nb_channels;
353  const int nb_samples = frame->nb_samples;
354  OSQContext *s = avctx->priv_data;
355  const int factor = s->factor;
356  int ret, decorrelate, downsample;
357  GetBitContext *gb = &s->gb;
358 
359  skip_bits1(gb);
360  decorrelate = get_bits1(gb);
361  downsample = get_bits1(gb);
362 
363  for (int ch = 0; ch < nb_channels; ch++) {
364  if ((ret = osq_channel_parameters(avctx, ch)) < 0) {
365  av_log(avctx, AV_LOG_ERROR, "invalid channel parameters\n");
366  return ret;
367  }
368  }
369 
370  if ((ret = do_decode(avctx, frame, decorrelate, downsample)) < 0)
371  return ret;
372 
373  align_get_bits(gb);
374 
375  switch (avctx->sample_fmt) {
376  case AV_SAMPLE_FMT_U8P:
377  for (int ch = 0; ch < nb_channels; ch++) {
378  uint8_t *dst = (uint8_t *)frame->extended_data[ch];
379  int32_t *src = s->decode_buffer[ch] + OFFSET;
380 
381  for (int n = 0; n < nb_samples; n++)
382  dst[n] = av_clip_uint8(src[n] + 0x80);
383  }
384  break;
385  case AV_SAMPLE_FMT_S16P:
386  for (int ch = 0; ch < nb_channels; ch++) {
387  int16_t *dst = (int16_t *)frame->extended_data[ch];
388  int32_t *src = s->decode_buffer[ch] + OFFSET;
389 
390  for (int n = 0; n < nb_samples; n++)
391  dst[n] = (int16_t)src[n];
392  }
393  break;
394  case AV_SAMPLE_FMT_S32P:
395  for (int ch = 0; ch < nb_channels; ch++) {
396  int32_t *dst = (int32_t *)frame->extended_data[ch];
397  int32_t *src = s->decode_buffer[ch] + OFFSET;
398 
399  for (int n = 0; n < nb_samples; n++)
400  dst[n] = src[n] * factor;
401  }
402  break;
403  default:
404  return AVERROR_BUG;
405  }
406 
407  return 0;
408 }
409 
411 {
412  OSQContext *s = avctx->priv_data;
413  GetBitContext *gb = &s->gb;
414  int ret, n;
415 
416  while (s->bitstream_size < s->max_framesize) {
417  int size;
418 
419  if (!s->pkt->data) {
420  ret = ff_decode_get_packet(avctx, s->pkt);
421  if (ret == AVERROR_EOF && s->bitstream_size > 0)
422  break;
423  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
424  return ret;
425  if (ret < 0)
426  goto fail;
427  }
428 
429  size = FFMIN(s->pkt->size - s->pkt_offset, s->max_framesize - s->bitstream_size);
430  memcpy(s->bitstream + s->bitstream_size, s->pkt->data + s->pkt_offset, size);
431  s->bitstream_size += size;
432  s->pkt_offset += size;
433 
434  if (s->pkt_offset == s->pkt->size) {
435  av_packet_unref(s->pkt);
436  s->pkt_offset = 0;
437  }
438  }
439 
440  frame->nb_samples = FFMIN(s->frame_samples, s->nb_samples);
441  if (frame->nb_samples <= 0)
442  return AVERROR_EOF;
443 
444  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
445  goto fail;
446 
447  if ((ret = init_get_bits8(gb, s->bitstream, s->bitstream_size)) < 0)
448  goto fail;
449 
450  if ((ret = osq_decode_block(avctx, frame)) < 0)
451  goto fail;
452 
453  s->nb_samples -= frame->nb_samples;
454 
455  n = get_bits_count(gb) / 8;
456  if (n > s->bitstream_size) {
458  goto fail;
459  }
460 
461  memmove(s->bitstream, &s->bitstream[n], s->bitstream_size - n);
462  s->bitstream_size -= n;
463 
464  return 0;
465 
466 fail:
467  s->bitstream_size = 0;
468  s->pkt_offset = 0;
469  av_packet_unref(s->pkt);
470 
471  return ret;
472 }
473 
475  .p.name = "osq",
476  CODEC_LONG_NAME("OSQ (Original Sound Quality)"),
477  .p.type = AVMEDIA_TYPE_AUDIO,
478  .p.id = AV_CODEC_ID_OSQ,
479  .priv_data_size = sizeof(OSQContext),
480  .init = osq_init,
482  .close = osq_close,
483  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
485  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
486  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
490  .flush = osq_flush,
491 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:221
decorrelate
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1508
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: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
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:242
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
D
#define D
Definition: osq.c:223
OSQContext::bitstream_size
size_t bitstream_size
Definition: osq.c:52
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
OSQContext::decode_buffer
int32_t * decode_buffer[2]
Definition: osq.c:59
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
osq_flush
static void osq_flush(AVCodecContext *avctx)
Definition: osq.c:65
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
OSQChannel::prev
int32_t prev
Definition: osq.c:43
OSQContext::ch
OSQChannel ch[2]
Definition: osq.c:48
internal.h
b
#define b
Definition: input.c:41
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
FFCodec
Definition: codec_internal.h:127
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
OSQChannel::residue_parameter
unsigned residue_parameter
Definition: osq.c:38
do_decode
static int do_decode(AVCodecContext *avctx, AVFrame *frame, int decorrelate, int downsample)
Definition: osq.c:228
P3
#define P3
Definition: osq.c:226
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
av_ceil_log2
#define av_ceil_log2
Definition: common.h:96
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
fail
#define fail()
Definition: checkasm.h:179
OSQContext::pkt_offset
int pkt_offset
Definition: osq.c:62
GetBitContext
Definition: get_bits.h:108
OSQContext::max_framesize
size_t max_framesize
Definition: osq.c:51
OSQChannel::coding_mode
unsigned coding_mode
Definition: osq.c:37
val
static double val(void *priv, double ch)
Definition: aeval.c:78
OFFSET
#define OFFSET
Definition: osq.c:33
OSQChannel::count
unsigned count
Definition: osq.c:41
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
OSQContext::nb_samples
uint64_t nb_samples
Definition: osq.c:57
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1574
C
#define C
Definition: osq.c:222
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
OSQContext
Definition: osq.c:46
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
update_residue_parameter
static int update_residue_parameter(OSQChannel *cb)
Definition: osq.c:157
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
OSQContext::factor
int factor
Definition: osq.c:54
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
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
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1554
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
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
codec_internal.h
OSQChannel::sum
double sum
Definition: osq.c:42
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:1057
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
E
#define E
Definition: osq.c:224
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
OSQChannel::residue_bits
unsigned residue_bits
Definition: osq.c:39
OSQContext::pkt
AVPacket * pkt
Definition: osq.c:61
osq_decode_block
static int osq_decode_block(AVCodecContext *avctx, AVFrame *frame)
Definition: osq.c:350
OSQContext::gb
GetBitContext gb
Definition: osq.c:47
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
internal.h
OSQChannel
Definition: osq.c:35
AVCodecInternal::in_pkt
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition: internal.h:74
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
OSQChannel::history
unsigned history[3]
Definition: osq.c:40
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
osq_receive_frame
static int osq_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: osq.c:410
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
OSQContext::bitstream
uint8_t * bitstream
Definition: osq.c:50
reset_stats
static void reset_stats(OSQChannel *cb)
Definition: osq.c:141
OSQContext::frame_samples
int frame_samples
Definition: osq.c:56
OSQContext::decorrelate
int decorrelate
Definition: osq.c:55
ret
ret
Definition: filter_design.txt:187
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
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:561
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
AVCodecContext
main external API structure.
Definition: avcodec.h:445
FF_CODEC_RECEIVE_FRAME_CB
#define FF_CODEC_RECEIVE_FRAME_CB(func)
Definition: codec_internal.h:293
osq_init
static av_cold int osq_init(AVCodecContext *avctx)
Definition: osq.c:86
get_urice
static uint32_t get_urice(GetBitContext *gb, int k)
Definition: osq.c:174
ff_osq_decoder
const FFCodec ff_osq_decoder
Definition: osq.c:474
osq_close
static av_cold int osq_close(AVCodecContext *avctx)
Definition: osq.c:73
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:433
av_clip_uint8
#define av_clip_uint8
Definition: common.h:105
factor
static const int factor[16]
Definition: vf_pp7.c:79
mem.h
update_stats
static void update_stats(OSQChannel *cb, int val)
Definition: osq.c:147
P2
#define P2
Definition: osq.c:225
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
osq_channel_parameters
static int osq_channel_parameters(AVCodecContext *avctx, int ch)
Definition: osq.c:191
int32_t
int32_t
Definition: audioconvert.c:56
A
#define A
Definition: osq.c:220
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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
B
#define B
Definition: osq.c:221
OSQChannel::pos
unsigned pos
Definition: osq.c:41
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:471
int
int
Definition: ffmpeg_filter.c:424
get_srice
static int32_t get_srice(GetBitContext *gb, int x)
Definition: osq.c:185
AV_CODEC_ID_OSQ
@ AV_CODEC_ID_OSQ
Definition: codec_id.h:544
OSQChannel::prediction
unsigned prediction
Definition: osq.c:36