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 "codec_internal.h"
30 #include "internal.h"
31 
32 enum DPX_TRC {
46 };
47 
51  /* 2 = N/A */
52  /* 3 = N/A */
60  /* 11 = N/A */
61  /* 12 = N/A */
62 };
63 
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 }
75 
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 }
87 
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;
92 
93  if (*n_datum)
94  (*n_datum)--;
95  else {
96  *lbuf = read32(ptr, is_big);
97  *n_datum = 2;
98  }
99 
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)
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 =
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 
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;
414  case DPX_TRC_SMPTE_170:
416  break;
418  avctx->color_trc = AVCOL_TRC_GAMMA28;
419  break;
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) {
434  break;
438  break;
442  break;
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) {
457  avctx->colorspace = AVCOL_SPC_BT709;
458  break;
461  avctx->colorspace = AVCOL_SPC_BT470BG;
462  break;
466  break;
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:
589  break;
590  case 51321:
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 
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,
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
w
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
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:1733
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
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: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
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:121
DPX_TRC_ITU_R_624_4_PAL
@ DPX_TRC_ITU_R_624_4_PAL
Definition: dpx.c:43
f
f
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
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
read16
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
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: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
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
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: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
h
h
Definition: vp9dsp_template.c:2038
read32
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
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