FFmpeg: libavcodec/ilbcdec.c Source File

FFmpeg

[フレーム]

libavcodec

ilbcdec.c

Go to the documentation of this file.

1 /*

3 *

4 * Redistribution and use in source and binary forms, with or without

5 * modification, are permitted provided that the following conditions are

6 * met:

7 *

8 * * Redistributions of source code must retain the above copyright

9 * notice, this list of conditions and the following disclaimer.

10 *

11 * * Redistributions in binary form must reproduce the above copyright

12 * notice, this list of conditions and the following disclaimer in

13 * the documentation and/or other materials provided with the

14 * distribution.

15 *

16 * * Neither the name of Google nor the names of its contributors may

17 * be used to endorse or promote products derived from this software

18 * without specific prior written permission.

19 *

20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

24 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

31 */

33 #include "libavutil/channel_layout.h"

34 #include "avcodec.h"

35 #include "codec_internal.h"

36 #include "internal.h"

37 #include "get_bits.h"

38 #include "ilbcdata.h"

40 #define LPC_N_20MS 1

41 #define LPC_N_30MS 2

42 #define LPC_N_MAX 2

43 #define LSF_NSPLIT 3

44 #define NASUB_MAX 4

45 #define LPC_FILTERORDER 10

46 #define NSUB_MAX 6

47 #define SUBL 40

49 #define ST_MEM_L_TBL 85

50 #define MEM_LF_TBL 147

51 #define STATE_SHORT_LEN_20MS 57

52 #define STATE_SHORT_LEN_30MS 58

54 #define BLOCKL_MAX 240

55 #define CB_MEML 147

56 #define CB_NSTAGES 3

57 #define CB_HALFFILTERLEN 4

58 #define CB_FILTERLEN 8

60 #define ENH_NBLOCKS_TOT 8

61 #define ENH_BLOCKL 80

62 #define ENH_BUFL (ENH_NBLOCKS_TOT)*ENH_BLOCKL

63 #define ENH_BUFL_FILTEROVERHEAD 3

64 #define BLOCKL_MAX 240

65 #define NSUB_20MS 4

66 #define NSUB_30MS 6

67 #define NSUB_MAX 6

68 #define NASUB_20MS 2

69 #define NASUB_30MS 4

70 #define NASUB_MAX 4

71 #define STATE_LEN 80

72 #define STATE_SHORT_LEN_30MS 58

73 #define STATE_SHORT_LEN_20MS 57

75 #define SPL_MUL_16_16(a, b) ((int32_t) (((int16_t)(a)) * ((int16_t)(b))))

76 #define SPL_MUL_16_16_RSFT(a, b, c) (SPL_MUL_16_16(a, b) >> (c))

78 typedef struct ILBCFrame {

79 int16_t lsf[LSF_NSPLIT*LPC_N_MAX];

80 int16_t cb_index[CB_NSTAGES*(NASUB_MAX + 1)];

81 int16_t gain_index[CB_NSTAGES*(NASUB_MAX + 1)];

82 int16_t ifm;

83 int16_t state_first;

84 int16_t idx[STATE_SHORT_LEN_30MS];

85 int16_t firstbits;

86 int16_t start;

87 } ILBCFrame;

89 typedef struct ILBCContext {

90 AVClass *class;

91 int enhancer;

93 int mode;

94 GetBitContext gb;

95 ILBCFrame frame;

97 int prev_enh_pl;

98 int consPLICount;

99 int last_lag;

100 int state_short_len;

101 int lpc_n;

102 int16_t nasub;

103 int16_t nsub;

104 int block_samples;

105 int16_t no_of_words;

106 int16_t no_of_bytes;

107 int16_t lsfdeq[LPC_FILTERORDER*LPC_N_MAX];

108 int16_t lsfold[LPC_FILTERORDER];

109 int16_t syntMem[LPC_FILTERORDER];

110 int16_t lsfdeqold[LPC_FILTERORDER];

111 int16_t weightdenum[(LPC_FILTERORDER + 1) * NSUB_MAX];

112 int16_t syntdenum[NSUB_MAX * (LPC_FILTERORDER + 1)];

113 int16_t old_syntdenum[NSUB_MAX * (LPC_FILTERORDER + 1)];

114 int16_t enh_buf[ENH_BUFL+ENH_BUFL_FILTEROVERHEAD];

115 int16_t enh_period[ENH_NBLOCKS_TOT];

116 int16_t prevResidual[NSUB_MAX*SUBL];

117 int16_t decresidual[BLOCKL_MAX];

118 int16_t plc_residual[BLOCKL_MAX + LPC_FILTERORDER];

119 int16_t seed;

120 int16_t prevPLI;

121 int16_t prevScale;

122 int16_t prevLag;

123 int16_t per_square;

124 int16_t prev_lpc[LPC_FILTERORDER + 1];

125 int16_t plc_lpc[LPC_FILTERORDER + 1];

126 int16_t hpimemx[2];

127 int16_t hpimemy[4];

128 } ILBCContext;

129

130 static int unpack_frame(ILBCContext *s)

131 {

132 ILBCFrame *frame = &s->frame;

133 GetBitContext *gb = &s->gb;

134 int j;

135

136 frame->lsf[0] = get_bits(gb, 6);

137 frame->lsf[1] = get_bits(gb, 7);

138 frame->lsf[2] = get_bits(gb, 7);

139

140 if (s->mode == 20) {

141 frame->start = get_bits(gb, 2);

142 frame->state_first = get_bits1(gb);

143 frame->ifm = get_bits(gb, 6);

144 frame->cb_index[0] = get_bits(gb, 6) << 1;

145 frame->gain_index[0] = get_bits(gb, 2) << 3;

146 frame->gain_index[1] = get_bits1(gb) << 3;

147 frame->cb_index[3] = get_bits(gb, 7) << 1;

148 frame->gain_index[3] = get_bits1(gb) << 4;

149 frame->gain_index[4] = get_bits1(gb) << 3;

150 frame->gain_index[6] = get_bits1(gb) << 4;

151 } else {

152 frame->lsf[3] = get_bits(gb, 6);

153 frame->lsf[4] = get_bits(gb, 7);

154 frame->lsf[5] = get_bits(gb, 7);

155 frame->start = get_bits(gb, 3);

156 frame->state_first = get_bits1(gb);

157 frame->ifm = get_bits(gb, 6);

158 frame->cb_index[0] = get_bits(gb, 4) << 3;

159 frame->gain_index[0] = get_bits1(gb) << 4;

160 frame->gain_index[1] = get_bits1(gb) << 3;

161 frame->cb_index[3] = get_bits(gb, 6) << 2;

162 frame->gain_index[3] = get_bits1(gb) << 4;

163 frame->gain_index[4] = get_bits1(gb) << 3;

164 }

165

166 for (j = 0; j < 48; j++)

167 frame->idx[j] = get_bits1(gb) << 2;

168

169 if (s->mode == 20) {

170 for (; j < 57; j++)

171 frame->idx[j] = get_bits1(gb) << 2;

172

173 frame->gain_index[1] |= get_bits1(gb) << 2;

174 frame->gain_index[3] |= get_bits(gb, 2) << 2;

175 frame->gain_index[4] |= get_bits1(gb) << 2;

176 frame->gain_index[6] |= get_bits1(gb) << 3;

177 frame->gain_index[7] = get_bits(gb, 2) << 2;

178 } else {

179 for (; j < 58; j++)

180 frame->idx[j] = get_bits1(gb) << 2;

181

182 frame->cb_index[0] |= get_bits(gb, 2) << 1;

183 frame->gain_index[0] |= get_bits1(gb) << 3;

184 frame->gain_index[1] |= get_bits1(gb) << 2;

185 frame->cb_index[3] |= get_bits1(gb) << 1;

186 frame->cb_index[6] = get_bits1(gb) << 7;

187 frame->cb_index[6] |= get_bits(gb, 6) << 1;

188 frame->cb_index[9] = get_bits(gb, 7) << 1;

189 frame->cb_index[12] = get_bits(gb, 3) << 5;

190 frame->cb_index[12] |= get_bits(gb, 4) << 1;

191 frame->gain_index[3] |= get_bits(gb, 2) << 2;

192 frame->gain_index[4] |= get_bits(gb, 2) << 1;

193 frame->gain_index[6] = get_bits(gb, 2) << 3;

194 frame->gain_index[7] = get_bits(gb, 2) << 2;

195 frame->gain_index[9] = get_bits1(gb) << 4;

196 frame->gain_index[10] = get_bits1(gb) << 3;

197 frame->gain_index[12] = get_bits1(gb) << 4;

198 frame->gain_index[13] = get_bits1(gb) << 3;

199 }

200

201 for (j = 0; j < 56; j++)

202 frame->idx[j] |= get_bits(gb, 2);

203

204 if (s->mode == 20) {

205 frame->idx[56] |= get_bits(gb, 2);

206 frame->cb_index[0] |= get_bits1(gb);

207 frame->cb_index[1] = get_bits(gb, 7);

208 frame->cb_index[2] = get_bits(gb, 6) << 1;

209 frame->cb_index[2] |= get_bits1(gb);

210 frame->gain_index[0] |= get_bits(gb, 3);

211 frame->gain_index[1] |= get_bits(gb, 2);

212 frame->gain_index[2] = get_bits(gb, 3);

213 frame->cb_index[3] |= get_bits1(gb);

214 frame->cb_index[4] = get_bits(gb, 6) << 1;

215 frame->cb_index[4] |= get_bits1(gb);

216 frame->cb_index[5] = get_bits(gb, 7);

217 frame->cb_index[6] = get_bits(gb, 8);

218 frame->cb_index[7] = get_bits(gb, 8);

219 frame->cb_index[8] = get_bits(gb, 8);

220 frame->gain_index[3] |= get_bits(gb, 2);

221 frame->gain_index[4] |= get_bits(gb, 2);

222 frame->gain_index[5] = get_bits(gb, 3);

223 frame->gain_index[6] |= get_bits(gb, 3);

224 frame->gain_index[7] |= get_bits(gb, 2);

225 frame->gain_index[8] = get_bits(gb, 3);

226 } else {

227 frame->idx[56] |= get_bits(gb, 2);

228 frame->idx[57] |= get_bits(gb, 2);

229 frame->cb_index[0] |= get_bits1(gb);

230 frame->cb_index[1] = get_bits(gb, 7);

231 frame->cb_index[2] = get_bits(gb, 4) << 3;

232 frame->cb_index[2] |= get_bits(gb, 3);

233 frame->gain_index[0] |= get_bits(gb, 3);

234 frame->gain_index[1] |= get_bits(gb, 2);

235 frame->gain_index[2] = get_bits(gb, 3);

236 frame->cb_index[3] |= get_bits1(gb);

237 frame->cb_index[4] = get_bits(gb, 4) << 3;

238 frame->cb_index[4] |= get_bits(gb, 3);

239 frame->cb_index[5] = get_bits(gb, 7);

240 frame->cb_index[6] |= get_bits1(gb);

241 frame->cb_index[7] = get_bits(gb, 5) << 3;

242 frame->cb_index[7] |= get_bits(gb, 3);

243 frame->cb_index[8] = get_bits(gb, 8);

244 frame->cb_index[9] |= get_bits1(gb);

245 frame->cb_index[10] = get_bits(gb, 4) << 4;

246 frame->cb_index[10] |= get_bits(gb, 4);

247 frame->cb_index[11] = get_bits(gb, 8);

248 frame->cb_index[12] |= get_bits1(gb);

249 frame->cb_index[13] = get_bits(gb, 3) << 5;

250 frame->cb_index[13] |= get_bits(gb, 5);

251 frame->cb_index[14] = get_bits(gb, 8);

252 frame->gain_index[3] |= get_bits(gb, 2);

253 frame->gain_index[4] |= get_bits1(gb);

254 frame->gain_index[5] = get_bits(gb, 3);

255 frame->gain_index[6] |= get_bits(gb, 3);

256 frame->gain_index[7] |= get_bits(gb, 2);

257 frame->gain_index[8] = get_bits(gb, 3);

258 frame->gain_index[9] |= get_bits(gb, 4);

259 frame->gain_index[10] |= get_bits1(gb) << 2;

260 frame->gain_index[10] |= get_bits(gb, 2);

261 frame->gain_index[11] = get_bits(gb, 3);

262 frame->gain_index[12] |= get_bits(gb, 4);

263 frame->gain_index[13] |= get_bits(gb, 3);

264 frame->gain_index[14] = get_bits(gb, 3);

265 }

266

267 return get_bits1(gb);

268 }

