GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/bmp.c Lines: 158 218 72.5 %
Date: 2019-11-20 04:07:19 Branches: 115 186 61.8 %

Line Branch Exec Source
1
/*
2
 * BMP image format decoder
3
 * Copyright (c) 2005 Mans Rullgard
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
#include <inttypes.h>
23
24
#include "avcodec.h"
25
#include "bytestream.h"
26
#include "bmp.h"
27
#include "internal.h"
28
#include "msrledec.h"
29
30
46
static int bmp_decode_frame(AVCodecContext *avctx,
31
                            void *data, int *got_frame,
32
                            AVPacket *avpkt)
33
{
34
46
    const uint8_t *buf = avpkt->data;
35
46
    int buf_size       = avpkt->size;
36
46
    AVFrame *p         = data;
37
    unsigned int fsize, hsize;
38
    int width, height;
39
    unsigned int depth;
40
    BiCompression comp;
41
    unsigned int ihsize;
42
    int i, j, n, linesize, ret;
43
46
    uint32_t rgb[3] = {0};
44
46
    uint32_t alpha = 0;
45
    uint8_t *ptr;
46
    int dsize;
47
46
    const uint8_t *buf0 = buf;
48
    GetByteContext gb;
49
50
46
    if (buf_size < 14) {
51
        av_log(avctx, AV_LOG_ERROR, "buf size too small (%d)\n", buf_size);
52
        return AVERROR_INVALIDDATA;
53
    }
54
55

92
    if (bytestream_get_byte(&buf) != 'B' ||
56
46
        bytestream_get_byte(&buf) != 'M') {
57
        av_log(avctx, AV_LOG_ERROR, "bad magic number\n");
58
        return AVERROR_INVALIDDATA;
59
    }
60
61
46
    fsize = bytestream_get_le32(&buf);
62
46
    if (buf_size < fsize) {
63
        av_log(avctx, AV_LOG_ERROR, "not enough data (%d < %u), trying to decode anyway\n",
64
               buf_size, fsize);
65
        fsize = buf_size;
66
    }
67
68
46
    buf += 2; /* reserved1 */
69
46
    buf += 2; /* reserved2 */
70
71
46
    hsize  = bytestream_get_le32(&buf); /* header size */
72
46
    ihsize = bytestream_get_le32(&buf); /* more header size */
73
46
    if (ihsize + 14LL > hsize) {
74
        av_log(avctx, AV_LOG_ERROR, "invalid header size %u\n", hsize);
75
        return AVERROR_INVALIDDATA;
76
    }
77
78
    /* sometimes file size is set to some headers size, set a real size in that case */
79

46
    if (fsize == 14 || fsize == ihsize + 14)
80
2
        fsize = buf_size - 2;
81
82
46
    if (fsize <= hsize) {
83
        av_log(avctx, AV_LOG_ERROR,
84
               "Declared file size is less than header size (%u < %u)\n",
85
               fsize, hsize);
86
        return AVERROR_INVALIDDATA;
87
    }
88
89
46
    switch (ihsize) {
90
44
    case  40: // windib
91
    case  56: // windib v3
92
    case  64: // OS/2 v2
93
    case 108: // windib v4
94
    case 124: // windib v5
95
44
        width  = bytestream_get_le32(&buf);
96
44
        height = bytestream_get_le32(&buf);
97
44
        break;
98
2
    case  12: // OS/2 v1
99
2
        width  = bytestream_get_le16(&buf);
100
2
        height = bytestream_get_le16(&buf);
101
2
        break;
102
    default:
103
        avpriv_report_missing_feature(avctx, "Information header size %u",
104
                                      ihsize);
105
        return AVERROR_PATCHWELCOME;
106
    }
107
108
    /* planes */
109
46
    if (bytestream_get_le16(&buf) != 1) {
110
        av_log(avctx, AV_LOG_ERROR, "invalid BMP header\n");
111
        return AVERROR_INVALIDDATA;
112
    }
113
114
46
    depth = bytestream_get_le16(&buf);
115
116
46
    if (ihsize >= 40)
117
44
        comp = bytestream_get_le32(&buf);
