FFmpeg: libavcodec/g726.c Source File

FFmpeg

[フレーム]

libavcodec

g726.c

Go to the documentation of this file.

1 /*

2 * G.726 ADPCM audio codec

4 *

5 * This is a very straightforward rendition of the G.726

6 * Section 4 "Computational Details".

7 *

8 * This file is part of FFmpeg.

9 *

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

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

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

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

14 *

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

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

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

18 * Lesser General Public License for more details.

19 *

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

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

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

23 */

25 #include "config_components.h"

27 #include <limits.h>

29 #include "libavutil/channel_layout.h"

30 #include "libavutil/opt.h"

31 #include "avcodec.h"

32 #include "codec_internal.h"

33 #include "encode.h"

34 #include "internal.h"

35 #include "get_bits.h"

36 #include "put_bits.h"

38 /**

39 * G.726 11-bit float.

40 * G.726 Standard uses rather odd 11-bit floating point arithmetic for

41 * numerous occasions. It's a mystery to me why they did it this way

42 * instead of simply using 32-bit integer arithmetic.

43 */

44 typedef struct Float11 {

45 uint8_t sign; /**< 1 bit sign */

46 uint8_t exp; /**< 4 bits exponent */

47 uint8_t mant; /**< 6 bits mantissa */

48 } Float11;

50 static inline Float11* i2f(int i, Float11* f)

51 {

52 f->sign = (i < 0);

53 if (f->sign)

54 i = -i;

55 f->exp = av_log2_16bit(i) + !!i;

56 f->mant = i? (i<<6) >> f->exp : 1<<5;

57 return f;

58 }

60 static inline int16_t mult(Float11* f1, Float11* f2)

61 {

62 int res, exp;

64 exp = f1->exp + f2->exp;

65 res = (((f1->mant * f2->mant) + 0x30) >> 4);

66 res = exp > 19 ? res << (exp - 19) : res >> (19 - exp);

67 return (f1->sign ^ f2->sign) ? -res : res;

68 }

70 static inline int sgn(int value)

71 {

72 return (value < 0) ? -1 : 1;

73 }

75 typedef struct G726Tables {

76 const int* quant; /**< quantization table */

77 const int16_t* iquant; /**< inverse quantization table */

78 const int16_t* W; /**< special table #1 ;-) */

79 const uint8_t* F; /**< special table #2 */

80 } G726Tables;

82 typedef struct G726Context {

83 AVClass *class;

84 G726Tables tbls; /**< static tables needed for computation */

86 Float11 sr[2]; /**< prev. reconstructed samples */

87 Float11 dq[6]; /**< prev. difference */

88 int a[2]; /**< second order predictor coeffs */

89 int b[6]; /**< sixth order predictor coeffs */

90 int pk[2]; /**< signs of prev. 2 sez + dq */

92 int ap; /**< scale factor control */

93 int yu; /**< fast scale factor */

94 int yl; /**< slow scale factor */

95 int dms; /**< short average magnitude of F[i] */

96 int dml; /**< long average magnitude of F[i] */

97 int td; /**< tone detect */

99 int se; /**< estimated signal for the next iteration */

100 int sez; /**< estimated second order prediction */

101 int y; /**< quantizer scaling factor for the next iteration */

102 int code_size;

103 int little_endian; /**< little-endian bitstream as used in aiff and Sun AU */

104 } G726Context;

105

106 static const int quant_tbl16[] = /**< 16kbit/s 2 bits per sample */

107 { 260, INT_MAX };

108 static const int16_t iquant_tbl16[] =

109 { 116, 365, 365, 116 };

110 static const int16_t W_tbl16[] =

111 { -22, 439, 439, -22 };

112 static const uint8_t F_tbl16[] =

113 { 0, 7, 7, 0 };

114

115 static const int quant_tbl24[] = /**< 24kbit/s 3 bits per sample */

116 { 7, 217, 330, INT_MAX };

117 static const int16_t iquant_tbl24[] =

118 { INT16_MIN, 135, 273, 373, 373, 273, 135, INT16_MIN };

119 static const int16_t W_tbl24[] =

120 { -4, 30, 137, 582, 582, 137, 30, -4 };

121 static const uint8_t F_tbl24[] =

122 { 0, 1, 2, 7, 7, 2, 1, 0 };

123

124 static const int quant_tbl32[] = /**< 32kbit/s 4 bits per sample */

125 { -125, 79, 177, 245, 299, 348, 399, INT_MAX };

