FFmpeg: libavcodec/ra144enc.c Source File

FFmpeg

[フレーム]

libavcodec

ra144enc.c

Go to the documentation of this file.

1 /*

2 * Real Audio 1.0 (14.4K) encoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * Real Audio 1.0 (14.4K) encoder

25 * @author Francesco Lavra <francescolavra@interfree.it>

26 */

28 #include <float.h>

30 #include "libavutil/channel_layout.h"

31 #include "avcodec.h"

32 #include "audio_frame_queue.h"

33 #include "celp_filters.h"

34 #include "codec_internal.h"

35 #include "encode.h"

36 #include "mathops.h"

37 #include "put_bits.h"

38 #include "ra144.h"

40 static av_cold int ra144_encode_close(AVCodecContext *avctx)

41 {

42 RA144Context *ractx = avctx->priv_data;

43 ff_lpc_end(&ractx->lpc_ctx);

44 ff_af_queue_close(&ractx->afq);

45 return 0;

46 }

49 static av_cold int ra144_encode_init(AVCodecContext * avctx)

50 {

51 RA144Context *ractx;

52 int ret;

54 avctx->frame_size = NBLOCKS * BLOCKSIZE;

55 avctx->initial_padding = avctx->frame_size;

56 avctx->bit_rate = 8000;

57 ractx = avctx->priv_data;

58 ractx->lpc_coef[0] = ractx->lpc_tables[0];

59 ractx->lpc_coef[1] = ractx->lpc_tables[1];

60 ractx->avctx = avctx;

61 ff_audiodsp_init(&ractx->adsp);

62 ret = ff_lpc_init(&ractx->lpc_ctx, avctx->frame_size, LPC_ORDER,

63 FF_LPC_TYPE_LEVINSON);

64 if (ret < 0)

65 return ret;

67 ff_af_queue_init(avctx, &ractx->afq);

69 return 0;

70 }

73 /**

74 * Quantize a value by searching a sorted table for the element with the

75 * nearest value

76 *

77 * @param value value to quantize

78 * @param table array containing the quantization table

79 * @param size size of the quantization table

80 * @return index of the quantization table corresponding to the element with the

81 * nearest value

82 */

83 static int quantize(int value, const int16_t *table, unsigned int size)

84 {

85 unsigned int low = 0, high = size - 1;

87 while (1) {

88 int index = (low + high) >> 1;

89 int error = table[index] - value;

91 if (index == low)

92 return table[high] + error > value ? low : high;

93 if (error > 0) {

94 high = index;

95 } else {

96 low = index;

97 }

98 }

99 }

100

101

102 /**

103 * Orthogonalize a vector to another vector

104 *

105 * @param v vector to orthogonalize

106 * @param u vector against which orthogonalization is performed

107 */

108 static void orthogonalize(float *v, const float *u)

109 {

110 int i;

111 float num = 0, den = 0;

112

113 for (i = 0; i < BLOCKSIZE; i++) {

114 num += v[i] * u[i];

115 den += u[i] * u[i];

116 }

117 num /= den;

118 for (i = 0; i < BLOCKSIZE; i++)

119 v[i] -= num * u[i];

120 }

121

122

123 /**

124 * Calculate match score and gain of an LPC-filtered vector with respect to

125 * input data, possibly orthogonalizing it to up to two other vectors.

126 *

127 * @param work array used to calculate the filtered vector

128 * @param coefs coefficients of the LPC filter

129 * @param vect original vector

130 * @param ortho1 first vector against which orthogonalization is performed

131 * @param ortho2 second vector against which orthogonalization is performed

132 * @param data input data

133 * @param score pointer to variable where match score is returned

134 * @param gain pointer to variable where gain is returned

135 */

136 static void get_match_score(float *work, const float *coefs, float *vect,

137 const float *ortho1, const float *ortho2,

138 const float *data, float *score, float *gain)

139 {

140 float c, g;

141 int i;

142

143 ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER);

144 if (ortho1)

145 orthogonalize(work, ortho1);

146 if (ortho2)

147 orthogonalize(work, ortho2);

148 c = g = 0;

149 for (i = 0; i < BLOCKSIZE; i++) {

150 g += work[i] * work[i];

151 c += data[i] * work[i];

152 }

153 if (c <= 0) {

154 *score = 0;

155 return;

156 }

157 *gain = c / g;

