lpc.h 6.16 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 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
#else
121
#ifdef LPC_USE_DOUBLE
122
typedef double LPC_TYPE;
123
#else
124
typedef float LPC_TYPE;
125
#endif
126
#endif // USE_FIXED
127

128 129 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
/**
 * 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;
    }
}

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

171 172
    av_assert2(normalize || !fail);

173 174 175 176 177 178 179
    if (normalize)
        err = *autoc++;

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

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

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

            r /= err;
187
            err *= FIXR(1.0) - (r * r);
188 189 190 191 192
        }

        lpc[i] = r;

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

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

        lpc_last = lpc;
        lpc += lpc_stride;
    }

    return 0;
}

209
#endif /* AVCODEC_LPC_H */