FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/mlpdec.c
Date: 2023-03-22 23:59:29
Exec Total Coverage
Lines: 476 665 71.6%
Functions: 18 19 94.7%
Branches: 287 449 63.9%
Line Branch Exec Source
1 /*
2 * MLP decoder
3 * Copyright (c) 2007-2008 Ian Caulfield
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 * MLP decoder
25 */
26
27 #include "config_components.h"
28
29 #include <stdint.h>
30
31 #include "avcodec.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/channel_layout.h"
35 #include "libavutil/mem_internal.h"
36 #include "libavutil/thread.h"
37 #include "libavutil/opt.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40 #include "get_bits.h"
41 #include "mlp_parse.h"
42 #include "mlpdsp.h"
43 #include "mlp.h"
44 #include "config.h"
45 #include "profiles.h"
46
47 /** number of bits used for VLC lookup - longest Huffman code is 9 */
48 #if ARCH_ARM
49 #define VLC_BITS 5
50 #define VLC_STATIC_SIZE 64
51 #else
52 #define VLC_BITS 9
53 #define VLC_STATIC_SIZE 512
54 #endif
55
56 typedef struct SubStream {
57 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
58 uint8_t restart_seen;
59 /// Set if end of stream is encountered
60 uint8_t end_of_stream;
61
62 //@{
63 /** restart header data */
64 /// The type of noise to be used in the rematrix stage.
65 uint16_t noise_type;
66
67 /// The index of the first channel coded in this substream.
68 uint8_t min_channel;
69 /// The index of the last channel coded in this substream.
70 uint8_t max_channel;
71 /// The coded channels mask in this substream.
72 uint64_t coded_channels;
73 /// The number of channels input into the rematrix stage.
74 uint8_t max_matrix_channel;
75 /// For each channel output by the matrix, the output channel to map it to
76 uint8_t ch_assign[MAX_CHANNELS];
77 /// The channel layout for this substream
78 uint64_t mask;
79 /// The matrix encoding mode for this substream
80 enum AVMatrixEncoding matrix_encoding;
81 enum AVMatrixEncoding prev_matrix_encoding;
82
83 /// Channel coding parameters for channels in the substream
84 ChannelParams channel_params[MAX_CHANNELS];
85
86 /// The left shift applied to random noise in 0x31ea substreams.
87 uint8_t noise_shift;
88 /// The current seed value for the pseudorandom noise generator(s).
89 uint32_t noisegen_seed;
90
91 /// Set if the substream contains extra info to check the size of VLC blocks.
92 uint8_t data_check_present;
93
94 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
95 uint8_t param_presence_flags;
96 #define PARAM_BLOCKSIZE (1 << 7)
97 #define PARAM_MATRIX (1 << 6)
98 #define PARAM_OUTSHIFT (1 << 5)
99 #define PARAM_QUANTSTEP (1 << 4)
100 #define PARAM_FIR (1 << 3)
101 #define PARAM_IIR (1 << 2)
102 #define PARAM_HUFFOFFSET (1 << 1)
103 #define PARAM_PRESENCE (1 << 0)
104 //@}
105
106 //@{
107 /** matrix data */
108
109 /// Number of matrices to be applied.
110 uint8_t num_primitive_matrices;
111
112 /// matrix output channel
113 uint8_t matrix_out_ch[MAX_MATRICES];
114
115 /// Whether the LSBs of the matrix output are encoded in the bitstream.
116 uint8_t lsb_bypass[MAX_MATRICES];
117 /// Matrix coefficients, stored as 2.14 fixed point.
118 DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];
119 /// Left shift to apply to noise values in 0x31eb substreams.
120 uint8_t matrix_noise_shift[MAX_MATRICES];
121 //@}
122
123 /// Left shift to apply to Huffman-decoded residuals.
124 uint8_t quant_step_size[MAX_CHANNELS];
125
126 /// number of PCM samples in current audio block
127 uint16_t blocksize;
128 /// Number of PCM samples decoded so far in this frame.
129 uint16_t blockpos;
130
131 /// Left shift to apply to decoded PCM values to get final 24-bit output.
132 int8_t output_shift[MAX_CHANNELS];
133
134 /// Running XOR of all output samples.
135 int32_t lossless_check_data;
136
137 } SubStream;
138
139 typedef struct MLPDecodeContext {
140 const AVClass *class;
141 AVCodecContext *avctx;
142
143 AVChannelLayout downmix_layout;
144
145 /// Current access unit being read has a major sync.
146 int is_major_sync_unit;
147
148 /// Size of the major sync unit, in bytes
149 int major_sync_header_size;
150
151 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
152 uint8_t params_valid;
153
154 /// Number of substreams contained within this stream.
155 uint8_t num_substreams;
156
157 /// Which substream of substreams carry 16-channel presentation
158 uint8_t extended_substream_info;
159
160 /// Which substream of substreams carry 2/6/8-channel presentation
161 uint8_t substream_info;
162
163 /// Index of the last substream to decode - further substreams are skipped.
164 uint8_t max_decoded_substream;
165
166 /// Stream needs channel reordering to comply with FFmpeg's channel order
167 uint8_t needs_reordering;
168
169 /// number of PCM samples contained in each frame
170 int access_unit_size;
171 /// next power of two above the number of samples in each frame
172 int access_unit_size_pow2;
173
174 SubStream substream[MAX_SUBSTREAMS];
175
176 int matrix_changed;
177 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
178
179 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
180 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
181 DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
182
183 MLPDSPContext dsp;
184 } MLPDecodeContext;
185
186 static const enum AVChannel thd_channel_order[] = {
187 AV_CHAN_FRONT_LEFT, AV_CHAN_FRONT_RIGHT, // LR
188 AV_CHAN_FRONT_CENTER, // C
189 AV_CHAN_LOW_FREQUENCY, // LFE
190 AV_CHAN_SIDE_LEFT, AV_CHAN_SIDE_RIGHT, // LRs
191 AV_CHAN_TOP_FRONT_LEFT, AV_CHAN_TOP_FRONT_RIGHT, // LRvh
192 AV_CHAN_FRONT_LEFT_OF_CENTER, AV_CHAN_FRONT_RIGHT_OF_CENTER, // LRc
193 AV_CHAN_BACK_LEFT, AV_CHAN_BACK_RIGHT, // LRrs
194 AV_CHAN_BACK_CENTER, // Cs
195 AV_CHAN_TOP_CENTER, // Ts
196 AV_CHAN_SURROUND_DIRECT_LEFT, AV_CHAN_SURROUND_DIRECT_RIGHT, // LRsd
197 AV_CHAN_WIDE_LEFT, AV_CHAN_WIDE_RIGHT, // LRw
198 AV_CHAN_TOP_FRONT_CENTER, // Cvh
199 AV_CHAN_LOW_FREQUENCY_2, // LFE2
200 };
201
202 2220 static int mlp_channel_layout_subset(AVChannelLayout *layout, uint64_t mask)
203 {
204
3/4
✓ Branch 1 taken 215 times.
✓ Branch 2 taken 2005 times.
✓ Branch 3 taken 215 times.
✗ Branch 4 not taken.
 2435 return av_channel_layout_check(layout) &&
205 215 av_channel_layout_subset(layout, mask) ==
206 215 av_channel_layout_subset(layout, UINT64_MAX);
207 }
208
209 3958 static enum AVChannel thd_channel_layout_extract_channel(uint64_t channel_layout,
210 int index)
211 {
212 int i;
213
214
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3958 times.
 3958 if (av_popcount64(channel_layout) <= index)
215 ✗ return AV_CHAN_NONE;
216
217
1/2
✓ Branch 0 taken 11285 times.
✗ Branch 1 not taken.
 11285 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
218
4/4
✓ Branch 0 taken 11237 times.
✓ Branch 1 taken 48 times.
✓ Branch 2 taken 3958 times.
✓ Branch 3 taken 7279 times.
 11285 if (channel_layout & (1ULL << thd_channel_order[i]) && !index--)
219 3958 return thd_channel_order[i];
220 ✗ return AV_CHAN_NONE;
221 }
222
223 static VLC huff_vlc[3];
224
225 /** Initialize static data, constant between all invocations of the codec. */
226
227 9 static av_cold void init_static(void)
228 {
229
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 9 times.
 36 for (int i = 0; i < 3; i++) {
230 static VLCElem vlc_buf[3 * VLC_STATIC_SIZE];
231 27 huff_vlc[i].table = &vlc_buf[i * VLC_STATIC_SIZE];
232 27 huff_vlc[i].table_allocated = VLC_STATIC_SIZE;
233 27 init_vlc(&huff_vlc[i], VLC_BITS, 18,
234 &ff_mlp_huffman_tables[i][0][1], 2, 1,
235 &ff_mlp_huffman_tables[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
236 }
237
238 9 ff_mlp_init_crc();
239 9 }
240
241 16834 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
242 unsigned int substr, unsigned int ch)
243 {
244 16834 SubStream *s = &m->substream[substr];
245 16834 ChannelParams *cp = &s->channel_params[ch];
246 16834 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
247
2/2
✓ Branch 0 taken 11899 times.
✓ Branch 1 taken 4935 times.
 16834 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
248 16834 int32_t sign_huff_offset = cp->huff_offset;
249
250
2/2
✓ Branch 0 taken 11899 times.
✓ Branch 1 taken 4935 times.
 16834 if (cp->codebook > 0)
251 11899 sign_huff_offset -= 7 << lsb_bits;
252
253
2/2
✓ Branch 0 taken 15281 times.
✓ Branch 1 taken 1553 times.
 16834 if (sign_shift >= 0)
254 15281 sign_huff_offset -= 1 << sign_shift;
255
256 16834 return sign_huff_offset;
257 }
258
259 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
260 * and plain LSBs. */
261
262 1121160 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
263 unsigned int substr, unsigned int pos)
264 {
265 1121160 SubStream *s = &m->substream[substr];
266 unsigned int mat, channel;
267
268
2/2
✓ Branch 0 taken 2054520 times.
✓ Branch 1 taken 1121160 times.
 3175680 for (mat = 0; mat < s->num_primitive_matrices; mat++)
269
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2054520 times.
 2054520 if (s->lsb_bypass[mat])
270 ✗ m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
271
272
2/2
✓ Branch 0 taken 2734080 times.
✓ Branch 1 taken 1121160 times.
 3855240 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
273 2734080 ChannelParams *cp = &s->channel_params[channel];
274 2734080 int codebook = cp->codebook;
275 2734080 int quant_step_size = s->quant_step_size[channel];
276 2734080 int lsb_bits = cp->huff_lsbs - quant_step_size;
277 2734080 int result = 0;
278
279
2/2
✓ Branch 0 taken 2490712 times.
✓ Branch 1 taken 243368 times.
 2734080 if (codebook > 0)
280 2490712 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
281 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
282
283
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2734080 times.
 2734080 if (result < 0)
284 ✗ return AVERROR_INVALIDDATA;
285
286
2/2
✓ Branch 0 taken 2549944 times.
✓ Branch 1 taken 184136 times.
 2734080 if (lsb_bits > 0)
287 2549944 result = (result << lsb_bits) + get_bits_long(gbp, lsb_bits);
288
289 2734080 result += cp->sign_huff_offset;
290 2734080 result *= 1 << quant_step_size;
291
292 2734080 m->sample_buffer[pos + s->blockpos][channel] = result;
293 }
294
295 1121160 return 0;
296 }
297
298 15 static av_cold int mlp_decode_init(AVCodecContext *avctx)
299 {
300 static AVOnce init_static_once = AV_ONCE_INIT;
301 15 MLPDecodeContext *m = avctx->priv_data;
302 int substr;
303
304 15 m->avctx = avctx;
305
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 15 times.
 75 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
306 60 m->substream[substr].lossless_check_data = 0xffffffff;
307 15 ff_mlpdsp_init(&m->dsp);
308
309 #if FF_API_OLD_CHANNEL_LAYOUT
310 FF_DISABLE_DEPRECATION_WARNINGS
311
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 13 times.
 15 if (avctx->request_channel_layout) {
312 2 av_channel_layout_uninit(&m->downmix_layout);
313 2 av_channel_layout_from_mask(&m->downmix_layout, avctx->request_channel_layout);
314 }
315 FF_ENABLE_DEPRECATION_WARNINGS
316 #endif
317 15 ff_thread_once(&init_static_once, init_static);
318
319 15 return 0;
320 }
321
322 /** Read a major sync info header - contains high level information about
323 * the stream - sample rate, channel arrangement etc. Most of this
324 * information is not actually necessary for decoding, only for playback.
325 */
326
327 1774 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
328 {
329 MLPHeaderInfo mh;
330 int substr, ret;
331
332
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1774 times.
 1774 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
333 ✗ return ret;
334
335
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.group1_bits == 0) {
336 ✗ av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
337 ✗ return AVERROR_INVALIDDATA;
338 }
339
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.group2_bits > mh.group1_bits) {
340 ✗ av_log(m->avctx, AV_LOG_ERROR,
341 "Channel group 2 cannot have more bits per sample than group 1.\n");
342 ✗ return AVERROR_INVALIDDATA;
343 }
344
345
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1774 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
346 ✗ av_log(m->avctx, AV_LOG_ERROR,
347 "Channel groups with differing sample rates are not currently supported.\n");
348 ✗ return AVERROR_INVALIDDATA;
349 }
350
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.group1_samplerate == 0) {
352 ✗ av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
353 ✗ return AVERROR_INVALIDDATA;
354 }
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.group1_samplerate > MAX_SAMPLERATE) {
356 ✗ av_log(m->avctx, AV_LOG_ERROR,
357 "Sampling rate %d is greater than the supported maximum (%d).\n",
358 mh.group1_samplerate, MAX_SAMPLERATE);
359 ✗ return AVERROR_INVALIDDATA;
360 }
361
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.access_unit_size > MAX_BLOCKSIZE) {
362 ✗ av_log(m->avctx, AV_LOG_ERROR,
363 "Block size %d is greater than the supported maximum (%d).\n",
364 mh.access_unit_size, MAX_BLOCKSIZE);
365 ✗ return AVERROR_INVALIDDATA;
366 }
367
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
368 ✗ av_log(m->avctx, AV_LOG_ERROR,
369 "Block size pow2 %d is greater than the supported maximum (%d).\n",
370 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
371 ✗ return AVERROR_INVALIDDATA;
372 }
373
374
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.num_substreams == 0)
375 ✗ return AVERROR_INVALIDDATA;
376
3/4
✓ Branch 0 taken 1117 times.
✓ Branch 1 taken 657 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1117 times.
 1774 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