126 static const int16_t iquant_tbl32[] =

127 { INT16_MIN, 4, 135, 213, 273, 323, 373, 425,

128 425, 373, 323, 273, 213, 135, 4, INT16_MIN };

129 static const int16_t W_tbl32[] =

130 { -12, 18, 41, 64, 112, 198, 355, 1122,

131 1122, 355, 198, 112, 64, 41, 18, -12};

132 static const uint8_t F_tbl32[] =

133 { 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 };

134

135 static const int quant_tbl40[] = /**< 40kbit/s 5 bits per sample */

136 { -122, -16, 67, 138, 197, 249, 297, 338,

137 377, 412, 444, 474, 501, 527, 552, INT_MAX };

138 static const int16_t iquant_tbl40[] =

139 { INT16_MIN, -66, 28, 104, 169, 224, 274, 318,

140 358, 395, 429, 459, 488, 514, 539, 566,

141 566, 539, 514, 488, 459, 429, 395, 358,

142 318, 274, 224, 169, 104, 28, -66, INT16_MIN };

143 static const int16_t W_tbl40[] =

144 { 14, 14, 24, 39, 40, 41, 58, 100,

145 141, 179, 219, 280, 358, 440, 529, 696,

146 696, 529, 440, 358, 280, 219, 179, 141,

147 100, 58, 41, 40, 39, 24, 14, 14 };

148 static const uint8_t F_tbl40[] =

149 { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6,

150 6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };

151

152 static const G726Tables G726Tables_pool[] =

153 {{ quant_tbl16, iquant_tbl16, W_tbl16, F_tbl16 },

154 { quant_tbl24, iquant_tbl24, W_tbl24, F_tbl24 },

155 { quant_tbl32, iquant_tbl32, W_tbl32, F_tbl32 },

156 { quant_tbl40, iquant_tbl40, W_tbl40, F_tbl40 }};

157

158

159 /**

160 * Paragraph 4.2.2 page 18: Adaptive quantizer.

161 */

162 static inline uint8_t quant(G726Context* c, int d)

163 {

164 int sign, exp, i, dln;

165

166 sign = i = 0;

167 if (d < 0) {

168 sign = 1;

169 d = -d;

170 }

171 exp = av_log2_16bit(d);

172 dln = ((exp<<7) + (((d<<7)>>exp)&0x7f)) - (c->y>>2);

173

174 while (c->tbls.quant[i] < INT_MAX && c->tbls.quant[i] < dln)

175 ++i;

176

177 if (sign)

178 i = ~i;

179 if (c->code_size != 2 && i == 0) /* I'm not sure this is a good idea */

180 i = 0xff;

181

182 return i;

183 }

184

185 /**

186 * Paragraph 4.2.3 page 22: Inverse adaptive quantizer.

187 */

188 static inline int16_t inverse_quant(G726Context* c, int i)

189 {

190 int dql, dex, dqt;

191

192 dql = c->tbls.iquant[i] + (c->y >> 2);

193 dex = (dql>>7) & 0xf; /* 4-bit exponent */

194 dqt = (1<<7) + (dql & 0x7f); /* log2 -> linear */

195 return (dql < 0) ? 0 : ((dqt<<dex) >> 7);

196 }

197

198 static int16_t g726_decode(G726Context* c, int I)