118
    else
119
2
        comp = BMP_RGB;
120
121


46
    if (comp != BMP_RGB && comp != BMP_BITFIELDS && comp != BMP_RLE4 &&
122
        comp != BMP_RLE8) {
123
        av_log(avctx, AV_LOG_ERROR, "BMP coding %d not supported\n", comp);
124
        return AVERROR_INVALIDDATA;
125
    }
126
127
46
    if (comp == BMP_BITFIELDS) {
128
6
        buf += 20;
129
6
        rgb[0] = bytestream_get_le32(&buf);
130
6
        rgb[1] = bytestream_get_le32(&buf);
131
6
        rgb[2] = bytestream_get_le32(&buf);
132
6
        if (ihsize > 40)
133
        alpha = bytestream_get_le32(&buf);
134
    }
135
136
46
    ret = ff_set_dimensions(avctx, width, height > 0 ? height : -(unsigned)height);
137
46
    if (ret < 0) {
138
        av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", width, height);
139
        return AVERROR_INVALIDDATA;
140
    }
141
142
46
    avctx->pix_fmt = AV_PIX_FMT_NONE;
143
144

46
    switch (depth) {
145
4
    case 32:
146
4
        if (comp == BMP_BITFIELDS) {
147

2
            if (rgb[0] == 0xFF000000 && rgb[1] == 0x00FF0000 && rgb[2] == 0x0000FF00)
148
                avctx->pix_fmt = alpha ? AV_PIX_FMT_ABGR : AV_PIX_FMT_0BGR;
149

2
            else if (rgb[0] == 0x00FF0000 && rgb[1] == 0x0000FF00 && rgb[2] == 0x000000FF)
150
2
                avctx->pix_fmt = alpha ? AV_PIX_FMT_BGRA : AV_PIX_FMT_BGR0;
151
            else if (rgb[0] == 0x0000FF00 && rgb[1] == 0x00FF0000 && rgb[2] == 0xFF000000)
152
                avctx->pix_fmt = alpha ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
153
            else if (rgb[0] == 0x000000FF && rgb[1] == 0x0000FF00 && rgb[2] == 0x00FF0000)
154
                avctx->pix_fmt = alpha ? AV_PIX_FMT_RGBA : AV_PIX_FMT_RGB0;
155
            else {
156
                av_log(avctx, AV_LOG_ERROR, "Unknown bitfields "
157
                       "%0"PRIX32" %0"PRIX32" %0"PRIX32"\n", rgb[0], rgb[1], rgb[2]);
158
                return AVERROR(EINVAL);
159
            }
160
        } else {
161
2
            avctx->pix_fmt = AV_PIX_FMT_BGRA;
162
        }
163
4
        break;
164
22
    case 24:
165
22
        avctx->pix_fmt = AV_PIX_FMT_BGR24;
166
22
        break;
167
6
    case 16:
168
6
        if (comp == BMP_RGB)
169
2
            avctx->pix_fmt = AV_PIX_FMT_RGB555;
170
4
        else if (comp == BMP_BITFIELDS) {
171

4
            if (rgb[0] == 0xF800 && rgb[1] == 0x07E0 && rgb[2] == 0x001F)
172
2
               avctx->pix_fmt = AV_PIX_FMT_RGB565;
173

2
            else if (rgb[0] == 0x7C00 && rgb[1] == 0x03E0 && rgb[2] == 0x001F)
174
2
               avctx->pix_fmt = AV_PIX_FMT_RGB555;
175
            else if (rgb[0] == 0x0F00 && rgb[1] == 0x00F0 && rgb[2] == 0x000F)
176
               avctx->pix_fmt = AV_PIX_FMT_RGB444;
177
            else {
178
               av_log(avctx, AV_LOG_ERROR,
179
                      "Unknown bitfields %0"PRIX32" %0"PRIX32" %0"PRIX32"\n",
180
                      rgb[0], rgb[1], rgb[2]);
181
               return AVERROR(EINVAL);
182
            }
183
        }
184
6
        break;
185
6
    case 8:
186
6
        if (hsize - ihsize - 14 > 0)
187
6
            avctx->pix_fmt = AV_PIX_FMT_PAL8;
188
        else
189
            avctx->pix_fmt = AV_PIX_FMT_GRAY8;
190
6
        break;
191
8
    case 1:
192
    case 4:
193
8
        if (hsize - ihsize - 14 > 0) {
194
8
            avctx->pix_fmt = AV_PIX_FMT_PAL8;
195
        } else {
196
            av_log(avctx, AV_LOG_ERROR, "Unknown palette for %u-colour BMP\n",
197
                   1 << depth);
198
            return AVERROR_INVALIDDATA;
199
        }
200
8
        break;
201
    default:
202
        av_log(avctx, AV_LOG_ERROR, "depth %u not supported\n", depth);
203
        return AVERROR_INVALIDDATA;
204
    }
