X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fdca.c;h=073b1c2386aaf2995012fa86323ebf962589b355;hb=d0a188501899a5aa613a950354caa9e15cb3ea35;hp=c3ade2f0427f9bf2ff7b133e7e5fedb4f8c2ca09;hpb=98c98e04ccae75ccaf0f3ebf18588bc0090dff8b;p=ffmpeg diff --git a/libavcodec/dca.c b/libavcodec/dca.c index c3ade2f0427..073b1c2386a 100644 --- a/libavcodec/dca.c +++ b/libavcodec/dca.c @@ -22,27 +22,31 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -/** - * @file dca.c - */ - #include #include #include +#include "libavutil/intmath.h" +#include "libavutil/intreadwrite.h" #include "avcodec.h" #include "dsputil.h" -#include "bitstream.h" +#include "fft.h" +#include "get_bits.h" +#include "put_bits.h" #include "dcadata.h" #include "dcahuff.h" #include "dca.h" +#include "synth_filter.h" +#include "dcadsp.h" //#define TRACE -#define DCA_PRIM_CHANNELS_MAX (5) +#define DCA_PRIM_CHANNELS_MAX (7) #define DCA_SUBBANDS (32) #define DCA_ABITS_MAX (32) /* Should be 28 */ -#define DCA_SUBSUBFAMES_MAX (4) +#define DCA_SUBSUBFRAMES_MAX (4) +#define DCA_SUBFRAMES_MAX (16) +#define DCA_BLOCKS_MAX (16) #define DCA_LFE_MAX (3) enum DCAMode { @@ -59,6 +63,115 @@ enum DCAMode { DCA_4F2R }; +/* 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. + * + * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead. + * S -> side, when both rear and back are configured move one of them to the side channel + * OV -> center back + * All 2 channel configurations -> CH_LAYOUT_STEREO + */ + +static const int64_t dca_core_channel_layout[] = { + CH_FRONT_CENTER, ///< 1, A + CH_LAYOUT_STEREO, ///< 2, A + B (dual mono) + CH_LAYOUT_STEREO, ///< 2, L + R (stereo) + CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference) + CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total) + CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R + CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S + CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S + CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR + CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR + CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR + CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV + CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR + CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR + CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2 + CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|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 @@ -67,9 +180,8 @@ enum DCAMode { #define DCA_LFE 0x80 #define HEADER_SIZE 14 -#define CONVERT_BIAS 384 -#define DCA_MAX_FRAME_SIZE 16383 +#define DCA_MAX_FRAME_SIZE 16384 /** Bit allocation */ typedef struct { @@ -84,10 +196,7 @@ static BitAlloc dca_tmode; ///< transition mode VLCs static BitAlloc dca_scalefactor; ///< scalefactor VLCs static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs -/** Pre-calculated cosine modulation coefs for the QMF */ -static float cos_mod[544]; - -static int av_always_inline get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx) +static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx) { return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset; } @@ -103,6 +212,7 @@ typedef struct { 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 @@ -125,6 +235,7 @@ typedef struct { /* Primary audio coding header */ int subframes; ///< number of subframes + 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 @@ -136,8 +247,8 @@ typedef struct { float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment /* Primary audio coding side information */ - int subsubframes; ///< number of subsubframes - int partial_samples; ///< partial subsubframe samples count + 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 @@ -150,71 +261,104 @@ typedef struct { int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands - float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX * - 2 /*history */ ]; ///< Low frequency effect data + float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data int lfe_scale_factor; /* Subband samples history (for ADPCM) */ float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4]; - float subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]; - float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][64]; + DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512]; + DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32]; + int hist_index[DCA_PRIM_CHANNELS_MAX]; + DECLARE_ALIGNED(16, float, raXin)[32]; int output; ///< type of output - int bias; ///< output bias + float add_bias; ///< output bias + float scale_bias; ///< output scale - DECLARE_ALIGNED_16(float, samples[1536]); /* 6 * 256 = 1536, might only need 5 */ - DECLARE_ALIGNED_16(int16_t, tsamples[1536]); + DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8]; + DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256]; + const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1]; uint8_t dca_buffer[DCA_MAX_FRAME_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; + /* XCh extension information */ + int xch_present; + int xch_base_channel; ///< index of first (only) channel containing XCH data + int debug_flag; ///< used for suppressing repeated error messages output DSPContext dsp; + FFTContext imdct; + SynthFilterContext synth; + DCADSPContext dcadsp; } DCAContext; -static void dca_init_vlcs(void) +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_inited = 0; - int i, j; + static int vlcs_initialized = 0; + int i, j, c = 14; + static VLC_TYPE dca_table[23622][2]; - if (vlcs_inited) + if (vlcs_initialized) return; dca_bitalloc_index.offset = 1; - dca_bitalloc_index.wrap = 1; - for (i = 0; i < 5; i++) + 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]; 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, 1); + bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); + } dca_scalefactor.offset = -64; dca_scalefactor.wrap = 2; - for (i = 0; i < 5; i++) + 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]; init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129, scales_bits[i], 1, 1, - scales_codes[i], 2, 2, 1); + scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); + } dca_tmode.offset = 0; dca_tmode.wrap = 1; - for (i = 0; i < 4; i++) + 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]; init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4, tmode_bits[i], 1, 1, - tmode_codes[i], 2, 2, 1); + tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); + } - for(i = 0; i < 10; i++) - for(j = 0; j < 7; j++){ - if(!bitalloc_codes[i][j]) break; + for (i = 0; i < 10; i++) + for (j = 0; j < 7; j++){ + if (!bitalloc_codes[i][j]) 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]; init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j], bitalloc_sizes[i], bitalloc_bits[i][j], 1, 1, - bitalloc_codes[i][j], 2, 2, 1); + bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC); + c++; } - vlcs_inited = 1; + vlcs_initialized = 1; } static inline void get_array(GetBitContext *gb, int *dst, int len, int bits) @@ -223,15 +367,87 @@ static inline void get_array(GetBitContext *gb, int *dst, int len, int bits) *dst++ = get_bits(gb, bits); } -static int dca_parse_frame_header(DCAContext * s) +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 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->bias = CONVERT_BIAS; + 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; + + + 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->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; + } + 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 codebooks quantization indexes */ + if (!base_channel) + memset(s->quant_index_huffman, 0, sizeof(s->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]); + + /* 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 (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)]; + + if (s->crc_present) { + /* Audio header CRC check */ + get_bits(&s->gb, 16); + } + + 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; +} + +static int dca_parse_frame_header(DCAContext * s) +{ init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8); /* Sync code */ @@ -249,7 +465,8 @@ static int dca_parse_frame_header(DCAContext * s) s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)]; if (!s->sample_rate) return -1; - s->bit_rate = dca_bit_rates[get_bits(&s->gb, 5)]; + s->bit_rate_index = get_bits(&s->gb, 5); + s->bit_rate = dca_bit_rates[s->bit_rate_index]; if (!s->bit_rate) return -1; @@ -278,7 +495,7 @@ static int dca_parse_frame_header(DCAContext * s) /* FIXME: channels mixing levels */ s->output = s->amode; - if(s->lfe) s->output |= DCA_LFE; + if (s->lfe) s->output |= DCA_LFE; #ifdef TRACE av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type); @@ -289,10 +506,10 @@ static int dca_parse_frame_header(DCAContext * s) 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 (%i Hz)\n", - s->sample_rate, dca_sample_rates[s->sample_rate]); - av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i (%i bits/s)\n", - s->bit_rate, dca_bit_rates[s->bit_rate]); + 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); @@ -320,71 +537,8 @@ static int dca_parse_frame_header(DCAContext * s) /* Primary audio coding header */ s->subframes = get_bits(&s->gb, 4) + 1; - s->prim_channels = get_bits(&s->gb, 3) + 1; - - - for (i = 0; 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 = 0; 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; - } - get_array(&s->gb, s->joint_intensity, s->prim_channels, 3); - get_array(&s->gb, s->transient_huffman, s->prim_channels, 2); - get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3); - get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3); - - /* Get codebooks quantization indexes */ - memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman)); - for (j = 1; j < 11; j++) - for (i = 0; i < s->prim_channels; i++) - s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]); - - /* Get scale factor adjustment */ - for (j = 0; j < 11; j++) - for (i = 0; i < s->prim_channels; i++) - s->scalefactor_adj[i][j] = 1; - - for (j = 1; j < 11; j++) - for (i = 0; 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)]; - - if (s->crc_present) { - /* Audio header CRC check */ - get_bits(&s->gb, 16); - } - - 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 = 0; 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; + return dca_parse_audio_coding_header(s, 0); } @@ -393,25 +547,28 @@ static inline int get_scale(GetBitContext *gb, int level, int value) if (level < 5) { /* huffman encoded */ value += get_bitalloc(gb, &dca_scalefactor, level); - } else if(level < 8) + } else if (level < 8) value = get_bits(gb, level + 1); return value; } -static int dca_subframe_header(DCAContext * s) +static int dca_subframe_header(DCAContext * s, int base_channel, int block_index) { /* Primary audio coding side information */ int j, k; - s->subsubframes = get_bits(&s->gb, 2) + 1; - s->partial_samples = get_bits(&s->gb, 3); - for (j = 0; j < s->prim_channels; j++) { + if (!base_channel) { + s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1; + 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); } /* Get prediction codebook */ - for (j = 0; j < s->prim_channels; j++) { + 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) { /* (Prediction coefficient VQ address) */ @@ -421,13 +578,17 @@ static int dca_subframe_header(DCAContext * s) } /* Bit allocation index */ - for (j = 0; j < s->prim_channels; j++) { + 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 { + else if (s->bitalloc_huffman[j] == 7) { + av_log(s->avctx, AV_LOG_ERROR, + "Invalid bit allocation index\n"); + return -1; + } else { s->bitalloc[j][k] = get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]); } @@ -441,10 +602,10 @@ static int dca_subframe_header(DCAContext * s) } /* Transition mode */ - for (j = 0; j < s->prim_channels; j++) { + for (j = base_channel; j < s->prim_channels; j++) { for (k = 0; k < s->subband_activity[j]; k++) { s->transition_mode[j][k] = 0; - if (s->subsubframes > 1 && + 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]); @@ -452,16 +613,16 @@ static int dca_subframe_header(DCAContext * s) } } - for (j = 0; j < s->prim_channels; j++) { - uint32_t *scale_table; + for (j = base_channel; j < s->prim_channels; j++) { + const uint32_t *scale_table; int scale_sum; memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2); if (s->scalefactor_huffman[j] == 6) - scale_table = (uint32_t *) scale_factor_quant7; + scale_table = scale_factor_quant7; else - scale_table = (uint32_t *) scale_factor_quant6; + scale_table = scale_factor_quant6; /* When huffman coded, only the difference is encoded */ scale_sum = 0; @@ -481,14 +642,14 @@ static int dca_subframe_header(DCAContext * s) } /* Joint subband scale factor codebook select */ - for (j = 0; j < s->prim_channels; j++) { + for (j = base_channel; j < s->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); } /* Scale factors for joint subband coding */ - for (j = 0; j < s->prim_channels; j++) { + for (j = base_channel; j < s->prim_channels; j++) { int source_channel; /* Transmitted only if joint subband coding enabled */ @@ -505,7 +666,7 @@ static int dca_subframe_header(DCAContext * s) s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */ } - if (!s->debug_flag & 0x02) { + if (!(s->debug_flag & 0x02)) { av_log(s->avctx, AV_LOG_DEBUG, "Joint stereo coding not supported\n"); s->debug_flag |= 0x02; @@ -514,15 +675,15 @@ static int dca_subframe_header(DCAContext * s) } /* Stereo downmix coefficients */ - if (s->prim_channels > 2) { - if(s->downmix) { - for (j = 0; j < s->prim_channels; j++) { + 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; - for (j = 0; j < s->prim_channels; j++) { + 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]; } @@ -543,18 +704,19 @@ static int dca_subframe_header(DCAContext * s) */ /* VQ encoded high frequency subbands */ - for (j = 0; j < s->prim_channels; j++) + for (j = base_channel; j < s->prim_channels; j++) for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++) /* 1 vector -> 32 samples */ s->high_freq_vq[j][k] = get_bits(&s->gb, 10); /* Low frequency effect data */ - if (s->lfe) { + if (!base_channel && s->lfe) { /* LFE samples */ - int lfe_samples = 2 * s->lfe * s->subsubframes; + 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; - for (j = lfe_samples; j < lfe_samples * 2; j++) { + for (j = lfe_samples; j < lfe_end_sample; j++) { /* Signed 8 bits int */ s->lfe_data[j] = get_sbits(&s->gb, 8); } @@ -565,21 +727,21 @@ static int dca_subframe_header(DCAContext * s) /* Quantization step size * scale factor */ lfe_scale = 0.035 * s->lfe_scale_factor; - for (j = lfe_samples; j < lfe_samples * 2; j++) + for (j = lfe_samples; j < lfe_end_sample; j++) s->lfe_data[j] *= lfe_scale; } #ifdef TRACE - av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes); + 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); - for (j = 0; j < s->prim_channels; j++) { + 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 = 0; j < s->prim_channels; j++) { + 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", @@ -588,19 +750,19 @@ static int dca_subframe_header(DCAContext * s) (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192, (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192); } - for (j = 0; j < s->prim_channels; j++) { + 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 = 0; j < s->prim_channels; j++) { + 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 = 0; j < s->prim_channels; j++) { + 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) @@ -610,15 +772,16 @@ static int dca_subframe_header(DCAContext * s) } av_log(s->avctx, AV_LOG_DEBUG, "\n"); } - for (j = 0; j < s->prim_channels; j++) { + 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 (s->prim_channels > 2 && s->downmix) { + 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]]); @@ -626,12 +789,15 @@ static int dca_subframe_header(DCAContext * s) } av_log(s->avctx, AV_LOG_DEBUG, "\n"); } - for (j = 0; j < s->prim_channels; j++) + 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(s->lfe){ + 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_samples * 2; j++) + 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"); } @@ -644,72 +810,40 @@ static void qmf_32_subbands(DCAContext * s, int chans, float samples_in[32][8], float *samples_out, float scale, float bias) { - float *prCoeff; - int i, j, k; - float praXin[33], *raXin = &praXin[1]; - - float *subband_fir_hist = s->subband_fir_hist[chans]; - float *subband_fir_hist2 = s->subband_fir_noidea[chans]; + const float *prCoeff; + int i; - int chindex = 0, subindex; + int sb_act = s->subband_activity[chans]; + int subindex; - praXin[0] = 0.0; + scale *= sqrt(1/8.0); /* Select filter */ if (!s->multirate_inter) /* Non-perfect reconstruction */ - prCoeff = (float *) fir_32bands_nonperfect; + prCoeff = fir_32bands_nonperfect; else /* Perfect reconstruction */ - prCoeff = (float *) fir_32bands_perfect; + prCoeff = fir_32bands_perfect; /* Reconstructed channel sample index */ for (subindex = 0; subindex < 8; subindex++) { - float t1, t2, sum[16], diff[16]; - /* Load in one sample from each subband and clear inactive subbands */ - for (i = 0; i < s->subband_activity[chans]; i++) - raXin[i] = samples_in[i][subindex]; - for (; i < 32; i++) - raXin[i] = 0.0; - - /* Multiply by cosine modulation coefficients and - * create temporary arrays SUM and DIFF */ - for (j = 0, k = 0; k < 16; k++) { - t1 = 0.0; - t2 = 0.0; - for (i = 0; i < 16; i++, j++){ - t1 += (raXin[2 * i] + raXin[2 * i + 1]) * cos_mod[j]; - t2 += (raXin[2 * i] + raXin[2 * i - 1]) * cos_mod[j + 256]; - } - sum[k] = t1 + t2; - diff[k] = t1 - t2; + for (i = 0; i < sb_act; i++){ + uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30; + AV_WN32A(&s->raXin[i], v); } + for (; i < 32; i++) + s->raXin[i] = 0.0; - j = 512; - /* Store history */ - for (k = 0; k < 16; k++) - subband_fir_hist[k] = cos_mod[j++] * sum[k]; - for (k = 0; k < 16; k++) - subband_fir_hist[32-k-1] = cos_mod[j++] * diff[k]; - - /* Multiply by filter coefficients */ - for (k = 31, i = 0; i < 32; i++, k--) - for (j = 0; j < 512; j += 64){ - subband_fir_hist2[i] += prCoeff[i+j] * ( subband_fir_hist[i+j] - subband_fir_hist[j+k]); - subband_fir_hist2[i+32] += prCoeff[i+j+32]*(-subband_fir_hist[i+j] - subband_fir_hist[j+k]); - } - - /* Create 32 PCM output samples */ - for (i = 0; i < 32; i++) - samples_out[chindex++] = subband_fir_hist2[i] * scale + bias; + 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, bias); + samples_out+= 32; - /* Update working arrays */ - memmove(&subband_fir_hist[32], &subband_fir_hist[0], (512 - 32) * sizeof(float)); - memmove(&subband_fir_hist2[0], &subband_fir_hist2[32], 32 * sizeof(float)); - memset(&subband_fir_hist2[32], 0, 32 * sizeof(float)); } } -static void lfe_interpolation_fir(int decimation_select, +static void lfe_interpolation_fir(DCAContext *s, int decimation_select, int num_deci_sample, float *samples_in, float *samples_out, float scale, float bias) @@ -722,30 +856,24 @@ static void lfe_interpolation_fir(int decimation_select, * samples_out: An array holding interpolated samples */ - int decifactor, k, j; + int decifactor; const float *prCoeff; - - int interp_index = 0; /* Index to the interpolated samples */ int deciindex; /* Select decimation filter */ if (decimation_select == 1) { - decifactor = 128; + decifactor = 64; prCoeff = lfe_fir_128; } else { - decifactor = 64; + decifactor = 32; prCoeff = lfe_fir_64; } /* Interpolation */ for (deciindex = 0; deciindex < num_deci_sample; deciindex++) { - /* One decimated sample generates decifactor interpolated ones */ - for (k = 0; k < decifactor; k++) { - float rTmp = 0.0; - //FIXME the coeffs are symetric, fix that - for (j = 0; j < 512 / decifactor; j++) - rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor]; - samples_out[interp_index++] = rTmp / scale + bias; - } + s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, + scale, bias); + samples_in++; + samples_out += 2 * decifactor; } } @@ -764,7 +892,7 @@ static void lfe_interpolation_fir(int decimation_select, samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1]; #define DOWNMIX_TO_STEREO(op1, op2) \ - for(i = 0; i < 256; i++){ \ + for (i = 0; i < 256; i++){ \ op1 \ op2 \ } @@ -776,7 +904,7 @@ static void dca_downmix(float *samples, int srcfmt, float t; float coef[DCA_PRIM_CHANNELS_MAX][2]; - for(i=0; i> 1; for (i = 0; i < 4; i++) { - values[i] = (code % levels) - offset; - code /= levels; + int div = FASTDIV(code, levels); + values[i] = code - offset - div*levels; + code = div; } if (code == 0) @@ -835,27 +964,28 @@ static int decode_blockcode(int code, int levels, int *values) 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 }; -static int dca_subsubframe(DCAContext * s) +static int dca_subsubframe(DCAContext * s, int base_channel, int block_index) { int k, l; int subsubframe = s->current_subsubframe; - float *quant_step_table; + const float *quant_step_table; /* FIXME */ - float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8]; + float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index]; + LOCAL_ALIGNED_16(int, block, [8]); /* * Audio data */ /* Select quantization step size table */ - if (s->bit_rate == 0x1f) - quant_step_table = (float *) lossless_quant_d; + if (s->bit_rate_index == 0x1f) + quant_step_table = lossless_quant_d; else - quant_step_table = (float *) lossy_quant_d; + quant_step_table = lossy_quant_d; - for (k = 0; k < s->prim_channels; k++) { + for (k = base_channel; k < s->prim_channels; k++) { for (l = 0; l < s->vq_start_subband[k]; l++) { int m; @@ -863,7 +993,6 @@ static int dca_subsubframe(DCAContext * s) int abits = s->bitalloc[k][l]; float quant_step_size = quant_step_table[abits]; - float rscale; /* * Determine quantization index code book and its type @@ -875,46 +1004,40 @@ static int dca_subsubframe(DCAContext * s) /* * Extract bits from the bit stream */ - if(!abits){ + if (!abits){ memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0])); - }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){ - if(abits <= 7){ - /* Block code */ - int block_code1, block_code2, size, levels; - int block[8]; - - size = abits_sizes[abits-1]; - levels = abits_levels[abits-1]; - - block_code1 = get_bits(&s->gb, size); - /* FIXME Should test return value */ - decode_blockcode(block_code1, levels, block); - block_code2 = get_bits(&s->gb, size); - decode_blockcode(block_code2, levels, &block[4]); - for (m = 0; m < 8; m++) - subband_samples[k][l][m] = block[m]; + } else { + /* 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]; + + if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){ + if (abits <= 7){ + /* Block code */ + int block_code1, block_code2, size, levels; + + size = abits_sizes[abits-1]; + levels = abits_levels[abits-1]; + + block_code1 = get_bits(&s->gb, size); + /* FIXME Should test return value */ + decode_blockcode(block_code1, levels, block); + block_code2 = get_bits(&s->gb, size); + decode_blockcode(block_code2, levels, &block[4]); + }else{ + /* no coding */ + for (m = 0; m < 8; m++) + block[m] = get_sbits(&s->gb, abits - 3); + } }else{ - /* no coding */ + /* Huffman coded */ for (m = 0; m < 8; m++) - subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3); + block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel); } - }else{ - /* Huffman coded */ - for (m = 0; m < 8; m++) - subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel); - } - - /* Deal with transients */ - if (s->transition_mode[k][l] && - subsubframe >= s->transition_mode[k][l]) - rscale = quant_step_size * s->scale_factor[k][l][1]; - else - rscale = quant_step_size * s->scale_factor[k][l][0]; - rscale *= s->scalefactor_adj[k][sel]; - - for (m = 0; m < 8; m++) - subband_samples[k][l][m] *= rscale; + s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l], + block, rscale, 8); + } /* * Inverse ADPCM if in prediction mode @@ -959,7 +1082,7 @@ static int dca_subsubframe(DCAContext * s) } /* Check for DSYNC after subsubframe */ - if (s->aspf || subsubframe == s->subsubframes - 1) { + 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"); @@ -970,36 +1093,39 @@ static int dca_subsubframe(DCAContext * s) } /* Backup predictor history for adpcm */ - for (k = 0; k < s->prim_channels; k++) + 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) +{ + 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[256 * k], - 2.0 / 3 /*pcm_to_double[s->source_pcm_res] */ , - 0 /*s->bias */ ); + qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]], + M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ , + s->add_bias ); } /* Down mixing */ - - if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) { + if (s->avctx->request_channels == 2 && s->prim_channels > 2) { dca_downmix(s->samples, s->amode, s->downmix_coef); } /* Generate LFE samples for this subsubframe FIXME!!! */ if (s->output & DCA_LFE) { - int lfe_samples = 2 * s->lfe * s->subsubframes; - int i_channels = dca_channels[s->output & DCA_CHANNEL_MASK]; - - lfe_interpolation_fir(s->lfe, 2 * s->lfe, - s->lfe_data + lfe_samples + - 2 * s->lfe * subsubframe, - &s->samples[256 * i_channels], - 8388608.0, s->bias); + lfe_interpolation_fir(s, s->lfe, 2 * s->lfe, + s->lfe_data + 2 * s->lfe * (block_index + 4), + &s->samples[256 * dca_lfe_index[s->amode]], + (1.0/256.0)*s->scale_bias, s->add_bias); /* Outputs 20bits pcm samples */ } @@ -1007,30 +1133,27 @@ static int dca_subsubframe(DCAContext * s) } -static int dca_subframe_footer(DCAContext * s) +static int dca_subframe_footer(DCAContext * s, int base_channel) { int aux_data_count = 0, i; - int lfe_samples; /* * Unpack optional information */ - if (s->timestamp) - get_bits(&s->gb, 32); - - if (s->aux_data) - aux_data_count = get_bits(&s->gb, 6); + /* presumably optional information only appears in the core? */ + if (!base_channel) { + if (s->timestamp) + get_bits(&s->gb, 32); - for (i = 0; i < aux_data_count; i++) - get_bits(&s->gb, 8); + if (s->aux_data) + aux_data_count = get_bits(&s->gb, 6); - if (s->crc_present && (s->downmix || s->dynrange)) - get_bits(&s->gb, 16); + for (i = 0; i < aux_data_count; i++) + get_bits(&s->gb, 8); - lfe_samples = 2 * s->lfe * s->subsubframes; - for (i = 0; i < lfe_samples; i++) { - s->lfe_data[i] = s->lfe_data[i + lfe_samples]; + if (s->crc_present && (s->downmix || s->dynrange)) + get_bits(&s->gb, 16); } return 0; @@ -1042,7 +1165,7 @@ static int dca_subframe_footer(DCAContext * s) * @param s pointer to the DCAContext */ -static int dca_decode_block(DCAContext * s) +static int dca_decode_block(DCAContext * s, int base_channel, int block_index) { /* Sanity check */ @@ -1057,7 +1180,7 @@ static int dca_decode_block(DCAContext * s) av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n"); #endif /* Read subframe header */ - if (dca_subframe_header(s)) + if (dca_subframe_header(s, base_channel, block_index)) return -1; } @@ -1065,12 +1188,12 @@ static int dca_decode_block(DCAContext * s) #ifdef TRACE av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n"); #endif - if (dca_subsubframe(s)) + if (dca_subsubframe(s, base_channel, block_index)) return -1; /* Update state */ s->current_subsubframe++; - if (s->current_subsubframe >= s->subsubframes) { + if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) { s->current_subsubframe = 0; s->current_subframe++; } @@ -1079,7 +1202,7 @@ static int dca_decode_block(DCAContext * s) av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n"); #endif /* Read subframe footer */ - if (dca_subframe_footer(s)) + if (dca_subframe_footer(s, base_channel)) return -1; } @@ -1089,26 +1212,30 @@ static int dca_decode_block(DCAContext * s) /** * Convert bitstream to one representation based on sync marker */ -static int dca_convert_bitstream(uint8_t * src, int src_size, uint8_t * dst, +static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst, int max_size) { uint32_t mrk; int i, tmp; - uint16_t *ssrc = (uint16_t *) src, *sdst = (uint16_t *) dst; + const uint16_t *ssrc = (const uint16_t *) src; + uint16_t *sdst = (uint16_t *) dst; PutBitContext pb; - if((unsigned)src_size > (unsigned)max_size) - return -1; + if ((unsigned)src_size > (unsigned)max_size) { +// av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n"); +// return -1; + src_size = max_size; + } mrk = AV_RB32(src); switch (mrk) { case DCA_MARKER_RAW_BE: - memcpy(dst, src, FFMIN(src_size, max_size)); - return FFMIN(src_size, max_size); + memcpy(dst, src, src_size); + return src_size; case DCA_MARKER_RAW_LE: - for (i = 0; i < (FFMIN(src_size, max_size) + 1) >> 1; i++) - *sdst++ = bswap_16(*ssrc++); - return FFMIN(src_size, max_size); + for (i = 0; i < (src_size + 1) >> 1; i++) + *sdst++ = av_bswap16(*ssrc++); + return src_size; case DCA_MARKER_14B_BE: case DCA_MARKER_14B_LE: init_put_bits(&pb, dst, max_size); @@ -1129,121 +1256,214 @@ static int dca_convert_bitstream(uint8_t * src, int src_size, uint8_t * dst, */ static int dca_decode_frame(AVCodecContext * avctx, void *data, int *data_size, - uint8_t * buf, int buf_size) + AVPacket *avpkt) { + const uint8_t *buf = avpkt->data; + int buf_size = avpkt->size; - int i, j, k; + int lfe_samples; + int num_core_channels = 0; + int i; int16_t *samples = data; DCAContext *s = avctx->priv_data; int channels; + s->xch_present = 0; s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE); if (s->dca_buffer_size == -1) { - av_log(avctx, AV_LOG_ERROR, "Not a DCA frame\n"); + av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n"); return -1; } init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8); if (dca_parse_frame_header(s) < 0) { //seems like the frame is corrupt, try with the next one + *data_size=0; return buf_size; } //set AVCodec values with parsed data avctx->sample_rate = s->sample_rate; avctx->bit_rate = s->bit_rate; - channels = s->prim_channels + !!s->lfe; - if(avctx->channels == 0) { - avctx->channels = channels; - } else if(channels < avctx->channels) { - av_log(avctx, AV_LOG_WARNING, "DTS source channels are less than " - "specified: output to %d channels.\n", channels); - avctx->channels = channels; - } - if(avctx->channels == 2) { - s->output = DCA_STEREO; - } else if(avctx->channels != channels) { - av_log(avctx, AV_LOG_ERROR, "Cannot downmix DTS to %d channels.\n", - avctx->channels); - return -1; + for (i = 0; i < (s->sample_blocks / 8); i++) { + dca_decode_block(s, 0, i); } - channels = avctx->channels; - if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels) - return -1; - *data_size = 0; - for (i = 0; i < (s->sample_blocks / 8); i++) { - dca_decode_block(s); - s->dsp.float_to_int16(s->tsamples, s->samples, 256 * channels); - /* interleave samples */ - for (j = 0; j < 256; j++) { - for (k = 0; k < channels; k++) - samples[k] = s->tsamples[j + k * 256]; - samples += channels; + /* record number of core channels incase less than max channels are requested */ + num_core_channels = s->prim_channels; + + /* extensions start at 32-bit boundaries into bitstream */ + skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31); + + while(get_bits_left(&s->gb) >= 32) { + uint32_t bits = get_bits_long(&s->gb, 32); + + switch(bits) { + case 0x5a5a5a5a: { + int ext_amode, xch_fsize; + + s->xch_base_channel = s->prim_channels; + + /* validate sync word using XCHFSIZE field */ + xch_fsize = show_bits(&s->gb, 10); + if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) && + (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1)) + continue; + + /* skip length-to-end-of-frame field for the moment */ + skip_bits(&s->gb, 10); + + /* extension amode should == 1, number of channels in extension */ + /* 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); + continue; + } + + /* much like core primary audio coding header */ + dca_parse_audio_coding_header(s, s->xch_base_channel); + + for (i = 0; i < (s->sample_blocks / 8); i++) { + dca_decode_block(s, s->xch_base_channel, i); + } + + s->xch_present = 1; + break; } - *data_size += 256 * sizeof(int16_t) * channels; + case 0x1d95f262: + av_log(avctx, AV_LOG_DEBUG, "Possible X96 extension found at %d bits\n", get_bits_count(&s->gb)); + av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", get_bits(&s->gb, 12)+1); + av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4)); + break; + } + + skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31); } - return buf_size; -} + channels = s->prim_channels + !!s->lfe; + 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)) { + avctx->channel_layout |= CH_BACK_CENTER; + if (s->lfe) { + avctx->channel_layout |= CH_LOW_FREQUENCY; + s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode]; + } else { + s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode]; + } + } else { + if (s->lfe) { + avctx->channel_layout |= CH_LOW_FREQUENCY; + s->channel_order_tab = dca_channel_reorder_lfe[s->amode]; + } else + s->channel_order_tab = dca_channel_reorder_nolfe[s->amode]; + } + if (s->prim_channels > 0 && + s->channel_order_tab[s->prim_channels - 1] < 0) + return -1; -/** - * Build the cosine modulation tables for the QMF - * - * @param s pointer to the DCAContext - */ + if (avctx->request_channels == 2 && s->prim_channels > 2) { + channels = 2; + s->output = DCA_STEREO; + avctx->channel_layout = CH_LAYOUT_STEREO; + } + } else { + av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode); + return -1; + } -static void pre_calc_cosmod(DCAContext * s) -{ - int i, j, k; - static int cosmod_inited = 0; - if(cosmod_inited) return; - for (j = 0, k = 0; k < 16; k++) - for (i = 0; i < 16; i++) - cos_mod[j++] = cos((2 * i + 1) * (2 * k + 1) * M_PI / 64); + /* There is nothing that prevents a dts frame to change channel configuration + but FFmpeg 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 (!avctx->channels) + avctx->channels = channels; - for (k = 0; k < 16; k++) - for (i = 0; i < 16; i++) - cos_mod[j++] = cos((i) * (2 * k + 1) * M_PI / 32); + if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels) + return -1; + *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels; - for (k = 0; k < 16; k++) - cos_mod[j++] = 0.25 / (2 * cos((2 * k + 1) * M_PI / 128)); + /* filter to get final output */ + for (i = 0; i < (s->sample_blocks / 8); i++) { + dca_filter_channels(s, i); + s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels); + samples += 256 * channels; + } - for (k = 0; k < 16; k++) - cos_mod[j++] = -0.25 / (2.0 * sin((2 * k + 1) * M_PI / 128)); + /* update lfe history */ + lfe_samples = 2 * s->lfe * (s->sample_blocks / 8); + for (i = 0; i < 2 * s->lfe * 4; i++) { + s->lfe_data[i] = s->lfe_data[i + lfe_samples]; + } - cosmod_inited = 1; + return buf_size; } + /** * DCA initialization * * @param avctx pointer to the AVCodecContext */ -static int dca_decode_init(AVCodecContext * avctx) +static av_cold int dca_decode_init(AVCodecContext * avctx) { DCAContext *s = avctx->priv_data; + int i; s->avctx = avctx; dca_init_vlcs(); - pre_calc_cosmod(s); dsputil_init(&s->dsp, avctx); + ff_mdct_init(&s->imdct, 6, 1, 1.0); + ff_synth_filter_init(&s->synth); + ff_dcadsp_init(&s->dcadsp); + + for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++) + s->samples_chanptr[i] = s->samples + i * 256; + avctx->sample_fmt = SAMPLE_FMT_S16; + + if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { + s->add_bias = 385.0f; + s->scale_bias = 1.0 / 32768.0; + } else { + s->add_bias = 0.0f; + s->scale_bias = 1.0; + + /* allow downmixing to stereo */ + if (avctx->channels > 0 && avctx->request_channels < avctx->channels && + avctx->request_channels == 2) { + avctx->channels = avctx->request_channels; + } + } + + return 0; } +static av_cold int dca_decode_end(AVCodecContext * avctx) +{ + DCAContext *s = avctx->priv_data; + ff_mdct_end(&s->imdct); + return 0; +} AVCodec dca_decoder = { .name = "dca", - .type = CODEC_TYPE_AUDIO, + .type = AVMEDIA_TYPE_AUDIO, .id = 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)"), };