FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mscc.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 0 143 0.0%
Branches: 0 68 0.0%

Line Branch Exec Source
1 /*
2 * Mandsoft Screen Capture Codec decoder
3 *
4 * Copyright (c) 2017 Paul B Mahol
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "avcodec.h"
28 #include "bytestream.h"
29 #include "internal.h"
30
31 #include <zlib.h>
32
33 typedef struct MSCCContext {
34 unsigned bpp;
35 unsigned int decomp_size;
36 uint8_t *decomp_buf;
37 unsigned int uncomp_size;
38 uint8_t *uncomp_buf;
39 z_stream zstream;
40
41 uint32_t pal[256];
42 } MSCCContext;
43
44 static int rle_uncompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb)
45 {
46 MSCCContext *s = avctx->priv_data;
47 unsigned x = 0, y = 0;
48
49 while (bytestream2_get_bytes_left(gb) > 0) {
50 uint32_t fill;
51 int j;
52 unsigned run = bytestream2_get_byte(gb);
53
54 if (run) {
55 switch (avctx->bits_per_coded_sample) {
56 case 8:
57 fill = bytestream2_get_byte(gb);
58 break;
59 case 16:
60 fill = bytestream2_get_le16(gb);
61 break;
62 case 24:
63 fill = bytestream2_get_le24(gb);
64 break;
65 case 32:
66 fill = bytestream2_get_le32(gb);
67 break;
68 }
69
70 for (j = 0; j < run; j++) {
71 switch (avctx->bits_per_coded_sample) {
72 case 8:
73 bytestream2_put_byte(pb, fill);
74 break;
75 case 16:
76 bytestream2_put_le16(pb, fill);
77 break;
78 case 24:
79 bytestream2_put_le24(pb, fill);
80 break;
81 case 32:
82 bytestream2_put_le32(pb, fill);
83 break;
84 }
85 }
86 x += run;
87 } else {
88 unsigned copy = bytestream2_get_byte(gb);
89
90 if (copy == 0) {
91 x = 0;
92 y++;
93 bytestream2_seek_p(pb, y * avctx->width * s->bpp, SEEK_SET);
94 } else if (copy == 1) {
95 return 0;
96 } else if (copy == 2) {
97
98 x += bytestream2_get_byte(gb);
99 y += bytestream2_get_byte(gb);
100
101 bytestream2_seek_p(pb, y * avctx->width * s->bpp + x * s->bpp, SEEK_SET);
102 } else {
103 for (j = 0; j < copy; j++) {
104 switch (avctx->bits_per_coded_sample) {
105 case 8:
106 bytestream2_put_byte(pb, bytestream2_get_byte(gb));
107 break;
108 case 16:
109 bytestream2_put_le16(pb, bytestream2_get_le16(gb));
110 break;
111 case 24:
112 bytestream2_put_le24(pb, bytestream2_get_le24(gb));
113 break;
114 case 32:
115 bytestream2_put_le32(pb, bytestream2_get_le32(gb));
116 break;
117 }
118 }
119
120 if (s->bpp == 1 && (copy & 1))
121 bytestream2_skip(gb, 1);
122 x += copy;
123 }
124 }
125 }
126
127 return AVERROR_INVALIDDATA;
128 }
129
130 static int decode_frame(AVCodecContext *avctx,
131 void *data, int *got_frame,
132 AVPacket *avpkt)
133 {
134 MSCCContext *s = avctx->priv_data;
135 AVFrame *frame = data;
136 uint8_t *buf = avpkt->data;
137 int buf_size = avpkt->size;
138 GetByteContext gb;
139 PutByteContext pb;
140 int ret, j;
141
142 if (avpkt->size < 3)
143 return buf_size;
144
145 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
146 return ret;
147
148 if (avctx->codec_id == AV_CODEC_ID_MSCC) {
149 avpkt->data[2] ^= avpkt->data[0];
150 buf += 2;
151 buf_size -= 2;
152 }
153
154 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
155 size_t size;
156 const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
157
158 if (pal && size == AVPALETTE_SIZE) {
159 frame->palette_has_changed = 1;
160 for (j = 0; j < 256; j++)
161 s->pal[j] = 0xFF000000 | AV_RL32(pal + j * 4);
162 } else if (pal) {
163 av_log(avctx, AV_LOG_ERROR,
164 "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
165 }
166 memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
167 }
168
169 ret = inflateReset(&s->zstream);
170 if (ret != Z_OK) {
171 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
172 return AVERROR_UNKNOWN;
173 }
174 s->zstream.next_in = buf;
175 s->zstream.avail_in = buf_size;
176 s->zstream.next_out = s->decomp_buf;
177 s->zstream.avail_out = s->decomp_size;
178 ret = inflate(&s->zstream, Z_FINISH);
179 if (ret != Z_STREAM_END) {
180 av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
181 return AVERROR_UNKNOWN;
182 }
183
184 bytestream2_init(&gb, s->decomp_buf, s->zstream.total_out);
185 bytestream2_init_writer(&pb, s->uncomp_buf, s->uncomp_size);
186
187 ret = rle_uncompress(avctx, &gb, &pb);
188 if (ret)
189 return ret;
190
191 for (j = 0; j < avctx->height; j++) {
192 memcpy(frame->data[0] + (avctx->height - j - 1) * frame->linesize[0],
193 s->uncomp_buf + s->bpp * j * avctx->width, s->bpp * avctx->width);
194 }
195
196 frame->key_frame = 1;
197 frame->pict_type = AV_PICTURE_TYPE_I;
198
199 *got_frame = 1;
200
201 return avpkt->size;
202 }
203
204 static av_cold int decode_init(AVCodecContext *avctx)
205 {
206 MSCCContext *s = avctx->priv_data;
207 int stride, zret;
208
209 switch (avctx->bits_per_coded_sample) {
210 case 8: avctx->pix_fmt = AV_PIX_FMT_PAL8; break;
211 case 16: avctx->pix_fmt = AV_PIX_FMT_RGB555; break;
212 case 24: avctx->pix_fmt = AV_PIX_FMT_BGR24; break;
213 case 32: avctx->pix_fmt = AV_PIX_FMT_BGRA; break;
214 default:
215 av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
216 return AVERROR_INVALIDDATA;
217 }
218
219 s->bpp = avctx->bits_per_coded_sample >> 3;
220 stride = 4 * ((avctx->width * avctx->bits_per_coded_sample + 31) / 32);
221
222 s->decomp_size = 2 * avctx->height * stride;
223 if (!(s->decomp_buf = av_malloc(s->decomp_size)))
224 return AVERROR(ENOMEM);
225
226 s->uncomp_size = avctx->height * stride;
227 if (!(s->uncomp_buf = av_malloc(s->uncomp_size)))
228 return AVERROR(ENOMEM);
229
230 s->zstream.zalloc = Z_NULL;
231 s->zstream.zfree = Z_NULL;
232 s->zstream.opaque = Z_NULL;
233 zret = inflateInit(&s->zstream);
234 if (zret != Z_OK) {
235 av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
236 return AVERROR_UNKNOWN;
237 }
238
239 return 0;
240 }
241
242 static av_cold int decode_close(AVCodecContext *avctx)
243 {
244 MSCCContext *s = avctx->priv_data;
245
246 av_freep(&s->decomp_buf);
247 s->decomp_size = 0;
248 av_freep(&s->uncomp_buf);
249 s->uncomp_size = 0;
250 inflateEnd(&s->zstream);
251
252 return 0;
253 }
254
255 const AVCodec ff_mscc_decoder = {
256 .name = "mscc",
257 .long_name = NULL_IF_CONFIG_SMALL("Mandsoft Screen Capture Codec"),
258 .type = AVMEDIA_TYPE_VIDEO,
259 .id = AV_CODEC_ID_MSCC,
260 .priv_data_size = sizeof(MSCCContext),
261 .init = decode_init,
262 .close = decode_close,
263 .decode = decode_frame,
264 .capabilities = AV_CODEC_CAP_DR1,
265 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
266 };
267
268 const AVCodec ff_srgc_decoder = {
269 .name = "srgc",
270 .long_name = NULL_IF_CONFIG_SMALL("Screen Recorder Gold Codec"),
271 .type = AVMEDIA_TYPE_VIDEO,
272 .id = AV_CODEC_ID_SRGC,
273 .priv_data_size = sizeof(MSCCContext),
274 .init = decode_init,
275 .close = decode_close,
276 .decode = decode_frame,
277 .capabilities = AV_CODEC_CAP_DR1,
278 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
279 };
280