377 ✗ av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
378 ✗ return AVERROR_INVALIDDATA;
379 }
380
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
 1774 if (mh.num_substreams > MAX_SUBSTREAMS) {
381 ✗ avpriv_request_sample(m->avctx,
382 "%d substreams (more than the "
383 "maximum supported by the decoder)",
384 mh.num_substreams);
385 ✗ return AVERROR_PATCHWELCOME;
386 }
387
388 1774 m->major_sync_header_size = mh.header_size;
389
390 1774 m->access_unit_size = mh.access_unit_size;
391 1774 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
392
393 1774 m->num_substreams = mh.num_substreams;
394 1774 m->substream_info = mh.substream_info;
395
396 /* If there is a 4th substream and the MSB of substream_info is set,
397 * there is a 16-channel spatial presentation (Atmos in TrueHD).
398 */
399
2/2
✓ Branch 0 taken 657 times.
✓ Branch 1 taken 1117 times.
 1774 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD
400
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 653 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 657 && m->num_substreams == 4 && m->substream_info >> 7 == 1) {
401 4 m->avctx->profile = FF_PROFILE_TRUEHD_ATMOS;
402 }
403
404 /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
405 1774 m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2);
406
407 1774 m->avctx->sample_rate = mh.group1_samplerate;
408 1774 m->avctx->frame_size = mh.access_unit_size;
409
410 1774 m->avctx->bits_per_raw_sample = mh.group1_bits;
411
2/2
✓ Branch 0 taken 657 times.
✓ Branch 1 taken 1117 times.
 1774 if (mh.group1_bits > 16)
