FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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://www.qzx.com/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:181
misc image utilities
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:65
int num
numerator
Definition: rational.h:44
int size
Definition: avcodec.h:1468
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:1935
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1752
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3392
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:87
uint8_t
#define av_cold
Definition: attributes.h:82
8 bit with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:74
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:151
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1467
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1499
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
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:3399
GLsizei count
Definition: opengl_enc.c:109
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1473
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
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:252
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:90
int width
picture width / height.
Definition: avcodec.h:1711
static int pcx_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: pcxenc.c:98
#define src
Definition: vp9dsp.c:530
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:85
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:209
main external API structure.
Definition: avcodec.h:1532
void * buf
Definition: avisynth_c.h:553
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1621
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:73
Y , 8bpp.
Definition: pixfmt.h:71
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
common internal api header.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2945
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:88
int den
denominator
Definition: rational.h:45
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:247
static const uint32_t monoblack_pal[16]
Definition: pcxenc.c:34
static av_cold int pcx_encode_init(AVCodecContext *avctx)
Definition: pcxenc.c:36
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
This structure stores compressed data.
Definition: avcodec.h:1444
AVCodec ff_pcx_encoder
Definition: pcxenc.c:207