FFmpeg: libavcodec/dpx.c Source File

FFmpeg

[フレーム]

libavcodec

dpx.c

Go to the documentation of this file.

1 /*

2 * DPX (.dpx) image decoder

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 #include "libavutil/avstring.h"

23 #include "libavutil/intreadwrite.h"

24 #include "libavutil/intfloat.h"

25 #include "libavutil/imgutils.h"

26 #include "libavutil/timecode.h"

27 #include "bytestream.h"

28 #include "avcodec.h"

29 #include "codec_internal.h"

30 #include "internal.h"

32 enum DPX_TRC {

33 DPX_TRC_USER_DEFINED = 0,

34 DPX_TRC_PRINTING_DENSITY = 1,

35 DPX_TRC_LINEAR = 2,

36 DPX_TRC_LOGARITHMIC = 3,

37 DPX_TRC_UNSPECIFIED_VIDEO = 4,

38 DPX_TRC_SMPTE_274 = 5,

39 DPX_TRC_ITU_R_709_4 = 6,

40 DPX_TRC_ITU_R_601_625 = 7,

41 DPX_TRC_ITU_R_601_525 = 8,

42 DPX_TRC_SMPTE_170 = 9,

43 DPX_TRC_ITU_R_624_4_PAL = 10,

44 DPX_TRC_Z_LINEAR = 11,

45 DPX_TRC_Z_HOMOGENEOUS = 12,

46 };

48 enum DPX_COL_SPEC {

49 DPX_COL_SPEC_USER_DEFINED = 0,

50 DPX_COL_SPEC_PRINTING_DENSITY = 1,

51 /* 2 = N/A */

52 /* 3 = N/A */

53 DPX_COL_SPEC_UNSPECIFIED_VIDEO = 4,

54 DPX_COL_SPEC_SMPTE_274 = 5,

55 DPX_COL_SPEC_ITU_R_709_4 = 6,

56 DPX_COL_SPEC_ITU_R_601_625 = 7,

57 DPX_COL_SPEC_ITU_R_601_525 = 8,

58 DPX_COL_SPEC_SMPTE_170 = 9,

59 DPX_COL_SPEC_ITU_R_624_4_PAL = 10,

60 /* 11 = N/A */

61 /* 12 = N/A */

62 };

64 static unsigned int read16(const uint8_t **ptr, int is_big)

65 {

66 unsigned int temp;

67 if (is_big) {

68 temp = AV_RB16(*ptr);

69 } else {

70 temp = AV_RL16(*ptr);

71 }

72 *ptr += 2;

73 return temp;

74 }

76 static unsigned int read32(const uint8_t **ptr, int is_big)

77 {

78 unsigned int temp;

79 if (is_big) {

80 temp = AV_RB32(*ptr);

81 } else {

82 temp = AV_RL32(*ptr);

83 }

84 *ptr += 4;

85 return temp;

86 }

88 static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf,

89 int *n_datum, int is_big, int shift)

90 {

91 uint16_t temp;

93 if (*n_datum)

94 (*n_datum)--;

95 else {

96 *lbuf = read32(ptr, is_big);

97 *n_datum = 2;

98 }

100 temp = *lbuf >> shift & 0x3FF;

101 *lbuf = *lbuf >> 10;

102

103 return temp;

104 }

105

106 static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf,

107 int *n_datum, int is_big, int shift)

108 {

109 if (*n_datum)

110 (*n_datum)--;

111 else {

112 *lbuf = read32(ptr, is_big);

113 *n_datum = 2;

114 }

115

116 *lbuf = *lbuf << 10 | *lbuf >> shift & 0x3FFFFF;

117

118 return *lbuf & 0x3FF;

119 }

120

121 static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf,

122 int *n_datum, int is_big)

123 {

124 if (*n_datum)

125 (*n_datum)--;

126 else {

127 *lbuf = read32(ptr, is_big);

128 *n_datum = 7;

129 }

130

131 switch (*n_datum){

132 case 7: return *lbuf & 0xFFF;

133 case 6: return (*lbuf >> 12) & 0xFFF;

134 case 5: {

135 uint32_t c = *lbuf >> 24;

136 *lbuf = read32(ptr, is_big);

137 c |= *lbuf << 8;

138 return c & 0xFFF;

139 }

140 case 4: return (*lbuf >> 4) & 0xFFF;

141 case 3: return (*lbuf >> 16) & 0xFFF;

142 case 2: {

143 uint32_t c = *lbuf >> 28;

144 *lbuf = read32(ptr, is_big);

145 c |= *lbuf << 4;

146 return c & 0xFFF;

147 }

148 case 1: return (*lbuf >> 8) & 0xFFF;

149 default: return *lbuf >> 20;

150 }

151 }

152

153 static int decode_frame(AVCodecContext *avctx, AVFrame *p,

154 int *got_frame, AVPacket *avpkt)