269

270 static void index_conv(int16_t *index)

271 {

272 int k;

273

274 for (k = 4; k < 6; k++) {

275 if (index[k] >= 44 && index[k] < 108) {

276 index[k] += 64;

277 } else if (index[k] >= 108 && index[k] < 128) {

278 index[k] += 128;

279 }

280 }

281 }

282

283 static void lsf_dequantization(int16_t *lsfdeq, int16_t *index, int16_t lpc_n)

284 {

285 int i, j, pos = 0, cb_pos = 0;

286

287 for (i = 0; i < LSF_NSPLIT; i++) {

288 for (j = 0; j < lsf_dim_codebook[i]; j++) {

289 lsfdeq[pos + j] = lsf_codebook[cb_pos + index[i] * lsf_dim_codebook[i] + j];

290 }

291

292 pos += lsf_dim_codebook[i];

293 cb_pos += lsf_size_codebook[i] * lsf_dim_codebook[i];

294 }

295

296 if (lpc_n > 1) {

297 pos = 0;

298 cb_pos = 0;

299 for (i = 0; i < LSF_NSPLIT; i++) {

300 for (j = 0; j < lsf_dim_codebook[i]; j++) {

301 lsfdeq[LPC_FILTERORDER + pos + j] = lsf_codebook[cb_pos +

302 index[LSF_NSPLIT + i] * lsf_dim_codebook[i] + j];

303 }

304

305 pos += lsf_dim_codebook[i];

306 cb_pos += lsf_size_codebook[i] * lsf_dim_codebook[i];

307 }

308 }

309 }

310

311 static void lsf_check_stability(int16_t *lsf, int dim, int nb_vectors)

312 {

313 for (int n = 0; n < 2; n++) {

314 for (int m = 0; m < nb_vectors; m++) {

315 for (int k = 0; k < dim - 1; k++) {

316 int i = m * dim + k;

317

318 if ((lsf[i + 1] - lsf[i]) < 319) {

319 if (lsf[i + 1] < lsf[i]) {

320 lsf[i + 1] = lsf[i] + 160;

321 lsf[i] = lsf[i + 1] - 160;

322 } else {

323 lsf[i] -= 160;

324 lsf[i + 1] += 160;

325 }

326 }

327

328 lsf[i] = av_clip(lsf[i], 82, 25723);

329 }

330 }

331 }

332 }

333

334 static void lsf_interpolate(int16_t *out, int16_t *in1,

335 int16_t *in2, int16_t coef,

336 int size)

337 {

338 int invcoef = 16384 - coef, i;

339

340 for (i = 0; i < size; i++)

341 out[i] = (coef * in1[i] + invcoef * in2[i] + 8192) >> 14;

342 }

343

344 static void lsf2lsp(int16_t *lsf, int16_t *lsp, int order)

345 {

346 int16_t diff, freq;

347 int32_t tmp;

348 int i, k;

349

350 for (i = 0; i < order; i++) {

351 freq = (lsf[i] * 20861) >> 15;

352 /* 20861: 1.0/(2.0*PI) in Q17 */

353 /*

354 Upper 8 bits give the index k and

355 Lower 8 bits give the difference, which needs

356 to be approximated linearly

357 */

358 k = FFMIN(freq >> 8, 63);

359 diff = freq & 0xFF;

360

361 /* Calculate linear approximation */

362 tmp = cos_derivative_tbl[k] * diff;

363 lsp[i] = cos_tbl[k] + (tmp >> 12);

364 }

365 }

366

367 static void get_lsp_poly(int16_t *lsp, int32_t *f)

368 {

369 int16_t high, low;

370 int i, j, k, l;

371 int32_t tmp;

372

373 f[0] = 16777216;

374 f[1] = lsp[0] * -1024;

375

376 for (i = 2, k = 2, l = 2; i <= 5; i++, k += 2) {

377 f[l] = f[l - 2];

378

379 for (j = i; j > 1; j--, l--) {

380 high = f[l - 1] >> 16;

381 low = (f[l - 1] - (high * (1 << 16))) >> 1;

382

383 tmp = ((high * lsp[k]) * 4) + (((low * lsp[k]) >> 15) * 4);

384

385 f[l] += f[l - 2];

386 f[l] -= (unsigned)tmp;

387 }

388

389 f[l] -= lsp[k] * (1 << 10);

390 l += i;

391 }

392 }

393

394 static void lsf2poly(int16_t *a, int16_t *lsf)

395 {

396 int32_t f[2][6];

397 int16_t lsp[10];

398 int32_t tmp;

399 int i;

400

401 lsf2lsp(lsf, lsp, LPC_FILTERORDER);

402

403 get_lsp_poly(&lsp[0], f[0]);

404 get_lsp_poly(&lsp[1], f[1]);

405

406 for (i = 5; i > 0; i--) {

407 f[0][i] += (unsigned)f[0][i - 1];

408 f[1][i] -= (unsigned)f[1][i - 1];

409 }

410

411 a[0] = 4096;

412 for (i = 5; i > 0; i--) {

413 tmp = f[0][6 - i] + (unsigned)f[1][6 - i] + 4096;

414 a[6 - i] = tmp >> 13;

415

416 tmp = f[0][6 - i] - (unsigned)f[1][6 - i] + 4096;

417 a[5 + i] = tmp >> 13;

418 }

419 }

420

421 static void lsp_interpolate2polydec(int16_t *a, int16_t *lsf1,

422 int16_t *lsf2, int coef, int length)

423 {

424 int16_t lsftmp[LPC_FILTERORDER];

425

426 lsf_interpolate(lsftmp, lsf1, lsf2, coef, length);

427 lsf2poly(a, lsftmp);

428 }

429

430 static void bw_expand(int16_t *out, const int16_t *in, const int16_t *coef, int length)

431 {

432 int i;

433

434 out[0] = in[0];

435 for (i = 1; i < length; i++)

436 out[i] = (coef[i] * in[i] + 16384) >> 15;

437 }

438

439 static void lsp_interpolate(int16_t *syntdenum, int16_t *weightdenum,

440 int16_t *lsfdeq, int16_t length,

441 ILBCContext *s)

