FFmpeg: libavcodec/sipr.c Source File

FFmpeg

[フレーム]

libavcodec

sipr.c

Go to the documentation of this file.

1 /*

2 * SIPR / ACELP.NET decoder

3 *

6 *

7 * This file is part of FFmpeg.

8 *

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

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

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

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

13 *

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

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

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

17 * Lesser General Public License for more details.

18 *

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

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

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

22 */

24 #include <math.h>

25 #include <stdint.h>

26 #include <string.h>

28 #include "libavutil/channel_layout.h"

29 #include "libavutil/float_dsp.h"

30 #include "libavutil/mathematics.h"

32 #define BITSTREAM_READER_LE

33 #include "avcodec.h"

34 #include "codec_internal.h"

35 #include "decode.h"

36 #include "get_bits.h"

37 #include "lsp.h"

38 #include "acelp_vectors.h"

39 #include "acelp_pitch_delay.h"

40 #include "acelp_filters.h"

41 #include "celp_filters.h"

43 #define MAX_SUBFRAME_COUNT 5

45 #include "sipr.h"

46 #include "siprdata.h"

48 typedef struct SiprModeParam {

49 const char *mode_name;

50 uint16_t bits_per_frame;

51 uint8_t subframe_count;

52 uint8_t frames_per_packet;

53 float pitch_sharp_factor;

55 /* bitstream parameters */

56 uint8_t number_of_fc_indexes;

57 uint8_t ma_predictor_bits; ///< size in bits of the switched MA predictor

59 /** size in bits of the i-th stage vector of quantizer */

60 uint8_t vq_indexes_bits[5];

62 /** size in bits of the adaptive-codebook index for every subframe */

63 uint8_t pitch_delay_bits[5];

65 uint8_t gp_index_bits;

66 uint8_t fc_index_bits[10]; ///< size in bits of the fixed codebook indexes

67 uint8_t gc_index_bits; ///< size in bits of the gain codebook indexes

68 } SiprModeParam;

70 static const SiprModeParam modes[MODE_COUNT] = {

71 [MODE_16k] = {

72 .mode_name = "16k",

73 .bits_per_frame = 160,

74 .subframe_count = SUBFRAME_COUNT_16k,

75 .frames_per_packet = 1,

76 .pitch_sharp_factor = 0.00,

78 .number_of_fc_indexes = 10,

79 .ma_predictor_bits = 1,

80 .vq_indexes_bits = {7, 8, 7, 7, 7},

81 .pitch_delay_bits = {9, 6},

82 .gp_index_bits = 4,

83 .fc_index_bits = {4, 5, 4, 5, 4, 5, 4, 5, 4, 5},

84 .gc_index_bits = 5

85 },

87 [MODE_8k5] = {

88 .mode_name = "8k5",

89 .bits_per_frame = 152,

90 .subframe_count = 3,

91 .frames_per_packet = 1,

92 .pitch_sharp_factor = 0.8,

94 .number_of_fc_indexes = 3,

95 .ma_predictor_bits = 0,

96 .vq_indexes_bits = {6, 7, 7, 7, 5},

97 .pitch_delay_bits = {8, 5, 5},

98 .gp_index_bits = 0,

99 .fc_index_bits = {9, 9, 9},

100 .gc_index_bits = 7

101 },

102

103 [MODE_6k5] = {

104 .mode_name = "6k5",

105 .bits_per_frame = 232,

106 .subframe_count = 3,

107 .frames_per_packet = 2,

108 .pitch_sharp_factor = 0.8,

109

110 .number_of_fc_indexes = 3,

111 .ma_predictor_bits = 0,

112 .vq_indexes_bits = {6, 7, 7, 7, 5},

113 .pitch_delay_bits = {8, 5, 5},

114 .gp_index_bits = 0,

115 .fc_index_bits = {5, 5, 5},

116 .gc_index_bits = 7

117 },

118

119 [MODE_5k0] = {

120 .mode_name = "5k0",

121 .bits_per_frame = 296,

122 .subframe_count = 5,

123 .frames_per_packet = 2,

124 .pitch_sharp_factor = 0.85,

125

126 .number_of_fc_indexes = 1,

127 .ma_predictor_bits = 0,

128 .vq_indexes_bits = {6, 7, 7, 7, 5},

129 .pitch_delay_bits = {8, 5, 8, 5, 5},

130 .gp_index_bits = 0,

131 .fc_index_bits = {10},

132 .gc_index_bits = 7

133 }

134 };

