2 * Mandsoft Screen Capture Codec decoder
4 * Copyright (c) 2017 Paul B Mahol
6 * This file is part of FFmpeg.
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.
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.
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
28 #include "bytestream.h"
33 typedef struct MSCCContext {
35 unsigned int decomp_size;
37 unsigned int uncomp_size;
44 static int rle_uncompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb)
46 MSCCContext *s = avctx->priv_data;
47 unsigned x = 0, y = 0;
49 while (bytestream2_get_bytes_left(gb) > 0) {
52 unsigned run = bytestream2_get_byte(gb);
55 switch (avctx->bits_per_coded_sample) {
57 fill = bytestream2_get_byte(gb);
60 fill = bytestream2_get_le16(gb);
63 fill = bytestream2_get_le24(gb);
66 fill = bytestream2_get_le32(gb);
70 for (j = 0; j < run; j++) {
71 switch (avctx->bits_per_coded_sample) {
73 bytestream2_put_byte(pb, fill);
76 bytestream2_put_le16(pb, fill);
79 bytestream2_put_le24(pb, fill);
82 bytestream2_put_le32(pb, fill);
88 unsigned copy = bytestream2_get_byte(gb);
93 bytestream2_seek_p(pb, y * avctx->width * s->bpp, SEEK_SET);
94 } else if (copy == 1) {
96 } else if (copy == 2) {
98 x += bytestream2_get_byte(gb);
99 y += bytestream2_get_byte(gb);
101 bytestream2_seek_p(pb, y * avctx->width * s->bpp + x * s->bpp, SEEK_SET);
103 for (j = 0; j < copy; j++) {
104 switch (avctx->bits_per_coded_sample) {
106 bytestream2_put_byte(pb, bytestream2_get_byte(gb));
109 bytestream2_put_le16(pb, bytestream2_get_le16(gb));
112 bytestream2_put_le24(pb, bytestream2_get_le24(gb));
115 bytestream2_put_le32(pb, bytestream2_get_le32(gb));
120 if (s->bpp == 1 && (copy & 1))
121 bytestream2_skip(gb, 1);
127 return AVERROR_INVALIDDATA;
130 static int decode_frame(AVCodecContext *avctx,
131 void *data, int *got_frame,
134 MSCCContext *s = avctx->priv_data;
135 AVFrame *frame = data;
136 uint8_t *buf = avpkt->data;
137 int buf_size = avpkt->size;
145 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
148 if (avctx->codec_id == AV_CODEC_ID_MSCC) {
149 avpkt->data[2] ^= avpkt->data[0];
154 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
156 const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
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);
163 av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
165 memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
168 ret = inflateReset(&s->zstream);
170 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
171 return AVERROR_UNKNOWN;
173 s->zstream.next_in = buf;
174 s->zstream.avail_in = buf_size;
175 s->zstream.next_out = s->decomp_buf;
176 s->zstream.avail_out = s->decomp_size;
177 ret = inflate(&s->zstream, Z_FINISH);
178 if (ret != Z_STREAM_END) {
179 av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
180 return AVERROR_UNKNOWN;
183 bytestream2_init(&gb, s->decomp_buf, s->zstream.total_out);
184 bytestream2_init_writer(&pb, s->uncomp_buf, s->uncomp_size);
186 ret = rle_uncompress(avctx, &gb, &pb);
190 for (j = 0; j < avctx->height; j++) {
191 memcpy(frame->data[0] + (avctx->height - j - 1) * frame->linesize[0],
192 s->uncomp_buf + s->bpp * j * avctx->width, s->bpp * avctx->width);
195 frame->key_frame = 1;
196 frame->pict_type = AV_PICTURE_TYPE_I;
203 static av_cold int decode_init(AVCodecContext *avctx)
205 MSCCContext *s = avctx->priv_data;
208 switch (avctx->bits_per_coded_sample) {
209 case 8: avctx->pix_fmt = AV_PIX_FMT_PAL8; break;
210 case 16: avctx->pix_fmt = AV_PIX_FMT_RGB555; break;
211 case 24: avctx->pix_fmt = AV_PIX_FMT_BGR24; break;
212 case 32: avctx->pix_fmt = AV_PIX_FMT_BGRA; break;
214 av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
215 return AVERROR_INVALIDDATA;
218 s->bpp = avctx->bits_per_coded_sample >> 3;
219 stride = 4 * ((avctx->width * avctx->bits_per_coded_sample + 31) / 32);
221 s->decomp_size = 2 * avctx->height * stride;
222 if (!(s->decomp_buf = av_malloc(s->decomp_size)))
223 return AVERROR(ENOMEM);
225 s->uncomp_size = avctx->height * stride;
226 if (!(s->uncomp_buf = av_malloc(s->uncomp_size)))
227 return AVERROR(ENOMEM);
229 s->zstream.zalloc = Z_NULL;
230 s->zstream.zfree = Z_NULL;
231 s->zstream.opaque = Z_NULL;
232 zret = inflateInit(&s->zstream);
234 av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
235 return AVERROR_UNKNOWN;
241 static av_cold int decode_close(AVCodecContext *avctx)
243 MSCCContext *s = avctx->priv_data;
245 av_freep(&s->decomp_buf);
247 av_freep(&s->uncomp_buf);
249 inflateEnd(&s->zstream);
254 AVCodec ff_mscc_decoder = {
256 .long_name = NULL_IF_CONFIG_SMALL("Mandsoft Screen Capture Codec"),
257 .type = AVMEDIA_TYPE_VIDEO,
258 .id = AV_CODEC_ID_MSCC,
259 .priv_data_size = sizeof(MSCCContext),
261 .close = decode_close,
262 .decode = decode_frame,
263 .capabilities = AV_CODEC_CAP_DR1,
264 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
267 AVCodec ff_srgc_decoder = {
269 .long_name = NULL_IF_CONFIG_SMALL("Screen Recorder Gold Codec"),
270 .type = AVMEDIA_TYPE_VIDEO,
271 .id = AV_CODEC_ID_SRGC,
272 .priv_data_size = sizeof(MSCCContext),
274 .close = decode_close,
275 .decode = decode_frame,
276 .capabilities = AV_CODEC_CAP_DR1,
277 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,