FFmpeg: libavcodec/opus/silk.c Source File

FFmpeg

[フレーム]

silk.c

Go to the documentation of this file.

1 /*

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * Opus SILK decoder

25 */

27 #include <stdint.h>

29 #include "libavutil/mem.h"

30 #include "mathops.h"

31 #include "opus.h"

32 #include "rc.h"

33 #include "silk.h"

34 #include "tab.h"

36 #define ROUND_MULL(a,b,s) (((MUL64(a, b) >> ((s) - 1)) + 1) >> 1)

38 typedef struct SilkFrame {

39 int coded;

40 int log_gain;

41 int16_t nlsf[16];

42 float lpc[16];

44 float output [2 * SILK_HISTORY];

45 float lpc_history[2 * SILK_HISTORY];

46 int primarylag;

48 int prev_voiced;

49 } SilkFrame;

51 struct SilkContext {

52 void *logctx;

53 int output_channels;

55 int midonly;

56 int subframes;

57 int sflength;

58 int flength;

59 int nlsf_interp_factor;

61 enum OpusBandwidth bandwidth;

62 int wb;

64 SilkFrame frame[2];

65 float prev_stereo_weights[2];

66 float stereo_weights[2];

68 int prev_coded_channels;

69 };

71 static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])

72 {

73 int pass, i;

74 for (pass = 0; pass < 20; pass++) {

75 int k, min_diff = 0;

76 for (i = 0; i < order+1; i++) {

77 int low = i != 0 ? nlsf[i-1] : 0;

78 int high = i != order ? nlsf[i] : 32768;

79 int diff = (high - low) - (min_delta[i]);

81 if (diff < min_diff) {

82 min_diff = diff;

83 k = i;

85 if (pass == 20)

86 break;

87 }

88 }

89 if (min_diff == 0) /* no issues; stabilized */

90 return;

92 /* wiggle one or two LSFs */

93 if (k == 0) {

94 /* repel away from lower bound */

95 nlsf[0] = min_delta[0];

96 } else if (k == order) {

97 /* repel away from higher bound */

98 nlsf[order-1] = 32768 - min_delta[order];

99 } else {

100 /* repel away from current position */

101 int min_center = 0, max_center = 32768, center_val;

102

103 /* lower extent */

104 for (i = 0; i < k; i++)

105 min_center += min_delta[i];

106 min_center += min_delta[k] >> 1;

107

108 /* upper extent */

109 for (i = order; i > k; i--)

110 max_center -= min_delta[i];

111 max_center -= min_delta[k] >> 1;

112

113 /* move apart */

114 center_val = nlsf[k - 1] + nlsf[k];

115 center_val = (center_val >> 1) + (center_val & 1); // rounded divide by 2

116 center_val = FFMIN(max_center, FFMAX(min_center, center_val));

117

118 nlsf[k - 1] = center_val - (min_delta[k] >> 1);

119 nlsf[k] = nlsf[k - 1] + min_delta[k];

120 }

121 }

122

123 /* resort to the fall-back method, the standard method for LSF stabilization */

124

125 /* sort; as the LSFs should be nearly sorted, use insertion sort */

126 for (i = 1; i < order; i++) {

127 int j, value = nlsf[i];

128 for (j = i - 1; j >= 0 && nlsf[j] > value; j--)

129 nlsf[j + 1] = nlsf[j];

130 nlsf[j + 1] = value;

131 }

132

133 /* push forwards to increase distance */

134 if (nlsf[0] < min_delta[0])

135 nlsf[0] = min_delta[0];

136 for (i = 1; i < order; i++)

137 nlsf[i] = FFMAX(nlsf[i], FFMIN(nlsf[i - 1] + min_delta[i], 32767));

138

139 /* push backwards to increase distance */

140 if (nlsf[order-1] > 32768 - min_delta[order])

141 nlsf[order-1] = 32768 - min_delta[order];

142 for (i = order-2; i >= 0; i--)

143 if (nlsf[i] > nlsf[i + 1] - min_delta[i+1])

144 nlsf[i] = nlsf[i + 1] - min_delta[i+1];

145

146 return;

147 }

148

149 static inline int silk_is_lpc_stable(const int16_t lpc[16], int order)

150 {

151 int k, j, DC_resp = 0;

152 int32_t lpc32[2][16]; // Q24

153 int totalinvgain = 1 << 30; // 1.0 in Q30

154 int32_t *row = lpc32[0], *prevrow;

155

156 /* initialize the first row for the Levinson recursion */

157 for (k = 0; k < order; k++) {

158 DC_resp += lpc[k];

159 row[k] = lpc[k] * 4096;

160 }

161

162 if (DC_resp >= 4096)

163 return 0;

164

165 /* check if prediction gain pushes any coefficients too far */

166 for (k = order - 1; 1; k--) {

167 int rc; // Q31; reflection coefficient

168 int gaindiv; // Q30; inverse of the gain (the divisor)

169 int gain; // gain for this reflection coefficient

170 int fbits; // fractional bits used for the gain

171 int error; // Q29; estimate of the error of our partial estimate of 1/gaindiv

172

173 if (FFABS(row[k]) > 16773022)

174 return 0;

175

176 rc = -(row[k] * 128);

177 gaindiv = (1 << 30) - MULH(rc, rc);

178

179 totalinvgain = MULH(totalinvgain, gaindiv) << 2;

180 if (k == 0)

181 return (totalinvgain >= 107374);

182

183 /* approximate 1.0/gaindiv */

184 fbits = opus_ilog(gaindiv);

185 gain = ((1 << 29) - 1) / (gaindiv >> (fbits + 1 - 16)); // Q<fbits-16>

186 error = (1 << 29) - MULL(gaindiv << (15 + 16 - fbits), gain, 16);

187 gain = ((gain << 16) + (error * gain >> 13));

188

189 /* switch to the next row of the LPC coefficients */

190 prevrow = row;

191 row = lpc32[k & 1];

192

193 for (j = 0; j < k; j++) {

194 int x = av_sat_sub32(prevrow[j], ROUND_MULL(prevrow[k - j - 1], rc, 31));

195 int64_t tmp = ROUND_MULL(x, gain, fbits);

196

197 /* per RFC 8251 section 6, if this calculation overflows, the filter

198 is considered unstable. */

199 if (tmp < INT32_MIN || tmp > INT32_MAX)

200 return 0;

201

202 row[j] = (int32_t)tmp;

203 }

204 }

205 }

