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" 30#include "libavutil/channel_layout.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 41typedef struct VLCSet { 42 VLC filter_params; 43 VLC bias; 44 VLC coding_mode; 45 VLC filter_coeffs[10][11]; 46 VLC short_codes[15]; 47 VLC long_codes[125]; 48} VLCSet; 49 50#define RALF_MAX_PKT_SIZE 8192 51 52typedef struct RALFContext { 53 int version; 54 int max_frame_size; 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 61 int32_t filter[64]; 62 63 int bias[2]; ///< a constant value added to channel data after filtering 64 65 int num_blocks; ///< number of blocks inside the frame 66 int sample_offset; 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 76static 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 106static av_cold int decode_close(AVCodecContext *avctx) 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 127static av_cold int decode_init(AVCodecContext *avctx) 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 } 152 avctx->sample_fmt = AV_SAMPLE_FMT_S16P; 153 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO 154 : AV_CH_LAYOUT_MONO; 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++) { 164 ret = init_ralf_vlc(&ctx->sets[i].filter_params, filter_param_def[i], 165 FILTERPARAM_ELEMENTS); 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], 176 CODING_MODE_ELEMENTS); 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], 185 FILTER_COEFFS_ELEMENTS); 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], 194 short_codes_def[i][j], SHORT_CODES_ELEMENTS); 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], 202 long_codes_def[i][j], LONG_CODES_ELEMENTS); 203 if (ret < 0) { 204 decode_close(avctx); 205 return ret; 206 } 207 } 208 } 209 210 return 0; 211} 212 213static 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 = (val << bits) | get_bits(gb, bits); 224 return val; 225} 226 227static int decode_channel(RALFContext *ctx, GetBitContext *gb, int ch, 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 ctx->filter_bits = (ctx->filter_params - 2) >> 6; 238 ctx->filter_length = ctx->filter_params - (ctx->filter_bits << 6) - 1; 239 240 if (ctx->filter_params == FILTER_RAW) { 241 for (i = 0; i < length; i++) 242 dst[i] = get_bits(gb, bits); 243 ctx->bias[ch] = 0; 244 return 0; 245 } 246 247 ctx->bias[ch] = get_vlc2(gb, set->bias.table, 9, 2); 248 ctx->bias[ch] = extend_code(gb, ctx->bias[ch], 127, 4); 249 250 if (ctx->filter_params == FILTER_NONE) { 251 memset(dst, 0, sizeof(*dst) * length); 252 return 0; 253 } 254 255 if (ctx->filter_params > 1) { 256 int cmode = 0, coeff = 0; 257 VLC *vlc = set->filter_coeffs[ctx->filter_bits] + 5; 258 259 add_bits = ctx->filter_bits; 260 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); 264 if (!cmode) 265 coeff -= 12 << add_bits; 266 coeff = t - coeff; 267 ctx->filter[i] = coeff; 268 269 cmode = coeff >> add_bits; 270 if (cmode < 0) { 271 cmode = -1 - av_log2(-cmode); 272 if (cmode < -5) 273 cmode = -5; 274 } else if (cmode > 0) { 275 cmode = 1 + av_log2(cmode); 276 if (cmode > 5) 277 cmode = 5; 278 } 279 } 280 } 281 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) 286 add_bits--; 287 range = 10; 288 range2 = 21; 289 code_vlc = set->long_codes + code_params - 15; 290 } else { 291 add_bits = 0; 292 range = 6; 293 range2 = 13; 294 code_vlc = set->short_codes + code_params; 295 } 296 297 for (i = 0; i < length; i += 2) { 298 int code1, code2; 299 300 t = get_vlc2(gb, code_vlc->table, code_vlc->bits, 2); 301 code1 = t / range2; 302 code2 = t % range2; 303 dst[i] = extend_code(gb, code1, range, 0) << add_bits; 304 dst[i + 1] = extend_code(gb, code2, range, 0) << add_bits; 305 if (add_bits) { 306 dst[i] |= get_bits(gb, add_bits); 307 dst[i + 1] |= get_bits(gb, add_bits); 308 } 309 } 310 311 return 0; 312} 313 314static void apply_lpc(RALFContext *ctx, int ch, int length, int bits) 315{ 316 int i, j, acc; 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; 320 321 for (i = 1; i < length; i++) { 322 int flen = FFMIN(ctx->filter_length, i); 323 324 acc = 0; 325 for (j = 0; j < flen; j++) 326 acc += ctx->filter[j] * audio[i - j - 1]; 327 if (acc < 0) { 328 acc = (acc + bias - 1) >> ctx->filter_bits; 329 acc = FFMAX(acc, min_clip); 330 } else { 331 acc = (acc + bias) >> ctx->filter_bits; 332 acc = FFMIN(acc, max_clip); 333 } 334 audio[i] += acc; 335 } 336} 337 338static int decode_block(AVCodecContext *avctx, GetBitContext *gb, 339 int16_t *dst0, int16_t *dst1) 340{ 341 RALFContext *ctx = avctx->priv_data; 342 int len, ch, ret; 343 int dmode, mode[2], bits[2]; 344 int *ch0, *ch1; 345 int i, t, t2; 346 347 len = 12 - get_unary(gb, 0, 6); 348 349 if (len <= 7) len ^= 1; // codes for length = 6 and 7 are swapped 350 len = 1 << len; 351 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; 356 } 357 358 if (avctx->channels > 1) 359 dmode = get_bits(gb, 2) + 1; 360 else 361 dmode = 0; 362 363 mode[0] = (dmode == 4) ? 1 : 0; 364 mode[1] = (dmode >= 2) ? 2 : 0; 365 bits[0] = 16; 366 bits[1] = (mode[1] == 2) ? 17 : 16; 367 368 for (ch = 0; ch < avctx->channels; ch++) { 369 if ((ret = decode_channel(ctx, gb, ch, len, mode[ch], bits[ch])) < 0) 370 return ret; 371 if (ctx->filter_params > 1 && ctx->filter_params != FILTER_RAW) { 372 ctx->filter_bits += 3; 373 apply_lpc(ctx, ch, len, bits[ch]); 374 } 375 if (get_bits_left(gb) < 0) 376 return AVERROR_INVALIDDATA; 377 } 378 ch0 = ctx->channel_data[0]; 379 ch1 = ctx->channel_data[1]; 380 switch (dmode) { 381 case 0: 382 for (i = 0; i < len; i++) 383 dst0[i] = ch0[i] + ctx->bias[0]; 384 break; 385 case 1: 386 for (i = 0; i < len; i++) { 387 dst0[i] = ch0[i] + ctx->bias[0]; 388 dst1[i] = ch1[i] + ctx->bias[1]; 389 } 390 break; 391 case 2: 392 for (i = 0; i < len; i++) { 393 ch0[i] += ctx->bias[0]; 394 dst0[i] = ch0[i]; 395 dst1[i] = ch0[i] - (ch1[i] + ctx->bias[1]); 396 } 397 break; 398 case 3: 399 for (i = 0; i < len; i++) { 400 t = ch0[i] + ctx->bias[0]; 401 t2 = ch1[i] + ctx->bias[1]; 402 dst0[i] = t + t2; 403 dst1[i] = t; 404 } 405 break; 406 case 4: 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; 412 } 413 break; 414 } 415 416 ctx->sample_offset += len; 417 418 return 0; 419} 420 421static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, 422 AVPacket *avpkt) 423{ 424 RALFContext *ctx = avctx->priv_data; 425 AVFrame *frame = data; 426 int16_t *samples0; 427 int16_t *samples1; 428 int ret; 429 GetBitContext gb; 430 int table_size, table_bytes, i; 431 const uint8_t *src, *block_pointer; 432 int src_size; 433 int bytes_left; 434 435 if (ctx->has_pkt) { 436 ctx->has_pkt = 0; 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; 441 } 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; 445 } 446 447 src = ctx->pkt; 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); 451 } else { 452 if (avpkt->size == RALF_MAX_PKT_SIZE) { 453 memcpy(ctx->pkt, avpkt->data, avpkt->size); 454 ctx->has_pkt = 1; 455 *got_frame_ptr = 0; 456 457 return avpkt->size; 458 } 459 src = avpkt->data; 460 src_size = avpkt->size; 461 } 462 463 frame->nb_samples = ctx->max_frame_size; 464 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 465 return ret; 466 samples0 = (int16_t *)frame->data[0]; 467 samples1 = (int16_t *)frame->data[1]; 468 469 if (src_size < 5) { 470 av_log(avctx, AV_LOG_ERROR, "too short packets are too short!\n"); 471 return AVERROR_INVALIDDATA; 472 } 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; 478 } 479 init_get_bits(&gb, src + 2, table_size); 480 ctx->num_blocks = 0; 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); 485 } else { 486 ctx->block_pts[ctx->num_blocks] = 0; 487 } 488 ctx->num_blocks++; 489 } 490 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"); 497 break; 498 } 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"); 503 break; 504 } 505 block_pointer += ctx->block_size[i]; 506 bytes_left -= ctx->block_size[i]; 507 } 508 509 frame->nb_samples = ctx->sample_offset; 510 *got_frame_ptr = ctx->sample_offset > 0; 511 512 return avpkt->size; 513} 514 515static void decode_flush(AVCodecContext *avctx) 516{ 517 RALFContext *ctx = avctx->priv_data; 518 519 ctx->has_pkt = 0; 520} 521 522 523AVCodec ff_ralf_decoder = { 524 .name = "ralf", 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), 529 .init = decode_init, 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 }, 536}; 537