GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/msvideo1.c Lines: 151 159 95.0 %
Date: 2021-04-19 06:27:07 Branches: 74 94 78.7 %

Line Branch Exec Source
1
/*
2
 * Microsoft Video-1 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
 * Microsoft Video-1 Decoder by Mike Melanson (melanson@pcisys.net)
25
 * For more information about the MS Video-1 format, visit:
26
 *   http://www.pcisys.net/~melanson/codecs/
27
 */
28
29
#include <stdio.h>
30
#include <stdlib.h>
31
#include <string.h>
32
33
#include "libavutil/internal.h"
34
#include "libavutil/intreadwrite.h"
35
#include "avcodec.h"
36
#include "decode.h"
37
#include "internal.h"
38
39
#define PALETTE_COUNT 256
40
#define CHECK_STREAM_PTR(n) \
41
  if ((stream_ptr + n) > s->size ) { \
42
    av_log(s->avctx, AV_LOG_ERROR, " MS Video-1 warning: stream_ptr out of bounds (%d >= %d)\n", \
43
      stream_ptr + n, s->size); \
44
    return; \
45
  }
46
47
typedef struct Msvideo1Context {
48
49
    AVCodecContext *avctx;
50
    AVFrame *frame;
51
52
    const unsigned char *buf;
53
    int size;
54
55
    int mode_8bit;  /* if it's not 8-bit, it's 16-bit */
56
57
    uint32_t pal[256];
58
} Msvideo1Context;
59
60
13
static av_cold int msvideo1_decode_init(AVCodecContext *avctx)
61
{
62
13
    Msvideo1Context *s = avctx->priv_data;
63
64
13
    s->avctx = avctx;
65
66

13
    if (avctx->width < 4 || avctx->height < 4)
67
        return AVERROR_INVALIDDATA;
68
69
    /* figure out the colorspace based on the presence of a palette */
70
13
    if (s->avctx->bits_per_coded_sample == 8) {
71
5
        s->mode_8bit = 1;
72
5
        avctx->pix_fmt = AV_PIX_FMT_PAL8;
73
5
        if (avctx->extradata_size >= AVPALETTE_SIZE)
74
5
            memcpy(s->pal, avctx->extradata, AVPALETTE_SIZE);
75
    } else {
76
8
        s->mode_8bit = 0;
77
8
        avctx->pix_fmt = AV_PIX_FMT_RGB555;
78
    }
79
80
13
    s->frame = av_frame_alloc();
81
13
    if (!s->frame)
82
        return AVERROR(ENOMEM);
83
84
13
    return 0;
85
}
86
87
147
static void msvideo1_decode_8bit(Msvideo1Context *s)
88
{
89
    int block_ptr, pixel_ptr;
90
    int total_blocks;
91
    int pixel_x, pixel_y;  /* pixel width and height iterators */
92
    int block_x, block_y;  /* block width and height iterators */
93
    int blocks_wide, blocks_high;  /* width and height in 4x4 blocks */
94
    int block_inc;
95
    int row_dec;
96
97
    /* decoding parameters */
98
    int stream_ptr;
99
    unsigned char byte_a, byte_b;
100
    unsigned short flags;
101
    int skip_blocks;
102
    unsigned char colors[8];
103
147
    unsigned char *pixels = s->frame->data[0];
104
147
    int stride = s->frame->linesize[0];
105
106
147
    stream_ptr = 0;
107
147
    skip_blocks = 0;
108
147
    blocks_wide = s->avctx->width / 4;
109
147
    blocks_high = s->avctx->height / 4;
110
147
    total_blocks = blocks_wide * blocks_high;
111
147
    block_inc = 4;
112
147
    row_dec = stride + 4;
113
114
3977
    for (block_y = blocks_high; block_y > 0; block_y--) {
115
3830
        block_ptr = ((block_y * 4) - 1) * stride;
116
186030
        for (block_x = blocks_wide; block_x > 0; block_x--) {
117
            /* check if this block should be skipped */
118
182200
            if (skip_blocks) {
119
94392
                block_ptr += block_inc;
120
94392
                skip_blocks--;
121
94392
                total_blocks--;
122
94392
                continue;
123
            }
124
125
87808
            pixel_ptr = block_ptr;
126
127
            /* get the next two bytes in the encoded data stream */
128
87808
            CHECK_STREAM_PTR(2);
129
87808
            byte_a = s->buf[stream_ptr++];
130
87808
            byte_b = s->buf[stream_ptr++];
131
132
            /* check if the decode is finished */
133

87808
            if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0))
134
                return;
135
87808
            else if ((byte_b & 0xFC) == 0x84) {
136
                /* skip code, but don't count the current block */
137
8662
                skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
138
79146
            } else if (byte_b < 0x80) {
139
                /* 2-color encoding */
140
11480
                flags = (byte_b << 8) | byte_a;
141
142
11480
                CHECK_STREAM_PTR(2);
143
11480
                colors[0] = s->buf[stream_ptr++];
144
11480
                colors[1] = s->buf[stream_ptr++];
145
146
57400
                for (pixel_y = 0; pixel_y < 4; pixel_y++) {
147
229600
                    for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
148
183680
                        pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
149
45920
                    pixel_ptr -= row_dec;
150
                }
151
67666
            } else if (byte_b >= 0x90) {
152
                /* 8-color encoding */
153
56844
                flags = (byte_b << 8) | byte_a;
154
155
56844
                CHECK_STREAM_PTR(8);
156
56844
                memcpy(colors, &s->buf[stream_ptr], 8);
157
56844
                stream_ptr += 8;
158
159
284220
                for (pixel_y = 0; pixel_y < 4; pixel_y++) {
160
1136880
                    for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
161
909504
                        pixels[pixel_ptr++] =
162
909504
                            colors[((pixel_y & 0x2) << 1) +
163
909504
                                (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
164
227376
                    pixel_ptr -= row_dec;
165
                }
166
            } else {
167
                /* 1-color encoding */
168
10822
                colors[0] = byte_a;
169
170
54110
                for (pixel_y = 0; pixel_y < 4; pixel_y++) {
171
216440
                    for (pixel_x = 0; pixel_x < 4; pixel_x++)
172
173152
                        pixels[pixel_ptr++] = colors[0];
173
43288
                    pixel_ptr -= row_dec;
174
                }
175
            }
176
177
87808
            block_ptr += block_inc;
178
87808
            total_blocks--;
179
        }
180
    }
181
182
    /* make the palette available on the way out */
183
147
    if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
184
147
        memcpy(s->frame->data[1], s->pal, AVPALETTE_SIZE);
185
}
186
187
180
static void msvideo1_decode_16bit(Msvideo1Context *s)
188
{
189
    int block_ptr, pixel_ptr;
190
    int total_blocks;
191
    int pixel_x, pixel_y;  /* pixel width and height iterators */
192
    int block_x, block_y;  /* block width and height iterators */
193
    int blocks_wide, blocks_high;  /* width and height in 4x4 blocks */
194
    int block_inc;
195
    int row_dec;
196
197
    /* decoding parameters */
198
    int stream_ptr;
199
    unsigned char byte_a, byte_b;
200
    unsigned short flags;
201
    int skip_blocks;
202
    unsigned short colors[8];
203
180
    unsigned short *pixels = (unsigned short *)s->frame->data[0];
204
180
    int stride = s->frame->linesize[0] / 2;
205
206
180
    stream_ptr = 0;
207
180
    skip_blocks = 0;
208
180
    blocks_wide = s->avctx->width / 4;
209
180
    blocks_high = s->avctx->height / 4;
210
180
    total_blocks = blocks_wide * blocks_high;
211
180
    block_inc = 4;
212
180
    row_dec = stride + 4;
213
214
12090
    for (block_y = blocks_high; block_y > 0; block_y--) {
215
11910
        block_ptr = ((block_y * 4) - 1) * stride;
216
1003380
        for (block_x = blocks_wide; block_x > 0; block_x--) {
217
            /* check if this block should be skipped */
218
991470
            if (skip_blocks) {
219
281140
                block_ptr += block_inc;
220
281140
                skip_blocks--;
221
281140
                total_blocks--;
222
281140
                continue;
223
            }
224
225
710330
            pixel_ptr = block_ptr;
226
227
            /* get the next two bytes in the encoded data stream */
228
710330
            CHECK_STREAM_PTR(2);
229
710330
            byte_a = s->buf[stream_ptr++];
230
710330
            byte_b = s->buf[stream_ptr++];
231
232
            /* check if the decode is finished */
233

710330
            if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) {
234
                return;
235
710330
            } else if ((byte_b & 0xFC) == 0x84) {
236
                /* skip code, but don't count the current block */
237
108271
                skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
238
602059
            } else if (byte_b < 0x80) {
239
                /* 2- or 8-color encoding modes */
240
280291
                flags = (byte_b << 8) | byte_a;
241
242
280291
                CHECK_STREAM_PTR(4);
243
280291
                colors[0] = AV_RL16(&s->buf[stream_ptr]);
244
280291
                stream_ptr += 2;
245
280291
                colors[1] = AV_RL16(&s->buf[stream_ptr]);
246
280291
                stream_ptr += 2;
247
248
280291
                if (colors[0] & 0x8000) {
249
                    /* 8-color encoding */
250
145448
                    CHECK_STREAM_PTR(12);
251
145448
                    colors[2] = AV_RL16(&s->buf[stream_ptr]);
252
145448
                    stream_ptr += 2;
253
145448
                    colors[3] = AV_RL16(&s->buf[stream_ptr]);
254
145448
                    stream_ptr += 2;
255
145448
                    colors[4] = AV_RL16(&s->buf[stream_ptr]);
256
145448
                    stream_ptr += 2;
257
145448
                    colors[5] = AV_RL16(&s->buf[stream_ptr]);
258
145448
                    stream_ptr += 2;
259
145448
                    colors[6] = AV_RL16(&s->buf[stream_ptr]);
260
145448
                    stream_ptr += 2;
261
145448
                    colors[7] = AV_RL16(&s->buf[stream_ptr]);
262
145448
                    stream_ptr += 2;
263
264
727240
                    for (pixel_y = 0; pixel_y < 4; pixel_y++) {
265
2908960
                        for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
266
2327168
                            pixels[pixel_ptr++] =
267
2327168
                                colors[((pixel_y & 0x2) << 1) +
268
2327168
                                    (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
269
581792
                        pixel_ptr -= row_dec;
270
                    }
271
                } else {
272
                    /* 2-color encoding */
273
674215
                    for (pixel_y = 0; pixel_y < 4; pixel_y++) {
274
2696860
                        for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
275
2157488
                            pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
276
539372
                        pixel_ptr -= row_dec;
277
                    }
278
                }
279
            } else {
280
                /* otherwise, it's a 1-color block */
281
321768
                colors[0] = (byte_b << 8) | byte_a;
282
283
1608840
                for (pixel_y = 0; pixel_y < 4; pixel_y++) {
284
6435360
                    for (pixel_x = 0; pixel_x < 4; pixel_x++)
285
5148288
                        pixels[pixel_ptr++] = colors[0];
286
1287072
                    pixel_ptr -= row_dec;
287
                }
288
            }
289
290
710330
            block_ptr += block_inc;
291
710330
            total_blocks--;
292
        }
293
    }
294
}
295
296
327
static int msvideo1_decode_frame(AVCodecContext *avctx,
297
                                void *data, int *got_frame,
298
                                AVPacket *avpkt)
299
{
300
327
    const uint8_t *buf = avpkt->data;
301
327
    int buf_size = avpkt->size;
302
327
    Msvideo1Context *s = avctx->priv_data;
303
    int ret;
304
305
327
    s->buf = buf;
306
327
    s->size = buf_size;
307
308
    // Discard frame if its smaller than the minimum frame size
309
327
    if (buf_size < (avctx->width/4) * (avctx->height/4) / 512) {
310
        av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
311
        return AVERROR_INVALIDDATA;
312
    }
313
314
327
    if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
315
        return ret;
316
317
327
    if (s->mode_8bit) {
318
147
        s->frame->palette_has_changed = ff_copy_palette(s->pal, avpkt, avctx);
319
    }
320
321
327
    if (s->mode_8bit)
322
147
        msvideo1_decode_8bit(s);
323
    else
324
180
        msvideo1_decode_16bit(s);
325
326
327
    if ((ret = av_frame_ref(data, s->frame)) < 0)
327
        return ret;
328
329
327
    *got_frame      = 1;
330
331
    /* report that the buffer was completely consumed */
332
327
    return buf_size;
333
}
334
335
13
static av_cold int msvideo1_decode_end(AVCodecContext *avctx)
336
{
337
13
    Msvideo1Context *s = avctx->priv_data;
338
339
13
    av_frame_free(&s->frame);
340
341
13
    return 0;
342
}
343
344
AVCodec ff_msvideo1_decoder = {
345
    .name           = "msvideo1",
346
    .long_name      = NULL_IF_CONFIG_SMALL("Microsoft Video 1"),
347
    .type           = AVMEDIA_TYPE_VIDEO,
348
    .id             = AV_CODEC_ID_MSVIDEO1,
349
    .priv_data_size = sizeof(Msvideo1Context),
350
    .init           = msvideo1_decode_init,
351
    .close          = msvideo1_decode_end,
352
    .decode         = msvideo1_decode_frame,
353
    .capabilities   = AV_CODEC_CAP_DR1,
354
};