FFmpeg: libavcodec/speexdec.c Source File

FFmpeg

[フレーム]

libavcodec

speexdec.c

Go to the documentation of this file.

1 /*

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

11 * modification, are permitted provided that the following conditions

12 * are met:

14 * - Redistributions of source code must retain the above copyright

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

17 * - Redistributions in binary form must reproduce the above copyright

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

19 * documentation and/or other materials provided with the distribution.

21 * - Neither the name of the Xiph.org Foundation nor the names of its

22 * contributors may be used to endorse or promote products derived from

23 * this software without specific prior written permission.

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

26 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

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

28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR

29 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

30 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

31 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

32 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

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

36 *

37 * This file is part of FFmpeg.

38 *

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

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

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

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

43 *

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

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

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

47 * Lesser General Public License for more details.

48 *

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

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

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

52 */

54 #include "libavutil/avassert.h"

55 #include "libavutil/avstring.h"

56 #include "libavutil/float_dsp.h"

57 #include "libavutil/mem.h"

58 #include "avcodec.h"

59 #include "bytestream.h"

60 #include "codec_internal.h"

61 #include "decode.h"

62 #include "get_bits.h"

63 #include "speexdata.h"

65 #define SPEEX_NB_MODES 3

66 #define SPEEX_INBAND_STEREO 9

68 #define QMF_ORDER 64

69 #define NB_ORDER 10

70 #define NB_FRAME_SIZE 160

71 #define NB_SUBMODES 9

72 #define NB_SUBMODE_BITS 4

73 #define SB_SUBMODE_BITS 3

75 #define NB_SUBFRAME_SIZE 40

76 #define NB_NB_SUBFRAMES 4

77 #define NB_PITCH_START 17

78 #define NB_PITCH_END 144

80 #define NB_DEC_BUFFER (NB_FRAME_SIZE + 2 * NB_PITCH_END + NB_SUBFRAME_SIZE + 12)

82 #define SPEEX_MEMSET(dst, c, n) (memset((dst), (c), (n) * sizeof(*(dst))))

83 #define SPEEX_COPY(dst, src, n) (memcpy((dst), (src), (n) * sizeof(*(dst))))

85 #define LSP_LINEAR(i) (.25f * (i) + .25f)

86 #define LSP_LINEAR_HIGH(i) (.3125f * (i) + .75f)

87 #define LSP_DIV_256(x) (0.00390625f * (x))

88 #define LSP_DIV_512(x) (0.001953125f * (x))

89 #define LSP_DIV_1024(x) (0.0009765625f * (x))

91 typedef struct LtpParams {

92 const int8_t *gain_cdbk;

93 int gain_bits;

94 int pitch_bits;

95 } LtpParam;

97 static const LtpParam ltp_params_vlbr = { gain_cdbk_lbr, 5, 0 };

98 static const LtpParam ltp_params_lbr = { gain_cdbk_lbr, 5, 7 };

99 static const LtpParam ltp_params_med = { gain_cdbk_lbr, 5, 7 };

100 static const LtpParam ltp_params_nb = { gain_cdbk_nb, 7, 7 };

101

102 typedef struct SplitCodebookParams {

103 int subvect_size;

104 int nb_subvect;

105 const signed char *shape_cb;

106 int shape_bits;

107 int have_sign;

108 } SplitCodebookParams;

109

110 static const SplitCodebookParams split_cb_nb_ulbr = { 20, 2, exc_20_32_table, 5, 0 };

111 static const SplitCodebookParams split_cb_nb_vlbr = { 10, 4, exc_10_16_table, 4, 0 };

112 static const SplitCodebookParams split_cb_nb_lbr = { 10, 4, exc_10_32_table, 5, 0 };

113 static const SplitCodebookParams split_cb_nb_med = { 8, 5, exc_8_128_table, 7, 0 };

114 static const SplitCodebookParams split_cb_nb = { 5, 8, exc_5_64_table, 6, 0 };

115 static const SplitCodebookParams split_cb_sb = { 5, 8, exc_5_256_table, 8, 0 };

116 static const SplitCodebookParams split_cb_high = { 8, 5, hexc_table, 7, 1 };

117 static const SplitCodebookParams split_cb_high_lbr= { 10, 4, hexc_10_32_table,5, 0 };

118

119 /** Quantizes LSPs */

120 typedef void (*lsp_quant_func)(float *, float *, int, GetBitContext *);

121

122 /** Decodes quantized LSPs */

123 typedef void (*lsp_unquant_func)(float *, int, GetBitContext *);

124

125 /** Long-term predictor quantization */

126 typedef int (*ltp_quant_func)(float *, float *, float *,

127 float *, float *, float *,

128 const void *, int, int, float, int, int,

129 GetBitContext *, char *, float *,

130 float *, int, int, int, float *);

131

132 /** Long-term un-quantize */

133 typedef void (*ltp_unquant_func)(float *, float *, int, int,

134 float, const void *, int, int *,

135 float *, GetBitContext *, int, int,

136 float, int);

137

138 /** Innovation quantization function */

139 typedef void (*innovation_quant_func)(float *, float *,

140 float *, float *, const void *,

141 int, int, float *, float *,

142 GetBitContext *, char *, int, int);

143

144 /** Innovation unquantization function */

145 typedef void (*innovation_unquant_func)(float *, const void *, int,

146 GetBitContext *, uint32_t *);

147

148 typedef struct SpeexSubmode {

149 int lbr_pitch; /**< Set to -1 for "normal" modes, otherwise encode pitch using

150 a global pitch and allowing a +- lbr_pitch variation (for

151 low not-rates)*/

152 int forced_pitch_gain; /**< Use the same (forced) pitch gain for all

153 sub-frames */

154 int have_subframe_gain; /**< Number of bits to use as sub-frame innovation

155 gain */

156 int double_codebook; /**< Apply innovation quantization twice for higher

157 quality (and higher bit-rate)*/

158 lsp_unquant_func lsp_unquant; /**< LSP unquantization function */

159

160 ltp_unquant_func ltp_unquant; /**< Long-term predictor (pitch) un-quantizer */

161 const void *LtpParam; /**< Pitch parameters (options) */

162

163 innovation_unquant_func innovation_unquant; /**< Innovation un-quantization */

164 const void *innovation_params; /**< Innovation quantization parameters*/

165

166 float comb_gain; /**< Gain of enhancer comb filter */

167 } SpeexSubmode;

168

169 typedef struct SpeexMode {

170 int modeID; /**< ID of the mode */

171 int (*decode)(AVCodecContext *avctx, void *dec, GetBitContext *gb, float *out);

172 int frame_size; /**< Size of frames used for decoding */

173 int subframe_size; /**< Size of sub-frames used for decoding */

174 int lpc_size; /**< Order of LPC filter */

175 float folding_gain; /**< Folding gain */

176 const SpeexSubmode *submodes[NB_SUBMODES]; /**< Sub-mode data for the mode */

177 int default_submode; /**< Default sub-mode to use when decoding */

178 } SpeexMode;

179

180 typedef struct DecoderState {

181 const SpeexMode *mode;

182 int modeID; /**< ID of the decoder mode */

183 int first; /**< Is first frame */

184 int full_frame_size; /**< Length of full-band frames */

185 int is_wideband; /**< If wideband is present */

186 int count_lost; /**< Was the last frame lost? */

187 int frame_size; /**< Length of high-band frames */

188 int subframe_size; /**< Length of high-band sub-frames */

189 int nb_subframes; /**< Number of high-band sub-frames */

190 int lpc_size; /**< Order of high-band LPC analysis */

191 float last_ol_gain; /**< Open-loop gain for previous frame */

192 float *innov_save; /**< If non-NULL, innovation is copied here */

193

194 /* This is used in packet loss concealment */

195 int last_pitch; /**< Pitch of last correctly decoded frame */

196 float last_pitch_gain; /**< Pitch gain of last correctly decoded frame */

197 uint32_t seed; /**< Seed used for random number generation */

198

199 int encode_submode;

200 const SpeexSubmode *const *submodes; /**< Sub-mode data */

201 int submodeID; /**< Activated sub-mode */

202 int lpc_enh_enabled; /**< 1 when LPC enhancer is on, 0 otherwise */

203

204 /* Vocoder data */

205 float voc_m1;

206 float voc_m2;

207 float voc_mean;

208 int voc_offset;

209

210 int dtx_enabled;

211 int highpass_enabled; /**< Is the input filter enabled */

212

213 float *exc; /**< Start of excitation frame */

214 float mem_hp[2]; /**< High-pass filter memory */

215 float exc_buf[NB_DEC_BUFFER]; /**< Excitation buffer */

216 float old_qlsp[NB_ORDER]; /**< Quantized LSPs for previous frame */

217 float interp_qlpc[NB_ORDER]; /**< Interpolated quantized LPCs */

218 float mem_sp[NB_ORDER]; /**< Filter memory for synthesis signal */

219 float g0_mem[QMF_ORDER];

220 float g1_mem[QMF_ORDER];

221 float pi_gain[NB_NB_SUBFRAMES]; /**< Gain of LPC filter at theta=pi (fe/2) */

222 float exc_rms[NB_NB_SUBFRAMES]; /**< RMS of excitation per subframe */

223 } DecoderState;

224

225 /* Default handler for user callbacks: skip it */

226 static int speex_default_user_handler(GetBitContext *gb, void *state, void *data)

227 {

228 const int req_size = get_bits(gb, 4);

229 skip_bits_long(gb, 5 + 8 * req_size);

230 return 0;

231 }

232

233 typedef struct StereoState {

234 float balance; /**< Left/right balance info */

235 float e_ratio; /**< Ratio of energies: E(left+right)/[E(left)+E(right)] */

236 float smooth_left; /**< Smoothed left channel gain */

237 float smooth_right; /**< Smoothed right channel gain */

238 } StereoState;

239

240 typedef struct SpeexContext {

241 AVClass *class;

242 GetBitContext gb;

243

244 int32_t version_id; /**< Version for Speex (for checking compatibility) */

245 int32_t rate; /**< Sampling rate used */

246 int32_t mode; /**< Mode used (0 for narrowband, 1 for wideband) */

247 int32_t bitstream_version; /**< Version ID of the bit-stream */

248 int32_t nb_channels; /**< Number of channels decoded */

249 int32_t bitrate; /**< Bit-rate used */

250 int32_t frame_size; /**< Size of frames */

251 int32_t vbr; /**< 1 for a VBR decoding, 0 otherwise */

252 int32_t frames_per_packet; /**< Number of frames stored per Ogg packet */

253 int32_t extra_headers; /**< Number of additional headers after the comments */

254

255 int pkt_size;

256

257 StereoState stereo;

258 DecoderState st[SPEEX_NB_MODES];

259

260 AVFloatDSPContext *fdsp;

261 } SpeexContext;

262

263 static void lsp_unquant_lbr(float *lsp, int order, GetBitContext *gb)

264 {

265 int id;

266

267 for (int i = 0; i < order; i++)

268 lsp[i] = LSP_LINEAR(i);

269

270 id = get_bits(gb, 6);

271 for (int i = 0; i < 10; i++)

272 lsp[i] += LSP_DIV_256(cdbk_nb[id * 10 + i]);

273

274 id = get_bits(gb, 6);

275 for (int i = 0; i < 5; i++)

276 lsp[i] += LSP_DIV_512(cdbk_nb_low1[id * 5 + i]);

277

278 id = get_bits(gb, 6);

279 for (int i = 0; i < 5; i++)

280 lsp[i + 5] += LSP_DIV_512(cdbk_nb_high1[id * 5 + i]);

281 }

282

283 static void forced_pitch_unquant(float *exc, float *exc_out, int start, int end,

284 float pitch_coef, const void *par, int nsf,

285 int *pitch_val, float *gain_val, GetBitContext *gb, int count_lost,

286 int subframe_offset, float last_pitch_gain, int cdbk_offset)