206

207 static void silk_lsp2poly(const int32_t lsp[/* 2 * half_order - 1 */],

208 int32_t pol[/* half_order + 1 */], int half_order)

209 {

210 int i, j;

211

212 pol[0] = 65536; // 1.0 in Q16

213 pol[1] = -lsp[0];

214

215 for (i = 1; i < half_order; i++) {

216 pol[i + 1] = pol[i - 1] * 2 - ROUND_MULL(lsp[2 * i], pol[i], 16);

217 for (j = i; j > 1; j--)

218 pol[j] += pol[j - 2] - ROUND_MULL(lsp[2 * i], pol[j - 1], 16);

219

220 pol[1] -= lsp[2 * i];

221 }

222 }

223

224 static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)

225 {

226 int i, k;

227 int32_t lsp[16]; // Q17; 2*cos(LSF)

228 int32_t p[9], q[9]; // Q16

229 int32_t lpc32[16]; // Q17

230 int16_t lpc[16]; // Q12

231

232 /* convert the LSFs to LSPs, i.e. 2*cos(LSF) */

233 for (k = 0; k < order; k++) {

234 int index = nlsf[k] >> 8;

235 int offset = nlsf[k] & 255;

236 int k2 = (order == 10) ? ff_silk_lsf_ordering_nbmb[k] : ff_silk_lsf_ordering_wb[k];

237

238 /* interpolate and round */

239 lsp[k2] = ff_silk_cosine[index] * 256;

240 lsp[k2] += (ff_silk_cosine[index + 1] - ff_silk_cosine[index]) * offset;

241 lsp[k2] = (lsp[k2] + 4) >> 3;

242 }

243

244 silk_lsp2poly(lsp , p, order >> 1);

245 silk_lsp2poly(lsp + 1, q, order >> 1);

246

247 /* reconstruct A(z) */

248 for (k = 0; k < order>>1; k++) {

249 int32_t p_tmp = p[k + 1] + p[k];

250 int32_t q_tmp = q[k + 1] - q[k];

251 lpc32[k] = -q_tmp - p_tmp;

252 lpc32[order-k-1] = q_tmp - p_tmp;

253 }

254

255 /* limit the range of the LPC coefficients to each fit within an int16_t */

256 for (i = 0; i < 10; i++) {

257 int j;

258 unsigned int maxabs = 0;

259 for (j = 0, k = 0; j < order; j++) {

260 unsigned int x = FFABS(lpc32[k]);

261 if (x > maxabs) {

262 maxabs = x; // Q17

263 k = j;

264 }

265 }

266

267 maxabs = (maxabs + 16) >> 5; // convert to Q12

268

269 if (maxabs > 32767) {

270 /* perform bandwidth expansion */

271 unsigned int chirp, chirp_base; // Q16

272 maxabs = FFMIN(maxabs, 163838); // anything above this overflows chirp's numerator

273 chirp_base = chirp = 65470 - ((maxabs - 32767) << 14) / ((maxabs * (k+1)) >> 2);

274

275 for (k = 0; k < order; k++) {

276 lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);

277 chirp = (chirp_base * chirp + 32768) >> 16;

278 }

279 } else break;

280 }

281

282 if (i == 10) {

283 /* time's up: just clamp */

284 for (k = 0; k < order; k++) {

285 int x = (lpc32[k] + 16) >> 5;

286 lpc[k] = av_clip_int16(x);

287 lpc32[k] = lpc[k] << 5; // shortcut mandated by the spec; drops lower 5 bits

288 }

289 } else {

290 for (k = 0; k < order; k++)

291 lpc[k] = (lpc32[k] + 16) >> 5;

292 }

293

294 /* if the prediction gain causes the LPC filter to become unstable,

295 apply further bandwidth expansion on the Q17 coefficients */

296 for (i = 1; i <= 16 && !silk_is_lpc_stable(lpc, order); i++) {

297 unsigned int chirp, chirp_base;

298 chirp_base = chirp = 65536 - (1 << i);

299

300 for (k = 0; k < order; k++) {

301 lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);

302 lpc[k] = (lpc32[k] + 16) >> 5;

303 chirp = (chirp_base * chirp + 32768) >> 16;

304 }

305 }

306

307 for (i = 0; i < order; i++)

308 lpcf[i] = lpc[i] / 4096.0f;

309 }

310

311 static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,

312 OpusRangeCoder *rc,

313 float lpc_leadin[16], float lpc[16],

314 int *lpc_order, int *has_lpc_leadin, int voiced)

315 {

316 int i;

317 int order; // order of the LP polynomial; 10 for NB/MB and 16 for WB

318 int8_t lsf_i1, lsf_i2[16]; // stage-1 and stage-2 codebook indices

319 int16_t lsf_res[16]; // residual as a Q10 value

320 int16_t nlsf[16]; // Q15

321

322 *lpc_order = order = s->wb ? 16 : 10;

323

324 /* obtain LSF stage-1 and stage-2 indices */

325 lsf_i1 = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s1[s->wb][voiced]);

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

327 int index = s->wb ? ff_silk_lsf_s2_model_sel_wb [lsf_i1][i] :

328 ff_silk_lsf_s2_model_sel_nbmb[lsf_i1][i];

329 lsf_i2[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2[index]) - 4;

330 if (lsf_i2[i] == -4)

331 lsf_i2[i] -= ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2_ext);

332 else if (lsf_i2[i] == 4)

333 lsf_i2[i] += ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2_ext);

334 }

335

336 /* reverse the backwards-prediction step */

337 for (i = order - 1; i >= 0; i--) {

338 int qstep = s->wb ? 9830 : 11796;

339

340 lsf_res[i] = lsf_i2[i] * 1024;

341 if (lsf_i2[i] < 0) lsf_res[i] += 102;

342 else if (lsf_i2[i] > 0) lsf_res[i] -= 102;

343 lsf_res[i] = (lsf_res[i] * qstep) >> 16;

344

345 if (i + 1 < order) {

346 int weight = s->wb ? ff_silk_lsf_pred_weights_wb [ff_silk_lsf_weight_sel_wb [lsf_i1][i]][i] :

347 ff_silk_lsf_pred_weights_nbmb[ff_silk_lsf_weight_sel_nbmb[lsf_i1][i]][i];

348 lsf_res[i] += (lsf_res[i+1] * weight) >> 8;

349 }

350 }

