GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/cinepak.c Lines: 227 259 87.6 %
Date: 2019-11-20 04:07:19 Branches: 118 166 71.1 %

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 "internal.h"
44
45
46
typedef uint8_t cvid_codebook[12];
47
48
#define MAX_STRIPS      32
49
50
typedef struct cvid_strip {
51
    uint16_t          id;
52
    uint16_t          x1, y1;
53
    uint16_t          x2, y2;
54
    cvid_codebook     v4_codebook[256];
55
    cvid_codebook     v1_codebook[256];
56
} cvid_strip;
57
58
typedef struct CinepakContext {
59
60
    AVCodecContext *avctx;
61
    AVFrame *frame;
62
63
    const unsigned char *data;
64
    int size;
65
66
    int width, height;
67
68
    int palette_video;
69
    cvid_strip strips[MAX_STRIPS];
70
71
    int sega_film_skip_bytes;
72
73
    uint32_t pal[256];
74
} CinepakContext;
75
76
2070
static void cinepak_decode_codebook (cvid_codebook *codebook,
77
                                     int chunk_id, int size, const uint8_t *data)
78
{
79
2070
    const uint8_t *eod = (data + size);
80
    uint32_t flag, mask;
81
    int      i, n;
82
    uint8_t *p;
83
84
    /* check if this chunk contains 4- or 6-element vectors */
85
2070
    n    = (chunk_id & 0x04) ? 4 : 6;
86
2070
    flag = 0;
87
2070
    mask = 0;
88
89
2070
    p = codebook[0];
90
376233
    for (i=0; i < 256; i++) {
91

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

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

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

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

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

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

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

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

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

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

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

547
    if (!num_strips && (!s->palette_video || !av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL)))
469
        return buf_size;
470
471
547
    if ((ret = cinepak_predecode_check(s)) < 0) {
472
        av_log(avctx, AV_LOG_ERROR, "cinepak_predecode_check failed\n");
473
        return ret;
474
    }
475
476
547
    if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
477
        return ret;
478
479
547
    if (s->palette_video) {
480
        int size;
481
56
        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
482

56
        if (pal && size == AVPALETTE_SIZE) {
483
1
            s->frame->palette_has_changed = 1;
484
1
            memcpy(s->pal, pal, AVPALETTE_SIZE);
485
55
        } else if (pal) {
486
            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
487
        }
488
    }
489
490
547
    if ((ret = cinepak_decode(s)) < 0) {
491
2
        av_log(avctx, AV_LOG_ERROR, "cinepak_decode failed\n");
492
    }
493
494
547
    if (s->palette_video)
495
56
        memcpy (s->frame->data[1], s->pal, AVPALETTE_SIZE);
496
497
547
    if ((ret = av_frame_ref(data, s->frame)) < 0)
498
        return ret;
499
500
547
    *got_frame = 1;
501
502
    /* report that the buffer was completely consumed */
503
547
    return buf_size;
504
}
505
506
14
static av_cold int cinepak_decode_end(AVCodecContext *avctx)
507
{
508
14
    CinepakContext *s = avctx->priv_data;
509
510
14
    av_frame_free(&s->frame);
511
512
14
    return 0;
513
}
514
515
AVCodec ff_cinepak_decoder = {
516
    .name           = "cinepak",
517
    .long_name      = NULL_IF_CONFIG_SMALL("Cinepak"),
518
    .type           = AVMEDIA_TYPE_VIDEO,
519
    .id             = AV_CODEC_ID_CINEPAK,
520
    .priv_data_size = sizeof(CinepakContext),
521
    .init           = cinepak_decode_init,
522
    .close          = cinepak_decode_end,
523
    .decode         = cinepak_decode_frame,
524
    .capabilities   = AV_CODEC_CAP_DR1,
525
};