412 657 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
413 else
414 1117 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
415 3548 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,
416 1774 m->substream[m->max_decoded_substream].output_shift,
417 1774 m->substream[m->max_decoded_substream].max_matrix_channel,
418 1774 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
419
420 1774 m->params_valid = 1;
421
2/2
✓ Branch 0 taken 7096 times.
✓ Branch 1 taken 1774 times.
 8870 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
422 7096 m->substream[substr].restart_seen = 0;
423
424 /* Set the layout for each substream. When there's more than one, the first
425 * substream is Stereo. Subsequent substreams' layouts are indicated in the
426 * major sync. */
427
2/2
✓ Branch 0 taken 1117 times.
✓ Branch 1 taken 657 times.
 1774 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
428
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1117 times.
 1117 if (mh.stream_type != SYNC_MLP) {
429 ✗ avpriv_request_sample(m->avctx,
430 "unexpected stream_type %X in MLP",
431 mh.stream_type);
432 ✗ return AVERROR_PATCHWELCOME;
433 }
434
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1117 times.
 1117 if ((substr = (mh.num_substreams > 1)))
435 ✗ m->substream[0].mask = AV_CH_LAYOUT_STEREO;
436 1117 m->substream[substr].mask = mh.channel_layout_mlp;
437 } else {
438
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 657 times.
 657 if (mh.stream_type != SYNC_TRUEHD) {
439 ✗ avpriv_request_sample(m->avctx,
440 "unexpected stream_type %X in !MLP",
441 mh.stream_type);
442 ✗ return AVERROR_PATCHWELCOME;
443 }
444 657 m->substream[1].mask = mh.channel_layout_thd_stream1;
445
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 657 times.
 657 if (mh.channels_thd_stream1 == 2 &&
446 ✗ mh.channels_thd_stream2 == 2 &&
447 ✗ m->avctx->ch_layout.nb_channels == 2)
448 ✗ m->substream[0].mask = AV_CH_LAYOUT_STEREO;
449
1/2
✓ Branch 0 taken 657 times.
✗ Branch 1 not taken.
 657 if ((substr = (mh.num_substreams > 1)))
450 657 m->substream[0].mask = AV_CH_LAYOUT_STEREO;
451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 657 times.
 657 if (mh.num_substreams == 1 &&
452 ✗ mh.channels_thd_stream1 == 1 &&
453 ✗ mh.channels_thd_stream2 == 1 &&
454 ✗ m->avctx->ch_layout.nb_channels == 1)
455 ✗ m->substream[0].mask = AV_CH_LAYOUT_MONO;
456
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 653 times.
 657 if (mh.num_substreams > 2)
457
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (mh.channel_layout_thd_stream2)
458 4 m->substream[2].mask = mh.channel_layout_thd_stream2;
459 else
460 ✗ m->substream[2].mask = mh.channel_layout_thd_stream1;
461
2/2
✓ Branch 0 taken 435 times.
✓ Branch 1 taken 222 times.
 657 if (m->avctx->ch_layout.nb_channels > 2)
462 435 m->substream[mh.num_substreams > 1].mask = mh.channel_layout_thd_stream1;
463 }
464
465
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1774 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1774 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
466
467 /* Parse the TrueHD decoder channel modifiers and set each substream's
468 * AVMatrixEncoding accordingly.
469 *
470 * The meaning of the modifiers depends on the channel layout:
471 *
472 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
473 *
474 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
475 *
476 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
477 * layouts with an Ls/Rs channel pair
478 */
479
2/2
✓ Branch 0 taken 7096 times.
✓ Branch 1 taken 1774 times.
 8870 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
480 7096 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
481
2/2
✓ Branch 0 taken 657 times.
✓ Branch 1 taken 1117 times.
 1774 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
482
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 653 times.
 657 if (mh.num_substreams > 2 &&
483
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
484
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
485
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
486 ✗ m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
487
488
1/2
✓ Branch 0 taken 657 times.
✗ Branch 1 not taken.
 657 if (mh.num_substreams > 1 &&
489
2/2
✓ Branch 0 taken 649 times.
✓ Branch 1 taken 8 times.
 657 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
490
1/2
✓ Branch 0 taken 649 times.
✗ Branch 1 not taken.
 649 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
491
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 645 times.
 649 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
492 4 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
493
494
1/2
✓ Branch 0 taken 657 times.
✗ Branch 1 not taken.
 657 if (mh.num_substreams > 0)
495
2/3
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 653 times.
 657 switch (mh.channel_modifier_thd_stream0) {
496 4 case THD_CH_MODIFIER_LTRT:
497 4 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
498 4 break;
499 ✗ case THD_CH_MODIFIER_LBINRBIN:
500 ✗ m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
501 ✗ break;
502 653 default:
503 653 break;
504 }
505 }
506
507 1774 return 0;
508 }
509
510 /** Read a restart header from a block in a substream. This contains parameters
511 * required to decode the audio that do not change very often. Generally
512 * (always) present only in blocks following a major sync. */
513
514 2220 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
515 const uint8_t *buf, unsigned int substr)
516 {
517 2220 SubStream *s = &m->substream[substr];
518 unsigned int ch;
519 int sync_word, tmp;
520 uint8_t checksum;
521 uint8_t lossless_check;
522 2220 int start_count = get_bits_count(gbp);
523 int min_channel, max_channel, max_matrix_channel, noise_type;
524 4440 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
525 ? MAX_MATRIX_CHANNEL_MLP
526
2/2
✓ Branch 0 taken 1117 times.
✓ Branch 1 taken 1103 times.
 2220 : MAX_MATRIX_CHANNEL_TRUEHD;
527
528 2220 sync_word = get_bits(gbp, 13);
529
530
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2220 times.
 2220 if (sync_word != 0x31ea >> 1) {
531 ✗ av_log(m->avctx, AV_LOG_ERROR,
532 "restart header sync incorrect (got 0x%04x)\n", sync_word);
533 ✗ return AVERROR_INVALIDDATA;
534 }
535
536 2220 noise_type = get_bits1(gbp);
537
538
3/4
✓ Branch 0 taken 1117 times.
✓ Branch 1 taken 1103 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1117 times.
 2220 if (m->avctx->codec_id == AV_CODEC_ID_MLP && noise_type) {
539 ✗ av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
540 ✗ return AVERROR_INVALIDDATA;
541 }
542
543 2220 skip_bits(gbp, 16); /* Output timestamp */
544
545 2220 min_channel = get_bits(gbp, 4);
546 2220 max_channel = get_bits(gbp, 4);
547 2220 max_matrix_channel = get_bits(gbp, 4);
548
549
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2220 times.
 2220 if (max_matrix_channel > std_max_matrix_channel) {
550 ✗ av_log(m->avctx, AV_LOG_ERROR,
551 "Max matrix channel cannot be greater than %d.\n",
552 std_max_matrix_channel);
553 ✗ return AVERROR_INVALIDDATA;
554 }
555
556 /* This should happen for TrueHD streams with >6 channels and MLP's noise
557 * type. It is not yet known if this is allowed. */
558
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2216 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 2220 if (max_matrix_channel > MAX_MATRIX_CHANNEL_MLP && !noise_type) {
559 ✗ avpriv_request_sample(m->avctx,
560 "%d channels (more than the "
561 "maximum supported by the decoder)",
562 max_channel + 2);
563 ✗ return AVERROR_PATCHWELCOME;
564 }
565
566
2/4
✓ Branch 0 taken 2220 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2220 times.
 2220 if (max_channel + 1 > MAX_CHANNELS || max_channel + 1 < min_channel)
567 ✗ return AVERROR_INVALIDDATA;
568
569 2220 s->min_channel = min_channel;
570 2220 s->max_channel = max_channel;
571 2220 s->coded_channels = ((1LL << (max_channel - min_channel + 1)) - 1) << min_channel;
572 2220 s->max_matrix_channel = max_matrix_channel;
573 2220 s->noise_type = noise_type;
574
575
2/2
✓ Branch 1 taken 215 times.
✓ Branch 2 taken 2005 times.
 2220 if (mlp_channel_layout_subset(&m->downmix_layout, s->mask) &&
576
1/2
✓ Branch 0 taken 215 times.
✗ Branch 1 not taken.
 215 m->max_decoded_substream > substr) {
577 215 av_log(m->avctx, AV_LOG_DEBUG,
578 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
579 "Further substreams will be skipped.\n",
580 215 s->max_channel + 1, s->mask, substr);
581 215 m->max_decoded_substream = substr;
582 }
583
584 2220 s->noise_shift = get_bits(gbp, 4);
585 2220 s->noisegen_seed = get_bits(gbp, 23);
586
587 2220 skip_bits(gbp, 19);
588
589 2220 s->data_check_present = get_bits1(gbp);
590 2220 lossless_check = get_bits(gbp, 8);
591
2/2
✓ Branch 0 taken 1774 times.
✓ Branch 1 taken 446 times.
 2220 if (substr == m->max_decoded_substream
592
2/2
✓ Branch 0 taken 1759 times.
✓ Branch 1 taken 15 times.
 1774 && s->lossless_check_data != 0xffffffff) {
593 1759 tmp = xor_32_to_8(s->lossless_check_data);
594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1759 times.
 1759 if (tmp != lossless_check)
595 ✗ av_log(m->avctx, AV_LOG_WARNING,
596 "Lossless check failed - expected %02x, calculated %02x.\n",
597 lossless_check, tmp);
598 }
599
600 2220 skip_bits(gbp, 16);
601
602 2220 memset(s->ch_assign, 0, sizeof(s->ch_assign));
603
604
2/2
✓ Branch 0 taken 6192 times.
✓ Branch 1 taken 2220 times.
 8412 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
605 6192 int ch_assign = get_bits(gbp, 6);
606
2/2
✓ Branch 0 taken 3958 times.
✓ Branch 1 taken 2234 times.
 6192 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
607 AVChannelLayout l;
608 3958 enum AVChannel channel = thd_channel_layout_extract_channel(s->mask, ch_assign);
609
610 3958 av_channel_layout_from_mask(&l, s->mask);
611 3958 ch_assign = av_channel_layout_index_from_channel(&l, channel);
612 }
613
2/4
✓ Branch 0 taken 6192 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6192 times.
 6192 if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