135

136 const float ff_pow_0_5[] = {

137 1.0/(1 << 1), 1.0/(1 << 2), 1.0/(1 << 3), 1.0/(1 << 4),

138 1.0/(1 << 5), 1.0/(1 << 6), 1.0/(1 << 7), 1.0/(1 << 8),

139 1.0/(1 << 9), 1.0/(1 << 10), 1.0/(1 << 11), 1.0/(1 << 12),

140 1.0/(1 << 13), 1.0/(1 << 14), 1.0/(1 << 15), 1.0/(1 << 16)

141 };

142

143 static void dequant(float *out, const int *idx, const float * const cbs[])

144 {

145 int i;

146 int stride = 2;

147 int num_vec = 5;

148

149 for (i = 0; i < num_vec; i++)

150 memcpy(out + stride*i, cbs[i] + stride*idx[i], stride*sizeof(float));

151

152 }

153

154 static void lsf_decode_fp(float *lsfnew, float *lsf_history,

155 const SiprParameters *parm)

156 {

157 int i;

158 float lsf_tmp[LP_FILTER_ORDER];

159

160 dequant(lsf_tmp, parm->vq_indexes, lsf_codebooks);

161

162 for (i = 0; i < LP_FILTER_ORDER; i++)

163 lsfnew[i] = lsf_history[i] * 0.33 + lsf_tmp[i] + mean_lsf[i];

164

165 ff_sort_nearly_sorted_floats(lsfnew, LP_FILTER_ORDER - 1);

166

167 /* Note that a minimum distance is not enforced between the last value and

168 the previous one, contrary to what is done in ff_acelp_reorder_lsf() */

169 ff_set_min_dist_lsf(lsfnew, LSFQ_DIFF_MIN, LP_FILTER_ORDER - 1);

170 lsfnew[9] = FFMIN(lsfnew[LP_FILTER_ORDER - 1], 1.3 * M_PI);

171

172 memcpy(lsf_history, lsf_tmp, LP_FILTER_ORDER * sizeof(*lsf_history));

173

174 for (i = 0; i < LP_FILTER_ORDER - 1; i++)

175 lsfnew[i] = cos(lsfnew[i]);

176 lsfnew[LP_FILTER_ORDER - 1] *= 6.153848 / M_PI;

177 }

178

179 /** Apply pitch lag to the fixed vector (AMR section 6.1.2). */

180 static void pitch_sharpening(int pitch_lag_int, float beta,

181 float *fixed_vector)

182 {

183 int i;

184

185 for (i = pitch_lag_int; i < SUBFR_SIZE; i++)

186 fixed_vector[i] += beta * fixed_vector[i - pitch_lag_int];

187 }

188

189 /**

190 * Extract decoding parameters from the input bitstream.

191 * @param parms parameters structure

192 * @param pgb pointer to initialized GetBitContext structure

193 */

194 static void decode_parameters(SiprParameters* parms, GetBitContext *pgb,

195 const SiprModeParam *p)

196 {

197 int i, j;

198

199 if (p->ma_predictor_bits)

200 parms->ma_pred_switch = get_bits(pgb, p->ma_predictor_bits);

201

202 for (i = 0; i < 5; i++)

203 parms->vq_indexes[i] = get_bits(pgb, p->vq_indexes_bits[i]);

204

205 for (i = 0; i < p->subframe_count; i++) {

206 parms->pitch_delay[i] = get_bits(pgb, p->pitch_delay_bits[i]);

207 if (p->gp_index_bits)

208 parms->gp_index[i] = get_bits(pgb, p->gp_index_bits);

209

210 for (j = 0; j < p->number_of_fc_indexes; j++)

211 parms->fc_indexes[i][j] = get_bits(pgb, p->fc_index_bits[j]);

212

213 parms->gc_index[i] = get_bits(pgb, p->gc_index_bits);

214 }

215 }

216

217 static void sipr_decode_lp(float *lsfnew, const float *lsfold, float *Az,

218 int num_subfr)