158 *score = *gain * c;

159 }

160

161

162 /**

163 * Create a vector from the adaptive codebook at a given lag value

164 *

165 * @param vect array where vector is stored

166 * @param cb adaptive codebook

167 * @param lag lag value

168 */

169 static void create_adapt_vect(float *vect, const int16_t *cb, int lag)

170 {

171 int i;

172

173 cb += BUFFERSIZE - lag;

174 for (i = 0; i < FFMIN(BLOCKSIZE, lag); i++)

175 vect[i] = cb[i];

176 if (lag < BLOCKSIZE)

177 for (i = 0; i < BLOCKSIZE - lag; i++)

178 vect[lag + i] = cb[i];

179 }

180

181

182 /**

183 * Search the adaptive codebook for the best entry and gain and remove its

184 * contribution from input data

185 *

186 * @param adapt_cb array from which the adaptive codebook is extracted

187 * @param work array used to calculate LPC-filtered vectors

188 * @param coefs coefficients of the LPC filter

189 * @param data input data

190 * @return index of the best entry of the adaptive codebook

191 */

192 static int adaptive_cb_search(const int16_t *adapt_cb, float *work,

193 const float *coefs, float *data)

194 {

195 int i, av_uninit(best_vect);

196 float score, gain, best_score, av_uninit(best_gain);

197 float exc[BLOCKSIZE];

198

199 gain = best_score = 0;

200 for (i = BLOCKSIZE / 2; i <= BUFFERSIZE; i++) {

201 create_adapt_vect(exc, adapt_cb, i);

202 get_match_score(work, coefs, exc, NULL, NULL, data, &score, &gain);

203 if (score > best_score) {

204 best_score = score;

205 best_vect = i;

206 best_gain = gain;

207 }

208 }

209 if (!best_score)

210 return 0;

211

212 /**

213 * Re-calculate the filtered vector from the vector with maximum match score

214 * and remove its contribution from input data.

215 */

216 create_adapt_vect(exc, adapt_cb, best_vect);

217 ff_celp_lp_synthesis_filterf(work, coefs, exc, BLOCKSIZE, LPC_ORDER);

218 for (i = 0; i < BLOCKSIZE; i++)

219 data[i] -= best_gain * work[i];

220 return best_vect - BLOCKSIZE / 2 + 1;

221 }

222

223

224 /**

225 * Find the best vector of a fixed codebook by applying an LPC filter to

226 * codebook entries, possibly orthogonalizing them to up to two other vectors

227 * and matching the results with input data.

228 *

229 * @param work array used to calculate the filtered vectors

230 * @param coefs coefficients of the LPC filter

231 * @param cb fixed codebook

232 * @param ortho1 first vector against which orthogonalization is performed

233 * @param ortho2 second vector against which orthogonalization is performed

234 * @param data input data

235 * @param idx pointer to variable where the index of the best codebook entry is

236 * returned

237 * @param gain pointer to variable where the gain of the best codebook entry is

238 * returned

239 */

240 static void find_best_vect(float *work, const float *coefs,

241 const int8_t cb[][BLOCKSIZE], const float *ortho1,

242 const float *ortho2, float *data, int *idx,

243 float *gain)

244 {

245 int i, j;

246 float g, score, best_score;

247 float vect[BLOCKSIZE];

248

249 *idx = *gain = best_score = 0;

250 for (i = 0; i < FIXED_CB_SIZE; i++) {

251 for (j = 0; j < BLOCKSIZE; j++)

252 vect[j] = cb[i][j];

253 get_match_score(work, coefs, vect, ortho1, ortho2, data, &score, &g);

254 if (score > best_score) {

255 best_score = score;

256 *idx = i;

257 *gain = g;

258 }

259 }

260 }

261

262

263 /**

264 * Search the two fixed codebooks for the best entry and gain

265 *

266 * @param work array used to calculate LPC-filtered vectors

267 * @param coefs coefficients of the LPC filter

268 * @param data input data

269 * @param cba_idx index of the best entry of the adaptive codebook

270 * @param cb1_idx pointer to variable where the index of the best entry of the

271 * first fixed codebook is returned

272 * @param cb2_idx pointer to variable where the index of the best entry of the

273 * second fixed codebook is returned

274 */

275 static void fixed_cb_search(float *work, const float *coefs, float *data,

276 int cba_idx, int *cb1_idx, int *cb2_idx)

