libavcodec/shorten.c

   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 */
  80 static 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
  86 typedef 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
 118 static 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
 128 static 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
 162 static 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
 172 static 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
 185 static 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
 211 static 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
 279 static 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
 344 static const int fixed_coeffs[][3] = {
 345     { 0,  0,  0 },
 346     { 1,  0,  0 },
 347     { 2, -1,  0 },
 348     { 3, -3,  1 }
 349 };
 350
 351 static 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
 406 static 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
 509 end:
 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
 525 static 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
 774 finish_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
 791 static 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
 807 const 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 };