287 {

288 av_assert0(!isnan(pitch_coef));

289 pitch_coef = fminf(pitch_coef, .99f);

290 for (int i = 0; i < nsf; i++) {

291 exc_out[i] = exc[i - start] * pitch_coef;

292 exc[i] = exc_out[i];

293 }

294 pitch_val[0] = start;

295 gain_val[0] = gain_val[2] = 0.f;

296 gain_val[1] = pitch_coef;

297 }

298

299 static inline float speex_rand(float std, uint32_t *seed)

300 {

301 const uint32_t jflone = 0x3f800000;

302 const uint32_t jflmsk = 0x007fffff;

303 float fran;

304 uint32_t ran;

305 seed[0] = 1664525 * seed[0] + 1013904223;

306 ran = jflone | (jflmsk & seed[0]);

307 fran = av_int2float(ran);

308 fran -= 1.5f;

309 fran *= std;

310 return fran;

311 }

312

313 static void noise_codebook_unquant(float *exc, const void *par, int nsf,

314 GetBitContext *gb, uint32_t *seed)

315 {

316 for (int i = 0; i < nsf; i++)

317 exc[i] = speex_rand(1.f, seed);

318 }

319

320 static void split_cb_shape_sign_unquant(float *exc, const void *par, int nsf,

321 GetBitContext *gb, uint32_t *seed)

322 {

323 int subvect_size, nb_subvect, have_sign, shape_bits;

324 const SplitCodebookParams *params;

325 const signed char *shape_cb;

326 int signs[10], ind[10];

327

328 params = par;

329 subvect_size = params->subvect_size;

330 nb_subvect = params->nb_subvect;

331

332 shape_cb = params->shape_cb;

333 have_sign = params->have_sign;

334 shape_bits = params->shape_bits;

335

336 /* Decode codewords and gains */

337 for (int i = 0; i < nb_subvect; i++) {

338 signs[i] = have_sign ? get_bits1(gb) : 0;

339 ind[i] = get_bitsz(gb, shape_bits);

340 }

341 /* Compute decoded excitation */

342 for (int i = 0; i < nb_subvect; i++) {

343 const float s = signs[i] ? -1.f : 1.f;

344

345 for (int j = 0; j < subvect_size; j++)

346 exc[subvect_size * i + j] += s * 0.03125f * shape_cb[ind[i] * subvect_size + j];

347 }

348 }

349

350 #define SUBMODE(x) st->submodes[st->submodeID]->x

351

352 #define gain_3tap_to_1tap(g) (FFABS(g[1]) + (g[0] > 0.f ? g[0] : -.5f * g[0]) + (g[2] > 0.f ? g[2] : -.5f * g[2]))

353

354 static void

355 pitch_unquant_3tap(float *exc, float *exc_out, int start, int end, float pitch_coef,

356 const void *par, int nsf, int *pitch_val, float *gain_val, GetBitContext *gb,

357 int count_lost, int subframe_offset, float last_pitch_gain, int cdbk_offset)

358 {

359 int pitch, gain_index, gain_cdbk_size;

360 const int8_t *gain_cdbk;

361 const LtpParam *params;

362 float gain[3];

363

364 params = (const LtpParam *)par;

365 gain_cdbk_size = 1 << params->gain_bits;

366 gain_cdbk = params->gain_cdbk + 4 * gain_cdbk_size * cdbk_offset;

367

368 pitch = get_bitsz(gb, params->pitch_bits);

369 pitch += start;

370 gain_index = get_bitsz(gb, params->gain_bits);

371 gain[0] = 0.015625f * gain_cdbk[gain_index * 4] + .5f;

372 gain[1] = 0.015625f * gain_cdbk[gain_index * 4 + 1] + .5f;

373 gain[2] = 0.015625f * gain_cdbk[gain_index * 4 + 2] + .5f;

374

375 if (count_lost && pitch > subframe_offset) {

376 float tmp = count_lost < 4 ? last_pitch_gain : 0.5f * last_pitch_gain;

377 float gain_sum;

378

379 tmp = fminf(tmp, .95f);

380 gain_sum = gain_3tap_to_1tap(gain);

381

382 if (gain_sum > tmp && gain_sum > 0.f) {

383 float fact = tmp / gain_sum;

384 for (int i = 0; i < 3; i++)

385 gain[i] *= fact;

386 }

387 }

388

389 pitch_val[0] = pitch;

390 gain_val[0] = gain[0];

391 gain_val[1] = gain[1];

392 gain_val[2] = gain[2];

393 SPEEX_MEMSET(exc_out, 0, nsf);

394

395 for (int i = 0; i < 3; i++) {

396 int tmp1, tmp3;

397 int pp = pitch + 1 - i;

398 tmp1 = nsf;

399 if (tmp1 > pp)

400 tmp1 = pp;

401 for (int j = 0; j < tmp1; j++)

402 exc_out[j] += gain[2 - i] * exc[j - pp];

403 tmp3 = nsf;

404 if (tmp3 > pp + pitch)

405 tmp3 = pp + pitch;

406 for (int j = tmp1; j < tmp3; j++)

407 exc_out[j] += gain[2 - i] * exc[j - pp - pitch];

408 }

409 }

410

411 static void lsp_unquant_nb(float *lsp, int order, GetBitContext *gb)

412 {

413 int id;

414

415 for (int i = 0; i < order; i++)

416 lsp[i] = LSP_LINEAR(i);

417

418 id = get_bits(gb, 6);

419 for (int i = 0; i < 10; i++)

420 lsp[i] += LSP_DIV_256(cdbk_nb[id * 10 + i]);

421

422 id = get_bits(gb, 6);

423 for (int i = 0; i < 5; i++)

424 lsp[i] += LSP_DIV_512(cdbk_nb_low1[id * 5 + i]);

425

426 id = get_bits(gb, 6);

427 for (int i = 0; i < 5; i++)

428 lsp[i] += LSP_DIV_1024(cdbk_nb_low2[id * 5 + i]);

429

430 id = get_bits(gb, 6);

431 for (int i = 0; i < 5; i++)

432 lsp[i + 5] += LSP_DIV_512(cdbk_nb_high1[id * 5 + i]);

433

434 id = get_bits(gb, 6);

435 for (int i = 0; i < 5; i++)

436 lsp[i + 5] += LSP_DIV_1024(cdbk_nb_high2[id * 5 + i]);

437 }

438

439 static void lsp_unquant_high(float *lsp, int order, GetBitContext *gb)

440 {

441 int id;

442

443 for (int i = 0; i < order; i++)

444 lsp[i] = LSP_LINEAR_HIGH(i);

445

446 id = get_bits(gb, 6);

447 for (int i = 0; i < order; i++)

448 lsp[i] += LSP_DIV_256(high_lsp_cdbk[id * order + i]);

449

450 id = get_bits(gb, 6);

451 for (int i = 0; i < order; i++)

452 lsp[i] += LSP_DIV_512(high_lsp_cdbk2[id * order + i]);

453 }

454

455 /* 2150 bps "vocoder-like" mode for comfort noise */

456 static const SpeexSubmode nb_submode1 = {

457 0, 1, 0, 0, lsp_unquant_lbr, forced_pitch_unquant, NULL,

458 noise_codebook_unquant, NULL, -1.f

459 };

460

461 /* 5.95 kbps very low bit-rate mode */

462 static const SpeexSubmode nb_submode2 = {

463 0, 0, 0, 0, lsp_unquant_lbr, pitch_unquant_3tap, &ltp_params_vlbr,

464 split_cb_shape_sign_unquant, &split_cb_nb_vlbr, .6f

465 };

466

467 /* 8 kbps low bit-rate mode */

468 static const SpeexSubmode nb_submode3 = {

469 -1, 0, 1, 0, lsp_unquant_lbr, pitch_unquant_3tap, &ltp_params_lbr,

470 split_cb_shape_sign_unquant, &split_cb_nb_lbr, .55f

471 };

472

473 /* 11 kbps medium bit-rate mode */

474 static const SpeexSubmode nb_submode4 = {

475 -1, 0, 1, 0, lsp_unquant_lbr, pitch_unquant_3tap, &ltp_params_med,

476 split_cb_shape_sign_unquant, &split_cb_nb_med, .45f

477 };

478

479 /* 15 kbps high bit-rate mode */

480 static const SpeexSubmode nb_submode5 = {

481 -1, 0, 3, 0, lsp_unquant_nb, pitch_unquant_3tap, &ltp_params_nb,

482 split_cb_shape_sign_unquant, &split_cb_nb, .25f

483 };

484

485 /* 18.2 high bit-rate mode */

486 static const SpeexSubmode nb_submode6 = {

487 -1, 0, 3, 0, lsp_unquant_nb, pitch_unquant_3tap, &ltp_params_nb,

488 split_cb_shape_sign_unquant, &split_cb_sb, .15f

489 };

490

491 /* 24.6 kbps high bit-rate mode */

492 static const SpeexSubmode nb_submode7 = {

493 -1, 0, 3, 1, lsp_unquant_nb, pitch_unquant_3tap, &ltp_params_nb,

494 split_cb_shape_sign_unquant, &split_cb_nb, 0.05f

495 };

496

497 /* 3.95 kbps very low bit-rate mode */

498 static const SpeexSubmode nb_submode8 = {

499 0, 1, 0, 0, lsp_unquant_lbr, forced_pitch_unquant, NULL,

500 split_cb_shape_sign_unquant, &split_cb_nb_ulbr, .5f

501 };

502

503 static const SpeexSubmode wb_submode1 = {

504 0, 0, 1, 0, lsp_unquant_high, NULL, NULL,

505 NULL, NULL, -1.f

506 };

507

508 static const SpeexSubmode wb_submode2 = {

509 0, 0, 1, 0, lsp_unquant_high, NULL, NULL,

510 split_cb_shape_sign_unquant, &split_cb_high_lbr, -1.f

511 };

512

513 static const SpeexSubmode wb_submode3 = {

514 0, 0, 1, 0, lsp_unquant_high, NULL, NULL,

515 split_cb_shape_sign_unquant, &split_cb_high, -1.f

516 };

517

518 static const SpeexSubmode wb_submode4 = {

519 0, 0, 1, 1, lsp_unquant_high, NULL, NULL,

520 split_cb_shape_sign_unquant, &split_cb_high, -1.f

521 };

522

523 static int nb_decode(AVCodecContext *, void *, GetBitContext *, float *);

524 static int sb_decode(AVCodecContext *, void *, GetBitContext *, float *);

525

526 static const SpeexMode speex_modes[SPEEX_NB_MODES] = {

527 {

528 .modeID = 0,

529 .decode = nb_decode,

530 .frame_size = NB_FRAME_SIZE,

531 .subframe_size = NB_SUBFRAME_SIZE,

532 .lpc_size = NB_ORDER,

533 .submodes = {

534 NULL, &nb_submode1, &nb_submode2, &nb_submode3, &nb_submode4,

535 &nb_submode5, &nb_submode6, &nb_submode7, &nb_submode8

536 },

537 .default_submode = 5,

538 },

539 {

540 .modeID = 1,

541 .decode = sb_decode,

542 .frame_size = NB_FRAME_SIZE,

543 .subframe_size = NB_SUBFRAME_SIZE,

544 .lpc_size = 8,

545 .folding_gain = 0.9f,

546 .submodes = {

547 NULL, &wb_submode1, &wb_submode2, &wb_submode3, &wb_submode4

548 },

549 .default_submode = 3,

550 },

551 {

552 .modeID = 2,

553 .decode = sb_decode,

554 .frame_size = 320,

555 .subframe_size = 80,

556 .lpc_size = 8,

557 .folding_gain = 0.7f,

558 .submodes = {

559 NULL, &wb_submode1

560 },

561 .default_submode = 1,

562 },

563 };