614 ✗ avpriv_request_sample(m->avctx,
615 "Assignment of matrix channel %d to invalid output channel %d",
616 ch, ch_assign);
617 ✗ return AVERROR_PATCHWELCOME;
618 }
619 6192 s->ch_assign[ch_assign] = ch;
620 }
621
622 2220 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
623
624
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2220 times.
 2220 if (checksum != get_bits(gbp, 8))
625 ✗ av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
626
627 /* Set default decoding parameters. */
628 2220 s->param_presence_flags = 0xff;
629 2220 s->num_primitive_matrices = 0;
630 2220 s->blocksize = 8;
631 2220 s->lossless_check_data = 0;
632
633 2220 memset(s->output_shift , 0, sizeof(s->output_shift ));
634 2220 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
635
636
2/2
✓ Branch 0 taken 5292 times.
✓ Branch 1 taken 2220 times.
 7512 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
637 5292 ChannelParams *cp = &s->channel_params[ch];
638 5292 cp->filter_params[FIR].order = 0;
639 5292 cp->filter_params[IIR].order = 0;
640 5292 cp->filter_params[FIR].shift = 0;
641 5292 cp->filter_params[IIR].shift = 0;
642
643 /* Default audio coding is 24-bit raw PCM. */
644 5292 cp->huff_offset = 0;
645 5292 cp->sign_huff_offset = -(1 << 23);
646 5292 cp->codebook = 0;
647 5292 cp->huff_lsbs = 24;
648 }
649
650
2/2
✓ Branch 0 taken 1774 times.
✓ Branch 1 taken 446 times.
 2220 if (substr == m->max_decoded_substream) {
651 1774 av_channel_layout_uninit(&m->avctx->ch_layout);
652 1774 av_channel_layout_from_mask(&m->avctx->ch_layout, s->mask);
653 3548 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
654 1774 s->output_shift,
655 1774 s->max_matrix_channel,
656 1774 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
657
658
3/4
✓ Branch 0 taken 1117 times.
✓ Branch 1 taken 657 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1117 times.
 1774 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
659 ✗ if (s->mask == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
660 ✗ s->mask == AV_CH_LAYOUT_5POINT0_BACK) {
661 ✗ int i = s->ch_assign[4];
662 ✗ s->ch_assign[4] = s->ch_assign[3];
663 ✗ s->ch_assign[3] = s->ch_assign[2];
664 ✗ s->ch_assign[2] = i;
665 ✗ } else if (s->mask == AV_CH_LAYOUT_5POINT1_BACK) {
666 ✗ FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
667 ✗ FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
668 }
669 }
670
671 }
672
673 2220 return 0;
674 }
675
676 /** Read parameters for one of the prediction filters. */
677
678 5829 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
679 unsigned int substr, unsigned int channel,
680 unsigned int filter)
681 {
682 5829 SubStream *s = &m->substream[substr];
683 5829 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
684
2/2
✓ Branch 0 taken 525 times.
✓ Branch 1 taken 5304 times.
 5829 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
685
2/2
✓ Branch 0 taken 525 times.
✓ Branch 1 taken 5304 times.
 5829 const char fchar = filter ? 'I' : 'F';
686 int i, order;
687
688 // Filter is 0 for FIR, 1 for IIR.
689
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5829 times.
 5829 av_assert0(filter < 2);
690
691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5829 times.
 5829 if (m->filter_changed[channel][filter]++ > 1) {
692 ✗ av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
693 ✗ return AVERROR_INVALIDDATA;
694 }
695
696 5829 order = get_bits(gbp, 4);
697
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5829 times.
 5829 if (order > max_order) {
698 ✗ av_log(m->avctx, AV_LOG_ERROR,
699 "%cIR filter order %d is greater than maximum %d.\n",
700 fchar, order, max_order);
701 ✗ return AVERROR_INVALIDDATA;
702 }
703 5829 fp->order = order;
704
705
2/2
✓ Branch 0 taken 5824 times.
✓ Branch 1 taken 5 times.
 5829 if (order > 0) {
706 5824 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
707 int coeff_bits, coeff_shift;
708
709 5824 fp->shift = get_bits(gbp, 4);
710
711 5824 coeff_bits = get_bits(gbp, 5);
712 5824 coeff_shift = get_bits(gbp, 3);
713
2/4
✓ Branch 0 taken 5824 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5824 times.
 5824 if (coeff_bits < 1 || coeff_bits > 16) {
714 ✗ av_log(m->avctx, AV_LOG_ERROR,
715 "%cIR filter coeff_bits must be between 1 and 16.\n",
716 fchar);
717 ✗ return AVERROR_INVALIDDATA;
718 }
719
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5824 times.
 5824 if (coeff_bits + coeff_shift > 16) {
720 ✗ av_log(m->avctx, AV_LOG_ERROR,
721 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
722 fchar);
723 ✗ return AVERROR_INVALIDDATA;
724 }
725
726
2/2
✓ Branch 0 taken 24259 times.
✓ Branch 1 taken 5824 times.
 30083 for (i = 0; i < order; i++)
727 24259 fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
728
729
2/2
✓ Branch 1 taken 525 times.
✓ Branch 2 taken 5299 times.
 5824 if (get_bits1(gbp)) {
730 int state_bits, state_shift;
731
732
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 525 times.
 525 if (filter == FIR) {
733 ✗ av_log(m->avctx, AV_LOG_ERROR,
734 "FIR filter has state data specified.\n");
735 ✗ return AVERROR_INVALIDDATA;
736 }
737
738 525 state_bits = get_bits(gbp, 4);
739 525 state_shift = get_bits(gbp, 4);
740
741 /* TODO: Check validity of state data. */
742
743
2/2
✓ Branch 0 taken 972 times.
✓ Branch 1 taken 525 times.
 1497 for (i = 0; i < order; i++)
744
1/2
✓ Branch 0 taken 972 times.
✗ Branch 1 not taken.
 972 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
745 }
746 }
747
748 5829 return 0;
749 }
750
751 /** Read parameters for primitive matrices. */
752
753 1927 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
754 {
755 1927 SubStream *s = &m->substream[substr];
756 unsigned int mat, ch;
757 3854 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
758 ? MAX_MATRICES_MLP
759
2/2
✓ Branch 0 taken 832 times.
✓ Branch 1 taken 1095 times.
 1927 : MAX_MATRICES_TRUEHD;
760
761
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1927 times.
 1927 if (m->matrix_changed++ > 1) {
762 ✗ av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
763 ✗ return AVERROR_INVALIDDATA;
764 }
765
766 1927 s->num_primitive_matrices = get_bits(gbp, 4);
767
768
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1927 times.
 1927 if (s->num_primitive_matrices > max_primitive_matrices) {
769 ✗ av_log(m->avctx, AV_LOG_ERROR,
770 "Number of primitive matrices cannot be greater than %d.\n",
771 max_primitive_matrices);
772 ✗ goto error;
773 }
774
775
2/2
✓ Branch 0 taken 3494 times.
✓ Branch 1 taken 1927 times.
 5421 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
776 int frac_bits, max_chan;
777 3494 s->matrix_out_ch[mat] = get_bits(gbp, 4);
778 3494 frac_bits = get_bits(gbp, 4);
779 3494 s->lsb_bypass [mat] = get_bits1(gbp);
780
781
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3494 times.
 3494 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
782 ✗ av_log(m->avctx, AV_LOG_ERROR,
783 "Invalid channel %d specified as output from matrix.\n",
784 ✗ s->matrix_out_ch[mat]);
785 ✗ goto error;
786 }
787
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3494 times.
 3494 if (frac_bits > 14) {
788 ✗ av_log(m->avctx, AV_LOG_ERROR,
789 "Too many fractional bits specified.\n");
790 ✗ goto error;
791 }
792
793 3494 max_chan = s->max_matrix_channel;
794
2/2
✓ Branch 0 taken 2146 times.
✓ Branch 1 taken 1348 times.
 3494 if (!s->noise_type)
