FFmpeg: libavcodec/dpcm.c Source File

FFmpeg

[フレーム]

libavcodec

dpcm.c

Go to the documentation of this file.

1 /*

2 * Assorted DPCM codecs

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 * Assorted DPCM (differential pulse code modulation) audio codecs

25 * by Mike Melanson (melanson@pcisys.net)

26 * Xan DPCM decoder by Mario Brito (mbrito@student.dei.uc.pt)

27 * for more information on the specific data formats, visit:

28 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html

29 * SOL DPCMs implemented by Konstantin Shishkov

30 *

31 * Note about using the Xan DPCM decoder: Xan DPCM is used in AVI files

32 * found in the Wing Commander IV computer game. These AVI files contain

33 * WAVEFORMAT headers which report the audio format as 0x01: raw PCM.

34 * Clearly incorrect. To detect Xan DPCM, you will probably have to

35 * special-case your AVI demuxer to use Xan DPCM if the file uses 'Xxan'

36 * (Xan video) for its video codec. Alternately, such AVI files also contain

37 * the fourcc 'Axan' in the 'auds' chunk of the AVI header.

38 */

40 #include "avcodec.h"

41 #include "bytestream.h"

42 #include "codec_internal.h"

43 #include "decode.h"

44 #include "mathops.h"

46 #include "libavutil/attributes.h"

48 typedef struct DPCMContext {

49 int16_t array[256];

50 int sample[2]; ///< previous sample (for SOL_DPCM and WADY_DPCM)

51 int scale; ///< scale for WADY_DPCM

52 const int8_t *sol_table; ///< delta table for SOL_DPCM

53 } DPCMContext;

55 static const int32_t derf_steps[96] = {

56 0, 1, 2, 3, 4, 5, 6, 7,

57 8, 9, 10, 11, 12, 13, 14, 16,

58 17, 19, 21, 23, 25, 28, 31, 34,

59 37, 41, 45, 50, 55, 60, 66, 73,

60 80, 88, 97, 107, 118, 130, 143, 157,

61 173, 190, 209, 230, 253, 279, 307, 337,

62 371, 408, 449, 494, 544, 598, 658, 724,

63 796, 876, 963, 1060, 1166, 1282, 1411, 1552,

64 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,

65 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132,

66 7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289,

67 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,

68 };

70 static const int16_t interplay_delta_table[] = {

71 0, 1, 2, 3, 4, 5, 6, 7,

72 8, 9, 10, 11, 12, 13, 14, 15,

73 16, 17, 18, 19, 20, 21, 22, 23,

74 24, 25, 26, 27, 28, 29, 30, 31,

75 32, 33, 34, 35, 36, 37, 38, 39,

76 40, 41, 42, 43, 47, 51, 56, 61,

77 66, 72, 79, 86, 94, 102, 112, 122,

78 133, 145, 158, 173, 189, 206, 225, 245,

79 267, 292, 318, 348, 379, 414, 452, 493,

80 538, 587, 640, 699, 763, 832, 908, 991,

81 1081, 1180, 1288, 1405, 1534, 1673, 1826, 1993,

82 2175, 2373, 2590, 2826, 3084, 3365, 3672, 4008,

83 4373, 4772, 5208, 5683, 6202, 6767, 7385, 8059,

84 8794, 9597, 10472, 11428, 12471, 13609, 14851, 16206,

85 17685, 19298, 21060, 22981, 25078, 27367, 29864, 32589,

86 -29973, -26728, -23186, -19322, -15105, -10503, -5481, -1,

87 1, 1, 5481, 10503, 15105, 19322, 23186, 26728,

88 29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,

89 -17685, -16206, -14851, -13609, -12471, -11428, -10472, -9597,

90 -8794, -8059, -7385, -6767, -6202, -5683, -5208, -4772,

91 -4373, -4008, -3672, -3365, -3084, -2826, -2590, -2373,

92 -2175, -1993, -1826, -1673, -1534, -1405, -1288, -1180,

93 -1081, -991, -908, -832, -763, -699, -640, -587,

94 -538, -493, -452, -414, -379, -348, -318, -292,

95 -267, -245, -225, -206, -189, -173, -158, -145,

96 -133, -122, -112, -102, -94, -86, -79, -72,

97 -66, -61, -56, -51, -47, -43, -42, -41,

98 -40, -39, -38, -37, -36, -35, -34, -33,

99 -32, -31, -30, -29, -28, -27, -26, -25,

100 -24, -23, -22, -21, -20, -19, -18, -17,

101 -16, -15, -14, -13, -12, -11, -10, -9,

102 -8, -7, -6, -5, -4, -3, -2, -1

103

104 };

