git.sesse.net Git - ffmpeg/blob - libavcodec/mscc.c

   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_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_CLEANUP,
 279 };