795 2146 max_chan+=2;
796
797
2/2
✓ Branch 0 taken 16736 times.
✓ Branch 1 taken 3494 times.
 20230 for (ch = 0; ch <= max_chan; ch++) {
798 16736 int coeff_val = 0;
799
2/2
✓ Branch 1 taken 9693 times.
✓ Branch 2 taken 7043 times.
 16736 if (get_bits1(gbp))
800 9693 coeff_val = get_sbits(gbp, frac_bits + 2);
801
802 16736 s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
803 }
804
805
2/2
✓ Branch 0 taken 1348 times.
✓ Branch 1 taken 2146 times.
 3494 if (s->noise_type)
806 1348 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
807 else
808 2146 s->matrix_noise_shift[mat] = 0;
809 }
810
811 1927 return 0;
812 ✗ error:
813 ✗ s->num_primitive_matrices = 0;
814 ✗ memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
815
816 ✗ return AVERROR_INVALIDDATA;
817 }
818
819 /** Read channel parameters. */
820
821 15911 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
822 GetBitContext *gbp, unsigned int ch)
823 {
824 15911 SubStream *s = &m->substream[substr];
825 15911 ChannelParams *cp = &s->channel_params[ch];
826 15911 FilterParams *fir = &cp->filter_params[FIR];
827 15911 FilterParams *iir = &cp->filter_params[IIR];
828 int ret;
829
830
1/2
✓ Branch 0 taken 15911 times.
✗ Branch 1 not taken.
 15911 if (s->param_presence_flags & PARAM_FIR)
831
2/2
✓ Branch 1 taken 5304 times.
✓ Branch 2 taken 10607 times.
 15911 if (get_bits1(gbp))
832
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5304 times.
 5304 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
833 ✗ return ret;
834
835
1/2
✓ Branch 0 taken 15911 times.
✗ Branch 1 not taken.
 15911 if (s->param_presence_flags & PARAM_IIR)
836
2/2
✓ Branch 1 taken 525 times.
✓ Branch 2 taken 15386 times.
 15911 if (get_bits1(gbp))
837
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 525 times.
 525 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
838 ✗ return ret;
839
840
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15911 times.
 15911 if (fir->order + iir->order > 8) {
841 ✗ av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
842 ✗ return AVERROR_INVALIDDATA;
843 }
844
845
4/4
✓ Branch 0 taken 10614 times.
✓ Branch 1 taken 5297 times.
✓ Branch 2 taken 990 times.
✓ Branch 3 taken 9624 times.
 15911 if (fir->order && iir->order &&
846
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 990 times.
 990 fir->shift != iir->shift) {
847 ✗ av_log(m->avctx, AV_LOG_ERROR,
848 "FIR and IIR filters must use the same precision.\n");
849 ✗ return AVERROR_INVALIDDATA;
850 }
851 /* The FIR and IIR filters must have the same precision.
852 * To simplify the filtering code, only the precision of the
853 * FIR filter is considered. If only the IIR filter is employed,
854 * the FIR filter precision is set to that of the IIR filter, so
855 * that the filtering code can use it. */
856
3/4
✓ Branch 0 taken 5297 times.
✓ Branch 1 taken 10614 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5297 times.
 15911 if (!fir->order && iir->order)
857 ✗ fir->shift = iir->shift;
858
859
1/2
✓ Branch 0 taken 15911 times.
✗ Branch 1 not taken.
 15911 if (s->param_presence_flags & PARAM_HUFFOFFSET)
860
2/2
✓ Branch 1 taken 3516 times.
✓ Branch 2 taken 12395 times.
 15911 if (get_bits1(gbp))
861 3516 cp->huff_offset = get_sbits(gbp, 15);
862
863 15911 cp->codebook = get_bits(gbp, 2);
864 15911 cp->huff_lsbs = get_bits(gbp, 5);
865
866
3/4
✓ Branch 0 taken 11899 times.
✓ Branch 1 taken 4012 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11899 times.
 15911 if (cp->codebook > 0 && cp->huff_lsbs > 24) {
867 ✗ av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
868 ✗ cp->huff_lsbs = 0;
869 ✗ return AVERROR_INVALIDDATA;
870 }
871
872 15911 return 0;
873 }
874
875 /** Read decoding parameters that change more often than those in the restart
876 * header. */
877
878 16036 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
879 unsigned int substr)
880 {
881 16036 SubStream *s = &m->substream[substr];
882 unsigned int ch;
883 16036 int ret = 0;
884 16036 unsigned recompute_sho = 0;
885
886
1/2
✓ Branch 0 taken 16036 times.
✗ Branch 1 not taken.
 16036 if (s->param_presence_flags & PARAM_PRESENCE)
887
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16036 times.
 16036 if (get_bits1(gbp))
888 ✗ s->param_presence_flags = get_bits(gbp, 8);
889
890
1/2
✓ Branch 0 taken 16036 times.
✗ Branch 1 not taken.
 16036 if (s->param_presence_flags & PARAM_BLOCKSIZE)
891
2/2
✓ Branch 1 taken 4422 times.
✓ Branch 2 taken 11614 times.
 16036 if (get_bits1(gbp)) {
892 4422 s->blocksize = get_bits(gbp, 9);
893
2/4
✓ Branch 0 taken 4422 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4422 times.
 4422 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
894 ✗ av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
895 ✗ s->blocksize = 0;
896 ✗ return AVERROR_INVALIDDATA;
897 }
898 }
899
900
1/2
✓ Branch 0 taken 16036 times.
✗ Branch 1 not taken.
 16036 if (s->param_presence_flags & PARAM_MATRIX)