155 {

156 const uint8_t *buf = avpkt->data;

157 int buf_size = avpkt->size;

158 uint8_t *ptr[AV_NUM_DATA_POINTERS];

159 uint32_t header_version, version = 0;

160 char creator[101] = { 0 };

161 char input_device[33] = { 0 };

162

163 unsigned int offset;

164 int magic_num, endian;

165 int x, y, stride, i, j, ret;

166 int w, h, bits_per_color, descriptor, elements, packing;

167 int yuv, color_trc, color_spec;

168 int encoding, need_align = 0, unpadded_10bit = 0;

169

170 unsigned int rgbBuffer = 0;

171 int n_datum = 0;

172

173 if (avpkt->size <= 1634) {

174 av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");

175 return AVERROR_INVALIDDATA;

176 }

177

178 magic_num = AV_RB32(buf);

179 buf += 4;

180

181 /* Check if the files "magic number" is "SDPX" which means it uses

182 * big-endian or XPDS which is for little-endian files */

183 if (magic_num == AV_RL32("SDPX")) {

184 endian = 0;

185 } else if (magic_num == AV_RB32("SDPX")) {

186 endian = 1;

187 } else {

188 av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");

189 return AVERROR_INVALIDDATA;

190 }

191

192 offset = read32(&buf, endian);

193 if (avpkt->size <= offset) {

194 av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");

195 return AVERROR_INVALIDDATA;

196 }

197

198 header_version = read32(&buf, 0);

199 if (header_version == MKTAG('V','1','.','0'))

200 version = 1;

201 if (header_version == MKTAG('V','2','.','0'))

202 version = 2;

203 if (!version)

204 av_log(avctx, AV_LOG_WARNING, "Unknown header format version %s.\n",

205 av_fourcc2str(header_version));

206

207 // Check encryption

208 buf = avpkt->data + 660;

209 ret = read32(&buf, endian);

210 if (ret != 0xFFFFFFFF) {

211 avpriv_report_missing_feature(avctx, "Encryption");

212 av_log(avctx, AV_LOG_WARNING, "The image is encrypted and may "

213 "not properly decode.\n");

214 }

215

216 // Need to end in 0x304 offset from start of file

217 buf = avpkt->data + 0x304;

218 w = read32(&buf, endian);

219 h = read32(&buf, endian);

220

221 if ((ret = ff_set_dimensions(avctx, w, h)) < 0)

222 return ret;

223

224 // Need to end in 0x320 to read the descriptor

225 buf += 20;

226 descriptor = buf[0];

227 color_trc = buf[1];

228 color_spec = buf[2];

229

230 // Need to end in 0x323 to read the bits per color

231 buf += 3;

232 avctx->bits_per_raw_sample =

233 bits_per_color = buf[0];

234 buf++;

235 packing = read16(&buf, endian);

236 encoding = read16(&buf, endian);

237

238 if (encoding) {

239 avpriv_report_missing_feature(avctx, "Encoding %d", encoding);

240 return AVERROR_PATCHWELCOME;

241 }

242

243 if (bits_per_color > 31)

244 return AVERROR_INVALIDDATA;

245

246 buf += 820;

247 avctx->sample_aspect_ratio.num = read32(&buf, endian);

248 avctx->sample_aspect_ratio.den = read32(&buf, endian);

249 if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)

250 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,

251 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den,

252 0x10000);

253 else

254 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };

255

256 /* preferred frame rate from Motion-picture film header */

257 if (offset >= 1724 + 4) {

258 buf = avpkt->data + 1724;

259 i = read32(&buf, endian);

260 if(i && i != 0xFFFFFFFF) {

261 AVRational q = av_d2q(av_int2float(i), 4096);

262 if (q.num > 0 && q.den > 0)

263 avctx->framerate = q;

264 }

265 }

266

267 /* alternative frame rate from television header */

268 if (offset >= 1940 + 4 &&

269 !(avctx->framerate.num && avctx->framerate.den)) {

270 buf = avpkt->data + 1940;

271 i = read32(&buf, endian);

272 if(i && i != 0xFFFFFFFF) {

273 AVRational q = av_d2q(av_int2float(i), 4096);

274 if (q.num > 0 && q.den > 0)

275 avctx->framerate = q;

276 }

277 }

278

279 /* SMPTE TC from television header */