219 {

220 double lsfint[LP_FILTER_ORDER];

221 int i,j;

222 float t, t0 = 1.0 / num_subfr;

223

224 t = t0 * 0.5;

225 for (i = 0; i < num_subfr; i++) {

226 for (j = 0; j < LP_FILTER_ORDER; j++)

227 lsfint[j] = lsfold[j] * (1 - t) + t * lsfnew[j];

228

229 ff_amrwb_lsp2lpc(lsfint, Az, LP_FILTER_ORDER);

230 Az += LP_FILTER_ORDER;

231 t += t0;

232 }

233 }

234

235 /**

236 * Evaluate the adaptive impulse response.

237 */

238 static void eval_ir(const float *Az, int pitch_lag, float *freq,

239 float pitch_sharp_factor)

240 {

241 float tmp1[SUBFR_SIZE+1], tmp2[LP_FILTER_ORDER+1];

242 int i;

243

244 tmp1[0] = 1.0;

245 for (i = 0; i < LP_FILTER_ORDER; i++) {

246 tmp1[i+1] = Az[i] * ff_pow_0_55[i];

247 tmp2[i ] = Az[i] * ff_pow_0_7 [i];

248 }

249 memset(tmp1 + 11, 0, 37 * sizeof(float));

250

251 ff_celp_lp_synthesis_filterf(freq, tmp2, tmp1, SUBFR_SIZE,

252 LP_FILTER_ORDER);

253

254 pitch_sharpening(pitch_lag, pitch_sharp_factor, freq);

255 }

256

257 /**

258 * Evaluate the convolution of a vector with a sparse vector.

259 */

260 static void convolute_with_sparse(float *out, const AMRFixed *pulses,

261 const float *shape, int length)

262 {

263 int i, j;

264

265 memset(out, 0, length*sizeof(float));

266 for (i = 0; i < pulses->n; i++)

267 for (j = pulses->x[i]; j < length; j++)

268 out[j] += pulses->y[i] * shape[j - pulses->x[i]];

269 }

270

271 /**

272 * Apply postfilter, very similar to AMR one.

273 */

274 static void postfilter_5k0(SiprContext *ctx, const float *lpc, float *samples)

275 {

276 float buf[SUBFR_SIZE + LP_FILTER_ORDER];

277 float *pole_out = buf + LP_FILTER_ORDER;

278 float lpc_n[LP_FILTER_ORDER];

279 float lpc_d[LP_FILTER_ORDER];

280 int i;

281

282 for (i = 0; i < LP_FILTER_ORDER; i++) {

283 lpc_d[i] = lpc[i] * ff_pow_0_75[i];

284 lpc_n[i] = lpc[i] * ff_pow_0_5 [i];

285 };

286

287 memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem,

288 LP_FILTER_ORDER*sizeof(float));

289

290 ff_celp_lp_synthesis_filterf(pole_out, lpc_d, samples, SUBFR_SIZE,

291 LP_FILTER_ORDER);

292

293 memcpy(ctx->postfilter_mem, pole_out + SUBFR_SIZE - LP_FILTER_ORDER,

294 LP_FILTER_ORDER*sizeof(float));

295

296 ff_tilt_compensation(&ctx->tilt_mem, 0.4, pole_out, SUBFR_SIZE);

297

298 memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem5k0,

299 LP_FILTER_ORDER*sizeof(*pole_out));

300

301 memcpy(ctx->postfilter_mem5k0, pole_out + SUBFR_SIZE - LP_FILTER_ORDER,

302 LP_FILTER_ORDER*sizeof(*pole_out));

303

304 ff_celp_lp_zero_synthesis_filterf(samples, lpc_n, pole_out, SUBFR_SIZE,

305 LP_FILTER_ORDER);

306

307 }

308

309 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const int16_t *pulses,

310 SiprMode mode, int low_gain)