205
206
46
    if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
207
        av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
208
        return AVERROR_INVALIDDATA;
209
    }
210
211
46
    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
212
        return ret;
213
46
    p->pict_type = AV_PICTURE_TYPE_I;
214
46
    p->key_frame = 1;
215
216
46
    buf   = buf0 + hsize;
217
46
    dsize = buf_size - hsize;
218
219
    /* Line size in file multiple of 4 */
220
46
    n = ((avctx->width * depth + 31) / 8) & ~3;
221
222

46
    if (n * avctx->height > dsize && comp != BMP_RLE4 && comp != BMP_RLE8) {
223
        n = (avctx->width * depth + 7) / 8;
224
        if (n * avctx->height > dsize) {
225
            av_log(avctx, AV_LOG_ERROR, "not enough data (%d < %d)\n",
226
                   dsize, n * avctx->height);
227
            return AVERROR_INVALIDDATA;
228
        }
229
        av_log(avctx, AV_LOG_ERROR, "data size too small, assuming missing line alignment\n");
230
    }
231
232
    // RLE may skip decoding some picture areas, so blank picture before decoding
233

46
    if (comp == BMP_RLE4 || comp == BMP_RLE8)
234
4
        memset(p->data[0], 0, avctx->height * p->linesize[0]);
235
236
46
    if (height > 0) {
237
46
        ptr      = p->data[0] + (avctx->height - 1) * p->linesize[0];
238
46
        linesize = -p->linesize[0];
239
    } else {
240
        ptr      = p->data[0];
241
        linesize = p->linesize[0];
242
    }
243
244
46
    if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
245
14
        int colors = 1 << depth;
246
247
14
        memset(p->data[1], 0, 1024);
248
249
14
        if (ihsize >= 36) {
250
            int t;
251
12
            buf = buf0 + 46;
252
12
            t   = bytestream_get_le32(&buf);
253

12
            if (t < 0 || t > (1 << depth)) {
254
                av_log(avctx, AV_LOG_ERROR,
255
                       "Incorrect number of colors - %X for bitdepth %u\n",
256
                       t, depth);
257
12
            } else if (t) {
258
2
                colors = t;
259
            }
260
        } else {
261
2
            colors = FFMIN(256, (hsize-ihsize-14) / 3);
262
        }
263
14
        buf = buf0 + 14 + ihsize; //palette location
264
        // OS/2 bitmap, 3 bytes per palette entry
265
14
        if ((hsize-ihsize-14) < (colors << 2)) {
266
2
            if ((hsize-ihsize-14) < colors * 3) {
267
                av_log(avctx, AV_LOG_ERROR, "palette doesn't fit in packet\n");
268
                return AVERROR_INVALIDDATA;
269
            }
270
514
            for (i = 0; i < colors; i++)
271
512
                ((uint32_t*)p->data[1])[i] = (0xFFU<<24) | bytestream_get_le24(&buf);
272
        } else {
273
1136
            for (i = 0; i < colors; i++)
274
1124
                ((uint32_t*)p->data[1])[i] = 0xFFU << 24 | bytestream_get_le32(&buf);
275
        }
276
14
        buf = buf0 + hsize;
277
    }
278

