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