105

106 static const int8_t sol_table_old[16] = {

107 0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,

108 -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1, 0x0

109 };

110

111 static const int8_t sol_table_new[16] = {

112 0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,

113 0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15

114 };

115

116 static const int16_t sol_table_16[128] = {

117 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,

118 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,

119 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,

120 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,

121 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,

122 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,

123 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,

124 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,

125 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,

126 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,

127 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,

128 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,

129 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000

130 };

131

132 static const int16_t wady_table[128] = {

133 0, 2, 4, 6, 8, 10, 12, 15,

134 18, 21, 24, 28, 32, 36, 40, 44,

135 49, 54, 59, 64, 70, 76, 82, 88,

136 95, 102, 109, 116, 124, 132, 140, 148,

137 160, 170, 180, 190, 200, 210, 220, 230,

138 240, 255, 270, 285, 300, 320, 340, 360,

139 380, 400, 425, 450, 475, 500, 525, 550,

140 580, 610, 650, 700, 750, 800, 900, 1000,

141 -0, -2, -4, -6, -8, -10, -12, -15,

142 -18, -21, -24, -28, -32, -36, -40, -44,

143 -49, -54, -59, -64, -70, -76, -82, -88,

144 -95, -102,-109,-116,-124,-132,-140,-148,

145 -160,-170,-180,-190,-200,-210,-220,-230,

146 -240,-255,-270,-285,-300,-320,-340,-360,

147 -380,-400,-425,-450,-475,-500,-525,-550,

148 -580,-610,-650,-700,-750,-800,-900,-1000,

149 };

150

151 static av_cold int dpcm_decode_init(AVCodecContext *avctx)

152 {

153 DPCMContext *s = avctx->priv_data;

154 int i;

155

156 if (avctx->ch_layout.nb_channels < 1 || avctx->ch_layout.nb_channels > 2) {

157 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");

158 return AVERROR(EINVAL);

159 }

160

161 s->sample[0] = s->sample[1] = 0;

162

163 switch (avctx->codec->id) {

164

165 case AV_CODEC_ID_ROQ_DPCM:

166 /* initialize square table */

167 for (i = 0; i < 128; i++) {

168 int16_t square = i * i;

169 s->array[i ] = square;

170 s->array[i + 128] = -square;

171 }

172 break;

173

174 case AV_CODEC_ID_SOL_DPCM:

175 switch(avctx->codec_tag){

176 case 1:

177 s->sol_table = sol_table_old;

178 s->sample[0] = s->sample[1] = 0x80;

179 break;

180 case 2:

181 s->sol_table = sol_table_new;

182 s->sample[0] = s->sample[1] = 0x80;

183 break;

184 case 3:

185 break;

186 default:

187 av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");

188 return -1;

189 }

190 break;

191

192 case AV_CODEC_ID_SDX2_DPCM:

193 for (i = -128; i < 128; i++) {

194 int16_t square = i * i * 2;

195 s->array[i+128] = i < 0 ? -square: square;

196 }

197 break;

198

199 case AV_CODEC_ID_CBD2_DPCM:

200 for (i = -128; i < 128; i++) {

201 int16_t cube = (i * i * i) / 64;

202 s->array[i+128] = cube;

203 }

204 break;

205

206 case AV_CODEC_ID_GREMLIN_DPCM: {

207 int delta = 0;

208 int code = 64;

209 int step = 45;

210

211 s->array[0] = 0;

212 for (i = 0; i < 127; i++) {

213 delta += (code >> 5);

214 code += step;

215 step += 2;

216

217 s->array[i*2 + 1] = delta;

218 s->array[i*2 + 2] = -delta;

219 }

220 s->array[255] = delta + (code >> 5);

221 }

222 break;

223

224 case AV_CODEC_ID_WADY_DPCM:

225 s->scale = (avctx->extradata && avctx->extradata_size > 0) ? avctx->extradata[0] : 1;

226 break;

227

228 default:

229 break;

230 }

231

232 if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)

