GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/indeo2.c Lines: 105 128 82.0 %
Date: 2021-01-26 01:16:58 Branches: 44 66 66.7 %

Line Branch Exec Source
1
/*
2
 * Intel Indeo 2 codec
3
 * Copyright (c) 2005 Konstantin Shishkov
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
 * Intel Indeo 2 decoder.
25
 */
26
27
#include "libavutil/attributes.h"
28
#include "libavutil/thread.h"
29
30
#define BITSTREAM_READER_LE
31
#include "avcodec.h"
32
#include "get_bits.h"
33
#include "indeo2data.h"
34
#include "internal.h"
35
#include "mathops.h"
36
37
typedef struct Ir2Context{
38
    AVCodecContext *avctx;
39
    AVFrame *picture;
40
    GetBitContext gb;
41
    int decode_delta;
42
} Ir2Context;
43
44
#define CODE_VLC_BITS 14
45
static VLC ir2_vlc;
46
47
/* Indeo 2 codes are in range 0x01..0x7F and 0x81..0x90 */
48
2449607
static inline int ir2_get_code(GetBitContext *gb)
49
{
50
2449607
    return get_vlc2(gb, ir2_vlc.table, CODE_VLC_BITS, 1);
51
}
52
53
633
static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst,
54
                            int pitch, const uint8_t *table)
55
{
56
    int i;
57
    int j;
58
633
    int out = 0;
59
60

633
    if ((width & 1) || width * height / (2*(IR2_CODES - 0x7F)) > get_bits_left(&ctx->gb))
61
        return AVERROR_INVALIDDATA;
62
63
    /* first line contain absolute values, other lines contain deltas */
64
25864
    while (out < width) {
65
25231
        int c = ir2_get_code(&ctx->gb);
66
25231
        if (c >= 0x80) { /* we have a run */
67
338
            c -= 0x7F;
68
338
            if (out + c*2 > width)
69
                return AVERROR_INVALIDDATA;
70
1192
            for (i = 0; i < c * 2; i++)
71
854
                dst[out++] = 0x80;
72
        } else { /* copy two values from table */
73
24893
            if (c <= 0)
74
                return AVERROR_INVALIDDATA;
75
24893
            dst[out++] = table[c * 2];
76
24893
            dst[out++] = table[(c * 2) + 1];
77
        }
78
    }
79
633
    dst += pitch;
80
81
37980
    for (j = 1; j < height; j++) {
82
37347
        out = 0;
83
2152428
        while (out < width) {
84
            int c;
85
2115081
            if (get_bits_left(&ctx->gb) <= 0)
86
                return AVERROR_INVALIDDATA;
87
2115081
            c = ir2_get_code(&ctx->gb);
88
2115081
            if (c >= 0x80) { /* we have a skip */
89
228280
                c -= 0x7F;
90
228280
                if (out + c*2 > width)
91
                    return AVERROR_INVALIDDATA;
92
961638
                for (i = 0; i < c * 2; i++) {
93
733358
                    dst[out] = dst[out - pitch];
94
733358
                    out++;
95
                }
96
            } else { /* add two deltas from table */
97
                int t;
98
1886801
                if (c <= 0)
99
                    return AVERROR_INVALIDDATA;
100
1886801
                t        = dst[out - pitch] + (table[c * 2] - 128);
101
1886801
                t        = av_clip_uint8(t);
102
1886801
                dst[out] = t;
103
1886801
                out++;
104
1886801
                t        = dst[out - pitch] + (table[(c * 2) + 1] - 128);
105
1886801
                t        = av_clip_uint8(t);
106
1886801
                dst[out] = t;
107
1886801
                out++;
108
            }
109
        }
110
37347
        dst += pitch;
111
    }
112
633
    return 0;
113
}
114
115
99
static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst,
116
                                  int pitch, const uint8_t *table)
117
{
118
    int j;
119
99
    int out = 0;
120
    int c;
121
    int t;
122
123
99
    if (width & 1)
124
        return AVERROR_INVALIDDATA;
125
126
6039
    for (j = 0; j < height; j++) {
127
5940
        out = 0;
128
315235
        while (out < width) {
129
309295
            if (get_bits_left(&ctx->gb) <= 0)
130
                return AVERROR_INVALIDDATA;
131
309295
            c = ir2_get_code(&ctx->gb);
132
309295
            if (c >= 0x80) { /* we have a skip */
133
56657
                c   -= 0x7F;
134
56657
                out += c * 2;
135
            } else { /* add two deltas from table */
136
252638
                if (c <= 0)
137
                    return AVERROR_INVALIDDATA;
138
252638
                t        = dst[out] + (((table[c * 2] - 128)*3) >> 2);
139
252638
                t        = av_clip_uint8(t);
140
252638
                dst[out] = t;
141
252638
                out++;
142
252638
                t        = dst[out] + (((table[(c * 2) + 1] - 128)*3) >> 2);
143
252638
                t        = av_clip_uint8(t);
144
252638
                dst[out] = t;
145
252638
                out++;
146
            }
147
        }
148
5940
        dst += pitch;
149
    }
150
99
    return 0;
151
}
152
153
244
static int ir2_decode_frame(AVCodecContext *avctx,
154
                        void *data, int *got_frame,
155
                        AVPacket *avpkt)