351

352 /* reconstruct the NLSF coefficients from the supplied indices */

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

354 const uint8_t * codebook = s->wb ? ff_silk_lsf_codebook_wb [lsf_i1] :

355 ff_silk_lsf_codebook_nbmb[lsf_i1];

356 int cur, prev, next, weight_sq, weight, ipart, fpart, y, value;

357

358 /* find the weight of the residual */

359 /* TODO: precompute */

360 cur = codebook[i];

361 prev = i ? codebook[i - 1] : 0;

362 next = i + 1 < order ? codebook[i + 1] : 256;

363 weight_sq = (1024 / (cur - prev) + 1024 / (next - cur)) << 16;

364

365 /* approximate square-root with mandated fixed-point arithmetic */

366 ipart = opus_ilog(weight_sq);

367 fpart = (weight_sq >> (ipart-8)) & 127;

368 y = ((ipart & 1) ? 32768 : 46214) >> ((32 - ipart)>>1);

369 weight = y + ((213 * fpart * y) >> 16);

370

371 value = cur * 128 + (lsf_res[i] * 16384) / weight;

372 nlsf[i] = av_clip_uintp2(value, 15);

373 }

374

375 /* stabilize the NLSF coefficients */

376 silk_stabilize_lsf(nlsf, order, s->wb ? ff_silk_lsf_min_spacing_wb :

377 ff_silk_lsf_min_spacing_nbmb);

378

379 /* produce an interpolation for the first 2 subframes, */

380 /* and then convert both sets of NLSFs to LPC coefficients */

381 *has_lpc_leadin = 0;

382 if (s->subframes == 4) {

383 int offset = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_interpolation_offset);

384 if (offset != 4 && frame->coded) {

385 *has_lpc_leadin = 1;

386 if (offset != 0) {

387 int16_t nlsf_leadin[16];

388 for (i = 0; i < order; i++)

389 nlsf_leadin[i] = frame->nlsf[i] +

390 ((nlsf[i] - frame->nlsf[i]) * offset >> 2);

391 silk_lsf2lpc(nlsf_leadin, lpc_leadin, order);

392 } else /* avoid re-computation for a (roughly) 1-in-4 occurrence */

393 memcpy(lpc_leadin, frame->lpc, 16 * sizeof(float));

394 } else

395 offset = 4;

396 s->nlsf_interp_factor = offset;

397

398 silk_lsf2lpc(nlsf, lpc, order);

399 } else {

400 s->nlsf_interp_factor = 4;

401 silk_lsf2lpc(nlsf, lpc, order);

402 }

403

404 memcpy(frame->nlsf, nlsf, order * sizeof(nlsf[0]));

405 memcpy(frame->lpc, lpc, order * sizeof(lpc[0]));

406 }

407

408 static inline void silk_count_children(OpusRangeCoder *rc, int model, int32_t total,

409 int32_t child[2])

410 {

411 if (total != 0) {

412 child[0] = ff_opus_rc_dec_cdf(rc,

413 ff_silk_model_pulse_location[model] + (((total - 1 + 5) * (total - 1)) >> 1));

414 child[1] = total - child[0];

415 } else {

416 child[0] = 0;

417 child[1] = 0;

418 }

419 }

420

421 static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,

422 float* excitationf,

423 int qoffset_high, int active, int voiced)

424 {

425 int i;

426 uint32_t seed;

427 int shellblocks;

428 int ratelevel;

429 uint8_t pulsecount[20]; // total pulses in each shell block

430 uint8_t lsbcount[20] = {0}; // raw lsbits defined for each pulse in each shell block

431 int32_t excitation[320]; // Q23

432

433 /* excitation parameters */

434 seed = ff_opus_rc_dec_cdf(rc, ff_silk_model_lcg_seed);

435 shellblocks = ff_silk_shell_blocks[s->bandwidth][s->subframes >> 2];

436 ratelevel = ff_opus_rc_dec_cdf(rc, ff_silk_model_exc_rate[voiced]);

437

438 for (i = 0; i < shellblocks; i++) {

439 pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[ratelevel]);

440 if (pulsecount[i] == 17) {

441 while (pulsecount[i] == 17 && ++lsbcount[i] != 10)

442 pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[9]);

443 if (lsbcount[i] == 10)

444 pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[10]);

445 }

446 }

447

448 /* decode pulse locations using PVQ */

449 for (i = 0; i < shellblocks; i++) {

450 if (pulsecount[i] != 0) {

451 int a, b, c, d;

452 int32_t * location = excitation + 16*i;

453 int32_t branch[4][2];

454 branch[0][0] = pulsecount[i];

455

456 /* unrolled tail recursion */

457 for (a = 0; a < 1; a++) {

458 silk_count_children(rc, 0, branch[0][a], branch[1]);

459 for (b = 0; b < 2; b++) {

460 silk_count_children(rc, 1, branch[1][b], branch[2]);

461 for (c = 0; c < 2; c++) {

462 silk_count_children(rc, 2, branch[2][c], branch[3]);

463 for (d = 0; d < 2; d++) {

464 silk_count_children(rc, 3, branch[3][d], location);

465 location += 2;

466 }

467 }

468 }

469 }

470 } else

471 memset(excitation + 16*i, 0, 16*sizeof(int32_t));

472 }

473

474 /* decode least significant bits */

475 for (i = 0; i < shellblocks << 4; i++) {

476 int bit;

477 for (bit = 0; bit < lsbcount[i >> 4]; bit++)

478 excitation[i] = (excitation[i] << 1) |

479 ff_opus_rc_dec_cdf(rc, ff_silk_model_excitation_lsb);

480 }

481

482 /* decode signs */

483 for (i = 0; i < shellblocks << 4; i++) {

484 if (excitation[i] != 0) {

485 int sign = ff_opus_rc_dec_cdf(rc, ff_silk_model_excitation_sign[active +

486 voiced][qoffset_high][FFMIN(pulsecount[i >> 4], 6)]);

487 if (sign == 0)

488 excitation[i] *= -1;

489 }

490 }

491

492 /* assemble the excitation */

