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 {
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,
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;
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  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);
293  if (!tcside)
294  return AVERROR(ENOMEM);
295 
296  tc_sd = (uint32_t*)tcside->data;
297  tc_sd[0] = 1;
298  tc_sd[1] = tc;
299 
301  tc_sd[1], 0, 0);
302  av_dict_set(&p->metadata, "timecode", tcbuf, 0);
303  }
304  }
305 
306  /* color range from television header */
307  if (offset >= 1964 + 4) {
308  buf = avpkt->data + 1952;
309  i = read32(&buf, endian);
310 
311  buf = avpkt->data + 1964;
312  j = read32(&buf, endian);
313 
314  if (i != 0xFFFFFFFF && j != 0xFFFFFFFF) {
315  float minCV, maxCV;
316  minCV = av_int2float(i);
317  maxCV = av_int2float(j);
318  if (bits_per_color >= 1 &&
319  minCV == 0.0f && maxCV == ((1<<bits_per_color) - 1)) {
320  avctx->color_range = AVCOL_RANGE_JPEG;
321  } else if (bits_per_color >= 8 &&
322  minCV == (1 <<(bits_per_color - 4)) &&
323  maxCV == (235<<(bits_per_color - 8))) {
324  avctx->color_range = AVCOL_RANGE_MPEG;
325  }
326  }
327  }
328 
329  switch (descriptor) {
330  case 1: // R
331  case 2: // G
332  case 3: // B
333  case 4: // A
334  case 6: // Y
335  elements = 1;
336  yuv = 1;
337  break;
338  case 50: // RGB
339  elements = 3;
340  yuv = 0;
341  break;
342  case 52: // ABGR
343  case 51: // RGBA
344  elements = 4;
345  yuv = 0;
346  break;
347  case 100: // UYVY422
348  elements = 2;
349  yuv = 1;
350  break;
351  case 102: // UYV444
352  elements = 3;
353  yuv = 1;
354  break;
355  case 103: // UYVA4444
356  elements = 4;
357  yuv = 1;
358  break;
359  default:
360  avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
361  return AVERROR_PATCHWELCOME;
362  }
363 
364  switch (bits_per_color) {
365  case 8:
366  stride = avctx->width * elements;
367  break;
368  case 10:
369  if (!packing) {
370  av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
371  return -1;
372  }
373  stride = (avctx->width * elements + 2) / 3 * 4;
374  break;
375  case 12:
376  stride = avctx->width * elements;
377  if (packing) {
378  stride *= 2;
379  } else {
380  stride *= 3;
381  if (stride % 8) {
382  stride /= 8;
383  stride++;
384  stride *= 8;
385  }
386  stride /= 2;
387  }
388  break;
389  case 16:
390  stride = 2 * avctx->width * elements;
391  break;
392  case 32:
393  stride = 4 * avctx->width * elements;
394  break;
395  case 1:
396  case 64:
397  avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
398  return AVERROR_PATCHWELCOME;
399  default:
400  return AVERROR_INVALIDDATA;
401  }
402 
403  switch (color_trc) {
404  case DPX_TRC_LINEAR:
405  avctx->color_trc = AVCOL_TRC_LINEAR;
406  break;
407  case DPX_TRC_SMPTE_274:
408  case DPX_TRC_ITU_R_709_4:
409  avctx->color_trc = AVCOL_TRC_BT709;
410  break;
413  case DPX_TRC_SMPTE_170:
415  break;
417  avctx->color_trc = AVCOL_TRC_GAMMA28;
418  break;
421  /* Nothing to do */
422  break;
423  default:
424  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX transfer characteristic "
425  "%d to color_trc.\n", color_trc);
426  break;
427  }
428 
429  switch (color_spec) {
433  break;
437  break;
441  break;
444  /* Nothing to do */
445  break;
446  default:
447  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX color specification "
448  "%d to color_primaries.\n", color_spec);
449  break;
450  }
451 
452  if (yuv) {
453  switch (color_spec) {
456  avctx->colorspace = AVCOL_SPC_BT709;
457  break;
460  avctx->colorspace = AVCOL_SPC_BT470BG;
461  break;
465  break;
468  /* Nothing to do */
469  break;
470  default:
471  av_log(avctx, AV_LOG_INFO, "Cannot map DPX color specification "
472  "%d to colorspace.\n", color_spec);
473  break;
474  }
475  } else {
476  avctx->colorspace = AVCOL_SPC_RGB;
477  }
478 
479  // Table 3c: Runs will always break at scan line boundaries. Packing
480  // will always break to the next 32-bit word at scan-line boundaries.
481  // Unfortunately, the encoder produced invalid files, so attempt
482  // to detect it
483  need_align = FFALIGN(stride, 4);
484  if (need_align*avctx->height + (int64_t)offset > avpkt->size) {
485  // Alignment seems unappliable, try without
486  if (stride*avctx->height + (int64_t)offset > avpkt->size) {
487  av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
488  return AVERROR_INVALIDDATA;
489  } else {
490  av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
491  "alignment.\n");
492  need_align = 0;
493  }
494  } else {
495  need_align -= stride;
496  stride = FFALIGN(stride, 4);
497  }
498 
499  switch (1000 * descriptor + 10 * bits_per_color + endian) {
500  case 1081:
501  case 1080:
502  case 2081:
503  case 2080:
504  case 3081:
505  case 3080:
506  case 4081:
507  case 4080:
508  case 6081:
509  case 6080:
510  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
511  break;
512  case 6121:
513  case 6120:
514  avctx->pix_fmt = AV_PIX_FMT_GRAY12;
515  break;
516  case 1320:
517  case 2320:
518  case 3320:
519  case 4320:
520  case 6320:
521  avctx->pix_fmt = AV_PIX_FMT_GRAYF32LE;
522  break;
523  case 1321:
524  case 2321:
525  case 3321:
526  case 4321:
527  case 6321:
528  avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
529  break;
530  case 50081:
531  case 50080:
532  avctx->pix_fmt = AV_PIX_FMT_RGB24;
533  break;
534  case 52081:
535  case 52080:
536  avctx->pix_fmt = AV_PIX_FMT_ABGR;
537  break;
538  case 51081:
539  case 51080:
540  avctx->pix_fmt = AV_PIX_FMT_RGBA;
541  break;
542  case 50100:
543  case 50101:
544  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
545  break;
546  case 51100:
547  case 51101:
548  avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
549  break;
550  case 50120:
551  case 50121:
552  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
553  break;
554  case 51120:
555  case 51121:
556  avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
557  break;
558  case 6100:
559  case 6101:
560  avctx->pix_fmt = AV_PIX_FMT_GRAY10;
561  break;
562  case 6161:
563  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
564  break;
565  case 6160:
566  avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
567  break;
568  case 50161:
569  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
570  break;
571  case 50160:
572  avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
573  break;
574  case 51161:
575  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
576  break;
577  case 51160:
578  avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
579  break;
580  case 50320:
581  avctx->pix_fmt = AV_PIX_FMT_GBRPF32LE;
582  break;
583  case 50321:
584  avctx->pix_fmt = AV_PIX_FMT_GBRPF32BE;
585  break;
586  case 51320:
588  break;
589  case 51321:
591  break;
592  case 100081:
593  avctx->pix_fmt = AV_PIX_FMT_UYVY422;
594  break;
595  case 102081:
596  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
597  break;
598  case 103081:
599  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
600  break;
601  default:
602  av_log(avctx, AV_LOG_ERROR, "Unsupported format %d\n",
603  1000 * descriptor + 10 * bits_per_color + endian);
604  return AVERROR_PATCHWELCOME;
605  }
606 
607  ff_set_sar(avctx, avctx->sample_aspect_ratio);
608 
609  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
610  return ret;
611 
612  av_strlcpy(creator, avpkt->data + 160, 100);
613  creator[100] = '\0';
614  av_dict_set(&p->metadata, "Creator", creator, 0);
615 
616  av_strlcpy(input_device, avpkt->data + 1556, 32);
617  input_device[32] = '\0';
618  av_dict_set(&p->metadata, "Input Device", input_device, 0);
619 
620  // Some devices do not pad 10bit samples to whole 32bit words per row
621  if (!memcmp(input_device, "Scanity", 7) ||
622  !memcmp(creator, "Lasergraphics Inc.", 18)) {
623  unpadded_10bit = 1;
624  }
625 
626  // Move pointer to offset from start of file
627  buf = avpkt->data + offset;
628 
629  for (i=0; i<AV_NUM_DATA_POINTERS; i++)
630  ptr[i] = p->data[i];
631 
632  switch (bits_per_color) {
633  case 10:
634  for (x = 0; x < avctx->height; x++) {
635  uint16_t *dst[4] = {(uint16_t*)ptr[0],
636  (uint16_t*)ptr[1],
637  (uint16_t*)ptr[2],
638  (uint16_t*)ptr[3]};
639  int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;
640  for (y = 0; y < avctx->width; y++) {
641  if (elements >= 3)
642  *dst[2]++ = read10in32(&buf, &rgbBuffer,
643  &n_datum, endian, shift);
644  if (elements == 1)
645  *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,
646  &n_datum, endian, shift);
647  else
648  *dst[0]++ = read10in32(&buf, &rgbBuffer,
649  &n_datum, endian, shift);
650  if (elements >= 2)
651  *dst[1]++ = read10in32(&buf, &rgbBuffer,
652  &n_datum, endian, shift);
653  if (elements == 4)
654  *dst[3]++ =
655  read10in32(&buf, &rgbBuffer,
656  &n_datum, endian, shift);
657  }
658  if (!unpadded_10bit)
659  n_datum = 0;
660  for (i = 0; i < elements; i++)
661  ptr[i] += p->linesize[i];
662  }
663  break;
664  case 12:
665  for (x = 0; x < avctx->height; x++) {
666  uint16_t *dst[4] = {(uint16_t*)ptr[0],
667  (uint16_t*)ptr[1],
668  (uint16_t*)ptr[2],
669  (uint16_t*)ptr[3]};
670  int shift = packing == 1 ? 4 : 0;
671  for (y = 0; y < avctx->width; y++) {
672  if (packing) {
673  if (elements >= 3)
674  *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;
675  *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;
676  if (elements >= 2)
677  *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;
678  if (elements == 4)
679  *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;
680  } else {
681  if (elements >= 3)
682  *dst[2]++ = read12in32(&buf, &rgbBuffer,
683  &n_datum, endian);
684  *dst[0]++ = read12in32(&buf, &rgbBuffer,
685  &n_datum, endian);
686  if (elements >= 2)
687  *dst[1]++ = read12in32(&buf, &rgbBuffer,
688  &n_datum, endian);
689  if (elements == 4)
690  *dst[3]++ = read12in32(&buf, &rgbBuffer,
691  &n_datum, endian);
692  }
693  }
694  n_datum = 0;
695  for (i = 0; i < elements; i++)
696  ptr[i] += p->linesize[i];
697  // Jump to next aligned position
698  buf += need_align;
699  }
700  break;
701  case 32:
702  if (elements == 1) {
703  av_image_copy_plane(ptr[0], p->linesize[0],
704  buf, stride,
705  elements * avctx->width * 4, avctx->height);
706  } else {
707  for (y = 0; y < avctx->height; y++) {
708  ptr[0] = p->data[0] + y * p->linesize[0];
709  ptr[1] = p->data[1] + y * p->linesize[1];
710  ptr[2] = p->data[2] + y * p->linesize[2];
711  ptr[3] = p->data[3] + y * p->linesize[3];
712  for (x = 0; x < avctx->width; x++) {
713  AV_WN32(ptr[2], AV_RN32(buf));
714  AV_WN32(ptr[0], AV_RN32(buf + 4));
715  AV_WN32(ptr[1], AV_RN32(buf + 8));
716  if (avctx->pix_fmt == AV_PIX_FMT_GBRAPF32BE ||
717  avctx->pix_fmt == AV_PIX_FMT_GBRAPF32LE) {
718  AV_WN32(ptr[3], AV_RN32(buf + 12));
719  buf += 4;
720  ptr[3] += 4;
721  }
722 
723  buf += 12;
724  ptr[2] += 4;
725  ptr[0] += 4;
726  ptr[1] += 4;
727  }
728  }
729  }
730  break;
731  case 16:
732  elements *= 2;
733  case 8:
734  if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P
735  || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
736  for (x = 0; x < avctx->height; x++) {
737  ptr[0] = p->data[0] + x * p->linesize[0];
738  ptr[1] = p->data[1] + x * p->linesize[1];
739  ptr[2] = p->data[2] + x * p->linesize[2];
740  ptr[3] = p->data[3] + x * p->linesize[3];
741  for (y = 0; y < avctx->width; y++) {
742  *ptr[1]++ = *buf++;
743  *ptr[0]++ = *buf++;
744  *ptr[2]++ = *buf++;
745  if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
746  *ptr[3]++ = *buf++;
747  }
748  }
749  } else {
750  av_image_copy_plane(ptr[0], p->linesize[0],
751  buf, stride,
752  elements * avctx->width, avctx->height);
753  }
754  break;
755  }
756 
757  *got_frame = 1;
758 
759  return buf_size;
760 }
761 
763  .name = "dpx",
764  .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
765  .type = AVMEDIA_TYPE_VIDEO,
766  .id = AV_CODEC_ID_DPX,
767  .decode = decode_frame,
768  .capabilities = AV_CODEC_CAP_DR1,
769 };
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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:177
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:1164
elements
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:492
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, buffer_size_t size)
Add a new side data to a frame.
Definition: frame.c:727
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
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:324
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:205
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:321
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:39
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:318
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
data
const char data[16]
Definition: mxf.c:142
DPX_TRC_Z_LINEAR
@ DPX_TRC_Z_LINEAR
Definition: dpx.c:43
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:513
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:341
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:373
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2071
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:518
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
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:415
timecode.h
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:489
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:1150
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
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:420
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
Definition: pixfmt.h:519
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:1747
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:465
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:466
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:320
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
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 RP177 Annex B
Definition: pixfmt.h:460
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:206
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:1893
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:370
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:325
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:228
DPX_COL_SPEC_ITU_R_601_625
@ DPX_COL_SPEC_ITU_R_601_625
Definition: dpx.c:55
ff_dpx_decoder
AVCodec ff_dpx_decoder
Definition: dpx.c:762
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:177
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:320
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:485
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
i
int i
Definition: input.c:407
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
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
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:416
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
uint8_t
uint8_t
Definition: audio_convert.c:194
DPX_TRC_LINEAR
@ DPX_TRC_LINEAR
Definition: dpx.c:34
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:319
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:569
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:340
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:99
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:610
temp
else temp
Definition: vf_mcdeint.c:259
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:490
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:82
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:84
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:226
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:346
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:709
bytestream.h
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:355
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:59
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:381
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 / SMPTE RP177 Annex B
Definition: pixfmt.h:514
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:915
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