156
{
157
244
    Ir2Context * const s = avctx->priv_data;
158
244
    const uint8_t *buf   = avpkt->data;
159
244
    int buf_size         = avpkt->size;
160
244
    AVFrame *picture     = data;
161
244
    AVFrame * const p    = s->picture;
162
    int start, ret;
163
    int ltab, ctab;
164
165
244
    if ((ret = ff_reget_buffer(avctx, p, 0)) < 0)
166
        return ret;
167
168
244
    start = 48; /* hardcoded for now */
169
170
244
    if (start >= buf_size) {
171
        av_log(s->avctx, AV_LOG_ERROR, "input buffer size too small (%d)\n", buf_size);
172
        return AVERROR_INVALIDDATA;
173
    }
174
175
244
    s->decode_delta = buf[18];
176
177
    /* decide whether frame uses deltas or not */
178
179
244
    if ((ret = init_get_bits8(&s->gb, buf + start, buf_size - start)) < 0)
180
        return ret;
181
182
244
    ltab = buf[0x22] & 3;
183
244
    ctab = buf[0x22] >> 2;
184
185
244
    if (ctab > 3) {
186
        av_log(avctx, AV_LOG_ERROR, "ctab %d is invalid\n", ctab);
187
        return AVERROR_INVALIDDATA;
188
    }
189
190
244
    if (s->decode_delta) { /* intraframe */
191
211
        if ((ret = ir2_decode_plane(s, avctx->width, avctx->height,
192
                                    p->data[0], p->linesize[0],
193
211
                                    ir2_delta_table[ltab])) < 0)
194
            return ret;
195
196
        /* swapped U and V */
197
211
        if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
198
                                    p->data[2], p->linesize[2],
199
211
                                    ir2_delta_table[ctab])) < 0)
200
            return ret;
201
211
        if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
202
                                    p->data[1], p->linesize[1],
203
211
                                    ir2_delta_table[ctab])) < 0)
204
            return ret;
205
    } else { /* interframe */
206
33
        if ((ret = ir2_decode_plane_inter(s, avctx->width, avctx->height,
207
                                          p->data[0], p->linesize[0],
208
33
                                          ir2_delta_table[ltab])) < 0)
209
            return ret;
210
        /* swapped U and V */
211
33
        if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
212
                                          p->data[2], p->linesize[2],
213
33
                                          ir2_delta_table[ctab])) < 0)
214
            return ret;
215
33
        if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
216
                                          p->data[1], p->linesize[1],
217
33
                                          ir2_delta_table[ctab])) < 0)
218
            return ret;
219
    }
220
221
244
    if ((ret = av_frame_ref(picture, p)) < 0)
222
        return ret;
223
224
244
    *got_frame = 1;
225
226
244
    return buf_size;
227
}
228
229
2
static av_cold void ir2_init_static(void)
230
{
231
2
    INIT_VLC_STATIC_FROM_LENGTHS(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
232
                                 &ir2_tab[0][1], 2, &ir2_tab[0][0], 2, 1,
233
                                 0, INIT_VLC_OUTPUT_LE, 1 << CODE_VLC_BITS);
234
2
}
235
236
4
static av_cold int ir2_decode_init(AVCodecContext *avctx)
237
{
238
    static AVOnce init_static_once = AV_ONCE_INIT;
239
4
    Ir2Context * const ic = avctx->priv_data;
240
241
4
    ic->avctx = avctx;
242
243
4
    avctx->pix_fmt= AV_PIX_FMT_YUV410P;
244
245
4
    ic->picture = av_frame_alloc();
246
4
    if (!ic->picture)
247
        return AVERROR(ENOMEM);
248
249
4
    ff_thread_once(&init_static_once, ir2_init_static);
250
251
4
    return 0;
252
}
253
254
4
static av_cold int ir2_decode_end(AVCodecContext *avctx)
255
{
256
4
    Ir2Context * const ic = avctx->priv_data;
257
258
4
    av_frame_free(&ic->picture);
259
260
4
    return 0;
261
}
262
263
AVCodec ff_indeo2_decoder = {
264
    .name           = "indeo2",
265
    .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
266
    .type           = AVMEDIA_TYPE_VIDEO,
267
    .id             = AV_CODEC_ID_INDEO2,
268
    .priv_data_size = sizeof(Ir2Context),
269
    .init           = ir2_decode_init,
270
    .close          = ir2_decode_end,
271
    .decode         = ir2_decode_frame,
272
    .capabilities   = AV_CODEC_CAP_DR1,
273
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
274
};