GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/cinepak.c Lines: 223 254 87.8 %
Date: 2021-04-20 15:25:36 Branches: 114 160 71.2 %

Line Branch Exec Source
1
/*
2
 * Cinepak Video Decoder
3
 * Copyright (C) 2003 The FFmpeg project
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
 * Cinepak video decoder
25
 * @author Ewald Snel <ewald@rambo.its.tudelft.nl>
26
 *
27
 * @see For more information on the Cinepak algorithm, visit:
28
 *   http://www.csse.monash.edu.au/~timf/
29
 * @see For more information on the quirky data inside Sega FILM/CPK files, visit:
30
 *   http://wiki.multimedia.cx/index.php?title=Sega_FILM
31
 *
32
 * Cinepak colorspace support (c) 2013 Rl, Aetey Global Technologies AB
33
 * @author Cinepak colorspace, Rl, Aetey Global Technologies AB
34
 */
35
36
#include <stdio.h>
37
#include <stdlib.h>
38
#include <string.h>
39
40
#include "libavutil/common.h"
41
#include "libavutil/intreadwrite.h"
42
#include "avcodec.h"
43
#include "decode.h"
44
#include "internal.h"
45
46
47
typedef uint8_t cvid_codebook[12];
48
49
#define MAX_STRIPS      32
50
51
typedef struct cvid_strip {
52
    uint16_t          id;
53
    uint16_t          x1, y1;
54
    uint16_t          x2, y2;
55
    cvid_codebook     v4_codebook[256];
56
    cvid_codebook     v1_codebook[256];
57
} cvid_strip;
58
59
typedef struct CinepakContext {
60
61
    AVCodecContext *avctx;
62
    AVFrame *frame;
63
64
    const unsigned char *data;
65
    int size;
66
67
    int width, height;
68
69
    int palette_video;
70
    cvid_strip strips[MAX_STRIPS];
71
72
    int sega_film_skip_bytes;
73
74
    uint32_t pal[256];
75
} CinepakContext;
76
77
2070
static void cinepak_decode_codebook (cvid_codebook *codebook,
78
                                     int chunk_id, int size, const uint8_t *data)
79
{
80
2070
    const uint8_t *eod = (data + size);
81
    uint32_t flag, mask;
82
    int      i, n;
83
    uint8_t *p;
84
85
    /* check if this chunk contains 4- or 6-element vectors */
86
2070
    n    = (chunk_id & 0x04) ? 4 : 6;
87
2070
    flag = 0;
88
2070
    mask = 0;
89
90
2070
    p = codebook[0];
91
376233
    for (i=0; i < 256; i++) {
92

374868
        if ((chunk_id & 0x01) && !(mask >>= 1)) {
93
6919
            if ((data + 4) > eod)
94
127
                break;
95
96
6792
            flag  = AV_RB32 (data);
97
6792
            data += 4;
98
6792
            mask  = 0x80000000;
99
        }
100
101

608550
        if (!(chunk_id & 0x01) || (flag & mask)) {
102
            int k, kk;
103
104
234387
            if ((data + n) > eod)
105
578
                break;
106
107
1169045
            for (k = 0; k < 4; ++k) {
108
935236
                int r = *data++;
109
3740944
                for (kk = 0; kk < 3; ++kk)
110
2805708
                    *p++ = r;
111
            }
112
233809
            if (n == 6) {
113
                int r, g, b, u, v;
114
211154
                u = *(int8_t *)data++;
115
211154
                v = *(int8_t *)data++;
116
211154
                p -= 12;
117
1055770
                for(k=0; k<4; ++k) {
118
844616
                    r = *p++ + v*2;
119
844616
                    g = *p++ - (u/2) - v;
120
844616
                    b = *p   + u*2;
121
844616
                    p -= 2;
122
844616
                    *p++ = av_clip_uint8(r);
123
844616
                    *p++ = av_clip_uint8(g);
124
844616
                    *p++ = av_clip_uint8(b);
125
                }
126
            }
127
        } else {
128
140354
            p += 12;
129
        }
130
    }
131
2070
}
132
133
1035
static int cinepak_decode_vectors (CinepakContext *s, cvid_strip *strip,
134
                                   int chunk_id, int size, const uint8_t *data)