493 for (i = 0; i < shellblocks << 4; i++) {

494 int value = excitation[i];

495 excitation[i] = value * 256 | ff_silk_quant_offset[voiced][qoffset_high];

496 if (value < 0) excitation[i] += 20;

497 else if (value > 0) excitation[i] -= 20;

498

499 /* invert samples pseudorandomly */

500 seed = 196314165 * seed + 907633515;

501 if (seed & 0x80000000)

502 excitation[i] *= -1;

503 seed += value;

504

505 excitationf[i] = excitation[i] / 8388608.0f;

506 }

507 }

508

509 /** Maximum residual history according to 4.2.7.6.1 */

510 #define SILK_MAX_LAG (288 + LTP_ORDER / 2)

511

512 /** Order of the LTP filter */

513 #define LTP_ORDER 5

514

515 static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,

516 int frame_num, int channel, int coded_channels,

517 int active, int active1, int redundant)

518 {

519 /* per frame */

520 int voiced; // combines with active to indicate inactive, active, or active+voiced

521 int qoffset_high;

522 int order; // order of the LPC coefficients

523 float lpc_leadin[16], lpc_body[16], residual[SILK_MAX_LAG + SILK_HISTORY];

524 int has_lpc_leadin;

525 float ltpscale;

526

527 /* per subframe */

528 struct {

529 float gain;

530 int pitchlag;

531 float ltptaps[5];

532 } sf[4];

533

534 SilkFrame * const frame = s->frame + channel;

535

536 int i;

537

538 /* obtain stereo weights */

539 if (coded_channels == 2 && channel == 0) {

540 int n, wi[2], ws[2], w[2];

541 n = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s1);

542 wi[0] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s2) + 3 * (n / 5);

543 ws[0] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s3);

544 wi[1] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s2) + 3 * (n % 5);

545 ws[1] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s3);

546

547 for (i = 0; i < 2; i++)

548 w[i] = ff_silk_stereo_weights[wi[i]] +

549 (((ff_silk_stereo_weights[wi[i] + 1] - ff_silk_stereo_weights[wi[i]]) * 6554) >> 16)

550 * (ws[i]*2 + 1);

551

552 s->stereo_weights[0] = (w[0] - w[1]) / 8192.0;

553 s->stereo_weights[1] = w[1] / 8192.0;

554

555 /* and read the mid-only flag */

556 s->midonly = active1 ? 0 : ff_opus_rc_dec_cdf(rc, ff_silk_model_mid_only);

557 }

558

559 /* obtain frame type */

560 if (!active) {

561 qoffset_high = ff_opus_rc_dec_cdf(rc, ff_silk_model_frame_type_inactive);

562 voiced = 0;

563 } else {

564 int type = ff_opus_rc_dec_cdf(rc, ff_silk_model_frame_type_active);

565 qoffset_high = type & 1;

566 voiced = type >> 1;

567 }

568

569 /* obtain subframe quantization gains */

570 for (i = 0; i < s->subframes; i++) {

571 int log_gain; //Q7

572 int ipart, fpart, lingain;

573

574 if (i == 0 && (frame_num == 0 || !frame->coded)) {

575 /* gain is coded absolute */

576 int x = ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_highbits[active + voiced]);

577 log_gain = (x<<3) | ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_lowbits);

578

579 if (frame->coded)

580 log_gain = FFMAX(log_gain, frame->log_gain - 16);

581 } else {

582 /* gain is coded relative */

583 int delta_gain = ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_delta);

584 log_gain = av_clip_uintp2(FFMAX((delta_gain<<1) - 16,

585 frame->log_gain + delta_gain - 4), 6);

586 }

587

588 frame->log_gain = log_gain;

589

590 /* approximate 2**(x/128) with a Q7 (i.e. non-integer) input */

591 log_gain = (log_gain * 0x1D1C71 >> 16) + 2090;

592 ipart = log_gain >> 7;

593 fpart = log_gain & 127;

594 lingain = (1 << ipart) + ((-174 * fpart * (128-fpart) >>16) + fpart) * ((1<<ipart) >> 7);

595 sf[i].gain = lingain / 65536.0f;

596 }

597

598 /* obtain LPC filter coefficients */

599 silk_decode_lpc(s, frame, rc, lpc_leadin, lpc_body, &order, &has_lpc_leadin, voiced);

600

601 /* obtain pitch lags, if this is a voiced frame */

602 if (voiced) {

603 int lag_absolute = (!frame_num || !frame->prev_voiced);

604 int primarylag; // primary pitch lag for the entire SILK frame

605 int ltpfilter;

606 const int8_t * offsets;

607

608 if (!lag_absolute) {

609 int delta = ff_opus_rc_dec_cdf(rc, ff_silk_model_pitch_delta);

610 if (delta)

611 primarylag = frame->primarylag + delta - 9;

612 else

613 lag_absolute = 1;

614 }

615

616 if (lag_absolute) {

617 /* primary lag is coded absolute */

618 int highbits, lowbits;

619 static const uint16_t * const model[] = {

620 ff_silk_model_pitch_lowbits_nb, ff_silk_model_pitch_lowbits_mb,

621 ff_silk_model_pitch_lowbits_wb

622 };

623 highbits = ff_opus_rc_dec_cdf(rc, ff_silk_model_pitch_highbits);

624 lowbits = ff_opus_rc_dec_cdf(rc, model[s->bandwidth]);

625

626 primarylag = ff_silk_pitch_min_lag[s->bandwidth] +

627 highbits*ff_silk_pitch_scale[s->bandwidth] + lowbits;

628 }

629 frame->primarylag = primarylag;

630

631 if (s->subframes == 2)

632 offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)

633 ? ff_silk_pitch_offset_nb10ms[ff_opus_rc_dec_cdf(rc,

634 ff_silk_model_pitch_contour_nb10ms)]

635 : ff_silk_pitch_offset_mbwb10ms[ff_opus_rc_dec_cdf(rc,

636 ff_silk_model_pitch_contour_mbwb10ms)];

637 else

638 offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)

639 ? ff_silk_pitch_offset_nb20ms[ff_opus_rc_dec_cdf(rc,

640 ff_silk_model_pitch_contour_nb20ms)]

641 : ff_silk_pitch_offset_mbwb20ms[ff_opus_rc_dec_cdf(rc,

642 ff_silk_model_pitch_contour_mbwb20ms)];

643

644 for (i = 0; i < s->subframes; i++)