564

565 static float compute_rms(const float *x, int len)

566 {

567 float sum = 0.f;

568

569 for (int i = 0; i < len; i++)

570 sum += x[i] * x[i];

571

572 av_assert0(len > 0);

573 return sqrtf(.1f + sum / len);

574 }

575

576 static void bw_lpc(float gamma, const float *lpc_in,

577 float *lpc_out, int order)

578 {

579 float tmp = gamma;

580

581 for (int i = 0; i < order; i++) {

582 lpc_out[i] = tmp * lpc_in[i];

583 tmp *= gamma;

584 }

585 }

586

587 static void iir_mem(const float *x, const float *den,

588 float *y, int N, int ord, float *mem)

589 {

590 for (int i = 0; i < N; i++) {

591 float yi = x[i] + mem[0];

592 float nyi = -yi;

593 for (int j = 0; j < ord - 1; j++)

594 mem[j] = mem[j + 1] + den[j] * nyi;

595 mem[ord - 1] = den[ord - 1] * nyi;

596 y[i] = yi;

597 }

598 }

599

600 static void highpass(const float *x, float *y, int len, float *mem, int wide)

601 {

602 static const float Pcoef[2][3] = {{ 1.00000f, -1.92683f, 0.93071f }, { 1.00000f, -1.97226f, 0.97332f } };

603 static const float Zcoef[2][3] = {{ 0.96446f, -1.92879f, 0.96446f }, { 0.98645f, -1.97277f, 0.98645f } };

604 const float *den, *num;

605

606 den = Pcoef[wide];

607 num = Zcoef[wide];

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

609 float yi = num[0] * x[i] + mem[0];

610 mem[0] = mem[1] + num[1] * x[i] + -den[1] * yi;

611 mem[1] = num[2] * x[i] + -den[2] * yi;

612 y[i] = yi;

613 }

614 }

615

616 #define median3(a, b, c) \

617 ((a) < (b) ? ((b) < (c) ? (b) : ((a) < (c) ? (c) : (a))) \

618 : ((c) < (b) ? (b) : ((c) < (a) ? (c) : (a))))

619

620 static int speex_std_stereo(GetBitContext *gb, void *state, void *data)

621 {

622 StereoState *stereo = data;

623 float sign = get_bits1(gb) ? -1.f : 1.f;

624

625 stereo->balance = exp(sign * .25f * get_bits(gb, 5));

626 stereo->e_ratio = e_ratio_quant[get_bits(gb, 2)];

627

628 return 0;

629 }

630

631 static int speex_inband_handler(GetBitContext *gb, void *state, StereoState *stereo)

632 {

633 int id = get_bits(gb, 4);

634

635 if (id == SPEEX_INBAND_STEREO) {

636 return speex_std_stereo(gb, state, stereo);

637 } else {

638 int adv;

639

640 if (id < 2)

641 adv = 1;

642 else if (id < 8)

643 adv = 4;

644 else if (id < 10)

645 adv = 8;

646 else if (id < 12)

647 adv = 16;

648 else if (id < 14)

649 adv = 32;

650 else

651 adv = 64;

652 skip_bits_long(gb, adv);

653 }

654 return 0;

655 }

656

657 static void sanitize_values(float *vec, float min_val, float max_val, int len)

658 {

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

660 if (!isnormal(vec[i]) || fabsf(vec[i]) < 1e-8f)

661 vec[i] = 0.f;

662 else

663 vec[i] = av_clipf(vec[i], min_val, max_val);

664 }

665 }

666

667 static void signal_mul(const float *x, float *y, float scale, int len)

668 {

669 for (int i = 0; i < len; i++)

670 y[i] = scale * x[i];

671 }

672

673 static float inner_prod(const float *x, const float *y, int len)

674 {

675 float sum = 0.f;

676

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

678 float part = 0.f;

679 part += x[i + 0] * y[i + 0];

680 part += x[i + 1] * y[i + 1];

681 part += x[i + 2] * y[i + 2];

682 part += x[i + 3] * y[i + 3];

683 part += x[i + 4] * y[i + 4];

684 part += x[i + 5] * y[i + 5];

685 part += x[i + 6] * y[i + 6];

686 part += x[i + 7] * y[i + 7];

687 sum += part;

688 }

689

690 return sum;

691 }

692

693 static int interp_pitch(const float *exc, float *interp, int pitch, int len)

694 {

695 float corr[4][7], maxcorr;

696 int maxi, maxj;

697

698 for (int i = 0; i < 7; i++)

699 corr[0][i] = inner_prod(exc, exc - pitch - 3 + i, len);

700 for (int i = 0; i < 3; i++) {

701 for (int j = 0; j < 7; j++) {

702 int i1, i2;

703 float tmp = 0.f;

704

705 i1 = 3 - j;

706 if (i1 < 0)

707 i1 = 0;

708 i2 = 10 - j;

709 if (i2 > 7)

710 i2 = 7;

711 for (int k = i1; k < i2; k++)

712 tmp += shift_filt[i][k] * corr[0][j + k - 3];

713 corr[i + 1][j] = tmp;

714 }

715 }

716 maxi = maxj = 0;

717 maxcorr = corr[0][0];

718 for (int i = 0; i < 4; i++) {

719 for (int j = 0; j < 7; j++) {

720 if (corr[i][j] > maxcorr) {

721 maxcorr = corr[i][j];

722 maxi = i;

723 maxj = j;

724 }

725 }

726 }

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

728 float tmp = 0.f;

729 if (maxi > 0.f) {

730 for (int k = 0; k < 7; k++)

731 tmp += exc[i - (pitch - maxj + 3) + k - 3] * shift_filt[maxi - 1][k];

732 } else {

733 tmp = exc[i - (pitch - maxj + 3)];

734 }

735 interp[i] = tmp;

736 }

737 return pitch - maxj + 3;

738 }

739

740 static void multicomb(const float *exc, float *new_exc, float *ak, int p, int nsf,

741 int pitch, int max_pitch, float comb_gain)

742 {

743 float old_ener, new_ener;

744 float iexc0_mag, iexc1_mag, exc_mag;

745 float iexc[4 * NB_SUBFRAME_SIZE];

746 float corr0, corr1, gain0, gain1;

747 float pgain1, pgain2;

748 float c1, c2, g1, g2;

749 float ngain, gg1, gg2;

750 int corr_pitch = pitch;

751

752 interp_pitch(exc, iexc, corr_pitch, 80);

753 if (corr_pitch > max_pitch)

754 interp_pitch(exc, iexc + nsf, 2 * corr_pitch, 80);

755 else

756 interp_pitch(exc, iexc + nsf, -corr_pitch, 80);

757

758 iexc0_mag = sqrtf(1000.f + inner_prod(iexc, iexc, nsf));

759 iexc1_mag = sqrtf(1000.f + inner_prod(iexc + nsf, iexc + nsf, nsf));

760 exc_mag = sqrtf(1.f + inner_prod(exc, exc, nsf));

761 corr0 = inner_prod(iexc, exc, nsf);

762 corr1 = inner_prod(iexc + nsf, exc, nsf);

763 if (corr0 > iexc0_mag * exc_mag)

764 pgain1 = 1.f;

765 else

766 pgain1 = (corr0 / exc_mag) / iexc0_mag;

767 if (corr1 > iexc1_mag * exc_mag)

768 pgain2 = 1.f;

769 else

770 pgain2 = (corr1 / exc_mag) / iexc1_mag;

771 gg1 = exc_mag / iexc0_mag;

772 gg2 = exc_mag / iexc1_mag;

773 if (comb_gain > 0.f) {

774 c1 = .4f * comb_gain + .07f;

775 c2 = .5f + 1.72f * (c1 - .07f);

776 } else {

777 c1 = c2 = 0.f;

778 }

779 g1 = 1.f - c2 * pgain1 * pgain1;

780 g2 = 1.f - c2 * pgain2 * pgain2;

781 g1 = fmaxf(g1, c1);

782 g2 = fmaxf(g2, c1);

783 g1 = c1 / g1;

784 g2 = c1 / g2;

785

786 if (corr_pitch > max_pitch) {

787 gain0 = .7f * g1 * gg1;

788 gain1 = .3f * g2 * gg2;

789 } else {

790 gain0 = .6f * g1 * gg1;

791 gain1 = .6f * g2 * gg2;

792 }

793 for (int i = 0; i < nsf; i++)

794 new_exc[i] = exc[i] + (gain0 * iexc[i]) + (gain1 * iexc[i + nsf]);

795 new_ener = compute_rms(new_exc, nsf);

796 old_ener = compute_rms(exc, nsf);

797

798 old_ener = fmaxf(old_ener, 1.f);

799 new_ener = fmaxf(new_ener, 1.f);

800 old_ener = fminf(old_ener, new_ener);

801 ngain = old_ener / new_ener;

802

803 for (int i = 0; i < nsf; i++)

804 new_exc[i] *= ngain;

805 }

806

807 static void lsp_interpolate(const float *old_lsp, const float *new_lsp,

808 float *lsp, int len, int subframe,

809 int nb_subframes, float margin)

810 {

811 const float tmp = (1.f + subframe) / nb_subframes;

812

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

814 lsp[i] = (1.f - tmp) * old_lsp[i] + tmp * new_lsp[i];

815 lsp[i] = av_clipf(lsp[i], margin, M_PI - margin);

816 }

817 for (int i = 1; i < len - 1; i++) {

818 lsp[i] = fmaxf(lsp[i], lsp[i - 1] + margin);

819 if (lsp[i] > lsp[i + 1] - margin)

820 lsp[i] = .5f * (lsp[i] + lsp[i + 1] - margin);

821 }

822 }

823

824 static void lsp_to_lpc(const float *freq, float *ak, int lpcrdr)

825 {

826 float xout1, xout2, xin1, xin2;

827 float *pw, *n0;

828 float Wp[4 * NB_ORDER + 2] = { 0 };

829 float x_freq[NB_ORDER];

830 const int m = lpcrdr >> 1;

831

832 pw = Wp;

833

834 xin1 = xin2 = 1.f;

835

836 for (int i = 0; i < lpcrdr; i++)

837 x_freq[i] = -cosf(freq[i]);

838

839 /* reconstruct P(z) and Q(z) by cascading second order

840 * polynomials in form 1 - 2xz(-1) +z(-2), where x is the

841 * LSP coefficient

842 */

843 for (int j = 0; j <= lpcrdr; j++) {

844 int i2 = 0;

845 for (int i = 0; i < m; i++, i2 += 2) {

846 n0 = pw + (i * 4);

847 xout1 = xin1 + 2.f * x_freq[i2 ] * n0[0] + n0[1];

848 xout2 = xin2 + 2.f * x_freq[i2 + 1] * n0[2] + n0[3];

849 n0[1] = n0[0];

850 n0[3] = n0[2];

851 n0[0] = xin1;

852 n0[2] = xin2;

853 xin1 = xout1;

854 xin2 = xout2;

855 }

856 xout1 = xin1 + n0[4];

857 xout2 = xin2 - n0[5];

858 if (j > 0)

859 ak[j - 1] = (xout1 + xout2) * 0.5f;

860 n0[4] = xin1;

861 n0[5] = xin2;

862

863 xin1 = 0.f;

864 xin2 = 0.f;

865 }

866 }

867

868 static int nb_decode(AVCodecContext *avctx, void *ptr_st,

869 GetBitContext *gb, float *out)