901
2/2
✓ Branch 1 taken 1927 times.
✓ Branch 2 taken 14109 times.
 16036 if (get_bits1(gbp))
902
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1927 times.
 1927 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
903 ✗ return ret;
904
905
1/2
✓ Branch 0 taken 16036 times.
✗ Branch 1 not taken.
 16036 if (s->param_presence_flags & PARAM_OUTSHIFT)
906
2/2
✓ Branch 1 taken 1403 times.
✓ Branch 2 taken 14633 times.
 16036 if (get_bits1(gbp)) {
907
2/2
✓ Branch 0 taken 4558 times.
✓ Branch 1 taken 1403 times.
 5961 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
908 4558 s->output_shift[ch] = get_sbits(gbp, 4);
909
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4558 times.
 4558 if (s->output_shift[ch] < 0) {
910 ✗ avpriv_request_sample(m->avctx, "Negative output_shift");
911 ✗ s->output_shift[ch] = 0;
912 }
913 }
914
2/2
✓ Branch 0 taken 1371 times.
✓ Branch 1 taken 32 times.
 1403 if (substr == m->max_decoded_substream)
915 1371 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
916 1371 s->output_shift,
917 1371 s->max_matrix_channel,
918 1371 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
919 }
920
921
1/2
✓ Branch 0 taken 16036 times.
✗ Branch 1 not taken.
 16036 if (s->param_presence_flags & PARAM_QUANTSTEP)
922
2/2
✓ Branch 1 taken 2236 times.
✓ Branch 2 taken 13800 times.
 16036 if (get_bits1(gbp))
923
2/2
✓ Branch 0 taken 6192 times.
✓ Branch 1 taken 2236 times.
 8428 for (ch = 0; ch <= s->max_channel; ch++) {
924 6192 s->quant_step_size[ch] = get_bits(gbp, 4);
925
926 6192 recompute_sho |= 1<<ch;
927 }
928
929
2/2
✓ Branch 0 taken 38080 times.
✓ Branch 1 taken 16036 times.
 54116 for (ch = s->min_channel; ch <= s->max_channel; ch++)
930
2/2
✓ Branch 1 taken 15911 times.
✓ Branch 2 taken 22169 times.
 38080 if (get_bits1(gbp)) {
931 15911 recompute_sho |= 1<<ch;
932
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15911 times.
 15911 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
933 ✗ goto fail;
934 }
935
936
937 16036 fail:
938
2/2
✓ Branch 0 taken 44382 times.
✓ Branch 1 taken 16036 times.
 60418 for (ch = 0; ch <= s->max_channel; ch++) {
939
2/2
✓ Branch 0 taken 16834 times.
✓ Branch 1 taken 27548 times.
 44382 if (recompute_sho & (1<<ch)) {
940 16834 ChannelParams *cp = &s->channel_params[ch];
941
942
3/4
✓ Branch 0 taken 11899 times.
✓ Branch 1 taken 4935 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11899 times.
 16834 if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
943 ✗ if (ret >= 0) {
944 ✗ av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
945 ✗ ret = AVERROR_INVALIDDATA;
946 }
947 ✗ s->quant_step_size[ch] = 0;
948 }
949
950 16834 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
951 }
952 }
953 16036 return ret;
954 }
955
956 #define MSB_MASK(bits) (-(1 << (bits)))
957
958 /** Generate PCM samples using the prediction filters and residual values
959 * read from the data stream, and update the filter state. */
960
961 73644 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
962 unsigned int channel)
963 {
964 73644 SubStream *s = &m->substream[substr];
965 73644 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
966 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
967 73644 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
968 73644 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
969 73644 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
970 73644 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
971 73644 unsigned int filter_shift = fir->shift;
972 73644 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
973
974 73644 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
975 73644 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
976
977 73644 m->dsp.mlp_filter_channel(firbuf, fircoeff,
978 73644 fir->order, iir->order,
979 73644 filter_shift, mask, s->blocksize,
980 73644 &m->sample_buffer[s->blockpos][channel]);
981
982 73644 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
983 73644 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
984 73644 }
985
986 /** Read a block of PCM residual data (or actual if no filtering active). */
987
988 30249 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
989 unsigned int substr)
990 {
991 30249 SubStream *s = &m->substream[substr];
992 30249 unsigned int i, ch, expected_stream_pos = 0;
993 int ret;
994
995
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30249 times.
 30249 if (s->data_check_present) {
996 ✗ expected_stream_pos = get_bits_count(gbp);
997 ✗ expected_stream_pos += get_bits(gbp, 16);
998 ✗ avpriv_request_sample(m->avctx,
999 "Substreams with VLC block size check info");
1000 }
1001
1002
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30249 times.
 30249 if (s->blockpos + s->blocksize > m->access_unit_size) {
1003 ✗ av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
1004 ✗ return AVERROR_INVALIDDATA;
1005 }
1006
1007 30249 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
1008 30249 s->blocksize * sizeof(m->bypassed_lsbs[0]));
1009
1010
2/2
✓ Branch 0 taken 1121160 times.
✓ Branch 1 taken 30249 times.
 1151409 for (i = 0; i < s->blocksize; i++)
1011
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1121160 times.
 1121160 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
1012 ✗ return ret;
1013
1014
2/2
✓ Branch 0 taken 73644 times.
✓ Branch 1 taken 30249 times.
 103893 for (ch = s->min_channel; ch <= s->max_channel; ch++)
1015 73644 filter_channel(m, substr, ch);
1016
1017 30249 s->blockpos += s->blocksize;
1018
1019
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30249 times.
 30249 if (s->data_check_present) {
1020 ✗ if (get_bits_count(gbp) != expected_stream_pos)
1021 ✗ av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
1022 ✗ skip_bits(gbp, 8);
1023 }
1024
1025 30249 return 0;
1026 }
1027
1028 /** Data table used for TrueHD noise generation function. */
1029
1030 static const int8_t noise_table[256] = {
1031 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
1032 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
1033 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
1034 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
1035 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
1036 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
1037 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
1038 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
1039 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
1040 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
1041 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
1042 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
1043 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
1044 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
1045 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
1046 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
1047 };
1048
1049 /** Noise generation functions.
1050 * I'm not sure what these are for - they seem to be some kind of pseudorandom
1051 * sequence generators, used to generate noise data which is used when the
1052 * channels are rematrixed. I'm not sure if they provide a practical benefit
1053 * to compression, or just obfuscate the decoder. Are they for some kind of
1054 * dithering? */
1055
1056 /** Generate two channels of noise, used in the matrix when
1057 * restart sync word == 0x31ea. */
1058
1059 12380 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1060 {
1061 12380 SubStream *s = &m->substream[substr];
1062 unsigned int i;
1063 12380 uint32_t seed = s->noisegen_seed;
1064 12380 unsigned int maxchan = s->max_matrix_channel;
1065
1066
2/2
✓ Branch 0 taken 495200 times.
✓ Branch 1 taken 12380 times.
 507580 for (i = 0; i < s->blockpos; i++) {
1067 495200 uint16_t seed_shr7 = seed >> 7;
1068 495200 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1069 495200 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift);
1070
1071 495200 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1072 }
1073
1074 12380 s->noisegen_seed = seed;
1075 12380 }
1076
1077 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1078
1079 7759 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1080 {
1081 7759 SubStream *s = &m->substream[substr];
1082 unsigned int i;
1083 7759 uint32_t seed = s->noisegen_seed;
1084
1085
2/2
✓ Branch 0 taken 496576 times.
✓ Branch 1 taken 7759 times.
 504335 for (i = 0; i < m->access_unit_size_pow2; i++) {
1086 496576 uint8_t seed_shr15 = seed >> 15;
1087 496576 m->noise_buffer[i] = noise_table[seed_shr15];
1088 496576 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1089 }
1090
1091 7759 s->noisegen_seed = seed;
1092 7759 }
1093
1094 /** Write the audio data into the output buffer. */
1095
1096 20139 static int output_data(MLPDecodeContext *m, unsigned int substr,
1097 AVFrame *frame, int *got_frame_ptr)
1098 {
1099 20139 AVCodecContext *avctx = m->avctx;
1100 20139 SubStream *s = &m->substream[substr];
1101 unsigned int mat;
1102 unsigned int maxchan;
1103 int ret;
1104 20139 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1105
1106
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20139 times.
 20139 if (m->avctx->ch_layout.nb_channels != s->max_matrix_channel + 1) {
1107 ✗ av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1108 ✗ return AVERROR_INVALIDDATA;
1109 }
1110
1111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20139 times.
 20139 if (!s->blockpos) {
1112 ✗ av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1113 ✗ return AVERROR_INVALIDDATA;
1114 }
1115
1116 20139 maxchan = s->max_matrix_channel;
1117
2/2
✓ Branch 0 taken 12380 times.
✓ Branch 1 taken 7759 times.
 20139 if (!s->noise_type) {
1118 12380 generate_2_noise_channels(m, substr);
1119 12380 maxchan += 2;
1120 } else {
1121 7759 fill_noise_buffer(m, substr);
1122 }
1123
1124 /* Apply the channel matrices in turn to reconstruct the original audio
1125 * samples. */
1126
2/2
✓ Branch 0 taken 35059 times.
✓ Branch 1 taken 20139 times.
 55198 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1127 35059 unsigned int dest_ch = s->matrix_out_ch[mat];
1128 35059 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1129 35059 s->matrix_coeff[mat],
1130 35059 &m->bypassed_lsbs[0][mat],
1131 35059 m->noise_buffer,
1132 35059 s->num_primitive_matrices - mat,
1133 dest_ch,
1134 35059 s->blockpos,
1135 maxchan,
1136 35059 s->matrix_noise_shift[mat],
1137 m->access_unit_size_pow2,
1138 35059 MSB_MASK(s->quant_step_size[dest_ch]));
1139 }
1140
1141 /* get output buffer */
1142 20139 frame->nb_samples = s->blockpos;
1143
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20139 times.
 20139 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1144 ✗ return ret;
