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