311 {

312 int i;

313

314 switch (mode) {

315 case MODE_6k5:

316 for (i = 0; i < 3; i++) {

317 fixed_sparse->x[i] = 3 * (pulses[i] & 0xf) + i;

318 fixed_sparse->y[i] = pulses[i] & 0x10 ? -1 : 1;

319 }

320 fixed_sparse->n = 3;

321 break;

322 case MODE_8k5:

323 for (i = 0; i < 3; i++) {

324 fixed_sparse->x[2*i ] = 3 * ((pulses[i] >> 4) & 0xf) + i;

325 fixed_sparse->x[2*i + 1] = 3 * ( pulses[i] & 0xf) + i;

326

327 fixed_sparse->y[2*i ] = (pulses[i] & 0x100) ? -1.0: 1.0;

328

329 fixed_sparse->y[2*i + 1] =

330 (fixed_sparse->x[2*i + 1] < fixed_sparse->x[2*i]) ?

331 -fixed_sparse->y[2*i ] : fixed_sparse->y[2*i];

332 }

333

334 fixed_sparse->n = 6;

335 break;

336 case MODE_5k0:

337 default:

338 if (low_gain) {

339 int offset = (pulses[0] & 0x200) ? 2 : 0;

340 int val = pulses[0];

341

342 for (i = 0; i < 3; i++) {

343 int index = (val & 0x7) * 6 + 4 - i*2;

344

345 fixed_sparse->y[i] = (offset + index) & 0x3 ? -1 : 1;

346 fixed_sparse->x[i] = index;

347

348 val >>= 3;

349 }

350 fixed_sparse->n = 3;

351 } else {

352 int pulse_subset = (pulses[0] >> 8) & 1;

353

354 fixed_sparse->x[0] = ((pulses[0] >> 4) & 15) * 3 + pulse_subset;

355 fixed_sparse->x[1] = ( pulses[0] & 15) * 3 + pulse_subset + 1;

356

357 fixed_sparse->y[0] = pulses[0] & 0x200 ? -1 : 1;

358 fixed_sparse->y[1] = -fixed_sparse->y[0];

359 fixed_sparse->n = 2;

360 }

361 break;

362 }

363 }

364

365 static void decode_frame(SiprContext *ctx, SiprParameters *params,

366 float *out_data)

367 {

368 int i, j;

369 int subframe_count = modes[ctx->mode].subframe_count;

370 int frame_size = subframe_count * SUBFR_SIZE;

371 float Az[LP_FILTER_ORDER * MAX_SUBFRAME_COUNT];

372 float *excitation;

373 float ir_buf[SUBFR_SIZE + LP_FILTER_ORDER];

374 float lsf_new[LP_FILTER_ORDER];

375 float *impulse_response = ir_buf + LP_FILTER_ORDER;

376 float *synth = ctx->synth_buf + 16; // 16 instead of LP_FILTER_ORDER for

377 // memory alignment

378 int t0_first = 0;

379 AMRFixed fixed_cb;

380

381 memset(ir_buf, 0, LP_FILTER_ORDER * sizeof(float));

382 lsf_decode_fp(lsf_new, ctx->lsf_history, params);

383

384 sipr_decode_lp(lsf_new, ctx->lsp_history, Az, subframe_count);

385

386 memcpy(ctx->lsp_history, lsf_new, LP_FILTER_ORDER * sizeof(float));

387

388 excitation = ctx->excitation + PITCH_DELAY_MAX + L_INTERPOL;

389

390 for (i = 0; i < subframe_count; i++) {

391 float *pAz = Az + i*LP_FILTER_ORDER;

392 float fixed_vector[SUBFR_SIZE];

393 int T0,T0_frac;

394 float pitch_gain, gain_code, avg_energy;

395

396 ff_decode_pitch_lag(&T0, &T0_frac, params->pitch_delay[i], t0_first, i,

397 ctx->mode == MODE_5k0, 6);

398

399 if (i == 0 || (i == 2 && ctx->mode == MODE_5k0))

400 t0_first = T0;

401

402 ff_acelp_interpolatef(excitation, excitation - T0 + (T0_frac <= 0),

403 ff_b60_sinc, 6,

404 2 * ((2 + T0_frac)%3 + 1), LP_FILTER_ORDER,

405 SUBFR_SIZE);

406

407 decode_fixed_sparse(&fixed_cb, params->fc_indexes[i], ctx->mode,

408 ctx->past_pitch_gain < 0.8);

409

410 eval_ir(pAz, T0, impulse_response, modes[ctx->mode].pitch_sharp_factor);

411

412 convolute_with_sparse(fixed_vector, &fixed_cb, impulse_response,

413 SUBFR_SIZE);

414

415 avg_energy = (0.01 + avpriv_scalarproduct_float_c(fixed_vector,

416 fixed_vector,

417 SUBFR_SIZE)) /

418 SUBFR_SIZE;

419

420 ctx->past_pitch_gain = pitch_gain = gain_cb[params->gc_index[i]][0];

421

422 gain_code = ff_amr_set_fixed_gain(gain_cb[params->gc_index[i]][1],

423 avg_energy, ctx->energy_history,

424 34 - 15.0/(0.05*M_LN10/M_LN2),

425 pred);

426

427 ff_weighted_vector_sumf(excitation, excitation, fixed_vector,

428 pitch_gain, gain_code, SUBFR_SIZE);

429

430 pitch_gain *= 0.5 * pitch_gain;

431 pitch_gain = FFMIN(pitch_gain, 0.4);

432

433 ctx->gain_mem = 0.7 * ctx->gain_mem + 0.3 * pitch_gain;

434 ctx->gain_mem = FFMIN(ctx->gain_mem, pitch_gain);

435 gain_code *= ctx->gain_mem;

436

437 for (j = 0; j < SUBFR_SIZE; j++)

438 fixed_vector[j] = excitation[j] - gain_code * fixed_vector[j];

439

440 if (ctx->mode == MODE_5k0) {

441 postfilter_5k0(ctx, pAz, fixed_vector);

442

443 ff_celp_lp_synthesis_filterf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,

444 pAz, excitation, SUBFR_SIZE,

445 LP_FILTER_ORDER);

446 }

447

448 ff_celp_lp_synthesis_filterf(synth + i*SUBFR_SIZE, pAz, fixed_vector,

449 SUBFR_SIZE, LP_FILTER_ORDER);

450

451 excitation += SUBFR_SIZE;

452 }