277 {

278 int i, ortho_cb1;

279 float gain;

280 float cba_vect[BLOCKSIZE], cb1_vect[BLOCKSIZE];

281 float vect[BLOCKSIZE];

282

283 /**

284 * The filtered vector from the adaptive codebook can be retrieved from

285 * work, because this function is called just after adaptive_cb_search().

286 */

287 if (cba_idx)

288 memcpy(cba_vect, work, sizeof(cba_vect));

289

290 find_best_vect(work, coefs, ff_cb1_vects, cba_idx ? cba_vect : NULL, NULL,

291 data, cb1_idx, &gain);

292

293 /**

294 * Re-calculate the filtered vector from the vector with maximum match score

295 * and remove its contribution from input data.

296 */

297 if (gain) {

298 for (i = 0; i < BLOCKSIZE; i++)

299 vect[i] = ff_cb1_vects[*cb1_idx][i];

300 ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER);

301 if (cba_idx)

302 orthogonalize(work, cba_vect);

303 for (i = 0; i < BLOCKSIZE; i++)

304 data[i] -= gain * work[i];

305 memcpy(cb1_vect, work, sizeof(cb1_vect));

306 ortho_cb1 = 1;

307 } else

308 ortho_cb1 = 0;

309

310 find_best_vect(work, coefs, ff_cb2_vects, cba_idx ? cba_vect : NULL,

311 ortho_cb1 ? cb1_vect : NULL, data, cb2_idx, &gain);

312 }

313

314

315 /**

316 * Encode a subblock of the current frame

317 *

318 * @param ractx encoder context

319 * @param sblock_data input data of the subblock

320 * @param lpc_coefs coefficients of the LPC filter

321 * @param rms RMS of the reflection coefficients

322 * @param pb pointer to PutBitContext of the current frame

323 */

324 static void ra144_encode_subblock(RA144Context *ractx,

325 const int16_t *sblock_data,

326 const int16_t *lpc_coefs, unsigned int rms,

327 PutBitContext *pb)

328 {

329 float data[BLOCKSIZE] = { 0 }, work[LPC_ORDER + BLOCKSIZE];

330 float coefs[LPC_ORDER];

331 float zero[BLOCKSIZE], cba[BLOCKSIZE], cb1[BLOCKSIZE], cb2[BLOCKSIZE];

332 int cba_idx, cb1_idx, cb2_idx, gain;

333 int i, n;

334 unsigned m[3];

335 float g[3];

336 float error, best_error;

337

338 for (i = 0; i < LPC_ORDER; i++) {

339 work[i] = ractx->curr_sblock[BLOCKSIZE + i];

340 coefs[i] = lpc_coefs[i] * (1/4096.0);

341 }

342

343 /**

344 * Calculate the zero-input response of the LPC filter and subtract it from

345 * input data.

346 */

347 ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, data, BLOCKSIZE,

348 LPC_ORDER);

349 for (i = 0; i < BLOCKSIZE; i++) {

350 zero[i] = work[LPC_ORDER + i];

351 data[i] = sblock_data[i] - zero[i];

352 }

353

354 /**

355 * Codebook search is performed without taking into account the contribution

356 * of the previous subblock, since it has been just subtracted from input

357 * data.

358 */

359 memset(work, 0, LPC_ORDER * sizeof(*work));

360

361 cba_idx = adaptive_cb_search(ractx->adapt_cb, work + LPC_ORDER, coefs,

362 data);

363 if (cba_idx) {

364 /**

365 * The filtered vector from the adaptive codebook can be retrieved from

366 * work, see implementation of adaptive_cb_search().

367 */

368 memcpy(cba, work + LPC_ORDER, sizeof(cba));

369

370 ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);

371 m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * rms) >> 12;

372 }

373 fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx);

374 for (i = 0; i < BLOCKSIZE; i++) {

375 cb1[i] = ff_cb1_vects[cb1_idx][i];

376 cb2[i] = ff_cb2_vects[cb2_idx][i];

377 }

378 ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb1, BLOCKSIZE,

379 LPC_ORDER);

380 memcpy(cb1, work + LPC_ORDER, sizeof(cb1));

381 m[1] = (ff_cb1_base[cb1_idx] * rms) >> 8;

382 ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb2, BLOCKSIZE,

383 LPC_ORDER);