442 {

443 int16_t lp[LPC_FILTERORDER + 1], *lsfdeq2;

444 int i, pos, lp_length;

445

446 lsfdeq2 = lsfdeq + length;

447 lp_length = length + 1;

448

449 if (s->mode == 30) {

450 lsp_interpolate2polydec(lp, (*s).lsfdeqold, lsfdeq, lsf_weight_30ms[0], length);

451 memcpy(syntdenum, lp, lp_length * 2);

452 bw_expand(weightdenum, lp, kLpcChirpSyntDenum, lp_length);

453

454 pos = lp_length;

455 for (i = 1; i < 6; i++) {

456 lsp_interpolate2polydec(lp, lsfdeq, lsfdeq2,

457 lsf_weight_30ms[i],

458 length);

459 memcpy(syntdenum + pos, lp, lp_length * 2);

460 bw_expand(weightdenum + pos, lp, kLpcChirpSyntDenum, lp_length);

461 pos += lp_length;

462 }

463 } else {

464 pos = 0;

465 for (i = 0; i < s->nsub; i++) {

466 lsp_interpolate2polydec(lp, s->lsfdeqold, lsfdeq,

467 lsf_weight_20ms[i], length);

468 memcpy(syntdenum + pos, lp, lp_length * 2);

469 bw_expand(weightdenum + pos, lp, kLpcChirpSyntDenum, lp_length);

470 pos += lp_length;

471 }

472 }

473

474 if (s->mode == 30) {

475 memcpy(s->lsfdeqold, lsfdeq2, length * 2);

476 } else {

477 memcpy(s->lsfdeqold, lsfdeq, length * 2);

478 }

479 }

480

481 static void filter_mafq12(int16_t *in_ptr, int16_t *out_ptr,

482 int16_t *B, int16_t B_length,

483 int16_t length)

484 {

485 int o, i, j;

486

487 for (i = 0; i < length; i++) {

488 const int16_t *b_ptr = &B[0];

489 const int16_t *x_ptr = &in_ptr[i];

490

491 o = 0;

492 for (j = 0; j < B_length; j++)

493 o += b_ptr[j] * *x_ptr--;

494

495 o = av_clip(o, -134217728, 134215679);

496

497 out_ptr[i] = ((o + 2048) >> 12);

498 }

499 }

500

501 static void filter_arfq12(const int16_t *data_in,

502 int16_t *data_out,

503 const int16_t *coefficients,

504 int coefficients_length,

505 int data_length)

506 {

507 int i, j;

508

509 for (i = 0; i < data_length; i++) {

510 int output = 0, sum = 0;

511

512 for (j = coefficients_length - 1; j > 0; j--) {

513 sum += (unsigned)(coefficients[j] * data_out[i - j]);

514 }

515

516 output = coefficients[0] * data_in[i] - (unsigned)sum;

517 output = av_clip(output, -134217728, 134215679);

518

519 data_out[i] = (output + 2048) >> 12;

520 }

521 }

522

523 static void state_construct(int16_t ifm, int16_t *idx,

524 int16_t *synt_denum, int16_t *Out_fix,

525 int16_t len)

526 {

527 int k;

528 int16_t maxVal;

529 int16_t *tmp1, *tmp2, *tmp3;

530 /* Stack based */

531 int16_t numerator[1 + LPC_FILTERORDER];

532 int16_t sampleValVec[2 * STATE_SHORT_LEN_30MS + LPC_FILTERORDER];

533 int16_t sampleMaVec[2 * STATE_SHORT_LEN_30MS + LPC_FILTERORDER];

534 int16_t *sampleVal = &sampleValVec[LPC_FILTERORDER];

535 int16_t *sampleMa = &sampleMaVec[LPC_FILTERORDER];

536 int16_t *sampleAr = &sampleValVec[LPC_FILTERORDER];

537

538 /* initialization of coefficients */

539

540 for (k = 0; k < LPC_FILTERORDER + 1; k++) {

541 numerator[k] = synt_denum[LPC_FILTERORDER - k];

542 }

543

544 /* decoding of the maximum value */

545

546 maxVal = frg_quant_mod[ifm];

547

548 /* decoding of the sample values */

549 tmp1 = sampleVal;

550 tmp2 = &idx[len - 1];

551

552 if (ifm < 37) {

553 for (k = 0; k < len; k++) {

554 /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 2097152 (= 0.5 << 22)

555 maxVal is in Q8 and result is in Q(-1) */

556 (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 2097152) >> 22);

557 tmp1++;

558 tmp2--;

559 }

560 } else if (ifm < 59) {

561 for (k = 0; k < len; k++) {

562 /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 262144 (= 0.5 << 19)

563 maxVal is in Q5 and result is in Q(-1) */

564 (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 262144) >> 19);

565 tmp1++;

566 tmp2--;

567 }

568 } else {

569 for (k = 0; k < len; k++) {

570 /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 65536 (= 0.5 << 17)

571 maxVal is in Q3 and result is in Q(-1) */

572 (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 65536) >> 17);

573 tmp1++;

574 tmp2--;

575 }

576 }

577

578 /* Set the rest of the data to zero */

579 memset(&sampleVal[len], 0, len * 2);

580

581 /* circular convolution with all-pass filter */

582

583 /* Set the state to zero */

584 memset(sampleValVec, 0, LPC_FILTERORDER * 2);

585

586 /* Run MA filter + AR filter */

587 filter_mafq12(sampleVal, sampleMa, numerator, LPC_FILTERORDER + 1, len + LPC_FILTERORDER);

588 memset(&sampleMa[len + LPC_FILTERORDER], 0, (len - LPC_FILTERORDER) * 2);

589 filter_arfq12(sampleMa, sampleAr, synt_denum, LPC_FILTERORDER + 1, 2 * len);

590

591 tmp1 = &sampleAr[len - 1];

592 tmp2 = &sampleAr[2 * len - 1];

593 tmp3 = Out_fix;

594 for (k = 0; k < len; k++) {

595 (*tmp3) = (*tmp1) + (*tmp2);

596 tmp1--;

597 tmp2--;

598 tmp3++;

599 }

600 }

601

602 static int16_t gain_dequantization(int index, int max_in, int stage)

603 {

604 int16_t scale = FFMAX(1638, FFABS(max_in));

605

606 return ((scale * ilbc_gain[stage][index]) + 8192) >> 14;

607 }

608

609 static void vector_rmultiplication(int16_t *out, const int16_t *in,

610 const int16_t *win,

611 int length, int shift)

612 {

613 for (int i = 0; i < length; i++)

614 out[i] = (in[i] * win[-i]) >> shift;

615 }

616

617 static void vector_multiplication(int16_t *out, const int16_t *in,

618 const int16_t *win, int length,

619 int shift)

620 {

621 for (int i = 0; i < length; i++)

622 out[i] = (in[i] * win[i]) >> shift;

623 }

624

625 static void add_vector_and_shift(int16_t *out, const int16_t *in1,

626 const int16_t *in2, int length,

627 int shift)

628 {

629 for (int i = 0; i < length; i++)

630 out[i] = (in1[i] + in2[i]) >> shift;

631 }

632

633 static void create_augmented_vector(int index, int16_t *buffer, int16_t *cbVec)

634 {

635 int16_t cbVecTmp[4];

636 int interpolation_length = FFMIN(4, index);

637 int16_t ilow = index - interpolation_length;

638

639 memcpy(cbVec, buffer - index, index * 2);

640

641 vector_multiplication(&cbVec[ilow], buffer - index - interpolation_length, alpha, interpolation_length, 15);

642 vector_rmultiplication(cbVecTmp, buffer - interpolation_length, &alpha[interpolation_length - 1], interpolation_length, 15);

643 add_vector_and_shift(&cbVec[ilow], &cbVec[ilow], cbVecTmp, interpolation_length, 0);

644

645 memcpy(cbVec + index, buffer - index, FFMIN(SUBL - index, index) * sizeof(*cbVec));

646 }

647

648 static void get_codebook(int16_t * cbvec, /* (o) Constructed codebook vector */

649 int16_t * mem, /* (i) Codebook buffer */

650 int16_t index, /* (i) Codebook index */

651 int16_t lMem, /* (i) Length of codebook buffer */

652 int16_t cbveclen /* (i) Codebook vector length */

653 )

654 {

655 int16_t k, base_size;

656 int16_t lag;

657 /* Stack based */

658 int16_t tempbuff2[SUBL + 5];

659

660 /* Determine size of codebook sections */

661 base_size = lMem - cbveclen + 1;

662

663 if (cbveclen == SUBL) {

664 base_size += cbveclen / 2;

665 }

666

667 /* No filter -> First codebook section */

668 if (index < lMem - cbveclen + 1) {

669 /* first non-interpolated vectors */

670

671 k = index + cbveclen;

672 /* get vector */

673 memcpy(cbvec, mem + lMem - k, cbveclen * 2);

674 } else if (index < base_size) {

675

676 /* Calculate lag */

677

678 k = (int16_t) SPL_MUL_16_16(2, (index - (lMem - cbveclen + 1))) + cbveclen;

679

680 lag = k / 2;

681

682 create_augmented_vector(lag, mem + lMem, cbvec);

683 } else {

684 int16_t memIndTest;

685

686 /* first non-interpolated vectors */

687

688 if (index - base_size < lMem - cbveclen + 1) {

689

690 /* Set up filter memory, stuff zeros outside memory buffer */

691

692 memIndTest = lMem - (index - base_size + cbveclen);

693

694 memset(mem - CB_HALFFILTERLEN, 0, CB_HALFFILTERLEN * 2);

695 memset(mem + lMem, 0, CB_HALFFILTERLEN * 2);

696

697 /* do filtering to get the codebook vector */

698

699 filter_mafq12(&mem[memIndTest + 4], cbvec, (int16_t *) kCbFiltersRev, CB_FILTERLEN, cbveclen);

700 } else {

701 /* interpolated vectors */

702 /* Stuff zeros outside memory buffer */

703 memIndTest = lMem - cbveclen - CB_FILTERLEN;

704 memset(mem + lMem, 0, CB_HALFFILTERLEN * 2);

705

706 /* do filtering */

707 filter_mafq12(&mem[memIndTest + 7], tempbuff2, (int16_t *) kCbFiltersRev, CB_FILTERLEN, (int16_t) (cbveclen + 5));

708

709 /* Calculate lag index */

710 lag = (cbveclen << 1) - 20 + index - base_size - lMem - 1;

711

712 create_augmented_vector(lag, tempbuff2 + SUBL + 5, cbvec);

713 }

714 }

715 }