645 sf[i].pitchlag = av_clip(primarylag + offsets[i],

646 ff_silk_pitch_min_lag[s->bandwidth],

647 ff_silk_pitch_max_lag[s->bandwidth]);

648

649 /* obtain LTP filter coefficients */

650 ltpfilter = ff_opus_rc_dec_cdf(rc, ff_silk_model_ltp_filter);

651 for (i = 0; i < s->subframes; i++) {

652 int index, j;

653 static const uint16_t * const filter_sel[] = {

654 ff_silk_model_ltp_filter0_sel, ff_silk_model_ltp_filter1_sel,

655 ff_silk_model_ltp_filter2_sel

656 };

657 static const int8_t (* const filter_taps[])[5] = {

658 ff_silk_ltp_filter0_taps, ff_silk_ltp_filter1_taps, ff_silk_ltp_filter2_taps

659 };

660 index = ff_opus_rc_dec_cdf(rc, filter_sel[ltpfilter]);

661 for (j = 0; j < 5; j++)

662 sf[i].ltptaps[j] = filter_taps[ltpfilter][index][j] / 128.0f;

663 }

664 }

665

666 /* obtain LTP scale factor */

667 if (voiced && frame_num == 0)

668 ltpscale = ff_silk_ltp_scale_factor[ff_opus_rc_dec_cdf(rc,

669 ff_silk_model_ltp_scale_index)] / 16384.0f;

670 else ltpscale = 15565.0f/16384.0f;

671

672 /* generate the excitation signal for the entire frame */

673 silk_decode_excitation(s, rc, residual + SILK_MAX_LAG, qoffset_high,

674 active, voiced);

675

676 /* skip synthesising the output if we do not need it */

677 // TODO: implement error recovery

678 if (s->output_channels == channel || redundant)

679 return;

680

681 /* generate the output signal */

682 for (i = 0; i < s->subframes; i++) {

683 const float * lpc_coeff = (i < 2 && has_lpc_leadin) ? lpc_leadin : lpc_body;

684 float *dst = frame->output + SILK_HISTORY + i * s->sflength;

685 float *resptr = residual + SILK_MAX_LAG + i * s->sflength;

686 float *lpc = frame->lpc_history + SILK_HISTORY + i * s->sflength;

687 float sum;

688 int j, k;

689

690 if (voiced) {

691 int out_end;

692 float scale;

693

694 if (i < 2 || s->nlsf_interp_factor == 4) {

695 out_end = -i * s->sflength;

696 scale = ltpscale;

697 } else {

698 out_end = -(i - 2) * s->sflength;

699 scale = 1.0f;

700 }

701

702 /* when the LPC coefficients change, a re-whitening filter is used */

703 /* to produce a residual that accounts for the change */

704 for (j = - sf[i].pitchlag - LTP_ORDER/2; j < out_end; j++) {

705 sum = dst[j];

706 for (k = 0; k < order; k++)

707 sum -= lpc_coeff[k] * dst[j - k - 1];

708 resptr[j] = av_clipf(sum, -1.0f, 1.0f) * scale / sf[i].gain;

709 }

710

711 if (out_end) {

712 float rescale = sf[i-1].gain / sf[i].gain;

713 for (j = out_end; j < 0; j++)

714 resptr[j] *= rescale;

715 }

716

717 /* LTP synthesis */

718 for (j = 0; j < s->sflength; j++) {

719 sum = resptr[j];

720 for (k = 0; k < LTP_ORDER; k++)

721 sum += sf[i].ltptaps[k] * resptr[j - sf[i].pitchlag + LTP_ORDER/2 - k];

722 resptr[j] = sum;

723 }

724 }

725

726 /* LPC synthesis */

727 for (j = 0; j < s->sflength; j++) {

728 sum = resptr[j] * sf[i].gain;

729 for (k = 1; k <= order; k++)

730 sum += lpc_coeff[k - 1] * lpc[j - k];

731

732 lpc[j] = sum;

733 dst[j] = av_clipf(sum, -1.0f, 1.0f);

734 }

735 }

736

737 frame->prev_voiced = voiced;

738 memmove(frame->lpc_history, frame->lpc_history + s->flength, SILK_HISTORY * sizeof(float));

739 memmove(frame->output, frame->output + s->flength, SILK_HISTORY * sizeof(float));

740

741 frame->coded = 1;

742 }

743

744 static void silk_unmix_ms(SilkContext *s, float *l, float *r)

745 {

746 float *mid = s->frame[0].output + SILK_HISTORY - s->flength;

747 float *side = s->frame[1].output + SILK_HISTORY - s->flength;

748 float w0_prev = s->prev_stereo_weights[0];

749 float w1_prev = s->prev_stereo_weights[1];

750 float w0 = s->stereo_weights[0];

751 float w1 = s->stereo_weights[1];

752 int n1 = ff_silk_stereo_interp_len[s->bandwidth];

753 int i;

754

755 for (i = 0; i < n1; i++) {

756 float interp0 = w0_prev + i * (w0 - w0_prev) / n1;

757 float interp1 = w1_prev + i * (w1 - w1_prev) / n1;

758 float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);

759

760 l[i] = av_clipf((1 + interp1) * mid[i - 1] + side[i - 1] + interp0 * p0, -1.0, 1.0);

761 r[i] = av_clipf((1 - interp1) * mid[i - 1] - side[i - 1] - interp0 * p0, -1.0, 1.0);

762 }

763

764 for (; i < s->flength; i++) {

765 float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);

766

767 l[i] = av_clipf((1 + w1) * mid[i - 1] + side[i - 1] + w0 * p0, -1.0, 1.0);

768 r[i] = av_clipf((1 - w1) * mid[i - 1] - side[i - 1] - w0 * p0, -1.0, 1.0);

769 }

770

771 memcpy(s->prev_stereo_weights, s->stereo_weights, sizeof(s->stereo_weights));

772 }

773

774 static void silk_flush_frame(SilkFrame *frame)

775 {

776 if (!frame->coded)

777 return;

778

779 memset(frame->output, 0, sizeof(frame->output));

780 memset(frame->lpc_history, 0, sizeof(frame->lpc_history));

781

782 memset(frame->lpc, 0, sizeof(frame->lpc));

783 memset(frame->nlsf, 0, sizeof(frame->nlsf));

784

785 frame->log_gain = 0;

786

787 frame->primarylag = 0;

788 frame->prev_voiced = 0;

789 frame->coded = 0;

790 }

