FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/targaenc.c
Date: 2024-07-26 21:54:09
Exec Total Coverage
Lines: 47 87 54.0%
Functions: 4 4 100.0%
Branches: 12 34 35.3%
Line Branch Exec Source
1 /*
2 * Targa (.tga) image encoder
3 * Copyright (c) 2007 Bobby Bingham
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 #include <string.h>
23
24 #include "libavutil/avassert.h"
25 #include "libavutil/imgutils.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 #include "avcodec.h"
31 #include "codec_internal.h"
32 #include "encode.h"
33 #include "rle.h"
34 #include "targa.h"
35
36 typedef struct TargaContext {
37 AVClass *class;
38
39 int rle;
40 } TargaContext;
41
42 /**
43 * RLE compress the image, with maximum size of out_size
44 * @param outbuf Output buffer
45 * @param out_size Maximum output size
46 * @param pic Image to compress
47 * @param bpp Bytes per pixel
48 * @param w Image width
49 * @param h Image height
50 * @return Size of output in bytes, or -1 if larger than out_size
51 */
52 13 static int targa_encode_rle(uint8_t *outbuf, int out_size, const AVFrame *pic,
53 int bpp, int w, int h)
54 {
55 int y,ret;
56 uint8_t *out;
57
58 13 out = outbuf;
59
60
1/2
✓ Branch 0 taken 3744 times.
✗ Branch 1 not taken.
 3744 for(y = 0; y < h; y ++) {
61 3744 ret = ff_rle_encode(out, out_size, pic->data[0] + pic->linesize[0] * y, bpp, w, 0x7f, 0, -1, 0);
62
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 3731 times.
 3744 if(ret == -1){
63 13 return -1;
64 }
65 3731 out+= ret;
66 3731 out_size -= ret;
67 }
68
69 ✗ return out - outbuf;
70 }
71
72 13 static int targa_encode_normal(uint8_t *outbuf, const AVFrame *pic, int bpp, int w, int h)
73 {
74 13 int i, n = bpp * w;
75 13 uint8_t *out = outbuf;
76 13 const uint8_t *ptr = pic->data[0];
77
78
2/2
✓ Branch 0 taken 3744 times.
✓ Branch 1 taken 13 times.
 3757 for(i=0; i < h; i++) {
79 3744 memcpy(out, ptr, n);
80 3744 out += n;
81 3744 ptr += pic->linesize[0];
82 }
83
84 13 return out - outbuf;
85 }
86
87 13 static int targa_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
88 const AVFrame *p, int *got_packet)
89 {
90 13 TargaContext *s = avctx->priv_data;
91 13 int bpp, picsize, datasize = -1, ret, i;
92 uint8_t *out;
93 13 int maxpal = 32*32;
94
95 13 picsize = av_image_get_buffer_size(avctx->pix_fmt,
96 avctx->width, avctx->height, 1);
97
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
 13 if ((ret = ff_alloc_packet(avctx, pkt, picsize + 45 + maxpal)) < 0)
98 ✗ return ret;
99
100 /* zero out the header and only set applicable fields */
101 13 memset(pkt->data, 0, 12);
102 13 AV_WL16(pkt->data+12, avctx->width);
103 13 AV_WL16(pkt->data+14, avctx->height);
104 /* image descriptor byte: origin is always top-left, bits 0-3 specify alpha */
105
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
 13 pkt->data[17] = 0x20 | (avctx->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0);
106
107 13 out = pkt->data + 18; /* skip past the header we write */
108
109 13 avctx->bits_per_coded_sample = av_get_bits_per_pixel(av_pix_fmt_desc_get(avctx->pix_fmt));
110
1/6
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 13 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 13 switch(avctx->pix_fmt) {
111 ✗ case AV_PIX_FMT_PAL8: {
112 ✗ int pal_bpp = 24; /* Only write 32bit palette if there is transparency information */
113 ✗ for (i = 0; i < 256; i++)
114 ✗ if (AV_RN32(p->data[1] + 4 * i) >> 24 != 0xFF) {
115 ✗ pal_bpp = 32;
116 ✗ break;
117 }
118 ✗ pkt->data[1] = 1; /* palette present */
119 ✗ pkt->data[2] = TGA_PAL; /* uncompressed palettised image */
120 ✗ pkt->data[6] = 1; /* palette contains 256 entries */
121 ✗ pkt->data[7] = pal_bpp; /* palette contains pal_bpp bit entries */
122 ✗ pkt->data[16] = 8; /* bpp */
123 ✗ for (i = 0; i < 256; i++)
124 ✗ if (pal_bpp == 32) {
125 ✗ AV_WL32(pkt->data + 18 + 4 * i, *(uint32_t *)(p->data[1] + i * 4));
126 } else {
127 ✗ AV_WL24(pkt->data + 18 + 3 * i, *(uint32_t *)(p->data[1] + i * 4));
128 }
129 ✗ out += 32 * pal_bpp; /* skip past the palette we just output */
130 ✗ av_assert0(32 * pal_bpp <= maxpal);
131 ✗ break;
132 }
133 ✗ case AV_PIX_FMT_GRAY8:
134 ✗ pkt->data[2] = TGA_BW; /* uncompressed grayscale image */
135 ✗ avctx->bits_per_coded_sample = 0x28;
136 ✗ pkt->data[16] = 8; /* bpp */
137 ✗ break;
138 ✗ case AV_PIX_FMT_RGB555LE:
139 ✗ pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
140 ✗ avctx->bits_per_coded_sample =
141 ✗ pkt->data[16] = 16; /* bpp */
142 ✗ break;
143 13 case AV_PIX_FMT_BGR24:
144 13 pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
145 13 pkt->data[16] = 24; /* bpp */
146 13 break;
147 ✗ case AV_PIX_FMT_BGRA:
148 ✗ pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
149 ✗ pkt->data[16] = 32; /* bpp */
150 ✗ break;
151 ✗ default:
152 ✗ av_log(avctx, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",
153 av_get_pix_fmt_name(avctx->pix_fmt));
154 ✗ return AVERROR(EINVAL);
155 }
156 13 bpp = pkt->data[16] >> 3;
157
158
159 /* try RLE compression */
160
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
 13 if (s->rle)
161 13 datasize = targa_encode_rle(out, picsize, p, bpp, avctx->width, avctx->height);
162
163 /* if that worked well, mark the picture as RLE compressed */
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
 13 if(datasize >= 0)
165 ✗ pkt->data[2] |= TGA_RLE;
166
167 /* if RLE didn't make it smaller, go back to no compression */
168 13 else datasize = targa_encode_normal(out, p, bpp, avctx->width, avctx->height);
169
170 13 out += datasize;
171
172 /* The standard recommends including this section, even if we don't use
173 * any of the features it affords. TODO: take advantage of the pixel
174 * aspect ratio and encoder ID fields available? */
175 13 memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);
176
177 13 pkt->size = out + 26 - pkt->data;
178 13 *got_packet = 1;
179
180 13 return 0;
181 }
182
183 1 static av_cold int targa_encode_init(AVCodecContext *avctx)
184 {
185
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (avctx->width > 0xffff || avctx->height > 0xffff) {
186 ✗ av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n");
187 ✗ return AVERROR(EINVAL);
188 }
189
190 1 return 0;
191 }
192
193 #define OFFSET(x) offsetof(TargaContext, x)
194 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
195 static const AVOption options[] = {
196 { "rle", "Use run-length compression", OFFSET(rle), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
197
198 { NULL },
199 };
200
201 static const AVClass targa_class = {
202 .class_name = "targa",
203 .item_name = av_default_item_name,
204 .option = options,
205 .version = LIBAVUTIL_VERSION_INT,
206 };
207
208 const FFCodec ff_targa_encoder = {
209 .p.name = "targa",
210 CODEC_LONG_NAME("Truevision Targa image"),
211 .p.type = AVMEDIA_TYPE_VIDEO,
212 .p.id = AV_CODEC_ID_TARGA,
213 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
214 .priv_data_size = sizeof(TargaContext),
215 .p.priv_class = &targa_class,
216 .init = targa_encode_init,
217 FF_CODEC_ENCODE_CB(targa_encode_frame),
218 .p.pix_fmts = (const enum AVPixelFormat[]){
219 AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_RGB555LE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
220 AV_PIX_FMT_NONE
221 },
222 };
223