GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/rscc.c Lines: 122 180 67.8 %
Date: 2020-08-14 10:39:37 Branches: 52 87 59.8 %

Line Branch Exec Source
1
/*
2
 * innoHeim/Rsupport Screen Capture Codec
3
 * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * innoHeim/Rsupport Screen Capture Codec decoder
25
 *
26
 * Fourcc: ISCC, RSCC
27
 *
28
 * Lossless codec, data stored in tiles, with optional deflate compression.
29
 *
30
 * Header contains the number of tiles in a frame with the tile coordinates,
31
 * and it can be deflated or not. Similarly, pixel data comes after the header
32
 * and a variable size value, and it can be deflated or just raw.
33
 *
34
 * Supports: PAL8, BGRA, BGR24, RGB555
35
 */
36
37
#include <stdint.h>
38
#include <string.h>
39
#include <zlib.h>
40
41
#include "libavutil/imgutils.h"
42
#include "libavutil/internal.h"
43
44
#include "avcodec.h"
45
#include "bytestream.h"
46
#include "internal.h"
47
48
#define TILE_SIZE 8
49
50
typedef struct Tile {
51
    int x, y;
52
    int w, h;
53
} Tile;
54
55
typedef struct RsccContext {
56
    GetByteContext gbc;
57
    AVFrame *reference;
58
    Tile *tiles;
59
    unsigned int tiles_size;
60
    int component_size;
61
62
    uint8_t palette[AVPALETTE_SIZE];
63
64
    /* zlib interaction */
65
    uint8_t *inflated_buf;
66
    uLongf inflated_size;
67
    int valid_pixels;
68
} RsccContext;
69
70
10
static av_cold int rscc_init(AVCodecContext *avctx)
71
{
72
10
    RsccContext *ctx = avctx->priv_data;
73
74
    /* These needs to be set to estimate uncompressed buffer */
75
10
    int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
76
10
    if (ret < 0) {
77
        av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
78
               avctx->width, avctx->height);
79
        return ret;
80
    }
81
82
    /* Allocate reference frame */
83
10
    ctx->reference = av_frame_alloc();
84
10
    if (!ctx->reference)
85
        return AVERROR(ENOMEM);
86
87
    /* Get pixel format and the size of the pixel */
88
10
    if (avctx->codec_tag == MKTAG('I', 'S', 'C', 'C')) {
89

2
        if (avctx->extradata && avctx->extradata_size == 4) {
90
2
            if ((avctx->extradata[0] >> 1) & 1) {
91
2
                avctx->pix_fmt = AV_PIX_FMT_BGRA;
92
2
                ctx->component_size = 4;
93
            } else {
94
                avctx->pix_fmt = AV_PIX_FMT_BGR24;
95
                ctx->component_size = 3;
96
            }
97
        } else {
98
            avctx->pix_fmt = AV_PIX_FMT_BGRA;
99
            ctx->component_size = 4;
100
        }
101
8
    } else if (avctx->codec_tag == MKTAG('R', 'S', 'C', 'C')) {
102
8
        ctx->component_size = avctx->bits_per_coded_sample / 8;
103

8
        switch (avctx->bits_per_coded_sample) {
104
2
        case 8:
105
2
            avctx->pix_fmt = AV_PIX_FMT_PAL8;
106
2
            break;
107
2
        case 16:
108
2
            avctx->pix_fmt = AV_PIX_FMT_RGB555LE;
109
2
            break;
110
2
        case 24:
111
2
            avctx->pix_fmt = AV_PIX_FMT_BGR24;
112
2
            break;
113
2
        case 32:
114
2
            avctx->pix_fmt = AV_PIX_FMT_BGR0;
115
2
            break;
116
        default:
117
            av_log(avctx, AV_LOG_ERROR, "Invalid bits per pixel value (%d)\n",
118
                   avctx->bits_per_coded_sample);
119
            return AVERROR_INVALIDDATA;
120
        }
121
    } else {
122
        avctx->pix_fmt = AV_PIX_FMT_BGR0;
123
        ctx->component_size = 4;
124
        av_log(avctx, AV_LOG_WARNING, "Invalid codec tag\n");
125
    }