870 {

871 DecoderState *st = ptr_st;

872 float ol_gain = 0, ol_pitch_coef = 0, best_pitch_gain = 0, pitch_average = 0;

873 int m, pitch, wideband, ol_pitch = 0, best_pitch = 40;

874 SpeexContext *s = avctx->priv_data;

875 float innov[NB_SUBFRAME_SIZE];

876 float exc32[NB_SUBFRAME_SIZE];

877 float interp_qlsp[NB_ORDER];

878 float qlsp[NB_ORDER];

879 float ak[NB_ORDER];

880 float pitch_gain[3] = { 0 };

881

882 st->exc = st->exc_buf + 2 * NB_PITCH_END + NB_SUBFRAME_SIZE + 6;

883

884 if (st->encode_submode) {

885 do { /* Search for next narrowband block (handle requests, skip wideband blocks) */

886 if (get_bits_left(gb) < 5)

887 return AVERROR_INVALIDDATA;

888 wideband = get_bits1(gb);

889 if (wideband) /* Skip wideband block (for compatibility) */ {

890 int submode, advance;

891

892 submode = get_bits(gb, SB_SUBMODE_BITS);

893 advance = wb_skip_table[submode];

894 advance -= SB_SUBMODE_BITS + 1;

895 if (advance < 0)

896 return AVERROR_INVALIDDATA;

897 skip_bits_long(gb, advance);

898

899 if (get_bits_left(gb) < 5)

900 return AVERROR_INVALIDDATA;

901 wideband = get_bits1(gb);

902 if (wideband) {

903 submode = get_bits(gb, SB_SUBMODE_BITS);

904 advance = wb_skip_table[submode];

905 advance -= SB_SUBMODE_BITS + 1;

906 if (advance < 0)

907 return AVERROR_INVALIDDATA;

908 skip_bits_long(gb, advance);

909 wideband = get_bits1(gb);

910 if (wideband) {

911 av_log(avctx, AV_LOG_ERROR, "more than two wideband layers found\n");

912 return AVERROR_INVALIDDATA;

913 }

914 }

915 }

916 if (get_bits_left(gb) < 4)

917 return AVERROR_INVALIDDATA;

918 m = get_bits(gb, 4);

919 if (m == 15) /* We found a terminator */ {

920 return AVERROR_INVALIDDATA;

921 } else if (m == 14) /* Speex in-band request */ {

922 int ret = speex_inband_handler(gb, st, &s->stereo);

923 if (ret)

924 return ret;

925 } else if (m == 13) /* User in-band request */ {

926 int ret = speex_default_user_handler(gb, st, NULL);

927 if (ret)

928 return ret;

929 } else if (m > 8) /* Invalid mode */ {

930 return AVERROR_INVALIDDATA;

931 }

932 } while (m > 8);

933

934 st->submodeID = m; /* Get the sub-mode that was used */

935 }

936

937 /* Shift all buffers by one frame */

938 memmove(st->exc_buf, st->exc_buf + NB_FRAME_SIZE, (2 * NB_PITCH_END + NB_SUBFRAME_SIZE + 12) * sizeof(float));

939

940 /* If null mode (no transmission), just set a couple things to zero */

941 if (st->submodes[st->submodeID] == NULL) {

942 float lpc[NB_ORDER];

943 float innov_gain = 0.f;

944

945 bw_lpc(0.93f, st->interp_qlpc, lpc, NB_ORDER);

946 innov_gain = compute_rms(st->exc, NB_FRAME_SIZE);

947 for (int i = 0; i < NB_FRAME_SIZE; i++)

948 st->exc[i] = speex_rand(innov_gain, &st->seed);

949

950 /* Final signal synthesis from excitation */

951 iir_mem(st->exc, lpc, out, NB_FRAME_SIZE, NB_ORDER, st->mem_sp);

952 st->count_lost = 0;

953

954 return 0;

955 }

956

957 /* Unquantize LSPs */

958 SUBMODE(lsp_unquant)(qlsp, NB_ORDER, gb);

959

960 /* Damp memory if a frame was lost and the LSP changed too much */

961 if (st->count_lost) {

962 float fact, lsp_dist = 0;

963

964 for (int i = 0; i < NB_ORDER; i++)

965 lsp_dist = lsp_dist + FFABS(st->old_qlsp[i] - qlsp[i]);

966 fact = .6f * exp(-.2f * lsp_dist);

967 for (int i = 0; i < NB_ORDER; i++)

968 st->mem_sp[i] = fact * st->mem_sp[i];

969 }

970

971 /* Handle first frame and lost-packet case */

972 if (st->first || st->count_lost)

973 memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));

974

975 /* Get open-loop pitch estimation for low bit-rate pitch coding */

976 if (SUBMODE(lbr_pitch) != -1)

977 ol_pitch = NB_PITCH_START + get_bits(gb, 7);

978

979 if (SUBMODE(forced_pitch_gain))

980 ol_pitch_coef = 0.066667f * get_bits(gb, 4);

981

982 /* Get global excitation gain */

983 ol_gain = expf(get_bits(gb, 5) / 3.5f);

984

985 if (st->submodeID == 1)

986 st->dtx_enabled = get_bits(gb, 4) == 15;

987

988 if (st->submodeID > 1)

989 st->dtx_enabled = 0;

990

991 for (int sub = 0; sub < NB_NB_SUBFRAMES; sub++) { /* Loop on subframes */

992 float *exc, *innov_save = NULL, tmp, ener;

993 int pit_min, pit_max, offset, q_energy;

994

995 offset = NB_SUBFRAME_SIZE * sub; /* Offset relative to start of frame */

996 exc = st->exc + offset; /* Excitation */

997 if (st->innov_save) /* Original signal */

998 innov_save = st->innov_save + offset;

999

1000 SPEEX_MEMSET(exc, 0, NB_SUBFRAME_SIZE); /* Reset excitation */

1001

1002 /* Adaptive codebook contribution */

1003 av_assert0(SUBMODE(ltp_unquant));

1004 /* Handle pitch constraints if any */

1005 if (SUBMODE(lbr_pitch) != -1) {

1006 int margin = SUBMODE(lbr_pitch);

1007

1008 if (margin) {

1009 pit_min = ol_pitch - margin + 1;

1010 pit_min = FFMAX(pit_min, NB_PITCH_START);

1011 pit_max = ol_pitch + margin;

1012 pit_max = FFMIN(pit_max, NB_PITCH_START);

1013 } else {

1014 pit_min = pit_max = ol_pitch;

1015 }

1016 } else {

1017 pit_min = NB_PITCH_START;

1018 pit_max = NB_PITCH_END;

1019 }

1020

1021 SUBMODE(ltp_unquant)(exc, exc32, pit_min, pit_max, ol_pitch_coef, SUBMODE(LtpParam),

1022 NB_SUBFRAME_SIZE, &pitch, pitch_gain, gb, st->count_lost, offset,

1023 st->last_pitch_gain, 0);

1024

1025 sanitize_values(exc32, -32000, 32000, NB_SUBFRAME_SIZE);

1026

1027 tmp = gain_3tap_to_1tap(pitch_gain);

1028

1029 pitch_average += tmp;

1030 if ((tmp > best_pitch_gain &&

1031 FFABS(2 * best_pitch - pitch) >= 3 &&

1032 FFABS(3 * best_pitch - pitch) >= 4 &&

1033 FFABS(4 * best_pitch - pitch) >= 5) ||

1034 (tmp > .6f * best_pitch_gain &&

1035 (FFABS(best_pitch - 2 * pitch) < 3 ||

1036 FFABS(best_pitch - 3 * pitch) < 4 ||

1037 FFABS(best_pitch - 4 * pitch) < 5)) ||

1038 ((.67f * tmp) > best_pitch_gain &&

1039 (FFABS(2 * best_pitch - pitch) < 3 ||

1040 FFABS(3 * best_pitch - pitch) < 4 ||

1041 FFABS(4 * best_pitch - pitch) < 5))) {

1042 best_pitch = pitch;

1043 if (tmp > best_pitch_gain)

1044 best_pitch_gain = tmp;

1045 }

1046

1047 memset(innov, 0, sizeof(innov));

1048

1049 /* Decode sub-frame gain correction */

1050 if (SUBMODE(have_subframe_gain) == 3) {

1051 q_energy = get_bits(gb, 3);

1052 ener = exc_gain_quant_scal3[q_energy] * ol_gain;

1053 } else if (SUBMODE(have_subframe_gain) == 1) {

1054 q_energy = get_bits1(gb);

1055 ener = exc_gain_quant_scal1[q_energy] * ol_gain;

1056 } else {

1057 ener = ol_gain;

1058 }

1059

1060 av_assert0(SUBMODE(innovation_unquant));

1061 /* Fixed codebook contribution */

1062 SUBMODE(innovation_unquant)(innov, SUBMODE(innovation_params), NB_SUBFRAME_SIZE, gb, &st->seed);

1063 /* De-normalize innovation and update excitation */

1064

1065 signal_mul(innov, innov, ener, NB_SUBFRAME_SIZE);

1066

1067 /* Decode second codebook (only for some modes) */

1068 if (SUBMODE(double_codebook)) {

1069 float innov2[NB_SUBFRAME_SIZE] = { 0 };

1070

1071 SUBMODE(innovation_unquant)(innov2, SUBMODE(innovation_params), NB_SUBFRAME_SIZE, gb, &st->seed);

1072 signal_mul(innov2, innov2, 0.454545f * ener, NB_SUBFRAME_SIZE);

1073 for (int i = 0; i < NB_SUBFRAME_SIZE; i++)

1074 innov[i] += innov2[i];

1075 }

1076 for (int i = 0; i < NB_SUBFRAME_SIZE; i++)

1077 exc[i] = exc32[i] + innov[i];

1078 if (innov_save)

1079 memcpy(innov_save, innov, sizeof(innov));

1080

1081 /* Vocoder mode */

1082 if (st->submodeID == 1) {

1083 float g = ol_pitch_coef;

1084

1085 g = av_clipf(1.5f * (g - .2f), 0.f, 1.f);

1086

1087 SPEEX_MEMSET(exc, 0, NB_SUBFRAME_SIZE);

1088 while (st->voc_offset < NB_SUBFRAME_SIZE) {

1089 if (st->voc_offset >= 0)

1090 exc[st->voc_offset] = sqrtf(2.f * ol_pitch) * (g * ol_gain);

1091 st->voc_offset += ol_pitch;

1092 }

1093 st->voc_offset -= NB_SUBFRAME_SIZE;

1094

1095 for (int i = 0; i < NB_SUBFRAME_SIZE; i++) {

1096 float exci = exc[i];

1097 exc[i] = (.7f * exc[i] + .3f * st->voc_m1) + ((1.f - .85f * g) * innov[i]) - .15f * g * st->voc_m2;

1098 st->voc_m1 = exci;

1099 st->voc_m2 = innov[i];

1100 st->voc_mean = .8f * st->voc_mean + .2f * exc[i];

1101 exc[i] -= st->voc_mean;

1102 }

1103 }

1104 }

1105

1106 if (st->lpc_enh_enabled && SUBMODE(comb_gain) > 0 && !st->count_lost) {

1107 multicomb(st->exc - NB_SUBFRAME_SIZE, out, st->interp_qlpc, NB_ORDER,

1108 2 * NB_SUBFRAME_SIZE, best_pitch, 40, SUBMODE(comb_gain));

1109 multicomb(st->exc + NB_SUBFRAME_SIZE, out + 2 * NB_SUBFRAME_SIZE,

1110 st->interp_qlpc, NB_ORDER, 2 * NB_SUBFRAME_SIZE, best_pitch, 40,

1111 SUBMODE(comb_gain));

1112 } else {

1113 SPEEX_COPY(out, &st->exc[-NB_SUBFRAME_SIZE], NB_FRAME_SIZE);

1114 }

1115

1116 /* If the last packet was lost, re-scale the excitation to obtain the same

1117 * energy as encoded in ol_gain */