46
    if (comp == BMP_RLE4 || comp == BMP_RLE8) {
279

4
        if (comp == BMP_RLE8 && height < 0) {
280
            p->data[0]    +=  p->linesize[0] * (avctx->height - 1);
281
            p->linesize[0] = -p->linesize[0];
282
        }
283
4
        bytestream2_init(&gb, buf, dsize);
284
4
        ff_msrle_decode(avctx, p, depth, &gb);
285
4
        if (height < 0) {
286
            p->data[0]    +=  p->linesize[0] * (avctx->height - 1);
287
            p->linesize[0] = -p->linesize[0];
288
        }
289
    } else {
290

42
        switch (depth) {
291
2
        case 1:
292
130
            for (i = 0; i < avctx->height; i++) {
293
                int j;
294
2048
                for (j = 0; j < avctx->width >> 3; j++) {
295
1920
                    ptr[j*8+0] =  buf[j] >> 7;
296
1920
                    ptr[j*8+1] = (buf[j] >> 6) & 1;
297
1920
                    ptr[j*8+2] = (buf[j] >> 5) & 1;
298
1920
                    ptr[j*8+3] = (buf[j] >> 4) & 1;
299
1920
                    ptr[j*8+4] = (buf[j] >> 3) & 1;
300
1920
                    ptr[j*8+5] = (buf[j] >> 2) & 1;
301
1920
                    ptr[j*8+6] = (buf[j] >> 1) & 1;
302
1920
                    ptr[j*8+7] =  buf[j]       & 1;
303
                }
304
1024
                for (j = 0; j < (avctx->width & 7); j++) {
305
896
                    ptr[avctx->width - (avctx->width & 7) + j] = buf[avctx->width >> 3] >> (7 - j) & 1;
306
                }
307
128
                buf += n;
308
128
                ptr += linesize;
309
            }
310
2
            break;
311
30
        case 8:
312
        case 24:
313
        case 32:
314
5140
            for (i = 0; i < avctx->height; i++) {
315
5110
                memcpy(ptr, buf, n);
316
5110
                buf += n;
317
5110
                ptr += linesize;
318
            }
319
30
            break;
320
4
        case 4:
321
176
            for (i = 0; i < avctx->height; i++) {
322
                int j;
323
15052
                for (j = 0; j < n; j++) {
324
14880
                    ptr[j*2+0] = (buf[j] >> 4) & 0xF;
325
14880
                    ptr[j*2+1] = buf[j] & 0xF;
326
                }
327
172
                buf += n;
328
172
                ptr += linesize;
329
            }
330
4
            break;
331
6
        case 16:
332
390
            for (i = 0; i < avctx->height; i++) {
333
384
                const uint16_t *src = (const uint16_t *) buf;
334
384
                uint16_t *dst       = (uint16_t *) ptr;
335
336
49152
                for (j = 0; j < avctx->width; j++)
337
48768
                    *dst++ = av_le2ne16(*src++);
338
339
384
                buf += n;
340
384
                ptr += linesize;
341
            }
342
6
            break;
343
        default:
344
            av_log(avctx, AV_LOG_ERROR, "BMP decoder is broken\n");
345
            return AVERROR_INVALIDDATA;
346
        }
347
    }
348
46
    if (avctx->pix_fmt == AV_PIX_FMT_BGRA) {
349
130
        for (i = 0; i < avctx->height; i++) {
350
            int j;
351
128
            uint8_t *ptr = p->data[0] + p->linesize[0]*i + 3;
352
16384
            for (j = 0; j < avctx->width; j++) {
353
16256
                if (ptr[4*j])
354
                    break;
355
            }
356
128
            if (j < avctx->width)
357
                break;
358
        }
359
2
        if (i == avctx->height)
360
2
            avctx->pix_fmt = p->format = AV_PIX_FMT_BGR0;
361
    }
362
363
46
    *got_frame = 1;
364
365
46
    return buf_size;
366
}
367
368
AVCodec ff_bmp_decoder = {
369
    .name           = "bmp",
370
    .long_name      = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"),
371
    .type           = AVMEDIA_TYPE_VIDEO,
372
    .id             = AV_CODEC_ID_BMP,
373
    .decode         = bmp_decode_frame,
374
    .capabilities   = AV_CODEC_CAP_DR1,
375
};