/*
  * 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;
 }