135
{
136
1035
    const uint8_t   *eod = (data + size);
137
    uint32_t         flag, mask;
138
    uint8_t         *cb0, *cb1, *cb2, *cb3;
139
    int             x, y;
140
    char            *ip0, *ip1, *ip2, *ip3;
141
142
1035
    flag = 0;
143
1035
    mask = 0;
144
145
19017
    for (y=strip->y1; y < strip->y2; y+=4) {
146
147
/* take care of y dimension not being multiple of 4, such streams exist */
148
35968
        ip0 = ip1 = ip2 = ip3 = s->frame->data[0] +
149
17984
          (s->palette_video?strip->x1:strip->x1*3) + (y * s->frame->linesize[0]);
150
17984
        if(s->avctx->height - y > 1) {
151
17984
            ip1 = ip0 + s->frame->linesize[0];
152
17984
            if(s->avctx->height - y > 2) {
153
17984
                ip2 = ip1 + s->frame->linesize[0];
154
17984
                if(s->avctx->height - y > 3) {
155
17754
                    ip3 = ip2 + s->frame->linesize[0];
156
                }
157
            }
158
        }
159
/* to get the correct picture for not-multiple-of-4 cases let us fill each
160
 * block from the bottom up, thus possibly overwriting the bottommost line
161
 * more than once but ending with the correct data in place
162
 * (instead of in-loop checking) */
163
164
1132191
        for (x=strip->x1; x < strip->x2; x+=4) {
165

1114209
            if ((chunk_id & 0x01) && !(mask >>= 1)) {
166
27974
                if ((data + 4) > eod)
167
                    return AVERROR_INVALIDDATA;
168
169
27974
                flag  = AV_RB32 (data);
170
27974
                data += 4;
171
27974
                mask  = 0x80000000;
172
            }
173
174

1114209
            if (!(chunk_id & 0x01) || (flag & mask)) {
175

785585
                if (!(chunk_id & 0x02) && !(mask >>= 1)) {
176
23469
                    if ((data + 4) > eod)
177
                        return AVERROR_INVALIDDATA;
178
179
23469
                    flag  = AV_RB32 (data);
180
23469
                    data += 4;
181
23469
                    mask  = 0x80000000;
182
                }
183
184

1041043
                if ((chunk_id & 0x02) || (~flag & mask)) {
185
                    uint8_t *p;
186
255458
                    if (data >= eod)
187
                        return AVERROR_INVALIDDATA;
188
189
255458
                    p = strip->v1_codebook[*data++];
190
255458
                    if (s->palette_video) {
191
                        ip3[0] = ip3[1] = ip2[0] = ip2[1] = p[6];
192
                        ip3[2] = ip3[3] = ip2[2] = ip2[3] = p[9];
193
                        ip1[0] = ip1[1] = ip0[0] = ip0[1] = p[0];
194
                        ip1[2] = ip1[3] = ip0[2] = ip0[3] = p[3];
195
                    } else {
196
255458
                        p += 6;
197
255458
                        memcpy(ip3 + 0, p, 3); memcpy(ip3 + 3, p, 3);
198
255458
                        memcpy(ip2 + 0, p, 3); memcpy(ip2 + 3, p, 3);
199
255458
                        p += 3; /* ... + 9 */
200
255458
                        memcpy(ip3 + 6, p, 3); memcpy(ip3 + 9, p, 3);
201
255458
                        memcpy(ip2 + 6, p, 3); memcpy(ip2 + 9, p, 3);
202
255458
                        p -= 9; /* ... + 0 */
203
255458
                        memcpy(ip1 + 0, p, 3); memcpy(ip1 + 3, p, 3);
204
255458
                        memcpy(ip0 + 0, p, 3); memcpy(ip0 + 3, p, 3);
205
255458
                        p += 3; /* ... + 3 */
206
255458
                        memcpy(ip1 + 6, p, 3); memcpy(ip1 + 9, p, 3);
207
255458
                        memcpy(ip0 + 6, p, 3); memcpy(ip0 + 9, p, 3);
208
                    }
209
210
530127
                } else if (flag & mask) {
211
530127
                    if ((data + 4) > eod)
212
2
                        return AVERROR_INVALIDDATA;
213
214
530125
                    cb0 = strip->v4_codebook[*data++];
215
530125
                    cb1 = strip->v4_codebook[*data++];
216
530125
                    cb2 = strip->v4_codebook[*data++];
217
530125
                    cb3 = strip->v4_codebook[*data++];
218
530125
                    if (s->palette_video) {
219
                        uint8_t *p;
220
66297
                        p = ip3;
221
66297
                        *p++ = cb2[6];
222
66297
                        *p++ = cb2[9];
223
66297
                        *p++ = cb3[6];
224
66297
                        *p   = cb3[9];
225
66297
                        p = ip2;
226
66297
                        *p++ = cb2[0];
227
66297
                        *p++ = cb2[3];
228
66297
                        *p++ = cb3[0];
229
66297
                        *p   = cb3[3];
230
66297
                        p = ip1;
231
66297
                        *p++ = cb0[6];
232
66297
                        *p++ = cb0[9];
233
66297
                        *p++ = cb1[6];
234
66297
                        *p   = cb1[9];
235
66297
                        p = ip0;
236
66297
                        *p++ = cb0[0];
237
66297
                        *p++ = cb0[3];
238
66297
                        *p++ = cb1[0];
239
66297
                        *p   = cb1[3];
240
                    } else {
241
463828
                        memcpy(ip3 + 0, cb2 + 6, 6);
242
463828
                        memcpy(ip3 + 6, cb3 + 6, 6);
243
463828
                        memcpy(ip2 + 0, cb2 + 0, 6);
244
463828
                        memcpy(ip2 + 6, cb3 + 0, 6);
245
463828
                        memcpy(ip1 + 0, cb0 + 6, 6);
246
463828
                        memcpy(ip1 + 6, cb1 + 6, 6);
247
463828
                        memcpy(ip0 + 0, cb0 + 0, 6);
248
463828
                        memcpy(ip0 + 6, cb1 + 0, 6);
249
                    }
250
251
                }
252
            }
253
254
1114207
            if (s->palette_video) {
255
66297
                ip0 += 4;  ip1 += 4;
256
66297
                ip2 += 4;  ip3 += 4;
257
            } else {
258
1047910
                ip0 += 12;  ip1 += 12;
259
1047910
                ip2 += 12;  ip3 += 12;
260
            }
261
        }
262
    }
263
264
1033
    return 0;
265
}
266
267
1035
static int cinepak_decode_strip (CinepakContext *s,
268
                                 cvid_strip *strip, const uint8_t *data, int size)