453

454 memcpy(synth - LP_FILTER_ORDER, synth + frame_size - LP_FILTER_ORDER,

455 LP_FILTER_ORDER * sizeof(float));

456

457 if (ctx->mode == MODE_5k0) {

458 for (i = 0; i < subframe_count; i++) {

459 float energy = avpriv_scalarproduct_float_c(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i * SUBFR_SIZE,

460 ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i * SUBFR_SIZE,

461 SUBFR_SIZE);

462 ff_adaptive_gain_control(&synth[i * SUBFR_SIZE],

463 &synth[i * SUBFR_SIZE], energy,

464 SUBFR_SIZE, 0.9, &ctx->postfilter_agc);

465 }

466

467 memcpy(ctx->postfilter_syn5k0, ctx->postfilter_syn5k0 + frame_size,

468 LP_FILTER_ORDER*sizeof(float));

469 }

470 memmove(ctx->excitation, excitation - PITCH_DELAY_MAX - L_INTERPOL,

471 (PITCH_DELAY_MAX + L_INTERPOL) * sizeof(float));

472

473 ff_acelp_apply_order_2_transfer_function(out_data, synth,

474 (const float[2]) {-1.99997 , 1.000000000},

475 (const float[2]) {-1.93307352, 0.935891986},

476 0.939805806,

477 ctx->highpass_filt_mem,

478 frame_size);

479 }

480

481 static av_cold int sipr_decoder_init(AVCodecContext * avctx)