791

792 int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,

793 float *output[2],

794 enum OpusBandwidth bandwidth,

795 int coded_channels,

796 int duration_ms)

797 {

798 int active[2][6], redundancy[2];

799 int nb_frames, i, j;

800

801 if (bandwidth > OPUS_BANDWIDTH_WIDEBAND ||

802 coded_channels > 2 || duration_ms > 60) {

803 av_log(s->logctx, AV_LOG_ERROR, "Invalid parameters passed "

804 "to the SILK decoder.\n");

805 return AVERROR(EINVAL);

806 }

807

808 nb_frames = 1 + (duration_ms > 20) + (duration_ms > 40);

809 s->subframes = duration_ms / nb_frames / 5; // 5ms subframes

810 s->sflength = 20 * (bandwidth + 2);

811 s->flength = s->sflength * s->subframes;

812 s->bandwidth = bandwidth;

813 s->wb = bandwidth == OPUS_BANDWIDTH_WIDEBAND;

814

815 /* make sure to flush the side channel when switching from mono to stereo */

816 if (coded_channels > s->prev_coded_channels)

817 silk_flush_frame(&s->frame[1]);

818 s->prev_coded_channels = coded_channels;

819

820 /* read the LP-layer header bits */

821 for (i = 0; i < coded_channels; i++) {

822 for (j = 0; j < nb_frames; j++)

823 active[i][j] = ff_opus_rc_dec_log(rc, 1);

824

825 redundancy[i] = ff_opus_rc_dec_log(rc, 1);

826 }

827

828 /* read the per-frame LBRR flags */

829 for (i = 0; i < coded_channels; i++)

830 if (redundancy[i] && duration_ms > 20) {

831 redundancy[i] = ff_opus_rc_dec_cdf(rc, duration_ms == 40 ?

832 ff_silk_model_lbrr_flags_40 : ff_silk_model_lbrr_flags_60);

833 }

834

835 /* decode the LBRR frames */

836 for (i = 0; i < nb_frames; i++) {

837 for (j = 0; j < coded_channels; j++)

838 if (redundancy[j] & (1 << i)) {

839 int active1 = (j == 0 && !(redundancy[1] & (1 << i))) ? 0 : 1;

840 silk_decode_frame(s, rc, i, j, coded_channels, 1, active1, 1);

841 }

842

843 s->midonly = 0;

844 }

845

846 for (i = 0; i < nb_frames; i++) {

847 for (j = 0; j < coded_channels && !s->midonly; j++) {

848 int active1 = coded_channels > 1 ? active[1][i] : 0;

849 silk_decode_frame(s, rc, i, j, coded_channels, active[j][i], active1, 0);

850 }

851

852 /* reset the side channel if it is not coded */

853 if (s->midonly && s->frame[1].coded)

854 silk_flush_frame(&s->frame[1]);

855

856 if (coded_channels == 1 || s->output_channels == 1) {

857 for (j = 0; j < s->output_channels; j++) {

858 memcpy(output[j] + i * s->flength,

859 s->frame[0].output + SILK_HISTORY - s->flength - 2,

860 s->flength * sizeof(float));

861 }

862 } else {

863 silk_unmix_ms(s, output[0] + i * s->flength, output[1] + i * s->flength);

864 }

865

866 s->midonly = 0;

867 }

868

869 return nb_frames * s->flength;

870 }

871

872 void ff_silk_free(SilkContext **ps)

873 {

874 av_freep(ps);

875 }

876

877 void ff_silk_flush(SilkContext *s)

878 {

879 silk_flush_frame(&s->frame[0]);

880 silk_flush_frame(&s->frame[1]);

881

882 memset(s->prev_stereo_weights, 0, sizeof(s->prev_stereo_weights));

883 }

884

885 int ff_silk_init(void *logctx, SilkContext **ps, int output_channels)

886 {

887 SilkContext *s;

888

889 if (output_channels != 1 && output_channels != 2) {

890 av_log(logctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",

891 output_channels);

892 return AVERROR(EINVAL);

893 }

894

895 s = av_mallocz(sizeof(*s));

896 if (!s)

897 return AVERROR(ENOMEM);

898

899 s->logctx = logctx;

900 s->output_channels = output_channels;

901

902 ff_silk_flush(s);

903

904 *ps = s;

905

906 return 0;

907 }

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:32

ff_silk_lsf_codebook_wb

const uint8_t ff_silk_lsf_codebook_wb[32][16]

Definition: tab.c:507

ff_silk_model_gain_highbits

const uint16_t ff_silk_model_gain_highbits[3][9]

Definition: tab.c:49

av_clip

#define av_clip

Definition: common.h:100

SilkFrame::lpc_history

float lpc_history[2 *SILK_HISTORY]

Definition: silk.c:45

const char * r

Definition: vf_curves.c:127

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

ff_silk_cosine

const int16_t ff_silk_cosine[]

Definition: tab.c:558

OPUS_BANDWIDTH_NARROWBAND

@ OPUS_BANDWIDTH_NARROWBAND

Definition: opus.h:50

ff_silk_model_stereo_s1

const uint16_t ff_silk_model_stereo_s1[]

Definition: tab.c:34

SilkContext::prev_stereo_weights

float prev_stereo_weights[2]

Definition: silk.c:65

ff_silk_model_gain_lowbits

const uint16_t ff_silk_model_gain_lowbits[]

Definition: tab.c:55

silk_stabilize_lsf

static void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])

Definition: silk.c:71

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:124

ROUND_MULL

#define ROUND_MULL(a, b, s)

Definition: silk.c:36

SilkContext::output_channels

int output_channels

Definition: silk.c:53

int64_t

long long int64_t

Definition: coverity.c:34

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:226

silk_is_lpc_stable

static int silk_is_lpc_stable(const int16_t lpc[16], int order)

Definition: silk.c:149

SilkContext::flength

int flength

Definition: silk.c:58

SilkContext::logctx

void * logctx

Definition: silk.c:52

ff_silk_lsf_weight_sel_nbmb

const uint8_t ff_silk_lsf_weight_sel_nbmb[32][9]

Definition: tab.c:402

uint8_t w

Definition: llviddspenc.c:38

silk_count_children

static void silk_count_children(OpusRangeCoder *rc, int model, int32_t total, int32_t child[2])

Definition: silk.c:408