1145 40278 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1146 20139 s->blockpos,
1147 20139 m->sample_buffer,
1148 20139 frame->data[0],
1149 20139 s->ch_assign,
1150 20139 s->output_shift,
1151 20139 s->max_matrix_channel,
1152 is32);
1153
1154 /* Update matrix encoding side data */
1155
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20139 times.
 20139 if (s->matrix_encoding != s->prev_matrix_encoding) {
1156 ✗ if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1157 ✗ return ret;
1158
1159 ✗ s->prev_matrix_encoding = s->matrix_encoding;
1160 }
1161
1162 20139 *got_frame_ptr = 1;
1163
1164 20139 return 0;
1165 }
1166
1167 /** Read an access unit from the stream.
1168 * @return negative on error, 0 if not enough data is present in the input stream,
1169 * otherwise the number of bytes consumed. */
1170
1171 20139 static int read_access_unit(AVCodecContext *avctx, AVFrame *frame,
1172 int *got_frame_ptr, AVPacket *avpkt)
1173 {
1174 20139 const uint8_t *buf = avpkt->data;
1175 20139 int buf_size = avpkt->size;
1176 20139 MLPDecodeContext *m = avctx->priv_data;
1177 GetBitContext gb;
1178 unsigned int length, substr;
1179 unsigned int substream_start;
1180 20139 unsigned int header_size = 4;
1181 20139 unsigned int substr_header_size = 0;
1182 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1183 uint16_t substream_data_len[MAX_SUBSTREAMS];
1184 uint8_t parity_bits;
1185 int ret;
1186
1187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20139 times.
 20139 if (buf_size < 4)
1188 ✗ return AVERROR_INVALIDDATA;
1189
1190 20139 length = (AV_RB16(buf) & 0xfff) * 2;
1191
1192
2/4
✓ Branch 0 taken 20139 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 20139 times.
 20139 if (length < 4 || length > buf_size)
1193 ✗ return AVERROR_INVALIDDATA;
1194
1195 20139 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1196
1197 20139 m->is_major_sync_unit = 0;
1198
2/2
✓ Branch 1 taken 1774 times.
✓ Branch 2 taken 18365 times.
 20139 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1199
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1774 times.
 1774 if (read_major_sync(m, &gb) < 0)
1200 ✗ goto error;
1201 1774 m->is_major_sync_unit = 1;
1202 1774 header_size += m->major_sync_header_size;
1203 }
1204
1205
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20139 times.
 20139 if (!m->params_valid) {
1206 ✗ av_log(m->avctx, AV_LOG_WARNING,
1207 "Stream parameters not seen; skipping frame.\n");
1208 ✗ *got_frame_ptr = 0;
1209 ✗ return length;
1210 }
1211
1212 20139 substream_start = 0;
1213
1214
2/2
✓ Branch 0 taken 31571 times.
✓ Branch 1 taken 20139 times.
 51710 for (substr = 0; substr < m->num_substreams; substr++) {
1215 int extraword_present, checkdata_present, end, nonrestart_substr;
1216
1217 31571 extraword_present = get_bits1(&gb);
1218 31571 nonrestart_substr = get_bits1(&gb);
1219 31571 checkdata_present = get_bits1(&gb);
1220 31571 skip_bits1(&gb);
1221
1222 31571 end = get_bits(&gb, 12) * 2;
1223
1224 31571 substr_header_size += 2;
1225
1226
2/2
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 31395 times.
 31571 if (extraword_present) {
1227
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 176 times.
 176 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1228 ✗ av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1229 ✗ goto error;
1230 }
1231 176 skip_bits(&gb, 16);
1232 176 substr_header_size += 2;
1233 }
1234
1235
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31571 times.
 31571 if (length < header_size + substr_header_size) {
1236 ✗ av_log(m->avctx, AV_LOG_ERROR, "Insufficient data for headers\n");
1237 ✗ goto error;
1238 }
1239
1240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31571 times.
 31571 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1241 ✗ av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1242 ✗ goto error;
1243 }
1244
1245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31571 times.
 31571 if (end + header_size + substr_header_size > length) {
1246 ✗ av_log(m->avctx, AV_LOG_ERROR,
1247 "Indicated length of substream %d data goes off end of "
1248 "packet.\n", substr);
1249 ✗ end = length - header_size - substr_header_size;
1250 }
1251
1252
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31571 times.
 31571 if (end < substream_start) {
1253 ✗ av_log(avctx, AV_LOG_ERROR,
1254 "Indicated end offset of substream %d data "
1255 "is smaller than calculated start offset.\n",
1256 substr);
1257 ✗ goto error;
1258 }
1259
1260
2/2
✓ Branch 0 taken 3327 times.
✓ Branch 1 taken 28244 times.
 31571 if (substr > m->max_decoded_substream)
1261 3327 continue;
1262
1263 28244 substream_parity_present[substr] = checkdata_present;
1264 28244 substream_data_len[substr] = end - substream_start;
1265 28244 substream_start = end;
1266 }
1267
1268 20139 parity_bits = ff_mlp_calculate_parity(buf, 4);
1269 20139 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1270
1271
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20139 times.
 20139 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1272 ✗ av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1273 ✗ goto error;
1274 }
1275
1276 20139 buf += header_size + substr_header_size;
1277
1278
2/2
✓ Branch 0 taken 28029 times.
✓ Branch 1 taken 20139 times.
 48168 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1279 28029 SubStream *s = &m->substream[substr];