482 {

483 SiprContext *ctx = avctx->priv_data;

484 int i;

485

486 switch (avctx->block_align) {

487 case 20: ctx->mode = MODE_16k; break;

488 case 19: ctx->mode = MODE_8k5; break;

489 case 29: ctx->mode = MODE_6k5; break;

490 case 37: ctx->mode = MODE_5k0; break;

491 default:

492 if (avctx->bit_rate > 12200) ctx->mode = MODE_16k;

493 else if (avctx->bit_rate > 7500 ) ctx->mode = MODE_8k5;

494 else if (avctx->bit_rate > 5750 ) ctx->mode = MODE_6k5;

495 else ctx->mode = MODE_5k0;

496 av_log(avctx, AV_LOG_WARNING,

497 "Invalid block_align: %d. Mode %s guessed based on bitrate: %"PRId64"\n",

498 avctx->block_align, modes[ctx->mode].mode_name, avctx->bit_rate);

499 }

500

501 av_log(avctx, AV_LOG_DEBUG, "Mode: %s\n", modes[ctx->mode].mode_name);

502

503 if (ctx->mode == MODE_16k) {

504 ff_sipr_init_16k(ctx);

505 ctx->decode_frame = ff_sipr_decode_frame_16k;

506 } else {

507 ctx->decode_frame = decode_frame;

508 }

509

510 for (i = 0; i < LP_FILTER_ORDER; i++)

511 ctx->lsp_history[i] = cos((i+1) * M_PI / (LP_FILTER_ORDER + 1));

512

513 for (i = 0; i < 4; i++)

514 ctx->energy_history[i] = -14;

515

516 av_channel_layout_uninit(&avctx->ch_layout);

517 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

518 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

519

520 return 0;

521 }

522

523 static int sipr_decode_frame(AVCodecContext *avctx, AVFrame *frame,

524 int *got_frame_ptr, AVPacket *avpkt)

525 {

526 SiprContext *ctx = avctx->priv_data;

527 const uint8_t *buf=avpkt->data;

528 SiprParameters parm;

529 const SiprModeParam *mode_par = &modes[ctx->mode];

530 GetBitContext gb;

531 float *samples;

532 int subframe_size = ctx->mode == MODE_16k ? L_SUBFR_16k : SUBFR_SIZE;

533 int i, ret;

534

535 if (avpkt->size < (mode_par->bits_per_frame >> 3)) {

536 av_log(avctx, AV_LOG_ERROR,

537 "Error processing packet: packet size (%d) too small\n",

538 avpkt->size);

539 return AVERROR_INVALIDDATA;

540 }

541

542 /* get output buffer */

543 frame->nb_samples = mode_par->frames_per_packet * subframe_size *

544 mode_par->subframe_count;

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

546 return ret;

547 samples = (float *)frame->data[0];

548

549 init_get_bits(&gb, buf, mode_par->bits_per_frame);

550

551 for (i = 0; i < mode_par->frames_per_packet; i++) {

552 decode_parameters(&parm, &gb, mode_par);

553

554 ctx->decode_frame(ctx, &parm, samples);

555

556 samples += subframe_size * mode_par->subframe_count;

557 }

558

559 *got_frame_ptr = 1;

560

561 return mode_par->bits_per_frame >> 3;

562 }

563

564 const FFCodec ff_sipr_decoder = {

565 .p.name = "sipr",

566 CODEC_LONG_NAME("RealAudio SIPR / ACELP.NET"),

567 .p.type = AVMEDIA_TYPE_AUDIO,

568 .p.id = AV_CODEC_ID_SIPR,

569 .priv_data_size = sizeof(SiprContext),

570 .init = sipr_decoder_init,

571 FF_CODEC_DECODE_CB(sipr_decode_frame),

572 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

573 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AMRFixed::x

int x[10]

Definition: acelp_vectors.h:55

acelp_vectors.h

eval_ir

static void eval_ir(const float *Az, int pitch_lag, float *freq, float pitch_sharp_factor)

Evaluate the adaptive impulse response.

Definition: sipr.c:238

SiprModeParam::gp_index_bits

uint8_t gp_index_bits

Definition: sipr.c:65

ff_amr_set_fixed_gain

float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)

Calculate fixed gain (part of section 6.1.3 of AMR spec)

Definition: acelp_pitch_delay.c:84

SiprModeParam::mode_name

const char * mode_name

Definition: sipr.c:49

out

FILE * out

Definition: movenc.c:55

ff_decode_pitch_lag

void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe, int third_as_first, int resolution)

Decode the adaptive codebook index to the integer and fractional parts of the pitch lag for one subfr...

Definition: acelp_pitch_delay.c:105

postfilter_5k0

static void postfilter_5k0(SiprContext *ctx, const float *lpc, float *samples)

Apply postfilter, very similar to AMR one.

Definition: sipr.c:274

ff_amrwb_lsp2lpc

void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order)

LSP to LP conversion (5.2.4 of AMR-WB)

