FFmpeg
xwdenc.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 "libavutil/intreadwrite.h"
24 #include "libavutil/pixdesc.h"
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "encode.h"
28 #include "internal.h"
29 #include "xwd.h"
30 
31 #define WINDOW_NAME "lavcxwdenc"
32 #define WINDOW_NAME_SIZE 11
33 
34 static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
35  const AVFrame *pict, int *got_packet)
36 {
37  enum AVPixelFormat pix_fmt = avctx->pix_fmt;
38  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
39  uint32_t pixdepth, bpp, bpad, ncolors = 0, lsize, vclass, be = 0;
40  uint32_t rgb[3] = { 0 }, bitorder = 0;
41  uint32_t header_size;
42  int i, out_size, ret;
43  uint8_t *ptr, *buf;
44  AVFrame * const p = (AVFrame *)pict;
45  uint32_t pal[256];
46 
47  pixdepth = av_get_bits_per_pixel(desc);
48  if (desc->flags & AV_PIX_FMT_FLAG_BE)
49  be = 1;
50  switch (pix_fmt) {
51  case AV_PIX_FMT_ARGB:
52  case AV_PIX_FMT_BGRA:
53  case AV_PIX_FMT_RGBA:
54  case AV_PIX_FMT_ABGR:
55  if (pix_fmt == AV_PIX_FMT_ARGB ||
56  pix_fmt == AV_PIX_FMT_ABGR)
57  be = 1;
58  if (pix_fmt == AV_PIX_FMT_ABGR ||
59  pix_fmt == AV_PIX_FMT_RGBA) {
60  rgb[0] = 0xFF;
61  rgb[1] = 0xFF00;
62  rgb[2] = 0xFF0000;
63  } else {
64  rgb[0] = 0xFF0000;
65  rgb[1] = 0xFF00;
66  rgb[2] = 0xFF;
67  }
68  bpp = 32;
69  pixdepth = 24;
70  vclass = XWD_TRUE_COLOR;
71  bpad = 32;
72  break;
73  case AV_PIX_FMT_BGR24:
74  case AV_PIX_FMT_RGB24:
75  if (pix_fmt == AV_PIX_FMT_RGB24)
76  be = 1;
77  bpp = 24;
78  vclass = XWD_TRUE_COLOR;
79  bpad = 32;
80  rgb[0] = 0xFF0000;
81  rgb[1] = 0xFF00;
82  rgb[2] = 0xFF;
83  break;
84  case AV_PIX_FMT_RGB565LE:
85  case AV_PIX_FMT_RGB565BE:
86  case AV_PIX_FMT_BGR565LE:
87  case AV_PIX_FMT_BGR565BE:
88  if (pix_fmt == AV_PIX_FMT_BGR565LE ||
89  pix_fmt == AV_PIX_FMT_BGR565BE) {
90  rgb[0] = 0x1F;
91  rgb[1] = 0x7E0;
92  rgb[2] = 0xF800;
93  } else {
94  rgb[0] = 0xF800;
95  rgb[1] = 0x7E0;
96  rgb[2] = 0x1F;
97  }
98  bpp = 16;
99  vclass = XWD_TRUE_COLOR;
100  bpad = 16;
101  break;
102  case AV_PIX_FMT_RGB555LE:
103  case AV_PIX_FMT_RGB555BE:
104  case AV_PIX_FMT_BGR555LE:
105  case AV_PIX_FMT_BGR555BE:
106  if (pix_fmt == AV_PIX_FMT_BGR555LE ||
107  pix_fmt == AV_PIX_FMT_BGR555BE) {
108  rgb[0] = 0x1F;
109  rgb[1] = 0x3E0;
110  rgb[2] = 0x7C00;
111  } else {
112  rgb[0] = 0x7C00;
113  rgb[1] = 0x3E0;
114  rgb[2] = 0x1F;
115  }
116  bpp = 16;
117  vclass = XWD_TRUE_COLOR;
118  bpad = 16;
119  break;
120  case AV_PIX_FMT_RGB8:
121  case AV_PIX_FMT_BGR8:
122  case AV_PIX_FMT_RGB4_BYTE:
123  case AV_PIX_FMT_BGR4_BYTE:
124  case AV_PIX_FMT_PAL8:
125  bpp = 8;
126  vclass = XWD_PSEUDO_COLOR;
127  bpad = 8;
128  ncolors = 256;
129  break;
130  case AV_PIX_FMT_GRAY8:
131  bpp = 8;
132  bpad = 8;
133  vclass = XWD_STATIC_GRAY;
134  break;
135  case AV_PIX_FMT_MONOWHITE:
136  be = 1;
137  bitorder = 1;
138  bpp = 1;
139  bpad = 8;
140  vclass = XWD_STATIC_GRAY;
141  break;
142  default:
143  av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
144  return AVERROR(EINVAL);
145  }
146 
147  lsize = FFALIGN(bpp * avctx->width, bpad) / 8;
148  header_size = XWD_HEADER_SIZE + WINDOW_NAME_SIZE;
149  out_size = header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize;
150 
151  if ((ret = ff_get_encode_buffer(avctx, pkt, out_size, 0)) < 0)
152  return ret;
153  buf = pkt->data;
154 
155  p->key_frame = 1;
156  p->pict_type = AV_PICTURE_TYPE_I;
157 
158  bytestream_put_be32(&buf, header_size);
159  bytestream_put_be32(&buf, XWD_VERSION); // file version
160  bytestream_put_be32(&buf, XWD_Z_PIXMAP); // pixmap format
161  bytestream_put_be32(&buf, pixdepth); // pixmap depth in pixels
162  bytestream_put_be32(&buf, avctx->width); // pixmap width in pixels
163  bytestream_put_be32(&buf, avctx->height); // pixmap height in pixels
164  bytestream_put_be32(&buf, 0); // bitmap x offset
165  bytestream_put_be32(&buf, be); // byte order
166  bytestream_put_be32(&buf, 32); // bitmap unit
167  bytestream_put_be32(&buf, bitorder); // bit-order of image data
168  bytestream_put_be32(&buf, bpad); // bitmap scan-line pad in bits
169  bytestream_put_be32(&buf, bpp); // bits per pixel
170  bytestream_put_be32(&buf, lsize); // bytes per scan-line
171  bytestream_put_be32(&buf, vclass); // visual class
172  bytestream_put_be32(&buf, rgb[0]); // red mask
173  bytestream_put_be32(&buf, rgb[1]); // green mask
174  bytestream_put_be32(&buf, rgb[2]); // blue mask
175  bytestream_put_be32(&buf, 8); // size of each bitmask in bits
176  bytestream_put_be32(&buf, ncolors); // number of colors
177  bytestream_put_be32(&buf, ncolors); // number of entries in color map
178  bytestream_put_be32(&buf, avctx->width); // window width
179  bytestream_put_be32(&buf, avctx->height); // window height
180  bytestream_put_be32(&buf, 0); // window upper left X coordinate
181  bytestream_put_be32(&buf, 0); // window upper left Y coordinate
182  bytestream_put_be32(&buf, 0); // window border width
183  bytestream_put_buffer(&buf, WINDOW_NAME, WINDOW_NAME_SIZE);
184 
185  if (pix_fmt == AV_PIX_FMT_PAL8) {
186  memcpy(pal, p->data[1], sizeof(pal));
187  } else {
188  avpriv_set_systematic_pal2(pal, pix_fmt);
189  }
190 
191  for (i = 0; i < ncolors; i++) {
192  uint32_t val;
193  uint8_t red, green, blue;
194 
195  val = pal[i];
196  red = (val >> 16) & 0xFF;
197  green = (val >> 8) & 0xFF;
198  blue = val & 0xFF;
199 
200  bytestream_put_be32(&buf, i); // colormap entry number
201  bytestream_put_be16(&buf, red << 8);
202  bytestream_put_be16(&buf, green << 8);
203  bytestream_put_be16(&buf, blue << 8);
204  bytestream_put_byte(&buf, 0x7); // bitmask flag
205  bytestream_put_byte(&buf, 0); // padding
206  }
207 
208  ptr = p->data[0];
209  for (i = 0; i < avctx->height; i++) {
210  bytestream_put_buffer(&buf, ptr, lsize);
211  ptr += p->linesize[0];
212  }
213 
214  *got_packet = 1;
215  return 0;
216 }
217 
218 const AVCodec ff_xwd_encoder = {
219  .name = "xwd",
220  .long_name = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
221  .type = AVMEDIA_TYPE_VIDEO,
222  .id = AV_CODEC_ID_XWD,
223  .capabilities = AV_CODEC_CAP_DR1,
224  .encode2 = xwd_encode_frame,
225  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,
226  AV_PIX_FMT_RGBA,
227  AV_PIX_FMT_ARGB,
228  AV_PIX_FMT_ABGR,
229  AV_PIX_FMT_RGB24,
230  AV_PIX_FMT_BGR24,
231  AV_PIX_FMT_RGB565BE,
232  AV_PIX_FMT_RGB565LE,
233  AV_PIX_FMT_BGR565BE,
234  AV_PIX_FMT_BGR565LE,
235  AV_PIX_FMT_RGB555BE,
236  AV_PIX_FMT_RGB555LE,
237  AV_PIX_FMT_BGR555BE,
238  AV_PIX_FMT_BGR555LE,
239  AV_PIX_FMT_RGB8,
240  AV_PIX_FMT_BGR8,
241  AV_PIX_FMT_RGB4_BYTE,
242  AV_PIX_FMT_BGR4_BYTE,
243  AV_PIX_FMT_PAL8,
244  AV_PIX_FMT_GRAY8,
245  AV_PIX_FMT_MONOWHITE,
246  AV_PIX_FMT_NONE },
247 };
be
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 be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
AVCodec
AVCodec.
Definition: codec.h:202
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
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
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
out_size
int out_size
Definition: movenc.c:55
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
pixdesc.h
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
encode.h
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
WINDOW_NAME
#define WINDOW_NAME
Definition: xwdenc.c:31
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2612
XWD_Z_PIXMAP
#define XWD_Z_PIXMAP
Definition: xwd.h:32
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
rgb
Definition: rpzaenc.c:59
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:409
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
intreadwrite.h
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
avpriv_set_systematic_pal2
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:178
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
xwd.h
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
AV_CODEC_ID_XWD
@ AV_CODEC_ID_XWD
Definition: codec_id.h:208
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:111
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:112
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:414
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
XWD_HEADER_SIZE
#define XWD_HEADER_SIZE
Definition: xwd.h:27
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:110
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
xwd_encode_frame
static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: xwdenc.c:34
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
XWD_TRUE_COLOR
#define XWD_TRUE_COLOR
Definition: xwd.h:38
ret
ret
Definition: filter_design.txt:187
XWD_PSEUDO_COLOR
#define XWD_PSEUDO_COLOR
Definition: xwd.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:383
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
XWD_STATIC_GRAY
#define XWD_STATIC_GRAY
Definition: xwd.h:34
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:113
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
ff_xwd_encoder
const AVCodec ff_xwd_encoder
Definition: xwdenc.c:218
XWD_VERSION
#define XWD_VERSION
Definition: xwd.h:26
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:362
XWD_CMAP_SIZE
#define XWD_CMAP_SIZE
Definition: xwd.h:28
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
WINDOW_NAME_SIZE
#define WINDOW_NAME_SIZE
Definition: xwdenc.c:32
Generated on Wed Aug 24 2022 21:38:02 for FFmpeg by   doxygen 1.8.17