384 memcpy(cb2, work + LPC_ORDER, sizeof(cb2));

385 m[2] = (ff_cb2_base[cb2_idx] * rms) >> 8;

386 best_error = FLT_MAX;

387 gain = 0;

388 for (n = 0; n < 256; n++) {

389 g[1] = ((ff_gain_val_tab[n][1] * m[1]) >> ff_gain_exp_tab[n]) *

390 (1/4096.0);

391 g[2] = ((ff_gain_val_tab[n][2] * m[2]) >> ff_gain_exp_tab[n]) *

392 (1/4096.0);

393 error = 0;

394 if (cba_idx) {

395 g[0] = ((ff_gain_val_tab[n][0] * m[0]) >> ff_gain_exp_tab[n]) *

396 (1/4096.0);

397 for (i = 0; i < BLOCKSIZE; i++) {

398 data[i] = zero[i] + g[0] * cba[i] + g[1] * cb1[i] +

399 g[2] * cb2[i];

400 error += (data[i] - sblock_data[i]) *

401 (data[i] - sblock_data[i]);

402 }

403 } else {

404 for (i = 0; i < BLOCKSIZE; i++) {

405 data[i] = zero[i] + g[1] * cb1[i] + g[2] * cb2[i];

406 error += (data[i] - sblock_data[i]) *

407 (data[i] - sblock_data[i]);

408 }

409 }

410 if (error < best_error) {

411 best_error = error;

412 gain = n;

413 }

414 }

415 put_bits(pb, 7, cba_idx);

416 put_bits(pb, 8, gain);

417 put_bits(pb, 7, cb1_idx);

418 put_bits(pb, 7, cb2_idx);

419 ff_subblock_synthesis(ractx, lpc_coefs, cba_idx, cb1_idx, cb2_idx, rms,

420 gain);

421 }

422

423

424 static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

425 const AVFrame *frame, int *got_packet_ptr)

426 {

427 static const uint8_t sizes[LPC_ORDER] = {64, 32, 32, 16, 16, 8, 8, 8, 8, 4};

428 static const uint8_t bit_sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};

429 RA144Context *ractx = avctx->priv_data;

430 PutBitContext pb;

431 int32_t lpc_data[NBLOCKS * BLOCKSIZE];

432 int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER];

433 int shift[LPC_ORDER];

434 int16_t block_coefs[NBLOCKS][LPC_ORDER];

435 int lpc_refl[LPC_ORDER]; /**< reflection coefficients of the frame */

436 unsigned int refl_rms[NBLOCKS]; /**< RMS of the reflection coefficients */

437 const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;

438 int energy = 0;

439 int i, idx, ret;

440

441 if (ractx->last_frame)

442 return 0;

443

444 if ((ret = ff_get_encode_buffer(avctx, avpkt, FRAME_SIZE, 0)) < 0)

445 return ret;

446

447 /**

448 * Since the LPC coefficients are calculated on a frame centered over the

449 * fourth subframe, to encode a given frame, data from the next frame is

450 * needed. In each call to this function, the previous frame (whose data are

451 * saved in the encoder context) is encoded, and data from the current frame

452 * are saved in the encoder context to be used in the next function call.

453 */

454 for (i = 0; i < (2 * BLOCKSIZE + BLOCKSIZE / 2); i++) {

455 lpc_data[i] = ractx->curr_block[BLOCKSIZE + BLOCKSIZE / 2 + i];

456 energy += (lpc_data[i] * lpc_data[i]) >> 4;

457 }

458 if (frame) {

459 int j;

460 for (j = 0; j < frame->nb_samples && i < NBLOCKS * BLOCKSIZE; i++, j++) {

461 lpc_data[i] = samples[j] >> 2;

462 energy += (lpc_data[i] * lpc_data[i]) >> 4;

463 }

464 }

465 if (i < NBLOCKS * BLOCKSIZE)

466 memset(&lpc_data[i], 0, (NBLOCKS * BLOCKSIZE - i) * sizeof(*lpc_data));

467 energy = ff_energy_tab[quantize(ff_t_sqrt(energy >> 5) >> 10, ff_energy_tab,

468 32)];

469

470 ff_lpc_calc_coefs(&ractx->lpc_ctx, lpc_data, NBLOCKS * BLOCKSIZE, LPC_ORDER,

471 LPC_ORDER, 16, lpc_coefs, shift, FF_LPC_TYPE_LEVINSON,

472 0, ORDER_METHOD_EST, 0, 12, 0);