233 avctx->sample_fmt = AV_SAMPLE_FMT_U8;

234 else

235 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

236

237 return 0;

238 }

239

240

241 static int dpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,

242 int *got_frame_ptr, AVPacket *avpkt)

243 {

244 int buf_size = avpkt->size;

245 DPCMContext *s = avctx->priv_data;

246 int out = 0, ret;

247 int predictor[2];

248 int ch = 0;

249 int stereo = avctx->ch_layout.nb_channels - 1;

250 int16_t *output_samples, *samples_end;

251 GetByteContext gb;

252

253 if (stereo && (buf_size & 1))

254 buf_size--;

255 bytestream2_init(&gb, avpkt->data, buf_size);

256

257 /* calculate output size */

258 switch(avctx->codec->id) {

259 case AV_CODEC_ID_ROQ_DPCM:

260 out = buf_size - 8;

261 break;

262 case AV_CODEC_ID_INTERPLAY_DPCM:

263 out = buf_size - 6 - avctx->ch_layout.nb_channels;

264 break;

265 case AV_CODEC_ID_XAN_DPCM:

266 out = buf_size - 2 * avctx->ch_layout.nb_channels;

267 break;

268 case AV_CODEC_ID_SOL_DPCM:

269 if (avctx->codec_tag != 3)

270 out = buf_size * 2;

271 else

272 out = buf_size;

273 break;

274 case AV_CODEC_ID_WADY_DPCM:

275 case AV_CODEC_ID_DERF_DPCM:

276 case AV_CODEC_ID_GREMLIN_DPCM:

277 case AV_CODEC_ID_CBD2_DPCM:

278 case AV_CODEC_ID_SDX2_DPCM:

279 out = buf_size;

280 break;

281 }

282 if (out <= 0) {

283 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");

284 return AVERROR(EINVAL);

285 }

286 if (out % avctx->ch_layout.nb_channels) {

287 av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");

288 }

289

290 /* get output buffer */

291 frame->nb_samples = (out + avctx->ch_layout.nb_channels - 1) / avctx->ch_layout.nb_channels;

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

293 return ret;

294 output_samples = (int16_t *)frame->data[0];

295 samples_end = output_samples + out;

296

297 switch(avctx->codec->id) {

298

299 case AV_CODEC_ID_ROQ_DPCM:

300 bytestream2_skipu(&gb, 6);

301

302 if (stereo) {

303 predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);

304 predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);

305 } else {

306 predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);

307 }

308

309 /* decode the samples */

310 while (output_samples < samples_end) {

311 predictor[ch] += s->array[bytestream2_get_byteu(&gb)];

312 predictor[ch] = av_clip_int16(predictor[ch]);

313 *output_samples++ = predictor[ch];

314

315 /* toggle channel */

316 ch ^= stereo;

317 }

318 break;

319

320 case AV_CODEC_ID_INTERPLAY_DPCM:

321 bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */

322

323 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {

324 predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);

325 *output_samples++ = predictor[ch];

326 }

327

328 ch = 0;

329 while (output_samples < samples_end) {

330 predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];

331 predictor[ch] = av_clip_int16(predictor[ch]);

332 *output_samples++ = predictor[ch];

333

334 /* toggle channel */

335 ch ^= stereo;

336 }

337 break;

338

339 case AV_CODEC_ID_XAN_DPCM:

340 {

341 int shift[2] = { 4, 4 };

342

343 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)

344 predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);

345

346 ch = 0;

347 while (output_samples < samples_end) {

348 int diff = bytestream2_get_byteu(&gb);

349 int n = diff & 3;

350

351 if (n == 3)

352 shift[ch]++;

353 else

354 shift[ch] -= (2 * n);

355 diff = sign_extend((diff &~ 3) << 8, 16);

356

357 /* saturate the shifter to 0..31 */

358 shift[ch] = av_clip_uintp2(shift[ch], 5);

359

360 diff >>= shift[ch];

361 predictor[ch] += diff;

362

363 predictor[ch] = av_clip_int16(predictor[ch]);

364 *output_samples++ = predictor[ch];

365

366 /* toggle channel */

367 ch ^= stereo;

368 }

369 break;

370 }

371 case AV_CODEC_ID_SOL_DPCM:

