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 "encode.h"

35 #include "internal.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 if (avctx->channels != 1) {

55 av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n",

56 avctx->channels);

57 return -1;

58 }

59 avctx->frame_size = NBLOCKS * BLOCKSIZE;

60 avctx->initial_padding = avctx->frame_size;

61 avctx->bit_rate = 8000;

62 ractx = avctx->priv_data;

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

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

65 ractx->avctx = avctx;

66 ff_audiodsp_init(&ractx->adsp);

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

68 FF_LPC_TYPE_LEVINSON);

69 if (ret < 0)

70 return ret;

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

74 return 0;

75 }

78 /**

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

80 * nearest value

81 *

82 * @param value value to quantize

83 * @param table array containing the quantization table

84 * @param size size of the quantization table

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

86 * nearest value

87 */

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

89 {

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

92 while (1) {

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

94 int error = table[index] - value;

96 if (index == low)

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

98 if (error > 0) {

99 high = index;

100 } else {

101 low = index;

102 }

103 }

104 }

105

106

107 /**

108 * Orthogonalize a vector to another vector

109 *

110 * @param v vector to orthogonalize

111 * @param u vector against which orthogonalization is performed

112 */

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

114 {

115 int i;

116 float num = 0, den = 0;

117

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

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

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

121 }

122 num /= den;

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

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

125 }

126

127

128 /**

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

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

131 *

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

133 * @param coefs coefficients of the LPC filter

134 * @param vect original vector

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

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

137 * @param data input data

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

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

140 */

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

142 const float *ortho1, const float *ortho2,

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

144 {

145 float c, g;

146 int i;

147

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

149 if (ortho1)

150 orthogonalize(work, ortho1);

151 if (ortho2)

152 orthogonalize(work, ortho2);

153 c = g = 0;

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

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

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

157 }

158 if (c <= 0) {

159 *score = 0;

160 return;

161 }

162 *gain = c / g;

163 *score = *gain * c;

164 }

165

166

167 /**

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

169 *

170 * @param vect array where vector is stored

171 * @param cb adaptive codebook

172 * @param lag lag value

173 */

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

175 {

176 int i;

177

178 cb += BUFFERSIZE - lag;

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

180 vect[i] = cb[i];

181 if (lag < BLOCKSIZE)

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

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

184 }

185

186

187 /**

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

189 * contribution from input data

190 *

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

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

193 * @param coefs coefficients of the LPC filter

194 * @param data input data

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

196 */

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

198 const float *coefs, float *data)

199 {

200 int i, av_uninit(best_vect);

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

202 float exc[BLOCKSIZE];

203

204 gain = best_score = 0;

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

206 create_adapt_vect(exc, adapt_cb, i);

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

208 if (score > best_score) {

209 best_score = score;

210 best_vect = i;

211 best_gain = gain;

212 }

213 }

214 if (!best_score)

215 return 0;

216

217 /**

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

219 * and remove its contribution from input data.

220 */

221 create_adapt_vect(exc, adapt_cb, best_vect);

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

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

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

225 return best_vect - BLOCKSIZE / 2 + 1;

226 }

227

228

229 /**

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

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

232 * and matching the results with input data.

233 *

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

235 * @param coefs coefficients of the LPC filter

236 * @param cb fixed codebook

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

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

239 * @param data input data

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

241 * returned

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

243 * returned

244 */

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

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

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

248 float *gain)

249 {

250 int i, j;

251 float g, score, best_score;

252 float vect[BLOCKSIZE];

253

254 *idx = *gain = best_score = 0;

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

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

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

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

259 if (score > best_score) {

260 best_score = score;

261 *idx = i;

262 *gain = g;

263 }

264 }

265 }

266

267

268 /**

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

270 *

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

272 * @param coefs coefficients of the LPC filter

273 * @param data input data

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

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

276 * first fixed codebook is returned

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

278 * second fixed codebook is returned

279 */

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