199 {

200 int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0;

201 Float11 f;

202 int I_sig= I >> (c->code_size - 1);

203

204 dq = inverse_quant(c, I);

205

206 /* Transition detect */

207 ylint = (c->yl >> 15);

208 ylfrac = (c->yl >> 10) & 0x1f;

209 thr2 = (ylint > 9) ? 0x1f << 10 : (0x20 + ylfrac) << ylint;

210 tr= (c->td == 1 && dq > ((3*thr2)>>2));

211

212 if (I_sig) /* get the sign */

213 dq = -dq;

214 re_signal = (int16_t)(c->se + dq);

215

216 /* Update second order predictor coefficient A2 and A1 */

217 pk0 = (c->sez + dq) ? sgn(c->sez + dq) : 0;

218 dq0 = dq ? sgn(dq) : 0;

219 if (tr) {

220 c->a[0] = 0;

221 c->a[1] = 0;

222 for (i=0; i<6; i++)

223 c->b[i] = 0;

224 } else {

225 /* This is a bit crazy, but it really is +255 not +256 */

226 fa1 = av_clip_intp2((-c->a[0]*c->pk[0]*pk0)>>5, 8);

227

228 c->a[1] += 128*pk0*c->pk[1] + fa1 - (c->a[1]>>7);

229 c->a[1] = av_clip(c->a[1], -12288, 12288);

230 c->a[0] += 64*3*pk0*c->pk[0] - (c->a[0] >> 8);

231 c->a[0] = av_clip(c->a[0], -(15360 - c->a[1]), 15360 - c->a[1]);

232

233 for (i=0; i<6; i++)

234 c->b[i] += 128*dq0*sgn(-c->dq[i].sign) - (c->b[i]>>8);

235 }

236

237 /* Update Dq and Sr and Pk */

238 c->pk[1] = c->pk[0];

239 c->pk[0] = pk0 ? pk0 : 1;

240 c->sr[1] = c->sr[0];

241 i2f(re_signal, &c->sr[0]);

242 for (i=5; i>0; i--)

243 c->dq[i] = c->dq[i-1];

244 i2f(dq, &c->dq[0]);

245 c->dq[0].sign = I_sig; /* Isn't it crazy ?!?! */

246

247 c->td = c->a[1] < -11776;

248

249 /* Update Ap */

250 c->dms += (c->tbls.F[I]<<4) + ((- c->dms) >> 5);

251 c->dml += (c->tbls.F[I]<<4) + ((- c->dml) >> 7);

252 if (tr)

253 c->ap = 256;

254 else {

255 c->ap += (-c->ap) >> 4;

256 if (c->y <= 1535 || c->td || abs((c->dms << 2) - c->dml) >= (c->dml >> 3))

257 c->ap += 0x20;

258 }

259

260 /* Update Yu and Yl */

261 c->yu = av_clip(c->y + c->tbls.W[I] + ((-c->y)>>5), 544, 5120);

262 c->yl += c->yu + ((-c->yl)>>6);

263

264 /* Next iteration for Y */

265 al = (c->ap >= 256) ? 1<<6 : c->ap >> 2;

266 c->y = (c->yl + (c->yu - (c->yl>>6))*al) >> 6;

267

268 /* Next iteration for SE and SEZ */

269 c->se = 0;

270 for (i=0; i<6; i++)

271 c->se += mult(i2f(c->b[i] >> 2, &f), &c->dq[i]);

272 c->sez = c->se >> 1;

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

274 c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]);

275 c->se >>= 1;

276

277 return av_clip(re_signal * 4, -0xffff, 0xffff);

278 }

279

280 static av_cold int g726_reset(G726Context *c)

281 {

282 int i;

283

284 c->tbls = G726Tables_pool[c->code_size - 2];

285 for (i=0; i<2; i++) {

286 c->sr[i].mant = 1<<5;

287 c->pk[i] = 1;

288 }

289 for (i=0; i<6; i++) {

290 c->dq[i].mant = 1<<5;

291 }

292 c->yu = 544;

293 c->yl = 34816;

294

295 c->y = 544;

296

297 return 0;

298 }

299

300 #if CONFIG_ADPCM_G726_ENCODER || CONFIG_ADPCM_G726LE_ENCODER

301 static int16_t g726_encode(G726Context* c, int16_t sig)

302 {

303 uint8_t i;

304

305 i = av_mod_uintp2(quant(c, sig/4 - c->se), c->code_size);

306 g726_decode(c, i);

307 return i;

308 }

309

310 /* Interfacing to the libavcodec */

311

312 static av_cold int g726_encode_init(AVCodecContext *avctx)

313 {

314 G726Context* c = avctx->priv_data;

315

316 c->little_endian = !strcmp(avctx->codec->name, "g726le");

317

318 if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&

319 avctx->sample_rate != 8000) {

320 av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not "

321 "allowed when the compliance level is higher than unofficial. "

322 "Resample or reduce the compliance level.\n");

323 return AVERROR(EINVAL);

324 }

325 if (avctx->sample_rate <= 0) {

326 av_log(avctx, AV_LOG_ERROR, "Invalid sample rate %d\n",

327 avctx->sample_rate);

328 return AVERROR(EINVAL);

329 }

330

331 if (avctx->ch_layout.nb_channels != 1) {

332 av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n");

333 return AVERROR(EINVAL);

334 }

335

336 if (avctx->bit_rate)

337 c->code_size = (avctx->bit_rate + avctx->sample_rate/2) / avctx->sample_rate;

338

339 c->code_size = av_clip(c->code_size, 2, 5);

340 avctx->bit_rate = c->code_size * avctx->sample_rate;

