LCOV - code coverage report
Current view: top level - libavcodec - dca_core.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 20 20 100.0 %
Date: 2017-12-15 18:13:28 Functions: 2 2 100.0 %

          Line data    Source code
       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             : #ifndef AVCODEC_DCA_CORE_H
      22             : #define AVCODEC_DCA_CORE_H
      23             : 
      24             : #include "libavutil/common.h"
      25             : #include "libavutil/float_dsp.h"
      26             : #include "libavutil/fixed_dsp.h"
      27             : #include "libavutil/mem.h"
      28             : 
      29             : #include "avcodec.h"
      30             : #include "internal.h"
      31             : #include "get_bits.h"
      32             : #include "dca.h"
      33             : #include "dca_exss.h"
      34             : #include "dcadsp.h"
      35             : #include "dcadct.h"
      36             : #include "dcamath.h"
      37             : #include "dcahuff.h"
      38             : #include "fft.h"
      39             : #include "synth_filter.h"
      40             : 
      41             : #define DCA_CHANNELS            7
      42             : #define DCA_SUBBANDS            32
      43             : #define DCA_SUBBANDS_X96        64
      44             : #define DCA_SUBFRAMES           16
      45             : #define DCA_SUBBAND_SAMPLES     8
      46             : #define DCA_PCMBLOCK_SAMPLES    32
      47             : #define DCA_LFE_HISTORY         8
      48             : #define DCA_ABITS_MAX           26
      49             : 
      50             : #define DCA_CORE_CHANNELS_MAX       6
      51             : #define DCA_DMIX_CHANNELS_MAX       4
      52             : #define DCA_XXCH_CHANNELS_MAX       2
      53             : #define DCA_EXSS_CHANNELS_MAX       8
      54             : #define DCA_EXSS_CHSETS_MAX         4
      55             : 
      56             : #define DCA_FILTER_MODE_X96     0x01
      57             : #define DCA_FILTER_MODE_FIXED   0x02
      58             : 
      59             : enum DCACoreAudioMode {
      60             :     DCA_AMODE_MONO,             // Mode 0: A (mono)
      61             :     DCA_AMODE_MONO_DUAL,        // Mode 1: A + B (dual mono)
      62             :     DCA_AMODE_STEREO,           // Mode 2: L + R (stereo)
      63             :     DCA_AMODE_STEREO_SUMDIFF,   // Mode 3: (L+R) + (L-R) (sum-diff)
      64             :     DCA_AMODE_STEREO_TOTAL,     // Mode 4: LT + RT (left and right total)
      65             :     DCA_AMODE_3F,               // Mode 5: C + L + R
      66             :     DCA_AMODE_2F1R,             // Mode 6: L + R + S
      67             :     DCA_AMODE_3F1R,             // Mode 7: C + L + R + S
      68             :     DCA_AMODE_2F2R,             // Mode 8: L + R + SL + SR
      69             :     DCA_AMODE_3F2R,             // Mode 9: C + L + R + SL + SR
      70             : 
      71             :     DCA_AMODE_COUNT
      72             : };
      73             : 
      74             : enum DCACoreExtAudioType {
      75             :     DCA_EXT_AUDIO_XCH   = 0,
      76             :     DCA_EXT_AUDIO_X96   = 2,
      77             :     DCA_EXT_AUDIO_XXCH  = 6
      78             : };
      79             : 
      80             : enum DCACoreLFEFlag {
      81             :     DCA_LFE_FLAG_NONE,
      82             :     DCA_LFE_FLAG_128,
      83             :     DCA_LFE_FLAG_64,
      84             :     DCA_LFE_FLAG_INVALID
      85             : };
      86             : 
      87             : typedef struct DCADSPData {
      88             :     union {
      89             :         struct {
      90             :             DECLARE_ALIGNED(32, float, hist1)[1024];
      91             :             DECLARE_ALIGNED(32, float, hist2)[64];
      92             :         } flt;
      93             :         struct {
      94             :             DECLARE_ALIGNED(32, int32_t, hist1)[1024];
      95             :             DECLARE_ALIGNED(32, int32_t, hist2)[64];
      96             :         } fix;
      97             :     } u;
      98             :     int offset;
      99             : } DCADSPData;
     100             : 
     101             : typedef struct DCACoreDecoder {
     102             :     AVCodecContext  *avctx;
     103             :     GetBitContext   gb;
     104             :     GetBitContext   gb_in;
     105             : 
     106             :     // Bit stream header
     107             :     int     crc_present;        ///< CRC present flag
     108             :     int     npcmblocks;         ///< Number of PCM sample blocks
     109             :     int     frame_size;         ///< Primary frame byte size
     110             :     int     audio_mode;         ///< Audio channel arrangement
     111             :     int     sample_rate;        ///< Core audio sampling frequency
     112             :     int     bit_rate;           ///< Transmission bit rate
     113             :     int     drc_present;        ///< Embedded dynamic range flag
     114             :     int     ts_present;         ///< Embedded time stamp flag
     115             :     int     aux_present;        ///< Auxiliary data flag
     116             :     int     ext_audio_type;     ///< Extension audio descriptor flag
     117             :     int     ext_audio_present;  ///< Extended coding flag
     118             :     int     sync_ssf;           ///< Audio sync word insertion flag
     119             :     int     lfe_present;        ///< Low frequency effects flag
     120             :     int     predictor_history;  ///< Predictor history flag switch
     121             :     int     filter_perfect;     ///< Multirate interpolator switch
     122             :     int     source_pcm_res;     ///< Source PCM resolution
     123             :     int     es_format;          ///< Extended surround (ES) mastering flag
     124             :     int     sumdiff_front;      ///< Front sum/difference flag
     125             :     int     sumdiff_surround;   ///< Surround sum/difference flag
     126             : 
     127             :     // Primary audio coding header
     128             :     int         nsubframes;     ///< Number of subframes
     129             :     int         nchannels;      ///< Number of primary audio channels (incl. extension channels)
     130             :     int         ch_mask;        ///< Speaker layout mask (incl. LFE and extension channels)
     131             :     int8_t      nsubbands[DCA_CHANNELS];                ///< Subband activity count
     132             :     int8_t      subband_vq_start[DCA_CHANNELS];         ///< High frequency VQ start subband
     133             :     int8_t      joint_intensity_index[DCA_CHANNELS];    ///< Joint intensity coding index
     134             :     int8_t      transition_mode_sel[DCA_CHANNELS];      ///< Transient mode code book
     135             :     int8_t      scale_factor_sel[DCA_CHANNELS];         ///< Scale factor code book
     136             :     int8_t      bit_allocation_sel[DCA_CHANNELS];       ///< Bit allocation quantizer select
     137             :     int8_t      quant_index_sel[DCA_CHANNELS][DCA_CODE_BOOKS];  ///< Quantization index codebook select
     138             :     int32_t     scale_factor_adj[DCA_CHANNELS][DCA_CODE_BOOKS]; ///< Scale factor adjustment
     139             : 
     140             :     // Primary audio coding side information
     141             :     int8_t      nsubsubframes[DCA_SUBFRAMES];   ///< Subsubframe count for each subframe
     142             :     int8_t      prediction_mode[DCA_CHANNELS][DCA_SUBBANDS_X96];            ///< Prediction mode
     143             :     int16_t     prediction_vq_index[DCA_CHANNELS][DCA_SUBBANDS_X96];        ///< Prediction coefficients VQ address
     144             :     int8_t      bit_allocation[DCA_CHANNELS][DCA_SUBBANDS_X96];             ///< Bit allocation index
     145             :     int8_t      transition_mode[DCA_SUBFRAMES][DCA_CHANNELS][DCA_SUBBANDS]; ///< Transition mode
     146             :     int32_t     scale_factors[DCA_CHANNELS][DCA_SUBBANDS][2];               ///< Scale factors (2x for transients and X96)
     147             :     int8_t      joint_scale_sel[DCA_CHANNELS];                              ///< Joint subband codebook select
     148             :     int32_t     joint_scale_factors[DCA_CHANNELS][DCA_SUBBANDS_X96];        ///< Scale factors for joint subband coding
     149             : 
     150             :     // Auxiliary data
     151             :     int     prim_dmix_embedded; ///< Auxiliary dynamic downmix flag
     152             :     int     prim_dmix_type;     ///< Auxiliary primary channel downmix type
     153             :     int     prim_dmix_coeff[DCA_DMIX_CHANNELS_MAX * DCA_CORE_CHANNELS_MAX]; ///< Dynamic downmix code coefficients
     154             : 
     155             :     // Core extensions
     156             :     int     ext_audio_mask;     ///< Bit mask of fully decoded core extensions
     157             : 
     158             :     // XCH extension data
     159             :     int     xch_pos;    ///< Bit position of XCH frame in core substream
     160             : 
     161             :     // XXCH extension data
     162             :     int     xxch_crc_present;       ///< CRC presence flag for XXCH channel set header
     163             :     int     xxch_mask_nbits;        ///< Number of bits for loudspeaker mask
     164             :     int     xxch_core_mask;         ///< Core loudspeaker activity mask
     165             :     int     xxch_spkr_mask;         ///< Loudspeaker layout mask
     166             :     int     xxch_dmix_embedded;     ///< Downmix already performed by encoder
     167             :     int     xxch_dmix_scale_inv;    ///< Downmix scale factor
     168             :     int     xxch_dmix_mask[DCA_XXCH_CHANNELS_MAX];  ///< Downmix channel mapping mask
     169             :     int     xxch_dmix_coeff[DCA_XXCH_CHANNELS_MAX * DCA_CORE_CHANNELS_MAX];     ///< Downmix coefficients
     170             :     int     xxch_pos;   ///< Bit position of XXCH frame in core substream
     171             : 
     172             :     // X96 extension data
     173             :     int     x96_rev_no;         ///< X96 revision number
     174             :     int     x96_crc_present;    ///< CRC presence flag for X96 channel set header
     175             :     int     x96_nchannels;      ///< Number of primary channels in X96 extension
     176             :     int     x96_high_res;       ///< X96 high resolution flag
     177             :     int     x96_subband_start;  ///< First encoded subband in X96 extension
     178             :     int     x96_rand;           ///< Random seed for generating samples for unallocated X96 subbands
     179             :     int     x96_pos;            ///< Bit position of X96 frame in core substream
     180             : 
     181             :     // Sample buffers
     182             :     unsigned int    x96_subband_size;
     183             :     int32_t         *x96_subband_buffer;    ///< X96 subband sample buffer base
     184             :     int32_t         *x96_subband_samples[DCA_CHANNELS][DCA_SUBBANDS_X96];   ///< X96 subband samples
     185             : 
     186             :     unsigned int    subband_size;
     187             :     int32_t         *subband_buffer;    ///< Subband sample buffer base
     188             :     int32_t         *subband_samples[DCA_CHANNELS][DCA_SUBBANDS];   ///< Subband samples
     189             :     int32_t         *lfe_samples;    ///< Decimated LFE samples
     190             : 
     191             :     // DSP contexts
     192             :     DCADSPData              dcadsp_data[DCA_CHANNELS];    ///< FIR history buffers
     193             :     DCADSPContext           *dcadsp;
     194             :     DCADCTContext           dcadct;
     195             :     FFTContext              imdct[2];
     196             :     SynthFilterContext      synth;
     197             :     AVFloatDSPContext       *float_dsp;
     198             :     AVFixedDSPContext       *fixed_dsp;
     199             : 
     200             :     // PCM output data
     201             :     unsigned int    output_size;
     202             :     void            *output_buffer;                         ///< PCM output buffer base
     203             :     int32_t         *output_samples[DCA_SPEAKER_COUNT];     ///< PCM output for fixed point mode
     204             :     int32_t         output_history_lfe_fixed;               ///< LFE PCM history for X96 filter
     205             :     float           output_history_lfe_float;               ///< LFE PCM history for X96 filter
     206             : 
     207             :     int     ch_remap[DCA_SPEAKER_COUNT];   ///< Channel to speaker map
     208             :     int     request_mask;   ///< Requested channel layout (for stereo downmix)
     209             : 
     210             :     int     npcmsamples;    ///< Number of PCM samples per channel
     211             :     int     output_rate;    ///< Output sample rate (1x or 2x header rate)
     212             : 
     213             :     int     filter_mode;    ///< Previous filtering mode for detecting changes
     214             : } DCACoreDecoder;
     215             : 
     216        7743 : static inline int ff_dca_core_map_spkr(DCACoreDecoder *core, int spkr)
     217             : {
     218        7743 :     if (core->ch_mask & (1U << spkr))
     219        7631 :         return spkr;
     220         112 :     if (spkr == DCA_SPEAKER_Lss && (core->ch_mask & DCA_SPEAKER_MASK_Ls))
     221          48 :         return DCA_SPEAKER_Ls;
     222          64 :     if (spkr == DCA_SPEAKER_Rss && (core->ch_mask & DCA_SPEAKER_MASK_Rs))
     223          48 :         return DCA_SPEAKER_Rs;
     224          16 :     return -1;
     225             : }
     226             : 
     227      679852 : static inline void ff_dca_core_dequantize(int32_t *output, const int32_t *input,
     228             :                                           int32_t step_size, int32_t scale, int residual, int len)
     229             : {
     230             :     // Account for quantizer step size
     231      679852 :     int64_t step_scale = (int64_t)step_size * scale;
     232      679852 :     int n, shift = 0;
     233             : 
     234             :     // Limit scale factor resolution to 22 bits
     235      679852 :     if (step_scale > (1 << 23)) {
     236      472149 :         shift = av_log2(step_scale >> 23) + 1;
     237      472149 :         step_scale >>= shift;
     238             :     }
     239             : 
     240             :     // Scale the samples
     241      679852 :     if (residual) {
     242       41958 :         for (n = 0; n < len; n++)
     243       37296 :             output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));
     244             :     } else {
     245     5812006 :         for (n = 0; n < len; n++)
     246     5136816 :             output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));
     247             :     }
     248      679852 : }
     249             : 
     250             : int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size);
     251             : int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset);
     252             : int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth);
     253             : int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame);
     254             : av_cold void ff_dca_core_flush(DCACoreDecoder *s);
     255             : av_cold int ff_dca_core_init(DCACoreDecoder *s);
     256             : av_cold void ff_dca_core_close(DCACoreDecoder *s);
     257             : 
     258             : #endif

Generated by: LCOV version 1.13