716

717 static void construct_vector (

718 int16_t *decvector, /* (o) Decoded vector */

719 int16_t *index, /* (i) Codebook indices */

720 int16_t *gain_index, /* (i) Gain quantization indices */

721 int16_t *mem, /* (i) Buffer for codevector construction */

722 int16_t lMem, /* (i) Length of buffer */

723 int16_t veclen)

724 {

725 int16_t gain[CB_NSTAGES];

726 int16_t cbvec0[SUBL];

727 int16_t cbvec1[SUBL];

728 int16_t cbvec2[SUBL];

729 unsigned a32;

730 int16_t *gainPtr;

731 int j;

732

733 /* gain de-quantization */

734

735 gain[0] = gain_dequantization(gain_index[0], 16384, 0);

736 gain[1] = gain_dequantization(gain_index[1], gain[0], 1);

737 gain[2] = gain_dequantization(gain_index[2], gain[1], 2);

738

739 /* codebook vector construction and construction of total vector */

740

741 /* Stack based */

742 get_codebook(cbvec0, mem, index[0], lMem, veclen);

743 get_codebook(cbvec1, mem, index[1], lMem, veclen);

744 get_codebook(cbvec2, mem, index[2], lMem, veclen);

745

746 gainPtr = &gain[0];

747 for (j = 0; j < veclen; j++) {

748 a32 = SPL_MUL_16_16(*gainPtr++, cbvec0[j]);

749 a32 += SPL_MUL_16_16(*gainPtr++, cbvec1[j]);

750 a32 += SPL_MUL_16_16(*gainPtr, cbvec2[j]);

751 gainPtr -= 2;

752 decvector[j] = (int)(a32 + 8192) >> 14;

753 }

754 }

755

756 static void reverse_memcpy(int16_t *dest, int16_t *source, int length)

757 {

758 int16_t* destPtr = dest;

759 int16_t* sourcePtr = source;

760 int j;

761

762 for (j = 0; j < length; j++)

763 *destPtr-- = *sourcePtr++;

764 }

765

766 static void decode_residual(ILBCContext *s,

767 ILBCFrame *encbits,

768 int16_t *decresidual,

769 int16_t *syntdenum)

770 {

771 int16_t meml_gotten, Nfor, Nback, diff, start_pos;

772 int16_t subcount, subframe;

773 int16_t *reverseDecresidual = s->enh_buf; /* Reversed decoded data, used for decoding backwards in time (reuse memory in state) */

774 int16_t *memVec = s->prevResidual;

775 int16_t *mem = &memVec[CB_HALFFILTERLEN]; /* Memory for codebook */

776

777 diff = STATE_LEN - s->state_short_len;

778

779 if (encbits->state_first == 1) {

780 start_pos = (encbits->start - 1) * SUBL;

781 } else {

782 start_pos = (encbits->start - 1) * SUBL + diff;

783 }

784

785 /* decode scalar part of start state */

786

787 state_construct(encbits->ifm, encbits->idx, &syntdenum[(encbits->start - 1) * (LPC_FILTERORDER + 1)], &decresidual[start_pos], s->state_short_len);

788

789 if (encbits->state_first) { /* put adaptive part in the end */

790 /* setup memory */

791 memset(mem, 0, (int16_t) (CB_MEML - s->state_short_len) * 2);

792 memcpy(mem + CB_MEML - s->state_short_len, decresidual + start_pos, s->state_short_len * 2);

793

794 /* construct decoded vector */

795

796 construct_vector(&decresidual[start_pos + s->state_short_len], encbits->cb_index, encbits->gain_index, mem + CB_MEML - ST_MEM_L_TBL, ST_MEM_L_TBL, (int16_t) diff);

797

798 } else { /* put adaptive part in the beginning */

799 /* setup memory */

800 meml_gotten = s->state_short_len;

801 reverse_memcpy(mem + CB_MEML - 1, decresidual + start_pos, meml_gotten);

802 memset(mem, 0, (int16_t) (CB_MEML - meml_gotten) * 2);

803

804 /* construct decoded vector */

805 construct_vector(reverseDecresidual, encbits->cb_index, encbits->gain_index, mem + CB_MEML - ST_MEM_L_TBL, ST_MEM_L_TBL, diff);

806

807 /* get decoded residual from reversed vector */

808 reverse_memcpy(&decresidual[start_pos - 1], reverseDecresidual, diff);

809 }

810

811 /* counter for predicted subframes */

812 subcount = 1;

813

814 /* forward prediction of subframes */

815 Nfor = s->nsub - encbits->start - 1;

816

817 if (Nfor > 0) {

818 /* setup memory */

819 memset(mem, 0, (CB_MEML - STATE_LEN) * 2);

820 memcpy(mem + CB_MEML - STATE_LEN, decresidual + (encbits->start - 1) * SUBL, STATE_LEN * 2);

821

822 /* loop over subframes to encode */

823 for (subframe = 0; subframe < Nfor; subframe++) {

824 /* construct decoded vector */

825 construct_vector(&decresidual[(encbits->start + 1 + subframe) * SUBL], encbits->cb_index + subcount * CB_NSTAGES, encbits->gain_index + subcount * CB_NSTAGES, mem, MEM_LF_TBL, SUBL);

826

827 /* update memory */

828 memmove(mem, mem + SUBL, (CB_MEML - SUBL) * sizeof(*mem));

829 memcpy(mem + CB_MEML - SUBL, &decresidual[(encbits->start + 1 + subframe) * SUBL], SUBL * 2);

830

831 subcount++;

832 }

833

834 }

835

836 /* backward prediction of subframes */

837 Nback = encbits->start - 1;

838

839 if (Nback > 0) {

840 /* setup memory */

841 meml_gotten = SUBL * (s->nsub + 1 - encbits->start);

842 if (meml_gotten > CB_MEML) {

843 meml_gotten = CB_MEML;

844 }

845

846 reverse_memcpy(mem + CB_MEML - 1, decresidual + (encbits->start - 1) * SUBL, meml_gotten);

847 memset(mem, 0, (int16_t) (CB_MEML - meml_gotten) * 2);

848

849 /* loop over subframes to decode */

850 for (subframe = 0; subframe < Nback; subframe++) {

851 /* construct decoded vector */

852 construct_vector(&reverseDecresidual[subframe * SUBL], encbits->cb_index + subcount * CB_NSTAGES,

853 encbits->gain_index + subcount * CB_NSTAGES, mem, MEM_LF_TBL, SUBL);

854

855 /* update memory */

856 memmove(mem, mem + SUBL, (CB_MEML - SUBL) * sizeof(*mem));

857 memcpy(mem + CB_MEML - SUBL, &reverseDecresidual[subframe * SUBL], SUBL * 2);

858

859 subcount++;

860 }

861

862 /* get decoded residual from reversed vector */

863 reverse_memcpy(decresidual + SUBL * Nback - 1, reverseDecresidual, SUBL * Nback);

864 }

865 }

866

867 static int16_t max_abs_value_w16(const int16_t* vector, int length)

868 {

869 int i = 0, absolute = 0, maximum = 0;

870

871 if (vector == NULL || length <= 0) {

872 return -1;

873 }

874

875 for (i = 0; i < length; i++) {

876 absolute = FFABS(vector[i]);

877 if (absolute > maximum)

878 maximum = absolute;

879 }

880

881 // Guard the case for abs(-32768).

882 return FFMIN(maximum, INT16_MAX);

883 }

884

885 static int16_t get_size_in_bits(uint32_t n)

886 {

887 int16_t bits;

888

889 if (0xFFFF0000 & n) {

890 bits = 16;

891 } else {

892 bits = 0;

893 }

894

895 if (0x0000FF00 & (n >> bits)) bits += 8;

896 if (0x000000F0 & (n >> bits)) bits += 4;

897 if (0x0000000C & (n >> bits)) bits += 2;

898 if (0x00000002 & (n >> bits)) bits += 1;

899 if (0x00000001 & (n >> bits)) bits += 1;

900

901 return bits;

902 }

903

904 static int32_t scale_dot_product(const int16_t *v1, const int16_t *v2, int length, int scaling)

905 {

906 int64_t sum = 0;

907

908 for (int i = 0; i < length; i++)

909 sum += (v1[i] * v2[i]) >> scaling;

910

911 return av_clipl_int32(sum);

912 }

913

914 static void correlation(int32_t *corr, int32_t *ener, int16_t *buffer,

915 int16_t lag, int16_t blen, int16_t srange, int16_t scale)

916 {

917 int16_t *w16ptr;

918

919 w16ptr = &buffer[blen - srange - lag];

920

921 *corr = scale_dot_product(&buffer[blen - srange], w16ptr, srange, scale);

922 *ener = scale_dot_product(w16ptr, w16ptr, srange, scale);

923

924 if (*ener == 0) {

925 *corr = 0;

926 *ener = 1;

927 }

928 }

929

930 #define SPL_SHIFT_W32(x, c) (((c) >= 0) ? ((x) << (c)) : ((x) >> (-(c))))

931

932 static int16_t norm_w32(int32_t a)

933 {

934 if (a == 0) {

935 return 0;

936 } else if (a < 0) {

937 a = ~a;

938 }

939

940 return ff_clz(a);

941 }

942

943 static int32_t div_w32_w16(int32_t num, int16_t den)

944 {

945 if (den != 0)

946 return num / den;

947 else

948 return 0x7FFFFFFF;

949 }

