FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/pcxenc.c	Lines:	68	100	68.0 %
Date:	2020-09-21 17:35:45	Branches:	32	53	60.4 %


/*
 * PC Paintbrush PCX (.pcx) image encoder
 * Copyright (c) 2009 Daniel Verkamp <daniel at drv.nu>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * PCX image encoder
 * @author Daniel Verkamp
 * @see http://bespin.org/~qz/pc-gpe/pcx.txt
 */

#include "avcodec.h"
#include "bytestream.h"
#include "libavutil/imgutils.h"
#include "internal.h"

static const uint32_t monoblack_pal[16] = { 0x000000, 0xFFFFFF };

static av_cold int pcx_encode_init(AVCodecContext *avctx)
{
#if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
    avctx->coded_frame->key_frame = 1;
FF_ENABLE_DEPRECATION_WARNINGS
#endif

    return 0;
}

/**
 * PCX run-length encoder
 * @param dst output buffer
 * @param dst_size size of output buffer
 * @param src input buffer
 * @param src_plane_size size of one plane of input buffer in bytes
 * @param nplanes number of planes in input buffer
 * @return number of bytes written to dst or -1 on error
 * @bug will not work for nplanes != 1 && bpp != 8
 */
static int pcx_rle_encode(      uint8_t *dst, int dst_size,
                          const uint8_t *src, int src_plane_size, int nplanes)
{
    int p;
    const uint8_t *dst_start = dst;

    // check worst-case upper bound on dst_size
    if (dst_size < 2LL * src_plane_size * nplanes || src_plane_size <= 0)
        return AVERROR(EINVAL);

    for (p = 0; p < nplanes; p++) {
        int count = 1;
        const uint8_t *src_plane = src + p;
        const uint8_t *src_plane_end = src_plane + src_plane_size * nplanes;
        uint8_t prev = *src_plane;
        src_plane += nplanes;

        for (; ; src_plane += nplanes) {
            if (src_plane < src_plane_end && *src_plane == prev && count < 0x3F) {
                // current byte is same as prev
                ++count;
            } else {
                // output prev * count
                if (count != 1 || prev >= 0xC0)
                    *dst++ = 0xC0 | count;
                *dst++ = prev;

                if (src_plane == src_plane_end)
                    break;

                // start new run
                count = 1;
                prev = *src_plane;
            }
        }
    }

    return dst - dst_start;
}