280 if (offset >= 1920 + 4) {

281 uint32_t tc;

282 uint32_t *tc_sd;

283 char tcbuf[AV_TIMECODE_STR_SIZE];

284

285 buf = avpkt->data + 1920;

286 // read32 to native endian, av_bswap32 to opposite of native for

287 // compatibility with av_timecode_make_smpte_tc_string2 etc

288 tc = av_bswap32(read32(&buf, endian));

289

290 if (i != 0xFFFFFFFF) {

291 AVFrameSideData *tcside =

292 av_frame_new_side_data(p, AV_FRAME_DATA_S12M_TIMECODE,

293 sizeof(uint32_t) * 4);

294 if (!tcside)

295 return AVERROR(ENOMEM);

296

297 tc_sd = (uint32_t*)tcside->data;

298 tc_sd[0] = 1;

299 tc_sd[1] = tc;

300

301 av_timecode_make_smpte_tc_string2(tcbuf, avctx->framerate,

302 tc_sd[1], 0, 0);

303 av_dict_set(&p->metadata, "timecode", tcbuf, 0);

304 }

305 }

306

307 /* color range from television header */

308 if (offset >= 1964 + 4) {

309 buf = avpkt->data + 1952;

310 i = read32(&buf, endian);

311

312 buf = avpkt->data + 1964;

313 j = read32(&buf, endian);

314

315 if (i != 0xFFFFFFFF && j != 0xFFFFFFFF) {

316 float minCV, maxCV;

317 minCV = av_int2float(i);

318 maxCV = av_int2float(j);

319 if (bits_per_color >= 1 &&

320 minCV == 0.0f && maxCV == ((1U<<bits_per_color) - 1)) {

321 avctx->color_range = AVCOL_RANGE_JPEG;

322 } else if (bits_per_color >= 8 &&

323 minCV == (1 <<(bits_per_color - 4)) &&

324 maxCV == (235<<(bits_per_color - 8))) {

325 avctx->color_range = AVCOL_RANGE_MPEG;

326 }

327 }

328 }

329

330 switch (descriptor) {

331 case 1: // R

332 case 2: // G

333 case 3: // B

334 case 4: // A

335 case 6: // Y

336 elements = 1;

337 yuv = 1;

338 break;

339 case 50: // RGB

340 elements = 3;

341 yuv = 0;

342 break;

343 case 52: // ABGR

344 case 51: // RGBA

345 elements = 4;

346 yuv = 0;

347 break;

348 case 100: // UYVY422

349 elements = 2;

350 yuv = 1;

351 break;

352 case 102: // UYV444

353 elements = 3;

354 yuv = 1;

355 break;

356 case 103: // UYVA4444

357 elements = 4;

358 yuv = 1;

359 break;

360 default:

361 avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);

362 return AVERROR_PATCHWELCOME;

363 }

364

365 switch (bits_per_color) {

366 case 8:

367 stride = avctx->width * elements;

368 break;

369 case 10:

370 if (!packing) {

371 av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");

372 return -1;

373 }

374 stride = (avctx->width * elements + 2) / 3 * 4;

375 break;

376 case 12:

377 stride = avctx->width * elements;

378 if (packing) {

379 stride *= 2;

380 } else {

381 stride *= 3;

382 if (stride % 8) {

383 stride /= 8;

384 stride++;

385 stride *= 8;

386 }

387 stride /= 2;

388 }

389 break;

390 case 16:

391 stride = 2 * avctx->width * elements;

392 break;

393 case 32:

394 stride = 4 * avctx->width * elements;

395 break;

396 case 1:

397 case 64:

398 avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);

399 return AVERROR_PATCHWELCOME;

400 default:

401 return AVERROR_INVALIDDATA;

402 }

403

404 switch (color_trc) {

405 case DPX_TRC_LINEAR:

406 avctx->color_trc = AVCOL_TRC_LINEAR;

407 break;

408 case DPX_TRC_SMPTE_274:

409 case DPX_TRC_ITU_R_709_4:

410 avctx->color_trc = AVCOL_TRC_BT709;

411 break;

412 case DPX_TRC_ITU_R_601_625:

413 case DPX_TRC_ITU_R_601_525:

414 case DPX_TRC_SMPTE_170:

415 avctx->color_trc = AVCOL_TRC_SMPTE170M;

416 break;

417 case DPX_TRC_ITU_R_624_4_PAL:

418 avctx->color_trc = AVCOL_TRC_GAMMA28;

419 break;

420 case DPX_TRC_USER_DEFINED:

421 case DPX_TRC_UNSPECIFIED_VIDEO:

422 /* Nothing to do */

423 break;

424 default:

425 av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX transfer characteristic "

426 "%d to color_trc.\n", color_trc);

427 break;

428 }

429

430 switch (color_spec) {

431 case DPX_COL_SPEC_SMPTE_274:

432 case DPX_COL_SPEC_ITU_R_709_4:

433 avctx->color_primaries = AVCOL_PRI_BT709;

434 break;

435 case DPX_COL_SPEC_ITU_R_601_625:

436 case DPX_COL_SPEC_ITU_R_624_4_PAL:

437 avctx->color_primaries = AVCOL_PRI_BT470BG;

438 break;

439 case DPX_COL_SPEC_ITU_R_601_525:

440 case DPX_COL_SPEC_SMPTE_170:

441 avctx->color_primaries = AVCOL_PRI_SMPTE170M;

442 break;

443 case DPX_COL_SPEC_USER_DEFINED:

444 case DPX_COL_SPEC_UNSPECIFIED_VIDEO:

445 /* Nothing to do */

446 break;

447 default:

448 av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX color specification "

449 "%d to color_primaries.\n", color_spec);

