FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/pcx.c
Date: 2026-10-29 17:07:12
Exec Total Coverage
Lines: 63 137 46.0%
Functions: 2 3 66.7%
Branches: 33 99 33.3%
Line Branch Exec Source
1 /*
2 * PC Paintbrush PCX (.pcx) image decoder
3 * Copyright (c) 2007, 2008 Ivo van Poorten
4 *
5 * This decoder does not support CGA palettes. I am unable to find samples
6 * and Netpbm cannot generate them.
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 #include "libavutil/mem.h"
26 #include "avcodec.h"
27 #include "bytestream.h"
28 #include "codec_internal.h"
29 #include "decode.h"
30 #include "get_bits.h"
31
32 #define PCX_HEADER_SIZE 128
33
34 4320 static int pcx_rle_decode(GetByteContext *gb,
35 uint8_t *dst,
36 unsigned int bytes_per_scanline,
37 int compressed)
38 {
39 4320 unsigned int i = 0;
40 unsigned char run, value;
41
42
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4320 times.
 4320 if (bytestream2_get_bytes_left(gb) < 1)
43 ✗ return AVERROR_INVALIDDATA;
44
45
1/2
✓ Branch 0 taken 4320 times.
✗ Branch 1 not taken.
 4320 if (compressed) {
46
3/4
✓ Branch 0 taken 4325705 times.
✓ Branch 1 taken 4320 times.
✓ Branch 3 taken 4325705 times.
✗ Branch 4 not taken.
 4330025 while (i < bytes_per_scanline && bytestream2_get_bytes_left(gb)>0) {
47 4325705 run = 1;
48 4325705 value = bytestream2_get_byte(gb);
49
3/4
✓ Branch 0 taken 1136991 times.
✓ Branch 1 taken 3188714 times.
✓ Branch 3 taken 1136991 times.
✗ Branch 4 not taken.
 4325705 if (value >= 0xc0 && bytestream2_get_bytes_left(gb)>0) {
50 1136991 run = value & 0x3f;
51 1136991 value = bytestream2_get_byte(gb);
52 }
53
4/4
✓ Branch 0 taken 8883305 times.
✓ Branch 1 taken 4320 times.
✓ Branch 2 taken 4561920 times.
✓ Branch 3 taken 4321385 times.
 8887625 while (i < bytes_per_scanline && run--)
54 4561920 dst[i++] = value;
55 }
56 } else {
57 ✗ i = bytestream2_get_buffer(gb, dst, bytes_per_scanline);
58 }
59 4320 memset(dst + i, 0, bytes_per_scanline - i);
60 4320 return 0;
61 }
62
63 ✗ static void pcx_palette(GetByteContext *gb, uint32_t *dst, int pallen)
64 {
65 int i;
66
67 ✗ pallen = FFMIN(pallen, bytestream2_get_bytes_left(gb) / 3);
68 ✗ for (i = 0; i < pallen; i++)
69 ✗ *dst++ = 0xFF000000 | bytestream2_get_be24u(gb);
70 ✗ if (pallen < 256)
71 ✗ memset(dst, 0, (256 - pallen) * sizeof(*dst));
72 ✗ }
73
74 15 static int pcx_decode_frame(AVCodecContext *avctx, AVFrame *p,
75 int *got_frame, AVPacket *avpkt)
76 {
77 GetByteContext gb;
78 int compressed, xmin, ymin, xmax, ymax;
79 int ret;
80 unsigned int w, h, bits_per_pixel, bytes_per_line, nplanes, y, x,
81 bytes_per_scanline;
82 uint8_t *ptr, *scanline;
83 ptrdiff_t stride;
84
85
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (avpkt->size < PCX_HEADER_SIZE) {
86 ✗ av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
87 ✗ return AVERROR_INVALIDDATA;
88 }
89
90 15 bytestream2_init(&gb, avpkt->data, avpkt->size);
91
92
2/4
✓ Branch 1 taken 15 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15 times.
 15 if (bytestream2_get_byteu(&gb) != 0x0a || bytestream2_get_byteu(&gb) > 5) {
93 ✗ av_log(avctx, AV_LOG_ERROR, "this is not PCX encoded data\n");
94 ✗ return AVERROR_INVALIDDATA;
95 }
96
97 15 compressed = bytestream2_get_byteu(&gb);
98 15 bits_per_pixel = bytestream2_get_byteu(&gb);
99 15 xmin = bytestream2_get_le16u(&gb);
100 15 ymin = bytestream2_get_le16u(&gb);
101 15 xmax = bytestream2_get_le16u(&gb);
102 15 ymax = bytestream2_get_le16u(&gb);
103 15 avctx->sample_aspect_ratio.num = bytestream2_get_le16u(&gb);
104 15 avctx->sample_aspect_ratio.den = bytestream2_get_le16u(&gb);
105
106
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
 15 if (xmax < xmin || ymax < ymin) {
107 ✗ av_log(avctx, AV_LOG_ERROR, "invalid image dimensions\n");
108 ✗ return AVERROR_INVALIDDATA;
109 }
110
111 15 w = xmax - xmin + 1;
112 15 h = ymax - ymin + 1;
113
114 15 bytestream2_skipu(&gb, 49);
115 15 nplanes = bytestream2_get_byteu(&gb);
116 15 bytes_per_line = bytestream2_get_le16u(&gb);
117 15 bytes_per_scanline = nplanes * bytes_per_line;
118
119
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
 15 if (bytes_per_scanline < (w * bits_per_pixel * nplanes + 7) / 8 ||
120 ✗ (!compressed && bytes_per_scanline > bytestream2_get_bytes_left(&gb) / h)) {
121 ✗ av_log(avctx, AV_LOG_ERROR, "PCX data is corrupted\n");
122 ✗ return AVERROR_INVALIDDATA;
123 }
124
125
1/3
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 15 switch ((nplanes << 8) + bits_per_pixel) {
126 15 case 0x0308:
127 15 avctx->pix_fmt = AV_PIX_FMT_RGB24;
128 15 break;
129 ✗ case 0x0108:
130 case 0x0104:
131 case 0x0102:
132 case 0x0101:
133 case 0x0401:
134 case 0x0301:
135 case 0x0201:
136 ✗ avctx->pix_fmt = AV_PIX_FMT_PAL8;
137 ✗ break;
138 ✗ default:
139 ✗ av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");
140 ✗ return AVERROR_INVALIDDATA;
141 }
142
143 15 bytestream2_skipu(&gb, 60);
144
145
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
 15 if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
146 ✗ return ret;
147
148
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
 15 if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
149 ✗ return ret;
150
151 15 p->pict_type = AV_PICTURE_TYPE_I;
152
153 15 ptr = p->data[0];
154 15 stride = p->linesize[0];
155
156 15 scanline = av_malloc(bytes_per_scanline + AV_INPUT_BUFFER_PADDING_SIZE);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (!scanline)
158 ✗ return AVERROR(ENOMEM);
159
160
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
 15 if (nplanes == 3 && bits_per_pixel == 8) {
161
2/2
✓ Branch 0 taken 4320 times.
✓ Branch 1 taken 15 times.
 4335 for (y = 0; y < h; y++) {
162 4320 ret = pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
163
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4320 times.
 4320 if (ret < 0)
164 ✗ goto end;
165
166
2/2
✓ Branch 0 taken 1520640 times.
✓ Branch 1 taken 4320 times.
 1524960 for (x = 0; x < w; x++) {
167 1520640 ptr[3 * x] = scanline[x];
168 1520640 ptr[3 * x + 1] = scanline[x + bytes_per_line];
169 1520640 ptr[3 * x + 2] = scanline[x + (bytes_per_line << 1)];
170 }
171
172 4320 ptr += stride;
173 }
174 ✗ } else if (nplanes == 1 && bits_per_pixel == 8) {
175 ✗ int palstart = avpkt->size - 769;
176
177 ✗ if (avpkt->size < 769) {
178 ✗ av_log(avctx, AV_LOG_ERROR, "File is too short\n");
179 ✗ ret = avctx->err_recognition & AV_EF_EXPLODE ?
180 ✗ AVERROR_INVALIDDATA : avpkt->size;
181 ✗ goto end;
182 }
183
184 ✗ for (y = 0; y < h; y++, ptr += stride) {
185 ✗ ret = pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
186 ✗ if (ret < 0)
187 ✗ goto end;
188 ✗ memcpy(ptr, scanline, w);
189 }
190
191 ✗ if (bytestream2_tell(&gb) != palstart) {
192 ✗ av_log(avctx, AV_LOG_WARNING, "image data possibly corrupted\n");
193 ✗ bytestream2_seek(&gb, palstart, SEEK_SET);
194 }
195 ✗ if (bytestream2_get_byte(&gb) != 12) {
196 ✗ av_log(avctx, AV_LOG_ERROR, "expected palette after image data\n");
197 ✗ ret = avctx->err_recognition & AV_EF_EXPLODE ?
198 ✗ AVERROR_INVALIDDATA : avpkt->size;
199 ✗ goto end;
200 }
201 ✗ } else if (nplanes == 1) { /* all packed formats, max. 16 colors */
202 GetBitContext s;
203
204 ✗ for (y = 0; y < h; y++) {
205 ✗ init_get_bits8(&s, scanline, bytes_per_scanline);
206
207 ✗ ret = pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
208 ✗ if (ret < 0)
209 ✗ goto end;
210
211 ✗ for (x = 0; x < w; x++)
212 ✗ ptr[x] = get_bits(&s, bits_per_pixel);
213 ✗ ptr += stride;
214 }
215 } else { /* planar, 4, 8 or 16 colors */
216 int i;
217
218 ✗ for (y = 0; y < h; y++) {
219 ✗ ret = pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
220 ✗ if (ret < 0)
221 ✗ goto end;
222
223 ✗ for (x = 0; x < w; x++) {
224 ✗ int m = 0x80 >> (x & 7), v = 0;
225 ✗ for (i = nplanes - 1; i >= 0; i--) {
226 ✗ v <<= 1;
227 ✗ v += !!(scanline[i * bytes_per_line + (x >> 3)] & m);
228 }
229 ✗ ptr[x] = v;
230 }
231 ✗ ptr += stride;
232 }
233 }
234
235 15 ret = bytestream2_tell(&gb);
236
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 15 if (nplanes == 1 && bits_per_pixel == 8) {
237 ✗ pcx_palette(&gb, (uint32_t *)p->data[1], 256);
238 ✗ ret += 256 * 3;
239
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 } else if (bits_per_pixel * nplanes == 1) {
240 ✗ AV_WN32A(p->data[1] , 0xFF000000);
241 ✗ AV_WN32A(p->data[1]+4, 0xFFFFFFFF);
242
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 } else if (bits_per_pixel < 8) {
243 ✗ bytestream2_seek(&gb, 16, SEEK_SET);
244 ✗ pcx_palette(&gb, (uint32_t *)p->data[1], 16);
245 }
246
247 15 *got_frame = 1;
248
249 15 end:
250 15 av_free(scanline);
251 15 return ret;
252 }
253
254 const FFCodec ff_pcx_decoder = {
255 .p.name = "pcx",
256 CODEC_LONG_NAME("PC Paintbrush PCX image"),
257 .p.type = AVMEDIA_TYPE_VIDEO,
258 .p.id = AV_CODEC_ID_PCX,
259 FF_CODEC_DECODE_CB(pcx_decode_frame),
260 .p.capabilities = AV_CODEC_CAP_DR1,
261 };
262