473 for (i = 0; i < LPC_ORDER; i++)

474 block_coefs[NBLOCKS - 1][i] = -lpc_coefs[LPC_ORDER - 1][i]

475 * (1 << (12 - shift[LPC_ORDER - 1]));

476

477 /**

478 * TODO: apply perceptual weighting of the input speech through bandwidth

479 * expansion of the LPC filter.

480 */

481

482 if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {

483 /**

484 * The filter is unstable: use the coefficients of the previous frame.

485 */

486 ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]);

487 if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {

488 /* the filter is still unstable. set reflection coeffs to zero. */

489 memset(lpc_refl, 0, sizeof(lpc_refl));

490 }

491 }

492 init_put_bits(&pb, avpkt->data, avpkt->size);

493 for (i = 0; i < LPC_ORDER; i++) {

494 idx = quantize(lpc_refl[i], ff_lpc_refl_cb[i], sizes[i]);

495 put_bits(&pb, bit_sizes[i], idx);

496 lpc_refl[i] = ff_lpc_refl_cb[i][idx];

497 }

498 ractx->lpc_refl_rms[0] = ff_rms(lpc_refl);

499 ff_eval_coefs(ractx->lpc_coef[0], lpc_refl);

500 refl_rms[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy);

501 refl_rms[1] = ff_interp(ractx, block_coefs[1], 2,

502 energy <= ractx->old_energy,

503 ff_t_sqrt(energy * ractx->old_energy) >> 12);

504 refl_rms[2] = ff_interp(ractx, block_coefs[2], 3, 0, energy);

505 refl_rms[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], energy);

506 ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[0]);

507 put_bits(&pb, 5, quantize(energy, ff_energy_tab, 32));

508 for (i = 0; i < NBLOCKS; i++)

509 ra144_encode_subblock(ractx, ractx->curr_block + i * BLOCKSIZE,

510 block_coefs[i], refl_rms[i], &pb);

511 flush_put_bits(&pb);

512 ractx->old_energy = energy;

513 ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0];

514 FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);

515

516 /* copy input samples to current block for processing in next call */

517 i = 0;

518 if (frame) {

519 for (; i < frame->nb_samples; i++)

520 ractx->curr_block[i] = samples[i] >> 2;

521

522 if ((ret = ff_af_queue_add(&ractx->afq, frame)) < 0)

523 return ret;

524 } else

525 ractx->last_frame = 1;

526 memset(&ractx->curr_block[i], 0,

527 (NBLOCKS * BLOCKSIZE - i) * sizeof(*ractx->curr_block));

528

529 /* Get the next frame pts/duration */

530 ff_af_queue_remove(&ractx->afq, avctx->frame_size, &avpkt->pts,

531 &avpkt->duration);

532

533 *got_packet_ptr = 1;

534 return 0;

535 }

536

537

538 const FFCodec ff_ra_144_encoder = {

539 .p.name = "real_144",

540 CODEC_LONG_NAME("RealAudio 1.0 (14.4K)"),

541 .p.type = AVMEDIA_TYPE_AUDIO,

542 .p.id = AV_CODEC_ID_RA_144,

543 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

544 AV_CODEC_CAP_SMALL_LAST_FRAME,

545 .priv_data_size = sizeof(RA144Context),

546 .init = ra144_encode_init,

547 FF_CODEC_ENCODE_CB(ra144_encode_frame),

548 .close = ra144_encode_close,

549 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),

550 CODEC_SAMPLERATES(8000),

551 CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),

552 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:32

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1051

NBLOCKS

#define NBLOCKS

number of subblocks within a block

Definition: ra144.h:33

ra144_encode_subblock

static void ra144_encode_subblock(RA144Context *ractx, const int16_t *sblock_data, const int16_t *lpc_coefs, unsigned int rms, PutBitContext *pb)

Encode a subblock of the current frame.

Definition: ra144enc.c:324

RA144Context::avctx

AVCodecContext * avctx

Definition: ra144.h:41

ff_af_queue_remove

void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)

Remove frame(s) from the queue.

Definition: audio_frame_queue.c:75

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

Definition: vf_geq.c:247

adaptive_cb_search

static int adaptive_cb_search(const int16_t *adapt_cb, float *work, const float *coefs, float *data)