450 break;

451 }

452

453 if (yuv) {

454 switch (color_spec) {

455 case DPX_COL_SPEC_SMPTE_274:

456 case DPX_COL_SPEC_ITU_R_709_4:

457 avctx->colorspace = AVCOL_SPC_BT709;

458 break;

459 case DPX_COL_SPEC_ITU_R_601_625:

460 case DPX_COL_SPEC_ITU_R_624_4_PAL:

461 avctx->colorspace = AVCOL_SPC_BT470BG;

462 break;

463 case DPX_COL_SPEC_ITU_R_601_525:

464 case DPX_COL_SPEC_SMPTE_170:

465 avctx->colorspace = AVCOL_SPC_SMPTE170M;

466 break;

467 case DPX_COL_SPEC_USER_DEFINED:

468 case DPX_COL_SPEC_UNSPECIFIED_VIDEO:

469 /* Nothing to do */

470 break;

471 default:

472 av_log(avctx, AV_LOG_INFO, "Cannot map DPX color specification "

473 "%d to colorspace.\n", color_spec);

474 break;

475 }

476 } else {

477 avctx->colorspace = AVCOL_SPC_RGB;

478 }

479

480 // Table 3c: Runs will always break at scan line boundaries. Packing

481 // will always break to the next 32-bit word at scan-line boundaries.

482 // Unfortunately, the encoder produced invalid files, so attempt

483 // to detect it

484 need_align = FFALIGN(stride, 4);

485 if (need_align*avctx->height + (int64_t)offset > avpkt->size) {

486 // Alignment seems unappliable, try without

487 if (stride*avctx->height + (int64_t)offset > avpkt->size) {

488 av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");

489 return AVERROR_INVALIDDATA;

490 } else {

491 av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "

492 "alignment.\n");

493 need_align = 0;

494 }

495 } else {

496 need_align -= stride;

497 stride = FFALIGN(stride, 4);

498 }

499

500 switch (1000 * descriptor + 10 * bits_per_color + endian) {

501 case 1081:

502 case 1080:

503 case 2081:

504 case 2080:

505 case 3081:

506 case 3080:

507 case 4081:

508 case 4080:

509 case 6081:

510 case 6080:

511 avctx->pix_fmt = AV_PIX_FMT_GRAY8;

512 break;

513 case 6121:

514 case 6120:

515 avctx->pix_fmt = AV_PIX_FMT_GRAY12;

516 break;

517 case 1320:

518 case 2320:

519 case 3320:

520 case 4320:

521 case 6320:

522 avctx->pix_fmt = AV_PIX_FMT_GRAYF32LE;

523 break;

524 case 1321:

525 case 2321:

526 case 3321:

527 case 4321:

528 case 6321:

529 avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;

530 break;

531 case 50081:

532 case 50080:

533 avctx->pix_fmt = AV_PIX_FMT_RGB24;

534 break;

535 case 52081:

536 case 52080:

537 avctx->pix_fmt = AV_PIX_FMT_ABGR;

538 break;

539 case 51081:

540 case 51080:

541 avctx->pix_fmt = AV_PIX_FMT_RGBA;

542 break;

543 case 50100:

544 case 50101:

545 avctx->pix_fmt = AV_PIX_FMT_GBRP10;

546 break;

547 case 51100:

548 case 51101:

549 avctx->pix_fmt = AV_PIX_FMT_GBRAP10;

550 break;

551 case 50120:

552 case 50121:

553 avctx->pix_fmt = AV_PIX_FMT_GBRP12;

554 break;

555 case 51120:

556 case 51121:

557 avctx->pix_fmt = AV_PIX_FMT_GBRAP12;

558 break;

559 case 6100:

560 case 6101:

561 avctx->pix_fmt = AV_PIX_FMT_GRAY10;

562 break;

563 case 6161:

564 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;

565 break;

566 case 6160:

567 avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;

568 break;

569 case 50161:

570 avctx->pix_fmt = AV_PIX_FMT_RGB48BE;

571 break;

572 case 50160:

573 avctx->pix_fmt = AV_PIX_FMT_RGB48LE;

574 break;

575 case 51161:

576 avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;

577 break;

578 case 51160:

579 avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;

580 break;

581 case 50320:

582 avctx->pix_fmt = AV_PIX_FMT_GBRPF32LE;

583 break;

584 case 50321:

585 avctx->pix_fmt = AV_PIX_FMT_GBRPF32BE;

586 break;

587 case 51320:

588 avctx->pix_fmt = AV_PIX_FMT_GBRAPF32LE;

589 break;

590 case 51321:

591 avctx->pix_fmt = AV_PIX_FMT_GBRAPF32BE;

592 break;

593 case 100081:

594 avctx->pix_fmt = AV_PIX_FMT_UYVY422;

595 break;

596 case 102081:

597 avctx->pix_fmt = AV_PIX_FMT_YUV444P;

598 break;

599 case 103081:

600 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;

601 break;

602 default:

603 av_log(avctx, AV_LOG_ERROR, "Unsupported format %d\n",

604 1000 * descriptor + 10 * bits_per_color + endian);

605 return AVERROR_PATCHWELCOME;

606 }

