FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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:3073
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:227
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:226
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:404
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:1453
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:400
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:1919
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1750
int version
Definition: avisynth_c.h:766
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2767
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:3441
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:365
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:366
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
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:1452
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:512
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 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:405
const char * name
Name of the codec implementation.
Definition: avcodec.h:3448
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
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:1713
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:257
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:1540
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1919
void * buf
Definition: avisynth_c.h:690
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:401
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:240
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.
static double c[64]
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:1429
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
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