Search the adaptive codebook for the best entry and gain and remove its contribution from input data.

Definition: ra144enc.c:192

ff_lpc_calc_coefs

int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)

Calculate LPC coefficients for multiple orders.

Definition: lpc.c:238

ff_energy_tab

const int16_t ff_energy_tab[32]

Definition: ra144.c:1440

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

ff_af_queue_init

av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)

Initialize AudioFrameQueue.

Definition: audio_frame_queue.c:28

ff_lpc_init

av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)

Initialize LPCContext.

Definition: lpc.c:340

FRAME_SIZE

#define FRAME_SIZE

fixed_cb_search

static void fixed_cb_search(float *work, const float *coefs, float *data, int cba_idx, int *cb1_idx, int *cb2_idx)

Search the two fixed codebooks for the best entry and gain.

Definition: ra144enc.c:275

AV_CODEC_ID_RA_144

@ AV_CODEC_ID_RA_144

Definition: codec_id.h:444

AVFrame

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

Definition: frame.h:427

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:224

ff_eval_coefs

void ff_eval_coefs(int *coefs, const int *refl)

Evaluate the LPC filter coefficients from the reflection coefficients.

Definition: ra144.c:1593

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

Definition: cbs_apv.c:68

AVPacket::data

uint8_t * data

Definition: packet.h:558

encode.h

table

static const uint16_t table[]

Definition: prosumer.c:203

data

const char data[16]

Definition: mxf.c:149

high

int high

Definition: dovi_rpuenc.c:39

FFCodec

Definition: codec_internal.h:127

ff_audiodsp_init

av_cold void ff_audiodsp_init(AudioDSPContext *c)

Definition: audiodsp.c:65

FIXED_CB_SIZE

#define FIXED_CB_SIZE

size of fixed codebooks

Definition: ra144.h:36

float.h

ff_cb2_vects

const int8_t ff_cb2_vects[128][40]

Definition: ra144.c:758

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:576

BUFFERSIZE

#define BUFFERSIZE

the size of the adaptive codebook

Definition: ra144.h:35

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

get_match_score

static void get_match_score(float *work, const float *coefs, float *vect, const float *ortho1, const float *ortho2, const float *data, float *score, float *gain)

Calculate match score and gain of an LPC-filtered vector with respect to input data,...

Definition: ra144enc.c:136

RA144Context::buffer_a

int16_t buffer_a[FFALIGN(BLOCKSIZE, 16)]

Definition: ra144.h:66

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

ff_cb1_vects

const int8_t ff_cb1_vects[128][40]

Definition: ra144.c:114

audio_frame_queue.h

AVCodecContext::initial_padding

int initial_padding

Audio only.

Definition: avcodec.h:1096

RA144Context::lpc_coef

unsigned int * lpc_coef[2]

LPC coefficients: lpc_coef[0] is the coefficients of the current frame and lpc_coef[1] of the previou...

Definition: ra144.h:53

create_adapt_vect

static void create_adapt_vect(float *vect, const int16_t *cb, int lag)

Create a vector from the adaptive codebook at a given lag value.

Definition: ra144enc.c:169

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:358

ff_af_queue_add

int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)

Add a frame to the queue.

Definition: audio_frame_queue.c:44

ff_eval_refl

int ff_eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx)

Evaluate the reflection coefficients from the filter coefficients.

Definition: ra144.c:1545

av_cold

#define av_cold

Definition: attributes.h:106

ff_lpc_refl_cb

const int16_t *const ff_lpc_refl_cb[10]

Definition: ra144.c:1502

ff_irms

int ff_irms(AudioDSPContext *adsp, const int16_t *data)

inverse root mean square

Definition: ra144.c:1684

ff_ra_144_encoder

const FFCodec ff_ra_144_encoder

Definition: ra144enc.c:538

const char * g

Definition: vf_curves.c:128

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

quantize

static int quantize(int value, const int16_t *table, unsigned int size)

Quantize a value by searching a sorted table for the element with the nearest value.

Definition: ra144enc.c:83

RA144Context::curr_block

int16_t curr_block[NBLOCKS *BLOCKSIZE]

Definition: ra144.h:57

PutBitContext

Definition: put_bits.h:50

LPC_ORDER

#define LPC_ORDER

Definition: g723_1.h:40

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

if(ret)

Definition: filter_design.txt:179

