1/* 2 * Shorten decoder 3 * Copyright (c) 2005 Jeff Muizelaar 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/** 23 * @file 24 * Shorten decoder 25 * @author Jeff Muizelaar 26 */ 27 28#include <limits.h> 29#include "avcodec.h" 30#include "bswapdsp.h" 31#include "bytestream.h" 32#include "codec_internal.h" 33#include "get_bits.h" 34#include "golomb.h" 35#include "internal.h" 36 37#define MAX_CHANNELS 8 38#define MAX_BLOCKSIZE 65535 39 40#define OUT_BUFFER_SIZE 16384 41 42#define ULONGSIZE 2 43 44#define WAVE_FORMAT_PCM 0x0001 45 46#define DEFAULT_BLOCK_SIZE 256 47 48#define TYPESIZE 4 49#define CHANSIZE 0 50#define LPCQSIZE 2 51#define ENERGYSIZE 3 52#define BITSHIFTSIZE 2 53 54#define TYPE_S8 1 55#define TYPE_U8 2 56#define TYPE_S16HL 3 57#define TYPE_U16HL 4 58#define TYPE_S16LH 5 59#define TYPE_U16LH 6 60 61#define NWRAP 3 62#define NSKIPSIZE 1 63 64#define LPCQUANT 5 65#define V2LPCQOFFSET (1 << LPCQUANT) 66 67#define FNSIZE 2 68#define FN_DIFF0 0 69#define FN_DIFF1 1 70#define FN_DIFF2 2 71#define FN_DIFF3 3 72#define FN_QUIT 4 73#define FN_BLOCKSIZE 5 74#define FN_BITSHIFT 6 75#define FN_QLPC 7 76#define FN_ZERO 8 77#define FN_VERBATIM 9 78 79/** indicates if the FN_* command is audio or non-audio */ 80static const uint8_t is_audio_command[10] = { 1, 1, 1, 1, 0, 0, 0, 1, 1, 0 }; 81 82#define VERBATIM_CKSIZE_SIZE 5 83#define VERBATIM_BYTE_SIZE 8 84#define CANONICAL_HEADER_SIZE 44 85 86typedef struct ShortenContext { 87 AVCodecContext *avctx; 88 GetBitContext gb; 89 90 int min_framesize, max_framesize; 91 unsigned channels; 92 93 int32_t *decoded[MAX_CHANNELS]; 94 int32_t *decoded_base[MAX_CHANNELS]; 95 int32_t *offset[MAX_CHANNELS]; 96 int *coeffs; 97 uint8_t *bitstream; 98 int bitstream_size; 99 int bitstream_index; 100 unsigned int allocated_bitstream_size; 101 int header_size; 102 uint8_t header[OUT_BUFFER_SIZE]; 103 int version; 104 int cur_chan; 105 int bitshift; 106 int nmean; 107 int internal_ftype; 108 int nwrap; 109 int blocksize; 110 int bitindex; 111 int32_t lpcqoffset; 112 int got_header; 113 int got_quit_command; 114 int swap; 115 BswapDSPContext bdsp; 116} ShortenContext; 117 118static av_cold int shorten_decode_init(AVCodecContext *avctx) 119{ 120 ShortenContext *s = avctx->priv_data; 121 s->avctx = avctx; 122 123 ff_bswapdsp_init(&s->bdsp); 124 125 return 0; 126} 127 128static int allocate_buffers(ShortenContext *s) 129{ 130 int i, chan, err; 131 132 for (chan = 0; chan < s->channels; chan++) { 133 if (FFMAX(1, s->nmean) >= UINT_MAX / sizeof(int32_t)) { 134 av_log(s->avctx, AV_LOG_ERROR, "nmean too large\n"); 135 return AVERROR_INVALIDDATA; 136 } 137 if (s->blocksize + (uint64_t)s->nwrap >= UINT_MAX / sizeof(int32_t)) { 138 av_log(s->avctx, AV_LOG_ERROR, 139 "s->blocksize + s->nwrap too large\n"); 140 return AVERROR_INVALIDDATA; 141 } 142 143 if ((err = av_reallocp_array(&s->offset[chan], 144 sizeof(int32_t), 145 FFMAX(1, s->nmean))) < 0) 146 return err; 147 148 if ((err = av_reallocp_array(&s->decoded_base[chan], (s->blocksize + s->nwrap), 149 sizeof(s->decoded_base[0][0]))) < 0) 150 return err; 151 for (i = 0; i < s->nwrap; i++) 152 s->decoded_base[chan][i] = 0; 153 s->decoded[chan] = s->decoded_base[chan] + s->nwrap; 154 } 155 156 if ((err = av_reallocp_array(&s->coeffs, s->nwrap, sizeof(*s->coeffs))) < 0) 157 return err; 158 159 return 0; 160} 161 162static inline unsigned int get_uint(ShortenContext *s, int k) 163{ 164 if (s->version != 0) { 165 k = get_ur_golomb_shorten(&s->gb, ULONGSIZE); 166 if (k > 31U) 167 return AVERROR_INVALIDDATA; 168 } 169 return get_ur_golomb_shorten(&s->gb, k); 170} 171 172static void fix_bitshift(ShortenContext *s, int32_t *buffer) 173{ 174 int i; 175 176 if (s->bitshift == 32) { 177 for (i = 0; i < s->blocksize; i++) 178 buffer[i] = 0; 179 } else if (s->bitshift != 0) { 180 for (i = 0; i < s->blocksize; i++) 181 buffer[i] *= 1U << s->bitshift; 182 } 183} 184 185static int init_offset(ShortenContext *s) 186{ 187 int32_t mean = 0; 188 int chan, i; 189 int nblock = FFMAX(1, s->nmean); 190 /* initialise offset */ 191 switch (s->internal_ftype) { 192 case TYPE_U8: 193 s->avctx->sample_fmt = AV_SAMPLE_FMT_U8P; 194 mean = 0x80; 195 break; 196 case TYPE_S16HL: 197 case TYPE_S16LH: 198 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P; 199 break; 200 default: 201 av_log(s->avctx, AV_LOG_ERROR, "unknown audio type\n"); 202 return AVERROR_PATCHWELCOME; 203 } 204 205 for (chan = 0; chan < s->channels; chan++) 206 for (i = 0; i < nblock; i++) 207 s->offset[chan][i] = mean; 208 return 0; 209} 210 211static int decode_aiff_header(AVCodecContext *avctx, const uint8_t *header, 212 int header_size) 213{ 214 ShortenContext *s = avctx->priv_data; 215 int len, bps, exp; 216 GetByteContext gb; 217 uint64_t val; 218 uint32_t tag; 219 220 bytestream2_init(&gb, header, header_size); 221 222 if (bytestream2_get_le32(&gb) != MKTAG('F', 'O', 'R', 'M')) { 223 av_log(avctx, AV_LOG_ERROR, "missing FORM tag\n"); 224 return AVERROR_INVALIDDATA; 225 } 226 227 bytestream2_skip(&gb, 4); /* chunk size */ 228 229 tag = bytestream2_get_le32(&gb); 230 if (tag != MKTAG('A', 'I', 'F', 'F') && 231 tag != MKTAG('A', 'I', 'F', 'C')) { 232 av_log(avctx, AV_LOG_ERROR, "missing AIFF tag\n"); 233 return AVERROR_INVALIDDATA; 234 } 235 236 while (bytestream2_get_le32(&gb) != MKTAG('C', 'O', 'M', 'M')) { 237 len = bytestream2_get_be32(&gb); 238 if (len < 0 || bytestream2_get_bytes_left(&gb) < 18LL + len + (len&1)) { 239 av_log(avctx, AV_LOG_ERROR, "no COMM chunk found\n"); 240 return AVERROR_INVALIDDATA; 241 } 242 bytestream2_skip(&gb, len + (len & 1)); 243 } 244 len = bytestream2_get_be32(&gb); 245 246 if (len < 18) { 247 av_log(avctx, AV_LOG_ERROR, "COMM chunk was too short\n"); 248 return AVERROR_INVALIDDATA; 249 } 250 251 bytestream2_skip(&gb, 6); 252 bps = bytestream2_get_be16(&gb); 253 avctx->bits_per_coded_sample = bps; 254 255 s->swap = tag == MKTAG('A', 'I', 'F', 'C'); 256 257 if (bps != 16 && bps != 8) { 258 av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample: %d\n", bps); 259 return AVERROR(ENOSYS); 260 } 261 262 exp = bytestream2_get_be16(&gb) - 16383 - 63; 263 val = bytestream2_get_be64(&gb); 264 if (exp < -63 || exp > 63) { 265 av_log(avctx, AV_LOG_ERROR, "exp %d is out of range\n", exp); 266 return AVERROR_INVALIDDATA; 267 } 268 if (exp >= 0) 269 avctx->sample_rate = val << exp; 270 else 271 avctx->sample_rate = (val + (1ULL<<(-exp-1))) >> -exp; 272 len -= 18; 273 if (len > 0) 274 av_log(avctx, AV_LOG_INFO, "%d header bytes unparsed\n", len); 275 276 return 0; 277} 278 279static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header, 280 int header_size) 281{ 282 int len, bps; 283 short wave_format; 284 GetByteContext gb; 285 286 bytestream2_init(&gb, header, header_size); 287 288 if (bytestream2_get_le32(&gb) != MKTAG('R', 'I', 'F', 'F')) { 289 av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n"); 290 return AVERROR_INVALIDDATA; 291 } 292 293 bytestream2_skip(&gb, 4); /* chunk size */ 294 295 if (bytestream2_get_le32(&gb) != MKTAG('W', 'A', 'V', 'E')) { 296 av_log(avctx, AV_LOG_ERROR, "missing WAVE tag\n"); 297 return AVERROR_INVALIDDATA; 298 } 299 300 while (bytestream2_get_le32(&gb) != MKTAG('f', 'm', 't', ' ')) { 301 len = bytestream2_get_le32(&gb); 302 bytestream2_skip(&gb, len); 303 if (len < 0 || bytestream2_get_bytes_left(&gb) < 16) { 304 av_log(avctx, AV_LOG_ERROR, "no fmt chunk found\n"); 305 return AVERROR_INVALIDDATA; 306 } 307 } 308 len = bytestream2_get_le32(&gb); 309 310 if (len < 16) { 311 av_log(avctx, AV_LOG_ERROR, "fmt chunk was too short\n"); 312 return AVERROR_INVALIDDATA; 313 } 314 315 wave_format = bytestream2_get_le16(&gb); 316 317 switch (wave_format) { 318 case WAVE_FORMAT_PCM: 319 break; 320 default: 321 av_log(avctx, AV_LOG_ERROR, "unsupported wave format\n"); 322 return AVERROR(ENOSYS); 323 } 324 325 bytestream2_skip(&gb, 2); // skip channels (already got from shorten header) 326 avctx->sample_rate = bytestream2_get_le32(&gb); 327 bytestream2_skip(&gb, 4); // skip bit rate (represents original uncompressed bit rate) 328 bytestream2_skip(&gb, 2); // skip block align (not needed) 329 bps = bytestream2_get_le16(&gb); 330 avctx->bits_per_coded_sample = bps; 331 332 if (bps != 16 && bps != 8) { 333 av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample: %d\n", bps); 334 return AVERROR(ENOSYS); 335 } 336 337 len -= 16; 338 if (len > 0) 339 av_log(avctx, AV_LOG_INFO, "%d header bytes unparsed\n", len); 340 341 return 0; 342} 343 344static const int fixed_coeffs[][3] = { 345 { 0, 0, 0 }, 346 { 1, 0, 0 }, 347 { 2, -1, 0 }, 348 { 3, -3, 1 } 349}; 350 351static int decode_subframe_lpc(ShortenContext *s, int command, int channel, 352 int residual_size, int32_t coffset) 353{ 354 int pred_order, sum, qshift, init_sum, i, j; 355 const int *coeffs; 356 357 if (command == FN_QLPC) { 358 /* read/validate prediction order */ 359 pred_order = get_ur_golomb_shorten(&s->gb, LPCQSIZE); 360 if ((unsigned)pred_order > s->nwrap) { 361 av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n", 362 pred_order); 363 return AVERROR(EINVAL); 364 } 365 /* read LPC coefficients */ 366 for (i = 0; i < pred_order; i++) 367 s->coeffs[i] = get_sr_golomb_shorten(&s->gb, LPCQUANT); 368 coeffs = s->coeffs; 369 370 qshift = LPCQUANT; 371 } else { 372 /* fixed LPC coeffs */ 373 pred_order = command; 374 if (pred_order >= FF_ARRAY_ELEMS(fixed_coeffs)) { 375 av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n", 376 pred_order); 377 return AVERROR_INVALIDDATA; 378 } 379 coeffs = fixed_coeffs[pred_order]; 380 qshift = 0; 381 } 382 383 /* subtract offset from previous samples to use in prediction */ 384 if (command == FN_QLPC && coffset) 385 for (i = -pred_order; i < 0; i++) 386 s->decoded[channel][i] -= (unsigned)coffset; 387 388 /* decode residual and do LPC prediction */ 389 init_sum = pred_order ? (command == FN_QLPC ? s->lpcqoffset : 0) : coffset; 390 for (i = 0; i < s->blocksize; i++) { 391 sum = init_sum; 392 for (j = 0; j < pred_order; j++) 393 sum += coeffs[j] * (unsigned)s->decoded[channel][i - j - 1]; 394 s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + 395 (unsigned)(sum >> qshift); 396 } 397 398 /* add offset to current samples */ 399 if (command == FN_QLPC && coffset) 400 for (i = 0; i < s->blocksize; i++) 401 s->decoded[channel][i] += (unsigned)coffset; 402 403 return 0; 404} 405 406static int read_header(ShortenContext *s) 407{ 408 int i, ret; 409 int maxnlpc = 0; 410 /* shorten signature */ 411 if (get_bits_long(&s->gb, 32) != AV_RB32("ajkg")) { 412 av_log(s->avctx, AV_LOG_ERROR, "missing shorten magic 'ajkg'\n"); 413 return AVERROR_INVALIDDATA; 414 } 415 416 s->lpcqoffset = 0; 417 s->blocksize = DEFAULT_BLOCK_SIZE; 418 s->nmean = -1; 419 s->version = get_bits(&s->gb, 8); 420 s->internal_ftype = get_uint(s, TYPESIZE); 421 422 s->channels = get_uint(s, CHANSIZE); 423 if (!s->channels) { 424 av_log(s->avctx, AV_LOG_ERROR, "No channels reported\n"); 425 return AVERROR_INVALIDDATA; 426 } 427 if (s->channels > MAX_CHANNELS) { 428 av_log(s->avctx, AV_LOG_ERROR, "too many channels: %d\n", s->channels); 429 s->channels = 0; 430 return AVERROR_INVALIDDATA; 431 } 432 if (s->avctx->ch_layout.nb_channels != s->channels) { 433 av_channel_layout_uninit(&s->avctx->ch_layout); 434 s->avctx->ch_layout.nb_channels = s->channels; 435 s->avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; 436 } 437 438 /* get blocksize if version > 0 */ 439 if (s->version > 0) { 440 int skip_bytes; 441 unsigned blocksize; 442 443 blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE)); 444 if (!blocksize || blocksize > MAX_BLOCKSIZE) { 445 av_log(s->avctx, AV_LOG_ERROR, 446 "invalid or unsupported block size: %d\n", 447 blocksize); 448 return AVERROR(EINVAL); 449 } 450 s->blocksize = blocksize; 451 452 maxnlpc = get_uint(s, LPCQSIZE); 453 if (maxnlpc > 1024U) { 454 av_log(s->avctx, AV_LOG_ERROR, "maxnlpc is: %d\n", maxnlpc); 455 return AVERROR_INVALIDDATA; 456 } 457 s->nmean = get_uint(s, 0); 458 if (s->nmean > 32768U) { 459 av_log(s->avctx, AV_LOG_ERROR, "nmean is: %d\n", s->nmean); 460 return AVERROR_INVALIDDATA; 461 } 462 463 skip_bytes = get_uint(s, NSKIPSIZE); 464 if ((unsigned)skip_bytes > FFMAX(get_bits_left(&s->gb), 0)/8) { 465 av_log(s->avctx, AV_LOG_ERROR, "invalid skip_bytes: %d\n", skip_bytes); 466 return AVERROR_INVALIDDATA; 467 } 468 469 for (i = 0; i < skip_bytes; i++) 470 skip_bits(&s->gb, 8); 471 } 472 s->nwrap = FFMAX(NWRAP, maxnlpc); 473 474 if (s->version > 1) 475 s->lpcqoffset = V2LPCQOFFSET; 476 477 if (s->avctx->extradata_size > 0) 478 goto end; 479 480 if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) { 481 av_log(s->avctx, AV_LOG_ERROR, 482 "missing verbatim section at beginning of stream\n"); 483 return AVERROR_INVALIDDATA; 484 } 485 486 s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE); 487 if (s->header_size >= OUT_BUFFER_SIZE || 488 s->header_size < CANONICAL_HEADER_SIZE) { 489 av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n", 490 s->header_size); 491 return AVERROR_INVALIDDATA; 492 } 493 494 for (i = 0; i < s->header_size; i++) 495 s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE); 496 497 if (AV_RL32(s->header) == MKTAG('R','I','F','F')) { 498 if ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0) 499 return ret; 500 } else if (AV_RL32(s->header) == MKTAG('F','O','R','M')) { 501 if ((ret = decode_aiff_header(s->avctx, s->header, s->header_size)) < 0) 502 return ret; 503 } else { 504 avpriv_report_missing_feature(s->avctx, "unsupported bit packing %" 505 PRIX32, AV_RL32(s->header)); 506 return AVERROR_PATCHWELCOME; 507 } 508 509end: 510 511 if ((ret = allocate_buffers(s)) < 0) 512 return ret; 513 514 if ((ret = init_offset(s)) < 0) 515 return ret; 516 517 s->cur_chan = 0; 518 s->bitshift = 0; 519 520 s->got_header = 1; 521 522 return 0; 523} 524 525static int shorten_decode_frame(AVCodecContext *avctx, AVFrame *frame, 526 int *got_frame_ptr, AVPacket *avpkt) 527{ 528 const uint8_t *buf = avpkt->data; 529 int buf_size = avpkt->size; 530 ShortenContext *s = avctx->priv_data; 531 int i, input_buf_size = 0; 532 int ret; 533 534 /* allocate internal bitstream buffer */ 535 if (s->max_framesize == 0) { 536 void *tmp_ptr; 537 s->max_framesize = 8192; // should hopefully be enough for the first header 538 tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, 539 s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE); 540 if (!tmp_ptr) { 541 s->max_framesize = 0; 542 av_log(avctx, AV_LOG_ERROR, "error allocating bitstream buffer\n"); 543 return AVERROR(ENOMEM); 544 } 545 memset(tmp_ptr, 0, s->allocated_bitstream_size); 546 s->bitstream = tmp_ptr; 547 } 548 549 /* append current packet data to bitstream buffer */ 550 buf_size = FFMIN(buf_size, s->max_framesize - s->bitstream_size); 551 input_buf_size = buf_size; 552 553 if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE > 554 s->allocated_bitstream_size) { 555 memmove(s->bitstream, &s->bitstream[s->bitstream_index], 556 s->bitstream_size); 557 s->bitstream_index = 0; 558 } 559 if (buf) 560 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, 561 buf_size); 562 buf = &s->bitstream[s->bitstream_index]; 563 buf_size += s->bitstream_size; 564 s->bitstream_size = buf_size; 565 memset(buf + buf_size, 0, AV_INPUT_BUFFER_PADDING_SIZE); 566 567 /* do not decode until buffer has at least max_framesize bytes or 568 * the end of the file has been reached */ 569 if (buf_size < s->max_framesize && avpkt->data) { 570 *got_frame_ptr = 0; 571 return input_buf_size; 572 } 573 /* init and position bitstream reader */ 574 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0) 575 return ret; 576 skip_bits(&s->gb, s->bitindex); 577 578 /* process header or next subblock */ 579 if (!s->got_header) { 580 581 if ((ret = read_header(s)) < 0) 582 return ret; 583 584 if (avpkt->size) { 585 int max_framesize; 586 void *tmp_ptr; 587 588 max_framesize = FFMAX(s->max_framesize, s->blocksize * s->channels * 8); 589 tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, 590 max_framesize + AV_INPUT_BUFFER_PADDING_SIZE); 591 if (!tmp_ptr) { 592 av_log(avctx, AV_LOG_ERROR, "error allocating bitstream buffer\n"); 593 return AVERROR(ENOMEM); 594 } 595 s->bitstream = tmp_ptr; 596 s->max_framesize = max_framesize; 597 *got_frame_ptr = 0; 598 goto finish_frame; 599 } 600 } 601 602 /* if quit command was read previously, don't decode anything */ 603 if (s->got_quit_command) { 604 *got_frame_ptr = 0; 605 return avpkt->size; 606 } 607 608 s->cur_chan = 0; 609 while (s->cur_chan < s->channels) { 610 unsigned cmd; 611 int len; 612 613 if (get_bits_left(&s->gb) < 3 + FNSIZE) { 614 *got_frame_ptr = 0; 615 break; 616 } 617 618 cmd = get_ur_golomb_shorten(&s->gb, FNSIZE); 619 620 if (cmd > FN_VERBATIM) { 621 av_log(avctx, AV_LOG_ERROR, "unknown shorten function %d\n", cmd); 622 *got_frame_ptr = 0; 623 break; 624 } 625 626 if (!is_audio_command[cmd]) { 627 /* process non-audio command */ 628 switch (cmd) { 629 case FN_VERBATIM: 630 len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE); 631 if (len < 0 || len > get_bits_left(&s->gb)) { 632 av_log(avctx, AV_LOG_ERROR, "verbatim length %d invalid\n", 633 len); 634 return AVERROR_INVALIDDATA; 635 } 636 while (len--) 637 get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE); 638 break; 639 case FN_BITSHIFT: { 640 unsigned bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE); 641 if (bitshift > 32) { 642 av_log(avctx, AV_LOG_ERROR, "bitshift %d is invalid\n", 643 bitshift); 644 return AVERROR_INVALIDDATA; 645 } 646 s->bitshift = bitshift; 647 break; 648 } 649 case FN_BLOCKSIZE: { 650 unsigned blocksize = get_uint(s, av_log2(s->blocksize)); 651 if (blocksize > s->blocksize) { 652 avpriv_report_missing_feature(avctx, 653 "Increasing block size"); 654 return AVERROR_PATCHWELCOME; 655 } 656 if (!blocksize || blocksize > MAX_BLOCKSIZE) { 657 av_log(avctx, AV_LOG_ERROR, "invalid or unsupported " 658 "block size: %d\n", blocksize); 659 return AVERROR(EINVAL); 660 } 661 s->blocksize = blocksize; 662 break; 663 } 664 case FN_QUIT: 665 s->got_quit_command = 1; 666 break; 667 } 668 if (cmd == FN_QUIT) 669 break; 670 } else { 671 /* process audio command */ 672 int residual_size = 0; 673 int channel = s->cur_chan; 674 int32_t coffset; 675 676 /* get Rice code for residual decoding */ 677 if (cmd != FN_ZERO) { 678 residual_size = get_ur_golomb_shorten(&s->gb, ENERGYSIZE); 679 /* This is a hack as version 0 differed in the definition 680 * of get_sr_golomb_shorten(). */ 681 if (s->version == 0) 682 residual_size--; 683 if (residual_size > 30U) { 684 av_log(avctx, AV_LOG_ERROR, "residual size unsupportd: %d\n", residual_size); 685 return AVERROR_INVALIDDATA; 686 } 687 } 688 689 /* calculate sample offset using means from previous blocks */ 690 if (s->nmean == 0) 691 coffset = s->offset[channel][0]; 692 else { 693 int32_t sum = (s->version < 2) ? 0 : s->nmean / 2; 694 for (i = 0; i < s->nmean; i++) 695 sum += (unsigned)s->offset[channel][i]; 696 coffset = sum / s->nmean; 697 if (s->version >= 2) 698 coffset = s->bitshift == 0 ? coffset : coffset >> s->bitshift - 1 >> 1; 699 } 700 701 /* decode samples for this channel */ 702 if (cmd == FN_ZERO) { 703 for (i = 0; i < s->blocksize; i++) 704 s->decoded[channel][i] = 0; 705 } else { 706 if ((ret = decode_subframe_lpc(s, cmd, channel, 707 residual_size, coffset)) < 0) 708 return ret; 709 } 710 711 /* update means with info from the current block */ 712 if (s->nmean > 0) { 713 int64_t sum = (s->version < 2) ? 0 : s->blocksize / 2; 714 for (i = 0; i < s->blocksize; i++) 715 sum += s->decoded[channel][i]; 716 717 for (i = 1; i < s->nmean; i++) 718 s->offset[channel][i - 1] = s->offset[channel][i]; 719 720 if (s->version < 2) 721 s->offset[channel][s->nmean - 1] = sum / s->blocksize; 722 else 723 s->offset[channel][s->nmean - 1] = s->bitshift == 32 ? 0 : (sum / s->blocksize) * (1LL << s->bitshift); 724 } 725 726 /* copy wrap samples for use with next block */ 727 for (i = -s->nwrap; i < 0; i++) 728 s->decoded[channel][i] = s->decoded[channel][i + s->blocksize]; 729 730 /* shift samples to add in unused zero bits which were removed 731 * during encoding */ 732 fix_bitshift(s, s->decoded[channel]); 733 734 /* if this is the last channel in the block, output the samples */ 735 s->cur_chan++; 736 if (s->cur_chan == s->channels) { 737 uint8_t *samples_u8; 738 int16_t *samples_s16; 739 int chan; 740 741 /* get output buffer */ 742 frame->nb_samples = s->blocksize; 743 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 744 return ret; 745 746 for (chan = 0; chan < s->channels; chan++) { 747 samples_u8 = ((uint8_t **)frame->extended_data)[chan]; 748 samples_s16 = ((int16_t **)frame->extended_data)[chan]; 749 for (i = 0; i < s->blocksize; i++) { 750 switch (s->internal_ftype) { 751 case TYPE_U8: 752 *samples_u8++ = av_clip_uint8(s->decoded[chan][i]); 753 break; 754 case TYPE_S16HL: 755 case TYPE_S16LH: 756 *samples_s16++ = av_clip_int16(s->decoded[chan][i]); 757 break; 758 } 759 } 760 if (s->swap && s->internal_ftype != TYPE_U8) 761 s->bdsp.bswap16_buf(((uint16_t **)frame->extended_data)[chan], 762 ((uint16_t **)frame->extended_data)[chan], 763 s->blocksize); 764 765 } 766 767 *got_frame_ptr = 1; 768 } 769 } 770 } 771 if (s->cur_chan < s->channels) 772 *got_frame_ptr = 0; 773 774finish_frame: 775 s->bitindex = get_bits_count(&s->gb) - 8 * (get_bits_count(&s->gb) / 8); 776 i = get_bits_count(&s->gb) / 8; 777 if (i > buf_size) { 778 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size); 779 s->bitstream_size = 0; 780 s->bitstream_index = 0; 781 return AVERROR_INVALIDDATA; 782 } 783 if (s->bitstream_size) { 784 s->bitstream_index += i; 785 s->bitstream_size -= i; 786 return input_buf_size; 787 } else 788 return i; 789} 790 791static av_cold int shorten_decode_close(AVCodecContext *avctx) 792{ 793 ShortenContext *s = avctx->priv_data; 794 int i; 795 796 for (i = 0; i < s->channels; i++) { 797 s->decoded[i] = NULL; 798 av_freep(&s->decoded_base[i]); 799 av_freep(&s->offset[i]); 800 } 801 av_freep(&s->bitstream); 802 av_freep(&s->coeffs); 803 804 return 0; 805} 806 807const FFCodec ff_shorten_decoder = { 808 .p.name = "shorten", 809 .p.long_name = NULL_IF_CONFIG_SMALL("Shorten"), 810 .p.type = AVMEDIA_TYPE_AUDIO, 811 .p.id = AV_CODEC_ID_SHORTEN, 812 .priv_data_size = sizeof(ShortenContext), 813 .init = shorten_decode_init, 814 .close = shorten_decode_close, 815 FF_CODEC_DECODE_CB(shorten_decode_frame), 816 .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF | 817 AV_CODEC_CAP_DELAY | 818 AV_CODEC_CAP_DR1 | 819 AV_CODEC_CAP_SUBFRAMES , 820 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, 821 AV_SAMPLE_FMT_U8P, 822 AV_SAMPLE_FMT_NONE }, 823 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 824}; 825