#include <stdarg.h>
-#include "imagei.h"
+#include "imageri.h"
/*
=head1 NAME
static int write_24bit_data(io_glue *ig, i_img *im);
static int read_bmp_pal(io_glue *ig, i_img *im, int count);
static i_img *read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
- int compression, long offbits);
+ int compression, long offbits, int allow_incomplete);
static i_img *read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
- int compression, long offbits);
+ int compression, long offbits, int allow_incomplete);
static i_img *read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
- int compression, long offbits);
+ int compression, long offbits, int allow_incomplete);
static i_img *read_direct_bmp(io_glue *ig, int xsize, int ysize,
int bit_count, int clr_used, int compression,
- long offbits);
+ long offbits, int allow_incomplete);
/*
=item i_writebmp_wiol(im, io_glue)
*/
i_img *
-i_readbmp_wiol(io_glue *ig) {
+i_readbmp_wiol(io_glue *ig, int allow_incomplete) {
int b_magic, m_magic, filesize, res1, res2, infohead_size;
int xsize, ysize, planes, bit_count, compression, size_image, xres, yres;
int clr_used, clr_important, offbits;
&xsize, &ysize, &planes,
&bit_count, &compression, &size_image, &xres, &yres,
&clr_used, &clr_important)) {
- i_push_error(0, "file too short");
+ i_push_error(0, "file too short to be a BMP file");
return 0;
}
if (b_magic != 'B' || m_magic != 'M' || infohead_size != INFOHEAD_SIZE
bit_count, compression, size_image, xres, yres, clr_used,
clr_important));
- if (!i_int_check_image_file_limits(xsize, ysize, 3, sizeof(i_sample_t))) {
+ if (!i_int_check_image_file_limits(xsize, abs(ysize), 3, sizeof(i_sample_t))) {
mm_log((1, "i_readbmp_wiol: image size exceeds limits\n"));
return NULL;
}
switch (bit_count) {
case 1:
- im = read_1bit_bmp(ig, xsize, ysize, clr_used, compression, offbits);
+ im = read_1bit_bmp(ig, xsize, ysize, clr_used, compression, offbits,
+ allow_incomplete);
break;
case 4:
- im = read_4bit_bmp(ig, xsize, ysize, clr_used, compression, offbits);
+ im = read_4bit_bmp(ig, xsize, ysize, clr_used, compression, offbits,
+ allow_incomplete);
break;
case 8:
- im = read_8bit_bmp(ig, xsize, ysize, clr_used, compression, offbits);
+ im = read_8bit_bmp(ig, xsize, ysize, clr_used, compression, offbits,
+ allow_incomplete);
break;
case 32:
case 24:
case 16:
im = read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression,
- offbits);
+ offbits, allow_incomplete);
break;
default:
break;
default:
- m_fatal(1, "Unknown read_packed format code 0x%02x", *format);
+ i_fatal(1, "Unknown read_packed format code 0x%02x", *format);
}
++format;
}
break;
default:
- m_fatal(1, "Unknown write_packed format code 0x%02x", *format);
+ i_fatal(1, "Unknown write_packed format code 0x%02x", *format);
}
++format;
}
*/
static i_img *
read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
- int compression, long offbits) {
+ int compression, long offbits, int allow_incomplete) {
i_img *im;
- int x, y, lasty, yinc;
+ int x, y, lasty, yinc, start_y;
i_palidx *line, *p;
unsigned char *packed;
int line_size = (xsize + 7)/8;
line_size = (line_size+3) / 4 * 4;
if (ysize > 0) {
- y = ysize-1;
+ start_y = ysize-1;
lasty = -1;
yinc = -1;
}
else {
/* when ysize is -ve it's a top-down image */
ysize = -ysize;
- y = 0;
+ start_y = 0;
lasty = ysize;
yinc = 1;
}
+ y = start_y;
if (!clr_used)
clr_used = 2;
if (clr_used < 0 || clr_used > 2) {
if (ig->readcb(ig, packed, line_size) != line_size) {
myfree(packed);
myfree(line);
- i_push_error(0, "failed reading 1-bit bmp data");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(start_y - y));
+ return im;
+ }
+ else {
+ i_push_error(0, "failed reading 1-bit bmp data");
+ i_img_destroy(im);
+ return NULL;
+ }
}
in = packed;
bit = 0x80;
*/
static i_img *
read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
- int compression, long offbits) {
+ int compression, long offbits, int allow_incomplete) {
i_img *im;
int x, y, lasty, yinc;
i_palidx *line, *p;
unsigned char *in;
int size, i;
long base_offset;
+ int starty;
/* line_size is going to be smaller than xsize in most cases (and
when it's not, xsize is itself small), and hence not overflow */
line_size = (line_size+3) / 4 * 4;
if (ysize > 0) {
- y = ysize-1;
+ starty = ysize-1;
lasty = -1;
yinc = -1;
}
else {
/* when ysize is -ve it's a top-down image */
ysize = -ysize;
- y = 0;
+ starty = 0;
lasty = ysize;
yinc = 1;
}
+ y = starty;
if (!clr_used)
clr_used = 16;
if (ig->readcb(ig, packed, line_size) != line_size) {
myfree(packed);
myfree(line);
- i_push_error(0, "failed reading 4-bit bmp data");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
+ return im;
+ }
+ else {
+ i_push_error(0, "failed reading 4-bit bmp data");
+ i_img_destroy(im);
+ return NULL;
+ }
}
in = packed;
p = line;
if (ig->readcb(ig, packed, 2) != 2) {
myfree(packed);
myfree(line);
- i_push_error(0, "missing data during decompression");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
+ return im;
+ }
+ else {
+ i_push_error(0, "missing data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
}
else if (packed[0]) {
+ if (x + packed[0] > xsize) {
+ /* this file is corrupt */
+ myfree(packed);
+ myfree(line);
+ i_push_error(0, "invalid data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
line[0] = packed[1] >> 4;
line[1] = packed[1] & 0x0F;
for (i = 0; i < packed[0]; i += 2) {
if (ig->readcb(ig, packed, 2) != 2) {
myfree(packed);
myfree(line);
- i_push_error(0, "missing data during decompression");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
+ return im;
+ }
+ else {
+ i_push_error(0, "missing data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
}
x += packed[0];
y += yinc * packed[1];
default:
count = packed[1];
+ if (x + count > xsize) {
+ /* this file is corrupt */
+ myfree(packed);
+ myfree(line);
+ i_push_error(0, "invalid data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
size = (count + 1) / 2;
read_size = (size+1) / 2 * 2;
if (ig->readcb(ig, packed, read_size) != read_size) {
myfree(packed);
myfree(line);
- i_push_error(0, "missing data during decompression");
- /*i_img_destroy(im);*/
- return im;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
+ return im;
+ }
+ else {
+ i_push_error(0, "missing data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
}
for (i = 0; i < size; ++i) {
line[0] = packed[i] >> 4;
}
/*
-=item read_8bit_bmp(ig, xsize, ysize, clr_used, compression)
+=item read_8bit_bmp(ig, xsize, ysize, clr_used, compression, allow_incomplete)
Reads in the palette and image data for a 8-bit/pixel image.
*/
static i_img *
read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
- int compression, long offbits) {
+ int compression, long offbits, int allow_incomplete) {
i_img *im;
- int x, y, lasty, yinc;
+ int x, y, lasty, yinc, start_y;
i_palidx *line;
int line_size = xsize;
long base_offset;
}
if (ysize > 0) {
- y = ysize-1;
+ start_y = ysize-1;
lasty = -1;
yinc = -1;
}
else {
/* when ysize is -ve it's a top-down image */
ysize = -ysize;
- y = 0;
+ start_y = 0;
lasty = ysize;
yinc = 1;
}
+ y = start_y;
if (!clr_used)
clr_used = 256;
if (clr_used > 256 || clr_used < 0) {
while (y != lasty) {
if (ig->readcb(ig, line, line_size) != line_size) {
myfree(line);
- i_push_error(0, "failed reading 8-bit bmp data");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(start_y - y));
+ return im;
+ }
+ else {
+ i_push_error(0, "failed reading 8-bit bmp data");
+ i_img_destroy(im);
+ return NULL;
+ }
}
i_ppal(im, 0, xsize, y, line);
y += yinc;
/* there's always at least 2 bytes in a sequence */
if (ig->readcb(ig, packed, 2) != 2) {
myfree(line);
- i_push_error(0, "missing data during decompression");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(start_y-y));
+ return im;
+ }
+ else {
+ i_push_error(0, "missing data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
}
if (packed[0]) {
+ if (x + packed[0] > xsize) {
+ /* this file isn't incomplete, it's corrupt */
+ myfree(line);
+ i_push_error(0, "invalid data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
memset(line, packed[1], packed[0]);
i_ppal(im, x, x+packed[0], y, line);
x += packed[0];
case BMPRLE_DELTA:
if (ig->readcb(ig, packed, 2) != 2) {
myfree(line);
- i_push_error(0, "missing data during decompression");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(start_y-y));
+ return im;
+ }
+ else {
+ i_push_error(0, "missing data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
}
x += packed[0];
y += yinc * packed[1];
default:
count = packed[1];
+ if (x + count > xsize) {
+ /* runs shouldn't cross a line boundary */
+ /* this file isn't incomplete, it's corrupt */
+ myfree(line);
+ i_push_error(0, "invalid data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
read_size = (count+1) / 2 * 2;
if (ig->readcb(ig, line, read_size) != read_size) {
myfree(line);
- i_push_error(0, "missing data during decompression");
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(start_y-y));
+ return im;
+ }
+ else {
+ i_push_error(0, "missing data during decompression");
+ i_img_destroy(im);
+ return NULL;
+ }
}
i_ppal(im, x, x+count, y, line);
x += count;
};
/*
-=item read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression)
+=item read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression, allow_incomplete)
Skips the palette and reads in the image data for a direct colour image.
*/
static i_img *
read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
- int clr_used, int compression, long offbits) {
+ int clr_used, int compression, long offbits,
+ int allow_incomplete) {
i_img *im;
- int x, y, lasty, yinc;
+ int x, y, starty, lasty, yinc;
i_color *line, *p;
int pix_size = bit_count / 8;
int line_size = xsize * pix_size;
extras = line_size - xsize * pix_size;
if (ysize > 0) {
- y = ysize-1;
+ starty = ysize-1;
lasty = -1;
yinc = -1;
}
else {
/* when ysize is -ve it's a top-down image */
ysize = -ysize;
- y = 0;
+ starty = 0;
lasty = ysize;
yinc = 1;
}
+ y = starty;
if (compression == BI_RGB) {
compression_name = "BI_RGB";
masks = std_masks[pix_size-2];
return NULL;
}
+ if (offbits < base_offset) {
+ i_push_errorf(0, "image data offset too small (%ld)", offbits);
+ return NULL;
+ }
+
if (offbits > base_offset) {
/* this will be slow if the offset is large, but that should be
rare */
for (x = 0; x < xsize; ++x) {
unsigned pixel;
if (!read_packed(ig, unpack_code, &pixel)) {
- i_push_error(0, "failed reading image data");
myfree(line);
- i_img_destroy(im);
- return NULL;
+ if (allow_incomplete) {
+ i_tags_setn(&im->tags, "i_incomplete", 1);
+ i_tags_setn(&im->tags, "i_lines_read", abs(starty - y));
+ return im;
+ }
+ else {
+ i_push_error(0, "failed reading image data");
+ i_img_destroy(im);
+ return NULL;
+ }
}
for (i = 0; i < 3; ++i) {
if (masks.shifts[i] > 0)
projects / imager.git / blobdiff