607

608 ff_set_sar(avctx, avctx->sample_aspect_ratio);

609

610 if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

611 return ret;

612

613 av_strlcpy(creator, avpkt->data + 160, 100);

614 creator[100] = '0円';

615 av_dict_set(&p->metadata, "Creator", creator, 0);

616

617 av_strlcpy(input_device, avpkt->data + 1556, 32);

618 input_device[32] = '0円';

619 av_dict_set(&p->metadata, "Input Device", input_device, 0);

620

621 // Some devices do not pad 10bit samples to whole 32bit words per row

622 if (!memcmp(input_device, "Scanity", 7) ||

623 !memcmp(creator, "Lasergraphics Inc.", 18)) {

624 unpadded_10bit = 1;

625 }

626

627 // Move pointer to offset from start of file

628 buf = avpkt->data + offset;

629

630 for (i=0; i<AV_NUM_DATA_POINTERS; i++)

631 ptr[i] = p->data[i];

632

633 switch (bits_per_color) {

634 case 10:

635 for (x = 0; x < avctx->height; x++) {

636 uint16_t *dst[4] = {(uint16_t*)ptr[0],

637 (uint16_t*)ptr[1],

638 (uint16_t*)ptr[2],

639 (uint16_t*)ptr[3]};

640 int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;

641 for (y = 0; y < avctx->width; y++) {

642 if (elements >= 3)

643 *dst[2]++ = read10in32(&buf, &rgbBuffer,

644 &n_datum, endian, shift);

645 if (elements == 1)

646 *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,

647 &n_datum, endian, shift);

648 else

649 *dst[0]++ = read10in32(&buf, &rgbBuffer,

650 &n_datum, endian, shift);

651 if (elements >= 2)

652 *dst[1]++ = read10in32(&buf, &rgbBuffer,

653 &n_datum, endian, shift);

654 if (elements == 4)

655 *dst[3]++ =

656 read10in32(&buf, &rgbBuffer,

657 &n_datum, endian, shift);

658 }

659 if (!unpadded_10bit)

660 n_datum = 0;

661 for (i = 0; i < elements; i++)

662 ptr[i] += p->linesize[i];

663 }

664 break;

665 case 12:

666 for (x = 0; x < avctx->height; x++) {

667 uint16_t *dst[4] = {(uint16_t*)ptr[0],

668 (uint16_t*)ptr[1],

669 (uint16_t*)ptr[2],

670 (uint16_t*)ptr[3]};

671 int shift = packing == 1 ? 4 : 0;

672 for (y = 0; y < avctx->width; y++) {

673 if (packing) {

674 if (elements >= 3)

675 *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;

676 *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;

677 if (elements >= 2)

678 *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;

679 if (elements == 4)

680 *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;

681 } else {

682 if (elements >= 3)

683 *dst[2]++ = read12in32(&buf, &rgbBuffer,

684 &n_datum, endian);

685 *dst[0]++ = read12in32(&buf, &rgbBuffer,

686 &n_datum, endian);

687 if (elements >= 2)

688 *dst[1]++ = read12in32(&buf, &rgbBuffer,

689 &n_datum, endian);

690 if (elements == 4)

691 *dst[3]++ = read12in32(&buf, &rgbBuffer,

692 &n_datum, endian);

693 }

694 }

695 n_datum = 0;

696 for (i = 0; i < elements; i++)

697 ptr[i] += p->linesize[i];

698 // Jump to next aligned position

699 buf += need_align;

700 }

701 break;

702 case 32:

703 if (elements == 1) {

704 av_image_copy_plane(ptr[0], p->linesize[0],

705 buf, stride,

706 elements * avctx->width * 4, avctx->height);

707 } else {

708 for (y = 0; y < avctx->height; y++) {

709 ptr[0] = p->data[0] + y * p->linesize[0];

710 ptr[1] = p->data[1] + y * p->linesize[1];

711 ptr[2] = p->data[2] + y * p->linesize[2];

712 ptr[3] = p->data[3] + y * p->linesize[3];

713 for (x = 0; x < avctx->width; x++) {

714 AV_WN32(ptr[2], AV_RN32(buf));

715 AV_WN32(ptr[0], AV_RN32(buf + 4));

716 AV_WN32(ptr[1], AV_RN32(buf + 8));

717 if (avctx->pix_fmt == AV_PIX_FMT_GBRAPF32BE ||

718 avctx->pix_fmt == AV_PIX_FMT_GBRAPF32LE) {

719 AV_WN32(ptr[3], AV_RN32(buf + 12));

720 buf += 4;

721 ptr[3] += 4;

722 }

723

724 buf += 12;

725 ptr[2] += 4;

726 ptr[0] += 4;

727 ptr[1] += 4;

728 }

729 }

730 }

