vaapi_encode_mpeg2: Fix width/height columns/rows confusion
[ffmpeg.git] / libavcodec / dca_exss.c
1 /*
2  * Copyright (C) 2016 foo86
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "dcadec.h"
22
23 static void parse_xll_parameters(DCAExssParser *s, DCAExssAsset *asset)
24 {
25     // Size of XLL data in extension substream
26     asset->xll_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
27
28     // XLL sync word present flag
29     if (asset->xll_sync_present = get_bits1(&s->gb)) {
30         int xll_delay_nbits;
31
32         // Peak bit rate smoothing buffer size
33         skip_bits(&s->gb, 4);
34
35         // Number of bits for XLL decoding delay
36         xll_delay_nbits = get_bits(&s->gb, 5) + 1;
37
38         // Initial XLL decoding delay in frames
39         asset->xll_delay_nframes = get_bits_long(&s->gb, xll_delay_nbits);
40
41         // Number of bytes offset to XLL sync
42         asset->xll_sync_offset = get_bits(&s->gb, s->exss_size_nbits);
43     } else {
44         asset->xll_delay_nframes = 0;
45         asset->xll_sync_offset = 0;
46     }
47 }
48
49 static void parse_lbr_parameters(DCAExssParser *s, DCAExssAsset *asset)
50 {
51     // Size of LBR component in extension substream
52     asset->lbr_size = get_bits(&s->gb, 14) + 1;
53
54     // LBR sync word present flag
55     if (get_bits1(&s->gb))
56         // LBR sync distance
57         skip_bits(&s->gb, 2);
58 }
59
60 static int parse_descriptor(DCAExssParser *s, DCAExssAsset *asset)
61 {
62     int i, j, drc_present, descr_size, descr_pos = get_bits_count(&s->gb);
63
64     // Size of audio asset descriptor in bytes
65     descr_size = get_bits(&s->gb, 9) + 1;
66
67     // Audio asset identifier
68     asset->asset_index = get_bits(&s->gb, 3);
69
70     //
71     // Per stream static metadata
72     //
73
74     if (s->static_fields_present) {
75         // Asset type descriptor presence
76         if (get_bits1(&s->gb))
77             // Asset type descriptor
78             skip_bits(&s->gb, 4);
79
80         // Language descriptor presence
81         if (get_bits1(&s->gb))
82             // Language descriptor
83             skip_bits(&s->gb, 24);
84
85         // Additional textual information presence
86         if (get_bits1(&s->gb)) {
87             // Byte size of additional text info
88             int text_size = get_bits(&s->gb, 10) + 1;
89
90             // Sanity check available size
91             if (get_bits_left(&s->gb) < text_size * 8)
92                 return AVERROR_INVALIDDATA;
93
94             // Additional textual information string
95             skip_bits_long(&s->gb, text_size * 8);
96         }
97
98         // PCM bit resolution
99         asset->pcm_bit_res = get_bits(&s->gb, 5) + 1;
100
101         // Maximum sample rate
102         asset->max_sample_rate = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];
103
104         // Total number of channels
105         asset->nchannels_total = get_bits(&s->gb, 8) + 1;
106
107         // One to one map channel to speakers
108         if (asset->one_to_one_map_ch_to_spkr = get_bits1(&s->gb)) {
109             int spkr_mask_nbits = 0;
110             int spkr_remap_nsets;
111             int nspeakers[8];
112
113             // Embedded stereo flag
114             asset->embedded_stereo = asset->nchannels_total > 2 && get_bits1(&s->gb);
115
116             // Embedded 6 channels flag
117             asset->embedded_6ch = asset->nchannels_total > 6 && get_bits1(&s->gb);
118
119             // Speaker mask enabled flag
120             if (asset->spkr_mask_enabled = get_bits1(&s->gb)) {
121                 // Number of bits for speaker activity mask
122                 spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;
123
124                 // Loudspeaker activity mask
125                 asset->spkr_mask = get_bits(&s->gb, spkr_mask_nbits);
126             }
127
128             // Number of speaker remapping sets
129             if ((spkr_remap_nsets = get_bits(&s->gb, 3)) && !spkr_mask_nbits) {
130                 if (s->avctx)
131                     av_log(s->avctx, AV_LOG_ERROR, "Speaker mask disabled yet there are remapping sets\n");
132                 return AVERROR_INVALIDDATA;
133             }
134
135             // Standard loudspeaker layout mask
136             for (i = 0; i < spkr_remap_nsets; i++)
137                 nspeakers[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
138
139             for (i = 0; i < spkr_remap_nsets; i++) {
140                 // Number of channels to be decoded for speaker remapping
141                 int nch_for_remaps = get_bits(&s->gb, 5) + 1;
142
143                 for (j = 0; j < nspeakers[i]; j++) {
144                     // Decoded channels to output speaker mapping mask
145                     int remap_ch_mask = get_bits_long(&s->gb, nch_for_remaps);
146
147                     // Loudspeaker remapping codes
148                     skip_bits_long(&s->gb, av_popcount(remap_ch_mask) * 5);
149                 }
150             }
151         } else {
152             asset->embedded_stereo = 0;
153             asset->embedded_6ch = 0;
154             asset->spkr_mask_enabled = 0;
155             asset->spkr_mask = 0;
156
157             // Representation type
158             asset->representation_type = get_bits(&s->gb, 3);
159         }
160     }
161
162     //
163     // DRC, DNC and mixing metadata
164     //
165
166     // Dynamic range coefficient presence flag
167     drc_present = get_bits1(&s->gb);
168
169     // Code for dynamic range coefficient
170     if (drc_present)
171         skip_bits(&s->gb, 8);
172
173     // Dialog normalization presence flag
174     if (get_bits1(&s->gb))
175         // Dialog normalization code
176         skip_bits(&s->gb, 5);
177
178     // DRC for stereo downmix
179     if (drc_present && asset->embedded_stereo)
180         skip_bits(&s->gb, 8);
181
182     // Mixing metadata presence flag
183     if (s->mix_metadata_enabled && get_bits1(&s->gb)) {
184         int nchannels_dmix;
185
186         // External mixing flag
187         skip_bits1(&s->gb);
188
189         // Post mixing / replacement gain adjustment
190         skip_bits(&s->gb, 6);
191
192         // DRC prior to mixing
193         if (get_bits(&s->gb, 2) == 3)
194             // Custom code for mixing DRC
195             skip_bits(&s->gb, 8);
196         else
197             // Limit for mixing DRC
198             skip_bits(&s->gb, 3);
199
200         // Scaling type for channels of main audio
201         // Scaling parameters of main audio
202         if (get_bits1(&s->gb))
203             for (i = 0; i < s->nmixoutconfigs; i++)
204                 skip_bits_long(&s->gb, 6 * s->nmixoutchs[i]);
205         else
206             skip_bits_long(&s->gb, 6 * s->nmixoutconfigs);
207
208         nchannels_dmix = asset->nchannels_total;
209         if (asset->embedded_6ch)
210             nchannels_dmix += 6;
211         if (asset->embedded_stereo)
212             nchannels_dmix += 2;
213
214         for (i = 0; i < s->nmixoutconfigs; i++) {
215             if (!s->nmixoutchs[i]) {
216                 if (s->avctx)
217                     av_log(s->avctx, AV_LOG_ERROR, "Invalid speaker layout mask for mixing configuration\n");
218                 return AVERROR_INVALIDDATA;
219             }
220             for (j = 0; j < nchannels_dmix; j++) {
221                 // Mix output mask
222                 int mix_map_mask = get_bits(&s->gb, s->nmixoutchs[i]);
223
224                 // Mixing coefficients
225                 skip_bits_long(&s->gb, av_popcount(mix_map_mask) * 6);
226             }
227         }
228     }
229
230     //
231     // Decoder navigation data
232     //
233
234     // Coding mode for the asset
235     asset->coding_mode = get_bits(&s->gb, 2);
236
237     // Coding components used in asset
238     switch (asset->coding_mode) {
239     case 0: // Coding mode that may contain multiple coding components
240         asset->extension_mask = get_bits(&s->gb, 12);
241
242         if (asset->extension_mask & DCA_EXSS_CORE) {
243             // Size of core component in extension substream
244             asset->core_size = get_bits(&s->gb, 14) + 1;
245             // Core sync word present flag
246             if (get_bits1(&s->gb))
247                 // Core sync distance
248                 skip_bits(&s->gb, 2);
249         }
250
251         if (asset->extension_mask & DCA_EXSS_XBR)
252             // Size of XBR extension in extension substream
253             asset->xbr_size = get_bits(&s->gb, 14) + 1;
254
255         if (asset->extension_mask & DCA_EXSS_XXCH)
256             // Size of XXCH extension in extension substream
257             asset->xxch_size = get_bits(&s->gb, 14) + 1;
258
259         if (asset->extension_mask & DCA_EXSS_X96)
260             // Size of X96 extension in extension substream
261             asset->x96_size = get_bits(&s->gb, 12) + 1;
262
263         if (asset->extension_mask & DCA_EXSS_LBR)
264             parse_lbr_parameters(s, asset);
265
266         if (asset->extension_mask & DCA_EXSS_XLL)
267             parse_xll_parameters(s, asset);
268
269         if (asset->extension_mask & DCA_EXSS_RSV1)
270             skip_bits(&s->gb, 16);
271
272         if (asset->extension_mask & DCA_EXSS_RSV2)
273             skip_bits(&s->gb, 16);
274         break;
275
276     case 1: // Loss-less coding mode without CBR component
277         asset->extension_mask = DCA_EXSS_XLL;
278         parse_xll_parameters(s, asset);
279         break;
280
281     case 2: // Low bit rate mode
282         asset->extension_mask = DCA_EXSS_LBR;
283         parse_lbr_parameters(s, asset);
284         break;
285
286     case 3: // Auxiliary coding mode
287         asset->extension_mask = 0;
288
289         // Size of auxiliary coded data
290         skip_bits(&s->gb, 14);
291
292         // Auxiliary codec identification
293         skip_bits(&s->gb, 8);
294
295         // Aux sync word present flag
296         if (get_bits1(&s->gb))
297             // Aux sync distance
298             skip_bits(&s->gb, 3);
299         break;
300     }
301
302     if (asset->extension_mask & DCA_EXSS_XLL)
303         // DTS-HD stream ID
304         asset->hd_stream_id = get_bits(&s->gb, 3);
305
306     // One to one mixing flag
307     // Per channel main audio scaling flag
308     // Main audio scaling codes
309     // Decode asset in secondary decoder flag
310     // Revision 2 DRC metadata
311     // Reserved
312     // Zero pad
313     if (ff_dca_seek_bits(&s->gb, descr_pos + descr_size * 8)) {
314         if (s->avctx)
315             av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS asset descriptor\n");
316         return AVERROR_INVALIDDATA;
317     }
318
319     return 0;
320 }
321
322 static int set_exss_offsets(DCAExssAsset *asset)
323 {
324     int offs = asset->asset_offset;
325     int size = asset->asset_size;
326
327     if (asset->extension_mask & DCA_EXSS_CORE) {
328         asset->core_offset = offs;
329         if (asset->core_size > size)
330             return AVERROR_INVALIDDATA;
331         offs += asset->core_size;
332         size -= asset->core_size;
333     }
334
335     if (asset->extension_mask & DCA_EXSS_XBR) {
336         asset->xbr_offset = offs;
337         if (asset->xbr_size > size)
338             return AVERROR_INVALIDDATA;
339         offs += asset->xbr_size;
340         size -= asset->xbr_size;
341     }
342
343     if (asset->extension_mask & DCA_EXSS_XXCH) {
344         asset->xxch_offset = offs;
345         if (asset->xxch_size > size)
346             return AVERROR_INVALIDDATA;
347         offs += asset->xxch_size;
348         size -= asset->xxch_size;
349     }
350
351     if (asset->extension_mask & DCA_EXSS_X96) {
352         asset->x96_offset = offs;
353         if (asset->x96_size > size)
354             return AVERROR_INVALIDDATA;
355         offs += asset->x96_size;
356         size -= asset->x96_size;
357     }
358
359     if (asset->extension_mask & DCA_EXSS_LBR) {
360         asset->lbr_offset = offs;
361         if (asset->lbr_size > size)
362             return AVERROR_INVALIDDATA;
363         offs += asset->lbr_size;
364         size -= asset->lbr_size;
365     }
366
367     if (asset->extension_mask & DCA_EXSS_XLL) {
368         asset->xll_offset = offs;
369         if (asset->xll_size > size)
370             return AVERROR_INVALIDDATA;
371         offs += asset->xll_size;
372         size -= asset->xll_size;
373     }
374
375     return 0;
376 }
377
378 int ff_dca_exss_parse(DCAExssParser *s, const uint8_t *data, int size)
379 {
380     int i, ret, offset, wide_hdr, header_size;
381
382     if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
383         return ret;
384
385     // Extension substream sync word
386     skip_bits_long(&s->gb, 32);
387
388     // User defined bits
389     skip_bits(&s->gb, 8);
390
391     // Extension substream index
392     s->exss_index = get_bits(&s->gb, 2);
393
394     // Flag indicating short or long header size
395     wide_hdr = get_bits1(&s->gb);
396
397     // Extension substream header length
398     header_size = get_bits(&s->gb, 8 + 4 * wide_hdr) + 1;
399
400     // Check CRC
401     if (s->avctx && ff_dca_check_crc(s->avctx, &s->gb, 32 + 8, header_size * 8)) {
402         av_log(s->avctx, AV_LOG_ERROR, "Invalid EXSS header checksum\n");
403         return AVERROR_INVALIDDATA;
404     }
405
406     s->exss_size_nbits = 16 + 4 * wide_hdr;
407
408     // Number of bytes of extension substream
409     s->exss_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
410     if (s->exss_size > size) {
411         if (s->avctx)
412             av_log(s->avctx, AV_LOG_ERROR, "Packet too short for EXSS frame\n");
413         return AVERROR_INVALIDDATA;
414     }
415
416     // Per stream static fields presence flag
417     if (s->static_fields_present = get_bits1(&s->gb)) {
418         int active_exss_mask[8];
419
420         // Reference clock code
421         skip_bits(&s->gb, 2);
422
423         // Extension substream frame duration
424         skip_bits(&s->gb, 3);
425
426         // Timecode presence flag
427         if (get_bits1(&s->gb))
428             // Timecode data
429             skip_bits_long(&s->gb, 36);
430
431         // Number of defined audio presentations
432         s->npresents = get_bits(&s->gb, 3) + 1;
433         if (s->npresents > 1) {
434             if (s->avctx)
435                 avpriv_request_sample(s->avctx, "%d audio presentations", s->npresents);
436             return AVERROR_PATCHWELCOME;
437         }
438
439         // Number of audio assets in extension substream
440         s->nassets = get_bits(&s->gb, 3) + 1;
441         if (s->nassets > 1) {
442             if (s->avctx)
443                 avpriv_request_sample(s->avctx, "%d audio assets", s->nassets);
444             return AVERROR_PATCHWELCOME;
445         }
446
447         // Active extension substream mask for audio presentation
448         for (i = 0; i < s->npresents; i++)
449             active_exss_mask[i] = get_bits(&s->gb, s->exss_index + 1);
450
451         // Active audio asset mask
452         for (i = 0; i < s->npresents; i++)
453             skip_bits_long(&s->gb, av_popcount(active_exss_mask[i]) * 8);
454
455         // Mixing metadata enable flag
456         if (s->mix_metadata_enabled = get_bits1(&s->gb)) {
457             int spkr_mask_nbits;
458
459             // Mixing metadata adjustment level
460             skip_bits(&s->gb, 2);
461
462             // Number of bits for mixer output speaker activity mask
463             spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;
464
465             // Number of mixing configurations
466             s->nmixoutconfigs = get_bits(&s->gb, 2) + 1;
467
468             // Speaker layout mask for mixer output channels
469             for (i = 0; i < s->nmixoutconfigs; i++)
470                 s->nmixoutchs[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
471         }
472     } else {
473         s->npresents = 1;
474         s->nassets = 1;
475     }
476
477     // Size of encoded asset data in bytes
478     offset = header_size;
479     for (i = 0; i < s->nassets; i++) {
480         s->assets[i].asset_offset = offset;
481         s->assets[i].asset_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
482         offset += s->assets[i].asset_size;
483         if (offset > s->exss_size) {
484             if (s->avctx)
485                 av_log(s->avctx, AV_LOG_ERROR, "EXSS asset out of bounds\n");
486             return AVERROR_INVALIDDATA;
487         }
488     }
489
490     // Audio asset descriptor
491     for (i = 0; i < s->nassets; i++) {
492         if ((ret = parse_descriptor(s, &s->assets[i])) < 0)
493             return ret;
494         if ((ret = set_exss_offsets(&s->assets[i])) < 0) {
495             if (s->avctx)
496                 av_log(s->avctx, AV_LOG_ERROR, "Invalid extension size in EXSS asset descriptor\n");
497             return ret;
498         }
499     }
500
501     // Backward compatible core present
502     // Backward compatible core substream index
503     // Backward compatible core asset index
504     // Reserved
505     // Byte align
506     // CRC16 of extension substream header
507     if (ff_dca_seek_bits(&s->gb, header_size * 8)) {
508         if (s->avctx)
509             av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS header\n");
510         return AVERROR_INVALIDDATA;
511     }
512
513     return 0;
514 }