SilkFrame::log_gain

int log_gain

Definition: silk.c:40

ff_silk_model_pitch_delta

const uint16_t ff_silk_model_pitch_delta[]

Definition: tab.c:115

SilkFrame::output

float output[2 *SILK_HISTORY]

Definition: silk.c:44

#define b

Definition: input.c:42

opus.h

high

int high

Definition: dovi_rpuenc.c:39

ff_silk_pitch_offset_mbwb20ms

const int8_t ff_silk_pitch_offset_mbwb20ms[34][4]

Definition: tab.c:635

SilkContext::frame

SilkFrame frame[2]

Definition: silk.c:64

silk_lsf2lpc

static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)

Definition: silk.c:224

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ff_silk_lsf_weight_sel_wb

const uint8_t ff_silk_lsf_weight_sel_wb[32][15]

Definition: tab.c:437

ff_silk_model_pitch_lowbits_nb

#define ff_silk_model_pitch_lowbits_nb

Definition: tab.h:56

rc.h

bit

#define bit(string, value)

Definition: cbs_mpeg2.c:56

ff_silk_lsf_min_spacing_wb

const uint16_t ff_silk_lsf_min_spacing_wb[]

Definition: tab.c:546

SilkContext::bandwidth

enum OpusBandwidth bandwidth

Definition: silk.c:61

SilkFrame

Definition: silk.c:38

ff_silk_model_lsf_s2_ext

const uint16_t ff_silk_model_lsf_s2_ext[]

Definition: tab.c:104

MULH

#define MULH

Definition: mathops.h:42

weight

const h264_weight_func weight

Definition: h264dsp_init.c:33

ff_silk_free

void ff_silk_free(SilkContext **ps)

Definition: silk.c:872

ff_silk_model_excitation_sign

const uint16_t ff_silk_model_excitation_sign[3][2][7][3]

Definition: tab.c:259

type

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 type

Definition: writing_filters.txt:86

ff_silk_model_pitch_lowbits_wb

#define ff_silk_model_pitch_lowbits_wb

Definition: tab.h:58

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

ff_silk_model_pitch_contour_mbwb20ms

const uint16_t ff_silk_model_pitch_contour_mbwb20ms[]

Definition: tab.c:130

SilkFrame::lpc

float lpc[16]

Definition: silk.c:42

ff_silk_model_lsf_interpolation_offset

const uint16_t ff_silk_model_lsf_interpolation_offset[]

Definition: tab.c:106

ff_silk_lsf_codebook_nbmb

const uint8_t ff_silk_lsf_codebook_nbmb[32][10]

Definition: tab.c:472

ff_silk_lsf_s2_model_sel_wb

const uint8_t ff_silk_lsf_s2_model_sel_wb[32][16]

Definition: tab.c:357

#define s(width, name)

Definition: cbs_vp9.c:198

ff_silk_lsf_s2_model_sel_nbmb

const uint8_t ff_silk_lsf_s2_model_sel_nbmb[32][10]

Definition: tab.c:322

offsets

static const int offsets[]

Definition: hevc_pel.c:34

ff_silk_lsf_pred_weights_wb

const uint8_t ff_silk_lsf_pred_weights_wb[2][15]

Definition: tab.c:397

ff_silk_model_lcg_seed

const uint16_t ff_silk_model_lcg_seed[]

Definition: tab.c:153

ff_silk_pitch_offset_nb10ms

const int8_t ff_silk_pitch_offset_nb10ms[3][2]

Definition: tab.c:600

ff_silk_model_excitation_lsb

const uint16_t ff_silk_model_excitation_lsb[]

Definition: tab.c:257

av_sat_sub32

#define av_sat_sub32

Definition: common.h:133

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

ff_silk_lsf_ordering_nbmb

const uint8_t ff_silk_lsf_ordering_nbmb[]

Definition: tab.c:550

SilkContext

Definition: silk.c:51

FFABS

#define FFABS(a)

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

Definition: common.h:74

OPUS_BANDWIDTH_WIDEBAND

@ OPUS_BANDWIDTH_WIDEBAND

Definition: opus.h:52

ff_silk_pitch_offset_nb20ms

const int8_t ff_silk_pitch_offset_nb20ms[11][4]

Definition: tab.c:606

ff_silk_model_ltp_filter0_sel

const uint16_t ff_silk_model_ltp_filter0_sel[]

Definition: tab.c:138

ff_silk_stereo_weights

const int16_t ff_silk_stereo_weights[]

Definition: tab.c:317

ff_silk_model_lbrr_flags_40

const uint16_t ff_silk_model_lbrr_flags_40[]

Definition: tab.c:31

ff_silk_model_lsf_s1

const uint16_t ff_silk_model_lsf_s1[2][2][33]

Definition: tab.c:62

LTP_ORDER

#define LTP_ORDER

Order of the LTP filter.

Definition: silk.c:513

av_clip_int16

#define av_clip_int16

Definition: common.h:115

SilkFrame::nlsf

int16_t nlsf[16]

Definition: silk.c:41

ff_silk_model_pitch_highbits

const uint16_t ff_silk_model_pitch_highbits[]

Definition: tab.c:108

ff_opus_rc_dec_log

uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits)

Definition: rc.c:114

ff_silk_model_mid_only

const uint16_t ff_silk_model_mid_only[]

Definition: tab.c:43

av_clipf

Definition: af_crystalizer.c:122

seed

static unsigned int seed

Definition: videogen.c:78

SilkContext::subframes

int subframes

Definition: silk.c:56

index

int index

Definition: gxfenc.c:90

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

ff_silk_init

int ff_silk_init(void *logctx, SilkContext **ps, int output_channels)

Definition: silk.c:885

ff_silk_flush

void ff_silk_flush(SilkContext *s)

Definition: silk.c:877

silk.h

ff_silk_shell_blocks

const uint8_t ff_silk_shell_blocks[3][2]

Definition: tab.c:739

ff_silk_model_gain_delta

const uint16_t ff_silk_model_gain_delta[]

Definition: tab.c:57

Definition: af_crystalizer.c:122

rescale

static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)

Definition: gdv.c:132

silk_unmix_ms

static void silk_unmix_ms(SilkContext *s, float *l, float *r)

Definition: silk.c:744

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

ff_silk_lsf_ordering_wb

const uint8_t ff_silk_lsf_ordering_wb[]