ff_af_queue_close

av_cold void ff_af_queue_close(AudioFrameQueue *afq)

Close AudioFrameQueue.

Definition: audio_frame_queue.c:36

ff_rescale_rms

unsigned int ff_rescale_rms(unsigned int rms, unsigned int energy)

Definition: ra144.c:1678

ff_cb2_base

const uint16_t ff_cb2_base[128]

Definition: ra144.c:1421

CODEC_CH_LAYOUTS

#define CODEC_CH_LAYOUTS(...)

Definition: codec_internal.h:379

NULL

#define NULL

Definition: coverity.c:32

sizes

static const int sizes[][2]

Definition: img2dec.c:61

RA144Context

Definition: ra144.h:40

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:481

work

must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do and instead of the variable declarations the generated *_tables h file should be included Since that will be generated in the build the path must be i e not Makefile changes To make the automatic table creation work

Definition: tablegen.txt:66

ff_lpc_end

av_cold void ff_lpc_end(LPCContext *s)

Uninitialize LPCContext.

Definition: lpc.c:365

mathops.h

RA144Context::adsp

AudioDSPContext adsp

Definition: ra144.h:42

RA144Context::lpc_tables

unsigned int lpc_tables[2][10]

Definition: ra144.h:49

celp_filters.h

find_best_vect

static void find_best_vect(float *work, const float *coefs, const int8_t cb[][BLOCKSIZE], const float *ortho1, const float *ortho2, float *data, int *idx, float *gain)

Find the best vector of a fixed codebook by applying an LPC filter to codebook entries,...

Definition: ra144enc.c:240

index

int index

Definition: gxfenc.c:90

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

Definition: undefined.txt:32

RA144Context::curr_sblock

int16_t curr_sblock[50]

The current subblock padded by the last 10 values of the previous one.

Definition: ra144.h:60

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

codec_internal.h

shift

static int shift(int a, int b)

Definition: bonk.c:261

MAX_LPC_ORDER

#define MAX_LPC_ORDER

Definition: lpc.h:37

size

int size

Definition: twinvq_data.h:10344

RA144Context::afq

AudioFrameQueue afq

Definition: ra144.h:44

ff_cb1_base

const uint16_t ff_cb1_base[128]

Definition: ra144.c:1402

CODEC_SAMPLEFMTS

#define CODEC_SAMPLEFMTS(...)

Definition: codec_internal.h:385

ORDER_METHOD_EST

#define ORDER_METHOD_EST

Definition: lpc.h:29

ff_copy_and_dup

void ff_copy_and_dup(int16_t *target, const int16_t *source, int offset)

Copy the last offset values of *source to *target.

Definition: ra144.c:1530

zero

static int zero(InterplayACMContext *s, unsigned ind, unsigned col)

Definition: interplayacm.c:121

ff_rms

unsigned int ff_rms(const int *data)

Definition: ra144.c:1636

ff_gain_val_tab

const int16_t ff_gain_val_tab[256][3]

Definition: ra144.c:28

ff_int_to_int16

void ff_int_to_int16(int16_t *out, const int *inp)

Definition: ra144.c:1613

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

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:551

RA144Context::old_energy

unsigned int old_energy

previous frame energy

Definition: ra144.h:47

ra144_encode_close

static av_cold int ra144_encode_close(AVCodecContext *avctx)

Definition: ra144enc.c:40

value

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

Definition: writing_filters.txt:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

ff_subblock_synthesis

void ff_subblock_synthesis(RA144Context *ractx, const int16_t *lpc_coefs, int cba_idx, int cb1_idx, int cb2_idx, int gval, int gain)

Definition: ra144.c:1694

avcodec.h

av_uninit

#define av_uninit(x)

Definition: attributes.h:174

ret

Definition: filter_design.txt:187

orthogonalize

static void orthogonalize(float *v, const float *u)

Orthogonalize a vector to another vector.

Definition: ra144enc.c:108

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

frame

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

Definition: filter_design.txt:265

RA144Context::adapt_cb

int16_t adapt_cb[146+2]

Adaptive codebook, its size is two units bigger to avoid a buffer overflow.

Definition: ra144.h:64

AVCodecContext

main external API structure.

Definition: avcodec.h:431

channel_layout.h

ff_t_sqrt

int ff_t_sqrt(unsigned int x)

Evaluate sqrt(x << 24).