372 if (avctx->codec_tag != 3) {

373 uint8_t *output_samples_u8 = frame->data[0],

374 *samples_end_u8 = output_samples_u8 + out;

375 while (output_samples_u8 < samples_end_u8) {

376 int n = bytestream2_get_byteu(&gb);

377

378 s->sample[0] += s->sol_table[n >> 4];

379 s->sample[0] = av_clip_uint8(s->sample[0]);

380 *output_samples_u8++ = s->sample[0];

381

382 s->sample[stereo] += s->sol_table[n & 0x0F];

383 s->sample[stereo] = av_clip_uint8(s->sample[stereo]);

384 *output_samples_u8++ = s->sample[stereo];

385 }

386 } else {

387 while (output_samples < samples_end) {

388 int n = bytestream2_get_byteu(&gb);

389 if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];

390 else s->sample[ch] += sol_table_16[n & 0x7F];

391 s->sample[ch] = av_clip_int16(s->sample[ch]);

392 *output_samples++ = s->sample[ch];

393 /* toggle channel */

394 ch ^= stereo;

395 }

396 }

397 break;

398

399 case AV_CODEC_ID_CBD2_DPCM:

400 case AV_CODEC_ID_SDX2_DPCM:

401 while (output_samples < samples_end) {

402 int8_t n = bytestream2_get_byteu(&gb);

403

404 if (!(n & 1))

405 s->sample[ch] = 0;

406 s->sample[ch] += s->array[n + 128];

407 s->sample[ch] = av_clip_int16(s->sample[ch]);

408 *output_samples++ = s->sample[ch];

409 ch ^= stereo;

410 }

411 break;

412

413 case AV_CODEC_ID_GREMLIN_DPCM: {

414 int idx = 0;

415

416 while (output_samples < samples_end) {

417 uint8_t n = bytestream2_get_byteu(&gb);

418

419 *output_samples++ = s->sample[idx] += (unsigned)s->array[n];

420 idx ^= 1;

421 }

422 }

423 break;

424

425 case AV_CODEC_ID_DERF_DPCM: {

426 int idx = 0;

427

428 while (output_samples < samples_end) {

429 uint8_t n = bytestream2_get_byteu(&gb);

430 int index = FFMIN(n & 0x7f, 95);

431

432 s->sample[idx] += (n & 0x80 ? -1: 1) * derf_steps[index];

433 s->sample[idx] = av_clip_int16(s->sample[idx]);

434 *output_samples++ = s->sample[idx];

435 idx ^= stereo;

436 }

437 }

438 break;

439

440 case AV_CODEC_ID_WADY_DPCM: {

441 int idx = 0;

442

443 while (output_samples < samples_end) {

444 const uint8_t n = bytestream2_get_byteu(&gb);

445

446 if (n & 0x80)

447 s->sample[idx] = sign_extend((n & 0x7f) << 9, 16);

448 else

449 s->sample[idx] += s->scale * (unsigned)wady_table[n & 0x7f];

450 *output_samples++ = av_clip_int16(s->sample[idx]);

451 idx ^= stereo;

452 }

453 }

454 break;

455 }

456

457 *got_frame_ptr = 1;

458

459 return avpkt->size;

460 }

461

462 static av_cold void dpcm_flush(AVCodecContext *avctx)

463 {

464 DPCMContext *s = avctx->priv_data;

465

466 s->sample[0] = s->sample[1] = 0;

467 }

468

469 #define DPCM_DECODER(id_, name_, long_name_) \

470 const FFCodec ff_ ## name_ ## _decoder = { \

471 .p.name = #name_, \

472 CODEC_LONG_NAME(long_name_), \

473 .p.type = AVMEDIA_TYPE_AUDIO, \

474 .p.id = id_, \

475 .p.capabilities = AV_CODEC_CAP_DR1, \

476 .priv_data_size = sizeof(DPCMContext), \

477 .init = dpcm_decode_init, \

478 .flush = dpcm_flush, \

479 FF_CODEC_DECODE_CB(dpcm_decode_frame), \

480 }

481

482 DPCM_DECODER(AV_CODEC_ID_CBD2_DPCM, cbd2_dpcm, "DPCM Cuberoot-Delta-Exact");

483 DPCM_DECODER(AV_CODEC_ID_DERF_DPCM, derf_dpcm, "DPCM Xilam DERF");