950

951 static void do_plc(int16_t *plc_residual, /* (o) concealed residual */

952 int16_t *plc_lpc, /* (o) concealed LP parameters */

953 int16_t PLI, /* (i) packet loss indicator

954 0 - no PL, 1 = PL */

955 int16_t *decresidual, /* (i) decoded residual */

956 int16_t *lpc, /* (i) decoded LPC (only used for no PL) */

957 int16_t inlag, /* (i) pitch lag */

958 ILBCContext *s) /* (i/o) decoder instance */

959 {

960 int16_t i, pick;

961 int32_t cross, ener, cross_comp, ener_comp = 0;

962 int32_t measure, max_measure, energy;

963 int16_t max, cross_square_max, cross_square;

964 int16_t j, lag, tmp1, tmp2, randlag;

965 int16_t shift1, shift2, shift3, shift_max;

966 int16_t scale3;

967 int16_t corrLen;

968 int32_t tmpW32, tmp2W32;

969 int16_t use_gain;

970 int16_t tot_gain;

971 int16_t max_perSquare;

972 int16_t scale1, scale2;

973 int16_t totscale;

974 int32_t nom;

975 int16_t denom;

976 int16_t pitchfact;

977 int16_t use_lag;

978 int ind;

979 int16_t randvec[BLOCKL_MAX];

980

981 /* Packet Loss */

982 if (PLI == 1) {

983

984 s->consPLICount += 1;

985

986 /* if previous frame not lost,

987 determine pitch pred. gain */

988

989 if (s->prevPLI != 1) {

990

991 /* Maximum 60 samples are correlated, preserve as high accuracy

992 as possible without getting overflow */

993 max = max_abs_value_w16(s->prevResidual, s->block_samples);

994 scale3 = (get_size_in_bits(max) << 1) - 25;

995 if (scale3 < 0) {

996 scale3 = 0;

997 }

998

999 /* Store scale for use when interpolating between the

1000 * concealment and the received packet */

1001 s->prevScale = scale3;

1002

1003 /* Search around the previous lag +/-3 to find the

1004 best pitch period */

1005 lag = inlag - 3;

1006

1007 /* Guard against getting outside the frame */

1008 corrLen = FFMIN(60, s->block_samples - (inlag + 3));

1009

1010 correlation(&cross, &ener, s->prevResidual, lag, s->block_samples, corrLen, scale3);

1011

1012 /* Normalize and store cross^2 and the number of shifts */

1013 shift_max = get_size_in_bits(FFABS(cross)) - 15;

1014 cross_square_max = (int16_t) SPL_MUL_16_16_RSFT(SPL_SHIFT_W32(cross, -shift_max), SPL_SHIFT_W32(cross, -shift_max), 15);

1015

1016 for (j = inlag - 2; j <= inlag + 3; j++) {

1017 correlation(&cross_comp, &ener_comp, s->prevResidual, j, s->block_samples, corrLen, scale3);

1018

1019 /* Use the criteria (corr*corr)/energy to compare if

1020 this lag is better or not. To avoid the division,

1021 do a cross multiplication */

1022 shift1 = get_size_in_bits(FFABS(cross_comp)) - 15;

1023 cross_square = (int16_t) SPL_MUL_16_16_RSFT(SPL_SHIFT_W32(cross_comp, -shift1), SPL_SHIFT_W32(cross_comp, -shift1), 15);

1024

1025 shift2 = get_size_in_bits(ener) - 15;

1026 measure = SPL_MUL_16_16(SPL_SHIFT_W32(ener, -shift2), cross_square);

1027

1028 shift3 = get_size_in_bits(ener_comp) - 15;

1029 max_measure = SPL_MUL_16_16(SPL_SHIFT_W32(ener_comp, -shift3), cross_square_max);

1030

1031 /* Calculate shift value, so that the two measures can

1032 be put in the same Q domain */

1033 if (((shift_max << 1) + shift3) > ((shift1 << 1) + shift2)) {

1034 tmp1 = FFMIN(31, (shift_max << 1) + shift3 - (shift1 << 1) - shift2);

1035 tmp2 = 0;

1036 } else {

1037 tmp1 = 0;

1038 tmp2 = FFMIN(31, (shift1 << 1) + shift2 - (shift_max << 1) - shift3);

1039 }

1040

1041 if ((measure >> tmp1) > (max_measure >> tmp2)) {

1042 /* New lag is better => record lag, measure and domain */

1043 lag = j;

1044 cross_square_max = cross_square;

1045 cross = cross_comp;

1046 shift_max = shift1;

1047 ener = ener_comp;

1048 }

1049 }

1050

1051 /* Calculate the periodicity for the lag with the maximum correlation.

1052

1053 Definition of the periodicity:

1054 abs(corr(vec1, vec2))/(sqrt(energy(vec1))*sqrt(energy(vec2)))

1055

1056 Work in the Square domain to simplify the calculations

1057 max_perSquare is less than 1 (in Q15)

1058 */

1059 tmp2W32 = scale_dot_product(&s->prevResidual[s->block_samples - corrLen], &s->prevResidual[s->block_samples - corrLen], corrLen, scale3);

1060

1061 if ((tmp2W32 > 0) && (ener_comp > 0)) {

1062 /* norm energies to int16_t, compute the product of the energies and

1063 use the upper int16_t as the denominator */

1064

1065 scale1 = norm_w32(tmp2W32) - 16;

1066 tmp1 = SPL_SHIFT_W32(tmp2W32, scale1);

1067

1068 scale2 = norm_w32(ener) - 16;

1069 tmp2 = SPL_SHIFT_W32(ener, scale2);

1070 denom = SPL_MUL_16_16_RSFT(tmp1, tmp2, 16); /* denom in Q(scale1+scale2-16) */

1071

1072 /* Square the cross correlation and norm it such that max_perSquare

1073 will be in Q15 after the division */

1074

1075 totscale = scale1 + scale2 - 1;

1076 tmp1 = SPL_SHIFT_W32(cross, (totscale >> 1));

1077 tmp2 = SPL_SHIFT_W32(cross, totscale - (totscale >> 1));

1078

1079 nom = SPL_MUL_16_16(tmp1, tmp2);

1080 max_perSquare = div_w32_w16(nom, denom);

1081 } else {

1082 max_perSquare = 0;

1083 }

1084 } else {

1085 /* previous frame lost, use recorded lag and gain */

1086 lag = s->prevLag;

1087 max_perSquare = s->per_square;

1088 }

1089

1090 /* Attenuate signal and scale down pitch pred gain if

1091 several frames lost consecutively */

1092

1093 use_gain = 32767; /* 1.0 in Q15 */

1094

1095 if (s->consPLICount * s->block_samples > 320) {

1096 use_gain = 29491; /* 0.9 in Q15 */

1097 } else if (s->consPLICount * s->block_samples > 640) {

1098 use_gain = 22938; /* 0.7 in Q15 */

1099 } else if (s->consPLICount * s->block_samples > 960) {

1100 use_gain = 16384; /* 0.5 in Q15 */

1101 } else if (s->consPLICount * s->block_samples > 1280) {

1102 use_gain = 0; /* 0.0 in Q15 */

1103 }

1104

1105 /* Compute mixing factor of picth repeatition and noise:

1106 for max_per>0.7 set periodicity to 1.0

1107 0.4<max_per<0.7 set periodicity to (maxper-0.4)/0.7-0.4)

1108 max_per<0.4 set periodicity to 0.0

1109 */

1110

1111 if (max_perSquare > 7868) { /* periodicity > 0.7 (0.7^4=0.2401 in Q15) */

1112 pitchfact = 32767;

1113 } else if (max_perSquare > 839) { /* 0.4 < periodicity < 0.7 (0.4^4=0.0256 in Q15) */

1114 /* find best index and interpolate from that */

1115 ind = 5;

1116 while ((max_perSquare < kPlcPerSqr[ind]) && (ind > 0)) {

1117 ind--;

1118 }

1119 /* pitch fact is approximated by first order */

1120 tmpW32 = kPlcPitchFact[ind] + SPL_MUL_16_16_RSFT(kPlcPfSlope[ind], (max_perSquare - kPlcPerSqr[ind]), 11);

1121

1122 pitchfact = FFMIN(tmpW32, 32767); /* guard against overflow */

1123

1124 } else { /* periodicity < 0.4 */

1125 pitchfact = 0;

1126 }

1127

1128 /* avoid repetition of same pitch cycle (buzzyness) */

1129 use_lag = lag;

1130 if (lag < 80) {

1131 use_lag = 2 * lag;

1132 }

1133

1134 /* compute concealed residual */

1135 energy = 0;

1136

1137 for (i = 0; i < s->block_samples; i++) {

1138 /* noise component - 52 < randlagFIX < 117 */

1139 s->seed = SPL_MUL_16_16(s->seed, 31821) + 13849;

1140 randlag = 53 + (s->seed & 63);

1141

1142 pick = i - randlag;

1143

1144 if (pick < 0) {

1145 randvec[i] = s->prevResidual[s->block_samples + pick];

1146 } else {

1147 randvec[i] = s->prevResidual[pick];

1148 }

1149

1150 /* pitch repeatition component */

1151 pick = i - use_lag;

1152

1153 if (pick < 0) {

1154 plc_residual[i] = s->prevResidual[s->block_samples + pick];

1155 } else {

1156 plc_residual[i] = plc_residual[pick];

1157 }

1158

1159 /* Attinuate total gain for each 10 ms */

1160 if (i < 80) {

1161 tot_gain = use_gain;

1162 } else if (i < 160) {

1163 tot_gain = SPL_MUL_16_16_RSFT(31130, use_gain, 15); /* 0.95*use_gain */

1164 } else {

1165 tot_gain = SPL_MUL_16_16_RSFT(29491, use_gain, 15); /* 0.9*use_gain */

1166 }

1167

1168 /* mix noise and pitch repeatition */

1169 plc_residual[i] = SPL_MUL_16_16_RSFT(tot_gain, (pitchfact * plc_residual[i] + (32767 - pitchfact) * randvec[i] + 16384) >> 15, 15);

1170

1171 /* Shifting down the result one step extra to ensure that no overflow

1172 will occur */

1173 energy += SPL_MUL_16_16_RSFT(plc_residual[i], plc_residual[i], (s->prevScale + 1));

1174

1175 }

1176

1177 /* less than 30 dB, use only noise */

1178 if (energy < SPL_SHIFT_W32(s->block_samples * 900, -s->prevScale - 1)) {

1179 energy = 0;

1180 for (i = 0; i < s->block_samples; i++) {

1181 plc_residual[i] = randvec[i];

1182 }

1183 }

1184

1185 /* use the old LPC */

1186 memcpy(plc_lpc, (*s).prev_lpc, (LPC_FILTERORDER + 1) * 2);

1187

1188 /* Update state in case there are multiple frame losses */

1189 s->prevLag = lag;

1190 s->per_square = max_perSquare;

1191 } else { /* no packet loss, copy input */

1192 memcpy(plc_residual, decresidual, s->block_samples * 2);

1193 memcpy(plc_lpc, lpc, (LPC_FILTERORDER + 1) * 2);

1194 s->consPLICount = 0;

1195 }

1196

1197 /* update state */

1198 s->prevPLI = PLI;

1199 memcpy(s->prev_lpc, plc_lpc, (LPC_FILTERORDER + 1) * 2);

1200 memcpy(s->prevResidual, plc_residual, s->block_samples * 2);

1201

1202 return;

1203 }

