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