FFmpeg
ralf.c
Go to the documentation of this file.
1 /*
2  * RealAudio Lossless decoder
3  *
4  * Copyright (c) 2012 Konstantin Shishkov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * This is a decoder for Real Audio Lossless format.
26  * Dedicated to the mastermind behind it, Ralph Wiggum.
27  */
28 
29 #include "libavutil/attributes.h"
31 #include "avcodec.h"
32 #include "codec_internal.h"
33 #include "get_bits.h"
34 #include "golomb.h"
35 #include "internal.h"
36 #include "unary.h"
37 #include "ralfdata.h"
38 
39 #define FILTER_NONE 0
40 #define FILTER_RAW 642
41 
42 typedef struct VLCSet {
46  VLC filter_coeffs[10][11];
49 } VLCSet;
50 
51 #define RALF_MAX_PKT_SIZE 8192
52 
53 typedef struct RALFContext {
54  int version;
58 
59  int filter_params; ///< combined filter parameters for the current channel data
60  int filter_length; ///< length of the filter for the current channel data
61  int filter_bits; ///< filter precision for the current channel data
63 
64  unsigned bias[2]; ///< a constant value added to channel data after filtering
65 
66  int num_blocks; ///< number of blocks inside the frame
68  int block_size[1 << 12]; ///< size of the blocks
69  int block_pts[1 << 12]; ///< block start time (in milliseconds)
70 
71  uint8_t pkt[16384];
72  int has_pkt;
73 } RALFContext;
74 
75 #define MAX_ELEMS 644 // no RALF table uses more than that
76 
77 static av_cold int init_ralf_vlc(VLC *vlc, const uint8_t *data, int elems)
78 {
79  uint8_t lens[MAX_ELEMS];
80  uint16_t codes[MAX_ELEMS];
81  int counts[17], prefixes[18];
82  int i, cur_len;
83  int max_bits = 0;
84  int nb = 0;
85 
86  for (i = 0; i <= 16; i++)
87  counts[i] = 0;
88  for (i = 0; i < elems; i++) {
89  cur_len = (nb ? *data & 0xF : *data >> 4) + 1;
90  counts[cur_len]++;
91  max_bits = FFMAX(max_bits, cur_len);
92  lens[i] = cur_len;
93  data += nb;
94  nb ^= 1;
95  }
96  prefixes[1] = 0;
97  for (i = 1; i <= 16; i++)
98  prefixes[i + 1] = (prefixes[i] + counts[i]) << 1;
99 
100  for (i = 0; i < elems; i++)
101  codes[i] = prefixes[lens[i]]++;
102 
103  return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), elems,
104  lens, 1, 1, codes, 2, 2, NULL, 0, 0, 0);
105 }
106 
108 {
109  RALFContext *ctx = avctx->priv_data;
110  int i, j, k;
111 
112  for (i = 0; i < 3; i++) {
113  ff_free_vlc(&ctx->sets[i].filter_params);
114  ff_free_vlc(&ctx->sets[i].bias);
115  ff_free_vlc(&ctx->sets[i].coding_mode);
116  for (j = 0; j < 10; j++)
117  for (k = 0; k < 11; k++)
118  ff_free_vlc(&ctx->sets[i].filter_coeffs[j][k]);
119  for (j = 0; j < 15; j++)
120  ff_free_vlc(&ctx->sets[i].short_codes[j]);
121  for (j = 0; j < 125; j++)
122  ff_free_vlc(&ctx->sets[i].long_codes[j]);
123  }
124 
125  return 0;
126 }
127 
129 {
130  RALFContext *ctx = avctx->priv_data;
131  int i, j, k;
132  int ret, channels;
133 
134  if (avctx->extradata_size < 24 || memcmp(avctx->extradata, "LSD:", 4)) {
135  av_log(avctx, AV_LOG_ERROR, "Extradata is not groovy, dude\n");
136  return AVERROR_INVALIDDATA;
137  }
138 
139  ctx->version = AV_RB16(avctx->extradata + 4);
140  if (ctx->version != 0x103) {
141  avpriv_request_sample(avctx, "Unknown version %X", ctx->version);
142  return AVERROR_PATCHWELCOME;
143  }
144 
145  channels = AV_RB16(avctx->extradata + 8);
146  avctx->sample_rate = AV_RB32(avctx->extradata + 12);
148  || avctx->sample_rate < 8000 || avctx->sample_rate > 96000) {
149  av_log(avctx, AV_LOG_ERROR, "Invalid coding parameters %d Hz %d ch\n",
150  avctx->sample_rate, channels);
151  return AVERROR_INVALIDDATA;
152  }
156 
157  ctx->max_frame_size = AV_RB32(avctx->extradata + 16);
158  if (ctx->max_frame_size > (1 << 20) || !ctx->max_frame_size) {
159  av_log(avctx, AV_LOG_ERROR, "invalid frame size %d\n",
160  ctx->max_frame_size);
161  }
162  ctx->max_frame_size = FFMAX(ctx->max_frame_size, avctx->sample_rate);
163 
164  for (i = 0; i < 3; i++) {
165  ret = init_ralf_vlc(&ctx->sets[i].filter_params, filter_param_def[i],
167  if (ret < 0)
168  return ret;
169  ret = init_ralf_vlc(&ctx->sets[i].bias, bias_def[i], BIAS_ELEMENTS);
170  if (ret < 0)
171  return ret;
172  ret = init_ralf_vlc(&ctx->sets[i].coding_mode, coding_mode_def[i],
174  if (ret < 0)
175  return ret;
176  for (j = 0; j < 10; j++) {
177  for (k = 0; k < 11; k++) {
178  ret = init_ralf_vlc(&ctx->sets[i].filter_coeffs[j][k],
179  filter_coeffs_def[i][j][k],
181  if (ret < 0)
182  return ret;
183  }
184  }
185  for (j = 0; j < 15; j++) {
186  ret = init_ralf_vlc(&ctx->sets[i].short_codes[j],
188  if (ret < 0)
189  return ret;
190  }
191  for (j = 0; j < 125; j++) {
192  ret = init_ralf_vlc(&ctx->sets[i].long_codes[j],
194  if (ret < 0)
195  return ret;
196  }
197  }
198 
199  return 0;
200 }
201 
202 static inline int extend_code(GetBitContext *gb, int val, int range, int bits)
203 {
204  if (val == 0) {
205  val = -range - get_ue_golomb(gb);
206  } else if (val == range * 2) {
207  val = range + get_ue_golomb(gb);
208  } else {
209  val -= range;
210  }
211  if (bits)
212  val = ((unsigned)val << bits) | get_bits(gb, bits);
213  return val;
214 }
215 
216 static int decode_channel(RALFContext *ctx, GetBitContext *gb, int ch,
217  int length, int mode, int bits)
218 {
219  int i, t;
220  int code_params;
221  VLCSet *set = ctx->sets + mode;
222  VLC *code_vlc; int range, range2, add_bits;
223  int *dst = ctx->channel_data[ch];
224 
225  ctx->filter_params = get_vlc2(gb, set->filter_params.table, 9, 2);
226  if (ctx->filter_params > 1) {
227  ctx->filter_bits = (ctx->filter_params - 2) >> 6;
228  ctx->filter_length = ctx->filter_params - (ctx->filter_bits << 6) - 1;
229  }
230 
231  if (ctx->filter_params == FILTER_RAW) {
232  for (i = 0; i < length; i++)
233  dst[i] = get_bits(gb, bits);
234  ctx->bias[ch] = 0;
235  return 0;
236  }
237 
238  ctx->bias[ch] = get_vlc2(gb, set->bias.table, 9, 2);
239  ctx->bias[ch] = extend_code(gb, ctx->bias[ch], 127, 4);
240 
241  if (ctx->filter_params == FILTER_NONE) {
242  memset(dst, 0, sizeof(*dst) * length);
243  return 0;
244  }
245 
246  if (ctx->filter_params > 1) {
247  int cmode = 0, coeff = 0;
248  VLC *vlc = set->filter_coeffs[ctx->filter_bits] + 5;
249 
250  add_bits = ctx->filter_bits;
251 
252  for (i = 0; i < ctx->filter_length; i++) {
253  t = get_vlc2(gb, vlc[cmode].table, vlc[cmode].bits, 2);
254  t = extend_code(gb, t, 21, add_bits);
255  if (!cmode)
256  coeff -= 12U << add_bits;
257  coeff = (unsigned)t - coeff;
258  ctx->filter[i] = coeff;
259 
260  cmode = coeff >> add_bits;
261  if (cmode < 0) {
262  cmode = -1 - av_log2(-cmode);
263  if (cmode < -5)
264  cmode = -5;
265  } else if (cmode > 0) {
266  cmode = 1 + av_log2(cmode);
267  if (cmode > 5)
268  cmode = 5;
269  }
270  }
271  }
272 
273  code_params = get_vlc2(gb, set->coding_mode.table, set->coding_mode.bits, 2);
274  if (code_params >= 15) {
275  add_bits = av_clip((code_params / 5 - 3) / 2, 0, 10);
276  if (add_bits > 9 && (code_params % 5) != 2)
277  add_bits--;
278  range = 10;
279  range2 = 21;
280  code_vlc = set->long_codes + (code_params - 15);
281  } else {
282  add_bits = 0;
283  range = 6;
284  range2 = 13;
285  code_vlc = set->short_codes + code_params;
286  }
287 
288  for (i = 0; i < length; i += 2) {
289  int code1, code2;
290 
291  t = get_vlc2(gb, code_vlc->table, code_vlc->bits, 2);
292  code1 = t / range2;
293  code2 = t % range2;
294  dst[i] = extend_code(gb, code1, range, 0) * (1U << add_bits);
295  dst[i + 1] = extend_code(gb, code2, range, 0) * (1U << add_bits);
296  if (add_bits) {
297  dst[i] |= get_bits(gb, add_bits);
298  dst[i + 1] |= get_bits(gb, add_bits);
299  }
300  }
301 
302  return 0;
303 }
304 
305 static void apply_lpc(RALFContext *ctx, int ch, int length, int bits)
306 {
307  int i, j, acc;
308  int *audio = ctx->channel_data[ch];
309  int bias = 1 << (ctx->filter_bits - 1);
310  int max_clip = (1 << bits) - 1, min_clip = -max_clip - 1;
311 
312  for (i = 1; i < length; i++) {
313  int flen = FFMIN(ctx->filter_length, i);
314 
315  acc = 0;
316  for (j = 0; j < flen; j++)
317  acc += (unsigned)ctx->filter[j] * audio[i - j - 1];
318  if (acc < 0) {
319  acc = (acc + bias - 1) >> ctx->filter_bits;
320  acc = FFMAX(acc, min_clip);
321  } else {
322  acc = ((unsigned)acc + bias) >> ctx->filter_bits;
323  acc = FFMIN(acc, max_clip);
324  }
325  audio[i] += acc;
326  }
327 }
328 
330  int16_t *dst0, int16_t *dst1)
331 {
332  RALFContext *ctx = avctx->priv_data;
333  int len, ch, ret;
334  int dmode, mode[2], bits[2];
335  int *ch0, *ch1;
336  int i;
337  unsigned int t, t2;
338 
339  len = 12 - get_unary(gb, 0, 6);
340 
341  if (len <= 7) len ^= 1; // codes for length = 6 and 7 are swapped
342  len = 1 << len;
343 
344  if (ctx->sample_offset + len > ctx->max_frame_size) {
345  av_log(avctx, AV_LOG_ERROR,
346  "Decoder's stomach is crying, it ate too many samples\n");
347  return AVERROR_INVALIDDATA;
348  }
349 
350  if (avctx->ch_layout.nb_channels > 1)
351  dmode = get_bits(gb, 2) + 1;
352  else
353  dmode = 0;
354 
355  mode[0] = (dmode == 4) ? 1 : 0;
356  mode[1] = (dmode >= 2) ? 2 : 0;
357  bits[0] = 16;
358  bits[1] = (mode[1] == 2) ? 17 : 16;
359 
360  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
361  if ((ret = decode_channel(ctx, gb, ch, len, mode[ch], bits[ch])) < 0)
362  return ret;
363  if (ctx->filter_params > 1 && ctx->filter_params != FILTER_RAW) {
364  ctx->filter_bits += 3;
365  apply_lpc(ctx, ch, len, bits[ch]);
366  }
367  if (get_bits_left(gb) < 0)
368  return AVERROR_INVALIDDATA;
369  }
370  ch0 = ctx->channel_data[0];
371  ch1 = ctx->channel_data[1];
372  switch (dmode) {
373  case 0:
374  for (i = 0; i < len; i++)
375  dst0[i] = ch0[i] + ctx->bias[0];
376  break;
377  case 1:
378  for (i = 0; i < len; i++) {
379  dst0[i] = ch0[i] + ctx->bias[0];
380  dst1[i] = ch1[i] + ctx->bias[1];
381  }
382  break;
383  case 2:
384  for (i = 0; i < len; i++) {
385  ch0[i] += ctx->bias[0];
386  dst0[i] = ch0[i];
387  dst1[i] = ch0[i] - (ch1[i] + ctx->bias[1]);
388  }
389  break;
390  case 3:
391  for (i = 0; i < len; i++) {
392  t = ch0[i] + ctx->bias[0];
393  t2 = ch1[i] + ctx->bias[1];
394  dst0[i] = t + t2;
395  dst1[i] = t;
396  }
397  break;
398  case 4:
399  for (i = 0; i < len; i++) {
400  t = ch1[i] + ctx->bias[1];
401  t2 = ((ch0[i] + ctx->bias[0]) * 2) | (t & 1);
402  dst0[i] = (int)(t2 + t) / 2;
403  dst1[i] = (int)(t2 - t) / 2;
404  }
405  break;
406  }
407 
408  ctx->sample_offset += len;
409 
410  return 0;
411 }
412 
414  int *got_frame_ptr, AVPacket *avpkt)
415 {
416  RALFContext *ctx = avctx->priv_data;
417  int16_t *samples0;
418  int16_t *samples1;
419  int ret;
420  GetBitContext gb;
421  int table_size, table_bytes, i;
422  const uint8_t *src, *block_pointer;
423  int src_size;
424  int bytes_left;
425 
426  if (ctx->has_pkt) {
427  ctx->has_pkt = 0;
428  table_bytes = (AV_RB16(avpkt->data) + 7) >> 3;
429  if (table_bytes + 3 > avpkt->size || avpkt->size > RALF_MAX_PKT_SIZE) {
430  av_log(avctx, AV_LOG_ERROR, "Wrong packet's breath smells of wrong data!\n");
431  return AVERROR_INVALIDDATA;
432  }
433  if (memcmp(ctx->pkt, avpkt->data, 2 + table_bytes)) {
434  av_log(avctx, AV_LOG_ERROR, "Wrong packet tails are wrong!\n");
435  return AVERROR_INVALIDDATA;
436  }
437 
438  src = ctx->pkt;
439  src_size = RALF_MAX_PKT_SIZE + avpkt->size;
440  memcpy(ctx->pkt + RALF_MAX_PKT_SIZE, avpkt->data + 2 + table_bytes,
441  avpkt->size - 2 - table_bytes);
442  } else {
443  if (avpkt->size == RALF_MAX_PKT_SIZE) {
444  memcpy(ctx->pkt, avpkt->data, avpkt->size);
445  ctx->has_pkt = 1;
446  *got_frame_ptr = 0;
447 
448  return avpkt->size;
449  }
450  src = avpkt->data;
451  src_size = avpkt->size;
452  }
453 
454  frame->nb_samples = ctx->max_frame_size;
455  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
456  return ret;
457  samples0 = (int16_t *)frame->data[0];
458  samples1 = (int16_t *)frame->data[1];
459 
460  if (src_size < 5) {
461  av_log(avctx, AV_LOG_ERROR, "too short packets are too short!\n");
462  return AVERROR_INVALIDDATA;
463  }
464  table_size = AV_RB16(src);
465  table_bytes = (table_size + 7) >> 3;
466  if (src_size < table_bytes + 3) {
467  av_log(avctx, AV_LOG_ERROR, "short packets are short!\n");
468  return AVERROR_INVALIDDATA;
469  }
470  init_get_bits(&gb, src + 2, table_size);
471  ctx->num_blocks = 0;
472  while (get_bits_left(&gb) > 0) {
473  if (ctx->num_blocks >= FF_ARRAY_ELEMS(ctx->block_size))
474  return AVERROR_INVALIDDATA;
475  ctx->block_size[ctx->num_blocks] = get_bits(&gb, 13 + avctx->ch_layout.nb_channels);
476  if (get_bits1(&gb)) {
477  ctx->block_pts[ctx->num_blocks] = get_bits(&gb, 9);
478  } else {
479  ctx->block_pts[ctx->num_blocks] = 0;
480  }
481  ctx->num_blocks++;
482  }
483 
484  block_pointer = src + table_bytes + 2;
485  bytes_left = src_size - table_bytes - 2;
486  ctx->sample_offset = 0;
487  for (i = 0; i < ctx->num_blocks; i++) {
488  if (bytes_left < ctx->block_size[i]) {
489  av_log(avctx, AV_LOG_ERROR, "I'm pedaling backwards\n");
490  break;
491  }
492  init_get_bits(&gb, block_pointer, ctx->block_size[i] * 8);
493  if (decode_block(avctx, &gb, samples0 + ctx->sample_offset,
494  samples1 + ctx->sample_offset) < 0) {
495  av_log(avctx, AV_LOG_ERROR, "Sir, I got carsick in your office. Not decoding the rest of packet.\n");
496  break;
497  }
498  block_pointer += ctx->block_size[i];
499  bytes_left -= ctx->block_size[i];
500  }
501 
502  frame->nb_samples = ctx->sample_offset;
503  *got_frame_ptr = ctx->sample_offset > 0;
504 
505  return avpkt->size;
506 }
507 
508 static void decode_flush(AVCodecContext *avctx)
509 {
510  RALFContext *ctx = avctx->priv_data;
511 
512  ctx->has_pkt = 0;
513 }
514 
515 
517  .p.name = "ralf",
518  .p.long_name = NULL_IF_CONFIG_SMALL("RealAudio Lossless"),
519  .p.type = AVMEDIA_TYPE_AUDIO,
520  .p.id = AV_CODEC_ID_RALF,
521  .priv_data_size = sizeof(RALFContext),
522  .init = decode_init,
523  .close = decode_close,
525  .flush = decode_flush,
526  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
528  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
531 };
LONG_CODES_ELEMENTS
#define LONG_CODES_ELEMENTS
Definition: ralfdata.h:33
decode_flush
static void decode_flush(AVCodecContext *avctx)
Definition: ralf.c:508
av_clip
#define av_clip
Definition: common.h:95
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:39
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
acc
int acc
Definition: yuv2rgb.c:554
code_vlc
static VLC code_vlc
Definition: wnv1.c:42
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
RALFContext::num_blocks
int num_blocks
number of blocks inside the frame
Definition: ralf.c:66
coding_mode_def
static const uint8_t coding_mode_def[3][72]
Definition: ralfdata.h:163
RALFContext
Definition: ralf.c:53
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: ralf.c:107
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
FILTER_RAW
#define FILTER_RAW
Definition: ralf.c:40
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:143
FFCodec
Definition: codec_internal.h:112
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:798
RALFContext::has_pkt
int has_pkt
Definition: ralf.c:72
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
long_codes_def
static const uint8_t long_codes_def[3][125][224]
Definition: ralfdata.h:2036
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
BIAS_ELEMENTS
#define BIAS_ELEMENTS
Definition: ralfdata.h:29
short_codes_def
static const uint8_t short_codes_def[3][15][88]
Definition: ralfdata.h:1577
VLCSet
Definition: ralf.c:42
init
static int init
Definition: av_tx.c:47
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
VLCSet::filter_params
VLC filter_params
Definition: ralf.c:43
U
#define U(x)
Definition: vp56_arith.h:37
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
SHORT_CODES_ELEMENTS
#define SHORT_CODES_ELEMENTS
Definition: ralfdata.h:32
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: ralf.c:128
GetBitContext
Definition: get_bits.h:62
val
static double val(void *priv, double ch)
Definition: aeval.c:77
RALFContext::channel_data
int32_t channel_data[2][4096]
Definition: ralf.c:57
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
set
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)
Definition: swresample.c:59
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
bits
uint8_t bits
Definition: vp3data.h:141
MAX_ELEMS
#define MAX_ELEMS
Definition: ralf.c:75
ctx
AVFormatContext * ctx
Definition: movenc.c:48
channels
channels
Definition: aptx.h:32
FILTERPARAM_ELEMENTS
#define FILTERPARAM_ELEMENTS
Definition: ralfdata.h:28
get_bits.h
RALFContext::filter
int32_t filter[64]
Definition: ralf.c:62
AV_CODEC_ID_RALF
@ AV_CODEC_ID_RALF
Definition: codec_id.h:482
filter_coeffs_def
static const uint8_t filter_coeffs_def[3][10][11][24]
Definition: ralfdata.h:188
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
RALFContext::block_pts
int block_pts[1<< 12]
block start time (in milliseconds)
Definition: ralf.c:69
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
RALFContext::block_size
int block_size[1<< 12]
size of the blocks
Definition: ralf.c:68
RALFContext::max_frame_size
int max_frame_size
Definition: ralf.c:55
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:960
FILTER_NONE
#define FILTER_NONE
Definition: ralf.c:39
VLCSet::coding_mode
VLC coding_mode
Definition: ralf.c:45
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
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:630
FILTER_COEFFS_ELEMENTS
#define FILTER_COEFFS_ELEMENTS
Definition: ralfdata.h:31
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
init_ralf_vlc
static av_cold int init_ralf_vlc(VLC *vlc, const uint8_t *data, int elems)
Definition: ralf.c:77
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
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:375
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:116
codec_internal.h
VLCSet::long_codes
VLC long_codes[125]
Definition: ralf.c:48
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
RALFContext::pkt
uint8_t pkt[16384]
Definition: ralf.c:71
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
RALFContext::bias
unsigned bias[2]
a constant value added to channel data after filtering
Definition: ralf.c:64
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
extend_code
static int extend_code(GetBitContext *gb, int val, int range, int bits)
Definition: ralf.c:202
filter_param_def
static const uint8_t filter_param_def[3][324]
Definition: ralfdata.h:35
attributes.h
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
RALFContext::filter_length
int filter_length
length of the filter for the current channel data
Definition: ralf.c:60
VLCSet::short_codes
VLC short_codes[15]
Definition: ralf.c:47
RALFContext::filter_params
int filter_params
combined filter parameters for the current channel data
Definition: ralf.c:59
bias_def
static const uint8_t bias_def[3][128]
Definition: ralfdata.h:123
decode_channel
static int decode_channel(RALFContext *ctx, GetBitContext *gb, int ch, int length, int mode, int bits)
Definition: ralf.c:216
RALF_MAX_PKT_SIZE
#define RALF_MAX_PKT_SIZE
Definition: ralf.c:51
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
ff_init_vlc_sparse
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: vlc.c:272
apply_lpc
static void apply_lpc(RALFContext *ctx, int ch, int length, int bits)
Definition: ralf.c:305
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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: codec_internal.h:31
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
len
int len
Definition: vorbis_enc_data.h:426
VLCSet::bias
VLC bias
Definition: ralf.c:44
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: ralf.c:413
avcodec.h
VLC::bits
int bits
Definition: vlc.h:27
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
RALFContext::version
int version
Definition: ralf.c:54
ff_ralf_decoder
const FFCodec ff_ralf_decoder
Definition: ralf.c:516
AVCodecContext
main external API structure.
Definition: avcodec.h:389
channel_layout.h
t2
#define t2
Definition: regdef.h:30
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:26
VLCSet::filter_coeffs
VLC filter_coeffs[10][11]
Definition: ralf.c:46
RALFContext::filter_bits
int filter_bits
filter precision for the current channel data
Definition: ralf.c:61
RALFContext::sample_offset
int sample_offset
Definition: ralf.c:67
decode_block
static int decode_block(AVCodecContext *avctx, GetBitContext *gb, int16_t *dst0, int16_t *dst1)
Definition: ralf.c:329
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
CODING_MODE_ELEMENTS
#define CODING_MODE_ELEMENTS
Definition: ralfdata.h:30
ralfdata.h
RALFContext::sets
VLCSet sets[3]
Definition: ralf.c:56
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
int32_t
int32_t
Definition: audioconvert.c:56
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
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
int
int
Definition: ffmpeg_filter.c:153
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98