1118 if (st->count_lost) {

1119 float exc_ener, gain;

1120

1121 exc_ener = compute_rms(st->exc, NB_FRAME_SIZE);

1122 av_assert0(exc_ener + 1.f > 0.f);

1123 gain = fminf(ol_gain / (exc_ener + 1.f), 2.f);

1124 for (int i = 0; i < NB_FRAME_SIZE; i++) {

1125 st->exc[i] *= gain;

1126 out[i] = st->exc[i - NB_SUBFRAME_SIZE];

1127 }

1128 }

1129

1130 for (int sub = 0; sub < NB_NB_SUBFRAMES; sub++) { /* Loop on subframes */

1131 const int offset = NB_SUBFRAME_SIZE * sub; /* Offset relative to start of frame */

1132 float pi_g = 1.f, *sp = out + offset; /* Original signal */

1133

1134 lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, NB_ORDER, sub, NB_NB_SUBFRAMES, 0.002f);

1135 lsp_to_lpc(interp_qlsp, ak, NB_ORDER); /* Compute interpolated LPCs (unquantized) */

1136

1137 for (int i = 0; i < NB_ORDER; i += 2) /* Compute analysis filter at w=pi */

1138 pi_g += ak[i + 1] - ak[i];

1139 st->pi_gain[sub] = pi_g;

1140 st->exc_rms[sub] = compute_rms(st->exc + offset, NB_SUBFRAME_SIZE);

1141

1142 iir_mem(sp, st->interp_qlpc, sp, NB_SUBFRAME_SIZE, NB_ORDER, st->mem_sp);

1143

1144 memcpy(st->interp_qlpc, ak, sizeof(st->interp_qlpc));

1145 }

1146

1147 if (st->highpass_enabled)

1148 highpass(out, out, NB_FRAME_SIZE, st->mem_hp, st->is_wideband);

1149

1150 /* Store the LSPs for interpolation in the next frame */

1151 memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));

1152

1153 st->count_lost = 0;

1154 st->last_pitch = best_pitch;

1155 st->last_pitch_gain = .25f * pitch_average;

1156 st->last_ol_gain = ol_gain;

1157 st->first = 0;

1158

1159 return 0;

1160 }

1161

1162 static void qmf_synth(const float *x1, const float *x2, const float *a, float *y, int N, int M, float *mem1, float *mem2)

1163 {

1164 const int M2 = M >> 1, N2 = N >> 1;

1165 float xx1[352], xx2[352];

1166

1167 for (int i = 0; i < N2; i++)

1168 xx1[i] = x1[N2-1-i];

1169 for (int i = 0; i < M2; i++)

1170 xx1[N2+i] = mem1[2*i+1];

1171 for (int i = 0; i < N2; i++)

1172 xx2[i] = x2[N2-1-i];

1173 for (int i = 0; i < M2; i++)

1174 xx2[N2+i] = mem2[2*i+1];

1175

1176 for (int i = 0; i < N2; i += 2) {

1177 float y0, y1, y2, y3;

1178 float x10, x20;

1179

1180 y0 = y1 = y2 = y3 = 0.f;

1181 x10 = xx1[N2-2-i];

1182 x20 = xx2[N2-2-i];

1183

1184 for (int j = 0; j < M2; j += 2) {

1185 float x11, x21;

1186 float a0, a1;

1187

1188 a0 = a[2*j];

1189 a1 = a[2*j+1];

1190 x11 = xx1[N2-1+j-i];

1191 x21 = xx2[N2-1+j-i];

1192

1193 y0 += a0 * (x11-x21);

1194 y1 += a1 * (x11+x21);

1195 y2 += a0 * (x10-x20);

1196 y3 += a1 * (x10+x20);

1197 a0 = a[2*j+2];

1198 a1 = a[2*j+3];

1199 x10 = xx1[N2+j-i];

1200 x20 = xx2[N2+j-i];

1201

1202 y0 += a0 * (x10-x20);

1203 y1 += a1 * (x10+x20);

1204 y2 += a0 * (x11-x21);

1205 y3 += a1 * (x11+x21);

1206 }

1207 y[2 * i ] = 2.f * y0;

1208 y[2 * i+1] = 2.f * y1;

1209 y[2 * i+2] = 2.f * y2;

1210 y[2 * i+3] = 2.f * y3;

1211 }

1212

1213 for (int i = 0; i < M2; i++)

1214 mem1[2*i+1] = xx1[i];

1215 for (int i = 0; i < M2; i++)

1216 mem2[2*i+1] = xx2[i];

1217 }

1218

1219 static int sb_decode(AVCodecContext *avctx, void *ptr_st,

1220 GetBitContext *gb, float *out)

1221 {

1222 SpeexContext *s = avctx->priv_data;

1223 DecoderState *st = ptr_st;

1224 float low_pi_gain[NB_NB_SUBFRAMES];

1225 float low_exc_rms[NB_NB_SUBFRAMES];

1226 float interp_qlsp[NB_ORDER];

1227 int ret, wideband;

1228 float *low_innov_alias;

1229 float qlsp[NB_ORDER];

1230 float ak[NB_ORDER];

1231 const SpeexMode *mode;

1232

1233 mode = st->mode;

1234

1235 if (st->modeID > 0) {

1236 low_innov_alias = out + st->frame_size;

1237 s->st[st->modeID - 1].innov_save = low_innov_alias;

1238 ret = speex_modes[st->modeID - 1].decode(avctx, &s->st[st->modeID - 1], gb, out);

1239 if (ret < 0)

1240 return ret;

1241 }

1242

1243 if (st->encode_submode) { /* Check "wideband bit" */

1244 if (get_bits_left(gb) > 0)

1245 wideband = show_bits1(gb);

1246 else

1247 wideband = 0;

1248 if (wideband) { /* Regular wideband frame, read the submode */

1249 wideband = get_bits1(gb);

1250 st->submodeID = get_bits(gb, SB_SUBMODE_BITS);

1251 } else { /* Was a narrowband frame, set "null submode" */

1252 st->submodeID = 0;

1253 }

1254 if (st->submodeID != 0 && st->submodes[st->submodeID] == NULL)

1255 return AVERROR_INVALIDDATA;

1256 }

1257

1258 /* If null mode (no transmission), just set a couple things to zero */

1259 if (st->submodes[st->submodeID] == NULL) {

1260 for (int i = 0; i < st->frame_size; i++)

1261 out[st->frame_size + i] = 1e-15f;

1262

1263 st->first = 1;

1264

1265 /* Final signal synthesis from excitation */

1266 iir_mem(out + st->frame_size, st->interp_qlpc, out + st->frame_size, st->frame_size, st->lpc_size, st->mem_sp);

1267

1268 qmf_synth(out, out + st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem);

1269

1270 return 0;

1271 }

1272

1273 memcpy(low_pi_gain, s->st[st->modeID - 1].pi_gain, sizeof(low_pi_gain));

1274 memcpy(low_exc_rms, s->st[st->modeID - 1].exc_rms, sizeof(low_exc_rms));

1275

1276 SUBMODE(lsp_unquant)(qlsp, st->lpc_size, gb);

1277

1278 if (st->first)

1279 memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));

1280

1281 for (int sub = 0; sub < st->nb_subframes; sub++) {

1282 float filter_ratio, el, rl, rh;

1283 float *innov_save = NULL, *sp;

1284 float exc[80];

1285 int offset;

1286

1287 offset = st->subframe_size * sub;

1288 sp = out + st->frame_size + offset;

1289 /* Pointer for saving innovation */

1290 if (st->innov_save) {

1291 innov_save = st->innov_save + 2 * offset;

1292 SPEEX_MEMSET(innov_save, 0, 2 * st->subframe_size);

1293 }

1294

1295 av_assert0(st->nb_subframes > 0);

1296 lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, st->lpc_size, sub, st->nb_subframes, 0.05f);

1297 lsp_to_lpc(interp_qlsp, ak, st->lpc_size);

1298

1299 /* Calculate reponse ratio between the low and high filter in the middle

1300 of the band (4000 Hz) */

1301 st->pi_gain[sub] = 1.f;

1302 rh = 1.f;

1303 for (int i = 0; i < st->lpc_size; i += 2) {

1304 rh += ak[i + 1] - ak[i];

1305 st->pi_gain[sub] += ak[i] + ak[i + 1];

1306 }

1307

1308 rl = low_pi_gain[sub];

1309 filter_ratio = (rl + .01f) / (rh + .01f);

1310

1311 SPEEX_MEMSET(exc, 0, st->subframe_size);

1312 if (!SUBMODE(innovation_unquant)) {

1313 const int x = get_bits(gb, 5);

1314 const float g = expf(.125f * (x - 10)) / filter_ratio;

1315

1316 for (int i = 0; i < st->subframe_size; i += 2) {

1317 exc[i ] = mode->folding_gain * low_innov_alias[offset + i ] * g;

1318 exc[i + 1] = -mode->folding_gain * low_innov_alias[offset + i + 1] * g;

1319 }

1320 } else {

1321 float gc, scale;

1322

1323 el = low_exc_rms[sub];

1324 gc = 0.87360f * gc_quant_bound[get_bits(gb, 4)];

1325

1326 if (st->subframe_size == 80)

1327 gc *= M_SQRT2;

1328

1329 scale = (gc * el) / filter_ratio;

1330 SUBMODE(innovation_unquant)

1331 (exc, SUBMODE(innovation_params), st->subframe_size,

1332 gb, &st->seed);

1333

1334 signal_mul(exc, exc, scale, st->subframe_size);

1335 if (SUBMODE(double_codebook)) {

1336 float innov2[80];

1337

1338 SPEEX_MEMSET(innov2, 0, st->subframe_size);

1339 SUBMODE(innovation_unquant)(innov2, SUBMODE(innovation_params), st->subframe_size, gb, &st->seed);

1340 signal_mul(innov2, innov2, 0.4f * scale, st->subframe_size);

1341 for (int i = 0; i < st->subframe_size; i++)

1342 exc[i] += innov2[i];

1343 }

1344 }

1345

1346 if (st->innov_save) {

1347 for (int i = 0; i < st->subframe_size; i++)

1348 innov_save[2 * i] = exc[i];

1349 }

1350

1351 iir_mem(st->exc_buf, st->interp_qlpc, sp, st->subframe_size, st->lpc_size, st->mem_sp);

1352 memcpy(st->exc_buf, exc, sizeof(exc));

1353 memcpy(st->interp_qlpc, ak, sizeof(st->interp_qlpc));

1354 st->exc_rms[sub] = compute_rms(st->exc_buf, st->subframe_size);

1355 }

1356

1357 qmf_synth(out, out + st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem);

1358 memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));

1359

1360 st->first = 0;

1361

1362 return 0;

1363 }

1364

1365 static int decoder_init(SpeexContext *s, DecoderState *st, const SpeexMode *mode)

1366 {

1367 st->mode = mode;

1368 st->modeID = mode->modeID;

1369

1370 st->first = 1;

1371 st->encode_submode = 1;

1372 st->is_wideband = st->modeID > 0;

1373 st->innov_save = NULL;

1374

1375 st->submodes = mode->submodes;

1376 st->submodeID = mode->default_submode;

1377 st->subframe_size = mode->subframe_size;

1378 st->lpc_size = mode->lpc_size;

1379 st->full_frame_size = (1 + (st->modeID > 0)) * mode->frame_size;

1380 st->nb_subframes = mode->frame_size / mode->subframe_size;

1381 st->frame_size = mode->frame_size;

1382

1383 st->lpc_enh_enabled = 1;

1384

1385 st->last_pitch = 40;

1386 st->count_lost = 0;

1387 st->seed = 1000;

1388 st->last_ol_gain = 0;

1389

1390 st->voc_m1 = st->voc_m2 = st->voc_mean = 0;

1391 st->voc_offset = 0;

1392 st->dtx_enabled = 0;

1393 st->highpass_enabled = mode->modeID == 0;

1394

1395 return 0;

1396 }