1204

1205 static int xcorr_coeff(int16_t *target, int16_t *regressor,

1206 int16_t subl, int16_t searchLen,

1207 int16_t offset, int16_t step)

1208 {

1209 int16_t maxlag;

1210 int16_t pos;

1211 int16_t max;

1212 int16_t cross_corr_scale, energy_scale;

1213 int16_t cross_corr_sg_mod, cross_corr_sg_mod_max;

1214 int32_t cross_corr, energy;

1215 int16_t cross_corr_mod, energy_mod, enery_mod_max;

1216 int16_t *tp, *rp;

1217 int16_t *rp_beg, *rp_end;

1218 int16_t totscale, totscale_max;

1219 int16_t scalediff;

1220 int32_t new_crit, max_crit;

1221 int shifts;

1222 int k;

1223

1224 /* Initializations, to make sure that the first one is selected */

1225 cross_corr_sg_mod_max = 0;

1226 enery_mod_max = INT16_MAX;

1227 totscale_max = -500;

1228 maxlag = 0;

1229 pos = 0;

1230

1231 /* Find scale value and start position */

1232 if (step == 1) {

1233 max = max_abs_value_w16(regressor, (int16_t) (subl + searchLen - 1));

1234 rp_beg = regressor;

1235 rp_end = &regressor[subl];

1236 } else { /* step== -1 */

1237 max = max_abs_value_w16(&regressor[-searchLen], (int16_t) (subl + searchLen - 1));

1238 rp_beg = &regressor[-1];

1239 rp_end = &regressor[subl - 1];

1240 }

1241

1242 /* Introduce a scale factor on the energy in int32_t in

1243 order to make sure that the calculation does not

1244 overflow */

1245

1246 if (max > 5000) {

1247 shifts = 2;

1248 } else {

1249 shifts = 0;

1250 }

1251

1252 /* Calculate the first energy, then do a +/- to get the other energies */

1253 energy = scale_dot_product(regressor, regressor, subl, shifts);

1254

1255 for (k = 0; k < searchLen; k++) {

1256 tp = target;

1257 rp = &regressor[pos];

1258

1259 cross_corr = scale_dot_product(tp, rp, subl, shifts);

1260

1261 if ((energy > 0) && (cross_corr > 0)) {

1262 /* Put cross correlation and energy on 16 bit word */

1263 cross_corr_scale = norm_w32(cross_corr) - 16;

1264 cross_corr_mod = (int16_t) SPL_SHIFT_W32(cross_corr, cross_corr_scale);

1265 energy_scale = norm_w32(energy) - 16;

1266 energy_mod = (int16_t) SPL_SHIFT_W32(energy, energy_scale);

1267

1268 /* Square cross correlation and store upper int16_t */

1269 cross_corr_sg_mod = (int16_t) SPL_MUL_16_16_RSFT(cross_corr_mod, cross_corr_mod, 16);

1270

1271 /* Calculate the total number of (dynamic) right shifts that have

1272 been performed on (cross_corr*cross_corr)/energy

1273 */

1274 totscale = energy_scale - (cross_corr_scale * 2);

1275

1276 /* Calculate the shift difference in order to be able to compare the two

1277 (cross_corr*cross_corr)/energy in the same domain

1278 */

1279 scalediff = totscale - totscale_max;

1280 scalediff = FFMIN(scalediff, 31);

1281 scalediff = FFMAX(scalediff, -31);

1282

1283 /* Compute the cross multiplication between the old best criteria

1284 and the new one to be able to compare them without using a

1285 division */

1286

1287 if (scalediff < 0) {

1288 new_crit = ((int32_t) cross_corr_sg_mod * enery_mod_max) >> (-scalediff);

1289 max_crit = ((int32_t) cross_corr_sg_mod_max * energy_mod);

1290 } else {

1291 new_crit = ((int32_t) cross_corr_sg_mod * enery_mod_max);

1292 max_crit = ((int32_t) cross_corr_sg_mod_max * energy_mod) >> scalediff;

1293 }

1294

1295 /* Store the new lag value if the new criteria is larger

1296 than previous largest criteria */

1297

1298 if (new_crit > max_crit) {

1299 cross_corr_sg_mod_max = cross_corr_sg_mod;

1300 enery_mod_max = energy_mod;

1301 totscale_max = totscale;

1302 maxlag = k;

1303 }

1304 }

1305 pos += step;

1306

1307 /* Do a +/- to get the next energy */

1308 energy += (unsigned)step * ((*rp_end * *rp_end - *rp_beg * *rp_beg) >> shifts);

1309

1310 rp_beg += step;

1311 rp_end += step;

1312 }

1313

1314 return maxlag + offset;

1315 }

1316

1317 static void hp_output(int16_t *signal, const int16_t *ba, int16_t *y,

1318 int16_t *x, int16_t len)

1319 {

1320 int32_t tmp;

1321

1322 for (int i = 0; i < len; i++) {

1323 tmp = SPL_MUL_16_16(y[1], ba[3]); /* (-a[1])*y[i-1] (low part) */

1324 tmp += SPL_MUL_16_16(y[3], ba[4]); /* (-a[2])*y[i-2] (low part) */

1325 tmp = (tmp >> 15);

1326 tmp += SPL_MUL_16_16(y[0], ba[3]); /* (-a[1])*y[i-1] (high part) */

1327 tmp += SPL_MUL_16_16(y[2], ba[4]); /* (-a[2])*y[i-2] (high part) */

1328 tmp = (tmp * 2);

1329

1330 tmp += SPL_MUL_16_16(signal[i], ba[0]); /* b[0]*x[0] */

1331 tmp += SPL_MUL_16_16(x[0], ba[1]); /* b[1]*x[i-1] */

1332 tmp += SPL_MUL_16_16(x[1], ba[2]); /* b[2]*x[i-2] */

1333

1334 /* Update state (input part) */

1335 x[1] = x[0];

1336 x[0] = signal[i];

1337

1338 /* Convert back to Q0 and multiply with 2 */

1339 signal[i] = av_clip_intp2(tmp + 1024, 26) >> 11;

1340

1341 /* Update state (filtered part) */

1342 y[2] = y[0];

1343 y[3] = y[1];

1344

1345 /* upshift tmp by 3 with saturation */

1346 if (tmp > 268435455) {

1347 tmp = INT32_MAX;

1348 } else if (tmp < -268435456) {

1349 tmp = INT32_MIN;

1350 } else {

1351 tmp = tmp * 8;

1352 }

1353

1354 y[0] = tmp >> 16;

1355 y[1] = (tmp - (y[0] * (1 << 16))) >> 1;

1356 }

1357 }

1358

1359 static int ilbc_decode_frame(AVCodecContext *avctx, AVFrame *frame,

1360 int *got_frame_ptr, AVPacket *avpkt)

