Mercurial > libavcodec.hg
annotate mlpdec.c @ 10952:ea8f891d997d libavcodec
H264 DXVA2 implementation
It allows VLD H264 decoding using DXVA2 (GPU assisted decoding API under
VISTA and Windows 7).
It is implemented by using AVHWAccel API. It has been tested successfully
for some time in VLC using an nvidia card on Windows 7.
To compile it, you need to have the system header dxva2api.h (either from
microsoft or using http://downloads.videolan.org/pub/videolan/testing/contrib/dxva2api.h)
The generated libavcodec.dll does not depend directly on any new lib as
the necessary objects are given by the application using FFmpeg.
author | fenrir |
---|---|
date | Wed, 20 Jan 2010 18:54:51 +0000 |
parents | 1194d0b64bfe |
children | 9aae10c862f7 |
rev | line source |
---|---|
7194 | 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 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8693
diff
changeset
|
23 * @file libavcodec/mlpdec.c |
7194 | 24 * MLP decoder |
25 */ | |
26 | |
7199 | 27 #include <stdint.h> |
28 | |
7194 | 29 #include "avcodec.h" |
9585 | 30 #include "dsputil.h" |
7194 | 31 #include "libavutil/intreadwrite.h" |
9428 | 32 #include "get_bits.h" |
7194 | 33 #include "libavutil/crc.h" |
34 #include "parser.h" | |
35 #include "mlp_parser.h" | |
7559
fd24c8628221
mlp: Split common code from parser and decoder to be used by encoder.
ramiro
parents:
7556
diff
changeset
|
36 #include "mlp.h" |
7194 | 37 |
7198 | 38 /** number of bits used for VLC lookup - longest Huffman code is 9 */ |
7194 | 39 #define VLC_BITS 9 |
40 | |
41 | |
42 static const char* sample_message = | |
43 "Please file a bug report following the instructions at " | |
8460
5b3c90656fdf
Change mplayerhq.hu references to ffmpeg.org where appropriate.
diego
parents:
8277
diff
changeset
|
44 "http://ffmpeg.org/bugreports.html and include " |
7194 | 45 "a sample of this file."; |
46 | |
47 typedef struct SubStream { | |
7198 | 48 //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded. |
7194 | 49 uint8_t restart_seen; |
50 | |
51 //@{ | |
52 /** restart header data */ | |
53 //! The type of noise to be used in the rematrix stage. | |
54 uint16_t noise_type; | |
55 | |
56 //! The index of the first channel coded in this substream. | |
57 uint8_t min_channel; | |
58 //! The index of the last channel coded in this substream. | |
59 uint8_t max_channel; | |
60 //! The number of channels input into the rematrix stage. | |
61 uint8_t max_matrix_channel; | |
9203 | 62 //! For each channel output by the matrix, the output channel to map it to |
63 uint8_t ch_assign[MAX_CHANNELS]; | |
7194 | 64 |
65 //! The left shift applied to random noise in 0x31ea substreams. | |
66 uint8_t noise_shift; | |
67 //! The current seed value for the pseudorandom noise generator(s). | |
68 uint32_t noisegen_seed; | |
69 | |
70 //! Set if the substream contains extra info to check the size of VLC blocks. | |
71 uint8_t data_check_present; | |
72 | |
73 //! Bitmask of which parameter sets are conveyed in a decoding parameter block. | |
74 uint8_t param_presence_flags; | |
75 #define PARAM_BLOCKSIZE (1 << 7) | |
76 #define PARAM_MATRIX (1 << 6) | |
77 #define PARAM_OUTSHIFT (1 << 5) | |
78 #define PARAM_QUANTSTEP (1 << 4) | |
79 #define PARAM_FIR (1 << 3) | |
80 #define PARAM_IIR (1 << 2) | |
81 #define PARAM_HUFFOFFSET (1 << 1) | |
9202 | 82 #define PARAM_PRESENCE (1 << 0) |
7194 | 83 //@} |
84 | |
85 //@{ | |
86 /** matrix data */ | |
87 | |
88 //! Number of matrices to be applied. | |
89 uint8_t num_primitive_matrices; | |
90 | |
91 //! matrix output channel | |
92 uint8_t matrix_out_ch[MAX_MATRICES]; | |
93 | |
94 //! Whether the LSBs of the matrix output are encoded in the bitstream. | |
95 uint8_t lsb_bypass[MAX_MATRICES]; | |
96 //! Matrix coefficients, stored as 2.14 fixed point. | |
9533 | 97 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]; |
7194 | 98 //! Left shift to apply to noise values in 0x31eb substreams. |
99 uint8_t matrix_noise_shift[MAX_MATRICES]; | |
100 //@} | |
101 | |
7198 | 102 //! Left shift to apply to Huffman-decoded residuals. |
7194 | 103 uint8_t quant_step_size[MAX_CHANNELS]; |
104 | |
7198 | 105 //! number of PCM samples in current audio block |
7194 | 106 uint16_t blocksize; |
107 //! Number of PCM samples decoded so far in this frame. | |
108 uint16_t blockpos; | |
109 | |
110 //! Left shift to apply to decoded PCM values to get final 24-bit output. | |
111 int8_t output_shift[MAX_CHANNELS]; | |
112 | |
113 //! Running XOR of all output samples. | |
114 int32_t lossless_check_data; | |
115 | |
116 } SubStream; | |
117 | |
118 typedef struct MLPDecodeContext { | |
119 AVCodecContext *avctx; | |
120 | |
9348
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
121 //! Current access unit being read has a major sync. |
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
122 int is_major_sync_unit; |
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
123 |
7194 | 124 //! Set if a valid major sync block has been read. Otherwise no decoding is possible. |
125 uint8_t params_valid; | |
126 | |
127 //! Number of substreams contained within this stream. | |
128 uint8_t num_substreams; | |
129 | |
130 //! Index of the last substream to decode - further substreams are skipped. | |
131 uint8_t max_decoded_substream; | |
132 | |
7198 | 133 //! number of PCM samples contained in each frame |
7194 | 134 int access_unit_size; |
7198 | 135 //! next power of two above the number of samples in each frame |
7194 | 136 int access_unit_size_pow2; |
137 | |
138 SubStream substream[MAX_SUBSTREAMS]; | |
139 | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
140 ChannelParams channel_params[MAX_CHANNELS]; |
7194 | 141 |
9350
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
142 int matrix_changed; |
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
143 int filter_changed[MAX_CHANNELS][NUM_FILTERS]; |
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
144 |
7194 | 145 int8_t noise_buffer[MAX_BLOCKSIZE_POW2]; |
146 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]; | |
9533 | 147 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]; |
9585 | 148 |
149 DSPContext dsp; | |
7194 | 150 } MLPDecodeContext; |
151 | |
152 static VLC huff_vlc[3]; | |
153 | |
154 /** Initialize static data, constant between all invocations of the codec. */ | |
155 | |
8693
18737839ed27
Add missing void keyword to parameterless function declarations.
diego
parents:
8460
diff
changeset
|
156 static av_cold void init_static(void) |
7194 | 157 { |
10415
e16322231312
mlp: Only initialize VLC tables once. This caused a crash when multiple
ramiro
parents:
9647
diff
changeset
|
158 if (!huff_vlc[0].bits) { |
10416 | 159 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18, |
160 &ff_mlp_huffman_tables[0][0][1], 2, 1, | |
161 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512); | |
162 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16, | |
163 &ff_mlp_huffman_tables[1][0][1], 2, 1, | |
164 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512); | |
165 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15, | |
166 &ff_mlp_huffman_tables[2][0][1], 2, 1, | |
167 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512); | |
10415
e16322231312
mlp: Only initialize VLC tables once. This caused a crash when multiple
ramiro
parents:
9647
diff
changeset
|
168 } |
7194 | 169 |
7559
fd24c8628221
mlp: Split common code from parser and decoder to be used by encoder.
ramiro
parents:
7556
diff
changeset
|
170 ff_mlp_init_crc(); |
7194 | 171 } |
172 | |
173 static inline int32_t calculate_sign_huff(MLPDecodeContext *m, | |
174 unsigned int substr, unsigned int ch) | |
175 { | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
176 ChannelParams *cp = &m->channel_params[ch]; |
7194 | 177 SubStream *s = &m->substream[substr]; |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
178 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch]; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
179 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1); |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
180 int32_t sign_huff_offset = cp->huff_offset; |
7194 | 181 |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
182 if (cp->codebook > 0) |
7194 | 183 sign_huff_offset -= 7 << lsb_bits; |
184 | |
185 if (sign_shift >= 0) | |
186 sign_huff_offset -= 1 << sign_shift; | |
187 | |
188 return sign_huff_offset; | |
189 } | |
190 | |
191 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs | |
192 * and plain LSBs. */ | |
193 | |
194 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, | |
195 unsigned int substr, unsigned int pos) | |
196 { | |
197 SubStream *s = &m->substream[substr]; | |
198 unsigned int mat, channel; | |
199 | |
200 for (mat = 0; mat < s->num_primitive_matrices; mat++) | |
201 if (s->lsb_bypass[mat]) | |
202 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp); | |
203 | |
204 for (channel = s->min_channel; channel <= s->max_channel; channel++) { | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
205 ChannelParams *cp = &m->channel_params[channel]; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
206 int codebook = cp->codebook; |
7194 | 207 int quant_step_size = s->quant_step_size[channel]; |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
208 int lsb_bits = cp->huff_lsbs - quant_step_size; |
7194 | 209 int result = 0; |
210 | |
211 if (codebook > 0) | |
212 result = get_vlc2(gbp, huff_vlc[codebook-1].table, | |
213 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS); | |
214 | |
215 if (result < 0) | |
216 return -1; | |
217 | |
218 if (lsb_bits > 0) | |
219 result = (result << lsb_bits) + get_bits(gbp, lsb_bits); | |
220 | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
221 result += cp->sign_huff_offset; |
7194 | 222 result <<= quant_step_size; |
223 | |
224 m->sample_buffer[pos + s->blockpos][channel] = result; | |
225 } | |
226 | |
227 return 0; | |
228 } | |
229 | |
230 static av_cold int mlp_decode_init(AVCodecContext *avctx) | |
231 { | |
232 MLPDecodeContext *m = avctx->priv_data; | |
233 int substr; | |
234 | |
235 init_static(); | |
236 m->avctx = avctx; | |
237 for (substr = 0; substr < MAX_SUBSTREAMS; substr++) | |
238 m->substream[substr].lossless_check_data = 0xffffffff; | |
9585 | 239 dsputil_init(&m->dsp, avctx); |
8276
9149588e5cc9
mlp: support bit-depths greater than 16 by default.
ramiro
parents:
8274
diff
changeset
|
240 |
7194 | 241 return 0; |
242 } | |
243 | |
244 /** Read a major sync info header - contains high level information about | |
245 * the stream - sample rate, channel arrangement etc. Most of this | |
246 * information is not actually necessary for decoding, only for playback. | |
247 */ | |
248 | |
249 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb) | |
250 { | |
251 MLPHeaderInfo mh; | |
252 int substr; | |
253 | |
254 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0) | |
255 return -1; | |
256 | |
257 if (mh.group1_bits == 0) { | |
7198 | 258 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n"); |
7194 | 259 return -1; |
260 } | |
261 if (mh.group2_bits > mh.group1_bits) { | |
262 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 263 "Channel group 2 cannot have more bits per sample than group 1.\n"); |
7194 | 264 return -1; |
265 } | |
266 | |
267 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) { | |
268 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 269 "Channel groups with differing sample rates are not currently supported.\n"); |
7194 | 270 return -1; |
271 } | |
272 | |
273 if (mh.group1_samplerate == 0) { | |
7198 | 274 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n"); |
7194 | 275 return -1; |
276 } | |
277 if (mh.group1_samplerate > MAX_SAMPLERATE) { | |
278 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 279 "Sampling rate %d is greater than the supported maximum (%d).\n", |
7194 | 280 mh.group1_samplerate, MAX_SAMPLERATE); |
281 return -1; | |
282 } | |
283 if (mh.access_unit_size > MAX_BLOCKSIZE) { | |
284 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 285 "Block size %d is greater than the supported maximum (%d).\n", |
7194 | 286 mh.access_unit_size, MAX_BLOCKSIZE); |
287 return -1; | |
288 } | |
289 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) { | |
290 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 291 "Block size pow2 %d is greater than the supported maximum (%d).\n", |
7194 | 292 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2); |
293 return -1; | |
294 } | |
295 | |
296 if (mh.num_substreams == 0) | |
297 return -1; | |
9201 | 298 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) { |
299 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n"); | |
300 return -1; | |
301 } | |
7194 | 302 if (mh.num_substreams > MAX_SUBSTREAMS) { |
303 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 304 "Number of substreams %d is larger than the maximum supported " |
305 "by the decoder. %s\n", mh.num_substreams, sample_message); | |
7194 | 306 return -1; |
307 } | |
308 | |
309 m->access_unit_size = mh.access_unit_size; | |
310 m->access_unit_size_pow2 = mh.access_unit_size_pow2; | |
311 | |
312 m->num_substreams = mh.num_substreams; | |
313 m->max_decoded_substream = m->num_substreams - 1; | |
314 | |
315 m->avctx->sample_rate = mh.group1_samplerate; | |
316 m->avctx->frame_size = mh.access_unit_size; | |
317 | |
8274 | 318 m->avctx->bits_per_raw_sample = mh.group1_bits; |
8277 | 319 if (mh.group1_bits > 16) |
7194 | 320 m->avctx->sample_fmt = SAMPLE_FMT_S32; |
8276
9149588e5cc9
mlp: support bit-depths greater than 16 by default.
ramiro
parents:
8274
diff
changeset
|
321 else |
9149588e5cc9
mlp: support bit-depths greater than 16 by default.
ramiro
parents:
8274
diff
changeset
|
322 m->avctx->sample_fmt = SAMPLE_FMT_S16; |
7194 | 323 |
324 m->params_valid = 1; | |
325 for (substr = 0; substr < MAX_SUBSTREAMS; substr++) | |
326 m->substream[substr].restart_seen = 0; | |
327 | |
328 return 0; | |
329 } | |
330 | |
331 /** Read a restart header from a block in a substream. This contains parameters | |
332 * required to decode the audio that do not change very often. Generally | |
333 * (always) present only in blocks following a major sync. */ | |
334 | |
335 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, | |
336 const uint8_t *buf, unsigned int substr) | |
337 { | |
338 SubStream *s = &m->substream[substr]; | |
339 unsigned int ch; | |
340 int sync_word, tmp; | |
341 uint8_t checksum; | |
342 uint8_t lossless_check; | |
343 int start_count = get_bits_count(gbp); | |
9531
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
344 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
345 ? MAX_MATRIX_CHANNEL_MLP |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
346 : MAX_MATRIX_CHANNEL_TRUEHD; |
7194 | 347 |
348 sync_word = get_bits(gbp, 13); | |
9613
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
349 |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
350 if (sync_word != 0x31ea >> 1) { |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
351 av_log(m->avctx, AV_LOG_ERROR, |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
352 "restart header sync incorrect (got 0x%04x)\n", sync_word); |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
353 return -1; |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
354 } |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
355 |
9530
dbb16aa52d43
mlpdec: Restart header sync must be 0x31ea for MLP.
ramiro
parents:
9508
diff
changeset
|
356 s->noise_type = get_bits1(gbp); |
7194 | 357 |
9613
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
358 if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) { |
56f0a4054770
mlpdec: Split sync word error and MLP sync word check.
ramiro
parents:
9612
diff
changeset
|
359 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n"); |
7194 | 360 return -1; |
361 } | |
362 | |
363 skip_bits(gbp, 16); /* Output timestamp */ | |
364 | |
365 s->min_channel = get_bits(gbp, 4); | |
366 s->max_channel = get_bits(gbp, 4); | |
367 s->max_matrix_channel = get_bits(gbp, 4); | |
368 | |
9531
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
369 if (s->max_matrix_channel > max_matrix_channel) { |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
370 av_log(m->avctx, AV_LOG_ERROR, |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
371 "Max matrix channel cannot be greater than %d.\n", |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
372 max_matrix_channel); |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
373 return -1; |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
374 } |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
375 |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
376 if (s->max_channel != s->max_matrix_channel) { |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
377 av_log(m->avctx, AV_LOG_ERROR, |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
378 "Max channel must be equal max matrix channel.\n"); |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
379 return -1; |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
380 } |
19a70bcc2220
mlpdec: Validate max_channel and max_matrix_channel.
ramiro
parents:
9530
diff
changeset
|
381 |
9614
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
382 /* This should happen for TrueHD streams with >6 channels and MLP's noise |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
383 * type. It is not yet known if this is allowed. */ |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
384 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) { |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
385 av_log(m->avctx, AV_LOG_ERROR, |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
386 "Number of channels %d is larger than the maximum supported " |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
387 "by the decoder. %s\n", s->max_channel+2, sample_message); |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
388 return -1; |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
389 } |
2d9e7d5cd89b
mlpdec: Fix possible writing out of array bounds introduced by being
ramiro
parents:
9613
diff
changeset
|
390 |
7194 | 391 if (s->min_channel > s->max_channel) { |
392 av_log(m->avctx, AV_LOG_ERROR, | |
393 "Substream min channel cannot be greater than max channel.\n"); | |
394 return -1; | |
395 } | |
396 | |
397 if (m->avctx->request_channels > 0 | |
398 && s->max_channel + 1 >= m->avctx->request_channels | |
399 && substr < m->max_decoded_substream) { | |
400 av_log(m->avctx, AV_LOG_INFO, | |
401 "Extracting %d channel downmix from substream %d. " | |
402 "Further substreams will be skipped.\n", | |
403 s->max_channel + 1, substr); | |
404 m->max_decoded_substream = substr; | |
405 } | |
406 | |
407 s->noise_shift = get_bits(gbp, 4); | |
408 s->noisegen_seed = get_bits(gbp, 23); | |
409 | |
410 skip_bits(gbp, 19); | |
411 | |
412 s->data_check_present = get_bits1(gbp); | |
413 lossless_check = get_bits(gbp, 8); | |
414 if (substr == m->max_decoded_substream | |
415 && s->lossless_check_data != 0xffffffff) { | |
7566
d112b4655bbd
mlp: split simple inline function that xors 4 bytes into one.
ramiro
parents:
7559
diff
changeset
|
416 tmp = xor_32_to_8(s->lossless_check_data); |
7194 | 417 if (tmp != lossless_check) |
418 av_log(m->avctx, AV_LOG_WARNING, | |
7198 | 419 "Lossless check failed - expected %02x, calculated %02x.\n", |
7194 | 420 lossless_check, tmp); |
421 } | |
422 | |
423 skip_bits(gbp, 16); | |
424 | |
9203 | 425 memset(s->ch_assign, 0, sizeof(s->ch_assign)); |
426 | |
7194 | 427 for (ch = 0; ch <= s->max_matrix_channel; ch++) { |
428 int ch_assign = get_bits(gbp, 6); | |
9203 | 429 if (ch_assign > s->max_matrix_channel) { |
7194 | 430 av_log(m->avctx, AV_LOG_ERROR, |
9203 | 431 "Assignment of matrix channel %d to invalid output channel %d. %s\n", |
432 ch, ch_assign, sample_message); | |
7194 | 433 return -1; |
434 } | |
9203 | 435 s->ch_assign[ch_assign] = ch; |
7194 | 436 } |
437 | |
7559
fd24c8628221
mlp: Split common code from parser and decoder to be used by encoder.
ramiro
parents:
7556
diff
changeset
|
438 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count); |
7194 | 439 |
440 if (checksum != get_bits(gbp, 8)) | |
7198 | 441 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n"); |
7194 | 442 |
7198 | 443 /* Set default decoding parameters. */ |
7194 | 444 s->param_presence_flags = 0xff; |
445 s->num_primitive_matrices = 0; | |
446 s->blocksize = 8; | |
447 s->lossless_check_data = 0; | |
448 | |
449 memset(s->output_shift , 0, sizeof(s->output_shift )); | |
450 memset(s->quant_step_size, 0, sizeof(s->quant_step_size)); | |
451 | |
452 for (ch = s->min_channel; ch <= s->max_channel; ch++) { | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
453 ChannelParams *cp = &m->channel_params[ch]; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
454 cp->filter_params[FIR].order = 0; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
455 cp->filter_params[IIR].order = 0; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
456 cp->filter_params[FIR].shift = 0; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
457 cp->filter_params[IIR].shift = 0; |
7194 | 458 |
7198 | 459 /* Default audio coding is 24-bit raw PCM. */ |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
460 cp->huff_offset = 0; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
461 cp->sign_huff_offset = (-1) << 23; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
462 cp->codebook = 0; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
463 cp->huff_lsbs = 24; |
7194 | 464 } |
465 | |
9507 | 466 if (substr == m->max_decoded_substream) |
9203 | 467 m->avctx->channels = s->max_matrix_channel + 1; |
7194 | 468 |
469 return 0; | |
470 } | |
471 | |
472 /** Read parameters for one of the prediction filters. */ | |
473 | |
474 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, | |
475 unsigned int channel, unsigned int filter) | |
476 { | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
477 FilterParams *fp = &m->channel_params[channel].filter_params[filter]; |
9278
41e285948ffc
mlpdec: Max filter orders for FIR and IIR are 8 and 4 respectively.
ramiro
parents:
9268
diff
changeset
|
478 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER; |
7194 | 479 const char fchar = filter ? 'I' : 'F'; |
480 int i, order; | |
481 | |
7198 | 482 // Filter is 0 for FIR, 1 for IIR. |
7194 | 483 assert(filter < 2); |
484 | |
9503
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
485 if (m->filter_changed[channel][filter]++ > 1) { |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
486 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n"); |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
487 return -1; |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
488 } |
9350
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
489 |
7194 | 490 order = get_bits(gbp, 4); |
9278
41e285948ffc
mlpdec: Max filter orders for FIR and IIR are 8 and 4 respectively.
ramiro
parents:
9268
diff
changeset
|
491 if (order > max_order) { |
7194 | 492 av_log(m->avctx, AV_LOG_ERROR, |
7198 | 493 "%cIR filter order %d is greater than maximum %d.\n", |
9278
41e285948ffc
mlpdec: Max filter orders for FIR and IIR are 8 and 4 respectively.
ramiro
parents:
9268
diff
changeset
|
494 fchar, order, max_order); |
7194 | 495 return -1; |
496 } | |
7552
88ffd7c9c0ed
mlpdec: Split filter parameters from context into their own struct.
ramiro
parents:
7451
diff
changeset
|
497 fp->order = order; |
7194 | 498 |
499 if (order > 0) { | |
9647
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
500 int32_t *fcoeff = m->channel_params[channel].coeff[filter]; |
7194 | 501 int coeff_bits, coeff_shift; |
502 | |
7552
88ffd7c9c0ed
mlpdec: Split filter parameters from context into their own struct.
ramiro
parents:
7451
diff
changeset
|
503 fp->shift = get_bits(gbp, 4); |
7194 | 504 |
505 coeff_bits = get_bits(gbp, 5); | |
506 coeff_shift = get_bits(gbp, 3); | |
507 if (coeff_bits < 1 || coeff_bits > 16) { | |
508 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 509 "%cIR filter coeff_bits must be between 1 and 16.\n", |
7194 | 510 fchar); |
511 return -1; | |
512 } | |
513 if (coeff_bits + coeff_shift > 16) { | |
514 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 515 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n", |
7194 | 516 fchar); |
517 return -1; | |
518 } | |
519 | |
520 for (i = 0; i < order; i++) | |
9647
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
521 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift; |
7194 | 522 |
523 if (get_bits1(gbp)) { | |
524 int state_bits, state_shift; | |
525 | |
526 if (filter == FIR) { | |
527 av_log(m->avctx, AV_LOG_ERROR, | |
7198 | 528 "FIR filter has state data specified.\n"); |
7194 | 529 return -1; |
530 } | |
531 | |
532 state_bits = get_bits(gbp, 4); | |
533 state_shift = get_bits(gbp, 4); | |
534 | |
7198 | 535 /* TODO: Check validity of state data. */ |
7194 | 536 |
537 for (i = 0; i < order; i++) | |
7553 | 538 fp->state[i] = get_sbits(gbp, state_bits) << state_shift; |
7194 | 539 } |
540 } | |
541 | |
542 return 0; | |
543 } | |
544 | |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
545 /** Read parameters for primitive matrices. */ |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
546 |
9504
dc643c3c285e
mlpdec: Make read_matrix_params() take unsigned int substr for consistency.
ramiro
parents:
9503
diff
changeset
|
547 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp) |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
548 { |
9504
dc643c3c285e
mlpdec: Make read_matrix_params() take unsigned int substr for consistency.
ramiro
parents:
9503
diff
changeset
|
549 SubStream *s = &m->substream[substr]; |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
550 unsigned int mat, ch; |
9532 | 551 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP |
552 ? MAX_MATRICES_MLP | |
553 : MAX_MATRICES_TRUEHD; | |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
554 |
9503
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
555 if (m->matrix_changed++ > 1) { |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
556 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n"); |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
557 return -1; |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
558 } |
1997b5b2a40e
mlpdec: Check for {matrix,filter}_changed as soon as they are incremented.
ramiro
parents:
9428
diff
changeset
|
559 |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
560 s->num_primitive_matrices = get_bits(gbp, 4); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
561 |
9532 | 562 if (s->num_primitive_matrices > max_primitive_matrices) { |
563 av_log(m->avctx, AV_LOG_ERROR, | |
564 "Number of primitive matrices cannot be greater than %d.\n", | |
565 max_primitive_matrices); | |
566 return -1; | |
567 } | |
568 | |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
569 for (mat = 0; mat < s->num_primitive_matrices; mat++) { |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
570 int frac_bits, max_chan; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
571 s->matrix_out_ch[mat] = get_bits(gbp, 4); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
572 frac_bits = get_bits(gbp, 4); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
573 s->lsb_bypass [mat] = get_bits1(gbp); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
574 |
9347
b799c2a83624
mlpdec: matrix_out_ch must not be greater than max_matrix_channel, and not max_channel.
ramiro
parents:
9288
diff
changeset
|
575 if (s->matrix_out_ch[mat] > s->max_matrix_channel) { |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
576 av_log(m->avctx, AV_LOG_ERROR, |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
577 "Invalid channel %d specified as output from matrix.\n", |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
578 s->matrix_out_ch[mat]); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
579 return -1; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
580 } |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
581 if (frac_bits > 14) { |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
582 av_log(m->avctx, AV_LOG_ERROR, |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
583 "Too many fractional bits specified.\n"); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
584 return -1; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
585 } |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
586 |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
587 max_chan = s->max_matrix_channel; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
588 if (!s->noise_type) |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
589 max_chan+=2; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
590 |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
591 for (ch = 0; ch <= max_chan; ch++) { |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
592 int coeff_val = 0; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
593 if (get_bits1(gbp)) |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
594 coeff_val = get_sbits(gbp, frac_bits + 2); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
595 |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
596 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
597 } |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
598 |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
599 if (s->noise_type) |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
600 s->matrix_noise_shift[mat] = get_bits(gbp, 4); |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
601 else |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
602 s->matrix_noise_shift[mat] = 0; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
603 } |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
604 |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
605 return 0; |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
606 } |
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
607 |
9263
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
608 /** Read channel parameters. */ |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
609 |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
610 static int read_channel_params(MLPDecodeContext *m, unsigned int substr, |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
611 GetBitContext *gbp, unsigned int ch) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
612 { |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
613 ChannelParams *cp = &m->channel_params[ch]; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
614 FilterParams *fir = &cp->filter_params[FIR]; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
615 FilterParams *iir = &cp->filter_params[IIR]; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
616 SubStream *s = &m->substream[substr]; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
617 |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
618 if (s->param_presence_flags & PARAM_FIR) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
619 if (get_bits1(gbp)) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
620 if (read_filter_params(m, gbp, ch, FIR) < 0) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
621 return -1; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
622 |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
623 if (s->param_presence_flags & PARAM_IIR) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
624 if (get_bits1(gbp)) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
625 if (read_filter_params(m, gbp, ch, IIR) < 0) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
626 return -1; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
627 |
9283 | 628 if (fir->order + iir->order > 8) { |
629 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n"); | |
630 return -1; | |
631 } | |
632 | |
9263
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
633 if (fir->order && iir->order && |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
634 fir->shift != iir->shift) { |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
635 av_log(m->avctx, AV_LOG_ERROR, |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
636 "FIR and IIR filters must use the same precision.\n"); |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
637 return -1; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
638 } |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
639 /* The FIR and IIR filters must have the same precision. |
9612
de33a215fd84
mlpdec: Fix indentation that got mangled from copy&paste.
ramiro
parents:
9585
diff
changeset
|
640 * To simplify the filtering code, only the precision of the |
de33a215fd84
mlpdec: Fix indentation that got mangled from copy&paste.
ramiro
parents:
9585
diff
changeset
|
641 * FIR filter is considered. If only the IIR filter is employed, |
de33a215fd84
mlpdec: Fix indentation that got mangled from copy&paste.
ramiro
parents:
9585
diff
changeset
|
642 * the FIR filter precision is set to that of the IIR filter, so |
de33a215fd84
mlpdec: Fix indentation that got mangled from copy&paste.
ramiro
parents:
9585
diff
changeset
|
643 * that the filtering code can use it. */ |
9263
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
644 if (!fir->order && iir->order) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
645 fir->shift = iir->shift; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
646 |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
647 if (s->param_presence_flags & PARAM_HUFFOFFSET) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
648 if (get_bits1(gbp)) |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
649 cp->huff_offset = get_sbits(gbp, 15); |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
650 |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
651 cp->codebook = get_bits(gbp, 2); |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
652 cp->huff_lsbs = get_bits(gbp, 5); |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
653 |
9283 | 654 if (cp->huff_lsbs > 24) { |
655 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n"); | |
656 return -1; | |
657 } | |
9263
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
658 |
9283 | 659 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch); |
9263
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
660 |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
661 return 0; |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
662 } |
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
663 |
7194 | 664 /** Read decoding parameters that change more often than those in the restart |
665 * header. */ | |
666 | |
667 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, | |
668 unsigned int substr) | |
669 { | |
670 SubStream *s = &m->substream[substr]; | |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
671 unsigned int ch; |
7194 | 672 |
9202 | 673 if (s->param_presence_flags & PARAM_PRESENCE) |
9507 | 674 if (get_bits1(gbp)) |
675 s->param_presence_flags = get_bits(gbp, 8); | |
7194 | 676 |
677 if (s->param_presence_flags & PARAM_BLOCKSIZE) | |
678 if (get_bits1(gbp)) { | |
679 s->blocksize = get_bits(gbp, 9); | |
9267 | 680 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) { |
681 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize."); | |
7194 | 682 s->blocksize = 0; |
683 return -1; | |
684 } | |
685 } | |
686 | |
687 if (s->param_presence_flags & PARAM_MATRIX) | |
9507 | 688 if (get_bits1(gbp)) |
9504
dc643c3c285e
mlpdec: Make read_matrix_params() take unsigned int substr for consistency.
ramiro
parents:
9503
diff
changeset
|
689 if (read_matrix_params(m, substr, gbp) < 0) |
9262
3c9a424163ee
mlpdec: Split read_matrix_params() into its own function.
ramiro
parents:
9203
diff
changeset
|
690 return -1; |
7194 | 691 |
692 if (s->param_presence_flags & PARAM_OUTSHIFT) | |
693 if (get_bits1(gbp)) | |
9507 | 694 for (ch = 0; ch <= s->max_matrix_channel; ch++) |
9264 | 695 s->output_shift[ch] = get_sbits(gbp, 4); |
7194 | 696 |
697 if (s->param_presence_flags & PARAM_QUANTSTEP) | |
698 if (get_bits1(gbp)) | |
699 for (ch = 0; ch <= s->max_channel; ch++) { | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
700 ChannelParams *cp = &m->channel_params[ch]; |
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
701 |
7194 | 702 s->quant_step_size[ch] = get_bits(gbp, 4); |
703 | |
7555
8d00a2dfcb7a
mlpdec: Split channel parameters from context into their own struct.
ramiro
parents:
7553
diff
changeset
|
704 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch); |
7194 | 705 } |
706 | |
707 for (ch = s->min_channel; ch <= s->max_channel; ch++) | |
9507 | 708 if (get_bits1(gbp)) |
9263
62774b28cde0
mlpdec: Split read_channel_params() into its own function.
ramiro
parents:
9262
diff
changeset
|
709 if (read_channel_params(m, substr, gbp, ch) < 0) |
7194 | 710 return -1; |
711 | |
712 return 0; | |
713 } | |
714 | |
715 #define MSB_MASK(bits) (-1u << bits) | |
716 | |
717 /** Generate PCM samples using the prediction filters and residual values | |
718 * read from the data stream, and update the filter state. */ | |
719 | |
720 static void filter_channel(MLPDecodeContext *m, unsigned int substr, | |
721 unsigned int channel) | |
722 { | |
723 SubStream *s = &m->substream[substr]; | |
9647
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
724 const int32_t *fircoeff = m->channel_params[channel].coeff[FIR]; |
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
725 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER]; |
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
726 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE; |
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
727 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE; |
9280
e3eff8a463ec
mlpdec: Split filter_state_buffer into [fi]irbuf and fp to [fi]ir.
ramiro
parents:
9279
diff
changeset
|
728 FilterParams *fir = &m->channel_params[channel].filter_params[FIR]; |
e3eff8a463ec
mlpdec: Split filter_state_buffer into [fi]irbuf and fp to [fi]ir.
ramiro
parents:
9279
diff
changeset
|
729 FilterParams *iir = &m->channel_params[channel].filter_params[IIR]; |
e3eff8a463ec
mlpdec: Split filter_state_buffer into [fi]irbuf and fp to [fi]ir.
ramiro
parents:
9279
diff
changeset
|
730 unsigned int filter_shift = fir->shift; |
7194 | 731 int32_t mask = MSB_MASK(s->quant_step_size[channel]); |
732 | |
9567
d98ad4678fb0
mlpdec: Simplify filtering code by using only one counter variable.
ramiro
parents:
9533
diff
changeset
|
733 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t)); |
d98ad4678fb0
mlpdec: Simplify filtering code by using only one counter variable.
ramiro
parents:
9533
diff
changeset
|
734 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t)); |
7194 | 735 |
9647
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
736 m->dsp.mlp_filter_channel(firbuf, fircoeff, |
d0fe5dc427f0
mlp: Simplify adressing of state and coeffs arrays for both filters by making
ramiro
parents:
9614
diff
changeset
|
737 fir->order, iir->order, |
9585 | 738 filter_shift, mask, s->blocksize, |
739 &m->sample_buffer[s->blockpos][channel]); | |
7194 | 740 |
9585 | 741 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t)); |
742 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t)); | |
7194 | 743 } |
744 | |
745 /** Read a block of PCM residual data (or actual if no filtering active). */ | |
746 | |
747 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp, | |
748 unsigned int substr) | |
749 { | |
750 SubStream *s = &m->substream[substr]; | |
751 unsigned int i, ch, expected_stream_pos = 0; | |
752 | |
753 if (s->data_check_present) { | |
754 expected_stream_pos = get_bits_count(gbp); | |
755 expected_stream_pos += get_bits(gbp, 16); | |
756 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features " | |
757 "we have not tested yet. %s\n", sample_message); | |
758 } | |
759 | |
760 if (s->blockpos + s->blocksize > m->access_unit_size) { | |
7198 | 761 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n"); |
7194 | 762 return -1; |
763 } | |
764 | |
765 memset(&m->bypassed_lsbs[s->blockpos][0], 0, | |
766 s->blocksize * sizeof(m->bypassed_lsbs[0])); | |
767 | |
9507 | 768 for (i = 0; i < s->blocksize; i++) |
7194 | 769 if (read_huff_channels(m, gbp, substr, i) < 0) |
770 return -1; | |
771 | |
9507 | 772 for (ch = s->min_channel; ch <= s->max_channel; ch++) |
7194 | 773 filter_channel(m, substr, ch); |
774 | |
775 s->blockpos += s->blocksize; | |
776 | |
777 if (s->data_check_present) { | |
778 if (get_bits_count(gbp) != expected_stream_pos) | |
7198 | 779 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n"); |
7194 | 780 skip_bits(gbp, 8); |
781 } | |
782 | |
783 return 0; | |
784 } | |
785 | |
7198 | 786 /** Data table used for TrueHD noise generation function. */ |
7194 | 787 |
788 static const int8_t noise_table[256] = { | |
789 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2, | |
790 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62, | |
791 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5, | |
792 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40, | |
793 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34, | |
794 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30, | |
795 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36, | |
796 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69, | |
797 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24, | |
798 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20, | |
799 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23, | |
800 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8, | |
801 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40, | |
802 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37, | |
803 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52, | |
804 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70, | |
805 }; | |
806 | |
807 /** Noise generation functions. | |
808 * I'm not sure what these are for - they seem to be some kind of pseudorandom | |
809 * sequence generators, used to generate noise data which is used when the | |
810 * channels are rematrixed. I'm not sure if they provide a practical benefit | |
811 * to compression, or just obfuscate the decoder. Are they for some kind of | |
812 * dithering? */ | |
813 | |
814 /** Generate two channels of noise, used in the matrix when | |
815 * restart sync word == 0x31ea. */ | |
816 | |
817 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr) | |
818 { | |
819 SubStream *s = &m->substream[substr]; | |
820 unsigned int i; | |
821 uint32_t seed = s->noisegen_seed; | |
822 unsigned int maxchan = s->max_matrix_channel; | |
823 | |
824 for (i = 0; i < s->blockpos; i++) { | |
825 uint16_t seed_shr7 = seed >> 7; | |
826 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift; | |
827 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift; | |
828 | |
829 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5); | |
830 } | |
831 | |
832 s->noisegen_seed = seed; | |
833 } | |
834 | |
835 /** Generate a block of noise, used when restart sync word == 0x31eb. */ | |
836 | |
837 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr) | |
838 { | |
839 SubStream *s = &m->substream[substr]; | |
840 unsigned int i; | |
841 uint32_t seed = s->noisegen_seed; | |
842 | |
843 for (i = 0; i < m->access_unit_size_pow2; i++) { | |
844 uint8_t seed_shr15 = seed >> 15; | |
845 m->noise_buffer[i] = noise_table[seed_shr15]; | |
846 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5); | |
847 } | |
848 | |
849 s->noisegen_seed = seed; | |
850 } | |
851 | |
852 | |
853 /** Apply the channel matrices in turn to reconstruct the original audio | |
854 * samples. */ | |
855 | |
856 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr) | |
857 { | |
858 SubStream *s = &m->substream[substr]; | |
859 unsigned int mat, src_ch, i; | |
860 unsigned int maxchan; | |
861 | |
862 maxchan = s->max_matrix_channel; | |
863 if (!s->noise_type) { | |
864 generate_2_noise_channels(m, substr); | |
865 maxchan += 2; | |
866 } else { | |
867 fill_noise_buffer(m, substr); | |
868 } | |
869 | |
870 for (mat = 0; mat < s->num_primitive_matrices; mat++) { | |
871 int matrix_noise_shift = s->matrix_noise_shift[mat]; | |
872 unsigned int dest_ch = s->matrix_out_ch[mat]; | |
873 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]); | |
9506
50feb15cbf2a
mlpdec: Use some context arrays with local variables in rematrix_channels().
ramiro
parents:
9505
diff
changeset
|
874 int32_t *coeffs = s->matrix_coeff[mat]; |
9505
bcef741a555a
truehd: Simplify rematrix_channels() as per Michael's original review.
ramiro
parents:
9504
diff
changeset
|
875 int index = s->num_primitive_matrices - mat; |
bcef741a555a
truehd: Simplify rematrix_channels() as per Michael's original review.
ramiro
parents:
9504
diff
changeset
|
876 int index2 = 2 * index + 1; |
7194 | 877 |
878 /* TODO: DSPContext? */ | |
879 | |
880 for (i = 0; i < s->blockpos; i++) { | |
9508
41ab6db265d0
mlpdec: Read context variable to local variable to make code cleaner.
ramiro
parents:
9507
diff
changeset
|
881 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat]; |
9506
50feb15cbf2a
mlpdec: Use some context arrays with local variables in rematrix_channels().
ramiro
parents:
9505
diff
changeset
|
882 int32_t *samples = m->sample_buffer[i]; |
7194 | 883 int64_t accum = 0; |
9507 | 884 |
885 for (src_ch = 0; src_ch <= maxchan; src_ch++) | |
886 accum += (int64_t) samples[src_ch] * coeffs[src_ch]; | |
887 | |
7194 | 888 if (matrix_noise_shift) { |
9505
bcef741a555a
truehd: Simplify rematrix_channels() as per Michael's original review.
ramiro
parents:
9504
diff
changeset
|
889 index &= m->access_unit_size_pow2 - 1; |
7194 | 890 accum += m->noise_buffer[index] << (matrix_noise_shift + 7); |
9505
bcef741a555a
truehd: Simplify rematrix_channels() as per Michael's original review.
ramiro
parents:
9504
diff
changeset
|
891 index += index2; |
7194 | 892 } |
9507 | 893 |
9508
41ab6db265d0
mlpdec: Read context variable to local variable to make code cleaner.
ramiro
parents:
9507
diff
changeset
|
894 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb; |
7194 | 895 } |
896 } | |
897 } | |
898 | |
899 /** Write the audio data into the output buffer. */ | |
900 | |
901 static int output_data_internal(MLPDecodeContext *m, unsigned int substr, | |
902 uint8_t *data, unsigned int *data_size, int is32) | |
903 { | |
904 SubStream *s = &m->substream[substr]; | |
9203 | 905 unsigned int i, out_ch = 0; |
7194 | 906 int32_t *data_32 = (int32_t*) data; |
907 int16_t *data_16 = (int16_t*) data; | |
908 | |
909 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2)) | |
910 return -1; | |
911 | |
912 for (i = 0; i < s->blockpos; i++) { | |
9203 | 913 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) { |
914 int mat_ch = s->ch_assign[out_ch]; | |
915 int32_t sample = m->sample_buffer[i][mat_ch] | |
916 << s->output_shift[mat_ch]; | |
917 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch; | |
7194 | 918 if (is32) *data_32++ = sample << 8; |
919 else *data_16++ = sample >> 8; | |
920 } | |
921 } | |
922 | |
9203 | 923 *data_size = i * out_ch * (is32 ? 4 : 2); |
7194 | 924 |
925 return 0; | |
926 } | |
927 | |
928 static int output_data(MLPDecodeContext *m, unsigned int substr, | |
929 uint8_t *data, unsigned int *data_size) | |
930 { | |
931 if (m->avctx->sample_fmt == SAMPLE_FMT_S32) | |
932 return output_data_internal(m, substr, data, data_size, 1); | |
933 else | |
934 return output_data_internal(m, substr, data, data_size, 0); | |
935 } | |
936 | |
937 | |
938 /** Read an access unit from the stream. | |
939 * Returns < 0 on error, 0 if not enough data is present in the input stream | |
940 * otherwise returns the number of bytes consumed. */ | |
941 | |
942 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9350
diff
changeset
|
943 AVPacket *avpkt) |
7194 | 944 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9350
diff
changeset
|
945 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9350
diff
changeset
|
946 int buf_size = avpkt->size; |
7194 | 947 MLPDecodeContext *m = avctx->priv_data; |
948 GetBitContext gb; | |
949 unsigned int length, substr; | |
950 unsigned int substream_start; | |
951 unsigned int header_size = 4; | |
952 unsigned int substr_header_size = 0; | |
953 uint8_t substream_parity_present[MAX_SUBSTREAMS]; | |
954 uint16_t substream_data_len[MAX_SUBSTREAMS]; | |
955 uint8_t parity_bits; | |
956 | |
957 if (buf_size < 4) | |
958 return 0; | |
959 | |
960 length = (AV_RB16(buf) & 0xfff) * 2; | |
961 | |
962 if (length > buf_size) | |
963 return -1; | |
964 | |
965 init_get_bits(&gb, (buf + 4), (length - 4) * 8); | |
966 | |
9348
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
967 m->is_major_sync_unit = 0; |
7194 | 968 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) { |
969 if (read_major_sync(m, &gb) < 0) | |
970 goto error; | |
9348
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
971 m->is_major_sync_unit = 1; |
7194 | 972 header_size += 28; |
973 } | |
974 | |
975 if (!m->params_valid) { | |
976 av_log(m->avctx, AV_LOG_WARNING, | |
7198 | 977 "Stream parameters not seen; skipping frame.\n"); |
7194 | 978 *data_size = 0; |
979 return length; | |
980 } | |
981 | |
982 substream_start = 0; | |
983 | |
984 for (substr = 0; substr < m->num_substreams; substr++) { | |
9348
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
985 int extraword_present, checkdata_present, end, nonrestart_substr; |
7194 | 986 |
987 extraword_present = get_bits1(&gb); | |
9348
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
988 nonrestart_substr = get_bits1(&gb); |
7194 | 989 checkdata_present = get_bits1(&gb); |
990 skip_bits1(&gb); | |
991 | |
992 end = get_bits(&gb, 12) * 2; | |
993 | |
994 substr_header_size += 2; | |
995 | |
996 if (extraword_present) { | |
9349 | 997 if (m->avctx->codec_id == CODEC_ID_MLP) { |
998 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n"); | |
999 goto error; | |
1000 } | |
7194 | 1001 skip_bits(&gb, 16); |
1002 substr_header_size += 2; | |
1003 } | |
1004 | |
9348
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
1005 if (!(nonrestart_substr ^ m->is_major_sync_unit)) { |
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
1006 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n"); |
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
1007 goto error; |
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
1008 } |
586dca8c04e7
mlpdec: Validate non-restart bit from the substream header.
ramiro
parents:
9347
diff
changeset
|
1009 |
7194 | 1010 if (end + header_size + substr_header_size > length) { |
1011 av_log(m->avctx, AV_LOG_ERROR, | |
1012 "Indicated length of substream %d data goes off end of " | |
1013 "packet.\n", substr); | |
1014 end = length - header_size - substr_header_size; | |
1015 } | |
1016 | |
1017 if (end < substream_start) { | |
1018 av_log(avctx, AV_LOG_ERROR, | |
1019 "Indicated end offset of substream %d data " | |
1020 "is smaller than calculated start offset.\n", | |
1021 substr); | |
1022 goto error; | |
1023 } | |
1024 | |
1025 if (substr > m->max_decoded_substream) | |
1026 continue; | |
1027 | |
1028 substream_parity_present[substr] = checkdata_present; | |
1029 substream_data_len[substr] = end - substream_start; | |
1030 substream_start = end; | |
1031 } | |
1032 | |
7559
fd24c8628221
mlp: Split common code from parser and decoder to be used by encoder.
ramiro
parents:
7556
diff
changeset
|
1033 parity_bits = ff_mlp_calculate_parity(buf, 4); |
fd24c8628221
mlp: Split common code from parser and decoder to be used by encoder.
ramiro
parents:
7556
diff
changeset
|
1034 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size); |
7194 | 1035 |
1036 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) { | |
1037 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n"); | |
1038 goto error; | |
1039 } | |
1040 | |
1041 buf += header_size + substr_header_size; | |
1042 | |
1043 for (substr = 0; substr <= m->max_decoded_substream; substr++) { | |
1044 SubStream *s = &m->substream[substr]; | |
1045 init_get_bits(&gb, buf, substream_data_len[substr] * 8); | |
1046 | |
9350
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
1047 m->matrix_changed = 0; |
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
1048 memset(m->filter_changed, 0, sizeof(m->filter_changed)); |
1432fb0ee5d7
mlpdec: Filters and matrices may change only once per substream per access unit.
ramiro
parents:
9349
diff
changeset
|
1049 |
7194 | 1050 s->blockpos = 0; |
1051 do { | |
1052 if (get_bits1(&gb)) { | |
1053 if (get_bits1(&gb)) { | |
7198 | 1054 /* A restart header should be present. */ |
7194 | 1055 if (read_restart_header(m, &gb, buf, substr) < 0) |
1056 goto next_substr; | |
1057 s->restart_seen = 1; | |
1058 } | |
1059 | |
9507 | 1060 if (!s->restart_seen) |
7194 | 1061 goto next_substr; |
1062 if (read_decoding_params(m, &gb, substr) < 0) | |
1063 goto next_substr; | |
1064 } | |
1065 | |
9507 | 1066 if (!s->restart_seen) |
7194 | 1067 goto next_substr; |
1068 | |
1069 if (read_block_data(m, &gb, substr) < 0) | |
1070 return -1; | |
1071 | |
9286 | 1072 if (get_bits_count(&gb) >= substream_data_len[substr] * 8) |
1073 goto substream_length_mismatch; | |
1074 | |
1075 } while (!get_bits1(&gb)); | |
7194 | 1076 |
1077 skip_bits(&gb, (-get_bits_count(&gb)) & 15); | |
9507 | 1078 |
9284 | 1079 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) { |
1080 int shorten_by; | |
1081 | |
1082 if (get_bits(&gb, 16) != 0xD234) | |
1083 return -1; | |
1084 | |
1085 shorten_by = get_bits(&gb, 16); | |
1086 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000) | |
1087 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos); | |
1088 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234) | |
1089 return -1; | |
1090 | |
7194 | 1091 if (substr == m->max_decoded_substream) |
7198 | 1092 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n"); |
7194 | 1093 } |
9507 | 1094 |
9288
37313693196a
mlpdec: Simplify check for substream_parity_present.
ramiro
parents:
9287
diff
changeset
|
1095 if (substream_parity_present[substr]) { |
7194 | 1096 uint8_t parity, checksum; |
1097 | |
9288
37313693196a
mlpdec: Simplify check for substream_parity_present.
ramiro
parents:
9287
diff
changeset
|
1098 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16) |
37313693196a
mlpdec: Simplify check for substream_parity_present.
ramiro
parents:
9287
diff
changeset
|
1099 goto substream_length_mismatch; |
37313693196a
mlpdec: Simplify check for substream_parity_present.
ramiro
parents:
9287
diff
changeset
|
1100 |
9285 | 1101 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2); |
1102 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2); | |
7194 | 1103 |
9285 | 1104 if ((get_bits(&gb, 8) ^ parity) != 0xa9 ) |
1105 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr); | |
1106 if ( get_bits(&gb, 8) != checksum) | |
1107 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr); | |
7194 | 1108 } |
9507 | 1109 |
1110 if (substream_data_len[substr] * 8 != get_bits_count(&gb)) | |
9286 | 1111 goto substream_length_mismatch; |
7194 | 1112 |
1113 next_substr: | |
9507 | 1114 if (!s->restart_seen) |
9287 | 1115 av_log(m->avctx, AV_LOG_ERROR, |
1116 "No restart header present in substream %d.\n", substr); | |
1117 | |
7194 | 1118 buf += substream_data_len[substr]; |
1119 } | |
1120 | |
1121 rematrix_channels(m, m->max_decoded_substream); | |
1122 | |
1123 if (output_data(m, m->max_decoded_substream, data, data_size) < 0) | |
1124 return -1; | |
1125 | |
1126 return length; | |
1127 | |
9286 | 1128 substream_length_mismatch: |
1129 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr); | |
1130 return -1; | |
1131 | |
7194 | 1132 error: |
1133 m->params_valid = 0; | |
1134 return -1; | |
1135 } | |
1136 | |
1137 AVCodec mlp_decoder = { | |
1138 "mlp", | |
1139 CODEC_TYPE_AUDIO, | |
1140 CODEC_ID_MLP, | |
1141 sizeof(MLPDecodeContext), | |
1142 mlp_decode_init, | |
1143 NULL, | |
1144 NULL, | |
1145 read_access_unit, | |
9190 | 1146 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"), |
7194 | 1147 }; |
1148 | |
9190 | 1149 #if CONFIG_TRUEHD_DECODER |
1150 AVCodec truehd_decoder = { | |
1151 "truehd", | |
1152 CODEC_TYPE_AUDIO, | |
1153 CODEC_ID_TRUEHD, | |
1154 sizeof(MLPDecodeContext), | |
1155 mlp_decode_init, | |
1156 NULL, | |
1157 NULL, | |
1158 read_access_unit, | |
1159 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"), | |
1160 }; | |
1161 #endif /* CONFIG_TRUEHD_DECODER */ |