blob: 72957499d339e3361efec57164ad36dd3d3490a4
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 | static int bmp_decode_frame(AVCodecContext *avctx, |
31 | void *data, int *got_frame, |
32 | AVPacket *avpkt) |
33 | { |
34 | const uint8_t *buf = avpkt->data; |
35 | int buf_size = avpkt->size; |
36 | 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 | uint32_t rgb[3] = {0}; |
44 | uint32_t alpha = 0; |
45 | uint8_t *ptr; |
46 | int dsize; |
47 | const uint8_t *buf0 = buf; |
48 | GetByteContext gb; |
49 | |
50 | 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 | if (bytestream_get_byte(&buf) != 'B' || |
56 | bytestream_get_byte(&buf) != 'M') { |
57 | av_log(avctx, AV_LOG_ERROR, "bad magic number\n"); |
58 | return AVERROR_INVALIDDATA; |
59 | } |
60 | |
61 | fsize = bytestream_get_le32(&buf); |
62 | 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 | buf += 2; /* reserved1 */ |
69 | buf += 2; /* reserved2 */ |
70 | |
71 | hsize = bytestream_get_le32(&buf); /* header size */ |
72 | ihsize = bytestream_get_le32(&buf); /* more header size */ |
73 | 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 | if (fsize == 14 || fsize == ihsize + 14) |
80 | fsize = buf_size - 2; |
81 | |
82 | 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 | switch (ihsize) { |
90 | 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 | width = bytestream_get_le32(&buf); |
96 | height = bytestream_get_le32(&buf); |
97 | break; |
98 | case 12: // OS/2 v1 |
99 | width = bytestream_get_le16(&buf); |
100 | height = bytestream_get_le16(&buf); |
101 | break; |
102 | default: |
103 | avpriv_report_missing_feature(avctx, "Information header size %u", |
104 | ihsize); |
105 | return AVERROR_PATCHWELCOME; |
106 | } |
107 | |
108 | /* planes */ |
109 | if (bytestream_get_le16(&buf) != 1) { |
110 | av_log(avctx, AV_LOG_ERROR, "invalid BMP header\n"); |
111 | return AVERROR_INVALIDDATA; |
112 | } |
113 | |
114 | depth = bytestream_get_le16(&buf); |
115 | |
116 | if (ihsize >= 40) |
117 | comp = bytestream_get_le32(&buf); |
118 | else |
119 | comp = BMP_RGB; |
120 | |
121 | 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 | if (comp == BMP_BITFIELDS) { |
128 | buf += 20; |
129 | rgb[0] = bytestream_get_le32(&buf); |
130 | rgb[1] = bytestream_get_le32(&buf); |
131 | rgb[2] = bytestream_get_le32(&buf); |
132 | if (ihsize > 40) |
133 | alpha = bytestream_get_le32(&buf); |
134 | } |
135 | |
136 | avctx->width = width; |
137 | avctx->height = height > 0 ? height : -(unsigned)height; |
138 | |
139 | avctx->pix_fmt = AV_PIX_FMT_NONE; |
140 | |
141 | switch (depth) { |
142 | case 32: |
143 | if (comp == BMP_BITFIELDS) { |
144 | if (rgb[0] == 0xFF000000 && rgb[1] == 0x00FF0000 && rgb[2] == 0x0000FF00) |
145 | avctx->pix_fmt = alpha ? AV_PIX_FMT_ABGR : AV_PIX_FMT_0BGR; |
146 | else if (rgb[0] == 0x00FF0000 && rgb[1] == 0x0000FF00 && rgb[2] == 0x000000FF) |
147 | avctx->pix_fmt = alpha ? AV_PIX_FMT_BGRA : AV_PIX_FMT_BGR0; |
148 | else if (rgb[0] == 0x0000FF00 && rgb[1] == 0x00FF0000 && rgb[2] == 0xFF000000) |
149 | avctx->pix_fmt = alpha ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB; |
150 | else if (rgb[0] == 0x000000FF && rgb[1] == 0x0000FF00 && rgb[2] == 0x00FF0000) |
151 | avctx->pix_fmt = alpha ? AV_PIX_FMT_RGBA : AV_PIX_FMT_RGB0; |
152 | else { |
153 | av_log(avctx, AV_LOG_ERROR, "Unknown bitfields " |
154 | "%0"PRIX32" %0"PRIX32" %0"PRIX32"\n", rgb[0], rgb[1], rgb[2]); |
155 | return AVERROR(EINVAL); |
156 | } |
157 | } else { |
158 | avctx->pix_fmt = AV_PIX_FMT_BGRA; |
159 | } |
160 | break; |
161 | case 24: |
162 | avctx->pix_fmt = AV_PIX_FMT_BGR24; |
163 | break; |
164 | case 16: |
165 | if (comp == BMP_RGB) |
166 | avctx->pix_fmt = AV_PIX_FMT_RGB555; |
167 | else if (comp == BMP_BITFIELDS) { |
168 | if (rgb[0] == 0xF800 && rgb[1] == 0x07E0 && rgb[2] == 0x001F) |
169 | avctx->pix_fmt = AV_PIX_FMT_RGB565; |
170 | else if (rgb[0] == 0x7C00 && rgb[1] == 0x03E0 && rgb[2] == 0x001F) |
171 | avctx->pix_fmt = AV_PIX_FMT_RGB555; |
172 | else if (rgb[0] == 0x0F00 && rgb[1] == 0x00F0 && rgb[2] == 0x000F) |
173 | avctx->pix_fmt = AV_PIX_FMT_RGB444; |
174 | else { |
175 | av_log(avctx, AV_LOG_ERROR, |
176 | "Unknown bitfields %0"PRIX32" %0"PRIX32" %0"PRIX32"\n", |
177 | rgb[0], rgb[1], rgb[2]); |
178 | return AVERROR(EINVAL); |
179 | } |
180 | } |
181 | break; |
182 | case 8: |
183 | if (hsize - ihsize - 14 > 0) |
184 | avctx->pix_fmt = AV_PIX_FMT_PAL8; |
185 | else |
186 | avctx->pix_fmt = AV_PIX_FMT_GRAY8; |
187 | break; |
188 | case 1: |
189 | case 4: |
190 | if (hsize - ihsize - 14 > 0) { |
191 | avctx->pix_fmt = AV_PIX_FMT_PAL8; |
192 | } else { |
193 | av_log(avctx, AV_LOG_ERROR, "Unknown palette for %u-colour BMP\n", |
194 | 1 << depth); |
195 | return AVERROR_INVALIDDATA; |
196 | } |
197 | break; |
198 | default: |
199 | av_log(avctx, AV_LOG_ERROR, "depth %u not supported\n", depth); |
200 | return AVERROR_INVALIDDATA; |
201 | } |
202 | |
203 | if (avctx->pix_fmt == AV_PIX_FMT_NONE) { |
204 | av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n"); |
205 | return AVERROR_INVALIDDATA; |
206 | } |
207 | |
208 | if ((ret = ff_get_buffer(avctx, p, 0)) < 0) |
209 | return ret; |
210 | p->pict_type = AV_PICTURE_TYPE_I; |
211 | p->key_frame = 1; |
212 | |
213 | buf = buf0 + hsize; |
214 | dsize = buf_size - hsize; |
215 | |
216 | /* Line size in file multiple of 4 */ |
217 | n = ((avctx->width * depth + 31) / 8) & ~3; |
218 | |
219 | if (n * avctx->height > dsize && comp != BMP_RLE4 && comp != BMP_RLE8) { |
220 | n = (avctx->width * depth + 7) / 8; |
221 | if (n * avctx->height > dsize) { |
222 | av_log(avctx, AV_LOG_ERROR, "not enough data (%d < %d)\n", |
223 | dsize, n * avctx->height); |
224 | return AVERROR_INVALIDDATA; |
225 | } |
226 | av_log(avctx, AV_LOG_ERROR, "data size too small, assuming missing line alignment\n"); |
227 | } |
228 | |
229 | // RLE may skip decoding some picture areas, so blank picture before decoding |
230 | if (comp == BMP_RLE4 || comp == BMP_RLE8) |
231 | memset(p->data[0], 0, avctx->height * p->linesize[0]); |
232 | |
233 | if (height > 0) { |
234 | ptr = p->data[0] + (avctx->height - 1) * p->linesize[0]; |
235 | linesize = -p->linesize[0]; |
236 | } else { |
237 | ptr = p->data[0]; |
238 | linesize = p->linesize[0]; |
239 | } |
240 | |
241 | if (avctx->pix_fmt == AV_PIX_FMT_PAL8) { |
242 | int colors = 1 << depth; |
243 | |
244 | memset(p->data[1], 0, 1024); |
245 | |
246 | if (ihsize >= 36) { |
247 | int t; |
248 | buf = buf0 + 46; |
249 | t = bytestream_get_le32(&buf); |
250 | if (t < 0 || t > (1 << depth)) { |
251 | av_log(avctx, AV_LOG_ERROR, |
252 | "Incorrect number of colors - %X for bitdepth %u\n", |
253 | t, depth); |
254 | } else if (t) { |
255 | colors = t; |
256 | } |
257 | } else { |
258 | colors = FFMIN(256, (hsize-ihsize-14) / 3); |
259 | } |
260 | buf = buf0 + 14 + ihsize; //palette location |
261 | // OS/2 bitmap, 3 bytes per palette entry |
262 | if ((hsize-ihsize-14) < (colors << 2)) { |
263 | if ((hsize-ihsize-14) < colors * 3) { |
264 | av_log(avctx, AV_LOG_ERROR, "palette doesn't fit in packet\n"); |
265 | return AVERROR_INVALIDDATA; |
266 | } |
267 | for (i = 0; i < colors; i++) |
268 | ((uint32_t*)p->data[1])[i] = (0xFFU<<24) | bytestream_get_le24(&buf); |
269 | } else { |
270 | for (i = 0; i < colors; i++) |
271 | ((uint32_t*)p->data[1])[i] = 0xFFU << 24 | bytestream_get_le32(&buf); |
272 | } |
273 | buf = buf0 + hsize; |
274 | } |
275 | if (comp == BMP_RLE4 || comp == BMP_RLE8) { |
276 | if (comp == BMP_RLE8 && height < 0) { |
277 | p->data[0] += p->linesize[0] * (avctx->height - 1); |
278 | p->linesize[0] = -p->linesize[0]; |
279 | } |
280 | bytestream2_init(&gb, buf, dsize); |
281 | ff_msrle_decode(avctx, p, depth, &gb); |
282 | if (height < 0) { |
283 | p->data[0] += p->linesize[0] * (avctx->height - 1); |
284 | p->linesize[0] = -p->linesize[0]; |
285 | } |
286 | } else { |
287 | switch (depth) { |
288 | case 1: |
289 | for (i = 0; i < avctx->height; i++) { |
290 | int j; |
291 | for (j = 0; j < n; j++) { |
292 | ptr[j*8+0] = buf[j] >> 7; |
293 | ptr[j*8+1] = (buf[j] >> 6) & 1; |
294 | ptr[j*8+2] = (buf[j] >> 5) & 1; |
295 | ptr[j*8+3] = (buf[j] >> 4) & 1; |
296 | ptr[j*8+4] = (buf[j] >> 3) & 1; |
297 | ptr[j*8+5] = (buf[j] >> 2) & 1; |
298 | ptr[j*8+6] = (buf[j] >> 1) & 1; |
299 | ptr[j*8+7] = buf[j] & 1; |
300 | } |
301 | buf += n; |
302 | ptr += linesize; |
303 | } |
304 | break; |
305 | case 8: |
306 | case 24: |
307 | case 32: |
308 | for (i = 0; i < avctx->height; i++) { |
309 | memcpy(ptr, buf, n); |
310 | buf += n; |
311 | ptr += linesize; |
312 | } |
313 | break; |
314 | case 4: |
315 | for (i = 0; i < avctx->height; i++) { |
316 | int j; |
317 | for (j = 0; j < n; j++) { |
318 | ptr[j*2+0] = (buf[j] >> 4) & 0xF; |
319 | ptr[j*2+1] = buf[j] & 0xF; |
320 | } |
321 | buf += n; |
322 | ptr += linesize; |
323 | } |
324 | break; |
325 | case 16: |
326 | for (i = 0; i < avctx->height; i++) { |
327 | const uint16_t *src = (const uint16_t *) buf; |
328 | uint16_t *dst = (uint16_t *) ptr; |
329 | |
330 | for (j = 0; j < avctx->width; j++) |
331 | *dst++ = av_le2ne16(*src++); |
332 | |
333 | buf += n; |
334 | ptr += linesize; |
335 | } |
336 | break; |
337 | default: |
338 | av_log(avctx, AV_LOG_ERROR, "BMP decoder is broken\n"); |
339 | return AVERROR_INVALIDDATA; |
340 | } |
341 | } |
342 | if (avctx->pix_fmt == AV_PIX_FMT_BGRA) { |
343 | for (i = 0; i < avctx->height; i++) { |
344 | int j; |
345 | uint8_t *ptr = p->data[0] + p->linesize[0]*i + 3; |
346 | for (j = 0; j < avctx->width; j++) { |
347 | if (ptr[4*j]) |
348 | break; |
349 | } |
350 | if (j < avctx->width) |
351 | break; |
352 | } |
353 | if (i == avctx->height) |
354 | avctx->pix_fmt = p->format = AV_PIX_FMT_BGR0; |
355 | } |
356 | |
357 | *got_frame = 1; |
358 | |
359 | return buf_size; |
360 | } |
361 | |
362 | AVCodec ff_bmp_decoder = { |
363 | .name = "bmp", |
364 | .long_name = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"), |
365 | .type = AVMEDIA_TYPE_VIDEO, |
366 | .id = AV_CODEC_ID_BMP, |
367 | .decode = bmp_decode_frame, |
368 | .capabilities = AV_CODEC_CAP_DR1, |
369 | }; |
370 |