1361 {

1362 const uint8_t *buf = avpkt->data;

1363 ILBCContext *s = avctx->priv_data;

1364 int mode = s->mode, ret;

1365 int16_t *plc_data = &s->plc_residual[LPC_FILTERORDER];

1366

1367 if ((ret = init_get_bits8(&s->gb, buf, avpkt->size)) < 0)

1368 return ret;

1369 memset(&s->frame, 0, sizeof(ILBCFrame));

1370

1371 frame->nb_samples = s->block_samples;

1372 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

1373 return ret;

1374

1375 if (unpack_frame(s))

1376 mode = 0;

1377 if (s->frame.start < 1 || s->frame.start > 5)

1378 mode = 0;

1379

1380 if (mode) {

1381 index_conv(s->frame.cb_index);

1382

1383 lsf_dequantization(s->lsfdeq, s->frame.lsf, s->lpc_n);

1384 lsf_check_stability(s->lsfdeq, LPC_FILTERORDER, s->lpc_n);

1385 lsp_interpolate(s->syntdenum, s->weightdenum,

1386 s->lsfdeq, LPC_FILTERORDER, s);

1387 decode_residual(s, &s->frame, s->decresidual, s->syntdenum);

1388

1389 do_plc(s->plc_residual, s->plc_lpc, 0,

1390 s->decresidual, s->syntdenum + (LPC_FILTERORDER + 1) * (s->nsub - 1),

1391 s->last_lag, s);

1392

1393 memcpy(s->decresidual, s->plc_residual, s->block_samples * 2);

1394 }

1395

1396 if (s->enhancer) {

1397 /* TODO */

1398 } else {

1399 int16_t lag, i;

1400

1401 /* Find last lag (since the enhancer is not called to give this info) */

1402 if (s->mode == 20) {

1403 lag = xcorr_coeff(&s->decresidual[s->block_samples-60], &s->decresidual[s->block_samples-80],

1404 60, 80, 20, -1);

1405 } else {

1406 lag = xcorr_coeff(&s->decresidual[s->block_samples-ENH_BLOCKL],

1407 &s->decresidual[s->block_samples-ENH_BLOCKL-20],

1408 ENH_BLOCKL, 100, 20, -1);

1409 }

1410

1411 /* Store lag (it is needed if next packet is lost) */

1412 s->last_lag = lag;

1413

1414 /* copy data and run synthesis filter */

1415 memcpy(plc_data, s->decresidual, s->block_samples * 2);

1416

1417 /* Set up the filter state */

1418 memcpy(&plc_data[-LPC_FILTERORDER], s->syntMem, LPC_FILTERORDER * 2);

1419

1420 for (i = 0; i < s->nsub; i++) {

1421 filter_arfq12(plc_data+i*SUBL, plc_data+i*SUBL,

1422 s->syntdenum + i*(LPC_FILTERORDER + 1),

1423 LPC_FILTERORDER + 1, SUBL);

1424 }

1425

1426 /* Save the filter state */

1427 memcpy(s->syntMem, &plc_data[s->block_samples-LPC_FILTERORDER], LPC_FILTERORDER * 2);

1428 }

1429

1430 memcpy(frame->data[0], plc_data, s->block_samples * 2);

1431

1432 hp_output((int16_t *)frame->data[0], hp_out_coeffs,

1433 s->hpimemy, s->hpimemx, s->block_samples);

1434

1435 memcpy(s->old_syntdenum, s->syntdenum, s->nsub*(LPC_FILTERORDER + 1) * 2);

1436

1437 s->prev_enh_pl = 0;

1438 if (mode == 0)

1439 s->prev_enh_pl = 1;

1440

1441 *got_frame_ptr = 1;

1442

1443 return avpkt->size;

1444 }

1445

1446 static av_cold int ilbc_decode_init(AVCodecContext *avctx)

1447 {

1448 ILBCContext *s = avctx->priv_data;

1449

1450 if (avctx->block_align == 38)

1451 s->mode = 20;

1452 else if (avctx->block_align == 50)

1453 s->mode = 30;

1454 else if (avctx->bit_rate > 0)

1455 s->mode = avctx->bit_rate <= 14000 ? 30 : 20;

1456 else

1457 return AVERROR_INVALIDDATA;

1458

1459 av_channel_layout_uninit(&avctx->ch_layout);

1460 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

1461 avctx->sample_rate = 8000;

1462 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

1463

1464 if (s->mode == 30) {

1465 s->block_samples = 240;

1466 s->nsub = NSUB_30MS;

1467 s->nasub = NASUB_30MS;

1468 s->lpc_n = LPC_N_30MS;

1469 s->state_short_len = STATE_SHORT_LEN_30MS;

1470 } else {

1471 s->block_samples = 160;

1472 s->nsub = NSUB_20MS;

1473 s->nasub = NASUB_20MS;

1474 s->lpc_n = LPC_N_20MS;

1475 s->state_short_len = STATE_SHORT_LEN_20MS;

1476 }

1477

1478 return 0;

1479 }

1480

1481 const FFCodec ff_ilbc_decoder = {

1482 .p.name = "ilbc",

1483 .p.long_name = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),

1484 .p.type = AVMEDIA_TYPE_AUDIO,

1485 .p.id = AV_CODEC_ID_ILBC,

1486 .init = ilbc_decode_init,

1487 FF_CODEC_DECODE_CB(ilbc_decode_frame),

1488 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

1489 .priv_data_size = sizeof(ILBCContext),

1490 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

1491 };

kPlcPerSqr

static const int16_t kPlcPerSqr[]

Definition: ilbcdata.h:53

ILBCContext::nsub

int16_t nsub

Definition: ilbcdec.c:103

lsf_dim_codebook

static const uint8_t lsf_dim_codebook[]

Definition: ilbcdata.h:38

ILBCContext::per_square

int16_t per_square

Definition: ilbcdec.c:123

ENH_NBLOCKS_TOT

#define ENH_NBLOCKS_TOT

Definition: ilbcdec.c:60

av_clip

#define av_clip

Definition: common.h:95

ILBCFrame::firstbits

int16_t firstbits

Definition: ilbcdec.c:85

out

FILE * out

Definition: movenc.c:54

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:998

ILBCContext::plc_residual

int16_t plc_residual[BLOCKL_MAX+LPC_FILTERORDER]

Definition: ilbcdec.c:118

ILBCContext::enh_buf

int16_t enh_buf[ENH_BUFL+ENH_BUFL_FILTEROVERHEAD]

Definition: ilbcdec.c:114

ILBCContext::weightdenum

int16_t weightdenum[(LPC_FILTERORDER+1) *NSUB_MAX]

Definition: ilbcdec.c:111

decode_residual

static void decode_residual(ILBCContext *s, ILBCFrame *encbits, int16_t *decresidual, int16_t *syntdenum)

Definition: ilbcdec.c:766

LSF_NSPLIT

#define LSF_NSPLIT

Definition: ilbcdec.c:43

ILBCContext::prevLag

int16_t prevLag

Definition: ilbcdec.c:122

output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output

Definition: filter_design.txt:225

filter_arfq12

static void filter_arfq12(const int16_t *data_in, int16_t *data_out, const int16_t *coefficients, int coefficients_length, int data_length)

Definition: ilbcdec.c:501

ff_clz

#define ff_clz

Definition: intmath.h:142

lsf_dequantization

static void lsf_dequantization(int16_t *lsfdeq, int16_t *index, int16_t lpc_n)

Definition: ilbcdec.c:283

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:325

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

index_conv

static void index_conv(int16_t *index)

Definition: ilbcdec.c:270

step

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step

Definition: rate_distortion.txt:58

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

NASUB_MAX

#define NASUB_MAX

Definition: ilbcdec.c:70

unpack_frame

static int unpack_frame(ILBCContext *s)

Definition: ilbcdec.c:130

ILBCContext::block_samples

int block_samples

Definition: ilbcdec.c:104

cos_derivative_tbl

static const int16_t cos_derivative_tbl[64]

Definition: ilbcdata.h:74

AV_CHANNEL_LAYOUT_MONO

#define AV_CHANNEL_LAYOUT_MONO

Definition: channel_layout.h:353

FFCodec

Definition: codec_internal.h:112

CB_NSTAGES

#define CB_NSTAGES

Definition: ilbcdec.c:56

ILBCContext::lsfdeqold

int16_t lsfdeqold[LPC_FILTERORDER]

Definition: ilbcdec.c:110

max

#define max(a, b)

Definition: cuda_runtime.h:33

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

SUBL

#define SUBL

Definition: ilbcdec.c:47

ILBCContext::seed

int16_t seed

Definition: ilbcdec.c:119

ILBCContext::gb

GetBitContext gb

Definition: ilbcdec.c:94

SPL_MUL_16_16

#define SPL_MUL_16_16(a, b)

Definition: ilbcdec.c:75

win

static float win(SuperEqualizerContext *s, float n, int N)

Definition: af_superequalizer.c:119

STATE_LEN

#define STATE_LEN

Definition: ilbcdec.c:71

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:379

ILBCContext::lsfdeq

int16_t lsfdeq[LPC_FILTERORDER *LPC_N_MAX]

Definition: ilbcdec.c:107

ILBCContext::decresidual

int16_t decresidual[BLOCKL_MAX]

Definition: ilbcdec.c:117

ILBCFrame::gain_index

int16_t gain_index[CB_NSTAGES *(NASUB_MAX+1)]

Definition: ilbcdec.c:81

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:2056

SPL_SHIFT_W32

#define SPL_SHIFT_W32(x, c)

Definition: ilbcdec.c:930

get_size_in_bits

static int16_t get_size_in_bits(uint32_t n)

Definition: ilbcdec.c:885

GetBitContext

Definition: get_bits.h:61

MEM_LF_TBL

#define MEM_LF_TBL

Definition: ilbcdec.c:50

vector_rmultiplication

static void vector_rmultiplication(int16_t *out, const int16_t *in, const int16_t *win, int length, int shift)

Definition: ilbcdec.c:609

vector_multiplication

static void vector_multiplication(int16_t *out, const int16_t *in, const int16_t *win, int length, int shift)

Definition: ilbcdec.c:617

construct_vector

static void construct_vector(int16_t *decvector, int16_t *index, int16_t *gain_index, int16_t *mem, int16_t lMem, int16_t veclen)

Definition: ilbcdec.c:717

scale

static av_always_inline float scale(float x, float s)

Definition: vf_v360.c:1389

STATE_SHORT_LEN_30MS

#define STATE_SHORT_LEN_30MS

Definition: ilbcdec.c:72

state_construct

static void state_construct(int16_t ifm, int16_t *idx, int16_t *synt_denum, int16_t *Out_fix, int16_t len)