341 avctx->bits_per_coded_sample = c->code_size;

342

343 g726_reset(c);

344

345 /* select a frame size that will end on a byte boundary and have a size of

346 approximately 1024 bytes */

347 avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2];

348

349 return 0;

350 }

351

352 static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

353 const AVFrame *frame, int *got_packet_ptr)

354 {

355 G726Context *c = avctx->priv_data;

356 const int16_t *samples = (const int16_t *)frame->data[0];

357 PutBitContext pb;

358 int i, ret, out_size;

359

360 out_size = (frame->nb_samples * c->code_size + 7) / 8;

361 if ((ret = ff_get_encode_buffer(avctx, avpkt, out_size, 0)) < 0)

362 return ret;

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

364

365 for (i = 0; i < frame->nb_samples; i++)

366 if (c->little_endian) {

367 put_bits_le(&pb, c->code_size, g726_encode(c, *samples++));

368 } else {

369 put_bits(&pb, c->code_size, g726_encode(c, *samples++));

370 }

371

372 if (c->little_endian) {

373 flush_put_bits_le(&pb);

374 } else {

375 flush_put_bits(&pb);

376 }

377

378 *got_packet_ptr = 1;

379 return 0;

380 }

381

382 #define OFFSET(x) offsetof(G726Context, x)

383 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

384 static const AVOption options[] = {

385 { "code_size", "Bits per code", OFFSET(code_size), AV_OPT_TYPE_INT, { .i64 = 4 }, 2, 5, AE },

386 { NULL },

387 };

388

389 static const AVClass g726_class = {

390 .class_name = "g726",

391 .item_name = av_default_item_name,

392 .option = options,

393 .version = LIBAVUTIL_VERSION_INT,

394 };

395

396 static const FFCodecDefault defaults[] = {

397 { "b", "0" },

398 { NULL },

399 };

400 #endif

401

402 #if CONFIG_ADPCM_G726_ENCODER

403 const FFCodec ff_adpcm_g726_encoder = {

404 .p.name = "g726",

405 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),

406 .p.type = AVMEDIA_TYPE_AUDIO,

407 .p.id = AV_CODEC_ID_ADPCM_G726,

408 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME,

409 .priv_data_size = sizeof(G726Context),

410 .init = g726_encode_init,

411 FF_CODEC_ENCODE_CB(g726_encode_frame),

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

413 AV_SAMPLE_FMT_NONE },

414 .p.priv_class = &g726_class,

415 .defaults = defaults,

416 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

417 };

418 #endif

419

420 #if CONFIG_ADPCM_G726LE_ENCODER

421 const FFCodec ff_adpcm_g726le_encoder = {

422 .p.name = "g726le",

423 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 little endian ADPCM (\"right-justified\")"),

424 .p.type = AVMEDIA_TYPE_AUDIO,

425 .p.id = AV_CODEC_ID_ADPCM_G726LE,

426 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME,

427 .priv_data_size = sizeof(G726Context),

428 .init = g726_encode_init,

429 FF_CODEC_ENCODE_CB(g726_encode_frame),

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

431 AV_SAMPLE_FMT_NONE },

432 .p.priv_class = &g726_class,

433 .defaults = defaults,

434 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

435 };

436 #endif

437

438 #if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER

439 static av_cold int g726_decode_init(AVCodecContext *avctx)

440 {

441 G726Context* c = avctx->priv_data;

442

443 if (avctx->ch_layout.nb_channels > 1){

444 avpriv_request_sample(avctx, "Decoding more than one channel");

445 return AVERROR_PATCHWELCOME;

446 }

447 av_channel_layout_uninit(&avctx->ch_layout);

448 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

449

450 c->little_endian = !strcmp(avctx->codec->name, "g726le");

451

452 c->code_size = avctx->bits_per_coded_sample;

453 if (c->code_size < 2 || c->code_size > 5) {

454 av_log(avctx, AV_LOG_ERROR, "Invalid number of bits %d\n", c->code_size);

455 return AVERROR(EINVAL);

456 }

457 g726_reset(c);

458

459 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

460

461 return 0;

462 }

463

464 static int g726_decode_frame(AVCodecContext *avctx, AVFrame *frame,

465 int *got_frame_ptr, AVPacket *avpkt)

