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 "bytestream.h"
27 #include "avcodec.h"
28 #include "internal.h"
29 
30 static unsigned int read16(const uint8_t **ptr, int is_big)
31 {
32  unsigned int temp;
33  if (is_big) {
34  temp = AV_RB16(*ptr);
35  } else {
36  temp = AV_RL16(*ptr);
37  }
38  *ptr += 2;
39  return temp;
40 }
41 
42 static unsigned int read32(const uint8_t **ptr, int is_big)
43 {
44  unsigned int temp;
45  if (is_big) {
46  temp = AV_RB32(*ptr);
47  } else {
48  temp = AV_RL32(*ptr);
49  }
50  *ptr += 4;
51  return temp;
52 }
53 
54 static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf,
55  int *n_datum, int is_big, int shift)
56 {
57  uint16_t temp;
58 
59  if (*n_datum)
60  (*n_datum)--;
61  else {
62  *lbuf = read32(ptr, is_big);
63  *n_datum = 2;
64  }
65 
66  temp = *lbuf >> shift & 0x3FF;
67  *lbuf = *lbuf >> 10;
68 
69  return temp;
70 }
71 
72 static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf,
73  int *n_datum, int is_big, int shift)
74 {
75  if (*n_datum)
76  (*n_datum)--;
77  else {
78  *lbuf = read32(ptr, is_big);
79  *n_datum = 2;
80  }
81 
82  *lbuf = *lbuf << 10 | *lbuf >> shift & 0x3FFFFF;
83 
84  return *lbuf & 0x3FF;
85 }
86 
87 static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf,
88  int *n_datum, int is_big)
89 {
90  if (*n_datum)
91  (*n_datum)--;
92  else {
93  *lbuf = read32(ptr, is_big);
94  *n_datum = 7;
95  }
96 
97  switch (*n_datum){
98  case 7: return *lbuf & 0xFFF;
99  case 6: return (*lbuf >> 12) & 0xFFF;
100  case 5: {
101  uint32_t c = *lbuf >> 24;
102  *lbuf = read32(ptr, is_big);
103  c |= *lbuf << 8;
104  return c & 0xFFF;
105  }
106  case 4: return (*lbuf >> 4) & 0xFFF;
107  case 3: return (*lbuf >> 16) & 0xFFF;
108  case 2: {
109  uint32_t c = *lbuf >> 28;
110  *lbuf = read32(ptr, is_big);
111  c |= *lbuf << 4;
112  return c & 0xFFF;
113  }
114  case 1: return (*lbuf >> 8) & 0xFFF;
115  default: return *lbuf >> 20;
116  }
117 }
118 
119 static int decode_frame(AVCodecContext *avctx,
120  void *data,
121  int *got_frame,
122  AVPacket *avpkt)
123 {
124  const uint8_t *buf = avpkt->data;
125  int buf_size = avpkt->size;
126  AVFrame *const p = data;
128  uint32_t header_version, version = 0;
129  char creator[101];
130  char input_device[33];
131 
132  unsigned int offset;
133  int magic_num, endian;
134  int x, y, stride, i, ret;
135  int w, h, bits_per_color, descriptor, elements, packing;
136  int encoding, need_align = 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 
196  // Need to end in 0x323 to read the bits per color
197  buf += 3;
198  avctx->bits_per_raw_sample =
199  bits_per_color = buf[0];
200  buf++;
201  packing = read16(&buf, endian);
202  encoding = read16(&buf, endian);
203 
204  if (encoding) {
205  avpriv_report_missing_feature(avctx, "Encoding %d", encoding);
206  return AVERROR_PATCHWELCOME;
207  }
208 
209  buf += 820;
210  avctx->sample_aspect_ratio.num = read32(&buf, endian);
211  avctx->sample_aspect_ratio.den = read32(&buf, endian);
212  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
215  0x10000);
216  else
217  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
218 
219  if (offset >= 1724 + 4) {
220  buf = avpkt->data + 1724;
221  i = read32(&buf, endian);
222  if(i) {
223  AVRational q = av_d2q(av_int2float(i), 4096);
224  if (q.num > 0 && q.den > 0)
225  avctx->framerate = q;
226  }
227  }
228 
229  switch (descriptor) {
230  case 6: // Y
231  elements = 1;
232  break;
233  case 52: // ABGR
234  case 51: // RGBA
235  case 103: // UYVA4444
236  elements = 4;
237  break;
238  case 50: // RGB
239  case 102: // UYV444
240  elements = 3;
241  break;
242  case 100: // UYVY422
243  elements = 2;
244  break;
245  default:
246  avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
247  return AVERROR_PATCHWELCOME;
248  }
249 
250  switch (bits_per_color) {
251  case 8:
252  stride = avctx->width * elements;
253  break;
254  case 10:
255  if (!packing) {
256  av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
257  return -1;
258  }
259  stride = (avctx->width * elements + 2) / 3 * 4;
260  break;
261  case 12:
262  stride = avctx->width * elements;
263  if (packing) {
264  stride *= 2;
265  } else {
266  stride *= 3;
267  if (stride % 8) {
268  stride /= 8;
269  stride++;
270  stride *= 8;
271  }
272  stride /= 2;
273  }
274  break;
275  case 16:
276  stride = 2 * avctx->width * elements;
277  break;
278  case 1:
279  case 32:
280  case 64:
281  avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
282  return AVERROR_PATCHWELCOME;
283  default:
284  return AVERROR_INVALIDDATA;
285  }
286 
287  // Table 3c: Runs will always break at scan line boundaries. Packing
288  // will always break to the next 32-bit word at scan-line boundaries.
289  // Unfortunately, the encoder produced invalid files, so attempt
290  // to detect it
291  need_align = FFALIGN(stride, 4);
292  if (need_align*avctx->height + (int64_t)offset > avpkt->size) {
293  // Alignment seems unappliable, try without
294  if (stride*avctx->height + (int64_t)offset > avpkt->size) {
295  av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
296  return AVERROR_INVALIDDATA;
297  } else {
298  av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
299  "alignment.\n");
300  need_align = 0;
301  }
302  } else {
303  need_align -= stride;
304  stride = FFALIGN(stride, 4);
305  }
306 
307  switch (1000 * descriptor + 10 * bits_per_color + endian) {
308  case 6081:
309  case 6080:
310  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
311  break;
312  case 6121:
313  case 6120:
314  avctx->pix_fmt = AV_PIX_FMT_GRAY12;
315  break;
316  case 50081:
317  case 50080:
318  avctx->pix_fmt = AV_PIX_FMT_RGB24;
319  break;
320  case 52081:
321  case 52080:
322  avctx->pix_fmt = AV_PIX_FMT_ABGR;
323  break;
324  case 51081:
325  case 51080:
326  avctx->pix_fmt = AV_PIX_FMT_RGBA;
327  break;
328  case 50100:
329  case 50101:
330  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
331  break;
332  case 51100:
333  case 51101:
334  avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
335  break;
336  case 50120:
337  case 50121:
338  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
339  break;
340  case 51120:
341  case 51121:
342  avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
343  break;
344  case 6100:
345  case 6101:
346  avctx->pix_fmt = AV_PIX_FMT_GRAY10;
347  break;
348  case 6161:
349  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
350  break;
351  case 6160:
352  avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
353  break;
354  case 50161:
355  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
356  break;
357  case 50160:
358  avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
359  break;
360  case 51161:
361  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
362  break;
363  case 51160:
364  avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
365  break;
366  case 100081:
367  avctx->pix_fmt = AV_PIX_FMT_UYVY422;
368  break;
369  case 102081:
370  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
371  break;
372  case 103081:
373  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
374  break;
375  default:
376  av_log(avctx, AV_LOG_ERROR, "Unsupported format\n");
377  return AVERROR_PATCHWELCOME;
378  }
379 
380  ff_set_sar(avctx, avctx->sample_aspect_ratio);
381 
382  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
383  return ret;
384 
385  av_strlcpy(creator, avpkt->data + 160, 100);
386  creator[100] = '\0';
387  av_dict_set(&p->metadata, "Creator", creator, 0);
388 
389  av_strlcpy(input_device, avpkt->data + 1556, 32);
390  input_device[32] = '\0';
391  av_dict_set(&p->metadata, "Input Device", input_device, 0);
392 
393  // Move pointer to offset from start of file
394  buf = avpkt->data + offset;
395 
396  for (i=0; i<AV_NUM_DATA_POINTERS; i++)
397  ptr[i] = p->data[i];
398 
399  switch (bits_per_color) {
400  case 10:
401  for (x = 0; x < avctx->height; x++) {
402  uint16_t *dst[4] = {(uint16_t*)ptr[0],
403  (uint16_t*)ptr[1],
404  (uint16_t*)ptr[2],
405  (uint16_t*)ptr[3]};
406  int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;
407  for (y = 0; y < avctx->width; y++) {
408  if (elements >= 3)
409  *dst[2]++ = read10in32(&buf, &rgbBuffer,
410  &n_datum, endian, shift);
411  if (elements == 1)
412  *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,
413  &n_datum, endian, shift);
414  else
415  *dst[0]++ = read10in32(&buf, &rgbBuffer,
416  &n_datum, endian, shift);
417  if (elements >= 2)
418  *dst[1]++ = read10in32(&buf, &rgbBuffer,
419  &n_datum, endian, shift);
420  if (elements == 4)
421  *dst[3]++ =
422  read10in32(&buf, &rgbBuffer,
423  &n_datum, endian, shift);
424  }
425  if (memcmp(input_device, "Scanity", 7))
426  n_datum = 0;
427  for (i = 0; i < elements; i++)
428  ptr[i] += p->linesize[i];
429  }
430  break;
431  case 12:
432  for (x = 0; x < avctx->height; x++) {
433  uint16_t *dst[4] = {(uint16_t*)ptr[0],
434  (uint16_t*)ptr[1],
435  (uint16_t*)ptr[2],
436  (uint16_t*)ptr[3]};
437  int shift = packing == 1 ? 4 : 0;
438  for (y = 0; y < avctx->width; y++) {
439  if (packing) {
440  if (elements >= 3)
441  *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;
442  *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;
443  if (elements >= 2)
444  *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;
445  if (elements == 4)
446  *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;
447  } else {
448  if (elements >= 3)
449  *dst[2]++ = read12in32(&buf, &rgbBuffer,
450  &n_datum, endian);
451  *dst[0]++ = read12in32(&buf, &rgbBuffer,
452  &n_datum, endian);
453  if (elements >= 2)
454  *dst[1]++ = read12in32(&buf, &rgbBuffer,
455  &n_datum, endian);
456  if (elements == 4)
457  *dst[3]++ = read12in32(&buf, &rgbBuffer,
458  &n_datum, endian);
459  }
460  }
461  n_datum = 0;
462  for (i = 0; i < elements; i++)
463  ptr[i] += p->linesize[i];
464  // Jump to next aligned position
465  buf += need_align;
466  }
467  break;
468  case 16:
469  elements *= 2;
470  case 8:
471  if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P
472  || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
473  for (x = 0; x < avctx->height; x++) {
474  ptr[0] = p->data[0] + x * p->linesize[0];
475  ptr[1] = p->data[1] + x * p->linesize[1];
476  ptr[2] = p->data[2] + x * p->linesize[2];
477  ptr[3] = p->data[3] + x * p->linesize[3];
478  for (y = 0; y < avctx->width; y++) {
479  *ptr[1]++ = *buf++;
480  *ptr[0]++ = *buf++;
481  *ptr[2]++ = *buf++;
482  if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
483  *ptr[3]++ = *buf++;
484  }
485  }
486  } else {
487  av_image_copy_plane(ptr[0], p->linesize[0],
488  buf, stride,
489  elements * avctx->width, avctx->height);
490  }
491  break;
492  }
493 
494  *got_frame = 1;
495 
496  return buf_size;
497 }
498 
500  .name = "dpx",
501  .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
502  .type = AVMEDIA_TYPE_VIDEO,
503  .id = AV_CODEC_ID_DPX,
504  .decode = decode_frame,
505  .capabilities = AV_CODEC_CAP_DR1,
506 };
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:119
AVRational framerate
Definition: avcodec.h:3108
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:296
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:54
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:407
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:182
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:104
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1481
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
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:1947
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
int version
Definition: avisynth_c.h:858
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2799
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:87
AVCodec.
Definition: avcodec.h:3492
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:369
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:499
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
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:30
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:87
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf, int *n_datum, int is_big, int shift)
Definition: dpx.c:72
uint8_t * data
Definition: avcodec.h:1480
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:119
AVDictionary * metadata
metadata.
Definition: frame.h:581
static unsigned int read32(const uint8_t **ptr, int is_big)
Definition: dpx.c:42
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:408
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
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:87
int width
picture width / height.
Definition: avcodec.h:1741
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
uint8_t w
Definition: llviddspenc.c:38
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
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:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
void * buf
Definition: avisynth_c.h:766
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
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
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:309
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
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
int den
Denominator.
Definition: rational.h:60
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
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:338
#define stride
#define MKTAG(a, b, c, d)
Definition: common.h:366
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
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