Definition: ilbcdec.c:523

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:667

ILBCFrame::state_first

int16_t state_first

Definition: ilbcdec.c:83

scale_dot_product

static int32_t scale_dot_product(const int16_t *v1, const int16_t *v2, int length, int scaling)

Definition: ilbcdec.c:904

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

#define s(width, name)

Definition: cbs_vp9.c:256

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

SPL_MUL_16_16_RSFT

#define SPL_MUL_16_16_RSFT(a, b, c)

Definition: ilbcdec.c:76

ILBCFrame::idx

int16_t idx[STATE_SHORT_LEN_30MS]

Definition: ilbcdec.c:84

lsf_weight_30ms

static const int16_t lsf_weight_30ms[]

Definition: ilbcdata.h:41

bits

uint8_t bits

Definition: vp3data.h:141

ILBCFrame::start

int16_t start

Definition: ilbcdec.c:86

ILBCContext::prev_lpc

int16_t prev_lpc[LPC_FILTERORDER+1]

Definition: ilbcdec.c:124

ILBCContext::state_short_len

int state_short_len

Definition: ilbcdec.c:100

get_bits.h

ILBCContext::lpc_n

int lpc_n

Definition: ilbcdec.c:101

kPlcPfSlope

static const int16_t kPlcPfSlope[]

Definition: ilbcdata.h:45

ILBCContext::mode

int mode

Definition: ilbcdec.c:93

create_augmented_vector

static void create_augmented_vector(int index, int16_t *buffer, int16_t *cbVec)

Definition: ilbcdec.c:633

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:64

ILBCFrame::cb_index

int16_t cb_index[CB_NSTAGES *(NASUB_MAX+1)]

Definition: ilbcdec.c:80

cos_tbl

static const int16_t cos_tbl[64]

Definition: ilbcdata.h:63

CB_HALFFILTERLEN

#define CB_HALFFILTERLEN

Definition: ilbcdec.c:57

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

add_vector_and_shift

static void add_vector_and_shift(int16_t *out, const int16_t *in1, const int16_t *in2, int length, int shift)

Definition: ilbcdec.c:625

NULL

#define NULL

Definition: coverity.c:32

av_clip_intp2

#define av_clip_intp2

Definition: common.h:116

LPC_N_20MS

#define LPC_N_20MS

Definition: ilbcdec.c:40

ILBCContext::lsfold

int16_t lsfold[LPC_FILTERORDER]

Definition: ilbcdec.c:108

coefficients

static double coefficients[8 *8]

Definition: dctref.c:35

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:439

lsf_check_stability

static void lsf_check_stability(int16_t *lsf, int dim, int nb_vectors)

Definition: ilbcdec.c:311

hp_out_coeffs

static const int16_t hp_out_coeffs[]

Definition: ilbcdata.h:43

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

div_w32_w16

static int32_t div_w32_w16(int32_t num, int16_t den)

Definition: ilbcdec.c:943

ilbc_decode_frame

static int ilbc_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: ilbcdec.c:1359

NASUB_30MS

#define NASUB_30MS

Definition: ilbcdec.c:69

ST_MEM_L_TBL

#define ST_MEM_L_TBL

Definition: ilbcdec.c:49

index

int index

Definition: gxfenc.c:89

correlation

static void correlation(int32_t *corr, int32_t *ener, int16_t *buffer, int16_t lag, int16_t blen, int16_t srange, int16_t scale)

Definition: ilbcdec.c:914

BLOCKL_MAX

#define BLOCKL_MAX

Definition: ilbcdec.c:64

av_channel_layout_uninit

void av_channel_layout_uninit(AVChannelLayout *channel_layout)

Free any allocated data in the channel layout and reset the channel count to 0.

Definition: channel_layout.c:630

lsf_size_codebook

static const uint8_t lsf_size_codebook[]

Definition: ilbcdata.h:39

source

Definition: filter_design.txt:255

AV_CODEC_CAP_CHANNEL_CONF

#define AV_CODEC_CAP_CHANNEL_CONF

Codec should fill in channel configuration and samplerate instead of container.

Definition: codec.h:109

shift1

static const int shift1[6]

Definition: dxa.c:51

Definition: af_crystalizer.c:122

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1403

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:375

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

ILBCContext::prevScale

int16_t prevScale

Definition: ilbcdec.c:121

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:290

codec_internal.h

av_clipl_int32

#define av_clipl_int32

Definition: common.h:113

ILBCContext::nasub

int16_t nasub

Definition: ilbcdec.c:102

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1014

size

int size

Definition: twinvq_data.h:10344

kCbFiltersRev

static const int16_t kCbFiltersRev[]

Definition: ilbcdata.h:49

lsf2lsp

static void lsf2lsp(int16_t *lsf, int16_t *lsp, int order)

Definition: ilbcdec.c:344

STATE_SHORT_LEN_20MS

#define STATE_SHORT_LEN_20MS

Definition: ilbcdec.c:73

gain_dequantization

static int16_t gain_dequantization(int index, int max_in, int stage)

Definition: ilbcdec.c:602

ILBCContext::prevResidual

int16_t prevResidual[NSUB_MAX *SUBL]

Definition: ilbcdec.c:116

ilbc_state

static const int16_t ilbc_state[8]

Definition: ilbcdata.h:217

ILBCContext::consPLICount

int consPLICount

Definition: ilbcdec.c:98

ILBCContext::hpimemy

int16_t hpimemy[4]

Definition: ilbcdec.c:127

ilbcdata.h

ilbc_gain

static const int16_t *const ilbc_gain[]

Definition: ilbcdata.h:213

norm_w32

static int16_t norm_w32(int32_t a)

Definition: ilbcdec.c:932

kLpcChirpSyntDenum

static const int16_t kLpcChirpSyntDenum[]

Definition: ilbcdata.h:59

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

shift2

static const int shift2[6]

Definition: dxa.c:52

NSUB_MAX

#define NSUB_MAX

Definition: ilbcdec.c:67

ILBCFrame::lsf

int16_t lsf[LSF_NSPLIT *LPC_N_MAX]

Definition: ilbcdec.c:79

max_abs_value_w16

static int16_t max_abs_value_w16(const int16_t *vector, int length)

Definition: ilbcdec.c:867

ff_ilbc_decoder

const FFCodec ff_ilbc_decoder

Definition: ilbcdec.c:1481

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

do_plc

static void do_plc(int16_t *plc_residual, int16_t *plc_lpc, int16_t PLI, int16_t *decresidual, int16_t *lpc, int16_t inlag, ILBCContext *s)

Definition: ilbcdec.c:951

lsf_interpolate

static void lsf_interpolate(int16_t *out, int16_t *in1, int16_t *in2, int16_t coef, int size)

Definition: ilbcdec.c:334

ENH_BUFL

#define ENH_BUFL

Definition: ilbcdec.c:62

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

ILBCContext::prev_enh_pl

int prev_enh_pl

Definition: ilbcdec.c:97

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: codec_internal.h:31

ILBCContext::no_of_words

int16_t no_of_words

Definition: ilbcdec.c:105

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

ILBCContext::frame

ILBCFrame frame

Definition: ilbcdec.c:95

ILBCContext::last_lag

int last_lag

Definition: ilbcdec.c:99

len

int len

Definition: vorbis_enc_data.h:426

bw_expand

static void bw_expand(int16_t *out, const int16_t *in, const int16_t *coef, int length)

Definition: ilbcdec.c:430

lsp_interpolate2polydec

static void lsp_interpolate2polydec(int16_t *a, int16_t *lsf1, int16_t *lsf2, int coef, int length)

Definition: ilbcdec.c:421

avcodec.h

dim

int dim

Definition: vorbis_enc_data.h:425

ENH_BUFL_FILTEROVERHEAD

#define ENH_BUFL_FILTEROVERHEAD

Definition: ilbcdec.c:63

ret

Definition: filter_design.txt:187

AVCodecContext::block_align

int block_align

number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.

Definition: avcodec.h:1043

get_codebook

static void get_codebook(int16_t *cbvec, int16_t *mem, int16_t index, int16_t lMem, int16_t cbveclen)

Definition: ilbcdec.c:648

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

CB_MEML

#define CB_MEML

Definition: ilbcdec.c:55

ILBCContext::prevPLI

int16_t prevPLI

Definition: ilbcdec.c:120

pos

unsigned int pos

Definition: spdifenc.c:412

ILBCContext::no_of_bytes

int16_t no_of_bytes

Definition: ilbcdec.c:106

#define B

Definition: huffyuvdsp.h:32

ilbc_decode_init

static av_cold int ilbc_decode_init(AVCodecContext *avctx)

Definition: ilbcdec.c:1446

hp_output

static void hp_output(int16_t *signal, const int16_t *ba, int16_t *y, int16_t *x, int16_t len)

Definition: ilbcdec.c:1317

ILBCFrame::ifm

int16_t ifm

Definition: ilbcdec.c:82

AVCodecContext

main external API structure.

Definition: avcodec.h:389

reverse_memcpy

static void reverse_memcpy(int16_t *dest, int16_t *source, int length)

Definition: ilbcdec.c:756

ILBCContext::enh_period

int16_t enh_period[ENH_NBLOCKS_TOT]

Definition: ilbcdec.c:115

channel_layout.h

ILBCContext::enhancer

int enhancer

Definition: ilbcdec.c:91

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

lsf2poly

static void lsf2poly(int16_t *a, int16_t *lsf)

Definition: ilbcdec.c:394

LPC_FILTERORDER

#define LPC_FILTERORDER

Definition: ilbcdec.c:45

mode

Definition: ebur128.h:83

LPC_N_30MS

#define LPC_N_30MS

Definition: ilbcdec.c:41