Definition: lsp.c:175

ff_b60_sinc

const float ff_b60_sinc[61]

b60 hamming windowed sinc function coefficients

Definition: acelp_vectors.c:103

siprdata.h

AVFrame

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

Definition: frame.h:389

MODE_5k0

@ MODE_5k0

Definition: sipr.h:51

ff_acelp_apply_order_2_transfer_function

void ff_acelp_apply_order_2_transfer_function(float *out, const float *in, const float zero_coeffs[2], const float pole_coeffs[2], float gain, float mem[2], int n)

Apply an order 2 rational transfer function in-place.

Definition: acelp_filters.c:121

AVPacket::data

uint8_t * data

Definition: packet.h:539

ff_sipr_decode_frame_16k

void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params, float *out_data)

Definition: sipr16k.c:176

FFCodec

Definition: codec_internal.h:127

mathematics.h

ff_sort_nearly_sorted_floats

void ff_sort_nearly_sorted_floats(float *vals, int len)

Sort values in ascending order.

Definition: lsp.c:239

LP_FILTER_ORDER

#define LP_FILTER_ORDER

linear predictive coding filter order

Definition: amrnbdata.h:53

MAX_SUBFRAME_COUNT

#define MAX_SUBFRAME_COUNT

Definition: sipr.c:43

ff_celp_lp_synthesis_filterf

void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)

LP synthesis filter.

Definition: celp_filters.c:85

ff_sipr_decoder

const FFCodec ff_sipr_decoder

Definition: sipr.c:564

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:514

LSFQ_DIFF_MIN

#define LSFQ_DIFF_MIN

minimum LSF distance (3.2.4) 0.0391 in Q13

Definition: g729dec.c:59

MODE_8k5

@ MODE_8k5

Definition: sipr.h:49

M_LN2

#define M_LN2

Definition: mathematics.h:43

SiprModeParam::frames_per_packet

uint8_t frames_per_packet

Definition: sipr.c:52

SUBFR_SIZE

#define SUBFR_SIZE

Subframe size for all modes except 16k.

Definition: sipr.h:43

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

PITCH_DELAY_MAX

#define PITCH_DELAY_MAX

Definition: acelp_pitch_delay.h:31

ff_pow_0_55

const float ff_pow_0_55[10]

Table of pow(0.55,n)

Definition: acelp_vectors.c:98

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

lsf_decode_fp

static void lsf_decode_fp(float *lsfnew, float *lsf_history, const SiprParameters *parm)

Definition: sipr.c:154

convolute_with_sparse

static void convolute_with_sparse(float *out, const AMRFixed *pulses, const float *shape, int length)

Evaluate the convolution of a vector with a sparse vector.

Definition: sipr.c:260

SiprModeParam::number_of_fc_indexes

uint8_t number_of_fc_indexes

Definition: sipr.c:56

GetBitContext

Definition: get_bits.h:108

SiprParameters

Definition: sipr.h:55

val

static double val(void *priv, double ch)

Definition: aeval.c:77

SiprParameters::gc_index

int gc_index[5]

fixed-codebook gain indexes

Definition: sipr.h:61

SiprModeParam::pitch_sharp_factor

float pitch_sharp_factor

Definition: sipr.c:53

ff_adaptive_gain_control

void ff_adaptive_gain_control(float *out, const float *in, float speech_energ, int size, float alpha, float *gain_mem)

Adaptive gain control (as used in AMR postfiltering)

Definition: acelp_vectors.c:192

decode_parameters

static void decode_parameters(SiprParameters *parms, GetBitContext *pgb, const SiprModeParam *p)

Extract decoding parameters from the input bitstream.

Definition: sipr.c:194

AV_CODEC_ID_SIPR

@ AV_CODEC_ID_SIPR

Definition: codec_id.h:481

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

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

frame_size

int frame_size

Definition: mxfenc.c:2424

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

dequant

static void dequant(float *out, const int *idx, const float *const cbs[])

Definition: sipr.c:143

AMRFixed

Sparse representation for the algebraic codebook (fixed) vector.

Definition: acelp_vectors.h:53

sipr_decode_lp

static void sipr_decode_lp(float *lsfnew, const float *lsfold, float *Az, int num_subfr)