126
127
    /* Store the value to check for keyframes */
128
10
    ctx->inflated_size = avctx->width * avctx->height * ctx->component_size;
129
130
    /* Allocate maximum size possible, a full frame */
131
10
    ctx->inflated_buf = av_malloc(ctx->inflated_size);
132
10
    if (!ctx->inflated_buf)
133
        return AVERROR(ENOMEM);
134
135
10
    return 0;
136
}
137
138
10
static av_cold int rscc_close(AVCodecContext *avctx)
139
{
140
10
    RsccContext *ctx = avctx->priv_data;
141
142
10
    av_freep(&ctx->tiles);
143
10
    av_freep(&ctx->inflated_buf);
144
10
    av_frame_free(&ctx->reference);
145
146
10
    return 0;
147
}
148
149
32
static int rscc_decode_frame(AVCodecContext *avctx, void *data,
150
                                     int *got_frame, AVPacket *avpkt)
151
{
152
32
    RsccContext *ctx = avctx->priv_data;
153
32
    GetByteContext *gbc = &ctx->gbc;
154
    GetByteContext tiles_gbc;
155
32
    AVFrame *frame = data;
156
    const uint8_t *pixels, *raw;
157
32
    uint8_t *inflated_tiles = NULL;
158
32
    int tiles_nb, packed_size, pixel_size = 0;
159
32
    int i, ret = 0;
160
161
32
    bytestream2_init(gbc, avpkt->data, avpkt->size);
162
163
    /* Size check */
164
32
    if (bytestream2_get_bytes_left(gbc) < 12) {
165
        av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);
166
        return AVERROR_INVALIDDATA;
167
    }
168
169
    /* Read number of tiles, and allocate the array */
170
32
    tiles_nb = bytestream2_get_le16(gbc);
171
172
32
    if (tiles_nb == 0) {
173
        av_log(avctx, AV_LOG_DEBUG, "no tiles\n");
174
        return avpkt->size;
175
    }
176
177
32
    av_fast_malloc(&ctx->tiles, &ctx->tiles_size,
178
                   tiles_nb * sizeof(*ctx->tiles));
179
32
    if (!ctx->tiles) {
180
        ret = AVERROR(ENOMEM);
181
        goto end;
182
    }
183
184
32
    av_log(avctx, AV_LOG_DEBUG, "Frame with %d tiles.\n", tiles_nb);
185
186
    /* When there are more than 5 tiles, they are packed together with
187
     * a size header. When that size does not match the number of tiles
188
     * times the tile size, it means it needs to be inflated as well */
189
32
    if (tiles_nb > 5) {
190
        uLongf packed_tiles_size;
191
192
24
        if (tiles_nb < 32)
193
17
            packed_tiles_size = bytestream2_get_byte(gbc);
194
        else
195
7
            packed_tiles_size = bytestream2_get_le16(gbc);
196
197
        ff_dlog(avctx, "packed tiles of size %lu.\n", packed_tiles_size);
198
199
        /* If necessary, uncompress tiles, and hijack the bytestream reader */
200
24
        if (packed_tiles_size != tiles_nb * TILE_SIZE) {
201
24
            uLongf length = tiles_nb * TILE_SIZE;
202
203
24
            if (bytestream2_get_bytes_left(gbc) < packed_tiles_size) {
204
                ret = AVERROR_INVALIDDATA;
205
                goto end;
206
            }
207
208
24
            inflated_tiles = av_malloc(length);
209
24
            if (!inflated_tiles) {
210
                ret = AVERROR(ENOMEM);
211
                goto end;
212
            }
213
214
24
            ret = uncompress(inflated_tiles, &length,
215
24
                             gbc->buffer, packed_tiles_size);
216
24
            if (ret) {
217
                av_log(avctx, AV_LOG_ERROR, "Tile deflate error %d.\n", ret);
218
                ret = AVERROR_UNKNOWN;
219
                goto end;
220
            }
221
222
            /* Skip the compressed tile section in the main byte reader,
223
             * and point it to read the newly uncompressed data */
224
24
            bytestream2_skip(gbc, packed_tiles_size);
225
24
            bytestream2_init(&tiles_gbc, inflated_tiles, length);
226
24
            gbc = &tiles_gbc;
227
        }
228
    }