Definition: tab.c:554

ff_silk_model_pulse_location

const uint16_t ff_silk_model_pulse_location[4][168]

Definition: tab.c:185

OpusRangeCoder

Definition: rc.h:41

SILK_MAX_LAG

#define SILK_MAX_LAG

Maximum residual history according to 4.2.7.6.1.

Definition: silk.c:510

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:166

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

silk_flush_frame

static void silk_flush_frame(SilkFrame *frame)

Definition: silk.c:774

ff_silk_ltp_filter2_taps

const int8_t ff_silk_ltp_filter2_taps[32][5]

Definition: tab.c:702

ff_opus_rc_dec_cdf

uint32_t ff_opus_rc_dec_cdf(OpusRangeCoder *rc, const uint16_t *cdf)

Definition: rc.c:90

ff_silk_model_pitch_contour_nb10ms

const uint16_t ff_silk_model_pitch_contour_nb10ms[]

Definition: tab.c:120

ff_silk_model_pitch_contour_nb20ms

const uint16_t ff_silk_model_pitch_contour_nb20ms[]

Definition: tab.c:122

ff_silk_model_ltp_filter1_sel

const uint16_t ff_silk_model_ltp_filter1_sel[]

Definition: tab.c:142

SILK_HISTORY

#define SILK_HISTORY

Definition: silk.h:29

tab.h

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

Definition: cbs_h2645.c:256

silk_decode_excitation

static void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc, float *excitationf, int qoffset_high, int active, int voiced)

Definition: silk.c:421

ff_silk_ltp_filter1_taps

const int8_t ff_silk_ltp_filter1_taps[16][5]

Definition: tab.c:683

SilkContext::nlsf_interp_factor

int nlsf_interp_factor

Definition: silk.c:59

SilkFrame::coded

int coded

Definition: silk.c:39

delta

float delta

Definition: vorbis_enc_data.h:430

value

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 default value

Definition: writing_filters.txt:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

ff_silk_model_lbrr_flags_60

const uint16_t ff_silk_model_lbrr_flags_60[]

Definition: tab.c:32

ff_silk_model_exc_rate

const uint16_t ff_silk_model_exc_rate[2][10]

Definition: tab.c:155

ff_silk_model_frame_type_inactive

const uint16_t ff_silk_model_frame_type_inactive[]

Definition: tab.c:45

SilkContext::prev_coded_channels

int prev_coded_channels

Definition: silk.c:68

ff_silk_lsf_min_spacing_nbmb

const uint16_t ff_silk_lsf_min_spacing_nbmb[]

Definition: tab.c:542

ff_silk_pitch_offset_mbwb10ms

const int8_t ff_silk_pitch_offset_mbwb10ms[12][2]

Definition: tab.c:620

ff_silk_model_ltp_filter2_sel

const uint16_t ff_silk_model_ltp_filter2_sel[]

Definition: tab.c:146

ff_silk_model_pitch_lowbits_mb

const uint16_t ff_silk_model_pitch_lowbits_mb[]

Definition: tab.c:113

ff_silk_model_stereo_s2

const uint16_t ff_silk_model_stereo_s2[]

Definition: tab.c:39

ff_silk_pitch_scale

const uint16_t ff_silk_pitch_scale[]

Definition: tab.c:594

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:265

opus_ilog

#define opus_ilog(i)

Definition: rc.h:32

ff_silk_pitch_max_lag

const uint16_t ff_silk_pitch_max_lag[]

Definition: tab.c:598

silk_decode_frame

static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc, int frame_num, int channel, int coded_channels, int active, int active1, int redundant)

Definition: silk.c:515

ff_silk_lsf_pred_weights_nbmb

const uint8_t ff_silk_lsf_pred_weights_nbmb[2][9]

Definition: tab.c:392

ff_silk_model_ltp_filter

const uint16_t ff_silk_model_ltp_filter[]

Definition: tab.c:136

ff_silk_decode_superframe

int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc, float *output[2], enum OpusBandwidth bandwidth, int coded_channels, int duration_ms)

Decode the LP layer of one Opus frame (which may correspond to several SILK frames).

Definition: silk.c:792

ff_silk_stereo_interp_len

const int ff_silk_stereo_interp_len[3]

Definition: tab.c:750

SilkFrame::primarylag

int primarylag

Definition: silk.c:46

SilkContext::stereo_weights

float stereo_weights[2]

Definition: silk.c:66

ff_silk_ltp_filter0_taps

const int8_t ff_silk_ltp_filter0_taps[8][5]

Definition: tab.c:672

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

SilkContext::sflength

int sflength

Definition: silk.c:57

ff_silk_model_frame_type_active

const uint16_t ff_silk_model_frame_type_active[]

Definition: tab.c:47

ff_silk_model_ltp_scale_index

const uint16_t ff_silk_model_ltp_scale_index[]

Definition: tab.c:151

SilkContext::midonly

int midonly

Definition: silk.c:55

mem.h

ff_silk_model_lsf_s2

const uint16_t ff_silk_model_lsf_s2[32][10]

Definition: tab.c:82

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: intra.c:273

SilkContext::wb

int wb

Definition: silk.c:62

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

ff_silk_pitch_min_lag

const uint16_t ff_silk_pitch_min_lag[]

Definition: tab.c:596

int32_t

Definition: audioconvert.c:56

silk_lsp2poly

static void silk_lsp2poly(const int32_t lsp[], int32_t pol[], int half_order)

Definition: silk.c:207

ff_silk_model_pulse_count

const uint16_t ff_silk_model_pulse_count[11][19]

Definition: tab.c:160

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

MULL

#define MULL(a, b, s)

Definition: mathops.h:58

ff_silk_quant_offset

const uint8_t ff_silk_quant_offset[2][2]

Definition: tab.c:745

silk_decode_lpc

static void silk_decode_lpc(SilkContext *s, SilkFrame *frame, OpusRangeCoder *rc, float lpc_leadin[16], float lpc[16], int *lpc_order, int *has_lpc_leadin, int voiced)

Definition: silk.c:311

SilkFrame::prev_voiced

int prev_voiced

Definition: silk.c:48

OpusBandwidth

Definition: opus.h:49

ff_silk_ltp_scale_factor

const uint16_t ff_silk_ltp_scale_factor[]

Definition: tab.c:737

channel

Definition: ebur128.h:39

codebook