731 break;

732 case 16:

733 elements *= 2;

734 case 8:

735 if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P

736 || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {

737 for (x = 0; x < avctx->height; x++) {

738 ptr[0] = p->data[0] + x * p->linesize[0];

739 ptr[1] = p->data[1] + x * p->linesize[1];

740 ptr[2] = p->data[2] + x * p->linesize[2];

741 ptr[3] = p->data[3] + x * p->linesize[3];

742 for (y = 0; y < avctx->width; y++) {

743 *ptr[1]++ = *buf++;

744 *ptr[0]++ = *buf++;

745 *ptr[2]++ = *buf++;

746 if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)

747 *ptr[3]++ = *buf++;

748 }

749 }

750 } else {

751 av_image_copy_plane(ptr[0], p->linesize[0],

752 buf, stride,

753 elements * avctx->width, avctx->height);

754 }

755 break;

756 }

757

758 *got_frame = 1;

759

760 return buf_size;

761 }

762

763 const FFCodec ff_dpx_decoder = {

764 .p.name = "dpx",

765 .p.long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),

766 .p.type = AVMEDIA_TYPE_VIDEO,

767 .p.id = AV_CODEC_ID_DPX,

768 FF_CODEC_DECODE_CB(decode_frame),

769 .p.capabilities = AV_CODEC_CAP_DR1,

770 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AV_TIMECODE_STR_SIZE

#define AV_TIMECODE_STR_SIZE

Definition: timecode.h:33

AV_CODEC_ID_DPX

@ AV_CODEC_ID_DPX

Definition: codec_id.h:178

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

DPX_COL_SPEC_ITU_R_709_4

@ DPX_COL_SPEC_ITU_R_709_4

Definition: dpx.c:55

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:966

elements

static const ElemCat * elements[ELEMENT_COUNT]

Definition: signature.h:566

av_frame_new_side_data

AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)

Add a new side data to a frame.

Definition: frame.c:672

decode_frame

static int decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)

Definition: dpx.c:153

AVCOL_TRC_LINEAR

@ AVCOL_TRC_LINEAR

"Linear transfer characteristics"

Definition: pixfmt.h:505

AV_FRAME_DATA_S12M_TIMECODE

@ AV_FRAME_DATA_S12M_TIMECODE

Timecode which conforms to SMPTE ST 12-1.

Definition: frame.h:152

DPX_COL_SPEC_USER_DEFINED

@ DPX_COL_SPEC_USER_DEFINED

Definition: dpx.c:49

AVFrame

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

Definition: frame.h:325

AV_PIX_FMT_RGBA64BE

@ AV_PIX_FMT_RGBA64BE

packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...

Definition: pixfmt.h:195

AVCodecContext::color_trc

enum AVColorTransferCharacteristic color_trc

Color Transfer Characteristic.

Definition: avcodec.h:959

AV_PIX_FMT_GBRAPF32LE

@ AV_PIX_FMT_GBRAPF32LE

IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.

Definition: pixfmt.h:313

read10in32_gray

static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)

Definition: dpx.c:88

uint8_t w

Definition: llviddspenc.c:38

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:599

AV_PIX_FMT_GBRPF32BE

@ AV_PIX_FMT_GBRPF32BE

IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.

Definition: pixfmt.h:310

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

DPX_TRC_Z_LINEAR

@ DPX_TRC_Z_LINEAR

Definition: dpx.c:44

FFCodec

Definition: codec_internal.h:112

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

AVCOL_SPC_RGB

@ AVCOL_SPC_RGB

order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1

Definition: pixfmt.h:526

DPX_TRC

Definition: dpx.c:32

intfloat.h

AV_PIX_FMT_GRAYF32LE

@ AV_PIX_FMT_GRAYF32LE

IEEE-754 single precision Y, 32bpp, little-endian.

Definition: pixfmt.h:333

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:346

av_image_copy_plane

void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)

Copy image plane from src to dst.

Definition: imgutils.c:374

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:1732

DPX_TRC_SMPTE_274

@ DPX_TRC_SMPTE_274

Definition: dpx.c:38

AV_PIX_FMT_GRAY16BE

@ AV_PIX_FMT_GRAY16BE

Y , 16bpp, big-endian.

Definition: pixfmt.h:97

AVCOL_SPC_BT470BG

