FFmpeg
dpx.c
Go to the documentation of this file.
1 /*
2  * DPX (.dpx) image decoder
3  * Copyright (c) 2009 Jimmy Christensen
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  */
21 
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 "internal.h"
30 
31 enum DPX_TRC {
32  DPX_TRC_USER_DEFINED = 0,
33  DPX_TRC_PRINTING_DENSITY = 1,
34  DPX_TRC_LINEAR = 2,
35  DPX_TRC_LOGARITHMIC = 3,
36  DPX_TRC_UNSPECIFIED_VIDEO = 4,
37  DPX_TRC_SMPTE_274 = 5,
38  DPX_TRC_ITU_R_709_4 = 6,
39  DPX_TRC_ITU_R_601_625 = 7,
40  DPX_TRC_ITU_R_601_525 = 8,
41  DPX_TRC_SMPTE_170 = 9,
42  DPX_TRC_ITU_R_624_4_PAL = 10,
43  DPX_TRC_Z_LINEAR = 11,
44  DPX_TRC_Z_HOMOGENEOUS = 12,
45 };
46 
47 enum DPX_COL_SPEC {
48  DPX_COL_SPEC_USER_DEFINED = 0,
49  DPX_COL_SPEC_PRINTING_DENSITY = 1,
50  /* 2 = N/A */
51  /* 3 = N/A */
52  DPX_COL_SPEC_UNSPECIFIED_VIDEO = 4,
53  DPX_COL_SPEC_SMPTE_274 = 5,
54  DPX_COL_SPEC_ITU_R_709_4 = 6,
55  DPX_COL_SPEC_ITU_R_601_625 = 7,
56  DPX_COL_SPEC_ITU_R_601_525 = 8,
57  DPX_COL_SPEC_SMPTE_170 = 9,
58  DPX_COL_SPEC_ITU_R_624_4_PAL = 10,
59  /* 11 = N/A */
60  /* 12 = N/A */
61 };
62 
63 static unsigned int read16(const uint8_t **ptr, int is_big)
64 {
65  unsigned int temp;
66  if (is_big) {
67  temp = AV_RB16(*ptr);
68  } else {
69  temp = AV_RL16(*ptr);
70  }
71  *ptr += 2;
72  return temp;
73 }
74 
75 static unsigned int read32(const uint8_t **ptr, int is_big)
76 {
77  unsigned int temp;
78  if (is_big) {
79  temp = AV_RB32(*ptr);
80  } else {
81  temp = AV_RL32(*ptr);
82  }
83  *ptr += 4;
84  return temp;
85 }
86 
87 static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf,
88  int *n_datum, int is_big, int shift)
89 {
90  uint16_t temp;
91 
92  if (*n_datum)
93  (*n_datum)--;
94  else {
95  *lbuf = read32(ptr, is_big);
96  *n_datum = 2;
97  }
98 
99  temp = *lbuf >> shift & 0x3FF;
100  *lbuf = *lbuf >> 10;
101 
102  return temp;
103 }
104 
105 static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf,
106  int *n_datum, int is_big, int shift)
107 {
108  if (*n_datum)
109  (*n_datum)--;
110  else {
111  *lbuf = read32(ptr, is_big);
112  *n_datum = 2;
113  }
114 
115  *lbuf = *lbuf << 10 | *lbuf >> shift & 0x3FFFFF;
116 
117  return *lbuf & 0x3FF;
118 }
119 
120 static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf,
121  int *n_datum, int is_big)
122 {
123  if (*n_datum)
124  (*n_datum)--;
125  else {
126  *lbuf = read32(ptr, is_big);
127  *n_datum = 7;
128  }
129 
130  switch (*n_datum){
131  case 7: return *lbuf & 0xFFF;
132  case 6: return (*lbuf >> 12) & 0xFFF;
133  case 5: {
134  uint32_t c = *lbuf >> 24;
135  *lbuf = read32(ptr, is_big);
136  c |= *lbuf << 8;
137  return c & 0xFFF;
138  }
139  case 4: return (*lbuf >> 4) & 0xFFF;
140  case 3: return (*lbuf >> 16) & 0xFFF;
141  case 2: {
142  uint32_t c = *lbuf >> 28;
143  *lbuf = read32(ptr, is_big);
144  c |= *lbuf << 4;
145  return c & 0xFFF;
146  }
147  case 1: return (*lbuf >> 8) & 0xFFF;
148  default: return *lbuf >> 20;
149  }
150 }
151 
152 static int decode_frame(AVCodecContext *avctx,
153  void *data,
154  int *got_frame,
155  AVPacket *avpkt)
156 {
157  const uint8_t *buf = avpkt->data;
158  int buf_size = avpkt->size;
159  AVFrame *const p = data;
160  uint8_t *ptr[AV_NUM_DATA_POINTERS];
161  uint32_t header_version, version = 0;
162  char creator[101] = { 0 };
163  char input_device[33] = { 0 };
164 
165  unsigned int offset;
166  int magic_num, endian;
167  int x, y, stride, i, j, ret;
168  int w, h, bits_per_color, descriptor, elements, packing;
169  int yuv, color_trc, color_spec;
170  int encoding, need_align = 0, unpadded_10bit = 0;
171 
172  unsigned int rgbBuffer = 0;
173  int n_datum = 0;
174 
175  if (avpkt->size <= 1634) {
176  av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
177  return AVERROR_INVALIDDATA;
178  }
179 
180  magic_num = AV_RB32(buf);
181  buf += 4;
182 
183  /* Check if the files "magic number" is "SDPX" which means it uses
184  * big-endian or XPDS which is for little-endian files */
185  if (magic_num == AV_RL32("SDPX")) {
186  endian = 0;
187  } else if (magic_num == AV_RB32("SDPX")) {
188  endian = 1;
189  } else {
190  av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");
191  return AVERROR_INVALIDDATA;
192  }
193 
194  offset = read32(&buf, endian);
195  if (avpkt->size <= offset) {
196  av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");
197  return AVERROR_INVALIDDATA;
198  }
199 
200  header_version = read32(&buf, 0);
201  if (header_version == MKTAG('V','1','.','0'))
202  version = 1;
203  if (header_version == MKTAG('V','2','.','0'))
204  version = 2;
205  if (!version)
206  av_log(avctx, AV_LOG_WARNING, "Unknown header format version %s.\n",
207  av_fourcc2str(header_version));
208 
209  // Check encryption
210  buf = avpkt->data + 660;
211  ret = read32(&buf, endian);
212  if (ret != 0xFFFFFFFF) {
213  avpriv_report_missing_feature(avctx, "Encryption");
214  av_log(avctx, AV_LOG_WARNING, "The image is encrypted and may "
215  "not properly decode.\n");
216  }
217 
218  // Need to end in 0x304 offset from start of file
219  buf = avpkt->data + 0x304;
220  w = read32(&buf, endian);
221  h = read32(&buf, endian);
222 
223  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
224  return ret;
225 
226  // Need to end in 0x320 to read the descriptor
227  buf += 20;
228  descriptor = buf[0];
229  color_trc = buf[1];
230  color_spec = buf[2];
231 
232  // Need to end in 0x323 to read the bits per color
233  buf += 3;
234  avctx->bits_per_raw_sample =
235  bits_per_color = buf[0];
236  buf++;
237  packing = read16(&buf, endian);
238  encoding = read16(&buf, endian);
239 
240  if (encoding) {
241  avpriv_report_missing_feature(avctx, "Encoding %d", encoding);
242  return AVERROR_PATCHWELCOME;
243  }
244 
245  if (bits_per_color > 31)
246  return AVERROR_INVALIDDATA;
247 
248  buf += 820;
249  avctx->sample_aspect_ratio.num = read32(&buf, endian);
250  avctx->sample_aspect_ratio.den = read32(&buf, endian);
251  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
252  av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
253  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den,
254  0x10000);
255  else
256  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
257 
258  /* preferred frame rate from Motion-picture film header */
259  if (offset >= 1724 + 4) {
260  buf = avpkt->data + 1724;
261  i = read32(&buf, endian);
262  if(i && i != 0xFFFFFFFF) {
263  AVRational q = av_d2q(av_int2float(i), 4096);
264  if (q.num > 0 && q.den > 0)
265  avctx->framerate = q;
266  }
267  }
268 
269  /* alternative frame rate from television header */
270  if (offset >= 1940 + 4 &&
271  !(avctx->framerate.num && avctx->framerate.den)) {
272  buf = avpkt->data + 1940;
273  i = read32(&buf, endian);
274  if(i && i != 0xFFFFFFFF) {
275  AVRational q = av_d2q(av_int2float(i), 4096);
276  if (q.num > 0 && q.den > 0)
277  avctx->framerate = q;
278  }
279  }
280 
281  /* SMPTE TC from television header */
282  if (offset >= 1920 + 4) {
283  uint32_t tc;
284  uint32_t *tc_sd;
285  char tcbuf[AV_TIMECODE_STR_SIZE];
286 
287  buf = avpkt->data + 1920;
288  // read32 to native endian, av_bswap32 to opposite of native for
289  // compatibility with av_timecode_make_smpte_tc_string2 etc
290  tc = av_bswap32(read32(&buf, endian));
291 
292  if (i != 0xFFFFFFFF) {
293  AVFrameSideData *tcside =
294  av_frame_new_side_data(p, AV_FRAME_DATA_S12M_TIMECODE,
295  sizeof(uint32_t) * 4);
296  if (!tcside)
297  return AVERROR(ENOMEM);
298 
299  tc_sd = (uint32_t*)tcside->data;
300  tc_sd[0] = 1;
301  tc_sd[1] = tc;
302 
303  av_timecode_make_smpte_tc_string2(tcbuf, avctx->framerate,
304  tc_sd[1], 0, 0);
305  av_dict_set(&p->metadata, "timecode", tcbuf, 0);
306  }
307  }
308 
309  /* color range from television header */
310  if (offset >= 1964 + 4) {
311  buf = avpkt->data + 1952;
312  i = read32(&buf, endian);
313 
314  buf = avpkt->data + 1964;
315  j = read32(&buf, endian);
316 
317  if (i != 0xFFFFFFFF && j != 0xFFFFFFFF) {
318  float minCV, maxCV;
319  minCV = av_int2float(i);
320  maxCV = av_int2float(j);
321  if (bits_per_color >= 1 &&
322  minCV == 0.0f && maxCV == ((1U<<bits_per_color) - 1)) {
323  avctx->color_range = AVCOL_RANGE_JPEG;
324  } else if (bits_per_color >= 8 &&
325  minCV == (1 <<(bits_per_color - 4)) &&
326  maxCV == (235<<(bits_per_color - 8))) {
327  avctx->color_range = AVCOL_RANGE_MPEG;
328  }
329  }
330  }
331 
332  switch (descriptor) {
333  case 1: // R
334  case 2: // G
335  case 3: // B
336  case 4: // A
337  case 6: // Y
338  elements = 1;
339  yuv = 1;
340  break;
341  case 50: // RGB
342  elements = 3;
343  yuv = 0;
344  break;
345  case 52: // ABGR
346  case 51: // RGBA
347  elements = 4;
348  yuv = 0;
349  break;
350  case 100: // UYVY422
351  elements = 2;
352  yuv = 1;
353  break;
354  case 102: // UYV444
355  elements = 3;
356  yuv = 1;
357  break;
358  case 103: // UYVA4444
359  elements = 4;
360  yuv = 1;
361  break;
362  default:
363  avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
364  return AVERROR_PATCHWELCOME;
365  }
366 
367  switch (bits_per_color) {
368  case 8:
369  stride = avctx->width * elements;
370  break;
371  case 10:
372  if (!packing) {
373  av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
374  return -1;
375  }
376  stride = (avctx->width * elements + 2) / 3 * 4;
377  break;
378  case 12:
379  stride = avctx->width * elements;
380  if (packing) {
381  stride *= 2;
382  } else {
383  stride *= 3;
384  if (stride % 8) {
385  stride /= 8;
386  stride++;
387  stride *= 8;
388  }
389  stride /= 2;
390  }
391  break;
392  case 16:
393  stride = 2 * avctx->width * elements;
394  break;
395  case 32:
396  stride = 4 * avctx->width * elements;
397  break;
398  case 1:
399  case 64:
400  avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
401  return AVERROR_PATCHWELCOME;
402  default:
403  return AVERROR_INVALIDDATA;
404  }
405 
406  switch (color_trc) {
407  case DPX_TRC_LINEAR:
408  avctx->color_trc = AVCOL_TRC_LINEAR;
409  break;
410  case DPX_TRC_SMPTE_274:
411  case DPX_TRC_ITU_R_709_4:
412  avctx->color_trc = AVCOL_TRC_BT709;
413  break;
414  case DPX_TRC_ITU_R_601_625:
415  case DPX_TRC_ITU_R_601_525:
416  case DPX_TRC_SMPTE_170:
417  avctx->color_trc = AVCOL_TRC_SMPTE170M;
418  break;
419  case DPX_TRC_ITU_R_624_4_PAL:
420  avctx->color_trc = AVCOL_TRC_GAMMA28;
421  break;
422  case DPX_TRC_USER_DEFINED:
423  case DPX_TRC_UNSPECIFIED_VIDEO:
424  /* Nothing to do */
425  break;
426  default:
427  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX transfer characteristic "
428  "%d to color_trc.\n", color_trc);
429  break;
430  }
431 
432  switch (color_spec) {
433  case DPX_COL_SPEC_SMPTE_274:
434  case DPX_COL_SPEC_ITU_R_709_4:
435  avctx->color_primaries = AVCOL_PRI_BT709;
436  break;
437  case DPX_COL_SPEC_ITU_R_601_625:
438  case DPX_COL_SPEC_ITU_R_624_4_PAL:
439  avctx->color_primaries = AVCOL_PRI_BT470BG;
440  break;
441  case DPX_COL_SPEC_ITU_R_601_525:
442  case DPX_COL_SPEC_SMPTE_170:
443  avctx->color_primaries = AVCOL_PRI_SMPTE170M;
444  break;
445  case DPX_COL_SPEC_USER_DEFINED:
446  case DPX_COL_SPEC_UNSPECIFIED_VIDEO:
447  /* Nothing to do */
448  break;
449  default:
450  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX color specification "
451  "%d to color_primaries.\n", color_spec);
452  break;
453  }
454 
455  if (yuv) {
456  switch (color_spec) {
457  case DPX_COL_SPEC_SMPTE_274:
458  case DPX_COL_SPEC_ITU_R_709_4:
459  avctx->colorspace = AVCOL_SPC_BT709;
460  break;
461  case DPX_COL_SPEC_ITU_R_601_625:
462  case DPX_COL_SPEC_ITU_R_624_4_PAL:
463  avctx->colorspace = AVCOL_SPC_BT470BG;
464  break;
465  case DPX_COL_SPEC_ITU_R_601_525:
466  case DPX_COL_SPEC_SMPTE_170:
467  avctx->colorspace = AVCOL_SPC_SMPTE170M;
468  break;
469  case DPX_COL_SPEC_USER_DEFINED:
470  case DPX_COL_SPEC_UNSPECIFIED_VIDEO:
471  /* Nothing to do */
472  break;
473  default:
474  av_log(avctx, AV_LOG_INFO, "Cannot map DPX color specification "
475  "%d to colorspace.\n", color_spec);
476  break;
477  }
478  } else {
479  avctx->colorspace = AVCOL_SPC_RGB;
480  }
481 
482  // Table 3c: Runs will always break at scan line boundaries. Packing
483  // will always break to the next 32-bit word at scan-line boundaries.
484  // Unfortunately, the encoder produced invalid files, so attempt
485  // to detect it
486  need_align = FFALIGN(stride, 4);
487  if (need_align*avctx->height + (int64_t)offset > avpkt->size) {
488  // Alignment seems unappliable, try without
489  if (stride*avctx->height + (int64_t)offset > avpkt->size) {
490  av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
491  return AVERROR_INVALIDDATA;
492  } else {
493  av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
494  "alignment.\n");
495  need_align = 0;
496  }
497  } else {
498  need_align -= stride;
499  stride = FFALIGN(stride, 4);
500  }
501 
502  switch (1000 * descriptor + 10 * bits_per_color + endian) {
503  case 1081:
504  case 1080:
505  case 2081:
506  case 2080:
507  case 3081:
508  case 3080:
509  case 4081:
510  case 4080:
511  case 6081:
512  case 6080:
513  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
514  break;
515  case 6121:
516  case 6120:
517  avctx->pix_fmt = AV_PIX_FMT_GRAY12;
518  break;
519  case 1320:
520  case 2320:
521  case 3320:
522  case 4320:
523  case 6320:
524  avctx->pix_fmt = AV_PIX_FMT_GRAYF32LE;
525  break;
526  case 1321:
527  case 2321:
528  case 3321:
529  case 4321:
530  case 6321:
531  avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
532  break;
533  case 50081:
534  case 50080:
535  avctx->pix_fmt = AV_PIX_FMT_RGB24;
536  break;
537  case 52081:
538  case 52080:
539  avctx->pix_fmt = AV_PIX_FMT_ABGR;
540  break;
541  case 51081:
542  case 51080:
543  avctx->pix_fmt = AV_PIX_FMT_RGBA;
544  break;
545  case 50100:
546  case 50101:
547  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
548  break;
549  case 51100:
550  case 51101:
551  avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
552  break;
553  case 50120:
554  case 50121:
555  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
556  break;
557  case 51120:
558  case 51121:
559  avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
560  break;
561  case 6100:
562  case 6101:
563  avctx->pix_fmt = AV_PIX_FMT_GRAY10;
564  break;
565  case 6161:
566  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
567  break;
568  case 6160:
569  avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
570  break;
571  case 50161:
572  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
573  break;
574  case 50160:
575  avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
576  break;
577  case 51161:
578  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
579  break;
580  case 51160:
581  avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
582  break;
583  case 50320:
584  avctx->pix_fmt = AV_PIX_FMT_GBRPF32LE;
585  break;
586  case 50321:
587  avctx->pix_fmt = AV_PIX_FMT_GBRPF32BE;
588  break;
589  case 51320:
590  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32LE;
591  break;
592  case 51321:
593  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32BE;
594  break;
595  case 100081:
596  avctx->pix_fmt = AV_PIX_FMT_UYVY422;
597  break;
598  case 102081:
599  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
600  break;
601  case 103081:
602  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
603  break;
604  default:
605  av_log(avctx, AV_LOG_ERROR, "Unsupported format %d\n",
606  1000 * descriptor + 10 * bits_per_color + endian);
607  return AVERROR_PATCHWELCOME;
608  }
609 
610  ff_set_sar(avctx, avctx->sample_aspect_ratio);
611 
612  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
613  return ret;
614 
615  av_strlcpy(creator, avpkt->data + 160, 100);
616  creator[100] = '\0';
617  av_dict_set(&p->metadata, "Creator", creator, 0);
618 
619  av_strlcpy(input_device, avpkt->data + 1556, 32);
620  input_device[32] = '\0';
621  av_dict_set(&p->metadata, "Input Device", input_device, 0);
622 
623  // Some devices do not pad 10bit samples to whole 32bit words per row
624  if (!memcmp(input_device, "Scanity", 7) ||
625  !memcmp(creator, "Lasergraphics Inc.", 18)) {
626  unpadded_10bit = 1;
627  }
628 
629  // Move pointer to offset from start of file
630  buf = avpkt->data + offset;
631 
632  for (i=0; i<AV_NUM_DATA_POINTERS; i++)
633  ptr[i] = p->data[i];
634 
635  switch (bits_per_color) {
636  case 10:
637  for (x = 0; x < avctx->height; x++) {
638  uint16_t *dst[4] = {(uint16_t*)ptr[0],
639  (uint16_t*)ptr[1],
640  (uint16_t*)ptr[2],
641  (uint16_t*)ptr[3]};
642  int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;
643  for (y = 0; y < avctx->width; y++) {
644  if (elements >= 3)
645  *dst[2]++ = read10in32(&buf, &rgbBuffer,
646  &n_datum, endian, shift);
647  if (elements == 1)
648  *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,
649  &n_datum, endian, shift);
650  else
651  *dst[0]++ = read10in32(&buf, &rgbBuffer,
652  &n_datum, endian, shift);
653  if (elements >= 2)
654  *dst[1]++ = read10in32(&buf, &rgbBuffer,
655  &n_datum, endian, shift);
656  if (elements == 4)
657  *dst[3]++ =
658  read10in32(&buf, &rgbBuffer,
659  &n_datum, endian, shift);
660  }
661  if (!unpadded_10bit)
662  n_datum = 0;
663  for (i = 0; i < elements; i++)
664  ptr[i] += p->linesize[i];
665  }
666  break;
667  case 12:
668  for (x = 0; x < avctx->height; x++) {
669  uint16_t *dst[4] = {(uint16_t*)ptr[0],
670  (uint16_t*)ptr[1],
671  (uint16_t*)ptr[2],
672  (uint16_t*)ptr[3]};
673  int shift = packing == 1 ? 4 : 0;
674  for (y = 0; y < avctx->width; y++) {
675  if (packing) {
676  if (elements >= 3)
677  *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;
678  *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;
679  if (elements >= 2)
680  *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;
681  if (elements == 4)
682  *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;
683  } else {
684  if (elements >= 3)
685  *dst[2]++ = read12in32(&buf, &rgbBuffer,
686  &n_datum, endian);
687  *dst[0]++ = read12in32(&buf, &rgbBuffer,
688  &n_datum, endian);
689  if (elements >= 2)
690  *dst[1]++ = read12in32(&buf, &rgbBuffer,
691  &n_datum, endian);
692  if (elements == 4)
693  *dst[3]++ = read12in32(&buf, &rgbBuffer,
694  &n_datum, endian);
695  }
696  }
697  n_datum = 0;
698  for (i = 0; i < elements; i++)
699  ptr[i] += p->linesize[i];
700  // Jump to next aligned position
701  buf += need_align;
702  }
703  break;
704  case 32:
705  if (elements == 1) {
706  av_image_copy_plane(ptr[0], p->linesize[0],
707  buf, stride,
708  elements * avctx->width * 4, avctx->height);
709  } else {
710  for (y = 0; y < avctx->height; y++) {
711  ptr[0] = p->data[0] + y * p->linesize[0];
712  ptr[1] = p->data[1] + y * p->linesize[1];
713  ptr[2] = p->data[2] + y * p->linesize[2];
714  ptr[3] = p->data[3] + y * p->linesize[3];
715  for (x = 0; x < avctx->width; x++) {
716  AV_WN32(ptr[2], AV_RN32(buf));
717  AV_WN32(ptr[0], AV_RN32(buf + 4));
718  AV_WN32(ptr[1], AV_RN32(buf + 8));
719  if (avctx->pix_fmt == AV_PIX_FMT_GBRAPF32BE ||
720  avctx->pix_fmt == AV_PIX_FMT_GBRAPF32LE) {
721  AV_WN32(ptr[3], AV_RN32(buf + 12));
722  buf += 4;
723  ptr[3] += 4;
724  }
725 
726  buf += 12;
727  ptr[2] += 4;
728  ptr[0] += 4;
729  ptr[1] += 4;
730  }
731  }
732  }
733  break;
734  case 16:
735  elements *= 2;
736  case 8:
737  if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P
738  || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
739  for (x = 0; x < avctx->height; x++) {
740  ptr[0] = p->data[0] + x * p->linesize[0];
741  ptr[1] = p->data[1] + x * p->linesize[1];
742  ptr[2] = p->data[2] + x * p->linesize[2];
743  ptr[3] = p->data[3] + x * p->linesize[3];
744  for (y = 0; y < avctx->width; y++) {
745  *ptr[1]++ = *buf++;
746  *ptr[0]++ = *buf++;
747  *ptr[2]++ = *buf++;
748  if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
749  *ptr[3]++ = *buf++;
750  }
751  }
752  } else {
753  av_image_copy_plane(ptr[0], p->linesize[0],
754  buf, stride,
755  elements * avctx->width, avctx->height);
756  }
757  break;
758  }
759 
760  *got_frame = 1;
761 
762  return buf_size;
763 }
764 
765 const AVCodec ff_dpx_decoder = {
766  .name = "dpx",
767  .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
768  .type = AVMEDIA_TYPE_VIDEO,
769  .id = AV_CODEC_ID_DPX,
770  .decode = decode_frame,
771  .capabilities = AV_CODEC_CAP_DR1,
772 };
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
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:54
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
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:605
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:503
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:151
DPX_COL_SPEC_USER_DEFINED
@ DPX_COL_SPEC_USER_DEFINED
Definition: dpx.c:48
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
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:953
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:311
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:87
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:597
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:308
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
DPX_TRC_Z_LINEAR
@ DPX_TRC_Z_LINEAR
Definition: dpx.c:43
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:524
DPX_TRC
DPX_TRC
Definition: dpx.c:31
intfloat.h
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:331
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
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:1710
DPX_TRC_SMPTE_274
@ DPX_TRC_SMPTE_274
Definition: dpx.c:37
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:529
DPX_TRC_ITU_R_601_625
@ DPX_TRC_ITU_R_601_625
Definition: dpx.c:39
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dpx.c:152
U
#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:420
timecode.h
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:500
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:38
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:946
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:424
DPX_TRC_SMPTE_170
@ DPX_TRC_SMPTE_170
Definition: dpx.c:41
intreadwrite.h
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:425
DPX_TRC_Z_HOMOGENEOUS
@ DPX_TRC_Z_HOMOGENEOUS
Definition: dpx.c:44
DPX_TRC_PRINTING_DENSITY
@ DPX_TRC_PRINTING_DENSITY
Definition: dpx.c:33
DPX_COL_SPEC_SMPTE_170
@ DPX_COL_SPEC_SMPTE_170
Definition: dpx.c:57
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:530
DPX_TRC_LOGARITHMIC
@ DPX_TRC_LOGARITHMIC
Definition: dpx.c:35
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1425
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
f
#define f(width, name)
Definition: cbs_vp9.c:255
DPX_COL_SPEC_SMPTE_274
@ DPX_COL_SPEC_SMPTE_274
Definition: dpx.c:53
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:476
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:477
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:385
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:310
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:967
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:471
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
DPX_COL_SPEC_PRINTING_DENSITY
@ DPX_COL_SPEC_PRINTING_DENSITY
Definition: dpx.c:49
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
c
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:120
DPX_TRC_ITU_R_624_4_PAL
@ DPX_TRC_ITU_R_624_4_PAL
Definition: dpx.c:42
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
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: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
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:318
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:225
DPX_COL_SPEC_ITU_R_601_625
@ DPX_COL_SPEC_ITU_R_601_625
Definition: dpx.c:55
DPX_TRC_UNSPECIFIED_VIDEO
@ DPX_TRC_UNSPECIFIED_VIDEO
Definition: dpx.c:36
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
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:496
DPX_COL_SPEC_UNSPECIFIED_VIDEO
@ DPX_COL_SPEC_UNSPECIFIED_VIDEO
Definition: dpx.c:52
read16
static unsigned int read16(const uint8_t **ptr, int is_big)
Definition: dpx.c:63
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:136
ff_dpx_decoder
const AVCodec ff_dpx_decoder
Definition: dpx.c:765
read10in32
static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)
Definition: dpx.c:105
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:421
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:34
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:309
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:580
avcodec.h
DPX_COL_SPEC_ITU_R_624_4_PAL
@ DPX_COL_SPEC_ITU_R_624_4_PAL
Definition: dpx.c:58
ret
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:330
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:101
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:608
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:501
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:83
tc
#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:86
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:223
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
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:556
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:362
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:83
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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
h
h
Definition: vp9dsp_template.c:2038
read32
static unsigned int read32(const uint8_t **ptr, int is_big)
Definition: dpx.c:75
avstring.h
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:386
DPX_COL_SPEC
DPX_COL_SPEC
Definition: dpx.c:47
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:525
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:753
DPX_TRC_USER_DEFINED
@ DPX_TRC_USER_DEFINED
Definition: dpx.c:32
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:40
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
DPX_COL_SPEC_ITU_R_601_525
@ DPX_COL_SPEC_ITU_R_601_525
Definition: dpx.c:56
Generated on Wed Aug 24 2022 21:37:32 for FFmpeg by   doxygen 1.8.17