281 int cba_idx, int *cb1_idx, int *cb2_idx)

282 {

283 int i, ortho_cb1;

284 float gain;

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

286 float vect[BLOCKSIZE];

287

288 /**

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

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

291 */

292 if (cba_idx)

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

294

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

296 data, cb1_idx, &gain);

297

298 /**

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

300 * and remove its contribution from input data.

301 */

302 if (gain) {

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

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

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

306 if (cba_idx)

307 orthogonalize(work, cba_vect);

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

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

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

311 ortho_cb1 = 1;

312 } else

313 ortho_cb1 = 0;

314

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

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

317 }

318

319

320 /**

321 * Encode a subblock of the current frame

322 *

323 * @param ractx encoder context

324 * @param sblock_data input data of the subblock

325 * @param lpc_coefs coefficients of the LPC filter

326 * @param rms RMS of the reflection coefficients

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

328 */

329 static void ra144_encode_subblock(RA144Context *ractx,

330 const int16_t *sblock_data,

331 const int16_t *lpc_coefs, unsigned int rms,

332 PutBitContext *pb)

333 {

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

335 float coefs[LPC_ORDER];

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

337 int cba_idx, cb1_idx, cb2_idx, gain;

338 int i, n;

339 unsigned m[3];

340 float g[3];

341 float error, best_error;

342

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

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

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

346 }

347

348 /**

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

350 * input data.

351 */

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

353 LPC_ORDER);

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

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

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

357 }

358

359 /**

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

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

362 * data.

363 */

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

365

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

367 data);

368 if (cba_idx) {

369 /**

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

371 * work, see implementation of adaptive_cb_search().

372 */

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

374

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

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

377 }

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

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

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

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

382 }

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

384 LPC_ORDER);

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

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

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

388 LPC_ORDER);

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

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

391 best_error = FLT_MAX;

392 gain = 0;

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

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

395 (1/4096.0);

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

397 (1/4096.0);

398 error = 0;

399 if (cba_idx) {

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

401 (1/4096.0);

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

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

404 g[2] * cb2[i];

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

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

407 }

408 } else {

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

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

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

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

413 }

414 }

415 if (error < best_error) {

416 best_error = error;

417 gain = n;

418 }

419 }

420 put_bits(pb, 7, cba_idx);

421 put_bits(pb, 8, gain);

422 put_bits(pb, 7, cb1_idx);

423 put_bits(pb, 7, cb2_idx);

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

425 gain);

426 }

427

428

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

430 const AVFrame *frame, int *got_packet_ptr)

431 {

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

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

434 RA144Context *ractx = avctx->priv_data;

435 PutBitContext pb;

436 int32_t lpc_data[NBLOCKS * BLOCKSIZE];

437 int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER];

438 int shift[LPC_ORDER];

439 int16_t block_coefs[NBLOCKS][LPC_ORDER];

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

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

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

443 int energy = 0;

444 int i, idx, ret;

445

446 if (ractx->last_frame)

447 return 0;

448

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

450 return ret;

451

452 /**

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

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

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

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

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

458 */

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

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

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

462 }

463 if (frame) {

464 int j;

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

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

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

468 }

469 }

470 if (i < NBLOCKS * BLOCKSIZE)

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

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

473 32)];

474

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

476 LPC_ORDER, 16, lpc_coefs, shift, FF_LPC_TYPE_LEVINSON,

477 0, ORDER_METHOD_EST, 0, 12, 0);

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

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

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

481

482 /**

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

484 * expansion of the LPC filter.

485 */

486

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

488 /**

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

490 */

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

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

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

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

495 }

496 }

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

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

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

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

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

502 }

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

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

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

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

507 energy <= ractx->old_energy,

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

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

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

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

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

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

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

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

516 flush_put_bits(&pb);

517 ractx->old_energy = energy;

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

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

520

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

522 i = 0;

523 if (frame) {

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

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

526

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

528 return ret;

529 } else