484 DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM, gremlin_dpcm, "DPCM Gremlin");

485 DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");

486 DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");

487 DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM, sdx2_dpcm, "DPCM Squareroot-Delta-Exact");

488 DPCM_DECODER(AV_CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");

489 DPCM_DECODER(AV_CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");

490 DPCM_DECODER(AV_CODEC_ID_WADY_DPCM, wady_dpcm, "DPCM Marble WADY");

sol_table_16

static const int16_t sol_table_16[128]

Definition: dpcm.c:116

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

DPCM_DECODER

#define DPCM_DECODER(id_, name_, long_name_)

Definition: dpcm.c:469

DPCMContext

Definition: dpcm.c:48

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

out

FILE * out

Definition: movenc.c:55

GetByteContext

Definition: bytestream.h:33

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:124

bytestream2_skipu

static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)

Definition: bytestream.h:174

AVFrame

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

Definition: frame.h:427

step

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step

Definition: rate_distortion.txt:58

interplay_delta_table

static const int16_t interplay_delta_table[]

Definition: dpcm.c:70

DPCMContext::scale

int scale

scale for WADY_DPCM

Definition: dpcm.c:51

AVPacket::data

uint8_t * data

Definition: packet.h:558

dpcm_decode_init

static av_cold int dpcm_decode_init(AVCodecContext *avctx)

Definition: dpcm.c:151

AV_CODEC_ID_SOL_DPCM

@ AV_CODEC_ID_SOL_DPCM

Definition: codec_id.h:451

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

sol_table_new

static const int8_t sol_table_new[16]

Definition: dpcm.c:111

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:440

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

dpcm_decode_frame

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

Definition: dpcm.c:241

AV_CODEC_ID_XAN_DPCM

@ AV_CODEC_ID_XAN_DPCM

Definition: codec_id.h:450

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

#define s(width, name)

Definition: cbs_vp9.c:198

AV_CODEC_ID_WADY_DPCM

@ AV_CODEC_ID_WADY_DPCM

Definition: codec_id.h:455

DPCMContext::sample

int sample[2]

previous sample (for SOL_DPCM and WADY_DPCM)

Definition: dpcm.c:50

decode.h

AV_CODEC_ID_DERF_DPCM

@ AV_CODEC_ID_DERF_DPCM

Definition: codec_id.h:454

sol_table_old

static const int8_t sol_table_old[16]

Definition: dpcm.c:106

if(ret)

Definition: filter_design.txt:179

av_clip_int16

#define av_clip_int16

Definition: common.h:115

AV_CODEC_ID_INTERPLAY_DPCM

@ AV_CODEC_ID_INTERPLAY_DPCM

Definition: codec_id.h:449

derf_steps

static const int32_t derf_steps[96]

Definition: dpcm.c:55

mathops.h

DPCMContext::sol_table

const int8_t * sol_table

delta table for SOL_DPCM

Definition: dpcm.c:52

AV_CODEC_ID_ROQ_DPCM

@ AV_CODEC_ID_ROQ_DPCM

Definition: codec_id.h:448

index

int index

Definition: gxfenc.c:90

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1720

AVPacket::size

int size

Definition: packet.h:559

codec_internal.h

shift

static int shift(int a, int b)

Definition: bonk.c:261

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:166

attributes.h

predictor

static void predictor(uint8_t *src, ptrdiff_t size)

Definition: exrenc.c:170

DPCMContext::array

int16_t array[256]

Definition: dpcm.c:49

dpcm_flush

static av_cold void dpcm_flush(AVCodecContext *avctx)

Definition: dpcm.c:462

AVCodec::id

enum AVCodecID id

Definition: codec.h:186

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

Definition: cbs_h2645.c:256

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

AV_SAMPLE_FMT_U8

@ AV_SAMPLE_FMT_U8

unsigned 8 bits

Definition: samplefmt.h:57

delta

float delta

Definition: vorbis_enc_data.h:430

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

ret

Definition: filter_design.txt:187

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

square

static int square(int x)

Definition: roqvideoenc.c:196

AV_CODEC_ID_CBD2_DPCM

@ AV_CODEC_ID_CBD2_DPCM

Definition: codec_id.h:456

AVCodecContext

main external API structure.

Definition: avcodec.h:431

sign_extend

static av_const int sign_extend(int val, unsigned bits)