FFmpeg coverage


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