466 {

467 const uint8_t *buf = avpkt->data;

468 int buf_size = avpkt->size;

469 G726Context *c = avctx->priv_data;

470 int16_t *samples;

471 GetBitContext gb;

472 int out_samples, ret;

473

474 out_samples = buf_size * 8 / c->code_size;

475

476 /* get output buffer */

477 frame->nb_samples = out_samples;

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

479 return ret;

480 samples = (int16_t *)frame->data[0];

481

482 init_get_bits(&gb, buf, buf_size * 8);

483

484 while (out_samples--)

485 *samples++ = g726_decode(c, c->little_endian ?

486 get_bits_le(&gb, c->code_size) :

487 get_bits(&gb, c->code_size));

488

489 if (get_bits_left(&gb) > 0)

490 av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");

491

492 *got_frame_ptr = 1;

493

494 return buf_size;

495 }

496

497 static void g726_decode_flush(AVCodecContext *avctx)

498 {

499 G726Context *c = avctx->priv_data;

500 g726_reset(c);

501 }

502 #endif

503

504 #if CONFIG_ADPCM_G726_DECODER

505 const FFCodec ff_adpcm_g726_decoder = {

506 .p.name = "g726",

507 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),

508 .p.type = AVMEDIA_TYPE_AUDIO,

509 .p.id = AV_CODEC_ID_ADPCM_G726,

510 .priv_data_size = sizeof(G726Context),

511 .init = g726_decode_init,

512 FF_CODEC_DECODE_CB(g726_decode_frame),

513 .flush = g726_decode_flush,

514 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

515 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

516 };

517 #endif

518

519 #if CONFIG_ADPCM_G726LE_DECODER

520 const FFCodec ff_adpcm_g726le_decoder = {

521 .p.name = "g726le",

522 .p.type = AVMEDIA_TYPE_AUDIO,

523 .p.id = AV_CODEC_ID_ADPCM_G726LE,

524 .priv_data_size = sizeof(G726Context),

525 .init = g726_decode_init,

526 FF_CODEC_DECODE_CB(g726_decode_frame),

527 .flush = g726_decode_flush,

528 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

529 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM little-endian"),

530 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

531 };

532 #endif

sgn

static int sgn(int value)

Definition: g726.c:70

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1026

G726Context

Definition: g726.c:82

G726Context::tbls

G726Tables tbls

static tables needed for computation

Definition: g726.c:84

av_clip

#define av_clip

Definition: common.h:95

W_tbl16

static const int16_t W_tbl16[]

Definition: g726.c:110

iquant_tbl32

static const int16_t iquant_tbl32[]

Definition: g726.c:126

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:839

AVERROR

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

opt.h

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:998

Float11::mant

uint8_t mant

6 bits mantissa

Definition: g726.c:47

G726Tables::F

const uint8_t * F

special table #2

Definition: g726.c:79

G726Tables

Definition: g726.c:75

W_tbl32

static const int16_t W_tbl32[]

Definition: g726.c:129

G726Context::dml

int dml

long average magnitude of F[i]

Definition: g726.c:96

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

G726Context::td

int td

tone detect

Definition: g726.c:97

av_mod_uintp2

#define av_mod_uintp2

Definition: common.h:122

out_size

int out_size

Definition: movenc.c:55

av_log2_16bit

int av_log2_16bit(unsigned v)

Definition: intmath.c:31

AVFrame

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

Definition: frame.h:325

put_bits

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

put n times val bit

Definition: j2kenc.c:221

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

iquant_tbl40

static const int16_t iquant_tbl40[]

Definition: g726.c:138

AVOption

AVOption.

Definition: opt.h:251

encode.h

AV_CHANNEL_LAYOUT_MONO

#define AV_CHANNEL_LAYOUT_MONO

Definition: channel_layout.h:353

FFCodec

Definition: codec_internal.h:112

G726Context::yl

int yl

slow scale factor

Definition: g726.c:94

iquant_tbl16

static const int16_t iquant_tbl16[]

Definition: g726.c:108

G726Tables::quant

const int * quant

quantization table

Definition: g726.c:76

quant_tbl24

static const int quant_tbl24[]

24kbit/s 3 bits per sample

Definition: g726.c:115

quant_tbl16

static const int quant_tbl16[]

16kbit/s 2 bits per sample

Definition: g726.c:106

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:300

F_tbl40

static const uint8_t F_tbl40[]

Definition: g726.c:148

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:649

FF_COMPLIANCE_UNOFFICIAL

#define FF_COMPLIANCE_UNOFFICIAL

Allow unofficial extensions.

Definition: avcodec.h:1304

init

static int init

Definition: av_tx.c:47

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:379

FFCodecDefault