@ AVCOL_SPC_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601

Definition: pixfmt.h:531

DPX_TRC_ITU_R_601_625

@ DPX_TRC_ITU_R_601_625

Definition: dpx.c:40

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

#define U(x)

Definition: vp56_arith.h:37

av_int2float

static av_always_inline float av_int2float(uint32_t i)

Reinterpret a 32-bit integer as a float.

Definition: intfloat.h:40

AV_PIX_FMT_GBRP10

#define AV_PIX_FMT_GBRP10

Definition: pixfmt.h:422

timecode.h

AVCOL_TRC_GAMMA28

@ AVCOL_TRC_GAMMA28

also ITU-R BT470BG

Definition: pixfmt.h:502

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

AVRational::num

int num

Numerator.

Definition: rational.h:59

DPX_TRC_ITU_R_709_4

@ DPX_TRC_ITU_R_709_4

Definition: dpx.c:39

av_bswap32

#define av_bswap32

Definition: bswap.h:33

AVCodecContext::color_primaries

enum AVColorPrimaries color_primaries

Chromaticity coordinates of the source primaries.

Definition: avcodec.h:952

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

AV_PIX_FMT_GBRAP10

#define AV_PIX_FMT_GBRAP10

Definition: pixfmt.h:426

DPX_TRC_SMPTE_170

@ DPX_TRC_SMPTE_170

Definition: dpx.c:42

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

intreadwrite.h

AV_PIX_FMT_GBRAP12

#define AV_PIX_FMT_GBRAP12

Definition: pixfmt.h:427

DPX_TRC_Z_HOMOGENEOUS

@ DPX_TRC_Z_HOMOGENEOUS

Definition: dpx.c:45

DPX_TRC_PRINTING_DENSITY

@ DPX_TRC_PRINTING_DENSITY

Definition: dpx.c:34

DPX_COL_SPEC_SMPTE_170

@ DPX_COL_SPEC_SMPTE_170

Definition: dpx.c:58

AVCOL_SPC_SMPTE170M

@ AVCOL_SPC_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above

Definition: pixfmt.h:532

DPX_TRC_LOGARITHMIC

@ DPX_TRC_LOGARITHMIC

Definition: dpx.c:36

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1448

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:94

DPX_COL_SPEC_SMPTE_274

@ DPX_COL_SPEC_SMPTE_274

Definition: dpx.c:54

AV_PIX_FMT_RGBA

@ AV_PIX_FMT_RGBA

packed RGBA 8:8:8:8, 32bpp, RGBARGBA...

Definition: pixfmt.h:93

AVCOL_PRI_BT470BG

@ AVCOL_PRI_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM

Definition: pixfmt.h:478

AVCOL_PRI_SMPTE170M

@ AVCOL_PRI_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC

Definition: pixfmt.h:479

AV_PIX_FMT_GRAY10

#define AV_PIX_FMT_GRAY10

Definition: pixfmt.h:387

AV_PIX_FMT_GBRAPF32BE

@ AV_PIX_FMT_GBRAPF32BE

IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.

Definition: pixfmt.h:312

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:973

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AV_PIX_FMT_RGB48LE

@ AV_PIX_FMT_RGB48LE

packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...

Definition: pixfmt.h:103

AVCOL_PRI_BT709

@ AVCOL_PRI_BT709

also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B

Definition: pixfmt.h:473

AV_PIX_FMT_RGBA64LE

@ AV_PIX_FMT_RGBA64LE

packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...

Definition: pixfmt.h:196

AV_RN32

#define AV_RN32(p)

Definition: intreadwrite.h:364

ff_dpx_decoder

const FFCodec ff_dpx_decoder

Definition: dpx.c:763

DPX_COL_SPEC_PRINTING_DENSITY

@ DPX_COL_SPEC_PRINTING_DENSITY

Definition: dpx.c:50

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:74

AV_PIX_FMT_ABGR

@ AV_PIX_FMT_ABGR

packed ABGR 8:8:8:8, 32bpp, ABGRABGR...

Definition: pixfmt.h:94

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

read12in32

static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big)

Definition: dpx.c:121

DPX_TRC_ITU_R_624_4_PAL

@ DPX_TRC_ITU_R_624_4_PAL

Definition: dpx.c:43

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_PIX_FMT_RGB24

@ AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:68

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

codec_internal.h

AV_WN32

#define AV_WN32(p, v)

Definition: intreadwrite.h:376

AV_NUM_DATA_POINTERS

#define AV_NUM_DATA_POINTERS

Definition: frame.h:326

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

avpriv_report_missing_feature

void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

AVFrameSideData::data

uint8_t * data

Definition: frame.h:233

DPX_COL_SPEC_ITU_R_601_625

@ DPX_COL_SPEC_ITU_R_601_625

Definition: dpx.c:56

DPX_TRC_UNSPECIFIED_VIDEO

