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/imgutils_internal.h"
24 #include "libavutil/pixdesc.h"
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "codec_internal.h"
28 #include "encode.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 *p, 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  const uint8_t *ptr;
44  uint8_t *buf;
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  bytestream_put_be32(&buf, header_size);
156  bytestream_put_be32(&buf, XWD_VERSION); // file version
157  bytestream_put_be32(&buf, XWD_Z_PIXMAP); // pixmap format
158  bytestream_put_be32(&buf, pixdepth); // pixmap depth in pixels
159  bytestream_put_be32(&buf, avctx->width); // pixmap width in pixels
160  bytestream_put_be32(&buf, avctx->height); // pixmap height in pixels
161  bytestream_put_be32(&buf, 0); // bitmap x offset
162  bytestream_put_be32(&buf, be); // byte order
163  bytestream_put_be32(&buf, 32); // bitmap unit
164  bytestream_put_be32(&buf, bitorder); // bit-order of image data
165  bytestream_put_be32(&buf, bpad); // bitmap scan-line pad in bits
166  bytestream_put_be32(&buf, bpp); // bits per pixel
167  bytestream_put_be32(&buf, lsize); // bytes per scan-line
168  bytestream_put_be32(&buf, vclass); // visual class
169  bytestream_put_be32(&buf, rgb[0]); // red mask
170  bytestream_put_be32(&buf, rgb[1]); // green mask
171  bytestream_put_be32(&buf, rgb[2]); // blue mask
172  bytestream_put_be32(&buf, 8); // size of each bitmask in bits
173  bytestream_put_be32(&buf, ncolors); // number of colors
174  bytestream_put_be32(&buf, ncolors); // number of entries in color map
175  bytestream_put_be32(&buf, avctx->width); // window width
176  bytestream_put_be32(&buf, avctx->height); // window height
177  bytestream_put_be32(&buf, 0); // window upper left X coordinate
178  bytestream_put_be32(&buf, 0); // window upper left Y coordinate
179  bytestream_put_be32(&buf, 0); // window border width
180  bytestream_put_buffer(&buf, WINDOW_NAME, WINDOW_NAME_SIZE);
181 
182  if (pix_fmt == AV_PIX_FMT_PAL8) {
183  memcpy(pal, p->data[1], sizeof(pal));
184  } else {
185  avpriv_set_systematic_pal2(pal, pix_fmt);
186  }
187 
188  for (i = 0; i < ncolors; i++) {
189  uint32_t val;
190  uint8_t red, green, blue;
191 
192  val = pal[i];
193  red = (val >> 16) & 0xFF;
194  green = (val >> 8) & 0xFF;
195  blue = val & 0xFF;
196 
197  bytestream_put_be32(&buf, i); // colormap entry number
198  bytestream_put_be16(&buf, red << 8);
199  bytestream_put_be16(&buf, green << 8);
200  bytestream_put_be16(&buf, blue << 8);
201  bytestream_put_byte(&buf, 0x7); // bitmask flag
202  bytestream_put_byte(&buf, 0); // padding
203  }
204 
205  ptr = p->data[0];
206  for (i = 0; i < avctx->height; i++) {
207  bytestream_put_buffer(&buf, ptr, lsize);
208  ptr += p->linesize[0];
209  }
210 
211  *got_packet = 1;
212  return 0;
213 }
214 
215 const FFCodec ff_xwd_encoder = {
216  .p.name = "xwd",
217  CODEC_LONG_NAME("XWD (X Window Dump) image"),
218  .p.type = AVMEDIA_TYPE_VIDEO,
219  .p.id = AV_CODEC_ID_XWD,
220  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
221  FF_CODEC_ENCODE_CB(xwd_encode_frame),
222  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,
223  AV_PIX_FMT_RGBA,
224  AV_PIX_FMT_ARGB,
225  AV_PIX_FMT_ABGR,
226  AV_PIX_FMT_RGB24,
227  AV_PIX_FMT_BGR24,
228  AV_PIX_FMT_RGB565BE,
229  AV_PIX_FMT_RGB565LE,
230  AV_PIX_FMT_BGR565BE,
231  AV_PIX_FMT_BGR565LE,
232  AV_PIX_FMT_RGB555BE,
233  AV_PIX_FMT_RGB555LE,
234  AV_PIX_FMT_BGR555BE,
235  AV_PIX_FMT_BGR555LE,
236  AV_PIX_FMT_RGB8,
237  AV_PIX_FMT_BGR8,
238  AV_PIX_FMT_RGB4_BYTE,
239  AV_PIX_FMT_BGR4_BYTE,
240  AV_PIX_FMT_PAL8,
241  AV_PIX_FMT_GRAY8,
242  AV_PIX_FMT_MONOWHITE,
243  AV_PIX_FMT_NONE },
244 };
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
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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:2965
out_size
int out_size
Definition: movenc.c:56
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
pixdesc.h
AVPacket::data
uint8_t * data
Definition: packet.h:524
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:82
FFCodec
Definition: codec_internal.h:127
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:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
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:2917
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:114
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
rgb
Definition: rpzaenc.c:60
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
avpriv_set_systematic_pal2
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:178
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
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:113
AV_CODEC_ID_XWD
@ AV_CODEC_ID_XWD
Definition: codec_id.h:210
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:118
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition: pixfmt.h:93
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
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:119
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:92
xwd_encode_frame
static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
Definition: xwdenc.c:34
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
codec_internal.h
XWD_HEADER_SIZE
#define XWD_HEADER_SIZE
Definition: xwd.h:27
imgutils_internal.h
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:117
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
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:115
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:194
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
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
ff_xwd_encoder
const FFCodec ff_xwd_encoder
Definition: xwdenc.c:215
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:106
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
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:112
desc
const char * desc
Definition: libsvtav1.c:75
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:120
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:501
XWD_VERSION
#define XWD_VERSION
Definition: xwd.h:26
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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:419
XWD_CMAP_SIZE
#define XWD_CMAP_SIZE
Definition: xwd.h:28
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
WINDOW_NAME_SIZE
#define WINDOW_NAME_SIZE
Definition: xwdenc.c:32
Generated on Thu Apr 18 2024 19:22:01 for FFmpeg by   doxygen 1.8.17