Definition: codec_internal.h:82

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:398

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:2056

g726_reset

static av_cold int g726_reset(G726Context *c)

Definition: g726.c:280

GetBitContext

Definition: get_bits.h:61

g726_decode

static int16_t g726_decode(G726Context *c, int I)

Definition: g726.c:198

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:263

G726Context::a

int a[2]

second order predictor coeffs

Definition: g726.c:88

mult

static int16_t mult(Float11 *f1, Float11 *f2)

Definition: g726.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

G726Context::yu

int yu

fast scale factor

Definition: g726.c:93

av_cold

#define av_cold

Definition: attributes.h:90

G726Context::little_endian

int little_endian

little-endian bitstream as used in aiff and Sun AU

Definition: g726.c:103

G726Context::dq

Float11 dq[6]

prev.

Definition: g726.c:87

AV_CODEC_ID_ADPCM_G726

@ AV_CODEC_ID_ADPCM_G726

Definition: codec_id.h:368

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

ff_adpcm_g726le_decoder

const FFCodec ff_adpcm_g726le_decoder

quant_tbl40

static const int quant_tbl40[]

40kbit/s 5 bits per sample

Definition: g726.c:135

quant

static uint8_t quant(G726Context *c, int d)

Paragraph 4.2.2 page 18: Adaptive quantizer.

Definition: g726.c:162

get_bits_le

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

Definition: get_bits.h:420

quant_tbl32

static const int quant_tbl32[]

32kbit/s 4 bits per sample

Definition: g726.c:124

get_bits.h

limits.h

W_tbl24

static const int16_t W_tbl24[]

Definition: g726.c:119

F_tbl16

static const uint8_t F_tbl16[]

Definition: g726.c:112

PutBitContext

Definition: put_bits.h:50

G726Context::dms

int dms

short average magnitude of F[i]

Definition: g726.c:95

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

av_clip_intp2

#define av_clip_intp2

Definition: common.h:116

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:439

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

G726Tables_pool

static const G726Tables G726Tables_pool[]

Definition: g726.c:152

G726Context::sez

int sez

estimated second order prediction

Definition: g726.c:100

Float11

G.726 11-bit float.

Definition: g726.c:44

flush_put_bits_le

static void flush_put_bits_le(PutBitContext *s)

Definition: put_bits.h:164

abs

#define abs(x)

Definition: cuda_runtime.h:35

#define AE

Definition: alacenc.c:636

W_tbl40

static const int16_t W_tbl40[]

Definition: g726.c:143

iquant_tbl24

static const int16_t iquant_tbl24[]

Definition: g726.c:117

exp

int8_t exp

Definition: eval.c:72

F_tbl32

static const uint8_t F_tbl32[]

Definition: g726.c:132

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

av_channel_layout_uninit

void av_channel_layout_uninit(AVChannelLayout *channel_layout)

Free any allocated data in the channel layout and reset the channel count to 0.

Definition: channel_layout.c:630

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

options

const OptionDef options[]

G726Context::y

int y

quantizer scaling factor for the next iteration

Definition: g726.c:101

Definition: af_crystalizer.c:122

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1403

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

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

defaults

static const FFCodecDefault defaults[]

Definition: amfenc_h264.c:362

i2f

static Float11 * i2f(int i, Float11 *f)

Definition: g726.c:50

AVChannelLayout

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

Definition: channel_layout.h:290

codec_internal.h

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1014

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

G726Context::code_size

int code_size

Definition: g726.c:102

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:1441

G726Context::ap

int ap

scale factor control

Definition: g726.c:92

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

Definition: cbs_h2645.c:269

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

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

Definition: cbs_av1.c:664

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

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: codec_internal.h:31

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

ff_adpcm_g726le_encoder

const FFCodec ff_adpcm_g726le_encoder

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

avcodec.h

F_tbl24

static const uint8_t F_tbl24[]

Definition: g726.c:121

ret

Definition: filter_design.txt:187

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

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

AVCodecContext::strict_std_compliance

int strict_std_compliance

strictly follow the standard (MPEG-4, ...).

Definition: avcodec.h:1300

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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro

AVCodecContext

main external API structure.

Definition: avcodec.h:389

AV_CODEC_ID_ADPCM_G726LE

@ AV_CODEC_ID_ADPCM_G726LE

Definition: codec_id.h:392

channel_layout.h

ff_get_encode_buffer

int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)

Get a buffer for a packet.

Definition: encode.c:79

AV_OPT_TYPE_INT