1397

1398 static int parse_speex_extradata(AVCodecContext *avctx,

1399 const uint8_t *extradata, int extradata_size)

1400 {

1401 SpeexContext *s = avctx->priv_data;

1402 const uint8_t *buf = av_strnstr(extradata, "Speex ", extradata_size);

1403

1404 if (!buf)

1405 return AVERROR_INVALIDDATA;

1406

1407 buf += 28;

1408

1409 s->version_id = bytestream_get_le32(&buf);

1410 buf += 4;

1411 s->rate = bytestream_get_le32(&buf);

1412 if (s->rate <= 0)

1413 return AVERROR_INVALIDDATA;

1414 s->mode = bytestream_get_le32(&buf);

1415 if (s->mode < 0 || s->mode >= SPEEX_NB_MODES)

1416 return AVERROR_INVALIDDATA;

1417 s->bitstream_version = bytestream_get_le32(&buf);

1418 if (s->bitstream_version != 4)

1419 return AVERROR_INVALIDDATA;

1420 s->nb_channels = bytestream_get_le32(&buf);

1421 if (s->nb_channels <= 0 || s->nb_channels > 2)

1422 return AVERROR_INVALIDDATA;

1423 s->bitrate = bytestream_get_le32(&buf);

1424 s->frame_size = bytestream_get_le32(&buf);

1425 if (s->frame_size < NB_FRAME_SIZE << (s->mode > 0) ||

1426 s->frame_size > INT32_MAX >> (s->mode > 0))

1427 return AVERROR_INVALIDDATA;

1428 s->frame_size <<= (s->mode > 0);

1429 s->vbr = bytestream_get_le32(&buf);

1430 s->frames_per_packet = bytestream_get_le32(&buf);

1431 if (s->frames_per_packet <= 0 ||

1432 s->frames_per_packet > 64 ||

1433 s->frames_per_packet >= INT32_MAX / s->nb_channels / s->frame_size)

1434 return AVERROR_INVALIDDATA;

1435 s->extra_headers = bytestream_get_le32(&buf);

1436

1437 return 0;

1438 }

1439

1440 static av_cold int speex_decode_init(AVCodecContext *avctx)

1441 {

1442 SpeexContext *s = avctx->priv_data;

1443 int ret;

1444

1445 s->fdsp = avpriv_float_dsp_alloc(0);

1446 if (!s->fdsp)

1447 return AVERROR(ENOMEM);

1448

1449 if (avctx->extradata && avctx->extradata_size >= 80) {

1450 ret = parse_speex_extradata(avctx, avctx->extradata, avctx->extradata_size);

1451 if (ret < 0)

1452 return ret;

1453 } else {

1454 s->rate = avctx->sample_rate;

1455 if (s->rate <= 0)

1456 return AVERROR_INVALIDDATA;

1457

1458 s->nb_channels = avctx->ch_layout.nb_channels;

1459 if (s->nb_channels <= 0 || s->nb_channels > 2)

1460 return AVERROR_INVALIDDATA;

1461

1462 switch (s->rate) {

1463 case 8000: s->mode = 0; break;

1464 case 16000: s->mode = 1; break;

1465 case 32000: s->mode = 2; break;

1466 default: s->mode = 2;

1467 }

1468

1469 s->frames_per_packet = 64;

1470 s->frame_size = NB_FRAME_SIZE << s->mode;

1471 }

1472

1473 if (avctx->codec_tag == MKTAG('S', 'P', 'X', 'N')) {

1474 int quality;

1475

1476 if (!avctx->extradata || avctx->extradata && avctx->extradata_size < 47) {

1477 av_log(avctx, AV_LOG_ERROR, "Missing or invalid extradata.\n");

1478 return AVERROR_INVALIDDATA;

1479 }

1480

1481 quality = avctx->extradata[37];

1482 if (quality > 10) {

1483 av_log(avctx, AV_LOG_ERROR, "Unsupported quality mode %d.\n", quality);

1484 return AVERROR_PATCHWELCOME;

1485 }

1486

1487 s->pkt_size = ((const uint8_t[]){ 5, 10, 15, 20, 20, 28, 28, 38, 38, 46, 62 })[quality];

1488

1489 s->mode = 0;

1490 s->nb_channels = 1;

1491 s->rate = avctx->sample_rate;

1492 if (s->rate <= 0)

1493 return AVERROR_INVALIDDATA;

1494 s->frames_per_packet = 1;

1495 s->frame_size = NB_FRAME_SIZE;

1496 }

1497

1498 if (s->bitrate > 0)

1499 avctx->bit_rate = s->bitrate;

1500 av_channel_layout_uninit(&avctx->ch_layout);

1501 avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;

1502 avctx->ch_layout.nb_channels = s->nb_channels;

1503 avctx->sample_rate = s->rate;

1504 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

1505

1506 for (int m = 0; m <= s->mode; m++) {

1507 ret = decoder_init(s, &s->st[m], &speex_modes[m]);

1508 if (ret < 0)

1509 return ret;

1510 }

1511

1512 s->stereo.balance = 1.f;

1513 s->stereo.e_ratio = .5f;

1514 s->stereo.smooth_left = 1.f;

1515 s->stereo.smooth_right = 1.f;

1516

1517 return 0;

1518 }

1519

1520 static void speex_decode_stereo(float *data, int frame_size, StereoState *stereo)

1521 {

1522 float balance, e_left, e_right, e_ratio;

1523

1524 balance = stereo->balance;

1525 e_ratio = stereo->e_ratio;

1526

1527 /* These two are Q14, with max value just below 2. */

1528 e_right = 1.f / sqrtf(e_ratio * (1.f + balance));

1529 e_left = sqrtf(balance) * e_right;

1530

1531 for (int i = frame_size - 1; i >= 0; i--) {

1532 float tmp = data[i];

1533 stereo->smooth_left = stereo->smooth_left * 0.98f + e_left * 0.02f;

1534 stereo->smooth_right = stereo->smooth_right * 0.98f + e_right * 0.02f;

1535 data[2 * i ] = stereo->smooth_left * tmp;

1536 data[2 * i + 1] = stereo->smooth_right * tmp;

1537 }

1538 }

1539

1540 static int speex_decode_frame(AVCodecContext *avctx, AVFrame *frame,

1541 int *got_frame_ptr, AVPacket *avpkt)

1542 {

1543 SpeexContext *s = avctx->priv_data;

1544 int frames_per_packet = s->frames_per_packet;

1545 const float scale = 1.f / 32768.f;

1546 int buf_size = avpkt->size;

1547 float *dst;

1548 int ret;

1549

1550 if (s->pkt_size && avpkt->size == 62)

1551 buf_size = s->pkt_size;

1552 if ((ret = init_get_bits8(&s->gb, avpkt->data, buf_size)) < 0)

1553 return ret;

1554

1555 frame->nb_samples = FFALIGN(s->frame_size * frames_per_packet, 4);

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

1557 return ret;

1558

1559 dst = (float *)frame->extended_data[0];

1560 for (int i = 0; i < frames_per_packet; i++) {

1561 ret = speex_modes[s->mode].decode(avctx, &s->st[s->mode], &s->gb, dst + i * s->frame_size);

1562 if (ret < 0)

1563 return ret;

1564 if (avctx->ch_layout.nb_channels == 2)

1565 speex_decode_stereo(dst + i * s->frame_size, s->frame_size, &s->stereo);

1566 if (get_bits_left(&s->gb) < 5 ||

1567 show_bits(&s->gb, 5) == 15) {

1568 frames_per_packet = i + 1;

1569 break;

1570 }

1571 }

1572

1573 dst = (float *)frame->extended_data[0];

1574 s->fdsp->vector_fmul_scalar(dst, dst, scale, frame->nb_samples * frame->ch_layout.nb_channels);

1575 frame->nb_samples = s->frame_size * frames_per_packet;

1576

1577 *got_frame_ptr = 1;

1578

1579 return (get_bits_count(&s->gb) + 7) >> 3;

1580 }

1581

1582 static av_cold int speex_decode_close(AVCodecContext *avctx)

1583 {

1584 SpeexContext *s = avctx->priv_data;

1585 av_freep(&s->fdsp);

1586 return 0;

1587 }

1588

1589 const FFCodec ff_speex_decoder = {

1590 .p.name = "speex",

1591 CODEC_LONG_NAME("Speex"),

1592 .p.type = AVMEDIA_TYPE_AUDIO,

1593 .p.id = AV_CODEC_ID_SPEEX,

1594 .init = speex_decode_init,

1595 FF_CODEC_DECODE_CB(speex_decode_frame),

1596 .close = speex_decode_close,

1597 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

1598 .priv_data_size = sizeof(SpeexContext),

1599 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

1600 };

#define M(a, b)

Definition: vp3dsp.c:48

LtpParams::pitch_bits

int pitch_bits

Definition: speexdec.c:94

DecoderState::submodeID

int submodeID

Activated sub-mode.

Definition: speexdec.c:201

split_cb_high

static const SplitCodebookParams split_cb_high

Definition: speexdec.c:116

SB_SUBMODE_BITS

#define SB_SUBMODE_BITS

Definition: speexdec.c:73

nb_submode4

static const SpeexSubmode nb_submode4

Definition: speexdec.c:474

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:278

DecoderState::seed

uint32_t seed

Seed used for random number generation.

Definition: speexdec.c:197

static const float h0[64]

Definition: speexdata.h:741

SpeexSubmode::have_subframe_gain

int have_subframe_gain

Number of bits to use as sub-frame innovation gain.

Definition: speexdec.c:154

SplitCodebookParams::shape_bits

int shape_bits

Definition: speexdec.c:106

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:43

show_bits1

static unsigned int show_bits1(GetBitContext *s)

Definition: get_bits.h:408

QMF_ORDER

#define QMF_ORDER

Definition: speexdec.c:68

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

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

wb_submode2

static const SpeexSubmode wb_submode2

Definition: speexdec.c:508

hexc_10_32_table

static const int8_t hexc_10_32_table[320]

Definition: speexdata.h:694

nb_submode3

static const SpeexSubmode nb_submode3

Definition: speexdec.c:468

DecoderState::count_lost

int count_lost

Was the last frame lost?

Definition: speexdec.c:186

exc_gain_quant_scal1

static const float exc_gain_quant_scal1[2]

Definition: speexdata.h:778

out

FILE * out

Definition: movenc.c:55

speexdata.h

SpeexContext::vbr

int32_t vbr

1 for a VBR decoding, 0 otherwise

Definition: speexdec.c:251

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1056

DecoderState::exc_buf

float exc_buf[NB_DEC_BUFFER]

Excitation buffer.

Definition: speexdec.c:215

DecoderState::highpass_enabled

int highpass_enabled

Is the input filter enabled.

Definition: speexdec.c:211

DecoderState::dtx_enabled

int dtx_enabled

Definition: speexdec.c:210

DecoderState::mode

const SpeexMode * mode

Definition: speexdec.c:181

hexc_table

static const int8_t hexc_table[1024]

Definition: speexdata.h:612

ltp_quant_func

int(* ltp_quant_func)(float *, float *, float *, float *, float *, float *, const void *, int, int, float, int, int, GetBitContext *, char *, float *, float *, int, int, int, float *)

Long-term predictor quantization.

Definition: speexdec.c:126

DecoderState::mem_hp

float mem_hp[2]

High-pass filter memory.

Definition: speexdec.c:214

DecoderState::voc_m1

float voc_m1

Definition: speexdec.c:205

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:266

exc_8_128_table

static const int8_t exc_8_128_table[1024]

Definition: speexdata.h:295

LSP_DIV_1024

#define LSP_DIV_1024(x)

