FFmpeg
pcxenc.c
Go to the documentation of this file.
1 /*
2  * PC Paintbrush PCX (.pcx) image encoder
3  * Copyright (c) 2009 Daniel Verkamp <daniel at drv.nu>
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 /**
23  * @file
24  * PCX image encoder
25  * @author Daniel Verkamp
26  * @see http://bespin.org/~qz/pc-gpe/pcx.txt
27  */
28 
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "libavutil/imgutils.h"
32 #include "internal.h"
33 
34 static const uint32_t monoblack_pal[16] = { 0x000000, 0xFFFFFF };
35 
37 {
38 #if FF_API_CODED_FRAME
41  avctx->coded_frame->key_frame = 1;
43 #endif
44 
45  return 0;
46 }
47 
48 /**
49  * PCX run-length encoder
50  * @param dst output buffer
51  * @param dst_size size of output buffer
52  * @param src input buffer
53  * @param src_plane_size size of one plane of input buffer in bytes
54  * @param nplanes number of planes in input buffer
55  * @return number of bytes written to dst or -1 on error
56  * @bug will not work for nplanes != 1 && bpp != 8
57  */
58 static int pcx_rle_encode( uint8_t *dst, int dst_size,
59  const uint8_t *src, int src_plane_size, int nplanes)
60 {
61  int p;
62  const uint8_t *dst_start = dst;
63 
64  // check worst-case upper bound on dst_size
65  if (dst_size < 2LL * src_plane_size * nplanes || src_plane_size <= 0)
66  return AVERROR(EINVAL);
67 
68  for (p = 0; p < nplanes; p++) {
69  int count = 1;
70  const uint8_t *src_plane = src + p;
71  const uint8_t *src_plane_end = src_plane + src_plane_size * nplanes;
72  uint8_t prev = *src_plane;
73  src_plane += nplanes;
74 
75  for (; ; src_plane += nplanes) {
76  if (src_plane < src_plane_end && *src_plane == prev && count < 0x3F) {
77  // current byte is same as prev
78  ++count;
79  } else {
80  // output prev * count
81  if (count != 1 || prev >= 0xC0)
82  *dst++ = 0xC0 | count;
83  *dst++ = prev;
84 
85  if (src_plane == src_plane_end)
86  break;
87 
88  // start new run
89  count = 1;
90  prev = *src_plane;
91  }
92  }
93  }
94 
95  return dst - dst_start;
96 }
97 
99  const AVFrame *frame, int *got_packet)
100 {
101  const uint8_t *buf_end;
102  uint8_t *buf;
103 
104  int bpp, nplanes, i, y, line_bytes, written, ret, max_pkt_size, sw, sh;
105  const uint32_t *pal = NULL;
106  uint32_t palette256[256];
107  const uint8_t *src;
108 
109  if (avctx->width > 65535 || avctx->height > 65535) {
110  av_log(avctx, AV_LOG_ERROR, "image dimensions do not fit in 16 bits\n");
111  return AVERROR(EINVAL);
112  }
113 
114  switch (avctx->pix_fmt) {
115  case AV_PIX_FMT_RGB24:
116  bpp = 8;
117  nplanes = 3;
118  break;
119  case AV_PIX_FMT_RGB8:
120  case AV_PIX_FMT_BGR8:
123  case AV_PIX_FMT_GRAY8:
124  bpp = 8;
125  nplanes = 1;
126  avpriv_set_systematic_pal2(palette256, avctx->pix_fmt);
127  pal = palette256;
128  break;
129  case AV_PIX_FMT_PAL8:
130  bpp = 8;
131  nplanes = 1;
132  pal = (uint32_t *)frame->data[1];
133  break;
135  bpp = 1;
136  nplanes = 1;
137  pal = monoblack_pal;
138  break;
139  default:
140  av_log(avctx, AV_LOG_ERROR, "unsupported pixfmt\n");
141  return AVERROR(EINVAL);
142  }
143 
144  line_bytes = (avctx->width * bpp + 7) >> 3;
145  line_bytes = (line_bytes + 1) & ~1;
146 
147  max_pkt_size = 128 + avctx->height * 2 * line_bytes * nplanes + (pal ? 256*3 + 1 : 0);
148  if ((ret = ff_alloc_packet2(avctx, pkt, max_pkt_size, 0)) < 0)
149  return ret;
150  buf = pkt->data;
151  buf_end = pkt->data + pkt->size;
152 
153  sw = avctx->sample_aspect_ratio.num;
154  sh = avctx->sample_aspect_ratio.den;
155  if (sw > 0xFFFFu || sh > 0xFFFFu)
156  av_reduce(&sw, &sh, sw, sh, 0xFFFFu);
157 
158  bytestream_put_byte(&buf, 10); // manufacturer
159  bytestream_put_byte(&buf, 5); // version
160  bytestream_put_byte(&buf, 1); // encoding
161  bytestream_put_byte(&buf, bpp); // bits per pixel per plane
162  bytestream_put_le16(&buf, 0); // x min
163  bytestream_put_le16(&buf, 0); // y min
164  bytestream_put_le16(&buf, avctx->width - 1); // x max
165  bytestream_put_le16(&buf, avctx->height - 1); // y max
166  bytestream_put_le16(&buf, sw); // horizontal DPI
167  bytestream_put_le16(&buf, sh); // vertical DPI
168  for (i = 0; i < 16; i++)
169  bytestream_put_be24(&buf, pal ? pal[i] : 0);// palette (<= 16 color only)
170  bytestream_put_byte(&buf, 0); // reserved
171  bytestream_put_byte(&buf, nplanes); // number of planes
172  bytestream_put_le16(&buf, line_bytes); // scanline plane size in bytes
173 
174  while (buf - pkt->data < 128)
175  *buf++= 0;
176 
177  src = frame->data[0];
178 
179  for (y = 0; y < avctx->height; y++) {
180  if ((written = pcx_rle_encode(buf, buf_end - buf,
181  src, line_bytes, nplanes)) < 0) {
182  av_log(avctx, AV_LOG_ERROR, "buffer too small\n");
183  return AVERROR_BUG;
184  }
185  buf += written;
186  src += frame->linesize[0];
187  }
188 
189  if (nplanes == 1 && bpp == 8) {
190  if (buf_end - buf < 257) {
191  av_log(avctx, AV_LOG_ERROR, "buffer too small\n");
192  return AVERROR_BUG;
193  }
194  bytestream_put_byte(&buf, 12);
195  for (i = 0; i < 256; i++) {
196  bytestream_put_be24(&buf, pal[i]);
197  }
198  }
199 
200  pkt->size = buf - pkt->data;
201  pkt->flags |= AV_PKT_FLAG_KEY;
202  *got_packet = 1;
203 
204  return 0;
205 }
206 
208  .name = "pcx",
209  .long_name = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
210  .type = AVMEDIA_TYPE_VIDEO,
211  .id = AV_CODEC_ID_PCX,
212  .init = pcx_encode_init,
213  .encode2 = pcx_encode_frame,
214  .pix_fmts = (const enum AVPixelFormat[]){
220  },
221 };
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
misc image utilities
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
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:1944
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static AVPacket pkt
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3481
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
uint8_t
#define av_cold
Definition: attributes.h:82
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:152
uint8_t * data
Definition: avcodec.h:1477
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 av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
#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
static int pcx_rle_encode(uint8_t *dst, int dst_size, const uint8_t *src, int src_plane_size, int nplanes)
PCX run-length encoder.
Definition: pcxenc.c:58
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
GLsizei count
Definition: opengl_enc.c:108
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
int width
picture width / height.
Definition: avcodec.h:1738
static int pcx_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: pcxenc.c:98
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1565
void * buf
Definition: avisynth_c.h:766
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:76
Y , 8bpp.
Definition: pixfmt.h:74
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2815
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
int den
Denominator.
Definition: rational.h:60
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
static const uint32_t monoblack_pal[16]
Definition: pcxenc.c:34
static av_cold int pcx_encode_init(AVCodecContext *avctx)
Definition: pcxenc.c:36
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodec ff_pcx_encoder
Definition: pcxenc.c:207