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