falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
85936 Commits
32 Branches
498MB
Tree: b8c2b9c392
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b8c2b9c392'
${ noResults }
FFmpeg/libavcodec/dca_core.h

230 lines
10KB
Raw Blame History 

  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. typedef struct DCADSPData {

  60.     union {

  61.         struct {

  62.             DECLARE_ALIGNED(32, float, hist1)[1024];

  63.             DECLARE_ALIGNED(32, float, hist2)[64];

  64.         } flt;

  65.         struct {

  66.             DECLARE_ALIGNED(32, int32_t, hist1)[1024];

  67.             DECLARE_ALIGNED(32, int32_t, hist2)[64];

  68.         } fix;

  69.     } u;

  70.     int offset;

  71. } DCADSPData;

  72. 

  73. typedef struct DCACoreDecoder {

  74.     AVCodecContext  *avctx;

  75.     GetBitContext   gb;

  76. 

  77.     // Bit stream header

  78.     int     crc_present;        ///< CRC present flag

  79.     int     npcmblocks;         ///< Number of PCM sample blocks

  80.     int     frame_size;         ///< Primary frame byte size

  81.     int     audio_mode;         ///< Audio channel arrangement

  82.     int     sample_rate;        ///< Core audio sampling frequency

  83.     int     bit_rate;           ///< Transmission bit rate

  84.     int     drc_present;        ///< Embedded dynamic range flag

  85.     int     ts_present;         ///< Embedded time stamp flag

  86.     int     aux_present;        ///< Auxiliary data flag

  87.     int     ext_audio_type;     ///< Extension audio descriptor flag

  88.     int     ext_audio_present;  ///< Extended coding flag

  89.     int     sync_ssf;           ///< Audio sync word insertion flag

  90.     int     lfe_present;        ///< Low frequency effects flag

  91.     int     predictor_history;  ///< Predictor history flag switch

  92.     int     filter_perfect;     ///< Multirate interpolator switch

  93.     int     source_pcm_res;     ///< Source PCM resolution

  94.     int     es_format;          ///< Extended surround (ES) mastering flag

  95.     int     sumdiff_front;      ///< Front sum/difference flag

  96.     int     sumdiff_surround;   ///< Surround sum/difference flag

  97. 

  98.     // Primary audio coding header

  99.     int         nsubframes;     ///< Number of subframes

  100.     int         nchannels;      ///< Number of primary audio channels (incl. extension channels)

  101.     int         ch_mask;        ///< Speaker layout mask (incl. LFE and extension channels)

  102.     int8_t      nsubbands[DCA_CHANNELS];                ///< Subband activity count

  103.     int8_t      subband_vq_start[DCA_CHANNELS];         ///< High frequency VQ start subband

  104.     int8_t      joint_intensity_index[DCA_CHANNELS];    ///< Joint intensity coding index

  105.     int8_t      transition_mode_sel[DCA_CHANNELS];      ///< Transient mode code book

  106.     int8_t      scale_factor_sel[DCA_CHANNELS];         ///< Scale factor code book

  107.     int8_t      bit_allocation_sel[DCA_CHANNELS];       ///< Bit allocation quantizer select

  108.     int8_t      quant_index_sel[DCA_CHANNELS][DCA_CODE_BOOKS];  ///< Quantization index codebook select

  109.     int32_t     scale_factor_adj[DCA_CHANNELS][DCA_CODE_BOOKS]; ///< Scale factor adjustment

  110. 

  111.     // Primary audio coding side information

  112.     int8_t      nsubsubframes[DCA_SUBFRAMES];   ///< Subsubframe count for each subframe

  113.     int8_t      prediction_mode[DCA_CHANNELS][DCA_SUBBANDS_X96];            ///< Prediction mode

  114.     int16_t     prediction_vq_index[DCA_CHANNELS][DCA_SUBBANDS_X96];        ///< Prediction coefficients VQ address

  115.     int8_t      bit_allocation[DCA_CHANNELS][DCA_SUBBANDS_X96];             ///< Bit allocation index

  116.     int8_t      transition_mode[DCA_SUBFRAMES][DCA_CHANNELS][DCA_SUBBANDS]; ///< Transition mode

  117.     int32_t     scale_factors[DCA_CHANNELS][DCA_SUBBANDS][2];               ///< Scale factors (2x for transients and X96)

  118.     int8_t      joint_scale_sel[DCA_CHANNELS];                              ///< Joint subband codebook select

  119.     int32_t     joint_scale_factors[DCA_CHANNELS][DCA_SUBBANDS_X96];        ///< Scale factors for joint subband coding

  120. 

  121.     // Auxiliary data

  122.     int     prim_dmix_embedded; ///< Auxiliary dynamic downmix flag

  123.     int     prim_dmix_type;     ///< Auxiliary primary channel downmix type

  124.     int     prim_dmix_coeff[DCA_DMIX_CHANNELS_MAX * DCA_CORE_CHANNELS_MAX]; ///< Dynamic downmix code coefficients

  125. 

  126.     // Core extensions

  127.     int     ext_audio_mask;     ///< Bit mask of fully decoded core extensions

  128. 

  129.     // XCH extension data

  130.     int     xch_pos;    ///< Bit position of XCH frame in core substream

  131. 

  132.     // XXCH extension data

  133.     int     xxch_crc_present;       ///< CRC presence flag for XXCH channel set header

  134.     int     xxch_mask_nbits;        ///< Number of bits for loudspeaker mask

  135.     int     xxch_core_mask;         ///< Core loudspeaker activity mask

  136.     int     xxch_spkr_mask;         ///< Loudspeaker layout mask

  137.     int     xxch_dmix_embedded;     ///< Downmix already performed by encoder

  138.     int     xxch_dmix_scale_inv;    ///< Downmix scale factor

  139.     int     xxch_dmix_mask[DCA_XXCH_CHANNELS_MAX];  ///< Downmix channel mapping mask

  140.     int     xxch_dmix_coeff[DCA_XXCH_CHANNELS_MAX * DCA_CORE_CHANNELS_MAX];     ///< Downmix coefficients

  141.     int     xxch_pos;   ///< Bit position of XXCH frame in core substream

  142. 

  143.     // X96 extension data

  144.     int     x96_rev_no;         ///< X96 revision number

  145.     int     x96_crc_present;    ///< CRC presence flag for X96 channel set header

  146.     int     x96_nchannels;      ///< Number of primary channels in X96 extension

  147.     int     x96_high_res;       ///< X96 high resolution flag

  148.     int     x96_subband_start;  ///< First encoded subband in X96 extension

  149.     int     x96_rand;           ///< Random seed for generating samples for unallocated X96 subbands

  150.     int     x96_pos;            ///< Bit position of X96 frame in core substream

  151. 

  152.     // Sample buffers

  153.     unsigned int    x96_subband_size;

  154.     int32_t         *x96_subband_buffer;    ///< X96 subband sample buffer base

  155.     int32_t         *x96_subband_samples[DCA_CHANNELS][DCA_SUBBANDS_X96];   ///< X96 subband samples

  156. 

  157.     unsigned int    subband_size;

  158.     int32_t         *subband_buffer;    ///< Subband sample buffer base

  159.     int32_t         *subband_samples[DCA_CHANNELS][DCA_SUBBANDS];   ///< Subband samples

  160.     int32_t         *lfe_samples;    ///< Decimated LFE samples

  161. 

  162.     // DSP contexts

  163.     DCADSPData              dcadsp_data[DCA_CHANNELS];    ///< FIR history buffers

  164.     DCADSPContext           *dcadsp;

  165.     DCADCTContext           dcadct;

  166.     FFTContext              imdct[2];

  167.     SynthFilterContext      synth;

  168.     AVFloatDSPContext       *float_dsp;

  169.     AVFixedDSPContext       *fixed_dsp;

  170. 

  171.     // PCM output data

  172.     unsigned int    output_size;

  173.     void            *output_buffer;                         ///< PCM output buffer base

  174.     int32_t         *output_samples[DCA_SPEAKER_COUNT];     ///< PCM output for fixed point mode

  175.     int32_t         output_history_lfe_fixed;               ///< LFE PCM history for X96 filter

  176.     float           output_history_lfe_float;               ///< LFE PCM history for X96 filter

  177. 

  178.     int     ch_remap[DCA_SPEAKER_COUNT];   ///< Channel to speaker map

  179.     int     request_mask;   ///< Requested channel layout (for stereo downmix)

  180. 

  181.     int     npcmsamples;    ///< Number of PCM samples per channel

  182.     int     output_rate;    ///< Output sample rate (1x or 2x header rate)

  183. 

  184.     int     filter_mode;    ///< Previous filtering mode for detecting changes

  185. } DCACoreDecoder;

  186. 

  187. static inline int ff_dca_core_map_spkr(DCACoreDecoder *core, int spkr)

  188. {

  189.     if (core->ch_mask & (1U << spkr))

  190.         return spkr;

  191.     if (spkr == DCA_SPEAKER_Lss && (core->ch_mask & DCA_SPEAKER_MASK_Ls))

  192.         return DCA_SPEAKER_Ls;

  193.     if (spkr == DCA_SPEAKER_Rss && (core->ch_mask & DCA_SPEAKER_MASK_Rs))

  194.         return DCA_SPEAKER_Rs;

  195.     return -1;

  196. }

  197. 

  198. static inline void ff_dca_core_dequantize(int32_t *output, const int32_t *input,

  199.                                           int32_t step_size, int32_t scale, int residual, int len)

  200. {

  201.     // Account for quantizer step size

  202.     int64_t step_scale = (int64_t)step_size * scale;

  203.     int n, shift = 0;

  204. 

  205.     // Limit scale factor resolution to 22 bits

  206.     if (step_scale > (1 << 23)) {

  207.         shift = av_log2(step_scale >> 23) + 1;

  208.         step_scale >>= shift;

  209.     }

  210. 

  211.     // Scale the samples

  212.     if (residual) {

  213.         for (n = 0; n < len; n++)

  214.             output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));

  215.     } else {

  216.         for (n = 0; n < len; n++)

  217.             output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));

  218.     }

  219. }

  220. 

  221. int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size);

  222. int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset);

  223. int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth);

  224. int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame);

  225. av_cold void ff_dca_core_flush(DCACoreDecoder *s);

  226. av_cold int ff_dca_core_init(DCACoreDecoder *s);

  227. av_cold void ff_dca_core_close(DCACoreDecoder *s);

  228. 

  229. #endif