FFmpeg
dpx.c
Go to the documentation of this file.
1 /*
2  * DPX (.dpx) image decoder
3  * Copyright (c) 2009 Jimmy Christensen
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avstring.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/intfloat.h"
25 #include "libavutil/imgutils.h"
26 #include "libavutil/timecode.h"
27 #include "avcodec.h"
28 #include "codec_internal.h"
29 #include "decode.h"
30 #include "dpx.h"
31 
32 static unsigned int read16(const uint8_t **ptr, int is_big)
33 {
34  unsigned int temp;
35  if (is_big) {
36  temp = AV_RB16(*ptr);
37  } else {
38  temp = AV_RL16(*ptr);
39  }
40  *ptr += 2;
41  return temp;
42 }
43 
44 static unsigned int read32(const uint8_t **ptr, int is_big)
45 {
46  unsigned int temp;
47  if (is_big) {
48  temp = AV_RB32(*ptr);
49  } else {
50  temp = AV_RL32(*ptr);
51  }
52  *ptr += 4;
53  return temp;
54 }
55 
56 static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf,
57  int *n_datum, int is_big, int shift)
58 {
59  uint16_t temp;
60 
61  if (*n_datum)
62  (*n_datum)--;
63  else {
64  *lbuf = read32(ptr, is_big);
65  *n_datum = 2;
66  }
67 
68  temp = *lbuf >> shift & 0x3FF;
69  *lbuf = *lbuf >> 10;
70 
71  return temp;
72 }
73 
74 static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf,
75  int *n_datum, int is_big, int shift)
76 {
77  if (*n_datum)
78  (*n_datum)--;
79  else {
80  *lbuf = read32(ptr, is_big);
81  *n_datum = 2;
82  }
83 
84  *lbuf = *lbuf << 10 | *lbuf >> shift & 0x3FFFFF;
85 
86  return *lbuf & 0x3FF;
87 }
88 
89 static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf,
90  int *n_datum, int is_big)
91 {
92  if (*n_datum)
93  (*n_datum)--;
94  else {
95  *lbuf = read32(ptr, is_big);
96  *n_datum = 7;
97  }
98 
99  switch (*n_datum){
100  case 7: return *lbuf & 0xFFF;
101  case 6: return (*lbuf >> 12) & 0xFFF;
102  case 5: {
103  uint32_t c = *lbuf >> 24;
104  *lbuf = read32(ptr, is_big);
105  c |= *lbuf << 8;
106  return c & 0xFFF;
107  }
108  case 4: return (*lbuf >> 4) & 0xFFF;
109  case 3: return (*lbuf >> 16) & 0xFFF;
110  case 2: {
111  uint32_t c = *lbuf >> 28;
112  *lbuf = read32(ptr, is_big);
113  c |= *lbuf << 4;
114  return c & 0xFFF;
115  }
116  case 1: return (*lbuf >> 8) & 0xFFF;
117  default: return *lbuf >> 20;
118  }
119 }
120 
121 static int decode_frame(AVCodecContext *avctx, AVFrame *p,
122  int *got_frame, AVPacket *avpkt)
123 {
124  const uint8_t *buf = avpkt->data;
125  int buf_size = avpkt->size;
126  uint8_t *ptr[AV_NUM_DATA_POINTERS];
127  uint32_t header_version, version = 0;
128  char creator[101] = { 0 };
129  char input_device[33] = { 0 };
130 
131  unsigned int offset;
132  int magic_num, endian;
133  int x, y, stride, i, j, ret;
134  int w, h, bits_per_color, descriptor, elements, packing;
135  int yuv, color_trc, color_spec;
136  int encoding, need_align = 0, unpadded_10bit = 0;
137 
138  unsigned int rgbBuffer = 0;
139  int n_datum = 0;
140 
141  if (avpkt->size <= 1634) {
142  av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
143  return AVERROR_INVALIDDATA;
144  }
145 
146  magic_num = AV_RB32(buf);
147  buf += 4;
148 
149  /* Check if the files "magic number" is "SDPX" which means it uses
150  * big-endian or XPDS which is for little-endian files */
151  if (magic_num == AV_RL32("SDPX")) {
152  endian = 0;
153  } else if (magic_num == AV_RB32("SDPX")) {
154  endian = 1;
155  } else {
156  av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");
157  return AVERROR_INVALIDDATA;
158  }
159 
160  offset = read32(&buf, endian);
161  if (avpkt->size <= offset) {
162  av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");
163  return AVERROR_INVALIDDATA;
164  }
165 
166  header_version = read32(&buf, 0);
167  if (header_version == MKTAG('V','1','.','0'))
168  version = 1;
169  if (header_version == MKTAG('V','2','.','0'))
170  version = 2;
171  if (!version)
172  av_log(avctx, AV_LOG_WARNING, "Unknown header format version %s.\n",
173  av_fourcc2str(header_version));
174 
175  // Check encryption
176  buf = avpkt->data + 660;
177  ret = read32(&buf, endian);
178  if (ret != 0xFFFFFFFF) {
179  avpriv_report_missing_feature(avctx, "Encryption");
180  av_log(avctx, AV_LOG_WARNING, "The image is encrypted and may "
181  "not properly decode.\n");
182  }
183 
184  // Need to end in 0x304 offset from start of file
185  buf = avpkt->data + 0x304;
186  w = read32(&buf, endian);
187  h = read32(&buf, endian);
188 
189  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
190  return ret;
191 
192  // Need to end in 0x320 to read the descriptor
193  buf += 20;
194  descriptor = buf[0];
195  color_trc = buf[1];
196  color_spec = buf[2];
197 
198  // Need to end in 0x323 to read the bits per color
199  buf += 3;
200  avctx->bits_per_raw_sample =
201  bits_per_color = buf[0];
202  buf++;
203  packing = read16(&buf, endian);
204  encoding = read16(&buf, endian);
205 
206  if (encoding) {
207  avpriv_report_missing_feature(avctx, "Encoding %d", encoding);
208  return AVERROR_PATCHWELCOME;
209  }
210 
211  if (bits_per_color > 31)
212  return AVERROR_INVALIDDATA;
213 
214  buf += 820;
215  avctx->sample_aspect_ratio.num = read32(&buf, endian);
216  avctx->sample_aspect_ratio.den = read32(&buf, endian);
217  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
218  av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
219  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den,
220  0x10000);
221  else
222  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
223 
224  /* preferred frame rate from Motion-picture film header */
225  if (offset >= 1724 + 4) {
226  buf = avpkt->data + 1724;
227  i = read32(&buf, endian);
228  if(i && i != 0xFFFFFFFF) {
229  AVRational q = av_d2q(av_int2float(i), 4096);
230  if (q.num > 0 && q.den > 0)
231  avctx->framerate = q;
232  }
233  }
234 
235  /* alternative frame rate from television header */
236  if (offset >= 1940 + 4 &&
237  !(avctx->framerate.num && avctx->framerate.den)) {
238  buf = avpkt->data + 1940;
239  i = read32(&buf, endian);
240  if(i && i != 0xFFFFFFFF) {
241  AVRational q = av_d2q(av_int2float(i), 4096);
242  if (q.num > 0 && q.den > 0)
243  avctx->framerate = q;
244  }
245  }
246 
247  /* SMPTE TC from television header */
248  if (offset >= 1920 + 4) {
249  uint32_t tc;
250  uint32_t *tc_sd;
251  char tcbuf[AV_TIMECODE_STR_SIZE];
252 
253  buf = avpkt->data + 1920;
254  // read32 to native endian, av_bswap32 to opposite of native for
255  // compatibility with av_timecode_make_smpte_tc_string2 etc
256  tc = av_bswap32(read32(&buf, endian));
257 
258  if (i != 0xFFFFFFFF) {
259  AVFrameSideData *tcside;
260  ret = ff_frame_new_side_data(avctx, p, AV_FRAME_DATA_S12M_TIMECODE,
261  sizeof(uint32_t) * 4, &tcside);
262  if (ret < 0)
263  return ret;
264 
265  if (tcside) {
266  tc_sd = (uint32_t*)tcside->data;
267  tc_sd[0] = 1;
268  tc_sd[1] = tc;
269 
270  av_timecode_make_smpte_tc_string2(tcbuf, avctx->framerate,
271  tc_sd[1], 0, 0);
272  av_dict_set(&p->metadata, "timecode", tcbuf, 0);
273  }
274  }
275  }
276 
277  /* color range from television header */
278  if (offset >= 1964 + 4) {
279  buf = avpkt->data + 1952;
280  i = read32(&buf, endian);
281 
282  buf = avpkt->data + 1964;
283  j = read32(&buf, endian);
284 
285  if (i != 0xFFFFFFFF && j != 0xFFFFFFFF) {
286  float minCV, maxCV;
287  minCV = av_int2float(i);
288  maxCV = av_int2float(j);
289  if (bits_per_color >= 1 &&
290  minCV == 0.0f && maxCV == ((1U<<bits_per_color) - 1)) {
291  avctx->color_range = AVCOL_RANGE_JPEG;
292  } else if (bits_per_color >= 8 &&
293  minCV == (1 <<(bits_per_color - 4)) &&
294  maxCV == (235<<(bits_per_color - 8))) {
295  avctx->color_range = AVCOL_RANGE_MPEG;
296  }
297  }
298  }
299 
300  switch (descriptor) {
301  case 1: // R
302  case 2: // G
303  case 3: // B
304  case 4: // A
305  case 6: // Y
306  elements = 1;
307  yuv = 1;
308  break;
309  case 50: // RGB
310  elements = 3;
311  yuv = 0;
312  break;
313  case 52: // ABGR
314  case 51: // RGBA
315  elements = 4;
316  yuv = 0;
317  break;
318  case 100: // UYVY422
319  elements = 2;
320  yuv = 1;
321  break;
322  case 102: // UYV444
323  elements = 3;
324  yuv = 1;
325  break;
326  case 103: // UYVA4444
327  elements = 4;
328  yuv = 1;
329  break;
330  default:
331  avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
332  return AVERROR_PATCHWELCOME;
333  }
334 
335  switch (bits_per_color) {
336  case 8:
337  stride = avctx->width * elements;
338  break;
339  case 10:
340  if (!packing) {
341  av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
342  return -1;
343  }
344  stride = (avctx->width * elements + 2) / 3 * 4;
345  break;
346  case 12:
347  stride = avctx->width * elements;
348  if (packing) {
349  stride *= 2;
350  } else {
351  stride *= 3;
352  if (stride % 8) {
353  stride /= 8;
354  stride++;
355  stride *= 8;
356  }
357  stride /= 2;
358  }
359  break;
360  case 16:
361  stride = 2 * avctx->width * elements;
362  break;
363  case 32:
364  stride = 4 * avctx->width * elements;
365  break;
366  case 1:
367  case 64:
368  avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
369  return AVERROR_PATCHWELCOME;
370  default:
371  return AVERROR_INVALIDDATA;
372  }
373 
374  switch (color_trc) {
375  case DPX_TRC_LINEAR:
376  avctx->color_trc = AVCOL_TRC_LINEAR;
377  break;
378  case DPX_TRC_SMPTE_274:
379  case DPX_TRC_ITU_R_709_4:
380  avctx->color_trc = AVCOL_TRC_BT709;
381  break;
382  case DPX_TRC_ITU_R_601_625:
383  case DPX_TRC_ITU_R_601_525:
384  case DPX_TRC_SMPTE_170:
385  avctx->color_trc = AVCOL_TRC_SMPTE170M;
386  break;
387  case DPX_TRC_ITU_R_624_4_PAL:
388  avctx->color_trc = AVCOL_TRC_GAMMA28;
389  break;
390  case DPX_TRC_USER_DEFINED:
391  case DPX_TRC_UNSPECIFIED_VIDEO:
392  /* Nothing to do */
393  break;
394  default:
395  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX transfer characteristic "
396  "%d to color_trc.\n", color_trc);
397  break;
398  }
399 
400  switch (color_spec) {
401  case DPX_COL_SPEC_SMPTE_274:
402  case DPX_COL_SPEC_ITU_R_709_4:
403  avctx->color_primaries = AVCOL_PRI_BT709;
404  break;
405  case DPX_COL_SPEC_ITU_R_601_625:
406  case DPX_COL_SPEC_ITU_R_624_4_PAL:
407  avctx->color_primaries = AVCOL_PRI_BT470BG;
408  break;
409  case DPX_COL_SPEC_ITU_R_601_525:
410  case DPX_COL_SPEC_SMPTE_170:
411  avctx->color_primaries = AVCOL_PRI_SMPTE170M;
412  break;
413  case DPX_COL_SPEC_USER_DEFINED:
414  case DPX_COL_SPEC_UNSPECIFIED_VIDEO:
415  /* Nothing to do */
416  break;
417  default:
418  av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX color specification "
419  "%d to color_primaries.\n", color_spec);
420  break;
421  }
422 
423  if (yuv) {
424  switch (color_spec) {
425  case DPX_COL_SPEC_SMPTE_274:
426  case DPX_COL_SPEC_ITU_R_709_4:
427  avctx->colorspace = AVCOL_SPC_BT709;
428  break;
429  case DPX_COL_SPEC_ITU_R_601_625:
430  case DPX_COL_SPEC_ITU_R_624_4_PAL:
431  avctx->colorspace = AVCOL_SPC_BT470BG;
432  break;
433  case DPX_COL_SPEC_ITU_R_601_525:
434  case DPX_COL_SPEC_SMPTE_170:
435  avctx->colorspace = AVCOL_SPC_SMPTE170M;
436  break;
437  case DPX_COL_SPEC_USER_DEFINED:
438  case DPX_COL_SPEC_UNSPECIFIED_VIDEO:
439  /* Nothing to do */
440  break;
441  default:
442  av_log(avctx, AV_LOG_INFO, "Cannot map DPX color specification "
443  "%d to colorspace.\n", color_spec);
444  break;
445  }
446  } else {
447  avctx->colorspace = AVCOL_SPC_RGB;
448  }
449 
450  av_strlcpy(creator, avpkt->data + 160, 100);
451  creator[100] = '\0';
452  av_dict_set(&p->metadata, "Creator", creator, 0);
453 
454  av_strlcpy(input_device, avpkt->data + 1556, 32);
455  input_device[32] = '\0';
456  av_dict_set(&p->metadata, "Input Device", input_device, 0);
457 
458  // Some devices do not pad 10bit samples to whole 32bit words per row
459  if (!memcmp(input_device, "Scanity", 7) ||
460  !memcmp(creator, "Lasergraphics Inc.", 18)) {
461  if (bits_per_color == 10)
462  unpadded_10bit = 1;
463  }
464 
465  // Table 3c: Runs will always break at scan line boundaries. Packing
466  // will always break to the next 32-bit word at scan-line boundaries.
467  // Unfortunately, the encoder produced invalid files, so attempt
468  // to detect it
469  // Also handle special case with unpadded content
470  need_align = FFALIGN(stride, 4);
471  if (need_align*avctx->height + (int64_t)offset > avpkt->size &&
472  (!unpadded_10bit || (avctx->width * avctx->height * elements + 2) / 3 * 4 + (int64_t)offset > avpkt->size)) {
473  // Alignment seems unappliable, try without
474  if (stride*avctx->height + (int64_t)offset > avpkt->size || unpadded_10bit) {
475  av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
476  return AVERROR_INVALIDDATA;
477  } else {
478  av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
479  "alignment.\n");
480  need_align = 0;
481  }
482  } else {
483  need_align -= stride;
484  stride = FFALIGN(stride, 4);
485  }
486 
487  switch (1000 * descriptor + 10 * bits_per_color + endian) {
488  case 1081:
489  case 1080:
490  case 2081:
491  case 2080:
492  case 3081:
493  case 3080:
494  case 4081:
495  case 4080:
496  case 6081:
497  case 6080:
498  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
499  break;
500  case 6121:
501  case 6120:
502  avctx->pix_fmt = AV_PIX_FMT_GRAY12;
503  break;
504  case 1320:
505  case 2320:
506  case 3320:
507  case 4320:
508  case 6320:
509  avctx->pix_fmt = AV_PIX_FMT_GRAYF32LE;
510  break;
511  case 1321:
512  case 2321:
513  case 3321:
514  case 4321:
515  case 6321:
516  avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
517  break;
518  case 50081:
519  case 50080:
520  avctx->pix_fmt = AV_PIX_FMT_RGB24;
521  break;
522  case 52081:
523  case 52080:
524  avctx->pix_fmt = AV_PIX_FMT_ABGR;
525  break;
526  case 51081:
527  case 51080:
528  avctx->pix_fmt = AV_PIX_FMT_RGBA;
529  break;
530  case 50100:
531  case 50101:
532  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
533  break;
534  case 51100:
535  case 51101:
536  avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
537  break;
538  case 50120:
539  case 50121:
540  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
541  break;
542  case 51120:
543  case 51121:
544  avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
545  break;
546  case 6100:
547  case 6101:
548  avctx->pix_fmt = AV_PIX_FMT_GRAY10;
549  break;
550  case 6161:
551  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
552  break;
553  case 6160:
554  avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
555  break;
556  case 50161:
557  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
558  break;
559  case 50160:
560  avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
561  break;
562  case 51161:
563  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
564  break;
565  case 51160:
566  avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
567  break;
568  case 50320:
569  avctx->pix_fmt = AV_PIX_FMT_GBRPF32LE;
570  break;
571  case 50321:
572  avctx->pix_fmt = AV_PIX_FMT_GBRPF32BE;
573  break;
574  case 51320:
575  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32LE;
576  break;
577  case 51321:
578  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32BE;
579  break;
580  case 100081:
581  avctx->pix_fmt = AV_PIX_FMT_UYVY422;
582  break;
583  case 102081:
584  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
585  break;
586  case 103081:
587  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
588  break;
589  default:
590  av_log(avctx, AV_LOG_ERROR, "Unsupported format %d\n",
591  1000 * descriptor + 10 * bits_per_color + endian);
592  return AVERROR_PATCHWELCOME;
593  }
594 
595  ff_set_sar(avctx, avctx->sample_aspect_ratio);
596 
597  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
598  return ret;
599 
600  // Move pointer to offset from start of file
601  buf = avpkt->data + offset;
602 
603  for (i=0; i<AV_NUM_DATA_POINTERS; i++)
604  ptr[i] = p->data[i];
605 
606  switch (bits_per_color) {
607  case 10:
608  for (x = 0; x < avctx->height; x++) {
609  uint16_t *dst[4] = {(uint16_t*)ptr[0],
610  (uint16_t*)ptr[1],
611  (uint16_t*)ptr[2],
612  (uint16_t*)ptr[3]};
613  int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;
614  for (y = 0; y < avctx->width; y++) {
615  if (elements >= 3)
616  *dst[2]++ = read10in32(&buf, &rgbBuffer,
617  &n_datum, endian, shift);
618  if (elements == 1)
619  *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,
620  &n_datum, endian, shift);
621  else
622  *dst[0]++ = read10in32(&buf, &rgbBuffer,
623  &n_datum, endian, shift);
624  if (elements >= 2)
625  *dst[1]++ = read10in32(&buf, &rgbBuffer,
626  &n_datum, endian, shift);
627  if (elements == 4)
628  *dst[3]++ =
629  read10in32(&buf, &rgbBuffer,
630  &n_datum, endian, shift);
631  }
632  if (!unpadded_10bit)
633  n_datum = 0;
634  for (i = 0; i < elements; i++)
635  ptr[i] += p->linesize[i];
636  }
637  break;
638  case 12:
639  for (x = 0; x < avctx->height; x++) {
640  uint16_t *dst[4] = {(uint16_t*)ptr[0],
641  (uint16_t*)ptr[1],
642  (uint16_t*)ptr[2],
643  (uint16_t*)ptr[3]};
644  int shift = packing == 1 ? 4 : 0;
645  for (y = 0; y < avctx->width; y++) {
646  if (packing) {
647  if (elements >= 3)
648  *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;
649  *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;
650  if (elements >= 2)
651  *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;
652  if (elements == 4)
653  *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;
654  } else {
655  if (elements >= 3)
656  *dst[2]++ = read12in32(&buf, &rgbBuffer,
657  &n_datum, endian);
658  *dst[0]++ = read12in32(&buf, &rgbBuffer,
659  &n_datum, endian);
660  if (elements >= 2)
661  *dst[1]++ = read12in32(&buf, &rgbBuffer,
662  &n_datum, endian);
663  if (elements == 4)
664  *dst[3]++ = read12in32(&buf, &rgbBuffer,
665  &n_datum, endian);
666  }
667  }
668  n_datum = 0;
669  for (i = 0; i < elements; i++)
670  ptr[i] += p->linesize[i];
671  // Jump to next aligned position
672  buf += need_align;
673  }
674  break;
675  case 32:
676  if (elements == 1) {
677  av_image_copy_plane(ptr[0], p->linesize[0],
678  buf, stride,
679  elements * avctx->width * 4, avctx->height);
680  } else {
681  for (y = 0; y < avctx->height; y++) {
682  ptr[0] = p->data[0] + y * p->linesize[0];
683  ptr[1] = p->data[1] + y * p->linesize[1];
684  ptr[2] = p->data[2] + y * p->linesize[2];
685  ptr[3] = p->data[3] + y * p->linesize[3];
686  for (x = 0; x < avctx->width; x++) {
687  AV_WN32(ptr[2], AV_RN32(buf));
688  AV_WN32(ptr[0], AV_RN32(buf + 4));
689  AV_WN32(ptr[1], AV_RN32(buf + 8));
690  if (avctx->pix_fmt == AV_PIX_FMT_GBRAPF32BE ||
691  avctx->pix_fmt == AV_PIX_FMT_GBRAPF32LE) {
692  AV_WN32(ptr[3], AV_RN32(buf + 12));
693  buf += 4;
694  ptr[3] += 4;
695  }
696 
697  buf += 12;
698  ptr[2] += 4;
699  ptr[0] += 4;
700  ptr[1] += 4;
701  }
702  }
703  }
704  break;
705  case 16:
706  elements *= 2;
707  case 8:
708  if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P
709  || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
710  for (x = 0; x < avctx->height; x++) {
711  ptr[0] = p->data[0] + x * p->linesize[0];
712  ptr[1] = p->data[1] + x * p->linesize[1];
713  ptr[2] = p->data[2] + x * p->linesize[2];
714  ptr[3] = p->data[3] + x * p->linesize[3];
715  for (y = 0; y < avctx->width; y++) {
716  *ptr[1]++ = *buf++;
717  *ptr[0]++ = *buf++;
718  *ptr[2]++ = *buf++;
719  if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
720  *ptr[3]++ = *buf++;
721  }
722  }
723  } else {
724  av_image_copy_plane(ptr[0], p->linesize[0],
725  buf, stride,
726  elements * avctx->width, avctx->height);
727  }
728  break;
729  }
730 
731  *got_frame = 1;
732 
733  return buf_size;
734 }
735 
736 const FFCodec ff_dpx_decoder = {
737  .p.name = "dpx",
738  CODEC_LONG_NAME("DPX (Digital Picture Exchange) image"),
739  .p.type = AVMEDIA_TYPE_VIDEO,
740  .p.id = AV_CODEC_ID_DPX,
741  FF_CODEC_DECODE_CB(decode_frame),
742  .p.capabilities = AV_CODEC_CAP_DR1,
743 };
DPX_COL_SPEC_ITU_R_624_4_PAL
@ DPX_COL_SPEC_ITU_R_624_4_PAL
Definition: dpx.h:52
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
DPX_COL_SPEC_ITU_R_601_525
@ DPX_COL_SPEC_ITU_R_601_525
Definition: dpx.h:50
AV_CODEC_ID_DPX
@ AV_CODEC_ID_DPX
Definition: codec_id.h:180
DPX_TRC_USER_DEFINED
@ DPX_TRC_USER_DEFINED
Definition: dpx.h:26
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:659
elements
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:565
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: dpx.c:121
DPX_TRC_SMPTE_170
@ DPX_TRC_SMPTE_170
Definition: dpx.h:35
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:694
int64_t
long long int64_t
Definition: coverity.c:34
dpx.h
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:652
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:344
read10in32_gray
static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)
Definition: dpx.c:56
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:796
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:341
AVPacket::data
uint8_t * data
Definition: packet.h:588
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
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:720
intfloat.h
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
DPX_COL_SPEC_SMPTE_170
@ DPX_COL_SPEC_SMPTE_170
Definition: dpx.h:51
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:364
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:551
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:104
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:725
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:577
timecode.h
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:691
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_COL_SPEC_ITU_R_709_4
@ DPX_COL_SPEC_ITU_R_709_4
Definition: dpx.h:48
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:645
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:581
DPX_COL_SPEC_SMPTE_274
@ DPX_COL_SPEC_SMPTE_274
Definition: dpx.h:47
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:346
intreadwrite.h
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:582
DPX_TRC_ITU_R_709_4
@ DPX_TRC_ITU_R_709_4
Definition: dpx.h:32
DPX_COL_SPEC_ITU_R_601_625
@ DPX_COL_SPEC_ITU_R_601_625
Definition: dpx.h:49
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:726
DPX_TRC_ITU_R_624_4_PAL
@ DPX_TRC_ITU_R_624_4_PAL
Definition: dpx.h:36
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1553
decode.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
DPX_TRC_ITU_R_601_625
@ DPX_TRC_ITU_R_601_625
Definition: dpx.h:33
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:331
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:662
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:663
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:532
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:343
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:669
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:110
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:657
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:360
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:106
ff_dpx_decoder
const FFCodec ff_dpx_decoder
Definition: dpx.c:736
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
read12in32
static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big)
Definition: dpx.c:89
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:1728
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:589
codec_internal.h
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:372
shift
static int shift(int a, int b)
Definition: bonk.c:261
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
av_bswap32
#define av_bswap32
Definition: bswap.h:47
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:428
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:2126
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:284
DPX_COL_SPEC_UNSPECIFIED_VIDEO
@ DPX_COL_SPEC_UNSPECIFIED_VIDEO
Definition: dpx.h:46
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
version
version
Definition: libkvazaar.c:315
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:687
read16
static unsigned int read16(const uint8_t **ptr, int is_big)
Definition: dpx.c:32
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:109
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:131
read10in32
static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)
Definition: dpx.c:74
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:578
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:342
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:779
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:363
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
DPX_TRC_UNSPECIFIED_VIDEO
@ DPX_TRC_UNSPECIFIED_VIDEO
Definition: dpx.h:30
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVRational::den
int den
Denominator.
Definition: rational.h:60
DPX_TRC_ITU_R_601_525
@ DPX_TRC_ITU_R_601_525
Definition: dpx.h:34
temp
else temp
Definition: vf_mcdeint.c:271
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:692
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
DPX_COL_SPEC_USER_DEFINED
@ DPX_COL_SPEC_USER_DEFINED
Definition: dpx.h:42
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:105
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:282
DPX_TRC_LINEAR
@ DPX_TRC_LINEAR
Definition: dpx.h:28
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:565
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:86
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
imgutils.h
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2070
read32
static unsigned int read32(const uint8_t **ptr, int is_big)
Definition: dpx.c:44
avstring.h
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:533
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:721
DPX_TRC_SMPTE_274
@ DPX_TRC_SMPTE_274
Definition: dpx.h:31
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:616
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
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:347
Generated on Mon Nov 3 2025 19:21:53 for FFmpeg by   doxygen 1.8.17