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 "get_bits.h"
33 #include "golomb.h"
34 #include "internal.h"
35 #include "unary.h"
36 #include "ralfdata.h"
37 
38 #define FILTER_NONE 0
39 #define FILTER_RAW 642
40 
41 typedef struct VLCSet {
45  VLC filter_coeffs[10][11];
48 } VLCSet;
49 
50 #define RALF_MAX_PKT_SIZE 8192
51 
52 typedef struct RALFContext {
53  int version;
55  VLCSet sets[3];
56  int32_t channel_data[2][4096];
57 
58  int filter_params; ///< combined filter parameters for the current channel data
59  int filter_length; ///< length of the filter for the current channel data
60  int filter_bits; ///< filter precision for the current channel data
62 
63  unsigned bias[2]; ///< a constant value added to channel data after filtering
64 
65  int num_blocks; ///< number of blocks inside the frame
67  int block_size[1 << 12]; ///< size of the blocks
68  int block_pts[1 << 12]; ///< block start time (in milliseconds)
69 
70  uint8_t pkt[16384];
71  int has_pkt;
72 } RALFContext;
73 
74 #define MAX_ELEMS 644 // no RALF table uses more than that
75 
76 static av_cold int init_ralf_vlc(VLC *vlc, const uint8_t *data, int elems)
77 {
78  uint8_t lens[MAX_ELEMS];
79  uint16_t codes[MAX_ELEMS];
80  int counts[17], prefixes[18];
81  int i, cur_len;
82  int max_bits = 0;
83  int nb = 0;
84 
85  for (i = 0; i <= 16; i++)
86  counts[i] = 0;
87  for (i = 0; i < elems; i++) {
88  cur_len = (nb ? *data & 0xF : *data >> 4) + 1;
89  counts[cur_len]++;
90  max_bits = FFMAX(max_bits, cur_len);
91  lens[i] = cur_len;
92  data += nb;
93  nb ^= 1;
94  }
95  prefixes[1] = 0;
96  for (i = 1; i <= 16; i++)
97  prefixes[i + 1] = (prefixes[i] + counts[i]) << 1;
98 
99  for (i = 0; i < elems; i++)
100  codes[i] = prefixes[lens[i]]++;
101 
102  return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), elems,
103  lens, 1, 1, codes, 2, 2, NULL, 0, 0, 0);
104 }
105 
107 {
108  RALFContext *ctx = avctx->priv_data;
109  int i, j, k;
110 
111  for (i = 0; i < 3; i++) {
112  ff_free_vlc(&ctx->sets[i].filter_params);
113  ff_free_vlc(&ctx->sets[i].bias);
114  ff_free_vlc(&ctx->sets[i].coding_mode);
115  for (j = 0; j < 10; j++)
116  for (k = 0; k < 11; k++)
117  ff_free_vlc(&ctx->sets[i].filter_coeffs[j][k]);
118  for (j = 0; j < 15; j++)
119  ff_free_vlc(&ctx->sets[i].short_codes[j]);
120  for (j = 0; j < 125; j++)
121  ff_free_vlc(&ctx->sets[i].long_codes[j]);
122  }
123 
124  return 0;
125 }
126 
128 {
129  RALFContext *ctx = avctx->priv_data;
130  int i, j, k;
131  int ret;
132 
133  if (avctx->extradata_size < 24 || memcmp(avctx->extradata, "LSD:", 4)) {
134  av_log(avctx, AV_LOG_ERROR, "Extradata is not groovy, dude\n");
135  return AVERROR_INVALIDDATA;
136  }
137 
138  ctx->version = AV_RB16(avctx->extradata + 4);
139  if (ctx->version != 0x103) {
140  avpriv_request_sample(avctx, "Unknown version %X", ctx->version);
141  return AVERROR_PATCHWELCOME;
142  }
143 
144  avctx->channels = AV_RB16(avctx->extradata + 8);
145  avctx->sample_rate = AV_RB32(avctx->extradata + 12);
146  if (avctx->channels < 1 || avctx->channels > 2
147  || avctx->sample_rate < 8000 || avctx->sample_rate > 96000) {
148  av_log(avctx, AV_LOG_ERROR, "Invalid coding parameters %d Hz %d ch\n",
149  avctx->sample_rate, avctx->channels);
150  return AVERROR_INVALIDDATA;
151  }
153  avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO
155 
156  ctx->max_frame_size = AV_RB32(avctx->extradata + 16);
157  if (ctx->max_frame_size > (1 << 20) || !ctx->max_frame_size) {
158  av_log(avctx, AV_LOG_ERROR, "invalid frame size %d\n",
159  ctx->max_frame_size);
160  }
161  ctx->max_frame_size = FFMAX(ctx->max_frame_size, avctx->sample_rate);
162 
163  for (i = 0; i < 3; i++) {
166  if (ret < 0) {
167  decode_close(avctx);
168  return ret;
169  }
170  ret = init_ralf_vlc(&ctx->sets[i].bias, bias_def[i], BIAS_ELEMENTS);
171  if (ret < 0) {
172  decode_close(avctx);
173  return ret;
174  }
175  ret = init_ralf_vlc(&ctx->sets[i].coding_mode, coding_mode_def[i],
177  if (ret < 0) {
178  decode_close(avctx);
179  return ret;
180  }
181  for (j = 0; j < 10; j++) {
182  for (k = 0; k < 11; k++) {
183  ret = init_ralf_vlc(&ctx->sets[i].filter_coeffs[j][k],
184  filter_coeffs_def[i][j][k],
186  if (ret < 0) {
187  decode_close(avctx);
188  return ret;
189  }
190  }
191  }
192  for (j = 0; j < 15; j++) {
193  ret = init_ralf_vlc(&ctx->sets[i].short_codes[j],
195  if (ret < 0) {
196  decode_close(avctx);
197  return ret;
198  }
199  }
200  for (j = 0; j < 125; j++) {
201  ret = init_ralf_vlc(&ctx->sets[i].long_codes[j],
203  if (ret < 0) {
204  decode_close(avctx);
205  return ret;
206  }
207  }
208  }
209 
210  return 0;
211 }
212 
213 static inline int extend_code(GetBitContext *gb, int val, int range, int bits)
214 {
215  if (val == 0) {
216  val = -range - get_ue_golomb(gb);
217  } else if (val == range * 2) {
218  val = range + get_ue_golomb(gb);
219  } else {
220  val -= range;
221  }
222  if (bits)
223  val = ((unsigned)val << bits) | get_bits(gb, bits);
224  return val;
225 }
226 
228  int length, int mode, int bits)
229 {
230  int i, t;
231  int code_params;
232  VLCSet *set = ctx->sets + mode;
233  VLC *code_vlc; int range, range2, add_bits;
234  int *dst = ctx->channel_data[ch];
235 
236  ctx->filter_params = get_vlc2(gb, set->filter_params.table, 9, 2);
237  if (ctx->filter_params > 1) {
238  ctx->filter_bits = (ctx->filter_params - 2) >> 6;
239  ctx->filter_length = ctx->filter_params - (ctx->filter_bits << 6) - 1;
240  }
241 
242  if (ctx->filter_params == FILTER_RAW) {
243  for (i = 0; i < length; i++)
244  dst[i] = get_bits(gb, bits);
245  ctx->bias[ch] = 0;
246  return 0;
247  }
248 
249  ctx->bias[ch] = get_vlc2(gb, set->bias.table, 9, 2);
250  ctx->bias[ch] = extend_code(gb, ctx->bias[ch], 127, 4);
251 
252  if (ctx->filter_params == FILTER_NONE) {
253  memset(dst, 0, sizeof(*dst) * length);
254  return 0;
255  }
256 
257  if (ctx->filter_params > 1) {
258  int cmode = 0, coeff = 0;
259  VLC *vlc = set->filter_coeffs[ctx->filter_bits] + 5;
260 
261  add_bits = ctx->filter_bits;
262 
263  for (i = 0; i < ctx->filter_length; i++) {
264  t = get_vlc2(gb, vlc[cmode].table, vlc[cmode].bits, 2);
265  t = extend_code(gb, t, 21, add_bits);
266  if (!cmode)
267  coeff -= 12U << add_bits;
268  coeff = (unsigned)t - coeff;
269  ctx->filter[i] = coeff;
270 
271  cmode = coeff >> add_bits;
272  if (cmode < 0) {
273  cmode = -1 - av_log2(-cmode);
274  if (cmode < -5)
275  cmode = -5;
276  } else if (cmode > 0) {
277  cmode = 1 + av_log2(cmode);
278  if (cmode > 5)
279  cmode = 5;
280  }
281  }
282  }
283 
284  code_params = get_vlc2(gb, set->coding_mode.table, set->coding_mode.bits, 2);
285  if (code_params >= 15) {
286  add_bits = av_clip((code_params / 5 - 3) / 2, 0, 10);
287  if (add_bits > 9 && (code_params % 5) != 2)
288  add_bits--;
289  range = 10;
290  range2 = 21;
291  code_vlc = set->long_codes + (code_params - 15);
292  } else {
293  add_bits = 0;
294  range = 6;
295  range2 = 13;
296  code_vlc = set->short_codes + code_params;
297  }
298 
299  for (i = 0; i < length; i += 2) {
300  int code1, code2;
301 
302  t = get_vlc2(gb, code_vlc->table, code_vlc->bits, 2);
303  code1 = t / range2;
304  code2 = t % range2;
305  dst[i] = extend_code(gb, code1, range, 0) * (1U << add_bits);
306  dst[i + 1] = extend_code(gb, code2, range, 0) * (1U << add_bits);
307  if (add_bits) {
308  dst[i] |= get_bits(gb, add_bits);
309  dst[i + 1] |= get_bits(gb, add_bits);
310  }
311  }
312 
313  return 0;
314 }
315 
316 static void apply_lpc(RALFContext *ctx, int ch, int length, int bits)
317 {
318  int i, j, acc;
319  int *audio = ctx->channel_data[ch];
320  int bias = 1 << (ctx->filter_bits - 1);
321  int max_clip = (1 << bits) - 1, min_clip = -max_clip - 1;
322 
323  for (i = 1; i < length; i++) {
324  int flen = FFMIN(ctx->filter_length, i);
325 
326  acc = 0;
327  for (j = 0; j < flen; j++)
328  acc += (unsigned)ctx->filter[j] * audio[i - j - 1];
329  if (acc < 0) {
330  acc = (acc + bias - 1) >> ctx->filter_bits;
331  acc = FFMAX(acc, min_clip);
332  } else {
333  acc = ((unsigned)acc + bias) >> ctx->filter_bits;
334  acc = FFMIN(acc, max_clip);
335  }
336  audio[i] += acc;
337  }
338 }
339 
341  int16_t *dst0, int16_t *dst1)
342 {
343  RALFContext *ctx = avctx->priv_data;
344  int len, ch, ret;
345  int dmode, mode[2], bits[2];
346  int *ch0, *ch1;
347  int i, t, t2;
348 
349  len = 12 - get_unary(gb, 0, 6);
350 
351  if (len <= 7) len ^= 1; // codes for length = 6 and 7 are swapped
352  len = 1 << len;
353 
354  if (ctx->sample_offset + len > ctx->max_frame_size) {
355  av_log(avctx, AV_LOG_ERROR,
356  "Decoder's stomach is crying, it ate too many samples\n");
357  return AVERROR_INVALIDDATA;
358  }
359 
360  if (avctx->channels > 1)
361  dmode = get_bits(gb, 2) + 1;
362  else
363  dmode = 0;
364 
365  mode[0] = (dmode == 4) ? 1 : 0;
366  mode[1] = (dmode >= 2) ? 2 : 0;
367  bits[0] = 16;
368  bits[1] = (mode[1] == 2) ? 17 : 16;
369 
370  for (ch = 0; ch < avctx->channels; ch++) {
371  if ((ret = decode_channel(ctx, gb, ch, len, mode[ch], bits[ch])) < 0)
372  return ret;
373  if (ctx->filter_params > 1 && ctx->filter_params != FILTER_RAW) {
374  ctx->filter_bits += 3;
375  apply_lpc(ctx, ch, len, bits[ch]);
376  }
377  if (get_bits_left(gb) < 0)
378  return AVERROR_INVALIDDATA;
379  }
380  ch0 = ctx->channel_data[0];
381  ch1 = ctx->channel_data[1];
382  switch (dmode) {
383  case 0:
384  for (i = 0; i < len; i++)
385  dst0[i] = ch0[i] + ctx->bias[0];
386  break;
387  case 1:
388  for (i = 0; i < len; i++) {
389  dst0[i] = ch0[i] + ctx->bias[0];
390  dst1[i] = ch1[i] + ctx->bias[1];
391  }
392  break;
393  case 2:
394  for (i = 0; i < len; i++) {
395  ch0[i] += ctx->bias[0];
396  dst0[i] = ch0[i];
397  dst1[i] = ch0[i] - (ch1[i] + ctx->bias[1]);
398  }
399  break;
400  case 3:
401  for (i = 0; i < len; i++) {
402  t = ch0[i] + ctx->bias[0];
403  t2 = ch1[i] + ctx->bias[1];
404  dst0[i] = t + t2;
405  dst1[i] = t;
406  }
407  break;
408  case 4:
409  for (i = 0; i < len; i++) {
410  t = ch1[i] + ctx->bias[1];
411  t2 = ((ch0[i] + ctx->bias[0]) * 2) | (t & 1);
412  dst0[i] = (t2 + t) / 2;
413  dst1[i] = (t2 - t) / 2;
414  }
415  break;
416  }
417 
418  ctx->sample_offset += len;
419 
420  return 0;
421 }
422 
423 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
424  AVPacket *avpkt)
425 {
426  RALFContext *ctx = avctx->priv_data;
427  AVFrame *frame = data;
428  int16_t *samples0;
429  int16_t *samples1;
430  int ret;
431  GetBitContext gb;
432  int table_size, table_bytes, i;
433  const uint8_t *src, *block_pointer;
434  int src_size;
435  int bytes_left;
436 
437  if (ctx->has_pkt) {
438  ctx->has_pkt = 0;
439  table_bytes = (AV_RB16(avpkt->data) + 7) >> 3;
440  if (table_bytes + 3 > avpkt->size || avpkt->size > RALF_MAX_PKT_SIZE) {
441  av_log(avctx, AV_LOG_ERROR, "Wrong packet's breath smells of wrong data!\n");
442  return AVERROR_INVALIDDATA;
443  }
444  if (memcmp(ctx->pkt, avpkt->data, 2 + table_bytes)) {
445  av_log(avctx, AV_LOG_ERROR, "Wrong packet tails are wrong!\n");
446  return AVERROR_INVALIDDATA;
447  }
448 
449  src = ctx->pkt;
450  src_size = RALF_MAX_PKT_SIZE + avpkt->size;
451  memcpy(ctx->pkt + RALF_MAX_PKT_SIZE, avpkt->data + 2 + table_bytes,
452  avpkt->size - 2 - table_bytes);
453  } else {
454  if (avpkt->size == RALF_MAX_PKT_SIZE) {
455  memcpy(ctx->pkt, avpkt->data, avpkt->size);
456  ctx->has_pkt = 1;
457  *got_frame_ptr = 0;
458 
459  return avpkt->size;
460  }
461  src = avpkt->data;
462  src_size = avpkt->size;
463  }
464 
465  frame->nb_samples = ctx->max_frame_size;
466  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
467  return ret;
468  samples0 = (int16_t *)frame->data[0];
469  samples1 = (int16_t *)frame->data[1];
470 
471  if (src_size < 5) {
472  av_log(avctx, AV_LOG_ERROR, "too short packets are too short!\n");
473  return AVERROR_INVALIDDATA;
474  }
475  table_size = AV_RB16(src);
476  table_bytes = (table_size + 7) >> 3;
477  if (src_size < table_bytes + 3) {
478  av_log(avctx, AV_LOG_ERROR, "short packets are short!\n");
479  return AVERROR_INVALIDDATA;
480  }
481  init_get_bits(&gb, src + 2, table_size);
482  ctx->num_blocks = 0;
483  while (get_bits_left(&gb) > 0) {
484  ctx->block_size[ctx->num_blocks] = get_bits(&gb, 13 + avctx->channels);
485  if (get_bits1(&gb)) {
486  ctx->block_pts[ctx->num_blocks] = get_bits(&gb, 9);
487  } else {
488  ctx->block_pts[ctx->num_blocks] = 0;
489  }
490  ctx->num_blocks++;
491  }
492 
493  block_pointer = src + table_bytes + 2;
494  bytes_left = src_size - table_bytes - 2;
495  ctx->sample_offset = 0;
496  for (i = 0; i < ctx->num_blocks; i++) {
497  if (bytes_left < ctx->block_size[i]) {
498  av_log(avctx, AV_LOG_ERROR, "I'm pedaling backwards\n");
499  break;
500  }
501  init_get_bits(&gb, block_pointer, ctx->block_size[i] * 8);
502  if (decode_block(avctx, &gb, samples0 + ctx->sample_offset,
503  samples1 + ctx->sample_offset) < 0) {
504  av_log(avctx, AV_LOG_ERROR, "Sir, I got carsick in your office. Not decoding the rest of packet.\n");
505  break;
506  }
507  block_pointer += ctx->block_size[i];
508  bytes_left -= ctx->block_size[i];
509  }
510 
511  frame->nb_samples = ctx->sample_offset;
512  *got_frame_ptr = ctx->sample_offset > 0;
513 
514  return avpkt->size;
515 }
516 
517 static void decode_flush(AVCodecContext *avctx)
518 {
519  RALFContext *ctx = avctx->priv_data;
520 
521  ctx->has_pkt = 0;
522 }
523 
524 
526  .name = "ralf",
527  .long_name = NULL_IF_CONFIG_SMALL("RealAudio Lossless"),
528  .type = AVMEDIA_TYPE_AUDIO,
529  .id = AV_CODEC_ID_RALF,
530  .priv_data_size = sizeof(RALFContext),
531  .init = decode_init,
532  .close = decode_close,
533  .decode = decode_frame,
534  .flush = decode_flush,
535  .capabilities = AV_CODEC_CAP_DR1,
536  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
538 };
#define NULL
Definition: coverity.c:32
int max_frame_size
Definition: ralf.c:54
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
int num_blocks
number of blocks inside the frame
Definition: ralf.c:65
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int acc
Definition: yuv2rgb.c:554
#define avpriv_request_sample(...)
int ff_init_vlc_sparse(VLC *vlc_arg, 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: bitstream.c:273
int size
Definition: avcodec.h:1498
VLC filter_params
Definition: ralf.c:42
int av_log2(unsigned v)
Definition: intmath.c:26
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
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:87
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3509
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)
Definition: swresample.c:59
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
Macro definitions for various function/variable attributes.
static const uint8_t bias_def[3][128]
Definition: ralfdata.h:123
#define MAX_ELEMS
Definition: ralf.c:74
#define FILTER_NONE
Definition: ralf.c:38
static const uint8_t filter_coeffs_def[3][10][11][24]
Definition: ralfdata.h:188
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2253
uint8_t
#define av_cold
Definition: attributes.h:82
int sample_offset
Definition: ralf.c:66
static int decode_block(AVCodecContext *avctx, GetBitContext *gb, int16_t *dst0, int16_t *dst1)
Definition: ralf.c:340
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1686
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:87
uint8_t * data
Definition: avcodec.h:1497
bitstream reader API header.
int version
Definition: ralf.c:53
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
int filter_bits
filter precision for the current channel data
Definition: ralf.c:60
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: ralf.c:423
int has_pkt
Definition: ralf.c:71
static void decode_flush(AVCodecContext *avctx)
Definition: ralf.c:517
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static av_cold int decode_close(AVCodecContext *avctx)
Definition: ralf.c:106
static int decode_channel(RALFContext *ctx, GetBitContext *gb, int ch, int length, int mode, int bits)
Definition: ralf.c:227
static const uint8_t long_codes_def[3][125][224]
Definition: ralfdata.h:2036
#define RALF_MAX_PKT_SIZE
Definition: ralf.c:50
VLC coding_mode
Definition: ralf.c:44
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3516
uint8_t bits
Definition: vp3data.h:202
#define FFMAX(a, b)
Definition: common.h:94
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2296
int32_t channel_data[2][4096]
Definition: ralf.c:56
VLCSet sets[3]
Definition: ralf.c:55
audio channel layout utility functions
#define FILTER_COEFFS_ELEMENTS
Definition: ralfdata.h:31
unsigned bias[2]
a constant value added to channel data after filtering
Definition: ralf.c:63
#define FFMIN(a, b)
Definition: common.h:96
#define FILTER_RAW
Definition: ralf.c:39
#define SHORT_CODES_ELEMENTS
Definition: ralfdata.h:32
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
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
static const uint8_t coding_mode_def[3][72]
Definition: ralfdata.h:163
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:797
int bits
Definition: vlc.h:27
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int32_t filter[64]
Definition: ralf.c:61
int filter_params
combined filter parameters for the current channel data
Definition: ralf.c:58
uint8_t pkt[16384]
Definition: ralf.c:70
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2245
AVCodec ff_ralf_decoder
Definition: ralf.c:525
#define FILTERPARAM_ELEMENTS
Definition: ralfdata.h:28
main external API structure.
Definition: avcodec.h:1585
static VLC code_vlc
Definition: wnv1.c:45
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
VLC long_codes[125]
Definition: ralf.c:47
int extradata_size
Definition: avcodec.h:1687
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
Definition: ralf.c:41
static av_cold int init_ralf_vlc(VLC *vlc, const uint8_t *data, int elems)
Definition: ralf.c:76
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
VLC short_codes[15]
Definition: ralf.c:46
VLC filter_coeffs[10][11]
Definition: ralf.c:45
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int block_size[1<< 12]
size of the blocks
Definition: ralf.c:67
int block_pts[1<< 12]
block start time (in milliseconds)
Definition: ralf.c:68
#define CODING_MODE_ELEMENTS
Definition: ralfdata.h:30
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
static const uint8_t short_codes_def[3][15][88]
Definition: ralfdata.h:1577
VLC bias
Definition: ralf.c:43
int filter_length
length of the filter for the current channel data
Definition: ralf.c:59
void * priv_data
Definition: avcodec.h:1612
static av_cold int decode_init(AVCodecContext *avctx)
Definition: ralf.c:127
static int extend_code(GetBitContext *gb, int val, int range, int bits)
Definition: ralf.c:213
int len
int channels
number of audio channels
Definition: avcodec.h:2246
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const uint8_t filter_param_def[3][324]
Definition: ralfdata.h:35
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#define BIAS_ELEMENTS
Definition: ralfdata.h:29
signed 16 bits, planar
Definition: samplefmt.h:67
#define LONG_CODES_ELEMENTS
Definition: ralfdata.h:33
#define AV_CH_LAYOUT_MONO
static void apply_lpc(RALFContext *ctx, int ch, int length, int bits)
Definition: ralf.c:316
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1474
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:991
for(j=16;j >0;--j)
#define t2
Definition: regdef.h:30