FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
xwddec.c
Go to the documentation of this file.
1 /*
2  * XWD image format
3  *
4  * Copyright (c) 2012 Paul B Mahol
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <inttypes.h>
24 
25 #include "libavutil/imgutils.h"
26 #include "avcodec.h"
27 #include "bytestream.h"
28 #include "internal.h"
29 #include "xwd.h"
30 
31 static int xwd_decode_frame(AVCodecContext *avctx, void *data,
32  int *got_frame, AVPacket *avpkt)
33 {
34  AVFrame *p = data;
35  const uint8_t *buf = avpkt->data;
36  int i, ret, buf_size = avpkt->size;
37  uint32_t version, header_size, vclass, ncolors;
38  uint32_t xoffset, be, bpp, lsize, rsize;
39  uint32_t pixformat, pixdepth, bunit, bitorder, bpad;
40  uint32_t rgb[3];
41  uint8_t *ptr;
42  GetByteContext gb;
43 
44  if (buf_size < XWD_HEADER_SIZE)
45  return AVERROR_INVALIDDATA;
46 
47  bytestream2_init(&gb, buf, buf_size);
48  header_size = bytestream2_get_be32u(&gb);
49 
50  version = bytestream2_get_be32u(&gb);
51  if (version != XWD_VERSION) {
52  av_log(avctx, AV_LOG_ERROR, "unsupported version\n");
53  return AVERROR_INVALIDDATA;
54  }
55 
56  if (buf_size < header_size || header_size < XWD_HEADER_SIZE) {
57  av_log(avctx, AV_LOG_ERROR, "invalid header size\n");
58  return AVERROR_INVALIDDATA;
59  }
60 
61  pixformat = bytestream2_get_be32u(&gb);
62  pixdepth = bytestream2_get_be32u(&gb);
63  avctx->width = bytestream2_get_be32u(&gb);
64  avctx->height = bytestream2_get_be32u(&gb);
65  xoffset = bytestream2_get_be32u(&gb);
66  be = bytestream2_get_be32u(&gb);
67  bunit = bytestream2_get_be32u(&gb);
68  bitorder = bytestream2_get_be32u(&gb);
69  bpad = bytestream2_get_be32u(&gb);
70  bpp = bytestream2_get_be32u(&gb);
71  lsize = bytestream2_get_be32u(&gb);
72  vclass = bytestream2_get_be32u(&gb);
73  rgb[0] = bytestream2_get_be32u(&gb);
74  rgb[1] = bytestream2_get_be32u(&gb);
75  rgb[2] = bytestream2_get_be32u(&gb);
76  bytestream2_skipu(&gb, 8);
77  ncolors = bytestream2_get_be32u(&gb);
78  bytestream2_skipu(&gb, header_size - (XWD_HEADER_SIZE - 20));
79 
80  av_log(avctx, AV_LOG_DEBUG,
81  "pixformat %"PRIu32", pixdepth %"PRIu32", bunit %"PRIu32", bitorder %"PRIu32", bpad %"PRIu32"\n",
82  pixformat, pixdepth, bunit, bitorder, bpad);
83  av_log(avctx, AV_LOG_DEBUG,
84  "vclass %"PRIu32", ncolors %"PRIu32", bpp %"PRIu32", be %"PRIu32", lsize %"PRIu32", xoffset %"PRIu32"\n",
85  vclass, ncolors, bpp, be, lsize, xoffset);
86  av_log(avctx, AV_LOG_DEBUG,
87  "red %0"PRIx32", green %0"PRIx32", blue %0"PRIx32"\n",
88  rgb[0], rgb[1], rgb[2]);
89 
90  if (pixformat > XWD_Z_PIXMAP) {
91  av_log(avctx, AV_LOG_ERROR, "invalid pixmap format\n");
92  return AVERROR_INVALIDDATA;
93  }
94 
95  if (pixdepth == 0 || pixdepth > 32) {
96  av_log(avctx, AV_LOG_ERROR, "invalid pixmap depth\n");
97  return AVERROR_INVALIDDATA;
98  }
99 
100  if (xoffset) {
101  avpriv_request_sample(avctx, "xoffset %"PRIu32"", xoffset);
102  return AVERROR_PATCHWELCOME;
103  }
104 
105  if (be > 1) {
106  av_log(avctx, AV_LOG_ERROR, "invalid byte order\n");
107  return AVERROR_INVALIDDATA;
108  }
109 
110  if (bitorder > 1) {
111  av_log(avctx, AV_LOG_ERROR, "invalid bitmap bit order\n");
112  return AVERROR_INVALIDDATA;
113  }
114 
115  if (bunit != 8 && bunit != 16 && bunit != 32) {
116  av_log(avctx, AV_LOG_ERROR, "invalid bitmap unit\n");
117  return AVERROR_INVALIDDATA;
118  }
119 
120  if (bpad != 8 && bpad != 16 && bpad != 32) {
121  av_log(avctx, AV_LOG_ERROR, "invalid bitmap scan-line pad\n");
122  return AVERROR_INVALIDDATA;
123  }
124 
125  if (bpp == 0 || bpp > 32) {
126  av_log(avctx, AV_LOG_ERROR, "invalid bits per pixel\n");
127  return AVERROR_INVALIDDATA;
128  }
129 
130  if (ncolors > 256) {
131  av_log(avctx, AV_LOG_ERROR, "invalid number of entries in colormap\n");
132  return AVERROR_INVALIDDATA;
133  }
134 
135  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, NULL)) < 0)
136  return ret;
137 
138  rsize = FFALIGN(avctx->width * bpp, bpad) / 8;
139  if (lsize < rsize) {
140  av_log(avctx, AV_LOG_ERROR, "invalid bytes per scan-line\n");
141  return AVERROR_INVALIDDATA;
142  }
143 
144  if (bytestream2_get_bytes_left(&gb) < ncolors * XWD_CMAP_SIZE + (uint64_t)avctx->height * lsize) {
145  av_log(avctx, AV_LOG_ERROR, "input buffer too small\n");
146  return AVERROR_INVALIDDATA;
147  }
148 
149  if (pixformat != XWD_Z_PIXMAP) {
150  avpriv_report_missing_feature(avctx, "Pixmap format %"PRIu32, pixformat);
151  return AVERROR_PATCHWELCOME;
152  }
153 
154  avctx->pix_fmt = AV_PIX_FMT_NONE;
155  switch (vclass) {
156  case XWD_STATIC_GRAY:
157  case XWD_GRAY_SCALE:
158  if (bpp != 1 && bpp != 8)
159  return AVERROR_INVALIDDATA;
160  if (pixdepth == 1) {
161  avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
162  } else if (pixdepth == 8) {
163  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
164  }
165  break;
166  case XWD_STATIC_COLOR:
167  case XWD_PSEUDO_COLOR:
168  if (bpp == 8)
169  avctx->pix_fmt = AV_PIX_FMT_PAL8;
170  break;
171  case XWD_TRUE_COLOR:
172  case XWD_DIRECT_COLOR:
173  if (bpp != 16 && bpp != 24 && bpp != 32)
174  return AVERROR_INVALIDDATA;
175  if (bpp == 16 && pixdepth == 15) {
176  if (rgb[0] == 0x7C00 && rgb[1] == 0x3E0 && rgb[2] == 0x1F)
178  else if (rgb[0] == 0x1F && rgb[1] == 0x3E0 && rgb[2] == 0x7C00)
180  } else if (bpp == 16 && pixdepth == 16) {
181  if (rgb[0] == 0xF800 && rgb[1] == 0x7E0 && rgb[2] == 0x1F)
183  else if (rgb[0] == 0x1F && rgb[1] == 0x7E0 && rgb[2] == 0xF800)
185  } else if (bpp == 24) {
186  if (rgb[0] == 0xFF0000 && rgb[1] == 0xFF00 && rgb[2] == 0xFF)
187  avctx->pix_fmt = be ? AV_PIX_FMT_RGB24 : AV_PIX_FMT_BGR24;
188  else if (rgb[0] == 0xFF && rgb[1] == 0xFF00 && rgb[2] == 0xFF0000)
189  avctx->pix_fmt = be ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24;
190  } else if (bpp == 32) {
191  if (rgb[0] == 0xFF0000 && rgb[1] == 0xFF00 && rgb[2] == 0xFF)
192  avctx->pix_fmt = be ? AV_PIX_FMT_ARGB : AV_PIX_FMT_BGRA;
193  else if (rgb[0] == 0xFF && rgb[1] == 0xFF00 && rgb[2] == 0xFF0000)
194  avctx->pix_fmt = be ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA;
195  }
196  bytestream2_skipu(&gb, ncolors * XWD_CMAP_SIZE);
197  break;
198  default:
199  av_log(avctx, AV_LOG_ERROR, "invalid visual class\n");
200  return AVERROR_INVALIDDATA;
201  }
202 
203  if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
204  avpriv_request_sample(avctx,
205  "Unknown file: bpp %"PRIu32", pixdepth %"PRIu32", vclass %"PRIu32"",
206  bpp, pixdepth, vclass);
207  return AVERROR_PATCHWELCOME;
208  }
209 
210  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
211  return ret;
212 
213  p->key_frame = 1;
215 
216  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
217  uint32_t *dst = (uint32_t *)p->data[1];
218  uint8_t red, green, blue;
219 
220  for (i = 0; i < ncolors; i++) {
221 
222  bytestream2_skipu(&gb, 4); // skip colormap entry number
223  red = bytestream2_get_byteu(&gb);
224  bytestream2_skipu(&gb, 1);
225  green = bytestream2_get_byteu(&gb);
226  bytestream2_skipu(&gb, 1);
227  blue = bytestream2_get_byteu(&gb);
228  bytestream2_skipu(&gb, 3); // skip bitmask flag and padding
229 
230  dst[i] = red << 16 | green << 8 | blue;
231  }
232  }
233 
234  ptr = p->data[0];
235  for (i = 0; i < avctx->height; i++) {
236  bytestream2_get_bufferu(&gb, ptr, rsize);
237  bytestream2_skipu(&gb, lsize - rsize);
238  ptr += p->linesize[0];
239  }
240 
241  *got_frame = 1;
242 
243  return buf_size;
244 }
245 
247  .name = "xwd",
248  .long_name = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
249  .type = AVMEDIA_TYPE_VIDEO,
250  .id = AV_CODEC_ID_XWD,
251  .decode = xwd_decode_frame,
252  .capabilities = AV_CODEC_CAP_DR1,
253 };
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:180
#define XWD_GRAY_SCALE
Definition: xwd.h:35
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:64
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:116
int size
Definition: avcodec.h:1575
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1867
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:119
int version
Definition: avisynth_c.h:629
AVCodec.
Definition: avcodec.h:3531
#define XWD_DIRECT_COLOR
Definition: xwd.h:39
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:273
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:114
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
8 bit with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
#define XWD_STATIC_GRAY
Definition: xwd.h:34
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:113
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:95
uint8_t * data
Definition: avcodec.h:1574
#define XWD_HEADER_SIZE
Definition: xwd.h:27
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:170
#define XWD_CMAP_SIZE
Definition: xwd.h:28
#define XWD_VERSION
Definition: xwd.h:26
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
#define XWD_Z_PIXMAP
Definition: xwd.h:32
#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:176
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:96
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3538
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:93
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:94
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:251
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:254
int width
picture width / height.
Definition: avcodec.h:1826
static int xwd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: xwddec.c:31
AVCodec ff_xwd_decoder
Definition: xwddec.c:246
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:118
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:211
main external API structure.
Definition: avcodec.h:1639
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:928
void * buf
Definition: avisynth_c.h:553
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:121
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define XWD_STATIC_COLOR
Definition: xwd.h:36
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:115
#define XWD_TRUE_COLOR
Definition: xwd.h:38
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:194
Y , 8bpp.
Definition: pixfmt.h:70
common internal api header.
#define XWD_PSEUDO_COLOR
Definition: xwd.h:37
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:71
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:249
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:120
This structure stores compressed data.
Definition: avcodec.h:1551
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:950
for(j=16;j >0;--j)