269
{
270
1035
    const uint8_t *eod = (data + size);
271
    int      chunk_id, chunk_size;
272
273
    /* coordinate sanity checks */
274
1035
    if (strip->x2 > s->width   ||
275
1035
        strip->y2 > s->height  ||
276

1035
        strip->x1 >= strip->x2 || strip->y1 >= strip->y2)
277
        return AVERROR_INVALIDDATA;
278
279
3105
    while ((data + 4) <= eod) {
280
3105
        chunk_id   = data[0];
281
3105
        chunk_size = AV_RB24 (&data[1]) - 4;
282
3105
        if(chunk_size < 0)
283
            return AVERROR_INVALIDDATA;
284
285
3105
        data      += 4;
286
3105
        chunk_size = ((data + chunk_size) > eod) ? (eod - data) : chunk_size;
287
288

3105
        switch (chunk_id) {
289
290
1035
        case 0x20:
291
        case 0x21:
292
        case 0x24:
293
        case 0x25:
294
1035
            cinepak_decode_codebook (strip->v4_codebook, chunk_id,
295
                chunk_size, data);
296
1035
            break;
297
298
1035
        case 0x22:
299
        case 0x23:
300
        case 0x26:
301
        case 0x27:
302
1035
            cinepak_decode_codebook (strip->v1_codebook, chunk_id,
303
                chunk_size, data);
304
1035
            break;
305
306
1035
        case 0x30:
307
        case 0x31:
308
        case 0x32:
309
1035
            return cinepak_decode_vectors (s, strip, chunk_id,
310
                chunk_size, data);
311
        }
312
313
2070
        data += chunk_size;
314
    }
315
316
    return AVERROR_INVALIDDATA;
317
}
318
319
547
static int cinepak_predecode_check (CinepakContext *s)
320
{
321
    int           num_strips;
322
    int           encoded_buf_size;
323
324
547
    num_strips  = AV_RB16 (&s->data[8]);
325
547
    encoded_buf_size = AV_RB24(&s->data[1]);
326
327
547
    if (s->size < encoded_buf_size * (int64_t)(100 - s->avctx->discard_damaged_percentage) / 100)
328
        return AVERROR_INVALIDDATA;
329
330
    /* if this is the first frame, check for deviant Sega FILM data */
331
547
    if (s->sega_film_skip_bytes == -1) {
332
7
        if (!encoded_buf_size) {
333
            avpriv_request_sample(s->avctx, "encoded_buf_size 0");
334
            return AVERROR_PATCHWELCOME;
335
        }
336

7
        if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {
337
            /* If the encoded frame size differs from the frame size as indicated
338
             * by the container file, this data likely comes from a Sega FILM/CPK file.
339
             * If the frame header is followed by the bytes FE 00 00 06 00 00 then
340
             * this is probably one of the two known files that have 6 extra bytes
341
             * after the frame header. Else, assume 2 extra bytes. The container
342
             * size also cannot be a multiple of the encoded size. */
343
1
            if (s->size >= 16 &&
344
1
                (s->data[10] == 0xFE) &&
345
                (s->data[11] == 0x00) &&
346
                (s->data[12] == 0x00) &&
347
                (s->data[13] == 0x06) &&
348
                (s->data[14] == 0x00) &&
349
                (s->data[15] == 0x00))
350
                s->sega_film_skip_bytes = 6;
351
            else
352
1
                s->sega_film_skip_bytes = 2;
353
        } else
354
6
            s->sega_film_skip_bytes = 0;
355
    }
356
357
547
    if (s->size < 10 + s->sega_film_skip_bytes + num_strips * 12)
358
        return AVERROR_INVALIDDATA;
359
360
547
    if (num_strips) {
361
547
        const uint8_t *data = s->data + 10 + s->sega_film_skip_bytes;
362
547
        int strip_size = AV_RB24 (data + 1);
363

547
        if (strip_size < 12 || strip_size > encoded_buf_size)
364
            return AVERROR_INVALIDDATA;
365
    }
366
367
547
    return 0;
368
}
369
370
547
static int cinepak_decode (CinepakContext *s)
371
{
372
547
    const uint8_t  *eod = (s->data + s->size);
373
    int           i, result, strip_size, frame_flags, num_strips;
374
547
    int           y0 = 0;
375
376
547
    frame_flags = s->data[0];
377
547
    num_strips  = AV_RB16 (&s->data[8]);
378
379
547
    s->data += 10 + s->sega_film_skip_bytes;
380
381
547
    num_strips = FFMIN(num_strips, MAX_STRIPS);
382
383
547
    s->frame->key_frame = 0;
384
385
1580
    for (i=0; i < num_strips; i++) {
386
1035
        if ((s->data + 12) > eod)
387
            return AVERROR_INVALIDDATA;
388
389
1035
        s->strips[i].id = s->data[0];
390
/* zero y1 means "relative to the previous stripe" */
391
1035
        if (!(s->strips[i].y1 = AV_RB16 (&s->data[4])))
392
1035
            s->strips[i].y2 = (s->strips[i].y1 = y0) + AV_RB16 (&s->data[8]);
393
        else
394
            s->strips[i].y2 = AV_RB16 (&s->data[8]);
395
1035
        s->strips[i].x1 = AV_RB16 (&s->data[6]);
396
1035
        s->strips[i].x2 = AV_RB16 (&s->data[10]);
397
398
1035
        if (s->strips[i].id == 0x10)
399
115
            s->frame->key_frame = 1;
400
401
1035
        strip_size = AV_RB24 (&s->data[1]) - 12;
402
1035
        if (strip_size < 0)
403
            return AVERROR_INVALIDDATA;
404
1035
        s->data   += 12;
405
1035
        strip_size = ((s->data + strip_size) > eod) ? (eod - s->data) : strip_size;
406
407

1035
        if ((i > 0) && !(frame_flags & 0x01)) {
408
49
            memcpy (s->strips[i].v4_codebook, s->strips[i-1].v4_codebook,
409
                sizeof(s->strips[i].v4_codebook));
410
49
            memcpy (s->strips[i].v1_codebook, s->strips[i-1].v1_codebook,
411
                sizeof(s->strips[i].v1_codebook));
412
        }
413
414
1035
        result = cinepak_decode_strip (s, &s->strips[i], s->data, strip_size);
415
416
1035
        if (result != 0)
417
2
            return result;
418
419
1033
        s->data += strip_size;
420
1033
        y0    = s->strips[i].y2;
421
    }
422
545
    return 0;
423
}
424
425
14
static av_cold int cinepak_decode_init(AVCodecContext *avctx)
426
{
427
14
    CinepakContext *s = avctx->priv_data;
428
429
14
    s->avctx = avctx;
430
14
    s->width = (avctx->width + 3) & ~3;
431
14
    s->height = (avctx->height + 3) & ~3;
432
433
14
    s->sega_film_skip_bytes = -1;  /* uninitialized state */
434
435
    // check for paletted data
436
14
    if (avctx->bits_per_coded_sample != 8) {
437
12
        s->palette_video = 0;
438
12
        avctx->pix_fmt = AV_PIX_FMT_RGB24;
439
    } else {
440
2
        s->palette_video = 1;
441
2
        avctx->pix_fmt = AV_PIX_FMT_PAL8;
442
    }
443
444
14
    s->frame = av_frame_alloc();
445
14
    if (!s->frame)
446
        return AVERROR(ENOMEM);
447
448
14
    return 0;
449
}
450
451
547
static int cinepak_decode_frame(AVCodecContext *avctx,
452
                                void *data, int *got_frame,
453
                                AVPacket *avpkt)
