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