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

   1 /*
   2  * Copyright (c) 2019 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdint.h>
  22 #include <zlib.h>
  23
  24 #include "libavutil/frame.h"
  25 #include "libavutil/error.h"
  26 #include "libavutil/log.h"
  27
  28 #include "avcodec.h"
  29 #include "bytestream.h"
  30 #include "codec.h"
  31 #include "internal.h"
  32 #include "packet.h"
  33 #include "png.h"
  34 #include "pngdsp.h"
  35
  36 typedef struct LSCRContext {
  37     PNGDSPContext   dsp;
  38     AVCodecContext *avctx;
  39
  40     AVFrame        *last_picture;
  41     uint8_t        *buffer;
  42     int             buffer_size;
  43     uint8_t        *crow_buf;
  44     int             crow_size;
  45     uint8_t        *last_row;
  46     unsigned int    last_row_size;
  47
  48     GetByteContext  gb;
  49     uint8_t        *image_buf;
  50     int             image_linesize;
  51     int             row_size;
  52     int             cur_h;
  53     int             y;
  54
  55     z_stream        zstream;
  56 } LSCRContext;
  57
  58 static void handle_row(LSCRContext *s)
  59 {
  60     uint8_t *ptr, *last_row;
  61
  62     ptr = s->image_buf + s->image_linesize * s->y;
  63     if (s->y == 0)
  64         last_row = s->last_row;
  65     else
  66         last_row = ptr - s->image_linesize;
  67
  68     ff_png_filter_row(&s->dsp, ptr, s->crow_buf[0], s->crow_buf + 1,
  69                       last_row, s->row_size, 3);
  70
  71     s->y++;
  72 }
  73
  74 static int decode_idat(LSCRContext *s, int length)
  75 {
  76     int ret;
  77     s->zstream.avail_in = FFMIN(length, bytestream2_get_bytes_left(&s->gb));
  78     s->zstream.next_in  = s->gb.buffer;
  79
  80     if (length <= 0)
  81         return AVERROR_INVALIDDATA;
  82
  83     bytestream2_skip(&s->gb, length);
  84
  85     /* decode one line if possible */
  86     while (s->zstream.avail_in > 0) {
  87         ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
  88         if (ret != Z_OK && ret != Z_STREAM_END) {
  89             av_log(s->avctx, AV_LOG_ERROR, "inflate returned error %d\n", ret);
  90             return AVERROR_EXTERNAL;
  91         }
  92         if (s->zstream.avail_out == 0) {
  93             if (s->y < s->cur_h) {
  94                 handle_row(s);
  95             }
  96             s->zstream.avail_out = s->crow_size;
  97             s->zstream.next_out  = s->crow_buf;
  98         }
  99         if (ret == Z_STREAM_END && s->zstream.avail_in > 0) {
 100             av_log(s->avctx, AV_LOG_WARNING,
 101                    "%d undecompressed bytes left in buffer\n", s->zstream.avail_in);
 102             return 0;
 103         }
 104     }
 105     return 0;
 106 }
 107
 108 static int decode_frame_lscr(AVCodecContext *avctx,
 109                              void *data, int *got_frame,
 110                              AVPacket *avpkt)
 111 {
 112     LSCRContext *const s = avctx->priv_data;
 113     GetByteContext *gb = &s->gb;
 114     AVFrame *frame = s->last_picture;
 115     int ret, nb_blocks, offset = 0;
 116
 117     if (avpkt->size < 2)
 118         return AVERROR_INVALIDDATA;
 119     if (avpkt->size == 2)
 120         return 0;
 121
 122     bytestream2_init(gb, avpkt->data, avpkt->size);
 123
 124     nb_blocks = bytestream2_get_le16(gb);
 125     if (bytestream2_get_bytes_left(gb) < 2 + nb_blocks * (12 + 8))
 126         return AVERROR_INVALIDDATA;
 127
 128     ret = ff_reget_buffer(avctx, frame,
 129                           nb_blocks ? 0 : FF_REGET_BUFFER_FLAG_READONLY);
 130     if (ret < 0)
 131         return ret;
 132
 133     for (int b = 0; b < nb_blocks; b++) {
 134         int x, y, x2, y2, w, h, left;
 135         uint32_t csize, size;
 136
 137         s->zstream.zalloc = ff_png_zalloc;
 138         s->zstream.zfree  = ff_png_zfree;
 139         s->zstream.opaque = NULL;
 140
 141         if ((ret = inflateInit(&s->zstream)) != Z_OK) {
 142             av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
 143             ret = AVERROR_EXTERNAL;
 144             goto end;
 145         }
 146
 147         bytestream2_seek(gb, 2 + b * 12, SEEK_SET);
 148
 149         x = bytestream2_get_le16(gb);
 150         y = bytestream2_get_le16(gb);
 151         x2 = bytestream2_get_le16(gb);
 152         y2 = bytestream2_get_le16(gb);
 153         w = x2-x;
 154         s->cur_h = h = y2-y;
 155
 156         if (w <= 0 || x < 0 || x >= avctx->width || w + x > avctx->width ||
 157             h <= 0 || y < 0 || y >= avctx->height || h + y > avctx->height) {
 158             ret = AVERROR_INVALIDDATA;
 159             goto end;
 160         }
 161
 162         size = bytestream2_get_le32(gb);
 163
 164         frame->key_frame = (nb_blocks == 1) &&
 165                            (w == avctx->width) &&
 166                            (h == avctx->height) &&
 167                            (x == 0) && (y == 0);
 168
 169         bytestream2_seek(gb, 2 + nb_blocks * 12 + offset, SEEK_SET);
 170         csize = bytestream2_get_be32(gb);
 171         if (bytestream2_get_le32(gb) != MKTAG('I', 'D', 'A', 'T')) {
 172             ret = AVERROR_INVALIDDATA;
 173             goto end;
 174         }
 175
 176         offset += size;
 177         left = size;
 178
 179         s->y                 = 0;
 180         s->row_size          = w * 3;
 181
 182         av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
 183         if (!s->buffer) {
 184             ret = AVERROR(ENOMEM);
 185             goto end;
 186         }
 187
 188         av_fast_padded_malloc(&s->last_row, &s->last_row_size, s->row_size);
 189         if (!s->last_row) {
 190             ret = AVERROR(ENOMEM);
 191             goto end;
 192         }
 193
 194         s->crow_size         = w * 3 + 1;
 195         s->crow_buf          = s->buffer + 15;
 196         s->zstream.avail_out = s->crow_size;
 197         s->zstream.next_out  = s->crow_buf;
 198         s->image_buf         = frame->data[0] + (avctx->height - y - 1) * frame->linesize[0] + x * 3;
 199         s->image_linesize    =-frame->linesize[0];
 200
 201         while (left > 16) {
 202             ret = decode_idat(s, csize);
 203             if (ret < 0)
 204                 goto end;
 205             left -= csize + 16;
 206             if (left > 16) {
 207                 bytestream2_skip(gb, 4);
 208                 csize = bytestream2_get_be32(gb);
 209                 if (bytestream2_get_le32(gb) != MKTAG('I', 'D', 'A', 'T')) {
 210                     ret = AVERROR_INVALIDDATA;
 211                     goto end;
 212                 }
 213             }
 214         }
 215
 216         inflateEnd(&s->zstream);
 217     }
 218
 219     frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 220
 221     if ((ret = av_frame_ref(data, frame)) < 0)
 222         return ret;
 223
 224     *got_frame = 1;
 225 end:
 226     inflateEnd(&s->zstream);
 227
 228     if (ret < 0)
 229         return ret;
 230     return avpkt->size;
 231 }
 232
 233 static int lscr_decode_close(AVCodecContext *avctx)
 234 {
 235     LSCRContext *s = avctx->priv_data;
 236
 237     av_frame_free(&s->last_picture);
 238     av_freep(&s->buffer);
 239     av_freep(&s->last_row);
 240
 241     return 0;
 242 }
 243
 244 static int lscr_decode_init(AVCodecContext *avctx)
 245 {
 246     LSCRContext *s = avctx->priv_data;
 247
 248     avctx->color_range = AVCOL_RANGE_JPEG;
 249     avctx->pix_fmt     = AV_PIX_FMT_BGR24;
 250
 251     s->avctx = avctx;
 252     s->last_picture = av_frame_alloc();
 253     if (!s->last_picture)
 254         return AVERROR(ENOMEM);
 255
 256     ff_pngdsp_init(&s->dsp);
 257
 258     return 0;
 259 }
 260
 261 static void lscr_decode_flush(AVCodecContext *avctx)
 262 {
 263     LSCRContext *s = avctx->priv_data;
 264     av_frame_unref(s->last_picture);
 265 }
 266
 267 const AVCodec ff_lscr_decoder = {
 268     .name           = "lscr",
 269     .long_name      = NULL_IF_CONFIG_SMALL("LEAD Screen Capture"),
 270     .type           = AVMEDIA_TYPE_VIDEO,
 271     .id             = AV_CODEC_ID_LSCR,
 272     .priv_data_size = sizeof(LSCRContext),
 273     .init           = lscr_decode_init,
 274     .close          = lscr_decode_close,
 275     .decode         = decode_frame_lscr,
 276     .flush          = lscr_decode_flush,
 277     .capabilities   = AV_CODEC_CAP_DR1,
 278     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 279 };