2 * RealAudio Lossless decoder
4 * Copyright (c) 2012 Konstantin Shishkov
6 * This file is part of FFmpeg.
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.
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.
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
25 * This is a decoder for Real Audio Lossless format.
26 * Dedicated to the mastermind behind it, Ralph Wiggum.
29 #include "libavutil/attributes.h"
30 #include "libavutil/channel_layout.h"
39 #define FILTER_RAW 642
41 typedef struct VLCSet
{
45 VLC filter_coeffs
[10][11];
50 #define RALF_MAX_PKT_SIZE 8192
52 typedef struct RALFContext
{
56 int32_t channel_data
[2][4096];
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
63 int bias
[2]; ///< a constant value added to channel data after filtering
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)
74 #define MAX_ELEMS 644 // no RALF table uses more than that
76 static av_cold
int init_ralf_vlc(VLC
*vlc
, const uint8_t *data
, int elems
)
78 uint8_t lens
[MAX_ELEMS
];
79 uint16_t codes
[MAX_ELEMS
];
80 int counts
[17], prefixes
[18];
85 for (i
= 0; i
<= 16; i
++)
87 for (i
= 0; i
< elems
; i
++) {
88 cur_len
= (nb
? *data
& 0xF : *data
>> 4) + 1;
90 max_bits
= FFMAX(max_bits
, cur_len
);
96 for (i
= 1; i
<= 16; i
++)
97 prefixes
[i
+ 1] = (prefixes
[i
] + counts
[i
]) << 1;
99 for (i
= 0; i
< elems
; i
++)
100 codes
[i
] = prefixes
[lens
[i
]]++;
102 return ff_init_vlc_sparse(vlc
, FFMIN(max_bits
, 9), elems
,
103 lens
, 1, 1, codes
, 2, 2, NULL
, 0, 0, 0);
106 static av_cold
int decode_close(AVCodecContext
*avctx
)
108 RALFContext
*ctx
= avctx
->priv_data
;
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
]);
127 static av_cold
int decode_init(AVCodecContext
*avctx
)
129 RALFContext
*ctx
= avctx
->priv_data
;
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
;
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
;
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
;
152 avctx
->sample_fmt
= AV_SAMPLE_FMT_S16P
;
153 avctx
->channel_layout
= (avctx
->channels
== 2) ? AV_CH_LAYOUT_STEREO
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
);
161 ctx
->max_frame_size
= FFMAX(ctx
->max_frame_size
, avctx
->sample_rate
);
163 for (i
= 0; i
< 3; i
++) {
164 ret
= init_ralf_vlc(&ctx
->sets
[i
].filter_params
, filter_param_def
[i
],
165 FILTERPARAM_ELEMENTS
);
170 ret
= init_ralf_vlc(&ctx
->sets
[i
].bias
, bias_def
[i
], BIAS_ELEMENTS
);
175 ret
= init_ralf_vlc(&ctx
->sets
[i
].coding_mode
, coding_mode_def
[i
],
176 CODING_MODE_ELEMENTS
);
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
],
185 FILTER_COEFFS_ELEMENTS
);
192 for (j
= 0; j
< 15; j
++) {
193 ret
= init_ralf_vlc(&ctx
->sets
[i
].short_codes
[j
],
194 short_codes_def
[i
][j
], SHORT_CODES_ELEMENTS
);
200 for (j
= 0; j
< 125; j
++) {
201 ret
= init_ralf_vlc(&ctx
->sets
[i
].long_codes
[j
],
202 long_codes_def
[i
][j
], LONG_CODES_ELEMENTS
);
213 static inline int extend_code(GetBitContext
*gb
, int val
, int range
, int bits
)
216 val
= -range
- get_ue_golomb(gb
);
217 } else if (val
== range
* 2) {
218 val
= range
+ get_ue_golomb(gb
);
223 val
= (val
<< bits
) | get_bits(gb
, bits
);
227 static int decode_channel(RALFContext
*ctx
, GetBitContext
*gb
, int ch
,
228 int length
, int mode
, int bits
)
232 VLCSet
*set
= ctx
->sets
+ mode
;
233 VLC
*code_vlc
; int range
, range2
, add_bits
;
234 int *dst
= ctx
->channel_data
[ch
];
236 ctx
->filter_params
= get_vlc2(gb
, set
->filter_params
.table
, 9, 2);
237 ctx
->filter_bits
= (ctx
->filter_params
- 2) >> 6;
238 ctx
->filter_length
= ctx
->filter_params
- (ctx
->filter_bits
<< 6) - 1;
240 if (ctx
->filter_params
== FILTER_RAW
) {
241 for (i
= 0; i
< length
; i
++)
242 dst
[i
] = get_bits(gb
, bits
);
247 ctx
->bias
[ch
] = get_vlc2(gb
, set
->bias
.table
, 9, 2);
248 ctx
->bias
[ch
] = extend_code(gb
, ctx
->bias
[ch
], 127, 4);
250 if (ctx
->filter_params
== FILTER_NONE
) {
251 memset(dst
, 0, sizeof(*dst
) * length
);
255 if (ctx
->filter_params
> 1) {
256 int cmode
= 0, coeff
= 0;
257 VLC
*vlc
= set
->filter_coeffs
[ctx
->filter_bits
] + 5;
259 add_bits
= ctx
->filter_bits
;
261 for (i
= 0; i
< ctx
->filter_length
; i
++) {
262 t
= get_vlc2(gb
, vlc
[cmode
].table
, vlc
[cmode
].bits
, 2);
263 t
= extend_code(gb
, t
, 21, add_bits
);
265 coeff
-= 12 << add_bits
;
267 ctx
->filter
[i
] = coeff
;
269 cmode
= coeff
>> add_bits
;
271 cmode
= -1 - av_log2(-cmode
);
274 } else if (cmode
> 0) {
275 cmode
= 1 + av_log2(cmode
);
282 code_params
= get_vlc2(gb
, set
->coding_mode
.table
, set
->coding_mode
.bits
, 2);
283 if (code_params
>= 15) {
284 add_bits
= av_clip((code_params
/ 5 - 3) / 2, 0, 10);
285 if (add_bits
> 9 && (code_params
% 5) != 2)
289 code_vlc
= set
->long_codes
+ code_params
- 15;
294 code_vlc
= set
->short_codes
+ code_params
;
297 for (i
= 0; i
< length
; i
+= 2) {
300 t
= get_vlc2(gb
, code_vlc
->table
, code_vlc
->bits
, 2);
303 dst
[i
] = extend_code(gb
, code1
, range
, 0) << add_bits
;
304 dst
[i
+ 1] = extend_code(gb
, code2
, range
, 0) << add_bits
;
306 dst
[i
] |= get_bits(gb
, add_bits
);
307 dst
[i
+ 1] |= get_bits(gb
, add_bits
);
314 static void apply_lpc(RALFContext
*ctx
, int ch
, int length
, int bits
)
317 int *audio
= ctx
->channel_data
[ch
];
318 int bias
= 1 << (ctx
->filter_bits
- 1);
319 int max_clip
= (1 << bits
) - 1, min_clip
= -max_clip
- 1;
321 for (i
= 1; i
< length
; i
++) {
322 int flen
= FFMIN(ctx
->filter_length
, i
);
325 for (j
= 0; j
< flen
; j
++)
326 acc
+= ctx
->filter
[j
] * audio
[i
- j
- 1];
328 acc
= (acc
+ bias
- 1) >> ctx
->filter_bits
;
329 acc
= FFMAX(acc
, min_clip
);
331 acc
= (acc
+ bias
) >> ctx
->filter_bits
;
332 acc
= FFMIN(acc
, max_clip
);
338 static int decode_block(AVCodecContext
*avctx
, GetBitContext
*gb
,
339 int16_t *dst0
, int16_t *dst1
)
341 RALFContext
*ctx
= avctx
->priv_data
;
343 int dmode
, mode
[2], bits
[2];
347 len
= 12 - get_unary(gb
, 0, 6);
349 if (len
<= 7) len
^= 1; // codes for length = 6 and 7 are swapped
352 if (ctx
->sample_offset
+ len
> ctx
->max_frame_size
) {
353 av_log(avctx
, AV_LOG_ERROR
,
354 "Decoder's stomach is crying, it ate too many samples\n");
355 return AVERROR_INVALIDDATA
;
358 if (avctx
->channels
> 1)
359 dmode
= get_bits(gb
, 2) + 1;
363 mode
[0] = (dmode
== 4) ? 1 : 0;
364 mode
[1] = (dmode
>= 2) ? 2 : 0;
366 bits
[1] = (mode
[1] == 2) ? 17 : 16;
368 for (ch
= 0; ch
< avctx
->channels
; ch
++) {
369 if ((ret
= decode_channel(ctx
, gb
, ch
, len
, mode
[ch
], bits
[ch
])) < 0)
371 if (ctx
->filter_params
> 1 && ctx
->filter_params
!= FILTER_RAW
) {
372 ctx
->filter_bits
+= 3;
373 apply_lpc(ctx
, ch
, len
, bits
[ch
]);
375 if (get_bits_left(gb
) < 0)
376 return AVERROR_INVALIDDATA
;
378 ch0
= ctx
->channel_data
[0];
379 ch1
= ctx
->channel_data
[1];
382 for (i
= 0; i
< len
; i
++)
383 dst0
[i
] = ch0
[i
] + ctx
->bias
[0];
386 for (i
= 0; i
< len
; i
++) {
387 dst0
[i
] = ch0
[i
] + ctx
->bias
[0];
388 dst1
[i
] = ch1
[i
] + ctx
->bias
[1];
392 for (i
= 0; i
< len
; i
++) {
393 ch0
[i
] += ctx
->bias
[0];
395 dst1
[i
] = ch0
[i
] - (ch1
[i
] + ctx
->bias
[1]);
399 for (i
= 0; i
< len
; i
++) {
400 t
= ch0
[i
] + ctx
->bias
[0];
401 t2
= ch1
[i
] + ctx
->bias
[1];
407 for (i
= 0; i
< len
; i
++) {
408 t
= ch1
[i
] + ctx
->bias
[1];
409 t2
= ((ch0
[i
] + ctx
->bias
[0]) << 1) | (t
& 1);
410 dst0
[i
] = (t2
+ t
) / 2;
411 dst1
[i
] = (t2
- t
) / 2;
416 ctx
->sample_offset
+= len
;
421 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame_ptr
,
424 RALFContext
*ctx
= avctx
->priv_data
;
425 AVFrame
*frame
= data
;
430 int table_size
, table_bytes
, i
;
431 const uint8_t *src
, *block_pointer
;
437 table_bytes
= (AV_RB16(avpkt
->data
) + 7) >> 3;
438 if (table_bytes
+ 3 > avpkt
->size
|| avpkt
->size
> RALF_MAX_PKT_SIZE
) {
439 av_log(avctx
, AV_LOG_ERROR
, "Wrong packet's breath smells of wrong data!\n");
440 return AVERROR_INVALIDDATA
;
442 if (memcmp(ctx
->pkt
, avpkt
->data
, 2 + table_bytes
)) {
443 av_log(avctx
, AV_LOG_ERROR
, "Wrong packet tails are wrong!\n");
444 return AVERROR_INVALIDDATA
;
448 src_size
= RALF_MAX_PKT_SIZE
+ avpkt
->size
;
449 memcpy(ctx
->pkt
+ RALF_MAX_PKT_SIZE
, avpkt
->data
+ 2 + table_bytes
,
450 avpkt
->size
- 2 - table_bytes
);
452 if (avpkt
->size
== RALF_MAX_PKT_SIZE
) {
453 memcpy(ctx
->pkt
, avpkt
->data
, avpkt
->size
);
460 src_size
= avpkt
->size
;
463 frame
->nb_samples
= ctx
->max_frame_size
;
464 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
466 samples0
= (int16_t *)frame
->data
[0];
467 samples1
= (int16_t *)frame
->data
[1];
470 av_log(avctx
, AV_LOG_ERROR
, "too short packets are too short!\n");
471 return AVERROR_INVALIDDATA
;
473 table_size
= AV_RB16(src
);
474 table_bytes
= (table_size
+ 7) >> 3;
475 if (src_size
< table_bytes
+ 3) {
476 av_log(avctx
, AV_LOG_ERROR
, "short packets are short!\n");
477 return AVERROR_INVALIDDATA
;
479 init_get_bits(&gb
, src
+ 2, table_size
);
481 while (get_bits_left(&gb
) > 0) {
482 ctx
->block_size
[ctx
->num_blocks
] = get_bits(&gb
, 15);
483 if (get_bits1(&gb
)) {
484 ctx
->block_pts
[ctx
->num_blocks
] = get_bits(&gb
, 9);
486 ctx
->block_pts
[ctx
->num_blocks
] = 0;
491 block_pointer
= src
+ table_bytes
+ 2;
492 bytes_left
= src_size
- table_bytes
- 2;
493 ctx
->sample_offset
= 0;
494 for (i
= 0; i
< ctx
->num_blocks
; i
++) {
495 if (bytes_left
< ctx
->block_size
[i
]) {
496 av_log(avctx
, AV_LOG_ERROR
, "I'm pedaling backwards\n");
499 init_get_bits(&gb
, block_pointer
, ctx
->block_size
[i
] * 8);
500 if (decode_block(avctx
, &gb
, samples0
+ ctx
->sample_offset
,
501 samples1
+ ctx
->sample_offset
) < 0) {
502 av_log(avctx
, AV_LOG_ERROR
, "Sir, I got carsick in your office. Not decoding the rest of packet.\n");
505 block_pointer
+= ctx
->block_size
[i
];
506 bytes_left
-= ctx
->block_size
[i
];
509 frame
->nb_samples
= ctx
->sample_offset
;
510 *got_frame_ptr
= ctx
->sample_offset
> 0;
515 static void decode_flush(AVCodecContext
*avctx
)
517 RALFContext
*ctx
= avctx
->priv_data
;
523 AVCodec ff_ralf_decoder
= {
525 .long_name
= NULL_IF_CONFIG_SMALL("RealAudio Lossless"),
526 .type
= AVMEDIA_TYPE_AUDIO
,
527 .id
= AV_CODEC_ID_RALF
,
528 .priv_data_size
= sizeof(RALFContext
),
530 .close
= decode_close
,
531 .decode
= decode_frame
,
532 .flush
= decode_flush
,
533 .capabilities
= CODEC_CAP_DR1
,
534 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_S16P
,
535 AV_SAMPLE_FMT_NONE
},