lpc.h 6.28 KB
Newer Older
1
/*
2
 * LPC utility code
3
 * Copyright (c) 2006  Justin Ruggles <justin.ruggles@gmail.com>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * 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_LPC_H
#define AVCODEC_LPC_H
24

25
#include <stdint.h>
26
#include "libavutil/avassert.h"
27
#include "libavutil/lls.h"
28
#include "aac_defines.h"
29 30 31 32 33 34 35 36

#define ORDER_METHOD_EST     0
#define ORDER_METHOD_2LEVEL  1
#define ORDER_METHOD_4LEVEL  2
#define ORDER_METHOD_8LEVEL  3
#define ORDER_METHOD_SEARCH  4
#define ORDER_METHOD_LOG     5

37 38
#define MIN_LPC_ORDER        1
#define MAX_LPC_ORDER       32
39

40 41 42 43 44 45 46 47 48 49 50
/**
 * LPC analysis type
 */
enum FFLPCType {
    FF_LPC_TYPE_DEFAULT     = -1, ///< use the codec default LPC type
    FF_LPC_TYPE_NONE        =  0, ///< do not use LPC prediction or use all zero coefficients
    FF_LPC_TYPE_FIXED       =  1, ///< fixed LPC coefficients
    FF_LPC_TYPE_LEVINSON    =  2, ///< Levinson-Durbin recursion
    FF_LPC_TYPE_CHOLESKY    =  3, ///< Cholesky factorization
    FF_LPC_TYPE_NB              , ///< Not part of ABI
};
51

52
typedef struct LPCContext {
53 54
    int blocksize;
    int max_order;
55
    enum FFLPCType lpc_type;
56
    double *windowed_buffer;
57 58 59 60 61 62 63 64 65 66 67 68
    double *windowed_samples;

    /**
     * Apply a Welch window to an array of input samples.
     * The output samples have the same scale as the input, but are in double
     * sample format.
     * @param data    input samples
     * @param len     number of input samples
     * @param w_data  output samples
     */
    void (*lpc_apply_welch_window)(const int32_t *data, int len,
                                   double *w_data);
69 70 71
    /**
     * Perform autocorrelation on input samples with delay of 0 to lag.
     * @param data  input samples.
72
     *              constraints: no alignment needed, but must have at
73
     *              least lag*sizeof(double) valid bytes preceding it, and
74 75 76
     *              size must be at least (len+1)*sizeof(double) if data is
     *              16-byte aligned or (len+2)*sizeof(double) if data is
     *              unaligned.
77 78 79 80 81
     * @param len   number of input samples to process
     * @param lag   maximum delay to calculate
     * @param autoc output autocorrelation coefficients.
     *              constraints: array size must be at least lag+1.
     */
82
    void (*lpc_compute_autocorr)(const double *data, int len, int lag,
83
                                 double *autoc);
84 85 86

    // TODO: these should be allocated to reduce ABI compatibility issues
    LLSModel lls_models[2];
87 88 89
} LPCContext;


90 91 92
/**
 * Calculate LPC coefficients for multiple orders
 */
93
int ff_lpc_calc_coefs(LPCContext *s,
94 95
                      const int32_t *samples, int blocksize, int min_order,
                      int max_order, int precision,
96
                      int32_t coefs[][MAX_LPC_ORDER], int *shift,
97
                      enum FFLPCType lpc_type, int lpc_passes,
98
                      int omethod, int min_shift, int max_shift, int zero_shift);
99

100 101 102
int ff_lpc_calc_ref_coefs(LPCContext *s,
                          const int32_t *samples, int order, double *ref);

103 104
double ff_lpc_calc_ref_coefs_f(LPCContext *s, const float *samples, int len,
                               int order, double *ref);
105

106 107 108
/**
 * Initialize LPCContext.
 */
109
int ff_lpc_init(LPCContext *s, int blocksize, int max_order,
110
                enum FFLPCType lpc_type);
111
void ff_lpc_init_x86(LPCContext *s);
112

113 114 115 116 117
/**
 * Uninitialize LPCContext.
 */
void ff_lpc_end(LPCContext *s);

118
#if USE_FIXED
119
typedef int LPC_TYPE;
120
typedef unsigned LPC_TYPE_U;
121
#else
122
#ifdef LPC_USE_DOUBLE
123
typedef double LPC_TYPE;
124
typedef double LPC_TYPE_U;
125
#else
126
typedef float LPC_TYPE;
127
typedef float LPC_TYPE_U;
128
#endif
129
#endif // USE_FIXED
130

131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
/**
 * Schur recursion.
 * Produces reflection coefficients from autocorrelation data.
 */
static inline void compute_ref_coefs(const LPC_TYPE *autoc, int max_order,
                                     LPC_TYPE *ref, LPC_TYPE *error)
{
    int i, j;
    LPC_TYPE err;
    LPC_TYPE gen0[MAX_LPC_ORDER], gen1[MAX_LPC_ORDER];

    for (i = 0; i < max_order; i++)
        gen0[i] = gen1[i] = autoc[i + 1];

    err    = autoc[0];
    ref[0] = -gen1[0] / err;
    err   +=  gen1[0] * ref[0];
    if (error)
        error[0] = err;
    for (i = 1; i < max_order; i++) {
        for (j = 0; j < max_order - i; j++) {
            gen1[j] = gen1[j + 1] + ref[i - 1] * gen0[j];
            gen0[j] = gen1[j + 1] * ref[i - 1] + gen0[j];
        }
        ref[i] = -gen1[0] / err;
        err   +=  gen1[0] * ref[i];
        if (error)
            error[i] = err;
    }
}

162 163
/**
 * Levinson-Durbin recursion.
164
 * Produce LPC coefficients from autocorrelation data.
165
 */
166
static inline int AAC_RENAME(compute_lpc_coefs)(const LPC_TYPE *autoc, int max_order,
167
                                    LPC_TYPE *lpc, int lpc_stride, int fail,
168 169 170
                                    int normalize)
{
    int i, j;
171
    LPC_TYPE err = 0;
172
    LPC_TYPE *lpc_last = lpc;
173

174 175
    av_assert2(normalize || !fail);

176 177 178 179 180 181 182
    if (normalize)
        err = *autoc++;

    if (fail && (autoc[max_order - 1] == 0 || err <= 0))
        return -1;

    for(i=0; i<max_order; i++) {
183
        LPC_TYPE r = AAC_SRA_R(-autoc[i], 5);
184 185 186 187 188 189

        if (normalize) {
            for(j=0; j<i; j++)
                r -= lpc_last[j] * autoc[i-j-1];

            r /= err;
190
            err *= FIXR(1.0) - (r * r);
191 192 193 194 195
        }

        lpc[i] = r;

        for(j=0; j < (i+1)>>1; j++) {
196 197
            LPC_TYPE f = lpc_last[    j];
            LPC_TYPE b = lpc_last[i-1-j];
198 199
            lpc[    j] = f + (LPC_TYPE_U)AAC_MUL26(r, b);
            lpc[i-1-j] = b + (LPC_TYPE_U)AAC_MUL26(r, f);
200 201 202 203 204 205 206 207 208 209 210 211
        }

        if (fail && err < 0)
            return -1;

        lpc_last = lpc;
        lpc += lpc_stride;
    }

    return 0;
}

212
#endif /* AVCODEC_LPC_H */