Definition: speexdec.c:89

SpeexContext::version_id

int32_t version_id

Version for Speex (for checking compatibility)

Definition: speexdec.c:244

cdbk_nb_high1

static const int8_t cdbk_nb_high1[320]

Definition: speexdata.h:562

SpeexMode::modeID

int modeID

ID of the mode.

Definition: speexdec.c:170

DecoderState::lpc_enh_enabled

int lpc_enh_enabled

1 when LPC enhancer is on, 0 otherwise

Definition: speexdec.c:202

AVFrame

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

Definition: frame.h:389

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

AVPacket::data

uint8_t * data

Definition: packet.h:539

LtpParams

Definition: speexdec.c:91

data

const char data[16]

Definition: mxf.c:148

DecoderState::exc

float * exc

Start of excitation frame.

Definition: speexdec.c:213

expf

#define expf(x)

Definition: libm.h:283

FFCodec

Definition: codec_internal.h:127

LSP_DIV_512

#define LSP_DIV_512(x)

Definition: speexdec.c:88

AVChannelLayout::order

enum AVChannelOrder order

Channel order used in this layout.

Definition: channel_layout.h:316

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

#define N2

Definition: vf_pp7.c:74

SpeexMode::lpc_size

int lpc_size

Order of LPC filter.

Definition: speexdec.c:174

static const uint64_t c1

Definition: murmur3.c:52

nb_submode8

static const SpeexSubmode nb_submode8

Definition: speexdec.c:498

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

SpeexSubmode::double_codebook

int double_codebook

Apply innovation quantization twice for higher quality (and higher bit-rate)

Definition: speexdec.c:156

speex_inband_handler

static int speex_inband_handler(GetBitContext *gb, void *state, StereoState *stereo)

Definition: speexdec.c:631

DecoderState::first

int first

Is first frame

Definition: speexdec.c:183

gain_3tap_to_1tap

#define gain_3tap_to_1tap(g)

Definition: speexdec.c:352

quality

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality

Definition: rate_distortion.txt:12

wb_submode4

static const SpeexSubmode wb_submode4

Definition: speexdec.c:518

SpeexSubmode

Definition: speexdec.c:148

SpeexMode::subframe_size

int subframe_size

Size of sub-frames used for decoding.

Definition: speexdec.c:173

SpeexSubmode::LtpParam

const void * LtpParam

Pitch parameters (options)

Definition: speexdec.c:161

LSP_DIV_256

#define LSP_DIV_256(x)

Definition: speexdec.c:87

SpeexContext::pkt_size

int pkt_size

Definition: speexdec.c:255

SpeexContext::nb_channels

int32_t nb_channels

Number of channels decoded.

Definition: speexdec.c:248

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

exc_5_256_table

static const int8_t exc_5_256_table[1280]

Definition: speexdata.h:137

AV_CODEC_ID_SPEEX

@ AV_CODEC_ID_SPEEX

Definition: codec_id.h:475

LSP_LINEAR_HIGH

#define LSP_LINEAR_HIGH(i)

Definition: speexdec.c:86

cosf

#define cosf(x)

Definition: libm.h:78

interp

Definition: vf_curves.c:62

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

speex_default_user_handler

static int speex_default_user_handler(GetBitContext *gb, void *state, void *data)

Definition: speexdec.c:226

av_int2float

static av_always_inline float av_int2float(uint32_t i)

Reinterpret a 32-bit integer as a float.

Definition: intfloat.h:40

SpeexSubmode::ltp_unquant

ltp_unquant_func ltp_unquant

Long-term predictor (pitch) un-quantizer.

Definition: speexdec.c:160

GetBitContext

Definition: get_bits.h:108

innovation_quant_func

void(* innovation_quant_func)(float *, float *, float *, float *, const void *, int, int, float *, float *, GetBitContext *, char *, int, int)

Innovation quantization function.

Definition: speexdec.c:139

DecoderState

Definition: speexdec.c:180

split_cb_nb_lbr

static const SplitCodebookParams split_cb_nb_lbr

Definition: speexdec.c:112

DecoderState::nb_subframes

int nb_subframes

Number of high-band sub-frames.

Definition: speexdec.c:189

fabsf

static __device__ float fabsf(float a)

Definition: cuda_runtime.h:181

wb_submode3

static const SpeexSubmode wb_submode3

Definition: speexdec.c:513

SpeexContext::bitrate

int32_t bitrate

Bit-rate used.

Definition: speexdec.c:249

e_ratio_quant

static const float e_ratio_quant[4]

Definition: speexdata.h:766

ff_speex_decoder

const FFCodec ff_speex_decoder

Definition: speexdec.c:1589

split_cb_nb_ulbr

static const SplitCodebookParams split_cb_nb_ulbr

Definition: speexdec.c:110

NB_PITCH_START

#define NB_PITCH_START

Definition: speexdec.c:77

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

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

StereoState::balance

float balance

Left/right balance info.

Definition: speexdec.c:234

lsp_interpolate

static void lsp_interpolate(const float *old_lsp, const float *new_lsp, float *lsp, int len, int subframe, int nb_subframes, float margin)

Definition: speexdec.c:807

float

Definition: af_crystalizer.c:122

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

#define s(width, name)

Definition: cbs_vp9.c:198

split_cb_sb

static const SplitCodebookParams split_cb_sb

Definition: speexdec.c:115

nb_decode

static int nb_decode(AVCodecContext *, void *, GetBitContext *, float *)

Definition: speexdec.c:868

const char * g

Definition: vf_curves.c:128

frame_size

int frame_size

Definition: mxfenc.c:2424

speex_std_stereo

static int speex_std_stereo(GetBitContext *gb, void *state, void *data)

Definition: speexdec.c:620

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CHANNEL_ORDER_UNSPEC

@ AV_CHANNEL_ORDER_UNSPEC

Only the channel count is specified, without any further information about the channel order.

Definition: channel_layout.h:116

gain_cdbk_lbr

static const int8_t gain_cdbk_lbr[128]

Definition: speexdata.h:406

fminf

float fminf(float, float)

NB_SUBFRAME_SIZE

#define NB_SUBFRAME_SIZE

Definition: speexdec.c:75

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

nb_submode7

static const SpeexSubmode nb_submode7

Definition: speexdec.c:492

decode.h

speex_rand

static float speex_rand(float std, uint32_t *seed)

Definition: speexdec.c:299

get_bits.h

cdbk_nb_low2

static const int8_t cdbk_nb_low2[320]

Definition: speexdata.h:537

speex_modes

static const SpeexMode speex_modes[SPEEX_NB_MODES]

Definition: speexdec.c:526

DecoderState::encode_submode

int encode_submode

Definition: speexdec.c:199

NB_FRAME_SIZE

#define NB_FRAME_SIZE

Definition: speexdec.c:70

StereoState

Definition: speexdec.c:233

DecoderState::modeID

int modeID

ID of the decoder mode.

Definition: speexdec.c:182

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

SUBMODE

#define SUBMODE(x)

Definition: speexdec.c:350

nb_submode6

static const SpeexSubmode nb_submode6

Definition: speexdec.c:486

SpeexSubmode::innovation_unquant

innovation_unquant_func innovation_unquant

Innovation un-quantization.

Definition: speexdec.c:163

FFABS

#define FFABS(a)

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

Definition: common.h:74

DecoderState::mem_sp

float mem_sp[NB_ORDER]

Filter memory for synthesis signal.

Definition: speexdec.c:218

SPEEX_MEMSET

#define SPEEX_MEMSET(dst, c, n)

Definition: speexdec.c:82

lsp_to_lpc

static void lsp_to_lpc(const float *freq, float *ak, int lpcrdr)

Definition: speexdec.c:824

speex_decode_frame

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

Definition: speexdec.c:1540

nb_submode1

static const SpeexSubmode nb_submode1

Definition: speexdec.c:456

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

SpeexContext::frames_per_packet

int32_t frames_per_packet

Number of frames stored per Ogg packet.

Definition: speexdec.c:252

NB_SUBMODES

#define NB_SUBMODES

Definition: speexdec.c:71

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

DecoderState::lpc_size

int lpc_size

Order of high-band LPC analysis.

Definition: speexdec.c:190

isnan

#define isnan(x)

Definition: libm.h:340

SpeexMode::default_submode

int default_submode

Default sub-mode to use when decoding.

Definition: speexdec.c:177

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:501

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

DecoderState::exc_rms

float exc_rms[NB_NB_SUBFRAMES]

RMS of excitation per subframe.

Definition: speexdec.c:222

split_cb_nb

static const SplitCodebookParams split_cb_nb

Definition: speexdec.c:114

sqrtf

static __device__ float sqrtf(float a)

Definition: cuda_runtime.h:184

SpeexContext::bitstream_version

int32_t bitstream_version

Version ID of the bit-stream.

Definition: speexdec.c:247

LtpParams::gain_bits

int gain_bits

Definition: speexdec.c:93

exc_10_32_table

static const int8_t exc_10_32_table[320]

Definition: speexdata.h:367

av_clipf

Definition: af_crystalizer.c:122

SpeexContext::extra_headers

int32_t extra_headers

Number of additional headers after the comments.

Definition: speexdec.c:253

ltp_params_nb

static const LtpParam ltp_params_nb

Definition: speexdec.c:100

exp

int8_t exp

Definition: eval.c:73

seed

static unsigned int seed

Definition: videogen.c:78

wb_skip_table

static const uint16_t wb_skip_table[8]

Definition: speexdata.h:765

DecoderState::voc_offset

int voc_offset

Definition: speexdec.c:208

float_dsp.h

SpeexSubmode::comb_gain

float comb_gain

Gain of enhancer comb filter.

Definition: speexdec.c:166

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

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

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

LtpParams::gain_cdbk

const int8_t * gain_cdbk

Definition: speexdec.c:92

lsp_unquant_nb

static void lsp_unquant_nb(float *lsp, int order, GetBitContext *gb)

Definition: speexdec.c:411

exc_5_64_table

static const int8_t exc_5_64_table[320]

Definition: speexdata.h:232

codec_internal.h

SpeexContext::fdsp

AVFloatDSPContext * fdsp

Definition: speexdec.c:260

ltp_params_lbr

static const LtpParam ltp_params_lbr

Definition: speexdec.c:98

dst

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

Definition: dsp.h:83

ltp_params_med

static const LtpParam ltp_params_med

Definition: speexdec.c:99

sanitize_values

static void sanitize_values(float *vec, float min_val, float max_val, int len)

Definition: speexdec.c:657

SpeexMode::folding_gain

float folding_gain

Folding gain.

Definition: speexdec.c:175

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

ltp_unquant_func

void(* ltp_unquant_func)(float *, float *, int, int, float, const void *, int, int *, float *, GetBitContext *, int, int, float, int)

Long-term un-quantize.

Definition: speexdec.c:133

NB_PITCH_END

#define NB_PITCH_END

Definition: speexdec.c:78

fmaxf

float fmaxf(float, float)

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1063

DecoderState::submodes

const SpeexSubmode *const * submodes

Sub-mode data.

Definition: speexdec.c:200

LSP_LINEAR

#define LSP_LINEAR(i)

Definition: speexdec.c:85

signal_mul

static void signal_mul(const float *x, float *y, float scale, int len)

Definition: speexdec.c:667

DecoderState::old_qlsp

float old_qlsp[NB_ORDER]

Quantized LSPs for previous frame.

Definition: speexdec.c:216

DecoderState::frame_size

int frame_size

Length of high-band frames.

Definition: speexdec.c:187

SpeexContext

Definition: speexdec.c:240

AVFloatDSPContext

Definition: float_dsp.h:24

noise_codebook_unquant

static void noise_codebook_unquant(float *exc, const void *par, int nsf, GetBitContext *gb, uint32_t *seed)

