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];
163  char input_device[33];
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 6: // Y
331  elements = 1;
332  yuv = 1;
333  break;
334  case 50: // RGB
335  elements = 3;
336  yuv = 0;
337  break;
338  case 52: // ABGR
339  case 51: // RGBA
340  elements = 4;
341  yuv = 0;
342  break;
343  case 100: // UYVY422
344  elements = 2;
345  yuv = 1;
346  break;
347  case 102: // UYV444
348  elements = 3;
349  yuv = 1;
350  break;
351  case 103: // UYVA4444
352  elements = 4;
353  yuv = 1;
354  break;
355  default:
356  avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
357  return AVERROR_PATCHWELCOME;
358  }
359 
360  switch (bits_per_color) {
361  case 8:
362  stride = avctx->width * elements;
363  break;
364  case 10:
365  if (!packing) {
366  av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
367  return -1;
368  }
369  stride = (avctx->width * elements + 2) / 3 * 4;
370  break;
371  case 12:
372  stride = avctx->width * elements;
373  if (packing) {
374  stride *= 2;
375  } else {
376  stride *= 3;
377  if (stride % 8) {
378  stride /= 8;
379  stride++;
380  stride *= 8;
381  }
382  stride /= 2;
383  }
384  break;
385  case 16:
386  stride = 2 * avctx->width * elements;
387  break;
388  case 1:
389  case 32:
390  case 64:
391  avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
392  return AVERROR_PATCHWELCOME;
393  default:
394  return AVERROR_INVALIDDATA;
395  }
396 
397  switch (color_trc) {
398  case DPX_TRC_LINEAR:
399  avctx->color_trc = AVCOL_TRC_LINEAR;
400  break;
401  case DPX_TRC_SMPTE_274:
402  case DPX_TRC_ITU_R_709_4:
403  avctx->color_trc = AVCOL_TRC_BT709;
404  break;
407  case DPX_TRC_SMPTE_170:
409  break;
411  avctx->color_trc = AVCOL_TRC_GAMMA28;
412  break;
415  /* Nothing to do */
416  break;
417  default:
418  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX transfer characteristic "
419  "%d to color_trc.\n", color_trc);
420  break;
421  }
422 
423  switch (color_spec) {
427  break;
431  break;
435  break;
438  /* Nothing to do */
439  break;
440  default:
441  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX color specification "
442  "%d to color_primaries.\n", color_spec);
443  break;
444  }
445 
446  if (yuv) {
447  switch (color_spec) {
450  avctx->colorspace = AVCOL_SPC_BT709;
451  break;
454  avctx->colorspace = AVCOL_SPC_BT470BG;
455  break;
459  break;
462  /* Nothing to do */
463  break;
464  default:
465  av_log(avctx, AV_LOG_INFO, "Cannot map DPX color specification "
466  "%d to colorspace.\n", color_spec);
467  break;
468  }
469  } else {
470  avctx->colorspace = AVCOL_SPC_RGB;
471  }
472 
473  // Table 3c: Runs will always break at scan line boundaries. Packing
474  // will always break to the next 32-bit word at scan-line boundaries.
475  // Unfortunately, the encoder produced invalid files, so attempt
476  // to detect it
477  need_align = FFALIGN(stride, 4);
478  if (need_align*avctx->height + (int64_t)offset > avpkt->size) {
479  // Alignment seems unappliable, try without
480  if (stride*avctx->height + (int64_t)offset > avpkt->size) {
481  av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
482  return AVERROR_INVALIDDATA;
483  } else {
484  av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
485  "alignment.\n");
486  need_align = 0;
487  }
488  } else {
489  need_align -= stride;
490  stride = FFALIGN(stride, 4);
491  }
492 
493  switch (1000 * descriptor + 10 * bits_per_color + endian) {
494  case 6081:
495  case 6080:
496  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
497  break;
498  case 6121:
499  case 6120:
500  avctx->pix_fmt = AV_PIX_FMT_GRAY12;
501  break;
502  case 50081:
503  case 50080:
504  avctx->pix_fmt = AV_PIX_FMT_RGB24;
505  break;
506  case 52081:
507  case 52080:
508  avctx->pix_fmt = AV_PIX_FMT_ABGR;
509  break;
510  case 51081:
511  case 51080:
512  avctx->pix_fmt = AV_PIX_FMT_RGBA;
513  break;
514  case 50100:
515  case 50101:
516  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
517  break;
518  case 51100:
519  case 51101:
520  avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
521  break;
522  case 50120:
523  case 50121:
524  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
525  break;
526  case 51120:
527  case 51121:
528  avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
529  break;
530  case 6100:
531  case 6101:
532  avctx->pix_fmt = AV_PIX_FMT_GRAY10;
533  break;
534  case 6161:
535  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
536  break;
537  case 6160:
538  avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
539  break;
540  case 50161:
541  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
542  break;
543  case 50160:
544  avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
545  break;
546  case 51161:
547  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
548  break;
549  case 51160:
550  avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
551  break;
552  case 100081:
553  avctx->pix_fmt = AV_PIX_FMT_UYVY422;
554  break;
555  case 102081:
556  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
557  break;
558  case 103081:
559  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
560  break;
561  default:
562  av_log(avctx, AV_LOG_ERROR, "Unsupported format\n");
563  return AVERROR_PATCHWELCOME;
564  }
565 
566  ff_set_sar(avctx, avctx->sample_aspect_ratio);
567 
568  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
569  return ret;
570 
571  av_strlcpy(creator, avpkt->data + 160, 100);
572  creator[100] = '\0';
573  av_dict_set(&p->metadata, "Creator", creator, 0);
574 
575  av_strlcpy(input_device, avpkt->data + 1556, 32);
576  input_device[32] = '\0';
577  av_dict_set(&p->metadata, "Input Device", input_device, 0);
578 
579  // Some devices do not pad 10bit samples to whole 32bit words per row
580  if (!memcmp(input_device, "Scanity", 7) ||
581  !memcmp(creator, "Lasergraphics Inc.", 18)) {
582  unpadded_10bit = 1;
583  }
584 
585  // Move pointer to offset from start of file
586  buf = avpkt->data + offset;
587 
588  for (i=0; i<AV_NUM_DATA_POINTERS; i++)
589  ptr[i] = p->data[i];
590 
591  switch (bits_per_color) {
592  case 10:
593  for (x = 0; x < avctx->height; x++) {
594  uint16_t *dst[4] = {(uint16_t*)ptr[0],
595  (uint16_t*)ptr[1],
596  (uint16_t*)ptr[2],
597  (uint16_t*)ptr[3]};
598  int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;
599  for (y = 0; y < avctx->width; y++) {
600  if (elements >= 3)
601  *dst[2]++ = read10in32(&buf, &rgbBuffer,
602  &n_datum, endian, shift);
603  if (elements == 1)
604  *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,
605  &n_datum, endian, shift);
606  else
607  *dst[0]++ = read10in32(&buf, &rgbBuffer,
608  &n_datum, endian, shift);
609  if (elements >= 2)
610  *dst[1]++ = read10in32(&buf, &rgbBuffer,
611  &n_datum, endian, shift);
612  if (elements == 4)
613  *dst[3]++ =
614  read10in32(&buf, &rgbBuffer,
615  &n_datum, endian, shift);
616  }
617  if (!unpadded_10bit)
618  n_datum = 0;
619  for (i = 0; i < elements; i++)
620  ptr[i] += p->linesize[i];
621  }
622  break;
623  case 12:
624  for (x = 0; x < avctx->height; x++) {
625  uint16_t *dst[4] = {(uint16_t*)ptr[0],
626  (uint16_t*)ptr[1],
627  (uint16_t*)ptr[2],
628  (uint16_t*)ptr[3]};
629  int shift = packing == 1 ? 4 : 0;
630  for (y = 0; y < avctx->width; y++) {
631  if (packing) {
632  if (elements >= 3)
633  *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;
634  *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;
635  if (elements >= 2)
636  *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;
637  if (elements == 4)
638  *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;
639  } else {
640  if (elements >= 3)
641  *dst[2]++ = read12in32(&buf, &rgbBuffer,
642  &n_datum, endian);
643  *dst[0]++ = read12in32(&buf, &rgbBuffer,
644  &n_datum, endian);
645  if (elements >= 2)
646  *dst[1]++ = read12in32(&buf, &rgbBuffer,
647  &n_datum, endian);
648  if (elements == 4)
649  *dst[3]++ = read12in32(&buf, &rgbBuffer,
650  &n_datum, endian);
651  }
652  }
653  n_datum = 0;
654  for (i = 0; i < elements; i++)
655  ptr[i] += p->linesize[i];
656  // Jump to next aligned position
657  buf += need_align;
658  }
659  break;
660  case 16:
661  elements *= 2;
662  case 8:
663  if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P
664  || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
665  for (x = 0; x < avctx->height; x++) {
666  ptr[0] = p->data[0] + x * p->linesize[0];
667  ptr[1] = p->data[1] + x * p->linesize[1];
668  ptr[2] = p->data[2] + x * p->linesize[2];
669  ptr[3] = p->data[3] + x * p->linesize[3];
670  for (y = 0; y < avctx->width; y++) {
671  *ptr[1]++ = *buf++;
672  *ptr[0]++ = *buf++;
673  *ptr[2]++ = *buf++;
674  if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
675  *ptr[3]++ = *buf++;
676  }
677  }
678  } else {
679  av_image_copy_plane(ptr[0], p->linesize[0],
680  buf, stride,
681  elements * avctx->width, avctx->height);
682  }
683  break;
684  }
685 
686  *got_frame = 1;
687 
688  return buf_size;
689 }
690 
692  .name = "dpx",
693  .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
694  .type = AVMEDIA_TYPE_VIDEO,
695  .id = AV_CODEC_ID_DPX,
696  .decode = decode_frame,
697  .capabilities = AV_CODEC_CAP_DR1,
698 };
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:514
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dpx.c:152
AVRational framerate
Definition: avcodec.h:2084
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:315
version
Definition: libkvazaar.c:320
static int shift(int a, int b)
Definition: sonic.c:82
static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)
Definition: dpx.c:87
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
"Linear transfer characteristics"
Definition: pixfmt.h:492
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
else temp
Definition: vf_mcdeint.c:256
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:106
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
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
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1166
int num
Numerator.
Definition: rational.h:59
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
int size
Definition: packet.h:364
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
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:910
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:519
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
#define tc
Definition: regdef.h:69
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1762
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:91
AVCodec.
Definition: codec.h:190
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:513
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
uint8_t
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
AVCodec ff_dpx_decoder
Definition: dpx.c:691
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
#define f(width, name)
Definition: cbs_vp9.c:255
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
static unsigned int read16(const uint8_t **ptr, int is_big)
Definition: dpx.c:63
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
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:91
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
Structure to hold side data for an AVFrame.
Definition: frame.h:220
static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)
Definition: dpx.c:105
uint8_t * data
Definition: packet.h:363
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:121
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
AVDictionary * metadata
metadata.
Definition: frame.h:600
static unsigned int read32(const uint8_t **ptr, int is_big)
Definition: dpx.c:75
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
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:460
const char * name
Name of the codec implementation.
Definition: codec.h:197
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
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big)
Definition: dpx.c:120
DPX_COL_SPEC
Definition: dpx.c:47
int width
picture width / height.
Definition: avcodec.h:704
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
uint8_t w
Definition: llviddspenc.c:39
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:465
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1145
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
Full range content.
Definition: pixfmt.h:586
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
also ITU-R BT1361
Definition: pixfmt.h:485
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define av_bswap32
Definition: bswap.h:33
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:490
Libavcodec external API header.
Timecode helpers header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
main external API structure.
Definition: avcodec.h:531
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1876
uint8_t * data
Definition: frame.h:222
DPX_TRC
Definition: dpx.c:31
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
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:726
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1159
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1152
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
Narrow or limited range content.
Definition: pixfmt.h:569
Y , 8bpp.
Definition: pixfmt.h:74
common internal api header.
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
also ITU-R BT470BG
Definition: pixfmt.h:489
int den
Denominator.
Definition: rational.h:60
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:466
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
#define stride
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
#define MKTAG(a, b, c, d)
Definition: common.h:405
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
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
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33