530 ractx->last_frame = 1;

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

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

533

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

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

536 &avpkt->duration);

537

538 *got_packet_ptr = 1;

539 return 0;

540 }

541

542

543 const AVCodec ff_ra_144_encoder = {

544 .name = "real_144",

545 .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),

546 .type = AVMEDIA_TYPE_AUDIO,

547 .id = AV_CODEC_ID_RA_144,

548 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

549 AV_CODEC_CAP_SMALL_LAST_FRAME,

550 .priv_data_size = sizeof(RA144Context),

551 .init = ra144_encode_init,

552 .encode2 = ra144_encode_frame,

553 .close = ra144_encode_close,

554 .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,

555 AV_SAMPLE_FMT_NONE },

556 .supported_samplerates = (const int[]){ 8000, 0 },

557 .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, 0 },

558 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

559 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1012

AVCodec

AVCodec.

Definition: codec.h:202

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

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

Definition: internal.h:42

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

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

ff_af_queue_close

void ff_af_queue_close(AudioFrameQueue *afq)

Close AudioFrameQueue.

Definition: audio_frame_queue.c:36

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

Definition: cbs_h2645.c:264

sample_fmts

static enum AVSampleFormat sample_fmts[]

Definition: adpcmenc.c:948

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

AV_CH_LAYOUT_MONO

#define AV_CH_LAYOUT_MONO

Definition: channel_layout.h:90

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

ff_af_queue_init

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

Initialize AudioFrameQueue.

Definition: audio_frame_queue.c:28

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

AV_CODEC_ID_RA_144

@ AV_CODEC_ID_RA_144

Definition: codec_id.h:410

AVFrame

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

Definition: frame.h:317

put_bits

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

put n times val bit

Definition: j2kenc.c:220

index

fg index

Definition: ffmpeg_filter.c:167

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

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

encode.h

table

static const uint16_t table[]

Definition: prosumer.c:206

data

const char data[16]

Definition: mxf.c:143

ff_audiodsp_init

av_cold void ff_audiodsp_init(AudioDSPContext *c)

Definition: audiodsp.c:106

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

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

init

static int init

Definition: av_tx.c:47

ff_ra_144_encoder

const AVCodec ff_ra_144_encoder

Definition: ra144enc.c:543

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

RA144Context::buffer_a

int16_t buffer_a[FFALIGN(BLOCKSIZE, 16)]

Definition: ra144.h:66

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

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

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_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_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

const char * g

Definition: vf_curves.c:117

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

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

RA144Context::curr_block

int16_t curr_block[NBLOCKS *BLOCKSIZE]

Definition: ra144.h:57

PutBitContext

Definition: put_bits.h:49

LPC_ORDER

#define LPC_ORDER

Definition: g723_1.h:40

if(ret)

Definition: filter_design.txt:179

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

NULL

#define NULL

Definition: coverity.c:32

sizes

static const int sizes[][2]

Definition: img2dec.c:53

RA144Context

Definition: ra144.h:40

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:433

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

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

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

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

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

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

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

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

Definition: internal.h:117

MAX_LPC_ORDER

#define MAX_LPC_ORDER

Definition: lpc.h:38

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:59

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

ORDER_METHOD_EST

#define ORDER_METHOD_EST

Definition: lpc.h:30

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

ff_rms

unsigned int ff_rms(const int *data)

Definition: ra144.c:1636

ff_lpc_end

av_cold void ff_lpc_end(LPCContext *s)

Uninitialize LPCContext.

Definition: lpc.c:323

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:993

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

AVPacket::pts

int64_t pts

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

Definition: packet.h:366

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

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:58

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

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

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

ret

Definition: filter_design.txt:187

orthogonalize

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

Orthogonalize a vector to another vector.

Definition: ra144enc.c:113

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

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

channel_layout.h

ff_t_sqrt

int ff_t_sqrt(unsigned int x)

Evaluate sqrt(x << 24).