FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/dca_exss.c	Lines:	125	234	53.4 %
Date:	2020-07-13 04:22:34	Branches:	79	171	46.2 %


/*
 * Copyright (C) 2016 foo86
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "dcadec.h"

static void parse_xll_parameters(DCAExssParser *s, DCAExssAsset *asset)
{
    // Size of XLL data in extension substream
    asset->xll_size = get_bits(&s->gb, s->exss_size_nbits) + 1;

    // XLL sync word present flag
    if (asset->xll_sync_present = get_bits1(&s->gb)) {
        int xll_delay_nbits;

        // Peak bit rate smoothing buffer size
        skip_bits(&s->gb, 4);

        // Number of bits for XLL decoding delay
        xll_delay_nbits = get_bits(&s->gb, 5) + 1;

        // Initial XLL decoding delay in frames
        asset->xll_delay_nframes = get_bits_long(&s->gb, xll_delay_nbits);

        // Number of bytes offset to XLL sync
        asset->xll_sync_offset = get_bits(&s->gb, s->exss_size_nbits);
    } else {
        asset->xll_delay_nframes = 0;
        asset->xll_sync_offset = 0;
    }
}

static void parse_lbr_parameters(DCAExssParser *s, DCAExssAsset *asset)
{
    // Size of LBR component in extension substream
    asset->lbr_size = get_bits(&s->gb, 14) + 1;

    // LBR sync word present flag
    if (get_bits1(&s->gb))
        // LBR sync distance
        skip_bits(&s->gb, 2);
}

static int parse_descriptor(DCAExssParser *s, DCAExssAsset *asset)
{
    int i, j, drc_present, descr_size, descr_pos = get_bits_count(&s->gb);

    // Size of audio asset descriptor in bytes
    descr_size = get_bits(&s->gb, 9) + 1;

    // Audio asset identifier
    asset->asset_index = get_bits(&s->gb, 3);

    //
    // Per stream static metadata
    //

    if (s->static_fields_present) {
        // Asset type descriptor presence
        if (get_bits1(&s->gb))
            // Asset type descriptor
            skip_bits(&s->gb, 4);

        // Language descriptor presence
        if (get_bits1(&s->gb))
            // Language descriptor
            skip_bits(&s->gb, 24);

        // Additional textual information presence
        if (get_bits1(&s->gb)) {
            // Byte size of additional text info
            int text_size = get_bits(&s->gb, 10) + 1;

            // Sanity check available size
            if (get_bits_left(&s->gb) < text_size * 8)
                return AVERROR_INVALIDDATA;

            // Additional textual information string
            skip_bits_long(&s->gb, text_size * 8);
        }

        // PCM bit resolution
        asset->pcm_bit_res = get_bits(&s->gb, 5) + 1;

        // Maximum sample rate
        asset->max_sample_rate = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];

        // Total number of channels
        asset->nchannels_total = get_bits(&s->gb, 8) + 1;

        // One to one map channel to speakers
        if (asset->one_to_one_map_ch_to_spkr = get_bits1(&s->gb)) {
            int spkr_mask_nbits = 0;
            int spkr_remap_nsets;
            int nspeakers[8];

            // Embedded stereo flag
            asset->embedded_stereo = asset->nchannels_total > 2 && get_bits1(&s->gb);

            // Embedded 6 channels flag
            asset->embedded_6ch = asset->nchannels_total > 6 && get_bits1(&s->gb);

            // Speaker mask enabled flag
            if (asset->spkr_mask_enabled = get_bits1(&s->gb)) {
                // Number of bits for speaker activity mask
                spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;

                // Loudspeaker activity mask
                asset->spkr_mask = get_bits(&s->gb, spkr_mask_nbits);
            }

            // Number of speaker remapping sets
            if ((spkr_remap_nsets = get_bits(&s->gb, 3)) && !spkr_mask_nbits) {
                if (s->avctx)
                    av_log(s->avctx, AV_LOG_ERROR, "Speaker mask disabled yet there are remapping sets\n");
                return AVERROR_INVALIDDATA;
            }

            // Standard loudspeaker layout mask
            for (i = 0; i < spkr_remap_nsets; i++)
                nspeakers[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));

            for (i = 0; i < spkr_remap_nsets; i++) {
                // Number of channels to be decoded for speaker remapping
                int nch_for_remaps = get_bits(&s->gb, 5) + 1;

                for (j = 0; j < nspeakers[i]; j++) {
                    // Decoded channels to output speaker mapping mask
                    int remap_ch_mask = get_bits_long(&s->gb, nch_for_remaps);

                    // Loudspeaker remapping codes
                    skip_bits_long(&s->gb, av_popcount(remap_ch_mask) * 5);
                }
            }
        } else {
            asset->embedded_stereo = 0;
            asset->embedded_6ch = 0;
            asset->spkr_mask_enabled = 0;
            asset->spkr_mask = 0;

            // Representation type
            asset->representation_type = get_bits(&s->gb, 3);
        }
    }

    //
    // DRC, DNC and mixing metadata
    //

    // Dynamic range coefficient presence flag
    drc_present = get_bits1(&s->gb);

    // Code for dynamic range coefficient
    if (drc_present)
        skip_bits(&s->gb, 8);

    // Dialog normalization presence flag
    if (get_bits1(&s->gb))
        // Dialog normalization code
        skip_bits(&s->gb, 5);

    // DRC for stereo downmix
    if (drc_present && asset->embedded_stereo)
        skip_bits(&s->gb, 8);

    // Mixing metadata presence flag
    if (s->mix_metadata_enabled && get_bits1(&s->gb)) {
        int nchannels_dmix;

        // External mixing flag
        skip_bits1(&s->gb);

        // Post mixing / replacement gain adjustment
        skip_bits(&s->gb, 6);

        // DRC prior to mixing
        if (get_bits(&s->gb, 2) == 3)
            // Custom code for mixing DRC
            skip_bits(&s->gb, 8);
        else
            // Limit for mixing DRC
            skip_bits(&s->gb, 3);

        // Scaling type for channels of main audio
        // Scaling parameters of main audio
        if (get_bits1(&s->gb))
            for (i = 0; i < s->nmixoutconfigs; i++)
                skip_bits_long(&s->gb, 6 * s->nmixoutchs[i]);
        else
            skip_bits_long(&s->gb, 6 * s->nmixoutconfigs);

        nchannels_dmix = asset->nchannels_total;
        if (asset->embedded_6ch)
            nchannels_dmix += 6;
        if (asset->embedded_stereo)
            nchannels_dmix += 2;

        for (i = 0; i < s->nmixoutconfigs; i++) {
            if (!s->nmixoutchs[i]) {
                if (s->avctx)
                    av_log(s->avctx, AV_LOG_ERROR, "Invalid speaker layout mask for mixing configuration\n");
                return AVERROR_INVALIDDATA;
            }
            for (j = 0; j < nchannels_dmix; j++) {
                // Mix output mask
                int mix_map_mask = get_bits(&s->gb, s->nmixoutchs[i]);

                // Mixing coefficients
                skip_bits_long(&s->gb, av_popcount(mix_map_mask) * 6);
            }
        }
    }

    //
    // Decoder navigation data
    //

    // Coding mode for the asset
    asset->coding_mode = get_bits(&s->gb, 2);

    // Coding components used in asset
    switch (asset->coding_mode) {
    case 0: // Coding mode that may contain multiple coding components
        asset->extension_mask = get_bits(&s->gb, 12);

        if (asset->extension_mask & DCA_EXSS_CORE) {
            // Size of core component in extension substream
            asset->core_size = get_bits(&s->gb, 14) + 1;
            // Core sync word present flag
            if (get_bits1(&s->gb))
                // Core sync distance
                skip_bits(&s->gb, 2);
        }

        if (asset->extension_mask & DCA_EXSS_XBR)
            // Size of XBR extension in extension substream
            asset->xbr_size = get_bits(&s->gb, 14) + 1;

        if (asset->extension_mask & DCA_EXSS_XXCH)
            // Size of XXCH extension in extension substream
            asset->xxch_size = get_bits(&s->gb, 14) + 1;

        if (asset->extension_mask & DCA_EXSS_X96)
            // Size of X96 extension in extension substream
            asset->x96_size = get_bits(&s->gb, 12) + 1;

        if (asset->extension_mask & DCA_EXSS_LBR)
            parse_lbr_parameters(s, asset);

        if (asset->extension_mask & DCA_EXSS_XLL)
            parse_xll_parameters(s, asset);

        if (asset->extension_mask & DCA_EXSS_RSV1)
            skip_bits(&s->gb, 16);

        if (asset->extension_mask & DCA_EXSS_RSV2)
            skip_bits(&s->gb, 16);
        break;

    case 1: // Loss-less coding mode without CBR component
        asset->extension_mask = DCA_EXSS_XLL;
        parse_xll_parameters(s, asset);
        break;

    case 2: // Low bit rate mode
        asset->extension_mask = DCA_EXSS_LBR;
        parse_lbr_parameters(s, asset);
        break;

    case 3: // Auxiliary coding mode
        asset->extension_mask = 0;

        // Size of auxiliary coded data
        skip_bits(&s->gb, 14);

        // Auxiliary codec identification
        skip_bits(&s->gb, 8);

        // Aux sync word present flag
        if (get_bits1(&s->gb))
            // Aux sync distance
            skip_bits(&s->gb, 3);
        break;
    }

    if (asset->extension_mask & DCA_EXSS_XLL)
        // DTS-HD stream ID
        asset->hd_stream_id = get_bits(&s->gb, 3);

    // One to one mixing flag
    // Per channel main audio scaling flag
    // Main audio scaling codes
    // Decode asset in secondary decoder flag
    // Revision 2 DRC metadata
    // Reserved
    // Zero pad
    if (ff_dca_seek_bits(&s->gb, descr_pos + descr_size * 8)) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS asset descriptor\n");
        return AVERROR_INVALIDDATA;
    }

    return 0;
}

static int set_exss_offsets(DCAExssAsset *asset)
{
    int offs = asset->asset_offset;
    int size = asset->asset_size;

    if (asset->extension_mask & DCA_EXSS_CORE) {
        asset->core_offset = offs;
        if (asset->core_size > size)
            return AVERROR_INVALIDDATA;
        offs += asset->core_size;
        size -= asset->core_size;
    }

    if (asset->extension_mask & DCA_EXSS_XBR) {
        asset->xbr_offset = offs;
        if (asset->xbr_size > size)
            return AVERROR_INVALIDDATA;
        offs += asset->xbr_size;
        size -= asset->xbr_size;
    }

    if (asset->extension_mask & DCA_EXSS_XXCH) {
        asset->xxch_offset = offs;
        if (asset->xxch_size > size)
            return AVERROR_INVALIDDATA;
        offs += asset->xxch_size;
        size -= asset->xxch_size;
    }

    if (asset->extension_mask & DCA_EXSS_X96) {
        asset->x96_offset = offs;
        if (asset->x96_size > size)
            return AVERROR_INVALIDDATA;
        offs += asset->x96_size;
        size -= asset->x96_size;
    }

    if (asset->extension_mask & DCA_EXSS_LBR) {
        asset->lbr_offset = offs;
        if (asset->lbr_size > size)
            return AVERROR_INVALIDDATA;
        offs += asset->lbr_size;
        size -= asset->lbr_size;
    }

    if (asset->extension_mask & DCA_EXSS_XLL) {
        asset->xll_offset = offs;
        if (asset->xll_size > size)
            return AVERROR_INVALIDDATA;
        offs += asset->xll_size;
        size -= asset->xll_size;
    }

    return 0;
}

int ff_dca_exss_parse(DCAExssParser *s, const uint8_t *data, int size)
{
    int i, ret, offset, wide_hdr, header_size;

    if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
        return ret;

    // Extension substream sync word
    skip_bits_long(&s->gb, 32);

    // User defined bits
    skip_bits(&s->gb, 8);

    // Extension substream index
    s->exss_index = get_bits(&s->gb, 2);

    // Flag indicating short or long header size
    wide_hdr = get_bits1(&s->gb);

    // Extension substream header length
    header_size = get_bits(&s->gb, 8 + 4 * wide_hdr) + 1;

    // Check CRC
    if (s->avctx && ff_dca_check_crc(s->avctx, &s->gb, 32 + 8, header_size * 8)) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid EXSS header checksum\n");
        return AVERROR_INVALIDDATA;
    }

    s->exss_size_nbits = 16 + 4 * wide_hdr;

    // Number of bytes of extension substream
    s->exss_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
    if (s->exss_size > size) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Packet too short for EXSS frame\n");
        return AVERROR_INVALIDDATA;
    }

    // Per stream static fields presence flag
    if (s->static_fields_present = get_bits1(&s->gb)) {
        int active_exss_mask[8];

        // Reference clock code
        skip_bits(&s->gb, 2);

        // Extension substream frame duration
        skip_bits(&s->gb, 3);

        // Timecode presence flag
        if (get_bits1(&s->gb))
            // Timecode data
            skip_bits_long(&s->gb, 36);

        // Number of defined audio presentations
        s->npresents = get_bits(&s->gb, 3) + 1;
        if (s->npresents > 1) {
            if (s->avctx)
                avpriv_request_sample(s->avctx, "%d audio presentations", s->npresents);
            return AVERROR_PATCHWELCOME;
        }

        // Number of audio assets in extension substream
        s->nassets = get_bits(&s->gb, 3) + 1;
        if (s->nassets > 1) {
            if (s->avctx)
                avpriv_request_sample(s->avctx, "%d audio assets", s->nassets);
            return AVERROR_PATCHWELCOME;
        }

        // Active extension substream mask for audio presentation
        for (i = 0; i < s->npresents; i++)
            active_exss_mask[i] = get_bits(&s->gb, s->exss_index + 1);

        // Active audio asset mask
        for (i = 0; i < s->npresents; i++)
            skip_bits_long(&s->gb, av_popcount(active_exss_mask[i]) * 8);

        // Mixing metadata enable flag
        if (s->mix_metadata_enabled = get_bits1(&s->gb)) {
            int spkr_mask_nbits;

            // Mixing metadata adjustment level
            skip_bits(&s->gb, 2);

            // Number of bits for mixer output speaker activity mask
            spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;

            // Number of mixing configurations
            s->nmixoutconfigs = get_bits(&s->gb, 2) + 1;

            // Speaker layout mask for mixer output channels
            for (i = 0; i < s->nmixoutconfigs; i++)
                s->nmixoutchs[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
        }
    } else {
        s->npresents = 1;
        s->nassets = 1;
    }

    // Size of encoded asset data in bytes
    offset = header_size;
    for (i = 0; i < s->nassets; i++) {
        s->assets[i].asset_offset = offset;
        s->assets[i].asset_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
        offset += s->assets[i].asset_size;
        if (offset > s->exss_size) {
            if (s->avctx)
                av_log(s->avctx, AV_LOG_ERROR, "EXSS asset out of bounds\n");
            return AVERROR_INVALIDDATA;
        }
    }

    // Audio asset descriptor
    for (i = 0; i < s->nassets; i++) {
        if ((ret = parse_descriptor(s, &s->assets[i])) < 0)
            return ret;
        if ((ret = set_exss_offsets(&s->assets[i])) < 0) {
            if (s->avctx)
                av_log(s->avctx, AV_LOG_ERROR, "Invalid extension size in EXSS asset descriptor\n");
            return ret;
        }
    }

    // Backward compatible core present
    // Backward compatible core substream index
    // Backward compatible core asset index
    // Reserved
    // Byte align
    // CRC16 of extension substream header
    if (ff_dca_seek_bits(&s->gb, header_size * 8)) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS header\n");
        return AVERROR_INVALIDDATA;
    }

    return 0;
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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		1389	static void parse_xll_parameters(DCAExssParser s, DCAExssAsset asset)
24			{
25			// Size of XLL data in extension substream
26		1389	asset->xll_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
27
28			// XLL sync word present flag
29	✓✗	1389	if (asset->xll_sync_present = get_bits1(&s->gb)) {
30			int xll_delay_nbits;
31
32			// Peak bit rate smoothing buffer size
33		1389	skip_bits(&s->gb, 4);
34
35			// Number of bits for XLL decoding delay
36		1389	xll_delay_nbits = get_bits(&s->gb, 5) + 1;
37
38			// Initial XLL decoding delay in frames
39		1389	asset->xll_delay_nframes = get_bits_long(&s->gb, xll_delay_nbits);
40
41			// Number of bytes offset to XLL sync
42		1389	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		1389	}
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		1453	static int parse_descriptor(DCAExssParser s, DCAExssAsset asset)
61			{
62		1453	int i, j, drc_present, descr_size, descr_pos = get_bits_count(&s->gb);
63
64			// Size of audio asset descriptor in bytes
65		1453	descr_size = get_bits(&s->gb, 9) + 1;
66
67			// Audio asset identifier
68		1453	asset->asset_index = get_bits(&s->gb, 3);
69
70			//
71			// Per stream static metadata
72			//
73
74	✓✗	1453	if (s->static_fields_present) {
75			// Asset type descriptor presence
76	✗✓	1453	if (get_bits1(&s->gb))
77			// Asset type descriptor
78			skip_bits(&s->gb, 4);
79
80			// Language descriptor presence
81	✗✓	1453	if (get_bits1(&s->gb))
82			// Language descriptor
83			skip_bits(&s->gb, 24);
84
85			// Additional textual information presence
86	✗✓	1453	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		1453	asset->pcm_bit_res = get_bits(&s->gb, 5) + 1;
100
101			// Maximum sample rate
102		1453	asset->max_sample_rate = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];
103
104			// Total number of channels
105		1453	asset->nchannels_total = get_bits(&s->gb, 8) + 1;
106
107			// One to one map channel to speakers
108	✓✗	1453	if (asset->one_to_one_map_ch_to_spkr = get_bits1(&s->gb)) {
109		1453	int spkr_mask_nbits = 0;
110			int spkr_remap_nsets;
111			int nspeakers[8];
112
113			// Embedded stereo flag
114	✓✗✓✓	1453	asset->embedded_stereo = asset->nchannels_total > 2 && get_bits1(&s->gb);
115
116			// Embedded 6 channels flag
117	✓✓✓✗	1453	asset->embedded_6ch = asset->nchannels_total > 6 && get_bits1(&s->gb);
118
119			// Speaker mask enabled flag
120	✓✗	1453	if (asset->spkr_mask_enabled = get_bits1(&s->gb)) {
121			// Number of bits for speaker activity mask
122		1453	spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;
123
124			// Loudspeaker activity mask
125		1453	asset->spkr_mask = get_bits(&s->gb, spkr_mask_nbits);
126			}
127
128			// Number of speaker remapping sets
129	✓✓✗✓	1453	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	✓✓	8509	for (i = 0; i < spkr_remap_nsets; i++)
137		7056	nspeakers[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
138
139	✓✓	8509	for (i = 0; i < spkr_remap_nsets; i++) {
140			// Number of channels to be decoded for speaker remapping
141		7056	int nch_for_remaps = get_bits(&s->gb, 5) + 1;
142
143	✓✓	63504	for (j = 0; j < nspeakers[i]; j++) {
144			// Decoded channels to output speaker mapping mask
145		56448	int remap_ch_mask = get_bits_long(&s->gb, nch_for_remaps);
146
147			// Loudspeaker remapping codes
148		56448	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		1453	drc_present = get_bits1(&s->gb);
168
169			// Code for dynamic range coefficient
170	✗✓	1453	if (drc_present)
171			skip_bits(&s->gb, 8);
172
173			// Dialog normalization presence flag
174	✗✓	1453	if (get_bits1(&s->gb))
175			// Dialog normalization code
176			skip_bits(&s->gb, 5);
177
178			// DRC for stereo downmix
179	✗✓✗✗	1453	if (drc_present && asset->embedded_stereo)
180			skip_bits(&s->gb, 8);
181
182			// Mixing metadata presence flag
183	✗✓✗✗	1453	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		1453	asset->coding_mode = get_bits(&s->gb, 2);
236
237			// Coding components used in asset
238	✓✓✗✗ ✗	1453	switch (asset->coding_mode) {
239		1432	case 0: // Coding mode that may contain multiple coding components
240		1432	asset->extension_mask = get_bits(&s->gb, 12);
241
242	✗✓	1432	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	✓✓	1432	if (asset->extension_mask & DCA_EXSS_XBR)
252			// Size of XBR extension in extension substream
253		24	asset->xbr_size = get_bits(&s->gb, 14) + 1;
254
255	✓✓	1432	if (asset->extension_mask & DCA_EXSS_XXCH)
256			// Size of XXCH extension in extension substream
257		40	asset->xxch_size = get_bits(&s->gb, 14) + 1;
258
259	✓✓	1432	if (asset->extension_mask & DCA_EXSS_X96)
260			// Size of X96 extension in extension substream
261		32	asset->x96_size = get_bits(&s->gb, 12) + 1;
262
263	✗✓	1432	if (asset->extension_mask & DCA_EXSS_LBR)
264			parse_lbr_parameters(s, asset);
265
266	✓✓	1432	if (asset->extension_mask & DCA_EXSS_XLL)
267		1368	parse_xll_parameters(s, asset);
268
269	✗✓	1432	if (asset->extension_mask & DCA_EXSS_RSV1)
270			skip_bits(&s->gb, 16);
271
272	✗✓	1432	if (asset->extension_mask & DCA_EXSS_RSV2)
273			skip_bits(&s->gb, 16);
274		1432	break;
275
276		21	case 1: // Loss-less coding mode without CBR component
277		21	asset->extension_mask = DCA_EXSS_XLL;
278		21	parse_xll_parameters(s, asset);
279		21	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	✓✓	1453	if (asset->extension_mask & DCA_EXSS_XLL)
303			// DTS-HD stream ID
304		1389	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	✗✓	1453	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		1453	return 0;
320			}
321
322		1453	static int set_exss_offsets(DCAExssAsset *asset)
323			{
324		1453	int offs = asset->asset_offset;
325		1453	int size = asset->asset_size;
326
327	✗✓	1453	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	✓✓	1453	if (asset->extension_mask & DCA_EXSS_XBR) {
336		24	asset->xbr_offset = offs;
337	✗✓	24	if (asset->xbr_size > size)
338			return AVERROR_INVALIDDATA;
339		24	offs += asset->xbr_size;
340		24	size -= asset->xbr_size;
341			}
342
343	✓✓	1453	if (asset->extension_mask & DCA_EXSS_XXCH) {
344		40	asset->xxch_offset = offs;
345	✗✓	40	if (asset->xxch_size > size)
346			return AVERROR_INVALIDDATA;
347		40	offs += asset->xxch_size;
348		40	size -= asset->xxch_size;
349			}
350
351	✓✓	1453	if (asset->extension_mask & DCA_EXSS_X96) {
352		32	asset->x96_offset = offs;
353	✗✓	32	if (asset->x96_size > size)
354			return AVERROR_INVALIDDATA;
355		32	offs += asset->x96_size;
356		32	size -= asset->x96_size;
357			}
358
359	✗✓	1453	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	✓✓	1453	if (asset->extension_mask & DCA_EXSS_XLL) {
368		1389	asset->xll_offset = offs;
369	✗✓	1389	if (asset->xll_size > size)
370			return AVERROR_INVALIDDATA;
371		1389	offs += asset->xll_size;
372		1389	size -= asset->xll_size;
373			}
374
375		1453	return 0;
376			}
377
378		1453	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	✗✓	1453	if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
383			return ret;
384
385			// Extension substream sync word
386		1453	skip_bits_long(&s->gb, 32);
387
388			// User defined bits
389		1453	skip_bits(&s->gb, 8);
390
391			// Extension substream index
392		1453	s->exss_index = get_bits(&s->gb, 2);
393
394			// Flag indicating short or long header size
395		1453	wide_hdr = get_bits1(&s->gb);
396
397			// Extension substream header length
398		1453	header_size = get_bits(&s->gb, 8 + 4 * wide_hdr) + 1;
399
400			// Check CRC
401	✓✓✗✓	1453	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		1453	s->exss_size_nbits = 16 + 4 * wide_hdr;
407
408			// Number of bytes of extension substream
409		1453	s->exss_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
410	✗✓	1453	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	✓✗	1453	if (s->static_fields_present = get_bits1(&s->gb)) {
418			int active_exss_mask[8];
419
420			// Reference clock code
421		1453	skip_bits(&s->gb, 2);
422
423			// Extension substream frame duration
424		1453	skip_bits(&s->gb, 3);
425
426			// Timecode presence flag
427	✗✓	1453	if (get_bits1(&s->gb))
428			// Timecode data
429			skip_bits_long(&s->gb, 36);
430
431			// Number of defined audio presentations
432		1453	s->npresents = get_bits(&s->gb, 3) + 1;
433	✗✓	1453	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		1453	s->nassets = get_bits(&s->gb, 3) + 1;
441	✗✓	1453	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	✓✓	2906	for (i = 0; i < s->npresents; i++)
449		1453	active_exss_mask[i] = get_bits(&s->gb, s->exss_index + 1);
450
451			// Active audio asset mask
452	✓✓	2906	for (i = 0; i < s->npresents; i++)
453		1453	skip_bits_long(&s->gb, av_popcount(active_exss_mask[i]) * 8);
454
455			// Mixing metadata enable flag
456	✗✓	1453	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		1453	offset = header_size;
479	✓✓	2906	for (i = 0; i < s->nassets; i++) {
480		1453	s->assets[i].asset_offset = offset;
481		1453	s->assets[i].asset_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
482		1453	offset += s->assets[i].asset_size;
483	✗✓	1453	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	✓✓	2906	for (i = 0; i < s->nassets; i++) {
492	✗✓	1453	if ((ret = parse_descriptor(s, &s->assets[i])) < 0)
493			return ret;
494	✗✓	1453	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	✗✓	1453	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		1453	return 0;
514			}