static int pcx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                            const AVFrame *frame, int *got_packet)
{
    const uint8_t *buf_end;
    uint8_t *buf;

    int bpp, nplanes, i, y, line_bytes, written, ret, max_pkt_size, sw, sh;
    const uint32_t *pal = NULL;
    uint32_t palette256[256];
    const uint8_t *src;

    if (avctx->width > 65535 || avctx->height > 65535) {
        av_log(avctx, AV_LOG_ERROR, "image dimensions do not fit in 16 bits\n");
        return AVERROR(EINVAL);
    }

    switch (avctx->pix_fmt) {
    case AV_PIX_FMT_RGB24:
        bpp = 8;
        nplanes = 3;
        break;
    case AV_PIX_FMT_RGB8:
    case AV_PIX_FMT_BGR8:
    case AV_PIX_FMT_RGB4_BYTE:
    case AV_PIX_FMT_BGR4_BYTE:
    case AV_PIX_FMT_GRAY8:
        bpp = 8;
        nplanes = 1;
        avpriv_set_systematic_pal2(palette256, avctx->pix_fmt);
        pal = palette256;
        break;
    case AV_PIX_FMT_PAL8:
        bpp = 8;
        nplanes = 1;
        pal = (uint32_t *)frame->data[1];
        break;
    case AV_PIX_FMT_MONOBLACK:
        bpp = 1;
        nplanes = 1;
        pal = monoblack_pal;
        break;
    default:
        av_log(avctx, AV_LOG_ERROR, "unsupported pixfmt\n");
        return AVERROR(EINVAL);
    }

    line_bytes = (avctx->width * bpp + 7) >> 3;
    line_bytes = (line_bytes + 1) & ~1;

    max_pkt_size = 128 + avctx->height * 2 * line_bytes * nplanes + (pal ? 256*3 + 1 : 0);
    if ((ret = ff_alloc_packet2(avctx, pkt, max_pkt_size, 0)) < 0)
        return ret;
    buf     = pkt->data;
    buf_end = pkt->data + pkt->size;

    sw = avctx->sample_aspect_ratio.num;
    sh = avctx->sample_aspect_ratio.den;
    if (sw > 0xFFFFu || sh > 0xFFFFu)
        av_reduce(&sw, &sh, sw, sh, 0xFFFFu);

    bytestream_put_byte(&buf, 10);                  // manufacturer
    bytestream_put_byte(&buf, 5);                   // version
    bytestream_put_byte(&buf, 1);                   // encoding
    bytestream_put_byte(&buf, bpp);                 // bits per pixel per plane
    bytestream_put_le16(&buf, 0);                   // x min
    bytestream_put_le16(&buf, 0);                   // y min
    bytestream_put_le16(&buf, avctx->width - 1);    // x max
    bytestream_put_le16(&buf, avctx->height - 1);   // y max
    bytestream_put_le16(&buf, sw);                  // horizontal DPI
    bytestream_put_le16(&buf, sh);                  // vertical DPI
    for (i = 0; i < 16; i++)
        bytestream_put_be24(&buf, pal ? pal[i] : 0);// palette (<= 16 color only)
    bytestream_put_byte(&buf, 0);                   // reserved
    bytestream_put_byte(&buf, nplanes);             // number of planes
    bytestream_put_le16(&buf, line_bytes);          // scanline plane size in bytes

    while (buf - pkt->data < 128)
        *buf++= 0;

    src = frame->data[0];

    for (y = 0; y < avctx->height; y++) {
        if ((written = pcx_rle_encode(buf, buf_end - buf,
                                      src, line_bytes, nplanes)) < 0) {
            av_log(avctx, AV_LOG_ERROR, "buffer too small\n");
            return AVERROR_BUG;
        }
        buf += written;
        src += frame->linesize[0];
    }

    if (nplanes == 1 && bpp == 8) {
        if (buf_end - buf < 257) {
            av_log(avctx, AV_LOG_ERROR, "buffer too small\n");
            return AVERROR_BUG;
        }
        bytestream_put_byte(&buf, 12);
        for (i = 0; i < 256; i++) {
            bytestream_put_be24(&buf, pal[i]);
        }
    }

    pkt->size   = buf - pkt->data;
    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;

    return 0;
}