229
230
    /* Fill in array of tiles, keeping track of how many pixels are updated */
231
712
    for (i = 0; i < tiles_nb; i++) {
232
680
        ctx->tiles[i].x = bytestream2_get_le16(gbc);
233
680
        ctx->tiles[i].w = bytestream2_get_le16(gbc);
234
680
        ctx->tiles[i].y = bytestream2_get_le16(gbc);
235
680
        ctx->tiles[i].h = bytestream2_get_le16(gbc);
236
237
680
        if (pixel_size + ctx->tiles[i].w * (int64_t)ctx->tiles[i].h * ctx->component_size > INT_MAX) {
238
            av_log(avctx, AV_LOG_ERROR, "Invalid tile dimensions\n");
239
            ret = AVERROR_INVALIDDATA;
240
            goto end;
241
        }
242
243
680
        pixel_size += ctx->tiles[i].w * ctx->tiles[i].h * ctx->component_size;
244
245
        ff_dlog(avctx, "tile %d orig(%d,%d) %dx%d.\n", i,
246
                ctx->tiles[i].x, ctx->tiles[i].y,
247
                ctx->tiles[i].w, ctx->tiles[i].h);
248
249

680
        if (ctx->tiles[i].w == 0 || ctx->tiles[i].h == 0) {
250
            av_log(avctx, AV_LOG_ERROR,
251
                   "invalid tile %d at (%d.%d) with size %dx%d.\n", i,
252
                   ctx->tiles[i].x, ctx->tiles[i].y,
253
                   ctx->tiles[i].w, ctx->tiles[i].h);
254
            ret = AVERROR_INVALIDDATA;
255
            goto end;
256
680
        } else if (ctx->tiles[i].x + ctx->tiles[i].w > avctx->width ||
257
680
                   ctx->tiles[i].y + ctx->tiles[i].h > avctx->height) {
258
            av_log(avctx, AV_LOG_ERROR,
259
                   "out of bounds tile %d at (%d.%d) with size %dx%d.\n", i,
260
                   ctx->tiles[i].x, ctx->tiles[i].y,
261
                   ctx->tiles[i].w, ctx->tiles[i].h);
262
            ret = AVERROR_INVALIDDATA;
263
            goto end;
264
        }
265
    }
266
267
    /* Reset the reader in case it had been modified before */
268
32
    gbc = &ctx->gbc;
269
270
    /* Extract how much pixel data the tiles contain */
271
32
    if (pixel_size < 0x100)
272
        packed_size = bytestream2_get_byte(gbc);
273
32
    else if (pixel_size < 0x10000)
274
        packed_size = bytestream2_get_le16(gbc);
275
32
    else if (pixel_size < 0x1000000)
276
32
        packed_size = bytestream2_get_le24(gbc);
277
    else
278
        packed_size = bytestream2_get_le32(gbc);
279
280
    ff_dlog(avctx, "pixel_size %d packed_size %d.\n", pixel_size, packed_size);
281
282
32
    if (packed_size < 0) {
283
        av_log(avctx, AV_LOG_ERROR, "Invalid tile size %d\n", packed_size);
284
        ret = AVERROR_INVALIDDATA;
285
        goto end;
286
    }
287
288
    /* Get pixels buffer, it may be deflated or just raw */
