mlp.h 6.22 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * MLP codec common header file
 * Copyright (c) 2007-2008 Ian Caulfield
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22 23
#ifndef AVCODEC_MLP_H
#define AVCODEC_MLP_H
24 25 26 27 28

#include <stdint.h>

#include "avcodec.h"

29 30 31
/** Last possible matrix channel for each codec */
#define MAX_MATRIX_CHANNEL_MLP      5
#define MAX_MATRIX_CHANNEL_TRUEHD   7
32 33 34 35 36
/** Maximum number of channels in a valid stream.
 *  MLP   : 5.1 + 2 noise channels -> 8 channels
 *  TrueHD: 7.1                    -> 8 channels
 */
#define MAX_CHANNELS                8
37 38 39 40

/** Maximum number of matrices used in decoding; most streams have one matrix
 *  per output channel, but some rematrix a channel (usually 0) more than once.
 */
41 42
#define MAX_MATRICES_MLP            6
#define MAX_MATRICES_TRUEHD         8
43
#define MAX_MATRICES                8
44

45 46
/** Maximum number of substreams that can be decoded.
 *  MLP's limit is 2. TrueHD supports at least up to 3.
47
 */
48
#define MAX_SUBSTREAMS      4
49

50 51
/** which multiple of 48000 the maximum sample rate is */
#define MAX_RATEFACTOR      4
52
/** maximum sample frequency seen in files */
53
#define MAX_SAMPLERATE      (MAX_RATEFACTOR * 48000)
54 55

/** maximum number of audio samples within one access unit */
56
#define MAX_BLOCKSIZE       (40 * MAX_RATEFACTOR)
57
/** next power of two greater than MAX_BLOCKSIZE */
58
#define MAX_BLOCKSIZE_POW2  (64 * MAX_RATEFACTOR)
59 60 61 62

/** number of allowed filters */
#define NUM_FILTERS         2

63 64 65
/** The maximum number of taps in IIR and FIR filters. */
#define MAX_FIR_ORDER       8
#define MAX_IIR_ORDER       4
66

67 68 69
/** Code that signals end of a stream. */
#define END_OF_STREAM       0xd234d234

70 71 72 73
#define FIR 0
#define IIR 1

/** filter data */
74
typedef struct FilterParams {
75 76 77
    uint8_t     order; ///< number of taps in filter
    uint8_t     shift; ///< Right shift to apply to output of filter.

78
    int32_t     state[MAX_FIR_ORDER];
79 80 81

    int coeff_bits;
    int coeff_shift;
82 83 84
} FilterParams;

/** sample data coding information */
85
typedef struct ChannelParams {
86
    FilterParams filter_params[NUM_FILTERS];
87
    int32_t     coeff[NUM_FILTERS][MAX_FIR_ORDER];
88 89 90 91 92 93 94 95 96 97

    int16_t     huff_offset;      ///< Offset to apply to residual values.
    int32_t     sign_huff_offset; ///< sign/rounding-corrected version of huff_offset
    uint8_t     codebook;         ///< Which VLC codebook to use to read residuals.
    uint8_t     huff_lsbs;        ///< Size of residual suffix not encoded using VLC.
} ChannelParams;

/** Tables defining the Huffman codes.
 *  There are three entropy coding methods used in MLP (four if you count
 *  "none" as a method). These use the same sequences for codes starting with
98 99
 *  00 or 01, but have different codes starting with 1.
 */
100 101
extern const uint8_t ff_mlp_huffman_tables[3][18][2];

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
typedef struct {
    uint8_t channel_occupancy;
    uint8_t group1_channels;
    uint8_t group2_channels;
    uint8_t summary_info;
} ChannelInformation;

/** Tables defining channel information.
 *
 *  Possible channel arrangements are:
 *
 *  (Group 1)   C
 *  (Group 1)   L,  R
 *  (Group 1)   Lf, Rf          /  (Group 2)   S
 *  (Group 1)   Lf, Rf          /  (Group 2)   Ls, Rs
 *  (Group 1)   Lf, Rf          /  (Group 2)   LFE
 *  (Group 1)   Lf, Rf          /  (Group 2)   LFE, S
 *  (Group 1)   Lf, Rf          /  (Group 2)   LFE, Ls, Rs
 *  (Group 1)   Lf, Rf          /  (Group 2)   C
 *  (Group 1)   Lf, Rf          /  (Group 2)   C, S
 *  (Group 1)   Lf, Rf          /  (Group 2)   C, Ls, Rs
 *  (Group 1)   Lf, Rf          /  (Group 2)   C, LFE
 *  (Group 1)   Lf, Rf          /  (Group 2)   C, LFE, S
 *  (Group 1)   Lf, Rf          /  (Group 2)   C, LFE, Ls,  Rs
 *  (Group 1)   Lf, Rf  C       /  (Group 2)   S
 *  (Group 1)   Lf, Rf  C       /  (Group 2)   Ls, Rs
 *  (Group 1)   Lf, Rf  C       /  (Group 2)   LFE
 *  (Group 1)   Lf, Rf  C       /  (Group 2)   LFE, S
 *  (Group 1)   Lf, Rf  C       /  (Group 2)   LFE, Ls, Rs
 *  (Group 1)   Lf, Rf  Ls  Rs  /  (Group 2)   LFE
 *  (Group 1)   Lf, Rf  Ls  Rs  /  (Group 2)   C
 *  (Group 1)   Lf, Rf, Ls, Rs  /  (Group 2)   C, LFE
 */
extern const ChannelInformation ff_mlp_ch_info[21];

extern const uint64_t ff_mlp_channel_layouts[12];

139 140 141
/** MLP uses checksums that seem to be based on the standard CRC algorithm, but
 *  are not (in implementation terms, the table lookup and XOR are reversed).
 *  We can implement this behavior using a standard av_crc on all but the
142 143
 *  last element, then XOR that with the last element.
 */
144 145 146 147
uint8_t  ff_mlp_checksum8 (const uint8_t *buf, unsigned int buf_size);
uint16_t ff_mlp_checksum16(const uint8_t *buf, unsigned int buf_size);

/** Calculate an 8-bit checksum over a restart header -- a non-multiple-of-8
148 149
 *  number of bits, starting two bits into the first byte of buf.
 */
150 151 152
uint8_t ff_mlp_restart_checksum(const uint8_t *buf, unsigned int bit_size);

/** XOR together all the bytes of a buffer.
153 154
 *  Does this belong in dspcontext?
 */
155 156
uint8_t ff_mlp_calculate_parity(const uint8_t *buf, unsigned int buf_size);

157
void ff_mlp_init_crc(void);
158

159 160 161 162 163 164 165 166
/** XOR four bytes into one. */
static inline uint8_t xor_32_to_8(uint32_t value)
{
    value ^= value >> 16;
    value ^= value >>  8;
    return value;
}

167 168 169 170 171 172 173 174 175 176
typedef enum THDChannelModifier {
    THD_CH_MODIFIER_NOTINDICATED  = 0x0,
    THD_CH_MODIFIER_STEREO        = 0x0, // Stereo (not Dolby Surround)
    THD_CH_MODIFIER_LTRT          = 0x1, // Dolby Surround
    THD_CH_MODIFIER_LBINRBIN      = 0x2, // Dolby Headphone
    THD_CH_MODIFIER_MONO          = 0x3, // Mono or Dual Mono
    THD_CH_MODIFIER_NOTSURROUNDEX = 0x1, // Not Dolby Digital EX
    THD_CH_MODIFIER_SURROUNDEX    = 0x2, // Dolby Digital EX
} THDChannelModifier;

177
#endif /* AVCODEC_MLP_H */