AVCodec ff_pcx_encoder = {
    .name           = "pcx",
    .long_name      = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_PCX,
    .init           = pcx_encode_init,
    .encode2        = pcx_encode_frame,
    .pix_fmts       = (const enum AVPixelFormat[]){
        AV_PIX_FMT_RGB24,
        AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
        AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
        AV_PIX_FMT_MONOBLACK,
        AV_PIX_FMT_NONE
    },
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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
36		1	static av_cold int pcx_encode_init(AVCodecContext *avctx)
37			{
38			#if FF_API_CODED_FRAME
39			FF_DISABLE_DEPRECATION_WARNINGS
40		1	avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
41		1	avctx->coded_frame->key_frame = 1;
42			FF_ENABLE_DEPRECATION_WARNINGS
43			#endif
44
45		1	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		3744	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		3744	const uint8_t *dst_start = dst;
63
64			// check worst-case upper bound on dst_size
65	✓✗✗✓	3744	if (dst_size < 2LL * src_plane_size * nplanes \|\| src_plane_size <= 0)
66			return AVERROR(EINVAL);
67
68	✓✓	14976	for (p = 0; p < nplanes; p++) {
69		11232	int count = 1;
70		11232	const uint8_t *src_plane = src + p;
71		11232	const uint8_t src_plane_end = src_plane + src_plane_size nplanes;
72		11232	uint8_t prev = *src_plane;
73		11232	src_plane += nplanes;
74
75		3942432	for (; ; src_plane += nplanes) {
76	✓✓✓✓ ✓✓	3953664	if (src_plane < src_plane_end && *src_plane == prev && count < 0x3F) {
77			// current byte is same as prev
78		204027	++count;
79			} else {
80			// output prev * count
81	✓✓✓✓	3749637	if (count != 1 \|\| prev >= 0xC0)
82		985221	*dst++ = 0xC0 \| count;
83		3749637	*dst++ = prev;
84
85	✓✓	3749637	if (src_plane == src_plane_end)
86		11232	break;
87
88			// start new run
89		3738405	count = 1;
90		3738405	prev = *src_plane;
91			}
92			}
93			}
94
95		3744	return dst - dst_start;
96			}
97
98		13	static int pcx_encode_frame(AVCodecContext avctx, AVPacket pkt,
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		13	const uint32_t *pal = NULL;
106			uint32_t palette256[256];
107			const uint8_t *src;
108
109	✓✗✗✓	13	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	✓✗✗✗ ✗	13	switch (avctx->pix_fmt) {
115		13	case AV_PIX_FMT_RGB24:
116		13	bpp = 8;
117		13	nplanes = 3;
118		13	break;
119			case AV_PIX_FMT_RGB8:
120			case AV_PIX_FMT_BGR8:
121			case AV_PIX_FMT_RGB4_BYTE:
122			case AV_PIX_FMT_BGR4_BYTE:
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;
134			case AV_PIX_FMT_MONOBLACK:
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		13	line_bytes = (avctx->width * bpp + 7) >> 3;
145		13	line_bytes = (line_bytes + 1) & ~1;
146
147	✗✓	13	max_pkt_size = 128 + avctx->height * 2 * line_bytes * nplanes + (pal ? 256*3 + 1 : 0);
148	✗✓	13	if ((ret = ff_alloc_packet2(avctx, pkt, max_pkt_size, 0)) < 0)
149			return ret;
150		13	buf = pkt->data;
151		13	buf_end = pkt->data + pkt->size;
152
153		13	sw = avctx->sample_aspect_ratio.num;
154		13	sh = avctx->sample_aspect_ratio.den;
155	✓✗✗✓	13	if (sw > 0xFFFFu \|\| sh > 0xFFFFu)
156			av_reduce(&sw, &sh, sw, sh, 0xFFFFu);
157
158		13	bytestream_put_byte(&buf, 10); // manufacturer
159		13	bytestream_put_byte(&buf, 5); // version
160		13	bytestream_put_byte(&buf, 1); // encoding
161		13	bytestream_put_byte(&buf, bpp); // bits per pixel per plane
162		13	bytestream_put_le16(&buf, 0); // x min
163		13	bytestream_put_le16(&buf, 0); // y min
164		13	bytestream_put_le16(&buf, avctx->width - 1); // x max
165		13	bytestream_put_le16(&buf, avctx->height - 1); // y max
166		13	bytestream_put_le16(&buf, sw); // horizontal DPI
167		13	bytestream_put_le16(&buf, sh); // vertical DPI
168	✓✓	221	for (i = 0; i < 16; i++)
169	✗✓	208	bytestream_put_be24(&buf, pal ? pal[i] : 0);// palette (<= 16 color only)
170		13	bytestream_put_byte(&buf, 0); // reserved
171		13	bytestream_put_byte(&buf, nplanes); // number of planes
172		13	bytestream_put_le16(&buf, line_bytes); // scanline plane size in bytes
173
174	✓✓	793	while (buf - pkt->data < 128)
175		780	*buf++= 0;
176
177		13	src = frame->data[0];
178
179	✓✓	3757	for (y = 0; y < avctx->height; y++) {
180	✗✓	3744	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		3744	buf += written;
186		3744	src += frame->linesize[0];
187			}
188
189	✗✓✗✗	13	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		13	pkt->size = buf - pkt->data;
201		13	pkt->flags \|= AV_PKT_FLAG_KEY;
202		13	*got_packet = 1;
203
204		13	return 0;
205			}
206
207			AVCodec ff_pcx_encoder = {
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[]){
215			AV_PIX_FMT_RGB24,
216			AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
217			AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
218			AV_PIX_FMT_MONOBLACK,
219			AV_PIX_FMT_NONE
220			},
221			};