GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/lscrdec.c Lines: 102 131 77.9 %
Date: 2021-04-20 04:37:23 Branches: 50 80 62.5 %

Line Branch Exec Source
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
4241
static void handle_row(LSCRContext *s)
59
{
60
    uint8_t *ptr, *last_row;
61
62
4241
    ptr = s->image_buf + s->image_linesize * s->y;
63
4241
    if (s->y == 0)
64
124
        last_row = s->last_row;
65
    else
66
4117
        last_row = ptr - s->image_linesize;
67
68
4241
    ff_png_filter_row(&s->dsp, ptr, s->crow_buf[0], s->crow_buf + 1,
69
                      last_row, s->row_size, 3);
70
71
4241
    s->y++;
72
4241
}
73
74
250
static int decode_idat(LSCRContext *s, int length)
75
{
76
    int ret;
77
250
    s->zstream.avail_in = FFMIN(length, bytestream2_get_bytes_left(&s->gb));
78
250
    s->zstream.next_in  = s->gb.buffer;
79
80
250
    if (length <= 0)
81
        return AVERROR_INVALIDDATA;
82
83
250
    bytestream2_skip(&s->gb, length);
84
85
    /* decode one line if possible */
86
4616
    while (s->zstream.avail_in > 0) {
87
4366
        ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
88

4366
        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
4366
        if (s->zstream.avail_out == 0) {
93
4241
            if (s->y < s->cur_h) {
94
4241
                handle_row(s);
95
            }
96
4241
            s->zstream.avail_out = s->crow_size;
97
4241
            s->zstream.next_out  = s->crow_buf;
98
        }
99

4366
        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
250
    return 0;
106
}
107
108
16
static int decode_frame_lscr(AVCodecContext *avctx,
109
                             void *data, int *got_frame,
110
                             AVPacket *avpkt)
111
{
112
16
    LSCRContext *const s = avctx->priv_data;
113
16
    GetByteContext *gb = &s->gb;
114
16
    AVFrame *frame = s->last_picture;
115
16
    int ret, nb_blocks, offset = 0;
116
117
16
    if (avpkt->size < 2)
118
        return AVERROR_INVALIDDATA;
119
16
    if (avpkt->size == 2)
120
        return 0;
121
122
16
    bytestream2_init(gb, avpkt->data, avpkt->size);
123
124
16
    nb_blocks = bytestream2_get_le16(gb);
125
16
    if (bytestream2_get_bytes_left(gb) < 2 + nb_blocks * (12 + 8))
126
        return AVERROR_INVALIDDATA;
127
128
16
    ret = ff_reget_buffer(avctx, frame,
129
                          nb_blocks ? 0 : FF_REGET_BUFFER_FLAG_READONLY);
130
16
    if (ret < 0)
131
        return ret;
132
133
140
    for (int b = 0; b < nb_blocks; b++) {
134
        int x, y, x2, y2, w, h, left;
135
        uint32_t csize, size;
136
137
124
        s->zstream.zalloc = ff_png_zalloc;
138
124
        s->zstream.zfree  = ff_png_zfree;
139
124
        s->zstream.opaque = NULL;
140
141
124
        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
124
        bytestream2_seek(gb, 2 + b * 12, SEEK_SET);
148
149
124
        x = bytestream2_get_le16(gb);
150
124
        y = bytestream2_get_le16(gb);
151
124
        x2 = bytestream2_get_le16(gb);
152
124
        y2 = bytestream2_get_le16(gb);
153
124
        w = x2-x;
154
124
        s->cur_h = h = y2-y;
155
156


124
        if (w <= 0 || x < 0 || x >= avctx->width || w + x > avctx->width ||
157

124
            h <= 0 || y < 0 || y >= avctx->height || h + y > avctx->height) {
158
            ret = AVERROR_INVALIDDATA;
159
            goto end;
160
        }
161
162
124
        size = bytestream2_get_le32(gb);
163
164
125
        frame->key_frame = (nb_blocks == 1) &&
165
1
                           (w == avctx->width) &&
166

1
                           (h == avctx->height) &&
167

125
                           (x == 0) && (y == 0);
168
169
124
        bytestream2_seek(gb, 2 + nb_blocks * 12 + offset, SEEK_SET);
170
124
        csize = bytestream2_get_be32(gb);
171
124
        if (bytestream2_get_le32(gb) != MKTAG('I', 'D', 'A', 'T')) {
172
            ret = AVERROR_INVALIDDATA;
173
            goto end;
174
        }
175
176
124
        offset += size;
177
124
        left = size;
178
179
124
        s->y                 = 0;
180
124
        s->row_size          = w * 3;
181
182
124
        av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
183
124
        if (!s->buffer) {
184
            ret = AVERROR(ENOMEM);
185
            goto end;
186
        }
187
188
124
        av_fast_padded_malloc(&s->last_row, &s->last_row_size, s->row_size);
189
124
        if (!s->last_row) {
190
            ret = AVERROR(ENOMEM);
191
            goto end;
192
        }
193
194
124
        s->crow_size         = w * 3 + 1;
195
124
        s->crow_buf          = s->buffer + 15;
196
124
        s->zstream.avail_out = s->crow_size;
197
124
        s->zstream.next_out  = s->crow_buf;
198
124
        s->image_buf         = frame->data[0] + (avctx->height - y - 1) * frame->linesize[0] + x * 3;
199
124
        s->image_linesize    =-frame->linesize[0];
200
201
374
        while (left > 16) {
202
250
            ret = decode_idat(s, csize);
203
250
            if (ret < 0)
204
                goto end;
205
250
            left -= csize + 16;
206
250
            if (left > 16) {
207
126
                bytestream2_skip(gb, 4);
208
126
                csize = bytestream2_get_be32(gb);
209
126
                if (bytestream2_get_le32(gb) != MKTAG('I', 'D', 'A', 'T')) {
210
                    ret = AVERROR_INVALIDDATA;
211
                    goto end;
212
                }
213
            }
214
        }
215
216
124
        inflateEnd(&s->zstream);
217
    }
218
219
16
    frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
220
221
16
    if ((ret = av_frame_ref(data, frame)) < 0)
222
        return ret;
223
224
16
    *got_frame = 1;
225
16
end:
226
16
    inflateEnd(&s->zstream);
227
228
16
    if (ret < 0)
229
        return ret;
230
16
    return avpkt->size;
231
}
232
233
2
static int lscr_decode_close(AVCodecContext *avctx)
234
{
235
2
    LSCRContext *s = avctx->priv_data;
236
237
2
    av_frame_free(&s->last_picture);
238
2
    av_freep(&s->buffer);
239
2
    av_freep(&s->last_row);
240
241
2
    return 0;
242
}
243
244
2
static int lscr_decode_init(AVCodecContext *avctx)
245
{
246
2
    LSCRContext *s = avctx->priv_data;
247
248
2
    avctx->color_range = AVCOL_RANGE_JPEG;
249
2
    avctx->pix_fmt     = AV_PIX_FMT_BGR24;
250
251
2
    s->avctx = avctx;
252
2
    s->last_picture = av_frame_alloc();
253
2
    if (!s->last_picture)
254
        return AVERROR(ENOMEM);
255
256
2
    ff_pngdsp_init(&s->dsp);
257
258
2
    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
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
};