| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * LSP routines for ACELP-based codecs | ||
| 3 | * | ||
| 4 | * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet (QCELP decoder) | ||
| 5 | * Copyright (c) 2008 Vladimir Voroshilov | ||
| 6 | * | ||
| 7 | * This file is part of FFmpeg. | ||
| 8 | * | ||
| 9 | * FFmpeg is free software; you can redistribute it and/or | ||
| 10 | * modify it under the terms of the GNU Lesser General Public | ||
| 11 | * License as published by the Free Software Foundation; either | ||
| 12 | * version 2.1 of the License, or (at your option) any later version. | ||
| 13 | * | ||
| 14 | * FFmpeg is distributed in the hope that it will be useful, | ||
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 17 | * Lesser General Public License for more details. | ||
| 18 | * | ||
| 19 | * You should have received a copy of the GNU Lesser General Public | ||
| 20 | * License along with FFmpeg; if not, write to the Free Software | ||
| 21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 22 | */ | ||
| 23 | |||
| 24 | #include <math.h> | ||
| 25 | |||
| 26 | #include "config.h" | ||
| 27 | |||
| 28 | #define FRAC_BITS 14 | ||
| 29 | #include "libavutil/macros.h" | ||
| 30 | #include "mathops.h" | ||
| 31 | #include "lsp.h" | ||
| 32 | #if ARCH_MIPS | ||
| 33 | #include "libavcodec/mips/lsp_mips.h" | ||
| 34 | #endif /* ARCH_MIPS */ | ||
| 35 | #include "libavutil/avassert.h" | ||
| 36 | |||
| 37 | ✗ | void ff_acelp_reorder_lsf(int16_t* lsfq, int lsfq_min_distance, int lsfq_min, int lsfq_max, int lp_order) | |
| 38 | { | ||
| 39 | int i, j; | ||
| 40 | |||
| 41 | /* sort lsfq in ascending order. float bubble algorithm, | ||
| 42 | O(n) if data already sorted, O(n^2) - otherwise */ | ||
| 43 | ✗ | for(i=0; i<lp_order-1; i++) | |
| 44 | ✗ | for(j=i; j>=0 && lsfq[j] > lsfq[j+1]; j--) | |
| 45 | ✗ | FFSWAP(int16_t, lsfq[j], lsfq[j+1]); | |
| 46 | |||
| 47 | ✗ | for(i=0; i<lp_order; i++) | |
| 48 | { | ||
| 49 | ✗ | lsfq[i] = FFMAX(lsfq[i], lsfq_min); | |
| 50 | ✗ | lsfq_min = lsfq[i] + lsfq_min_distance; | |
| 51 | } | ||
| 52 | ✗ | lsfq[lp_order-1] = FFMIN(lsfq[lp_order-1], lsfq_max);//Is warning required ? | |
| 53 | ✗ | } | |
| 54 | |||
| 55 | 17287 | void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size) | |
| 56 | { | ||
| 57 | int i; | ||
| 58 | 17287 | float prev = 0.0; | |
| 59 |
2/2✓ Branch 0 taken 218580 times.
✓ Branch 1 taken 17287 times.
|
235867 | for (i = 0; i < size; i++) |
| 60 |
2/2✓ Branch 0 taken 218198 times.
✓ Branch 1 taken 382 times.
|
218580 | prev = lsf[i] = FFMAX(lsf[i], prev + min_spacing); |
| 61 | 17287 | } | |
| 62 | |||
| 63 | |||
| 64 | /* Cosine table: base_cos[i] = (1 << 15) * cos(i * PI / 64) */ | ||
| 65 | static const int16_t tab_cos[65] = | ||
| 66 | { | ||
| 67 | 32767, 32738, 32617, 32421, 32145, 31793, 31364, 30860, | ||
| 68 | 30280, 29629, 28905, 28113, 27252, 26326, 25336, 24285, | ||
| 69 | 23176, 22011, 20793, 19525, 18210, 16851, 15451, 14014, | ||
| 70 | 12543, 11043, 9515, 7965, 6395, 4810, 3214, 1609, | ||
| 71 | 1, -1607, -3211, -4808, -6393, -7962, -9513, -11040, | ||
| 72 | -12541, -14012, -15449, -16848, -18207, -19523, -20791, -22009, | ||
| 73 | -23174, -24283, -25334, -26324, -27250, -28111, -28904, -29627, | ||
| 74 | -30279, -30858, -31363, -31792, -32144, -32419, -32616, -32736, -32768, | ||
| 75 | }; | ||
| 76 | |||
| 77 | ✗ | static int16_t ff_cos(uint16_t arg) | |
| 78 | { | ||
| 79 | ✗ | uint8_t offset= arg; | |
| 80 | ✗ | uint8_t ind = arg >> 8; | |
| 81 | |||
| 82 | av_assert2(arg <= 0x3fff); | ||
| 83 | |||
| 84 | ✗ | return tab_cos[ind] + (offset * (tab_cos[ind+1] - tab_cos[ind]) >> 8); | |
| 85 | } | ||
| 86 | |||
| 87 | ✗ | void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order) | |
| 88 | { | ||
| 89 | int i; | ||
| 90 | |||
| 91 | /* Convert LSF to LSP, lsp=cos(lsf) */ | ||
| 92 | ✗ | for(i=0; i<lp_order; i++) | |
| 93 | // 20861 = 2.0 / PI in (0.15) | ||
| 94 | ✗ | lsp[i] = ff_cos(lsf[i] * 20861 >> 15); // divide by PI and (0,13) -> (0,14) | |
| 95 | ✗ | } | |
| 96 | |||
| 97 | 10889 | void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order) | |
| 98 | { | ||
| 99 | int i; | ||
| 100 | |||
| 101 |
2/2✓ Branch 0 taken 167018 times.
✓ Branch 1 taken 10889 times.
|
177907 | for(i = 0; i < lp_order; i++) |
| 102 | 167018 | lsp[i] = cos(2.0 * M_PI * lsf[i]); | |
| 103 | 10889 | } | |
| 104 | |||
| 105 | /** | ||
| 106 | * @brief decodes polynomial coefficients from LSP | ||
| 107 | * @param[out] f decoded polynomial coefficients (-0x20000000 <= (3.22) <= 0x1fffffff) | ||
| 108 | * @param lsp LSP coefficients (-0x8000 <= (0.15) <= 0x7fff) | ||
| 109 | */ | ||
| 110 | ✗ | static void lsp2poly(int* f, const int16_t* lsp, int lp_half_order) | |
| 111 | { | ||
| 112 | int i, j; | ||
| 113 | |||
| 114 | ✗ | f[0] = 0x400000; // 1.0 in (3.22) | |
| 115 | ✗ | f[1] = -lsp[0] * 256; // *2 and (0.15) -> (3.22) | |
| 116 | |||
| 117 | ✗ | for(i=2; i<=lp_half_order; i++) | |
| 118 | { | ||
| 119 | ✗ | f[i] = f[i-2]; | |
| 120 | ✗ | for(j=i; j>1; j--) | |
| 121 | ✗ | f[j] -= MULL(f[j-1], lsp[2*i-2], FRAC_BITS) - f[j-2]; | |
| 122 | |||
| 123 | ✗ | f[1] -= lsp[2*i-2] * 256; | |
| 124 | } | ||
| 125 | ✗ | } | |
| 126 | |||
| 127 | #ifndef lsp2polyf | ||
| 128 | /** | ||
| 129 | * Compute the Pa / (1 + z(-1)) or Qa / (1 - z(-1)) coefficients | ||
| 130 | * needed for LSP to LPC conversion. | ||
| 131 | * We only need to calculate the 6 first elements of the polynomial. | ||
| 132 | * | ||
| 133 | * @param lsp line spectral pairs in cosine domain | ||
| 134 | * @param[out] f polynomial input/output as a vector | ||
| 135 | * | ||
| 136 | * TIA/EIA/IS-733 2.4.3.3.5-1/2 | ||
| 137 | */ | ||
| 138 | 157154 | static void lsp2polyf(const double *lsp, double *f, int lp_half_order) | |
| 139 | { | ||
| 140 | 157154 | f[0] = 1.0; | |
| 141 | 157154 | f[1] = -2 * lsp[0]; | |
| 142 | 157154 | lsp -= 2; | |
| 143 |
2/2✓ Branch 0 taken 847392 times.
✓ Branch 1 taken 157154 times.
|
1004546 | for (int i = 2; i <= lp_half_order; i++) { |
| 144 | 847392 | double val = -2 * lsp[2*i]; | |
| 145 | 847392 | f[i] = val * f[i-1] + 2*f[i-2]; | |
| 146 |
2/2✓ Branch 0 taken 2059932 times.
✓ Branch 1 taken 847392 times.
|
2907324 | for (int j = i-1; j > 1; j--) |
| 147 | 2059932 | f[j] += f[j-1] * val + f[j-2]; | |
| 148 | 847392 | f[1] += val; | |
| 149 | } | ||
| 150 | 157154 | } | |
| 151 | #endif /* lsp2polyf */ | ||
| 152 | |||
| 153 | ✗ | void ff_acelp_lsp2lpc(int16_t* lp, const int16_t* lsp, int lp_half_order) | |
| 154 | { | ||
| 155 | int i; | ||
| 156 | int f1[MAX_LP_HALF_ORDER+1]; // (3.22) | ||
| 157 | int f2[MAX_LP_HALF_ORDER+1]; // (3.22) | ||
| 158 | |||
| 159 | ✗ | lsp2poly(f1, lsp , lp_half_order); | |
| 160 | ✗ | lsp2poly(f2, lsp+1, lp_half_order); | |
| 161 | |||
| 162 | /* 3.2.6 of G.729, Equations 25 and 26*/ | ||
| 163 | ✗ | lp[0] = 4096; | |
| 164 | ✗ | for(i=1; i<lp_half_order+1; i++) | |
| 165 | { | ||
| 166 | ✗ | int ff1 = f1[i] + f1[i-1]; // (3.22) | |
| 167 | ✗ | int ff2 = f2[i] - f2[i-1]; // (3.22) | |
| 168 | |||
| 169 | ✗ | ff1 += 1 << 10; // for rounding | |
| 170 | ✗ | lp[i] = (ff1 + ff2) >> 11; // divide by 2 and (3.22) -> (3.12) | |
| 171 | ✗ | lp[(lp_half_order << 1) + 1 - i] = (ff1 - ff2) >> 11; // divide by 2 and (3.22) -> (3.12) | |
| 172 | } | ||
| 173 | ✗ | } | |
| 174 | |||
| 175 | 44042 | void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order) | |
| 176 | { | ||
| 177 | 44042 | int lp_half_order = lp_order >> 1; | |
| 178 | double buf[MAX_LP_HALF_ORDER + 1]; | ||
| 179 | double pa[MAX_LP_HALF_ORDER + 1]; | ||
| 180 | 44042 | double *qa = buf + 1; | |
| 181 | int i,j; | ||
| 182 | |||
| 183 | 44042 | qa[-1] = 0.0; | |
| 184 | |||
| 185 | 44042 | lsp2polyf(lsp , pa, lp_half_order ); | |
| 186 | 44042 | lsp2polyf(lsp + 1, qa, lp_half_order - 1); | |
| 187 | |||
| 188 |
2/2✓ Branch 0 taken 261644 times.
✓ Branch 1 taken 44042 times.
|
305686 | for (i = 1, j = lp_order - 1; i < lp_half_order; i++, j--) { |
| 189 | 261644 | double paf = pa[i] * (1 + lsp[lp_order - 1]); | |
| 190 | 261644 | double qaf = (qa[i] - qa[i-2]) * (1 - lsp[lp_order - 1]); | |
| 191 | 261644 | lp[i-1] = (paf + qaf) * 0.5; | |
| 192 | 261644 | lp[j-1] = (paf - qaf) * 0.5; | |
| 193 | } | ||
| 194 | |||
| 195 | 44042 | lp[lp_half_order - 1] = (1.0 + lsp[lp_order - 1]) * | |
| 196 | 44042 | pa[lp_half_order] * 0.5; | |
| 197 | |||
| 198 | 44042 | lp[lp_order - 1] = lsp[lp_order - 1]; | |
| 199 | 44042 | } | |
| 200 | |||
| 201 | ✗ | void ff_acelp_lp_decode(int16_t* lp_1st, int16_t* lp_2nd, const int16_t* lsp_2nd, const int16_t* lsp_prev, int lp_order) | |
| 202 | { | ||
| 203 | int16_t lsp_1st[MAX_LP_ORDER]; // (0.15) | ||
| 204 | int i; | ||
| 205 | |||
| 206 | /* LSP values for first subframe (3.2.5 of G.729, Equation 24)*/ | ||
| 207 | ✗ | for(i=0; i<lp_order; i++) | |
| 208 | #ifdef G729_BITEXACT | ||
| 209 | lsp_1st[i] = (lsp_2nd[i] >> 1) + (lsp_prev[i] >> 1); | ||
| 210 | #else | ||
| 211 | ✗ | lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) >> 1; | |
| 212 | #endif | ||
| 213 | |||
| 214 | ✗ | ff_acelp_lsp2lpc(lp_1st, lsp_1st, lp_order >> 1); | |
| 215 | |||
| 216 | /* LSP values for second subframe (3.2.5 of G.729)*/ | ||
| 217 | ✗ | ff_acelp_lsp2lpc(lp_2nd, lsp_2nd, lp_order >> 1); | |
| 218 | ✗ | } | |
| 219 | |||
| 220 | 34535 | void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order) | |
| 221 | { | ||
| 222 | double pa[MAX_LP_HALF_ORDER+1], qa[MAX_LP_HALF_ORDER+1]; | ||
| 223 | 34535 | float *lpc2 = lpc + (lp_half_order << 1) - 1; | |
| 224 | |||
| 225 | av_assert2(lp_half_order <= MAX_LP_HALF_ORDER); | ||
| 226 | |||
| 227 | 34535 | lsp2polyf(lsp, pa, lp_half_order); | |
| 228 | 34535 | lsp2polyf(lsp + 1, qa, lp_half_order); | |
| 229 | |||
| 230 |
2/2✓ Branch 0 taken 218608 times.
✓ Branch 1 taken 34535 times.
|
253143 | while (lp_half_order--) { |
| 231 | 218608 | double paf = pa[lp_half_order+1] + pa[lp_half_order]; | |
| 232 | 218608 | double qaf = qa[lp_half_order+1] - qa[lp_half_order]; | |
| 233 | |||
| 234 | 218608 | lpc [ lp_half_order] = 0.5*(paf+qaf); | |
| 235 | 218608 | lpc2[-lp_half_order] = 0.5*(paf-qaf); | |
| 236 | } | ||
| 237 | 34535 | } | |
| 238 | |||
| 239 | 7780 | void ff_sort_nearly_sorted_floats(float *vals, int len) | |
| 240 | { | ||
| 241 | int i,j; | ||
| 242 | |||
| 243 |
2/2✓ Branch 0 taken 80370 times.
✓ Branch 1 taken 7780 times.
|
88150 | for (i = 0; i < len - 1; i++) |
| 244 |
4/4✓ Branch 0 taken 80370 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 80369 times.
|
80371 | for (j = i; j >= 0 && vals[j] > vals[j+1]; j--) |
| 245 | 1 | FFSWAP(float, vals[j], vals[j+1]); | |
| 246 | 7780 | } | |
| 247 |