* Copyright (C) 2004 Benjamin Zores
* Copyright (C) 2006 Benjamin Larsson
* Copyright (C) 2007 Konstantin Shishkov
+ * Copyright (C) 2012 Paul B Mahol
+ * Copyright (C) 2014 Niels Möller
*
* This file is part of Libav.
*
#include <stddef.h>
#include <stdio.h>
+#include "libavutil/attributes.h"
+#include "libavutil/channel_layout.h"
#include "libavutil/common.h"
#include "libavutil/float_dsp.h"
-#include "libavutil/intmath.h"
+#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
-#include "libavutil/audioconvert.h"
+#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"
+
#include "avcodec.h"
-#include "dsputil.h"
+#include "dca.h"
+#include "dca_syncwords.h"
+#include "dcadata.h"
+#include "dcadsp.h"
+#include "dcahuff.h"
#include "fft.h"
+#include "fmtconvert.h"
#include "get_bits.h"
+#include "internal.h"
+#include "mathops.h"
+#include "profiles.h"
#include "put_bits.h"
-#include "dcadata.h"
-#include "dcahuff.h"
-#include "dca.h"
-#include "dca_parser.h"
#include "synth_filter.h"
-#include "dcadsp.h"
-#include "fmtconvert.h"
#if ARCH_ARM
# include "arm/dca.h"
#endif
-//#define TRACE
-
-#define DCA_PRIM_CHANNELS_MAX (7)
-#define DCA_SUBBANDS (32)
-#define DCA_ABITS_MAX (32) /* Should be 28 */
-#define DCA_SUBSUBFRAMES_MAX (4)
-#define DCA_SUBFRAMES_MAX (16)
-#define DCA_BLOCKS_MAX (16)
-#define DCA_LFE_MAX (3)
-
enum DCAMode {
DCA_MONO = 0,
DCA_CHANNEL,
DCA_4F2R
};
-/* these are unconfirmed but should be mostly correct */
-enum DCAExSSSpeakerMask {
- DCA_EXSS_FRONT_CENTER = 0x0001,
- DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
- DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
- DCA_EXSS_LFE = 0x0008,
- DCA_EXSS_REAR_CENTER = 0x0010,
- DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
- DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
- DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
- DCA_EXSS_OVERHEAD = 0x0100,
- DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
- DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
- DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
- DCA_EXSS_LFE2 = 0x1000,
- DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
- DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
- DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
-};
-
-enum DCAExtensionMask {
- DCA_EXT_CORE = 0x001, ///< core in core substream
- DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
- DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
- DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
- DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
- DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
- DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
- DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
- DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
- DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
-};
-
/* -1 are reserved or unknown */
static const int dca_ext_audio_descr_mask[] = {
DCA_EXT_XCH,
-1,
};
-/* extensions that reside in core substream */
-#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
-
/* Tables for mapping dts channel configurations to libavcodec multichannel api.
* Some compromises have been made for special configurations. Most configurations
* are never used so complete accuracy is not needed.
AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
};
-static const int8_t dca_lfe_index[] = {
- 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
-};
-
-static const int8_t dca_channel_reorder_lfe[][9] = {
- { 0, -1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 2, 0, 1, -1, -1, -1, -1, -1, -1},
- { 0, 1, 3, -1, -1, -1, -1, -1, -1},
- { 2, 0, 1, 4, -1, -1, -1, -1, -1},
- { 0, 1, 3, 4, -1, -1, -1, -1, -1},
- { 2, 0, 1, 4, 5, -1, -1, -1, -1},
- { 3, 4, 0, 1, 5, 6, -1, -1, -1},
- { 2, 0, 1, 4, 5, 6, -1, -1, -1},
- { 0, 6, 4, 5, 2, 3, -1, -1, -1},
- { 4, 2, 5, 0, 1, 6, 7, -1, -1},
- { 5, 6, 0, 1, 7, 3, 8, 4, -1},
- { 4, 2, 5, 0, 1, 6, 8, 7, -1},
-};
-
-static const int8_t dca_channel_reorder_lfe_xch[][9] = {
- { 0, 2, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, 3, -1, -1, -1, -1, -1, -1},
- { 0, 1, 3, -1, -1, -1, -1, -1, -1},
- { 0, 1, 3, -1, -1, -1, -1, -1, -1},
- { 0, 1, 3, -1, -1, -1, -1, -1, -1},
- { 2, 0, 1, 4, -1, -1, -1, -1, -1},
- { 0, 1, 3, 4, -1, -1, -1, -1, -1},
- { 2, 0, 1, 4, 5, -1, -1, -1, -1},
- { 0, 1, 4, 5, 3, -1, -1, -1, -1},
- { 2, 0, 1, 5, 6, 4, -1, -1, -1},
- { 3, 4, 0, 1, 6, 7, 5, -1, -1},
- { 2, 0, 1, 4, 5, 6, 7, -1, -1},
- { 0, 6, 4, 5, 2, 3, 7, -1, -1},
- { 4, 2, 5, 0, 1, 7, 8, 6, -1},
- { 5, 6, 0, 1, 8, 3, 9, 4, 7},
- { 4, 2, 5, 0, 1, 6, 9, 8, 7},
-};
-
-static const int8_t dca_channel_reorder_nolfe[][9] = {
- { 0, -1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 2, 0, 1, -1, -1, -1, -1, -1, -1},
- { 0, 1, 2, -1, -1, -1, -1, -1, -1},
- { 2, 0, 1, 3, -1, -1, -1, -1, -1},
- { 0, 1, 2, 3, -1, -1, -1, -1, -1},
- { 2, 0, 1, 3, 4, -1, -1, -1, -1},
- { 2, 3, 0, 1, 4, 5, -1, -1, -1},
- { 2, 0, 1, 3, 4, 5, -1, -1, -1},
- { 0, 5, 3, 4, 1, 2, -1, -1, -1},
- { 3, 2, 4, 0, 1, 5, 6, -1, -1},
- { 4, 5, 0, 1, 6, 2, 7, 3, -1},
- { 3, 2, 4, 0, 1, 5, 7, 6, -1},
-};
-
-static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
- { 0, 1, -1, -1, -1, -1, -1, -1, -1},
- { 0, 1, 2, -1, -1, -1, -1, -1, -1},
- { 0, 1, 2, -1, -1, -1, -1, -1, -1},
- { 0, 1, 2, -1, -1, -1, -1, -1, -1},
- { 0, 1, 2, -1, -1, -1, -1, -1, -1},
- { 2, 0, 1, 3, -1, -1, -1, -1, -1},
- { 0, 1, 2, 3, -1, -1, -1, -1, -1},
- { 2, 0, 1, 3, 4, -1, -1, -1, -1},
- { 0, 1, 3, 4, 2, -1, -1, -1, -1},
- { 2, 0, 1, 4, 5, 3, -1, -1, -1},
- { 2, 3, 0, 1, 5, 6, 4, -1, -1},
- { 2, 0, 1, 3, 4, 5, 6, -1, -1},
- { 0, 5, 3, 4, 1, 2, 6, -1, -1},
- { 3, 2, 4, 0, 1, 6, 7, 5, -1},
- { 4, 5, 0, 1, 7, 2, 8, 3, 6},
- { 3, 2, 4, 0, 1, 5, 8, 7, 6},
-};
-
#define DCA_DOLBY 101 /* FIXME */
#define DCA_CHANNEL_BITS 6
#define HEADER_SIZE 14
-#define DCA_MAX_FRAME_SIZE 16384
-#define DCA_MAX_EXSS_HEADER_SIZE 4096
-
-#define DCA_BUFFER_PADDING_SIZE 1024
+#define DCA_NSYNCAUX 0x9A1105A0
/** Bit allocation */
-typedef struct {
+typedef struct BitAlloc {
int offset; ///< code values offset
int maxbits[8]; ///< max bits in VLC
int wrap; ///< wrap for get_vlc2()
ba->offset;
}
-typedef struct {
- AVCodecContext *avctx;
- AVFrame frame;
- /* Frame header */
- int frame_type; ///< type of the current frame
- int samples_deficit; ///< deficit sample count
- int crc_present; ///< crc is present in the bitstream
- int sample_blocks; ///< number of PCM sample blocks
- int frame_size; ///< primary frame byte size
- int amode; ///< audio channels arrangement
- int sample_rate; ///< audio sampling rate
- int bit_rate; ///< transmission bit rate
- int bit_rate_index; ///< transmission bit rate index
-
- int downmix; ///< embedded downmix enabled
- int dynrange; ///< embedded dynamic range flag
- int timestamp; ///< embedded time stamp flag
- int aux_data; ///< auxiliary data flag
- int hdcd; ///< source material is mastered in HDCD
- int ext_descr; ///< extension audio descriptor flag
- int ext_coding; ///< extended coding flag
- int aspf; ///< audio sync word insertion flag
- int lfe; ///< low frequency effects flag
- int predictor_history; ///< predictor history flag
- int header_crc; ///< header crc check bytes
- int multirate_inter; ///< multirate interpolator switch
- int version; ///< encoder software revision
- int copy_history; ///< copy history
- int source_pcm_res; ///< source pcm resolution
- int front_sum; ///< front sum/difference flag
- int surround_sum; ///< surround sum/difference flag
- int dialog_norm; ///< dialog normalisation parameter
-
- /* Primary audio coding header */
- int subframes; ///< number of subframes
- int is_channels_set; ///< check for if the channel number is already set
- int total_channels; ///< number of channels including extensions
- int prim_channels; ///< number of primary audio channels
- int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
- int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
- int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
- int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
- int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
- int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
- int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
- float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
-
- /* Primary audio coding side information */
- int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
- int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
- int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
- int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
- int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
- int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
- int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
- int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
- int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
- int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
- int dynrange_coef; ///< dynamic range coefficient
-
- int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
-
- float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
- int lfe_scale_factor;
-
- /* Subband samples history (for ADPCM) */
- DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
- DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
- DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
- int hist_index[DCA_PRIM_CHANNELS_MAX];
- DECLARE_ALIGNED(32, float, raXin)[32];
-
- int output; ///< type of output
-
- DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
- float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
- float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
- uint8_t *extra_channels_buffer;
- unsigned int extra_channels_buffer_size;
-
- uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
- int dca_buffer_size; ///< how much data is in the dca_buffer
-
- const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
- GetBitContext gb;
- /* Current position in DCA frame */
- int current_subframe;
- int current_subsubframe;
-
- int core_ext_mask; ///< present extensions in the core substream
-
- /* XCh extension information */
- int xch_present; ///< XCh extension present and valid
- int xch_base_channel; ///< index of first (only) channel containing XCH data
-
- /* ExSS header parser */
- int static_fields; ///< static fields present
- int mix_metadata; ///< mixing metadata present
- int num_mix_configs; ///< number of mix out configurations
- int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
-
- int profile;
-
- int debug_flag; ///< used for suppressing repeated error messages output
- AVFloatDSPContext fdsp;
- FFTContext imdct;
- SynthFilterContext synth;
- DCADSPContext dcadsp;
- FmtConvertContext fmt_conv;
-} DCAContext;
-
-static const uint16_t dca_vlc_offs[] = {
- 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
- 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
- 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
- 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
- 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
- 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
-};
-
static av_cold void dca_init_vlcs(void)
{
static int vlcs_initialized = 0;
return;
dca_bitalloc_index.offset = 1;
- dca_bitalloc_index.wrap = 2;
+ dca_bitalloc_index.wrap = 2;
for (i = 0; i < 5; i++) {
- dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
- dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
+ dca_bitalloc_index.vlc[i].table = &dca_table[ff_dca_vlc_offs[i]];
+ dca_bitalloc_index.vlc[i].table_allocated = ff_dca_vlc_offs[i + 1] - ff_dca_vlc_offs[i];
init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
bitalloc_12_bits[i], 1, 1,
bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
}
dca_scalefactor.offset = -64;
- dca_scalefactor.wrap = 2;
+ dca_scalefactor.wrap = 2;
for (i = 0; i < 5; i++) {
- dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
- dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
+ dca_scalefactor.vlc[i].table = &dca_table[ff_dca_vlc_offs[i + 5]];
+ dca_scalefactor.vlc[i].table_allocated = ff_dca_vlc_offs[i + 6] - ff_dca_vlc_offs[i + 5];
init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
scales_bits[i], 1, 1,
scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
}
dca_tmode.offset = 0;
- dca_tmode.wrap = 1;
+ dca_tmode.wrap = 1;
for (i = 0; i < 4; i++) {
- dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
- dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
+ dca_tmode.vlc[i].table = &dca_table[ff_dca_vlc_offs[i + 10]];
+ dca_tmode.vlc[i].table_allocated = ff_dca_vlc_offs[i + 11] - ff_dca_vlc_offs[i + 10];
init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
tmode_bits[i], 1, 1,
tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
break;
dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
- dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
- dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
+ dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[ff_dca_vlc_offs[c]];
+ dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = ff_dca_vlc_offs[c + 1] - ff_dca_vlc_offs[c];
init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
bitalloc_sizes[i],
static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
{
int i, j;
- static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
+ static const uint8_t adj_table[4] = { 16, 18, 20, 23 };
static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
- s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
- s->prim_channels = s->total_channels;
-
- if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
- s->prim_channels = DCA_PRIM_CHANNELS_MAX;
+ s->audio_header.total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
+ s->audio_header.prim_channels = s->audio_header.total_channels;
+ if (s->audio_header.prim_channels > DCA_PRIM_CHANNELS_MAX)
+ s->audio_header.prim_channels = DCA_PRIM_CHANNELS_MAX;
- for (i = base_channel; i < s->prim_channels; i++) {
- s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
- if (s->subband_activity[i] > DCA_SUBBANDS)
- s->subband_activity[i] = DCA_SUBBANDS;
+ for (i = base_channel; i < s->audio_header.prim_channels; i++) {
+ s->audio_header.subband_activity[i] = get_bits(&s->gb, 5) + 2;
+ if (s->audio_header.subband_activity[i] > DCA_SUBBANDS)
+ s->audio_header.subband_activity[i] = DCA_SUBBANDS;
}
- for (i = base_channel; i < s->prim_channels; i++) {
- s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
- if (s->vq_start_subband[i] > DCA_SUBBANDS)
- s->vq_start_subband[i] = DCA_SUBBANDS;
+ for (i = base_channel; i < s->audio_header.prim_channels; i++) {
+ s->audio_header.vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
+ if (s->audio_header.vq_start_subband[i] > DCA_SUBBANDS)
+ s->audio_header.vq_start_subband[i] = DCA_SUBBANDS;
}
- get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
- get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
- get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
- get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
+ get_array(&s->gb, s->audio_header.joint_intensity + base_channel,
+ s->audio_header.prim_channels - base_channel, 3);
+ get_array(&s->gb, s->audio_header.transient_huffman + base_channel,
+ s->audio_header.prim_channels - base_channel, 2);
+ get_array(&s->gb, s->audio_header.scalefactor_huffman + base_channel,
+ s->audio_header.prim_channels - base_channel, 3);
+ get_array(&s->gb, s->audio_header.bitalloc_huffman + base_channel,
+ s->audio_header.prim_channels - base_channel, 3);
/* Get codebooks quantization indexes */
if (!base_channel)
- memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
+ memset(s->audio_header.quant_index_huffman, 0, sizeof(s->audio_header.quant_index_huffman));
for (j = 1; j < 11; j++)
- for (i = base_channel; i < s->prim_channels; i++)
- s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
+ for (i = base_channel; i < s->audio_header.prim_channels; i++)
+ s->audio_header.quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
/* Get scale factor adjustment */
for (j = 0; j < 11; j++)
- for (i = base_channel; i < s->prim_channels; i++)
- s->scalefactor_adj[i][j] = 1;
+ for (i = base_channel; i < s->audio_header.prim_channels; i++)
+ s->audio_header.scalefactor_adj[i][j] = 16;
for (j = 1; j < 11; j++)
- for (i = base_channel; i < s->prim_channels; i++)
- if (s->quant_index_huffman[i][j] < thr[j])
- s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
+ for (i = base_channel; i < s->audio_header.prim_channels; i++)
+ if (s->audio_header.quant_index_huffman[i][j] < thr[j])
+ s->audio_header.scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
if (s->crc_present) {
/* Audio header CRC check */
s->current_subframe = 0;
s->current_subsubframe = 0;
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
- av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
- for (i = base_channel; i < s->prim_channels; i++) {
- av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
- s->subband_activity[i]);
- av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
- s->vq_start_subband[i]);
- av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
- s->joint_intensity[i]);
- av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
- s->transient_huffman[i]);
- av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
- s->scalefactor_huffman[i]);
- av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
- s->bitalloc_huffman[i]);
- av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
- for (j = 0; j < 11; j++)
- av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
- for (j = 0; j < 11; j++)
- av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
-#endif
-
return 0;
}
if (!s->sample_rate)
return AVERROR_INVALIDDATA;
s->bit_rate_index = get_bits(&s->gb, 5);
- s->bit_rate = dca_bit_rates[s->bit_rate_index];
+ s->bit_rate = ff_dca_bit_rates[s->bit_rate_index];
if (!s->bit_rate)
return AVERROR_INVALIDDATA;
- s->downmix = get_bits(&s->gb, 1);
+ skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
s->dynrange = get_bits(&s->gb, 1);
s->timestamp = get_bits(&s->gb, 1);
s->aux_data = get_bits(&s->gb, 1);
s->lfe = get_bits(&s->gb, 2);
s->predictor_history = get_bits(&s->gb, 1);
+ if (s->lfe > 2) {
+ av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
+ return AVERROR_INVALIDDATA;
+ }
+
/* TODO: check CRC */
if (s->crc_present)
s->header_crc = get_bits(&s->gb, 16);
if (s->lfe)
s->output |= DCA_LFE;
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
- av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
- av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
- av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
- s->sample_blocks, s->sample_blocks * 32);
- av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
- av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
- s->amode, dca_channels[s->amode]);
- av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
- s->sample_rate);
- av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
- s->bit_rate);
- av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
- av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
- av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
- av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
- av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
- av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
- av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
- av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
- av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
- av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
- s->predictor_history);
- av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
- av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
- s->multirate_inter);
- av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
- av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
- av_log(s->avctx, AV_LOG_DEBUG,
- "source pcm resolution: %i (%i bits/sample)\n",
- s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
- av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
- av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
- av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
-#endif
-
/* Primary audio coding header */
- s->subframes = get_bits(&s->gb, 4) + 1;
+ s->audio_header.subframes = get_bits(&s->gb, 4) + 1;
return dca_parse_audio_coding_header(s, 0);
}
-
static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
{
if (level < 5) {
/* huffman encoded */
value += get_bitalloc(gb, &dca_scalefactor, level);
- value = av_clip(value, 0, (1 << log2range) - 1);
+ value = av_clip(value, 0, (1 << log2range) - 1);
} else if (level < 8) {
if (level + 1 > log2range) {
skip_bits(gb, level + 1 - log2range);
s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
}
- for (j = base_channel; j < s->prim_channels; j++) {
- for (k = 0; k < s->subband_activity[j]; k++)
- s->prediction_mode[j][k] = get_bits(&s->gb, 1);
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
+ for (k = 0; k < s->audio_header.subband_activity[j]; k++)
+ s->dca_chan[j].prediction_mode[k] = get_bits(&s->gb, 1);
}
/* Get prediction codebook */
- for (j = base_channel; j < s->prim_channels; j++) {
- for (k = 0; k < s->subband_activity[j]; k++) {
- if (s->prediction_mode[j][k] > 0) {
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
+ for (k = 0; k < s->audio_header.subband_activity[j]; k++) {
+ if (s->dca_chan[j].prediction_mode[k] > 0) {
/* (Prediction coefficient VQ address) */
- s->prediction_vq[j][k] = get_bits(&s->gb, 12);
+ s->dca_chan[j].prediction_vq[k] = get_bits(&s->gb, 12);
}
}
}
/* Bit allocation index */
- for (j = base_channel; j < s->prim_channels; j++) {
- for (k = 0; k < s->vq_start_subband[j]; k++) {
- if (s->bitalloc_huffman[j] == 6)
- s->bitalloc[j][k] = get_bits(&s->gb, 5);
- else if (s->bitalloc_huffman[j] == 5)
- s->bitalloc[j][k] = get_bits(&s->gb, 4);
- else if (s->bitalloc_huffman[j] == 7) {
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
+ for (k = 0; k < s->audio_header.vq_start_subband[j]; k++) {
+ if (s->audio_header.bitalloc_huffman[j] == 6)
+ s->dca_chan[j].bitalloc[k] = get_bits(&s->gb, 5);
+ else if (s->audio_header.bitalloc_huffman[j] == 5)
+ s->dca_chan[j].bitalloc[k] = get_bits(&s->gb, 4);
+ else if (s->audio_header.bitalloc_huffman[j] == 7) {
av_log(s->avctx, AV_LOG_ERROR,
"Invalid bit allocation index\n");
return AVERROR_INVALIDDATA;
} else {
- s->bitalloc[j][k] =
- get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
+ s->dca_chan[j].bitalloc[k] =
+ get_bitalloc(&s->gb, &dca_bitalloc_index, s->audio_header.bitalloc_huffman[j]);
}
- if (s->bitalloc[j][k] > 26) {
- av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
- j, k, s->bitalloc[j][k]);
+ if (s->dca_chan[j].bitalloc[k] > 26) {
+ ff_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
+ j, k, s->dca_chan[j].bitalloc[k]);
return AVERROR_INVALIDDATA;
}
}
}
/* Transition mode */
- for (j = base_channel; j < s->prim_channels; j++) {
- for (k = 0; k < s->subband_activity[j]; k++) {
- s->transition_mode[j][k] = 0;
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
+ for (k = 0; k < s->audio_header.subband_activity[j]; k++) {
+ s->dca_chan[j].transition_mode[k] = 0;
if (s->subsubframes[s->current_subframe] > 1 &&
- k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
- s->transition_mode[j][k] =
- get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
+ k < s->audio_header.vq_start_subband[j] && s->dca_chan[j].bitalloc[k] > 0) {
+ s->dca_chan[j].transition_mode[k] =
+ get_bitalloc(&s->gb, &dca_tmode, s->audio_header.transient_huffman[j]);
}
}
}
if (get_bits_left(&s->gb) < 0)
return AVERROR_INVALIDDATA;
- for (j = base_channel; j < s->prim_channels; j++) {
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
const uint32_t *scale_table;
int scale_sum, log_size;
- memset(s->scale_factor[j], 0,
- s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
+ memset(s->dca_chan[j].scale_factor, 0,
+ s->audio_header.subband_activity[j] * sizeof(s->dca_chan[j].scale_factor[0][0]) * 2);
- if (s->scalefactor_huffman[j] == 6) {
- scale_table = scale_factor_quant7;
- log_size = 7;
+ if (s->audio_header.scalefactor_huffman[j] == 6) {
+ scale_table = ff_dca_scale_factor_quant7;
+ log_size = 7;
} else {
- scale_table = scale_factor_quant6;
- log_size = 6;
+ scale_table = ff_dca_scale_factor_quant6;
+ log_size = 6;
}
/* When huffman coded, only the difference is encoded */
scale_sum = 0;
- for (k = 0; k < s->subband_activity[j]; k++) {
- if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
- scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
- s->scale_factor[j][k][0] = scale_table[scale_sum];
+ for (k = 0; k < s->audio_header.subband_activity[j]; k++) {
+ if (k >= s->audio_header.vq_start_subband[j] || s->dca_chan[j].bitalloc[k] > 0) {
+ scale_sum = get_scale(&s->gb, s->audio_header.scalefactor_huffman[j], scale_sum, log_size);
+ s->dca_chan[j].scale_factor[k][0] = scale_table[scale_sum];
}
- if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
+ if (k < s->audio_header.vq_start_subband[j] && s->dca_chan[j].transition_mode[k]) {
/* Get second scale factor */
- scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
- s->scale_factor[j][k][1] = scale_table[scale_sum];
+ scale_sum = get_scale(&s->gb, s->audio_header.scalefactor_huffman[j], scale_sum, log_size);
+ s->dca_chan[j].scale_factor[k][1] = scale_table[scale_sum];
}
}
}
/* Joint subband scale factor codebook select */
- for (j = base_channel; j < s->prim_channels; j++) {
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
/* Transmitted only if joint subband coding enabled */
- if (s->joint_intensity[j] > 0)
- s->joint_huff[j] = get_bits(&s->gb, 3);
+ if (s->audio_header.joint_intensity[j] > 0)
+ s->dca_chan[j].joint_huff = get_bits(&s->gb, 3);
}
if (get_bits_left(&s->gb) < 0)
return AVERROR_INVALIDDATA;
/* Scale factors for joint subband coding */
- for (j = base_channel; j < s->prim_channels; j++) {
+ for (j = base_channel; j < s->audio_header.prim_channels; j++) {
int source_channel;
/* Transmitted only if joint subband coding enabled */
- if (s->joint_intensity[j] > 0) {
+ if (s->audio_header.joint_intensity[j] > 0) {
int scale = 0;
- source_channel = s->joint_intensity[j] - 1;
+ source_channel = s->audio_header.joint_intensity[j] - 1;
/* When huffman coded, only the difference is encoded
* (is this valid as well for joint scales ???) */
- for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
- scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
- s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
+ for (k = s->audio_header.subband_activity[j];
+ k < s->audio_header.subband_activity[source_channel]; k++) {
+ scale = get_scale(&s->gb, s->dca_chan[j].joint_huff, 64 /* bias */, 7);
+ s->dca_chan[j].joint_scale_factor[k] = scale; /*joint_scale_table[scale]; */
}
if (!(s->debug_flag & 0x02)) {
}
}
- /* Stereo downmix coefficients */
- if (!base_channel && s->prim_channels > 2) {
- if (s->downmix) {
- for (j = base_channel; j < s->prim_channels; j++) {
- s->downmix_coef[j][0] = get_bits(&s->gb, 7);
- s->downmix_coef[j][1] = get_bits(&s->gb, 7);
- }
- } else {
- int am = s->amode & DCA_CHANNEL_MASK;
- if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
- av_log(s->avctx, AV_LOG_ERROR,
- "Invalid channel mode %d\n", am);
- return AVERROR_INVALIDDATA;
- }
- for (j = base_channel; j < s->prim_channels; j++) {
- s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
- s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
- }
- }
- }
-
/* Dynamic range coefficient */
if (!base_channel && s->dynrange)
s->dynrange_coef = get_bits(&s->gb, 8);
*/
/* VQ encoded high frequency subbands */
- for (j = base_channel; j < s->prim_channels; j++)
- for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
+ for (j = base_channel; j < s->audio_header.prim_channels; j++)
+ for (k = s->audio_header.vq_start_subband[j]; k < s->audio_header.subband_activity[j]; k++)
/* 1 vector -> 32 samples */
- s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
+ s->dca_chan[j].high_freq_vq[k] = get_bits(&s->gb, 10);
/* Low frequency effect data */
if (!base_channel && s->lfe) {
/* LFE samples */
- int lfe_samples = 2 * s->lfe * (4 + block_index);
+ int lfe_samples = 2 * s->lfe * (4 + block_index);
int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
float lfe_scale;
/* Scale factor index */
skip_bits(&s->gb, 1);
- s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
+ s->lfe_scale_factor = ff_dca_scale_factor_quant7[get_bits(&s->gb, 7)];
/* Quantization step size * scale factor */
lfe_scale = 0.035 * s->lfe_scale_factor;
s->lfe_data[j] *= lfe_scale;
}
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
- s->subsubframes[s->current_subframe]);
- av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
- s->partial_samples[s->current_subframe]);
-
- for (j = base_channel; j < s->prim_channels; j++) {
- av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
- for (k = 0; k < s->subband_activity[j]; k++)
- av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
- for (j = base_channel; j < s->prim_channels; j++) {
- for (k = 0; k < s->subband_activity[j]; k++)
- av_log(s->avctx, AV_LOG_DEBUG,
- "prediction coefs: %f, %f, %f, %f\n",
- (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
- (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
- (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
- (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
- }
- for (j = base_channel; j < s->prim_channels; j++) {
- av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
- for (k = 0; k < s->vq_start_subband[j]; k++)
- av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
- for (j = base_channel; j < s->prim_channels; j++) {
- av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
- for (k = 0; k < s->subband_activity[j]; k++)
- av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
- for (j = base_channel; j < s->prim_channels; j++) {
- av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
- for (k = 0; k < s->subband_activity[j]; k++) {
- if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
- av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
- if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
- av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
- }
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
- for (j = base_channel; j < s->prim_channels; j++) {
- if (s->joint_intensity[j] > 0) {
- int source_channel = s->joint_intensity[j] - 1;
- av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
- for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
- av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
- }
- if (!base_channel && s->prim_channels > 2 && s->downmix) {
- av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
- for (j = 0; j < s->prim_channels; j++) {
- av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
- dca_downmix_coeffs[s->downmix_coef[j][0]]);
- av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
- dca_downmix_coeffs[s->downmix_coef[j][1]]);
- }
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
- for (j = base_channel; j < s->prim_channels; j++)
- for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
- av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
- if (!base_channel && s->lfe) {
- int lfe_samples = 2 * s->lfe * (4 + block_index);
- int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
-
- av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
- for (j = lfe_samples; j < lfe_end_sample; j++)
- av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
- av_log(s->avctx, AV_LOG_DEBUG, "\n");
- }
-#endif
-
return 0;
}
static void qmf_32_subbands(DCAContext *s, int chans,
- float samples_in[32][8], float *samples_out,
+ float samples_in[DCA_SUBBANDS][SAMPLES_PER_SUBBAND], float *samples_out,
float scale)
{
const float *prCoeff;
- int i;
- int sb_act = s->subband_activity[chans];
- int subindex;
+ int sb_act = s->audio_header.subband_activity[chans];
scale *= sqrt(1 / 8.0);
/* Select filter */
if (!s->multirate_inter) /* Non-perfect reconstruction */
- prCoeff = fir_32bands_nonperfect;
+ prCoeff = ff_dca_fir_32bands_nonperfect;
else /* Perfect reconstruction */
- prCoeff = fir_32bands_perfect;
-
- for (i = sb_act; i < 32; i++)
- s->raXin[i] = 0.0;
-
- /* Reconstructed channel sample index */
- for (subindex = 0; subindex < 8; subindex++) {
- /* Load in one sample from each subband and clear inactive subbands */
- for (i = 0; i < sb_act; i++) {
- unsigned sign = (i - 1) & 2;
- uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
- AV_WN32A(&s->raXin[i], v);
+ prCoeff = ff_dca_fir_32bands_perfect;
+
+ s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
+ s->dca_chan[chans].subband_fir_hist,
+ &s->dca_chan[chans].hist_index,
+ s->dca_chan[chans].subband_fir_noidea, prCoeff,
+ samples_out, s->raXin, scale);
+}
+
+static QMF64_table *qmf64_precompute(void)
+{
+ unsigned i, j;
+ QMF64_table *table = av_malloc(sizeof(*table));
+ if (!table)
+ return NULL;
+
+ for (i = 0; i < 32; i++)
+ for (j = 0; j < 32; j++)
+ table->dct4_coeff[i][j] = cos((2 * i + 1) * (2 * j + 1) * M_PI / 128);
+ for (i = 0; i < 32; i++)
+ for (j = 0; j < 32; j++)
+ table->dct2_coeff[i][j] = cos((2 * i + 1) * j * M_PI / 64);
+
+ /* FIXME: Is the factor 0.125 = 1/8 right? */
+ for (i = 0; i < 32; i++)
+ table->rcos[i] = 0.125 / cos((2 * i + 1) * M_PI / 256);
+ for (i = 0; i < 32; i++)
+ table->rsin[i] = -0.125 / sin((2 * i + 1) * M_PI / 256);
+
+ return table;
+}
+
+/* FIXME: Totally unoptimized. Based on the reference code and
+ * http://multimedia.cx/mirror/dca-transform.pdf, with guessed tweaks
+ * for doubling the size. */
+static void qmf_64_subbands(DCAContext *s, int chans,
+ float samples_in[DCA_SUBBANDS_X96K][SAMPLES_PER_SUBBAND],
+ float *samples_out, float scale)
+{
+ float raXin[64];
+ float A[32], B[32];
+ float *raX = s->dca_chan[chans].subband_fir_hist;
+ float *raZ = s->dca_chan[chans].subband_fir_noidea;
+ unsigned i, j, k, subindex;
+
+ for (i = s->audio_header.subband_activity[chans]; i < DCA_SUBBANDS_X96K; i++)
+ raXin[i] = 0.0;
+ for (subindex = 0; subindex < SAMPLES_PER_SUBBAND; subindex++) {
+ for (i = 0; i < s->audio_header.subband_activity[chans]; i++)
+ raXin[i] = samples_in[i][subindex];
+
+ for (k = 0; k < 32; k++) {
+ A[k] = 0.0;
+ for (i = 0; i < 32; i++)
+ A[k] += (raXin[2 * i] + raXin[2 * i + 1]) * s->qmf64_table->dct4_coeff[k][i];
+ }
+ for (k = 0; k < 32; k++) {
+ B[k] = raXin[0] * s->qmf64_table->dct2_coeff[k][0];
+ for (i = 1; i < 32; i++)
+ B[k] += (raXin[2 * i] + raXin[2 * i - 1]) * s->qmf64_table->dct2_coeff[k][i];
+ }
+ for (k = 0; k < 32; k++) {
+ raX[k] = s->qmf64_table->rcos[k] * (A[k] + B[k]);
+ raX[63 - k] = s->qmf64_table->rsin[k] * (A[k] - B[k]);
+ }
+
+ for (i = 0; i < DCA_SUBBANDS_X96K; i++) {
+ float out = raZ[i];
+ for (j = 0; j < 1024; j += 128)
+ out += ff_dca_fir_64bands[j + i] * (raX[j + i] - raX[j + 63 - i]);
+ *samples_out++ = out * scale;
+ }
+
+ for (i = 0; i < DCA_SUBBANDS_X96K; i++) {
+ float hist = 0.0;
+ for (j = 0; j < 1024; j += 128)
+ hist += ff_dca_fir_64bands[64 + j + i] * (-raX[i + j] - raX[j + 63 - i]);
+
+ raZ[i] = hist;
}
- s->synth.synth_filter_float(&s->imdct,
- s->subband_fir_hist[chans],
- &s->hist_index[chans],
- s->subband_fir_noidea[chans], prCoeff,
- samples_out, s->raXin, scale);
- samples_out += 32;
+ /* FIXME: Make buffer circular, to avoid this move. */
+ memmove(raX + 64, raX, (1024 - 64) * sizeof(*raX));
}
}
-static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
- int num_deci_sample, float *samples_in,
- float *samples_out, float scale)
+static void lfe_interpolation_fir(DCAContext *s, const float *samples_in,
+ float *samples_out)
{
/* samples_in: An array holding decimated samples.
* Samples in current subframe starts from samples_in[0],
* samples_out: An array holding interpolated samples
*/
- int decifactor;
+ int idx;
const float *prCoeff;
int deciindex;
/* Select decimation filter */
- if (decimation_select == 1) {
- decifactor = 64;
- prCoeff = lfe_fir_128;
+ if (s->lfe == 1) {
+ idx = 1;
+ prCoeff = ff_dca_lfe_fir_128;
} else {
- decifactor = 32;
- prCoeff = lfe_fir_64;
+ idx = 0;
+ if (s->exss_ext_mask & DCA_EXT_EXSS_XLL)
+ prCoeff = ff_dca_lfe_xll_fir_64;
+ else
+ prCoeff = ff_dca_lfe_fir_64;
}
/* Interpolation */
- for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
- s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
+ for (deciindex = 0; deciindex < 2 * s->lfe; deciindex++) {
+ s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);
samples_in++;
- samples_out += 2 * decifactor;
+ samples_out += 2 * 32 * (1 + idx);
}
}
op2 \
}
-static void dca_downmix(float **samples, int srcfmt,
- int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
+static void dca_downmix(float **samples, int srcfmt, int lfe_present,
+ float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
const int8_t *channel_mapping)
{
int c, l, r, sl, sr, s;
int i;
float t, u, v;
- float coef[DCA_PRIM_CHANNELS_MAX][2];
-
- for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
- coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
- coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
- }
switch (srcfmt) {
case DCA_MONO:
- case DCA_CHANNEL:
- case DCA_STEREO_TOTAL:
- case DCA_STEREO_SUMDIFF:
case DCA_4F2R:
av_log(NULL, 0, "Not implemented!\n");
break;
+ case DCA_CHANNEL:
case DCA_STEREO:
+ case DCA_STEREO_TOTAL:
+ case DCA_STEREO_SUMDIFF:
break;
case DCA_3F:
c = channel_mapping[0];
MIX_REAR2(samples, sl, sr, 3, coef));
break;
}
+ if (lfe_present) {
+ int lf_buf = ff_dca_lfe_index[srcfmt];
+ int lf_idx = ff_dca_channels[srcfmt];
+ for (i = 0; i < 256; i++) {
+ samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
+ samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
+ }
+ }
}
-
#ifndef decode_blockcodes
/* Very compact version of the block code decoder that does not use table
* look-up but is slightly slower */
-static int decode_blockcode(int code, int levels, int *values)
+static int decode_blockcode(int code, int levels, int32_t *values)
{
int i;
int offset = (levels - 1) >> 1;
for (i = 0; i < 4; i++) {
int div = FASTDIV(code, levels);
values[i] = code - offset - div * levels;
- code = div;
+ code = div;
}
return code;
}
-static int decode_blockcodes(int code1, int code2, int levels, int *values)
+static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
{
return decode_blockcode(code1, levels, values) |
decode_blockcode(code2, levels, values + 4);
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
-#ifndef int8x8_fmul_int32
-static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
-{
- float fscale = scale / 16.0;
- int i;
- for (i = 0; i < 8; i++)
- dst[i] = src[i] * fscale;
-}
-#endif
-
static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
{
int k, l;
int subsubframe = s->current_subsubframe;
-
- const float *quant_step_table;
-
- /* FIXME */
- float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
- LOCAL_ALIGNED_16(int, block, [8]);
+ const uint32_t *quant_step_table;
/*
* Audio data
/* Select quantization step size table */
if (s->bit_rate_index == 0x1f)
- quant_step_table = lossless_quant_d;
+ quant_step_table = ff_dca_lossless_quant;
else
- quant_step_table = lossy_quant_d;
+ quant_step_table = ff_dca_lossy_quant;
+
+ for (k = base_channel; k < s->audio_header.prim_channels; k++) {
+ int32_t (*subband_samples)[8] = s->dca_chan[k].subband_samples[block_index];
- for (k = base_channel; k < s->prim_channels; k++) {
if (get_bits_left(&s->gb) < 0)
return AVERROR_INVALIDDATA;
- for (l = 0; l < s->vq_start_subband[k]; l++) {
+ for (l = 0; l < s->audio_header.vq_start_subband[k]; l++) {
int m;
/* Select the mid-tread linear quantizer */
- int abits = s->bitalloc[k][l];
-
- float quant_step_size = quant_step_table[abits];
-
- /*
- * Determine quantization index code book and its type
- */
+ int abits = s->dca_chan[k].bitalloc[l];
- /* Select quantization index code book */
- int sel = s->quant_index_huffman[k][abits];
+ uint32_t quant_step_size = quant_step_table[abits];
/*
* Extract bits from the bit stream
*/
- if (!abits) {
- memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
- } else {
+ if (!abits)
+ memset(subband_samples[l], 0, SAMPLES_PER_SUBBAND *
+ sizeof(subband_samples[l][0]));
+ else {
+ uint32_t rscale;
/* Deal with transients */
- int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
- float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
- s->scalefactor_adj[k][sel];
+ int sfi = s->dca_chan[k].transition_mode[l] &&
+ subsubframe >= s->dca_chan[k].transition_mode[l];
+ /* Determine quantization index code book and its type.
+ Select quantization index code book */
+ int sel = s->audio_header.quant_index_huffman[k][abits];
+
+ rscale = (s->dca_chan[k].scale_factor[l][sfi] *
+ s->audio_header.scalefactor_adj[k][sel] + 8) >> 4;
if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
if (abits <= 7) {
block_code1 = get_bits(&s->gb, size);
block_code2 = get_bits(&s->gb, size);
- err = decode_blockcodes(block_code1, block_code2,
- levels, block);
+ err = decode_blockcodes(block_code1, block_code2,
+ levels, subband_samples[l]);
if (err) {
av_log(s->avctx, AV_LOG_ERROR,
"ERROR: block code look-up failed\n");
}
} else {
/* no coding */
- for (m = 0; m < 8; m++)
- block[m] = get_sbits(&s->gb, abits - 3);
+ for (m = 0; m < SAMPLES_PER_SUBBAND; m++)
+ subband_samples[l][m] = get_sbits(&s->gb, abits - 3);
}
} else {
/* Huffman coded */
- for (m = 0; m < 8; m++)
- block[m] = get_bitalloc(&s->gb,
- &dca_smpl_bitalloc[abits], sel);
+ for (m = 0; m < SAMPLES_PER_SUBBAND; m++)
+ subband_samples[l][m] = get_bitalloc(&s->gb,
+ &dca_smpl_bitalloc[abits], sel);
}
-
- s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
- block, rscale, 8);
+ s->dcadsp.dequantize(subband_samples[l], quant_step_size, rscale);
}
+ }
+ for (l = 0; l < s->audio_header.vq_start_subband[k]; l++) {
+ int m;
/*
* Inverse ADPCM if in prediction mode
*/
- if (s->prediction_mode[k][l]) {
+ if (s->dca_chan[k].prediction_mode[l]) {
int n;
- for (m = 0; m < 8; m++) {
- for (n = 1; n <= 4; n++)
+ if (s->predictor_history)
+ subband_samples[l][0] += (ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][0] *
+ (int64_t)s->dca_chan[k].subband_samples_hist[l][3] +
+ ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][1] *
+ (int64_t)s->dca_chan[k].subband_samples_hist[l][2] +
+ ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][2] *
+ (int64_t)s->dca_chan[k].subband_samples_hist[l][1] +
+ ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][3] *
+ (int64_t)s->dca_chan[k].subband_samples_hist[l][0]) +
+ (1 << 12) >> 13;
+ for (m = 1; m < SAMPLES_PER_SUBBAND; m++) {
+ int64_t sum = ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][0] *
+ (int64_t)subband_samples[l][m - 1];
+ for (n = 2; n <= 4; n++)
if (m >= n)
- subband_samples[k][l][m] +=
- (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
- subband_samples[k][l][m - n] / 8192);
+ sum += ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][n - 1] *
+ (int64_t)subband_samples[l][m - n];
else if (s->predictor_history)
- subband_samples[k][l][m] +=
- (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
- s->subband_samples_hist[k][l][m - n + 4] / 8192);
+ sum += ff_dca_adpcm_vb[s->dca_chan[k].prediction_vq[l]][n - 1] *
+ (int64_t)s->dca_chan[k].subband_samples_hist[l][m - n + 4];
+ subband_samples[l][m] += (int32_t)(sum + (1 << 12) >> 13);
}
}
+
}
+ /* Backup predictor history for adpcm */
+ for (l = 0; l < DCA_SUBBANDS; l++)
+ AV_COPY128(s->dca_chan[k].subband_samples_hist[l], &subband_samples[l][4]);
+
/*
* Decode VQ encoded high frequencies
*/
- for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
- /* 1 vector -> 32 samples but we only need the 8 samples
- * for this subsubframe. */
- int hfvq = s->high_freq_vq[k][l];
-
+ if (s->audio_header.subband_activity[k] > s->audio_header.vq_start_subband[k]) {
if (!s->debug_flag & 0x01) {
av_log(s->avctx, AV_LOG_DEBUG,
"Stream with high frequencies VQ coding\n");
s->debug_flag |= 0x01;
}
- int8x8_fmul_int32(subband_samples[k][l],
- &high_freq_vq[hfvq][subsubframe * 8],
- s->scale_factor[k][l][0]);
+ s->dcadsp.decode_hf(subband_samples, s->dca_chan[k].high_freq_vq,
+ ff_dca_high_freq_vq,
+ subsubframe * SAMPLES_PER_SUBBAND,
+ s->dca_chan[k].scale_factor,
+ s->audio_header.vq_start_subband[k],
+ s->audio_header.subband_activity[k]);
}
}
/* Check for DSYNC after subsubframe */
if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
- if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
-#endif
- } else {
+ if (get_bits(&s->gb, 16) != 0xFFFF) {
av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
+ return AVERROR_INVALIDDATA;
}
}
- /* Backup predictor history for adpcm */
- for (k = base_channel; k < s->prim_channels; k++)
- for (l = 0; l < s->vq_start_subband[k]; l++)
- memcpy(s->subband_samples_hist[k][l],
- &subband_samples[k][l][4],
- 4 * sizeof(subband_samples[0][0][0]));
-
return 0;
}
-static int dca_filter_channels(DCAContext *s, int block_index)
+static int dca_filter_channels(DCAContext *s, int block_index, int upsample)
{
- float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
int k;
- /* 32 subbands QMF */
- for (k = 0; k < s->prim_channels; k++) {
-/* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
- 0, 8388608.0, 8388608.0 };*/
- qmf_32_subbands(s, k, subband_samples[k],
- s->samples_chanptr[s->channel_order_tab[k]],
- M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
- }
+ if (upsample) {
+ LOCAL_ALIGNED(32, float, samples, [DCA_SUBBANDS_X96K], [SAMPLES_PER_SUBBAND]);
+
+ if (!s->qmf64_table) {
+ s->qmf64_table = qmf64_precompute();
+ if (!s->qmf64_table)
+ return AVERROR(ENOMEM);
+ }
+
+ /* 64 subbands QMF */
+ for (k = 0; k < s->audio_header.prim_channels; k++) {
+ int32_t (*subband_samples)[SAMPLES_PER_SUBBAND] =
+ s->dca_chan[k].subband_samples[block_index];
+
+ s->fmt_conv.int32_to_float(samples[0], subband_samples[0],
+ DCA_SUBBANDS_X96K * SAMPLES_PER_SUBBAND);
+
+ if (s->channel_order_tab[k] >= 0)
+ qmf_64_subbands(s, k, samples,
+ s->samples_chanptr[s->channel_order_tab[k]],
+ /* Upsampling needs a factor 2 here. */
+ M_SQRT2 / 32768.0);
+ }
+ } else {
+ /* 32 subbands QMF */
+ LOCAL_ALIGNED(32, float, samples, [DCA_SUBBANDS], [SAMPLES_PER_SUBBAND]);
+
+ for (k = 0; k < s->audio_header.prim_channels; k++) {
+ int32_t (*subband_samples)[SAMPLES_PER_SUBBAND] =
+ s->dca_chan[k].subband_samples[block_index];
+
+ s->fmt_conv.int32_to_float(samples[0], subband_samples[0],
+ DCA_SUBBANDS * SAMPLES_PER_SUBBAND);
- /* Down mixing */
- if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
- dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);
+ if (s->channel_order_tab[k] >= 0)
+ qmf_32_subbands(s, k, samples,
+ s->samples_chanptr[s->channel_order_tab[k]],
+ M_SQRT1_2 / 32768.0);
+ }
}
/* Generate LFE samples for this subsubframe FIXME!!! */
- if (s->output & DCA_LFE) {
- lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
+ if (s->lfe) {
+ float *samples = s->samples_chanptr[ff_dca_lfe_index[s->amode]];
+ lfe_interpolation_fir(s,
s->lfe_data + 2 * s->lfe * (block_index + 4),
- s->samples_chanptr[dca_lfe_index[s->amode]],
- 1.0 / (256.0 * 32768.0));
- /* Outputs 20bits pcm samples */
+ samples);
+ if (upsample) {
+ unsigned i;
+ /* Should apply the filter in Table 6-11 when upsampling. For
+ * now, just duplicate. */
+ for (i = 511; i > 0; i--) {
+ samples[2 * i] =
+ samples[2 * i + 1] = samples[i];
+ }
+ samples[1] = samples[0];
+ }
+ }
+
+ /* FIXME: This downmixing is probably broken with upsample.
+ * Probably totally broken also with XLL in general. */
+ /* Downmixing to Stereo */
+ if (s->audio_header.prim_channels + !!s->lfe > 2 &&
+ s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
+ dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
+ s->channel_order_tab);
}
return 0;
}
-
static int dca_subframe_footer(DCAContext *s, int base_channel)
{
- int aux_data_count = 0, i;
+ int in, out, aux_data_count, aux_data_end, reserved;
+ uint32_t nsyncaux;
/*
* Unpack optional information
if (s->timestamp)
skip_bits_long(&s->gb, 32);
- if (s->aux_data)
+ if (s->aux_data) {
aux_data_count = get_bits(&s->gb, 6);
- for (i = 0; i < aux_data_count; i++)
- get_bits(&s->gb, 8);
+ // align (32-bit)
+ skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
+
+ aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
+
+ if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
+ av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",
+ nsyncaux);
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
+ avpriv_request_sample(s->avctx,
+ "Auxiliary Decode Time Stamp Flag");
+ // align (4-bit)
+ skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
+ // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
+ skip_bits_long(&s->gb, 44);
+ }
+
+ if ((s->core_downmix = get_bits1(&s->gb))) {
+ int am = get_bits(&s->gb, 3);
+ switch (am) {
+ case 0:
+ s->core_downmix_amode = DCA_MONO;
+ break;
+ case 1:
+ s->core_downmix_amode = DCA_STEREO;
+ break;
+ case 2:
+ s->core_downmix_amode = DCA_STEREO_TOTAL;
+ break;
+ case 3:
+ s->core_downmix_amode = DCA_3F;
+ break;
+ case 4:
+ s->core_downmix_amode = DCA_2F1R;
+ break;
+ case 5:
+ s->core_downmix_amode = DCA_2F2R;
+ break;
+ case 6:
+ s->core_downmix_amode = DCA_3F1R;
+ break;
+ default:
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Invalid mode %d for embedded downmix coefficients\n",
+ am);
+ return AVERROR_INVALIDDATA;
+ }
+ for (out = 0; out < ff_dca_channels[s->core_downmix_amode]; out++) {
+ for (in = 0; in < s->audio_header.prim_channels + !!s->lfe; in++) {
+ uint16_t tmp = get_bits(&s->gb, 9);
+ if ((tmp & 0xFF) > 241) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Invalid downmix coefficient code %"PRIu16"\n",
+ tmp);
+ return AVERROR_INVALIDDATA;
+ }
+ s->core_downmix_codes[in][out] = tmp;
+ }
+ }
+ }
+
+ align_get_bits(&s->gb); // byte align
+ skip_bits(&s->gb, 16); // nAUXCRC16
+
+ /*
+ * additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
+ *
+ * Note: don't check for overreads, aux_data_count can't be trusted.
+ */
+ if ((reserved = (aux_data_end - get_bits_count(&s->gb))) > 0) {
+ avpriv_request_sample(s->avctx,
+ "Core auxiliary data reserved content");
+ skip_bits_long(&s->gb, reserved);
+ }
+ }
- if (s->crc_present && (s->downmix || s->dynrange))
+ if (s->crc_present && s->dynrange)
get_bits(&s->gb, 16);
}
int ret;
/* Sanity check */
- if (s->current_subframe >= s->subframes) {
+ if (s->current_subframe >= s->audio_header.subframes) {
av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
- s->current_subframe, s->subframes);
+ s->current_subframe, s->audio_header.subframes);
return AVERROR_INVALIDDATA;
}
if (!s->current_subsubframe) {
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
-#endif
/* Read subframe header */
if ((ret = dca_subframe_header(s, base_channel, block_index)))
return ret;
}
/* Read subsubframe */
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
-#endif
if ((ret = dca_subsubframe(s, base_channel, block_index)))
return ret;
s->current_subsubframe = 0;
s->current_subframe++;
}
- if (s->current_subframe >= s->subframes) {
-#ifdef TRACE
- av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
-#endif
+ if (s->current_subframe >= s->audio_header.subframes) {
/* Read subframe footer */
if ((ret = dca_subframe_footer(s, base_channel)))
return ret;
return 0;
}
-/**
- * Return the number of channels in an ExSS speaker mask (HD)
- */
-static int dca_exss_mask2count(int mask)
-{
- /* count bits that mean speaker pairs twice */
- return av_popcount(mask) +
- av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
- DCA_EXSS_FRONT_LEFT_RIGHT |
- DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
- DCA_EXSS_WIDE_LEFT_RIGHT |
- DCA_EXSS_SIDE_LEFT_RIGHT |
- DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
- DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
- DCA_EXSS_REAR_LEFT_RIGHT |
- DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
-}
-
-/**
- * Skip mixing coefficients of a single mix out configuration (HD)
- */
-static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
+static float dca_dmix_code(unsigned code)
{
- int i;
-
- for (i = 0; i < channels; i++) {
- int mix_map_mask = get_bits(gb, out_ch);
- int num_coeffs = av_popcount(mix_map_mask);
- skip_bits_long(gb, num_coeffs * 6);
- }
+ int sign = (code >> 8) - 1;
+ code &= 0xff;
+ return ((ff_dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1U << 15));
}
-/**
- * Parse extension substream asset header (HD)
- */
-static int dca_exss_parse_asset_header(DCAContext *s)
+static int scan_for_extensions(AVCodecContext *avctx)
{
- int header_pos = get_bits_count(&s->gb);
- int header_size;
- int channels;
- int embedded_stereo = 0;
- int embedded_6ch = 0;
- int drc_code_present;
- int extensions_mask;
- int i, j;
-
- if (get_bits_left(&s->gb) < 16)
- return -1;
-
- /* We will parse just enough to get to the extensions bitmask with which
- * we can set the profile value. */
-
- header_size = get_bits(&s->gb, 9) + 1;
- skip_bits(&s->gb, 3); // asset index
-
- if (s->static_fields) {
- if (get_bits1(&s->gb))
- skip_bits(&s->gb, 4); // asset type descriptor
- if (get_bits1(&s->gb))
- skip_bits_long(&s->gb, 24); // language descriptor
-
- if (get_bits1(&s->gb)) {
- /* How can one fit 1024 bytes of text here if the maximum value
- * for the asset header size field above was 512 bytes? */
- int text_length = get_bits(&s->gb, 10) + 1;
- if (get_bits_left(&s->gb) < text_length * 8)
- return -1;
- skip_bits_long(&s->gb, text_length * 8); // info text
- }
-
- skip_bits(&s->gb, 5); // bit resolution - 1
- skip_bits(&s->gb, 4); // max sample rate code
- channels = get_bits(&s->gb, 8) + 1;
-
- if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
- int spkr_remap_sets;
- int spkr_mask_size = 16;
- int num_spkrs[7];
-
- if (channels > 2)
- embedded_stereo = get_bits1(&s->gb);
- if (channels > 6)
- embedded_6ch = get_bits1(&s->gb);
-
- if (get_bits1(&s->gb)) {
- spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
- skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
- }
-
- spkr_remap_sets = get_bits(&s->gb, 3);
-
- for (i = 0; i < spkr_remap_sets; i++) {
- /* std layout mask for each remap set */
- num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
- }
-
- for (i = 0; i < spkr_remap_sets; i++) {
- int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
- if (get_bits_left(&s->gb) < 0)
- return -1;
-
- for (j = 0; j < num_spkrs[i]; j++) {
- int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
- int num_dec_ch = av_popcount(remap_dec_ch_mask);
- skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
- }
- }
-
- } else {
- skip_bits(&s->gb, 3); // representation type
- }
- }
-
- drc_code_present = get_bits1(&s->gb);
- if (drc_code_present)
- get_bits(&s->gb, 8); // drc code
-
- if (get_bits1(&s->gb))
- skip_bits(&s->gb, 5); // dialog normalization code
-
- if (drc_code_present && embedded_stereo)
- get_bits(&s->gb, 8); // drc stereo code
-
- if (s->mix_metadata && get_bits1(&s->gb)) {
- skip_bits(&s->gb, 1); // external mix
- skip_bits(&s->gb, 6); // post mix gain code
-
- if (get_bits(&s->gb, 2) != 3) // mixer drc code
- skip_bits(&s->gb, 3); // drc limit
- else
- skip_bits(&s->gb, 8); // custom drc code
-
- if (get_bits1(&s->gb)) // channel specific scaling
- for (i = 0; i < s->num_mix_configs; i++)
- skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
- else
- skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
-
- for (i = 0; i < s->num_mix_configs; i++) {
- if (get_bits_left(&s->gb) < 0)
- return -1;
- dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
- if (embedded_6ch)
- dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
- if (embedded_stereo)
- dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
- }
- }
-
- switch (get_bits(&s->gb, 2)) {
- case 0: extensions_mask = get_bits(&s->gb, 12); break;
- case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
- case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
- case 3: extensions_mask = 0; /* aux coding */ break;
- }
-
- /* not parsed further, we were only interested in the extensions mask */
-
- if (get_bits_left(&s->gb) < 0)
- return -1;
-
- if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
- av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
- return -1;
- }
- skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
-
- if (extensions_mask & DCA_EXT_EXSS_XLL)
- s->profile = FF_PROFILE_DTS_HD_MA;
- else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
- DCA_EXT_EXSS_XXCH))
- s->profile = FF_PROFILE_DTS_HD_HRA;
-
- if (!(extensions_mask & DCA_EXT_CORE))
- av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
- if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
- av_log(s->avctx, AV_LOG_WARNING,
- "DTS extensions detection mismatch (%d, %d)\n",
- extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
-
- return 0;
-}
-
-/**
- * Parse extension substream header (HD)
- */
-static void dca_exss_parse_header(DCAContext *s)
-{
- int ss_index;
- int blownup;
- int num_audiop = 1;
- int num_assets = 1;
- int active_ss_mask[8];
- int i, j;
-
- if (get_bits_left(&s->gb) < 52)
- return;
-
- skip_bits(&s->gb, 8); // user data
- ss_index = get_bits(&s->gb, 2);
-
- blownup = get_bits1(&s->gb);
- skip_bits(&s->gb, 8 + 4 * blownup); // header_size
- skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
-
- s->static_fields = get_bits1(&s->gb);
- if (s->static_fields) {
- skip_bits(&s->gb, 2); // reference clock code
- skip_bits(&s->gb, 3); // frame duration code
-
- if (get_bits1(&s->gb))
- skip_bits_long(&s->gb, 36); // timestamp
-
- /* a single stream can contain multiple audio assets that can be
- * combined to form multiple audio presentations */
-
- num_audiop = get_bits(&s->gb, 3) + 1;
- if (num_audiop > 1) {
- av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
- /* ignore such streams for now */
- return;
- }
-
- num_assets = get_bits(&s->gb, 3) + 1;
- if (num_assets > 1) {
- av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
- /* ignore such streams for now */
- return;
- }
-
- for (i = 0; i < num_audiop; i++)
- active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
-
- for (i = 0; i < num_audiop; i++)
- for (j = 0; j <= ss_index; j++)
- if (active_ss_mask[i] & (1 << j))
- skip_bits(&s->gb, 8); // active asset mask
-
- s->mix_metadata = get_bits1(&s->gb);
- if (s->mix_metadata) {
- int mix_out_mask_size;
-
- skip_bits(&s->gb, 2); // adjustment level
- mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
- s->num_mix_configs = get_bits(&s->gb, 2) + 1;
-
- for (i = 0; i < s->num_mix_configs; i++) {
- int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
- s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
- }
- }
- }
-
- for (i = 0; i < num_assets; i++)
- skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
-
- for (i = 0; i < num_assets; i++) {
- if (dca_exss_parse_asset_header(s))
- return;
- }
-
- /* not parsed further, we were only interested in the extensions mask
- * from the asset header */
-}
-
-/**
- * Main frame decoding function
- * FIXME add arguments
- */
-static int dca_decode_frame(AVCodecContext *avctx, void *data,
- int *got_frame_ptr, AVPacket *avpkt)
-{
- const uint8_t *buf = avpkt->data;
- int buf_size = avpkt->size;
-
- int lfe_samples;
- int num_core_channels = 0;
- int i, ret;
- float **samples_flt;
DCAContext *s = avctx->priv_data;
- int channels, full_channels;
- int core_ss_end;
-
-
- s->xch_present = 0;
-
- s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
- DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
- if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
- av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
- return AVERROR_INVALIDDATA;
- }
-
- init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
- if ((ret = dca_parse_frame_header(s)) < 0) {
- //seems like the frame is corrupt, try with the next one
- return ret;
- }
- //set AVCodec values with parsed data
- avctx->sample_rate = s->sample_rate;
- avctx->bit_rate = s->bit_rate;
-
- s->profile = FF_PROFILE_DTS;
-
- for (i = 0; i < (s->sample_blocks / 8); i++) {
- if ((ret = dca_decode_block(s, 0, i))) {
- av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
- return ret;
- }
- }
-
- /* record number of core channels incase less than max channels are requested */
- num_core_channels = s->prim_channels;
-
- if (s->ext_coding)
- s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
- else
- s->core_ext_mask = 0;
+ int core_ss_end, ret = 0;
core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
/* only scan for extensions if ext_descr was unknown or indicated a
* supported XCh extension */
if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
-
/* if ext_descr was unknown, clear s->core_ext_mask so that the
* extensions scan can fill it up */
s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
while (core_ss_end - get_bits_count(&s->gb) >= 32) {
uint32_t bits = get_bits_long(&s->gb, 32);
+ int i;
switch (bits) {
- case 0x5a5a5a5a: {
+ case DCA_SYNCWORD_XCH: {
int ext_amode, xch_fsize;
- s->xch_base_channel = s->prim_channels;
+ s->xch_base_channel = s->audio_header.prim_channels;
/* validate sync word using XCHFSIZE field */
xch_fsize = show_bits(&s->gb, 10);
/* extension amode(number of channels in extension) should be 1 */
/* AFAIK XCh is not used for more channels */
if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
- av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
- " supported!\n", ext_amode);
+ av_log(avctx, AV_LOG_ERROR,
+ "XCh extension amode %d not supported!\n",
+ ext_amode);
continue;
}
s->xch_present = 1;
break;
}
- case 0x47004a03:
+ case DCA_SYNCWORD_XXCH:
/* XXCh: extended channels */
/* usually found either in core or HD part in DTS-HD HRA streams,
* but not in DTS-ES which contains XCh extensions instead */
/* check for ExSS (HD part) */
if (s->dca_buffer_size - s->frame_size > 32 &&
- get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
- dca_exss_parse_header(s);
+ get_bits_long(&s->gb, 32) == DCA_SYNCWORD_SUBSTREAM)
+ ff_dca_exss_parse_header(s);
- avctx->profile = s->profile;
+ return ret;
+}
- full_channels = channels = s->prim_channels + !!s->lfe;
+static int set_channel_layout(AVCodecContext *avctx, int channels, int num_core_channels)
+{
+ DCAContext *s = avctx->priv_data;
+ int i;
if (s->amode < 16) {
avctx->channel_layout = dca_core_channel_layout[s->amode];
- if (s->xch_present && (!avctx->request_channels ||
- avctx->request_channels > num_core_channels + !!s->lfe)) {
+ if (s->audio_header.prim_channels + !!s->lfe > 2 &&
+ avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
+ /*
+ * Neither the core's auxiliary data nor our default tables contain
+ * downmix coefficients for the additional channel coded in the XCh
+ * extension, so when we're doing a Stereo downmix, don't decode it.
+ */
+ s->xch_disable = 1;
+ }
+
+ if (s->xch_present && !s->xch_disable) {
avctx->channel_layout |= AV_CH_BACK_CENTER;
if (s->lfe) {
avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
- s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
+ s->channel_order_tab = ff_dca_channel_reorder_lfe_xch[s->amode];
} else {
- s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
+ s->channel_order_tab = ff_dca_channel_reorder_nolfe_xch[s->amode];
}
} else {
- channels = num_core_channels + !!s->lfe;
+ channels = num_core_channels + !!s->lfe;
s->xch_present = 0; /* disable further xch processing */
if (s->lfe) {
avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
- s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
+ s->channel_order_tab = ff_dca_channel_reorder_lfe[s->amode];
} else
- s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
+ s->channel_order_tab = ff_dca_channel_reorder_nolfe[s->amode];
}
if (channels > !!s->lfe &&
s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
return AVERROR_INVALIDDATA;
- if (avctx->request_channels == 2 && s->prim_channels > 2) {
- channels = 2;
- s->output = DCA_STEREO;
+ if (num_core_channels + !!s->lfe > 2 &&
+ avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
+ channels = 2;
+ s->output = s->audio_header.prim_channels == 2 ? s->amode : DCA_STEREO;
avctx->channel_layout = AV_CH_LAYOUT_STEREO;
+
+ /* Stereo downmix coefficients
+ *
+ * The decoder can only downmix to 2-channel, so we need to ensure
+ * embedded downmix coefficients are actually targeting 2-channel.
+ */
+ if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
+ s->core_downmix_amode == DCA_STEREO_TOTAL)) {
+ for (i = 0; i < num_core_channels + !!s->lfe; i++) {
+ /* Range checked earlier */
+ s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);
+ s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);
+ }
+ s->output = s->core_downmix_amode;
+ } else {
+ int am = s->amode & DCA_CHANNEL_MASK;
+ if (am >= FF_ARRAY_ELEMS(ff_dca_default_coeffs)) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Invalid channel mode %d\n", am);
+ return AVERROR_INVALIDDATA;
+ }
+ if (num_core_channels + !!s->lfe >
+ FF_ARRAY_ELEMS(ff_dca_default_coeffs[0])) {
+ avpriv_request_sample(s->avctx, "Downmixing %d channels",
+ s->audio_header.prim_channels + !!s->lfe);
+ return AVERROR_PATCHWELCOME;
+ }
+ for (i = 0; i < num_core_channels + !!s->lfe; i++) {
+ s->downmix_coef[i][0] = ff_dca_default_coeffs[am][i][0];
+ s->downmix_coef[i][1] = ff_dca_default_coeffs[am][i][1];
+ }
+ }
+ ff_dlog(s->avctx, "Stereo downmix coeffs:\n");
+ for (i = 0; i < num_core_channels + !!s->lfe; i++) {
+ ff_dlog(s->avctx, "L, input channel %d = %f\n", i,
+ s->downmix_coef[i][0]);
+ ff_dlog(s->avctx, "R, input channel %d = %f\n", i,
+ s->downmix_coef[i][1]);
+ }
+ ff_dlog(s->avctx, "\n");
}
} else {
- av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
+ av_log(avctx, AV_LOG_ERROR, "Nonstandard configuration %d !\n", s->amode);
return AVERROR_INVALIDDATA;
}
+ return 0;
+}
+
+/**
+ * Main frame decoding function
+ * FIXME add arguments
+ */
+static int dca_decode_frame(AVCodecContext *avctx, void *data,
+ int *got_frame_ptr, AVPacket *avpkt)
+{
+ AVFrame *frame = data;
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
+
+ int lfe_samples;
+ int num_core_channels = 0;
+ int i, ret;
+ float **samples_flt;
+ DCAContext *s = avctx->priv_data;
+ int channels, full_channels;
+ int upsample = 0;
+
+ s->exss_ext_mask = 0;
+ s->xch_present = 0;
+
+ s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
+ DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
+ if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
+ av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
+ return AVERROR_INVALIDDATA;
+ }
- /* There is nothing that prevents a dts frame to change channel configuration
- but Libav doesn't support that so only set the channels if it is previously
- unset. Ideally during the first probe for channels the crc should be checked
- and only set avctx->channels when the crc is ok. Right now the decoder could
- set the channels based on a broken first frame.*/
- if (s->is_channels_set == 0) {
- s->is_channels_set = 1;
- avctx->channels = channels;
+ if ((ret = dca_parse_frame_header(s)) < 0) {
+ // seems like the frame is corrupt, try with the next one
+ return ret;
}
- if (avctx->channels != channels) {
- av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
- "channels changing in stream. Skipping frame.\n");
- return AVERROR_PATCHWELCOME;
+ // set AVCodec values with parsed data
+ avctx->sample_rate = s->sample_rate;
+ avctx->bit_rate = s->bit_rate;
+
+ s->profile = FF_PROFILE_DTS;
+
+ for (i = 0; i < (s->sample_blocks / SAMPLES_PER_SUBBAND); i++) {
+ if ((ret = dca_decode_block(s, 0, i))) {
+ av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
+ return ret;
+ }
}
+ /* record number of core channels incase less than max channels are requested */
+ num_core_channels = s->audio_header.prim_channels;
+
+ if (s->ext_coding)
+ s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
+ else
+ s->core_ext_mask = 0;
+
+ ret = scan_for_extensions(avctx);
+
+ avctx->profile = s->profile;
+
+ full_channels = channels = s->audio_header.prim_channels + !!s->lfe;
+
+ ret = set_channel_layout(avctx, channels, num_core_channels);
+ if (ret < 0)
+ return ret;
+ avctx->channels = channels;
+
/* get output buffer */
- s->frame.nb_samples = 256 * (s->sample_blocks / 8);
- if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
+ frame->nb_samples = 256 * (s->sample_blocks / SAMPLES_PER_SUBBAND);
+ if (s->exss_ext_mask & DCA_EXT_EXSS_XLL) {
+ int xll_nb_samples = s->xll_segments * s->xll_smpl_in_seg;
+ /* Check for invalid/unsupported conditions first */
+ if (s->xll_residual_channels > channels) {
+ av_log(s->avctx, AV_LOG_WARNING,
+ "DCA: too many residual channels (%d, core channels %d). Disabling XLL\n",
+ s->xll_residual_channels, channels);
+ s->exss_ext_mask &= ~DCA_EXT_EXSS_XLL;
+ } else if (xll_nb_samples != frame->nb_samples &&
+ 2 * frame->nb_samples != xll_nb_samples) {
+ av_log(s->avctx, AV_LOG_WARNING,
+ "DCA: unsupported upsampling (%d XLL samples, %d core samples). Disabling XLL\n",
+ xll_nb_samples, frame->nb_samples);
+ s->exss_ext_mask &= ~DCA_EXT_EXSS_XLL;
+ } else {
+ if (2 * frame->nb_samples == xll_nb_samples) {
+ av_log(s->avctx, AV_LOG_INFO,
+ "XLL: upsampling core channels by a factor of 2\n");
+ upsample = 1;
+
+ frame->nb_samples = xll_nb_samples;
+ // FIXME: Is it good enough to copy from the first channel set?
+ avctx->sample_rate = s->xll_chsets[0].sampling_frequency;
+ }
+ /* If downmixing to stereo, don't decode additional channels.
+ * FIXME: Using the xch_disable flag for this doesn't seem right. */
+ if (!s->xch_disable)
+ avctx->channels += s->xll_channels - s->xll_residual_channels;
+ }
+ }
+
+ /* FIXME: This is an ugly hack, to just revert to the default
+ * layout if we have additional channels. Need to convert the XLL
+ * channel masks to libav channel_layout mask. */
+ if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels)
+ avctx->channel_layout = 0;
+
+ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
- samples_flt = (float **) s->frame.extended_data;
+ samples_flt = (float **) frame->extended_data;
/* allocate buffer for extra channels if downmixing */
if (avctx->channels < full_channels) {
ret = av_samples_get_buffer_size(NULL, full_channels - channels,
- s->frame.nb_samples,
+ frame->nb_samples,
avctx->sample_fmt, 0);
if (ret < 0)
return ret;
if (!s->extra_channels_buffer)
return AVERROR(ENOMEM);
- ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
+ ret = av_samples_fill_arrays((uint8_t **) s->extra_channels, NULL,
s->extra_channels_buffer,
full_channels - channels,
- s->frame.nb_samples, avctx->sample_fmt, 0);
+ frame->nb_samples, avctx->sample_fmt, 0);
if (ret < 0)
return ret;
}
/* filter to get final output */
- for (i = 0; i < (s->sample_blocks / 8); i++) {
+ for (i = 0; i < (s->sample_blocks / SAMPLES_PER_SUBBAND); i++) {
int ch;
-
+ unsigned block = upsample ? 512 : 256;
for (ch = 0; ch < channels; ch++)
- s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
+ s->samples_chanptr[ch] = samples_flt[ch] + i * block;
for (; ch < full_channels; ch++)
- s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
+ s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * block;
- dca_filter_channels(s, i);
+ dca_filter_channels(s, i, upsample);
/* If this was marked as a DTS-ES stream we need to subtract back- */
/* channel from SL & SR to remove matrixed back-channel signal */
}
/* update lfe history */
- lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
+ lfe_samples = 2 * s->lfe * (s->sample_blocks / SAMPLES_PER_SUBBAND);
for (i = 0; i < 2 * s->lfe * 4; i++)
s->lfe_data[i] = s->lfe_data[i + lfe_samples];
- *got_frame_ptr = 1;
- *(AVFrame *) data = s->frame;
+ if (s->exss_ext_mask & DCA_EXT_EXSS_XLL) {
+ ret = ff_dca_xll_decode_audio(s, frame);
+ if (ret < 0)
+ return ret;
+ }
+ /* AVMatrixEncoding
+ *
+ * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */
+ ret = ff_side_data_update_matrix_encoding(frame,
+ (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ?
+ AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE);
+ if (ret < 0)
+ return ret;
+
+ *got_frame_ptr = 1;
return buf_size;
}
-
-
/**
* DCA initialization
*
s->avctx = avctx;
dca_init_vlcs();
- avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
+ avpriv_float_dsp_init(&s->fdsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
ff_mdct_init(&s->imdct, 6, 1, 1.0);
ff_synth_filter_init(&s->synth);
ff_dcadsp_init(&s->dcadsp);
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
/* allow downmixing to stereo */
- if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
- avctx->request_channels == 2) {
- avctx->channels = avctx->request_channels;
- }
-
- avcodec_get_frame_defaults(&s->frame);
- avctx->coded_frame = &s->frame;
+ if (avctx->channels > 2 &&
+ avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
+ avctx->channels = 2;
return 0;
}
DCAContext *s = avctx->priv_data;
ff_mdct_end(&s->imdct);
av_freep(&s->extra_channels_buffer);
+ av_freep(&s->xll_sample_buf);
+ av_freep(&s->qmf64_table);
return 0;
}
-static const AVProfile profiles[] = {
- { FF_PROFILE_DTS, "DTS" },
- { FF_PROFILE_DTS_ES, "DTS-ES" },
- { FF_PROFILE_DTS_96_24, "DTS 96/24" },
- { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
- { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
- { FF_PROFILE_UNKNOWN },
+static const AVOption options[] = {
+ { "disable_xch", "disable decoding of the XCh extension", offsetof(DCAContext, xch_disable), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
+ { "disable_xll", "disable decoding of the XLL extension", offsetof(DCAContext, xll_disable), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
+ { NULL },
+};
+
+static const AVClass dca_decoder_class = {
+ .class_name = "DCA decoder",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
};
AVCodec ff_dca_decoder = {
.name = "dca",
+ .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_DTS,
.priv_data_size = sizeof(DCAContext),
.init = dca_decode_init,
.decode = dca_decode_frame,
.close = dca_decode_end,
- .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
- .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
+ .capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
AV_SAMPLE_FMT_NONE },
- .profiles = NULL_IF_CONFIG_SMALL(profiles),
+ .profiles = NULL_IF_CONFIG_SMALL(ff_dca_profiles),
+ .priv_class = &dca_decoder_class,
};
projects / ffmpeg / blobdiff