FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/shorten.c
Date: 2024-07-14 13:34:57
Exec Total Coverage
Lines: 233 410 56.8%
Functions: 10 11 90.9%
Branches: 123 269 45.7%

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