@ DPX_TRC_UNSPECIFIED_VIDEO

Definition: dpx.c:37

AV_PIX_FMT_YUVA444P

@ AV_PIX_FMT_YUVA444P

planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)

Definition: pixfmt.h:167

offset

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

Definition: writing_filters.txt:86

version

Definition: libkvazaar.c:313

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

AVCOL_TRC_BT709

@ AVCOL_TRC_BT709

also ITU-R BT1361

Definition: pixfmt.h:498

DPX_COL_SPEC_UNSPECIFIED_VIDEO

@ DPX_COL_SPEC_UNSPECIFIED_VIDEO

Definition: dpx.c:53

static unsigned int read16(const uint8_t **ptr, int is_big)

Definition: dpx.c:64

AV_PIX_FMT_RGB48BE

@ AV_PIX_FMT_RGB48BE

packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...

Definition: pixfmt.h:102

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

Definition: cbs_h2645.c:269

av_timecode_make_smpte_tc_string2

char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)

Get the timecode string from the SMPTE timecode format.

Definition: timecode.c:138

read10in32

static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)

Definition: dpx.c:106

AV_PIX_FMT_GBRP12

#define AV_PIX_FMT_GBRP12

Definition: pixfmt.h:423

av_d2q

AVRational av_d2q(double d, int max)

Convert a double precision floating point number to a rational.

Definition: rational.c:106

DPX_TRC_LINEAR

@ DPX_TRC_LINEAR

Definition: dpx.c:35

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

AVCodecContext::height

int height

Definition: avcodec.h:562

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:599

AV_PIX_FMT_GBRPF32LE

@ AV_PIX_FMT_GBRPF32LE

IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.

Definition: pixfmt.h:311

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:582

avcodec.h

stride

#define stride

Definition: h264pred_template.c:537

DPX_COL_SPEC_ITU_R_624_4_PAL

@ DPX_COL_SPEC_ITU_R_624_4_PAL

Definition: dpx.c:59

ret

Definition: filter_design.txt:187

AV_PIX_FMT_GRAYF32BE

@ AV_PIX_FMT_GRAYF32BE

IEEE-754 single precision Y, 32bpp, big-endian.

Definition: pixfmt.h:332

AV_PIX_FMT_UYVY422

@ AV_PIX_FMT_UYVY422

packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1

Definition: pixfmt.h:81

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

ff_set_sar

int ff_set_sar(AVCodecContext *avctx, AVRational sar)

Check that the provided sample aspect ratio is valid and set it on the codec context.

Definition: utils.c:105

AVCodecContext

main external API structure.

Definition: avcodec.h:389

AVRational::den

int den

Denominator.

Definition: rational.h:60

AVFrame::metadata

AVDictionary * metadata

metadata.

Definition: frame.h:620

temp

else temp

Definition: vf_mcdeint.c:248

AVCOL_TRC_SMPTE170M

@ AVCOL_TRC_SMPTE170M

also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC

Definition: pixfmt.h:503

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:71

shift

static int shift(int a, int b)

Definition: sonic.c:88

#define tc

Definition: regdef.h:69

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AV_PIX_FMT_GRAY16LE

@ AV_PIX_FMT_GRAY16LE

Y , 16bpp, little-endian.

Definition: pixfmt.h:98

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:90

AVFrameSideData

Structure to hold side data for an AVFrame.

Definition: frame.h:231

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

AVPacket

This structure stores compressed data.

Definition: packet.h:351

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:70

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:562

bytestream.h

imgutils.h

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:370

av_strlcpy

size_t av_strlcpy(char *dst, const char *src, size_t size)

Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.

Definition: avstring.c:86

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

Definition: vp9dsp_template.c:2038

static unsigned int read32(const uint8_t **ptr, int is_big)

Definition: dpx.c:76

avstring.h

AV_PIX_FMT_GRAY12

#define AV_PIX_FMT_GRAY12

Definition: pixfmt.h:388

DPX_COL_SPEC

Definition: dpx.c:48

AVCOL_SPC_BT709

@ AVCOL_SPC_BT709

also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B

Definition: pixfmt.h:527

AVCodecContext::sample_aspect_ratio

AVRational sample_aspect_ratio

sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.

Definition: avcodec.h:759

DPX_TRC_USER_DEFINED

@ DPX_TRC_USER_DEFINED

Definition: dpx.c:33

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

DPX_TRC_ITU_R_601_525

@ DPX_TRC_ITU_R_601_525

Definition: dpx.c:41

av_fourcc2str

#define av_fourcc2str(fourcc)

Definition: avutil.h:354

DPX_COL_SPEC_ITU_R_601_525

@ DPX_COL_SPEC_ITU_R_601_525

Definition: dpx.c:57

Generated on Wed Aug 24 2022 21:41:23 for FFmpeg by doxygen 1.8.17