289
32
    if (pixel_size == packed_size) {
290
        if (bytestream2_get_bytes_left(gbc) < pixel_size) {
291
            av_log(avctx, AV_LOG_ERROR, "Insufficient input for %d\n", pixel_size);
292
            ret = AVERROR_INVALIDDATA;
293
            goto end;
294
        }
295
        pixels = gbc->buffer;
296
    } else {
297
32
        uLongf len = ctx->inflated_size;
298
32
        if (bytestream2_get_bytes_left(gbc) < packed_size) {
299
2
            av_log(avctx, AV_LOG_ERROR, "Insufficient input for %d\n", packed_size);
300
2
            ret = AVERROR_INVALIDDATA;
301
2
            goto end;
302
        }
303
30
        ret = uncompress(ctx->inflated_buf, &len, gbc->buffer, packed_size);
304
30
        if (ret) {
305
            av_log(avctx, AV_LOG_ERROR, "Pixel deflate error %d.\n", ret);
306
            ret = AVERROR_UNKNOWN;
307
            goto end;
308
        }
309
30
        pixels = ctx->inflated_buf;
310
    }
311
312
    /* Allocate when needed */
313
30
    ret = ff_reget_buffer(avctx, ctx->reference, 0);
314
30
    if (ret < 0)
315
        goto end;
316
317
    /* Pointer to actual pixels, will be updated when data is consumed */
318
30
    raw = pixels;
319
694
    for (i = 0; i < tiles_nb; i++) {
320
664
        uint8_t *dst = ctx->reference->data[0] + ctx->reference->linesize[0] *
321
664
                       (avctx->height - ctx->tiles[i].y - 1) +
322
664
                       ctx->tiles[i].x * ctx->component_size;
323
664
        av_image_copy_plane(dst, -1 * ctx->reference->linesize[0],
324
664
                            raw, ctx->tiles[i].w * ctx->component_size,
325
664
                            ctx->tiles[i].w * ctx->component_size,
326
664
                            ctx->tiles[i].h);
327
664
        raw += ctx->tiles[i].w * ctx->component_size * ctx->tiles[i].h;
328
    }
329
330
    /* Frame is ready to be output */
331
30
    ret = av_frame_ref(frame, ctx->reference);
332
30
    if (ret < 0)
333
        goto end;
334
335
    /* Keyframe when the number of pixels updated matches the whole surface */
336
30
    if (pixel_size == ctx->inflated_size) {
337
5
        frame->pict_type = AV_PICTURE_TYPE_I;
338
5
        frame->key_frame = 1;
339
    } else {
340
25
        frame->pict_type = AV_PICTURE_TYPE_P;
341
    }
342
343
    /* Palette handling */
344
30
    if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
345
        int size;
346
1
        const uint8_t *palette = av_packet_get_side_data(avpkt,
347
                                                         AV_PKT_DATA_PALETTE,
348
                                                         &size);
349

1
        if (palette && size == AVPALETTE_SIZE) {
350
1
            frame->palette_has_changed = 1;
351
1
            memcpy(ctx->palette, palette, AVPALETTE_SIZE);
352
        } else if (palette) {
353
            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
354
        }
355
1
        memcpy (frame->data[1], ctx->palette, AVPALETTE_SIZE);
356
    }
357
    // We only return a picture when enough of it is undamaged, this avoids copying nearly broken frames around
358
30
    if (ctx->valid_pixels < ctx->inflated_size)
359
5
        ctx->valid_pixels += pixel_size;
360
30
    if (ctx->valid_pixels >= ctx->inflated_size * (100 - avctx->discard_damaged_percentage) / 100)
361
30
        *got_frame = 1;
362
363
30
    ret = avpkt->size;
364
32
end:
365
32
    av_free(inflated_tiles);
366
32
    return ret;
367
}
368
369
AVCodec ff_rscc_decoder = {
370
    .name           = "rscc",
371
    .long_name      = NULL_IF_CONFIG_SMALL("innoHeim/Rsupport Screen Capture Codec"),
372
    .type           = AVMEDIA_TYPE_VIDEO,
373
    .id             = AV_CODEC_ID_RSCC,
374
    .init           = rscc_init,
375
    .decode         = rscc_decode_frame,
376
    .close          = rscc_close,
377
    .priv_data_size = sizeof(RsccContext),
378
    .capabilities   = AV_CODEC_CAP_DR1,
379
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
380
                      FF_CODEC_CAP_INIT_CLEANUP,
381
};