FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mlpdec.c
Date: 2024-06-18 05:56:57
Exec Total Coverage
Lines: 481 679 70.8%
Functions: 18 19 94.7%
Branches: 290 459 63.2%

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