Definition: sipr.c:217

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:49

decode.h

get_bits.h

AMRFixed::y

float y[10]

Definition: acelp_vectors.h:56

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

decode_fixed_sparse

static void decode_fixed_sparse(AMRFixed *fixed_sparse, const int16_t *pulses, SiprMode mode, int low_gain)

Definition: sipr.c:309

SiprMode

Definition: sipr.h:47

SiprParameters::ma_pred_switch

int ma_pred_switch

switched moving average predictor

Definition: sipr.h:56

L_INTERPOL

#define L_INTERPOL

Number of past samples needed for excitation interpolation.

Definition: sipr.h:40

SiprModeParam::vq_indexes_bits

uint8_t vq_indexes_bits[5]

size in bits of the i-th stage vector of quantizer

Definition: sipr.c:60

MODE_16k

@ MODE_16k

Definition: sipr.h:48

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:501

SiprParameters::fc_indexes

int16_t fc_indexes[5][10]

fixed-codebook indexes

Definition: sipr.h:60

SiprParameters::pitch_delay

int pitch_delay[5]

pitch delay

Definition: sipr.h:58

celp_filters.h

index

int index

Definition: gxfenc.c:90

float_dsp.h

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

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1719

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

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

AVChannelLayout

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

Definition: channel_layout.h:311

codec_internal.h

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1063

ff_pow_0_7

const float ff_pow_0_7[10]

Table of pow(0.7,n)

Definition: acelp_vectors.c:88

sipr_decode_frame

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

Definition: sipr.c:523

SiprModeParam::bits_per_frame

uint16_t bits_per_frame

Definition: sipr.c:50

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

ff_pow_0_5

const float ff_pow_0_5[]

Definition: sipr.c:136

lsf_codebooks

static const float *const lsf_codebooks[]

Definition: siprdata.h:209

M_PI

#define M_PI

Definition: mathematics.h:67

ff_tilt_compensation

void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)

Apply tilt compensation filter, 1 - tilt * z-1.

Definition: acelp_filters.c:138

pitch_sharpening

static void pitch_sharpening(int pitch_lag_int, float beta, float *fixed_vector)

Apply pitch lag to the fixed vector (AMR section 6.1.2).

Definition: sipr.c:180

sipr.h

SiprParameters::vq_indexes

int vq_indexes[5]

Definition: sipr.h:57

SiprContext

Definition: sipr.h:64

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

Definition: cbs_h2645.c:256

ff_sipr_init_16k

void ff_sipr_init_16k(SiprContext *ctx)

Definition: sipr16k.c:271

modes

static const SiprModeParam modes[MODE_COUNT]

Definition: sipr.c:70

decode_frame

static void decode_frame(SiprContext *ctx, SiprParameters *params, float *out_data)

Definition: sipr.c:365

#define xf(width, name, var, range_min, range_max, subs,...)

Definition: cbs_av1.c:598

SiprModeParam::gc_index_bits

uint8_t gc_index_bits

size in bits of the gain codebook indexes

Definition: sipr.c:67

ff_pow_0_75

const float ff_pow_0_75[10]

Table of pow(0.75,n)

Definition: acelp_vectors.c:93

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

acelp_filters.h

ff_weighted_vector_sumf

void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b, float weight_coeff_a, float weight_coeff_b, int length)

float implementation of weighted sum of two vectors.

Definition: acelp_vectors.c:182

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

gain_cb

static const float gain_cb[128][2]

Definition: siprdata.h:213

MODE_6k5

@ MODE_6k5

Definition: sipr.h:50

avcodec.h

stride

#define stride

Definition: h264pred_template.c:537

ret

Definition: filter_design.txt:187

pred

static const float pred[4]

Definition: siprdata.h:259

AVCodecContext::block_align

int block_align

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

Definition: avcodec.h:1089

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

lsp.h

ff_celp_lp_zero_synthesis_filterf

void ff_celp_lp_zero_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)

LP zero synthesis filter.

Definition: celp_filters.c:200

AMRFixed::n

int n

Definition: acelp_vectors.h:54

SiprModeParam::pitch_delay_bits

uint8_t pitch_delay_bits[5]

size in bits of the adaptive-codebook index for every subframe