454
{
455
547
    const uint8_t *buf = avpkt->data;
456
547
    int ret = 0, buf_size = avpkt->size;
457
547
    CinepakContext *s = avctx->priv_data;
458
    int num_strips;
459
460
547
    s->data = buf;
461
547
    s->size = buf_size;
462
463
547
    if (s->size < 10)
464
        return AVERROR_INVALIDDATA;
465
466
547
    num_strips = AV_RB16 (&s->data[8]);
467
468
    //Empty frame, do not waste time
469

547
    if (!num_strips && (!s->palette_video || !av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL)))
470
        return buf_size;
471
472
547
    if ((ret = cinepak_predecode_check(s)) < 0) {
473
        av_log(avctx, AV_LOG_ERROR, "cinepak_predecode_check failed\n");
474
        return ret;
475
    }
476
477
547
    if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
478
        return ret;
479
480
547
    if (s->palette_video) {
481
56
        s->frame->palette_has_changed = ff_copy_palette(s->pal, avpkt, avctx);
482
    }
483
484
547
    if ((ret = cinepak_decode(s)) < 0) {
485
2
        av_log(avctx, AV_LOG_ERROR, "cinepak_decode failed\n");
486
    }
487
488
547
    if (s->palette_video)
489
56
        memcpy (s->frame->data[1], s->pal, AVPALETTE_SIZE);
490
491
547
    if ((ret = av_frame_ref(data, s->frame)) < 0)
492
        return ret;
493
494
547
    *got_frame = 1;
495
496
    /* report that the buffer was completely consumed */
497
547
    return buf_size;
498
}
499
500
14
static av_cold int cinepak_decode_end(AVCodecContext *avctx)
501
{
502
14
    CinepakContext *s = avctx->priv_data;
503
504
14
    av_frame_free(&s->frame);
505
506
14
    return 0;
507
}
508
509
AVCodec ff_cinepak_decoder = {
510
    .name           = "cinepak",
511
    .long_name      = NULL_IF_CONFIG_SMALL("Cinepak"),
512
    .type           = AVMEDIA_TYPE_VIDEO,
513
    .id             = AV_CODEC_ID_CINEPAK,
514
    .priv_data_size = sizeof(CinepakContext),
515
    .init           = cinepak_decode_init,
516
    .close          = cinepak_decode_end,
517
    .decode         = cinepak_decode_frame,
518
    .capabilities   = AV_CODEC_CAP_DR1,
519
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
520
};