1280
1281 28029 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1282
1283 28029 m->matrix_changed = 0;
1284 28029 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1285
1286 28029 s->blockpos = 0;
1287 do {
1288
2/2
✓ Branch 1 taken 16036 times.
✓ Branch 2 taken 14213 times.
 30249 if (get_bits1(&gb)) {
1289
2/2
✓ Branch 1 taken 2220 times.
✓ Branch 2 taken 13816 times.
 16036 if (get_bits1(&gb)) {
1290 /* A restart header should be present. */
1291
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2220 times.
 2220 if (read_restart_header(m, &gb, buf, substr) < 0)
1292 ✗ goto next_substr;
1293 2220 s->restart_seen = 1;
1294 }
1295
1296
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16036 times.
 16036 if (!s->restart_seen)
1297 ✗ goto next_substr;
1298
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16036 times.
 16036 if (read_decoding_params(m, &gb, substr) < 0)
1299 ✗ goto next_substr;
1300 }
1301
1302
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30249 times.
 30249 if (!s->restart_seen)
1303 ✗ goto next_substr;
1304
1305
2/2
✓ Branch 0 taken 14504 times.
✓ Branch 1 taken 15745 times.
 30249 if (((avctx->ch_layout.nb_channels == 6 &&
1306
1/2
✓ Branch 0 taken 14504 times.
✗ Branch 1 not taken.
 14504 ((m->substream_info >> 2) & 0x3) != 0x3) ||
1307
2/2
✓ Branch 0 taken 405 times.
✓ Branch 1 taken 29844 times.
 30249 (avctx->ch_layout.nb_channels == 8 &&
1308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 405 times.
 405 ((m->substream_info >> 4) & 0x7) != 0x7 &&
1309 ✗ ((m->substream_info >> 4) & 0x7) != 0x6 &&
1310 ✗ ((m->substream_info >> 4) & 0x7) != 0x3)) &&
1311 ✗ substr > 0 && substr < m->max_decoded_substream &&
1312 ✗ (s->min_channel <= m->substream[substr - 1].max_channel)) {
1313 ✗ av_log(avctx, AV_LOG_DEBUG,
1314 "Previous substream(%d) channels overlaps current substream(%d) channels, skipping.\n",
1315 substr - 1, substr);
1316 ✗ goto next_substr;
1317 }
1318
1319
2/2
✓ Branch 0 taken 8336 times.
✓ Branch 1 taken 21913 times.
 30249 if (substr != m->max_decoded_substream &&
1320
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8336 times.
 8336 ((s->coded_channels & m->substream[m->max_decoded_substream].coded_channels) != 0)) {
1321 ✗ av_log(avctx, AV_LOG_DEBUG,
1322 "Current substream(%d) channels overlaps final substream(%d) channels, skipping.\n",
1323 ✗ substr, m->max_decoded_substream);
1324 ✗ goto next_substr;
1325 }
1326
1327
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30249 times.
 30249 if ((ret = read_block_data(m, &gb, substr)) < 0)
1328 ✗ return ret;
1329
1330
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30249 times.
 30249 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1331 ✗ goto substream_length_mismatch;
1332
1333
2/2
✓ Branch 1 taken 2220 times.
✓ Branch 2 taken 28029 times.
 30249 } while (!get_bits1(&gb));
1334
1335 28029 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1336
1337
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 28029 times.
 28029 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1338 int shorten_by;
1339
1340 ✗ if (get_bits(&gb, 16) != 0xD234)
1341 ✗ return AVERROR_INVALIDDATA;
1342
1343 ✗ shorten_by = get_bits(&gb, 16);
1344 ✗ if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1345 ✗ s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1346 ✗ else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1347 ✗ return AVERROR_INVALIDDATA;
1348
1349 ✗ av_log(m->avctx, AV_LOG_DEBUG, "End of stream indicated.\n");
1350 ✗ s->end_of_stream = 1;
1351 }
1352
1353
1/2
✓ Branch 0 taken 28029 times.
✗ Branch 1 not taken.
 28029 if (substream_parity_present[substr]) {
1354 uint8_t parity, checksum;
1355
1356
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 28029 times.
 28029 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1357 ✗ goto substream_length_mismatch;
1358
1359 28029 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1360 28029 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1361
1362
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 28029 times.
 28029 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1363 ✗ av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1364
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 28029 times.
 28029 if ( get_bits(&gb, 8) != checksum)
1365 ✗ av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1366 }
1367
1368
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 28029 times.
 28029 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1369 ✗ goto substream_length_mismatch;
1370
1371 28029 next_substr:
1372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28029 times.
 28029 if (!s->restart_seen)
1373 ✗ av_log(m->avctx, AV_LOG_ERROR,
1374 "No restart header present in substream %d.\n", substr);
1375
1376 28029 buf += substream_data_len[substr];
1377 }
1378
1379
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20139 times.
 20139 if ((ret = output_data(m, m->max_decoded_substream, frame, got_frame_ptr)) < 0)
1380 ✗ return ret;
1381
1382
2/2
✓ Branch 0 taken 28029 times.
✓ Branch 1 taken 20139 times.
 48168 for (substr = 0; substr <= m->max_decoded_substream; substr++){
1383 28029 SubStream *s = &m->substream[substr];
1384
1385
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28029 times.
 28029 if (s->end_of_stream) {
1386 ✗ s->lossless_check_data = 0xffffffff;
1387 ✗ s->end_of_stream = 0;
1388 ✗ m->params_valid = 0;
1389 }
1390 }
1391
1392 20139 return length;
1393
1394 ✗ substream_length_mismatch:
1395 ✗ av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1396 ✗ return AVERROR_INVALIDDATA;
1397
1398 ✗ error:
1399 ✗ m->params_valid = 0;
1400 ✗ return AVERROR_INVALIDDATA;
1401 }
1402
1403 ✗ static void mlp_decode_flush(AVCodecContext *avctx)
1404 {
1405 ✗ MLPDecodeContext *m = avctx->priv_data;
1406
1407 ✗ m->params_valid = 0;
1408 ✗ for (int substr = 0; substr <= m->max_decoded_substream; substr++){
1409 ✗ SubStream *s = &m->substream[substr];
1410
1411 ✗ s->lossless_check_data = 0xffffffff;
1412 ✗ s->prev_matrix_encoding = 0;
1413 }
1414 }
1415
1416 #define OFFSET(x) offsetof(MLPDecodeContext, x)
1417 #define FLAGS (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1418 static const AVOption options[] = {
1419 { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout),
1420 AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = FLAGS },
1421 { NULL },
1422 };
1423
1424 static const AVClass mlp_decoder_class = {
1425 .class_name = "MLP decoder",
1426 .item_name = av_default_item_name,
1427 .option = options,
1428 .version = LIBAVUTIL_VERSION_INT,
1429 };
1430
1431 static const AVClass truehd_decoder_class = {
1432 .class_name = "TrueHD decoder",
1433 .item_name = av_default_item_name,
1434 .option = options,
1435 .version = LIBAVUTIL_VERSION_INT,
1436 };
1437
1438 #if CONFIG_MLP_DECODER
1439 const FFCodec ff_mlp_decoder = {
1440 .p.name = "mlp",
1441 CODEC_LONG_NAME("MLP (Meridian Lossless Packing)"),
1442 .p.type = AVMEDIA_TYPE_AUDIO,
1443 .p.id = AV_CODEC_ID_MLP,
1444 .priv_data_size = sizeof(MLPDecodeContext),
1445 .p.priv_class = &mlp_decoder_class,
1446 .init = mlp_decode_init,
1447 FF_CODEC_DECODE_CB(read_access_unit),
1448 .flush = mlp_decode_flush,
1449 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1450 };
1451 #endif
1452 #if CONFIG_TRUEHD_DECODER
1453 const FFCodec ff_truehd_decoder = {
1454 .p.name = "truehd",
1455 CODEC_LONG_NAME("TrueHD"),
1456 .p.type = AVMEDIA_TYPE_AUDIO,
1457 .p.id = AV_CODEC_ID_TRUEHD,
1458 .priv_data_size = sizeof(MLPDecodeContext),
1459 .p.priv_class = &truehd_decoder_class,
1460 .init = mlp_decode_init,
1461 FF_CODEC_DECODE_CB(read_access_unit),
1462 .flush = mlp_decode_flush,
1463 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1464 .p.profiles = NULL_IF_CONFIG_SMALL(ff_truehd_profiles),
1465 };
1466 #endif /* CONFIG_TRUEHD_DECODER */
1467