Definition: speexdec.c:313

pitch_unquant_3tap

static void pitch_unquant_3tap(float *exc, float *exc_out, int start, int end, float pitch_coef, const void *par, int nsf, int *pitch_val, float *gain_val, GetBitContext *gb, int count_lost, int subframe_offset, float last_pitch_gain, int cdbk_offset)

Definition: speexdec.c:355

gain_cdbk_nb

static const int8_t gain_cdbk_nb[512]

Definition: speexdata.h:257

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

static double a0(void *priv, double x, double y)

Definition: vf_xfade.c:2028

SpeexMode::frame_size

int frame_size

Size of frames used for decoding.

Definition: speexdec.c:172

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

cdbk_nb_high2

static const int8_t cdbk_nb_high2[320]

Definition: speexdata.h:587

#define N

Definition: af_mcompand.c:54

fact

static double fact(double i)

Definition: af_aiir.c:935

SPEEX_COPY

#define SPEEX_COPY(dst, src, n)

Definition: speexdec.c:83

M_PI

#define M_PI

Definition: mathematics.h:67

DecoderState::subframe_size

int subframe_size

Length of high-band sub-frames.

Definition: speexdec.c:188

SpeexSubmode::innovation_params

const void * innovation_params

Innovation quantization parameters.

Definition: speexdec.c:164

ran

static uint32_t ran(void)

Definition: trasher.c:28

exc_20_32_table

static const int8_t exc_20_32_table[640]

Definition: speexdata.h:417

shift_filt

static const float shift_filt[3][7]

Definition: speexdata.h:719

multicomb

static void multicomb(const float *exc, float *new_exc, float *ak, int p, int nsf, int pitch, int max_pitch, float comb_gain)

Definition: speexdec.c:740

SplitCodebookParams::shape_cb

const signed char * shape_cb

Definition: speexdec.c:105

lsp_quant_func

void(* lsp_quant_func)(float *, float *, int, GetBitContext *)

Quantizes LSPs.

Definition: speexdec.c:120

lsp_unquant_lbr

static void lsp_unquant_lbr(float *lsp, int order, GetBitContext *gb)

Definition: speexdec.c:263

split_cb_nb_med

static const SplitCodebookParams split_cb_nb_med

Definition: speexdec.c:113

forced_pitch_unquant

static void forced_pitch_unquant(float *exc, float *exc_out, int start, int end, float pitch_coef, const void *par, int nsf, int *pitch_val, float *gain_val, GetBitContext *gb, int count_lost, int subframe_offset, float last_pitch_gain, int cdbk_offset)

Definition: speexdec.c:283

nb_submode5

static const SpeexSubmode nb_submode5

Definition: speexdec.c:480

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

Definition: cbs_h2645.c:256

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:371

DecoderState::interp_qlpc

float interp_qlpc[NB_ORDER]

Interpolated quantized LPCs.

Definition: speexdec.c:217

lsp_unquant_func

void(* lsp_unquant_func)(float *, int, GetBitContext *)

Decodes quantized LSPs.

Definition: speexdec.c:123

iir_mem

static void iir_mem(const float *x, const float *den, float *y, int N, int ord, float *mem)

Definition: speexdec.c:587

DecoderState::full_frame_size

int full_frame_size

Length of full-band frames.

Definition: speexdec.c:184

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

DecoderState::voc_m2

float voc_m2

Definition: speexdec.c:206

len

int len

Definition: vorbis_enc_data.h:426

inner_prod

static float inner_prod(const float *x, const float *y, int len)

Definition: speexdec.c:673

cdbk_nb

static const int8_t cdbk_nb[640]

Definition: speexdata.h:463

avcodec.h

decoder_init

static int decoder_init(SpeexContext *s, DecoderState *st, const SpeexMode *mode)

Definition: speexdec.c:1365

SPEEX_INBAND_STEREO

#define SPEEX_INBAND_STEREO

Definition: speexdec.c:66

SpeexContext::gb

GetBitContext gb

Definition: speexdec.c:242

parse_speex_extradata

static int parse_speex_extradata(AVCodecContext *avctx, const uint8_t *extradata, int extradata_size)

Definition: speexdec.c:1398

ret

Definition: filter_design.txt:187

SplitCodebookParams::subvect_size

int subvect_size

Definition: speexdec.c:103

SpeexSubmode::lsp_unquant

lsp_unquant_func lsp_unquant

LSP unquantization function.

Definition: speexdec.c:158

split_cb_nb_vlbr

static const SplitCodebookParams split_cb_nb_vlbr

Definition: speexdec.c:111

SpeexMode::decode

int(* decode)(AVCodecContext *avctx, void *dec, GetBitContext *gb, float *out)

Definition: speexdec.c:171

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

av_strnstr

char * av_strnstr(const char *haystack, const char *needle, size_t hay_length)

Locate the first occurrence of the string needle in the string haystack where not more than hay_lengt...

Definition: avstring.c:71

StereoState::smooth_right

float smooth_right

Smoothed right channel gain.

Definition: speexdec.c:237

enum AVCodecID id

Definition: dts2pts.c:367

gc_quant_bound

static const float gc_quant_bound[16]

Definition: speexdata.h:760

DecoderState::last_pitch

int last_pitch

Pitch of last correctly decoded frame.

Definition: speexdec.c:195

StereoState::smooth_left

float smooth_left

Smoothed left channel gain.

Definition: speexdec.c:236

AVCodecContext

main external API structure.

Definition: avcodec.h:451

static const uint64_t c2

Definition: murmur3.c:53

SpeexMode::submodes

const SpeexSubmode * submodes[NB_SUBMODES]

Sub-mode data for the mode.

Definition: speexdec.c:176

DecoderState::last_ol_gain

float last_ol_gain

Open-loop gain for previous frame.

Definition: speexdec.c:191

cdbk_nb_low1

static const int8_t cdbk_nb_low1[320]

Definition: speexdata.h:512

mode

Definition: ebur128.h:83

DecoderState::voc_mean

float voc_mean

Definition: speexdec.c:207

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

NB_NB_SUBFRAMES

#define NB_NB_SUBFRAMES

Definition: speexdec.c:76

DecoderState::is_wideband

int is_wideband

If wideband is present.

Definition: speexdec.c:185

speex_decode_close

static av_cold int speex_decode_close(AVCodecContext *avctx)

Definition: speexdec.c:1582

SpeexContext::stereo

StereoState stereo

Definition: speexdec.c:257

DecoderState::g0_mem

float g0_mem[QMF_ORDER]

Definition: speexdec.c:219

mem.h

get_bitsz

static av_always_inline int get_bitsz(GetBitContext *s, int n)

Read 0-25 bits.

Definition: get_bits.h:351

high_lsp_cdbk2

static const int8_t high_lsp_cdbk2[512]

Definition: speexdata.h:99

SpeexContext::mode

int32_t mode

Mode used (0 for narrowband, 1 for wideband)

Definition: speexdec.c:246

M_SQRT2

#define M_SQRT2

Definition: mathematics.h:109

SpeexContext::st

DecoderState st[SPEEX_NB_MODES]

Definition: speexdec.c:258

nb_submode2

static const SpeexSubmode nb_submode2

Definition: speexdec.c:462

ltp_params_vlbr

static const LtpParam ltp_params_vlbr

Definition: speexdec.c:97

SpeexSubmode::forced_pitch_gain

int forced_pitch_gain

Use the same (forced) pitch gain for all sub-frames.

Definition: speexdec.c:152

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:476

scale

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

Definition: intra.c:291

wb_submode1

static const SpeexSubmode wb_submode1

Definition: speexdec.c:503

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

state

static struct @454 state

highpass

static void highpass(const float *x, float *y, int len, float *mem, int wide)

Definition: speexdec.c:600

NB_ORDER

#define NB_ORDER

Definition: speexdec.c:69

AVPacket

This structure stores compressed data.

Definition: packet.h:516

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:478

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

avpriv_float_dsp_alloc

av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)

Allocate a float DSP context.

Definition: float_dsp.c:146

DecoderState::g1_mem

float g1_mem[QMF_ORDER]

Definition: speexdec.c:220

speex_decode_stereo

static void speex_decode_stereo(float *data, int frame_size, StereoState *stereo)

Definition: speexdec.c:1520

int32_t

Definition: audioconvert.c:56

bytestream.h

innovation_unquant_func

void(* innovation_unquant_func)(float *, const void *, int, GetBitContext *, uint32_t *)

Innovation unquantization function.

Definition: speexdec.c:145

SpeexSubmode::lbr_pitch

int lbr_pitch

Set to -1 for "normal" modes, otherwise encode pitch using a global pitch and allowing a +- lbr_pitch...

Definition: speexdec.c:149

speex_decode_init

static av_cold int speex_decode_init(AVCodecContext *avctx)

Definition: speexdec.c:1440

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

SpeexContext::frame_size

int32_t frame_size

Size of frames.

Definition: speexdec.c:250

lsp_unquant_high

static void lsp_unquant_high(float *lsp, int order, GetBitContext *gb)

Definition: speexdec.c:439

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

exc_10_16_table

static const int8_t exc_10_16_table[160]

Definition: speexdata.h:392

qmf_synth

static void qmf_synth(const float *x1, const float *x2, const float *a, float *y, int N, int M, float *mem1, float *mem2)

Definition: speexdec.c:1162

exc_gain_quant_scal3

static const float exc_gain_quant_scal3[8]

Definition: speexdata.h:774

static double a1(void *priv, double x, double y)

Definition: vf_xfade.c:2029

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

DecoderState::last_pitch_gain

float last_pitch_gain

Pitch gain of last correctly decoded frame.

Definition: speexdec.c:196

avstring.h

split_cb_high_lbr

static const SplitCodebookParams split_cb_high_lbr

Definition: speexdec.c:117

SplitCodebookParams

Definition: speexdec.c:102

SplitCodebookParams::have_sign

int have_sign

Definition: speexdec.c:107

DecoderState::pi_gain

float pi_gain[NB_NB_SUBFRAMES]

Gain of LPC filter at theta=pi (fe/2)

Definition: speexdec.c:221

SpeexContext::rate

int32_t rate

Sampling rate used.

Definition: speexdec.c:245

bw_lpc

static void bw_lpc(float gamma, const float *lpc_in, float *lpc_out, int order)

Definition: speexdec.c:576

interp_pitch

static int interp_pitch(const float *exc, float *interp, int pitch, int len)

Definition: speexdec.c:693

AV_SAMPLE_FMT_FLT

@ AV_SAMPLE_FMT_FLT

float

Definition: samplefmt.h:60

compute_rms

static float compute_rms(const float *x, int len)

Definition: speexdec.c:565

NB_DEC_BUFFER

#define NB_DEC_BUFFER

Definition: speexdec.c:80

sb_decode

static int sb_decode(AVCodecContext *, void *, GetBitContext *, float *)

Definition: speexdec.c:1219

DecoderState::innov_save

float * innov_save

If non-NULL, innovation is copied here.

Definition: speexdec.c:192

SplitCodebookParams::nb_subvect

int nb_subvect

Definition: speexdec.c:104

StereoState::e_ratio

float e_ratio

Ratio of energies: E(left+right)/[E(left)+E(right)]

Definition: speexdec.c:235

SpeexMode

Definition: speexdec.c:169

split_cb_shape_sign_unquant

static void split_cb_shape_sign_unquant(float *exc, const void *par, int nsf, GetBitContext *gb, uint32_t *seed)

Definition: speexdec.c:320

high_lsp_cdbk

static const int8_t high_lsp_cdbk[512]

Definition: speexdata.h:59

SPEEX_NB_MODES

#define SPEEX_NB_MODES

Definition: speexdec.c:65

Generated on Fri Aug 22 2025 13:58:51 for FFmpeg by doxygen 1.8.17