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
shorten_decode_init(AVCodecContext *avctx)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
allocate_buffers(ShortenContext *s)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
get_uint(ShortenContext *s, int k)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
fix_bitshift(ShortenContext *s, int32_t *buffer)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
init_offset(ShortenContext *s)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
decode_aiff_header(AVCodecContext *avctx, const uint8_t *header, int header_size)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
decode_wave_header(AVCodecContext *avctx, const uint8_t *header, int header_size)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
decode_subframe_lpc(ShortenContext *s, int command, int channel, int residual_size, int32_t coffset)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
read_header(ShortenContext *s)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
shorten_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)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
shorten_decode_close(AVCodecContext *avctx)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 };
825