- set i_format to jpeg for jpeg files and test for it
- set i_format to png when reading png files and test for it
- i_yres was being set to the xres when reading a png file
+- added many bad BMP files to test various code paths in bmp.c, and
+ made many minor fixes to bmp.c to make them work:
+ - it was possible for various types of read failures to SEGV, both
+ as NULL pointer dereferences and buffer overflows
+ - some errors, like palettes being too large for the number of bits
+ per pixel, were not being caught
+ - failing to read all of a packed data structure would not cause
+ a read failure
+ - invalid compression types were not always caught
+ - error messages are more consistent (still not always great messages,
+ but one step at a time)
+- added bmp_compression_name, bmp_used_colors, bmp_filesize, bmp_bit_count
+ tags on reading a BMP file
=================================================================
Imager.pm
Imager.xs
MANIFEST
-README
Makefile.PL
+README
+bigtest.perl Library selection tester
bmp.c Reading and writing Windows BMP files
-tga.c Reading and writing Targa files
-rgb.c Reading and writing SGI rgb files
color.c Color translation and handling
conv.c
convert.c
+datatypes.c
+datatypes.h
+doco.perl
draw.c
-polygon.c
draw.h
-fills.c Generic fills
-map.c
+dynaload.c
+dynaload.h
+dynfilt/Makefile.PL
+dynfilt/compile.txt
+dynfilt/dt2.c
+dynfilt/dt2.exp
+dynfilt/dyntest.c
+dynfilt/dyntest.exp
+dynfilt/flines.c
+dynfilt/flines.exp
+dynfilt/mandelbrot.c
+dynfilt/mandelbrot.exp
+dynfilt/pluginst.h
+errep.perl
error.c
-gaussian.c
-ppport.h
-image.c
-image.h
-imagei.h
-datatypes.h
-datatypes.c
+ext.h
+feat.c
feat.h
-img16.c
-imgdouble.c Implements double/sample images
-io.c
-imio.h
-log.c
-log.h
-jpeg.c
-png.c
-gif.c
-tiff.c
-quant.c
-raw.c
-pnm.c
+fills.c Generic fills
+filterlist.perl
filters.c
-feat.c
font.c
-freetyp2.c Implements freetype2 font support
-maskimg.c
-palimg.c
-regmach.c
-regmach.h
-rotate.c
-stackmach.c
-stackmach.h
-tags.c
-trans2.c
-iolayer.h
-iolayer.c
fontfiles/ExistenceTest.afm please edit ExistenceTest.sfd in CVS
fontfiles/ExistenceTest.pfb to change these files, edited and
fontfiles/ExistenceTest.ttf generated using pfaedit
fontfiles/dcr10.afm
fontfiles/dcr10.pfb
fontfiles/dodge.ttf
+freetyp2.c Implements freetype2 font support
+gaussian.c
+gif.c
+image.c
+image.h
+imagei.h
+img16.c
+imgdouble.c Implements double/sample images
+imio.h
+io.c
+iolayer.c
+iolayer.h
+jpeg.c
lib/Imager/Color.pm
lib/Imager/Color/Float.pm
lib/Imager/Color/Table.pm
+lib/Imager/Draw.pod
+lib/Imager/Engines.pod
lib/Imager/Expr.pm
lib/Imager/Expr/Assem.pm
lib/Imager/Files.pod
-lib/Imager/Draw.pod
-lib/Imager/Transformations.pod
-lib/Imager/ImageTypes.pod
-lib/Imager/Filters.pod
-lib/Imager/Engines.pod
lib/Imager/Fill.pm
+lib/Imager/Filters.pod
lib/Imager/Font.pm
lib/Imager/Font/BBox.pm
-lib/Imager/Font/Type1.pm
-lib/Imager/Font/Truetype.pm
lib/Imager/Font/FreeType2.pm
+lib/Imager/Font/Image.pm
+lib/Imager/Font/Truetype.pm
+lib/Imager/Font/Type1.pm
lib/Imager/Font/Win32.pm
lib/Imager/Font/Wrap.pm
-lib/Imager/Font/Image.pm
lib/Imager/Fountain.pm
-lib/Imager/interface.pod
+lib/Imager/ImageTypes.pod
lib/Imager/Matrix2d.pm
-lib/Imager/regmach.pod
lib/Imager/Regops.pm
lib/Imager/Transform.pm
-t/testtools.pl
+lib/Imager/Transformations.pod
+lib/Imager/interface.pod
+lib/Imager/regmach.pod
+log.c
+log.h
+map.c
+maskimg.c
+palimg.c
+plug.h
+png.c
+pnm.c
+polygon.c
+ppport.h
+quant.c
+raw.c
+regmach.c
+regmach.h
+regops.perl
+rgb.c Reading and writing SGI rgb files
+rotate.c
+spot.perl For making an ordered dither matrix from a spot function
+stackmach.c
+stackmach.h
t/t00basic.t
t/t01introvert.t
t/t020masked.t
t/t75polyaa.t
t/t80texttools.t Test text wrapping
t/t90cc.t
+t/testtools.pl
+tags.c
+testimg/bad1oflow.bmp 1-bit/pixel, overflow integer on 32-bit machines
+testimg/bad1wid0.bmp 1-bit/pixel, zero width
+testimg/bad24comp.bmp 24-bit/pixel, bad compression
+testimg/bad24oflow.bmp 24-bit/pixel, overflow integer on 32-bit machines
+testimg/bad24wid0.bmp 24-bit/pixel, 0 width
+testimg/bad4oflow.bmp 4-bit/pixel, overflow integer on 32-bit machines
+testimg/bad4wid0.bmp 4-bit/pixel, 0 width
+testimg/bad4widbig.bmp 4-bit/pixel, large width
+testimg/bad8comp.bmp 8-bit/pixel, bad compression
+testimg/bad8oflow.bmp 8-bit/pixel, overflow integer on 32-bit machines
+testimg/bad8useda.bmp 8-bit/pixel, bad colors used value
+testimg/bad8wid0.bmp 8-bit/pixel, width 0
+testimg/badbits.bmp bad bits value in header
+testimg/badcomp1.bmp bad compression for 1-bit/pixel
+testimg/badcomp4.bmp bad compression for 4-bit/pixel
+testimg/badplanes.bmp bad planes value in header
+testimg/badused1.bmp 1-bit/pixel, out of range colors used value
+testimg/badused4a.bmp 4-bit/pixel, badly out of range used value (SEGV test)
+testimg/badused4b.bmp 4-bit/pixel, just out of range used value (SEGV test)
testimg/bandw.gif
testimg/comp4.bmp Compressed 4-bit/pixel BMP
testimg/comp4.tif 4-bit/pixel paletted TIFF
testimg/scalei.gif
testimg/screen2.gif
testimg/screen3.gif
+testimg/short1.bmp 1-bit/pixel, data missing from EOF
+testimg/short24.bmp 24-bit/pixel, data missing from EOF
+testimg/short4.bmp truncated 4bit/pixel uncompressed BMP
+testimg/short4rle.bmp truncated 4bit/pixel compressed BMP
+testimg/short8.bmp 8-bit/pixel, data missing from EOF
+testimg/short8rle.bmp 8-bit/pixel compressed, data missing from EOF
testimg/simple.pbm
testimg/test_gimp_pal A simple GIMP palette file
testimg/trimgdesc.gif
testimg/trmiddesc.gif
-typemap
-dynaload.c
-dynaload.h
-ext.h
-plug.h
-filterlist.perl
-doco.perl
-errep.perl
-regops.perl
-spot.perl For making an ordered dither matrix from a spot function
+tga.c Reading and writing Targa files
+tiff.c
+trans2.c
transform.perl Shell interface to Imager::Transform
-bigtest.perl Library selection tester
-dynfilt/pluginst.h
-dynfilt/dyntest.c
-dynfilt/dyntest.exp
-dynfilt/dt2.c
-dynfilt/dt2.exp
-dynfilt/mandelbrot.c
-dynfilt/mandelbrot.exp
-dynfilt/flines.c
-dynfilt/flines.exp
-dynfilt/compile.txt
-dynfilt/Makefile.PL
+typemap
win32.c Implements font support through Win32 GDI
static int write_8bit_data(io_glue *ig, i_img *im);
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);
+static i_img *read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
+ int compression);
static i_img *read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
int compression);
static i_img *read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
i_img *
i_readbmp_wiol(io_glue *ig) {
- int b_magic, m_magic, filesize, dummy, infohead_size;
+ 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;
i_img *im;
+
+ mm_log((1, "i_readbmp_wiol(ig %p)\n", ig));
io_glue_commit_types(ig);
i_clear_error();
if (!read_packed(ig, "CCVvvVVVVvvVVVVVV", &b_magic, &m_magic, &filesize,
- &dummy, &dummy, &offbits, &infohead_size,
+ &res1, &res2, &offbits, &infohead_size,
&xsize, &ysize, &planes,
&bit_count, &compression, &size_image, &xres, &yres,
&clr_used, &clr_important)) {
i_push_error(0, "not a BMP file");
return 0;
}
+
+ mm_log((1, " bmp header: filesize %d offbits %d xsize %d ysize %d planes %d "
+ "bit_count %d compression %d size %d xres %d yres %d clr_used %d "
+ "clr_important %d\n", filesize, offbits, xsize, ysize, planes,
+ bit_count, compression, size_image, xres, yres, clr_used,
+ clr_important));
switch (bit_count) {
case 1:
- im = read_1bit_bmp(ig, xsize, ysize, clr_used);
+ im = read_1bit_bmp(ig, xsize, ysize, clr_used, compression);
break;
case 4:
return NULL;
}
- /* store the resolution */
- if (xres && !yres)
- yres = xres;
- else if (yres && !xres)
- xres = yres;
- if (xres) {
- i_tags_set_float(&im->tags, "i_xres", 0, xres * 0.0254);
- i_tags_set_float(&im->tags, "i_yres", 0, yres * 0.0254);
+ if (im) {
+ /* store the resolution */
+ if (xres && !yres)
+ yres = xres;
+ else if (yres && !xres)
+ xres = yres;
+ if (xres) {
+ i_tags_set_float(&im->tags, "i_xres", 0, xres * 0.0254);
+ i_tags_set_float(&im->tags, "i_yres", 0, yres * 0.0254);
+ }
+ i_tags_addn(&im->tags, "bmp_compression", 0, compression);
+ i_tags_addn(&im->tags, "bmp_important_colors", 0, clr_important);
+ i_tags_addn(&im->tags, "bmp_used_colors", 0, clr_used);
+ i_tags_addn(&im->tags, "bmp_filesize", 0, filesize);
+ i_tags_addn(&im->tags, "bmp_bit_count", 0, bit_count);
+ i_tags_add(&im->tags, "i_format", 0, "bmp", 3, 0);
}
- i_tags_addn(&im->tags, "bmp_compression", 0, compression);
- i_tags_addn(&im->tags, "bmp_important_colors", 0, clr_important);
return im;
}
switch (*format) {
case 'v':
- if (ig->readcb(ig, buf, 2) == -1)
+ if (ig->readcb(ig, buf, 2) != 2)
return 0;
*p = buf[0] + (buf[1] << 8);
break;
case 'V':
- if (ig->readcb(ig, buf, 4) == -1)
+ if (ig->readcb(ig, buf, 4) != 4)
return 0;
*p = buf[0] + (buf[1] << 8) + (buf[2] << 16) + (buf[3] << 24);
break;
case 'C':
- if (ig->readcb(ig, buf, 1) == -1)
+ if (ig->readcb(ig, buf, 1) != 1)
return 0;
*p = buf[0];
break;
case 'c':
- if (ig->readcb(ig, buf, 1) == -1)
+ if (ig->readcb(ig, buf, 1) != 1)
return 0;
*p = (char)buf[0];
break;
case '3': /* extension - 24-bit number */
- if (ig->readcb(ig, buf, 3) == -1)
+ if (ig->readcb(ig, buf, 3) != 3)
return 0;
*p = buf[0] + (buf[1] << 8) + (buf[2] << 16);
break;
c.channel[0] = r;
c.channel[1] = g;
c.channel[2] = b;
- if (i_addcolors(im, &c, 1) < 0)
+ if (i_addcolors(im, &c, 1) < 0) {
+ i_push_error(0, "out of space in image palette");
return 0;
+ }
}
return 1;
=cut
*/
static i_img *
-read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used) {
+read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
+ int compression) {
i_img *im;
int x, y, lasty, yinc;
i_palidx *line, *p;
int byte, bit;
unsigned char *in;
+ if (compression != BI_RGB) {
+ i_push_errorf(0, "unknown 1-bit BMP compression (%d)", compression);
+ return NULL;
+ }
+
line_size = (line_size+3) / 4 * 4;
if (ysize > 0) {
lasty = ysize;
yinc = 1;
}
- im = i_img_pal_new(xsize, ysize, 3, 256);
if (!clr_used)
clr_used = 2;
+ if (clr_used < 0 || clr_used > 2) {
+ i_push_errorf(0, "out of range colors used (%d)", clr_used);
+ return NULL;
+ }
+ im = i_img_pal_new(xsize, ysize, 3, 256);
+ if (!im)
+ return NULL;
if (!read_bmp_pal(ig, im, clr_used)) {
i_img_destroy(im);
return NULL;
}
+
+ i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
packed = mymalloc(line_size);
line = mymalloc(xsize+8);
if (ig->readcb(ig, packed, line_size) != line_size) {
myfree(packed);
myfree(line);
- i_push_error(0, "reading 1-bit bmp data");
+ i_push_error(0, "failed reading 1-bit bmp data");
i_img_destroy(im);
return NULL;
}
lasty = ysize;
yinc = 1;
}
- im = i_img_pal_new(xsize, ysize, 3, 256);
if (!clr_used)
clr_used = 16;
+
+ if (clr_used > 16 || clr_used < 0) {
+ i_push_errorf(0, "out of range colors used (%d)", clr_used);
+ return NULL;
+ }
+
+ im = i_img_pal_new(xsize, ysize, 3, 256);
+ if (!im) /* error should have been pushed already */
+ return NULL;
if (!read_bmp_pal(ig, im, clr_used)) {
i_img_destroy(im);
return NULL;
packed = mymalloc(line_size);
line = mymalloc(xsize+1);
if (compression == BI_RGB) {
+ i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
while (y != lasty) {
if (ig->readcb(ig, packed, line_size) != line_size) {
myfree(packed);
myfree(line);
- i_push_error(0, "reading 4-bit bmp data");
+ i_push_error(0, "failed reading 4-bit bmp data");
i_img_destroy(im);
return NULL;
}
int want_high;
int count;
+ i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE4", -1, 0);
x = 0;
while (1) {
/* there's always at least 2 bytes in a sequence */
else { /*if (compression == BI_RLE4) {*/
myfree(packed);
myfree(line);
- i_push_error(0, "bad compression for 4-bit image");
+ i_push_errorf(0, "unknown 4-bit BMP compression (%d)", compression);
i_img_destroy(im);
return NULL;
}
lasty = ysize;
yinc = 1;
}
- im = i_img_pal_new(xsize, ysize, 3, 256);
if (!clr_used)
clr_used = 256;
+ if (clr_used > 256 || clr_used < 0) {
+ i_push_errorf(0, "out of range colors used (%d)", clr_used);
+ return NULL;
+ }
+
+ im = i_img_pal_new(xsize, ysize, 3, 256);
+ if (!im)
+ return NULL;
if (!read_bmp_pal(ig, im, clr_used)) {
i_img_destroy(im);
return NULL;
line = mymalloc(line_size);
if (compression == BI_RGB) {
+ i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
while (y != lasty) {
if (ig->readcb(ig, line, line_size) != line_size) {
myfree(line);
- i_push_error(0, "reading 8-bit bmp data");
+ i_push_error(0, "failed reading 8-bit bmp data");
i_img_destroy(im);
return NULL;
}
int count;
unsigned char packed[2];
+ i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE8", -1, 0);
x = 0;
while (1) {
/* there's always at least 2 bytes in a sequence */
}
else {
myfree(line);
- i_push_errorf(0, "unknown 8-bit BMP compression %d", compression);
+ i_push_errorf(0, "unknown 8-bit BMP compression (%d)", compression);
i_img_destroy(im);
return NULL;
}
int i;
int extras;
char junk[4];
+ const char *compression_name;
+ int bytes;
unpack_code[0] = *("v3V"+pix_size-2);
unpack_code[1] = '\0';
yinc = 1;
}
if (compression == BI_RGB) {
+ compression_name = "BI_RGB";
masks = std_masks[pix_size-2];
/* there's a potential "palette" after the header */
}
else if (compression == BI_BITFIELDS) {
int pos, bit;
+ compression_name = "BI_BITFIELDS";
+
for (i = 0; i < 3; ++i) {
if (!read_packed(ig, "V", masks.masks+i)) {
i_push_error(0, "reading pixel masks");
masks.shifts[i] = pos - 8;
}
}
+ else {
+ i_push_errorf(0, "unknown 24-bit BMP compression (%d)", compression);
+ return NULL;
+ }
im = i_img_empty(NULL, xsize, ysize);
+ if (!im)
+ return NULL;
- line = mymalloc(sizeof(i_color) * xsize);
+ i_tags_add(&im->tags, "bmp_compression_name", 0, compression_name, -1, 0);
+
+ /* I wasn't able to make this overflow in testing, but better to be
+ safe */
+ bytes = sizeof(i_color) * xsize;
+ if (bytes / sizeof(i_color) != xsize) {
+ i_img_destroy(im);
+ i_push_error(0, "integer overflow calculating buffer size");
+ return NULL;
+ }
+ line = mymalloc(bytes);
while (y != lasty) {
p = line;
for (x = 0; x < xsize; ++x) {
unsigned pixel;
if (!read_packed(ig, unpack_code, &pixel)) {
- i_push_error(0, "reading image data");
+ i_push_error(0, "failed reading image data");
myfree(line);
i_img_destroy(im);
return NULL;
=back
+=item bmp_compression_name
+
+The bmp_compression value as a BI_* string
+
=item bmp_important_colors
The number of important colors as defined by the writer of the image.
+=item bmp_used_colors
+
+Number of color used from the BMP header
+
+=item bmp_filesize
+
+The file size from the BMP header
+
+=item bmp_bit_count
+
+Number of bits stored per pixel. (24, 8, 4 or 1)
+
=back
=head2 TGA (TarGA)
#!perl -w
-print "1..12\n";
+print "1..62\n";
use Imager qw(:all);
use strict;
init_log("testout/t107bmp.log",1);
+require 't/testtools.pl';
my $base_diff = 0;
# if you change this make sure you generate new compressed versions
my $bi_rle8 = 1;
my $bi_rle4 = 2;
my $bi_bitfields = 3;
-read_test(5, "testout/t107_24bit.bmp", $img, bmp_compression=>0);
-read_test(6, "testout/t107_8bit.bmp", $im8, bmp_compression=>0);
-read_test(7, "testout/t107_4bit.bmp", $im4, bmp_compression=>0);
-read_test(8, "testout/t107_1bit.bmp", $im1, bmp_compression=>0);
+read_test(5, "testout/t107_24bit.bmp", $img,
+ bmp_compression=>0, bmp_bit_count => 24);
+read_test(6, "testout/t107_8bit.bmp", $im8,
+ bmp_compression=>0, bmp_bit_count => 8);
+read_test(7, "testout/t107_4bit.bmp", $im4,
+ bmp_compression=>0, bmp_bit_count => 4);
+read_test(8, "testout/t107_1bit.bmp", $im1, bmp_compression=>0,
+ bmp_bit_count=>1);
# the following might have slight differences
$base_diff = i_img_diff($img, $im8) * 2;
print "# base difference $base_diff\n";
-read_test(9, "testimg/comp4.bmp", $im4, bmp_compression=>$bi_rle4);
-read_test(10, "testimg/comp8.bmp", $im8, bmp_compression=>$bi_rle8);
+read_test(9, "testimg/comp4.bmp", $im4,
+ bmp_compression=>$bi_rle4, bmp_bit_count => 4);
+read_test(10, "testimg/comp8.bmp", $im8,
+ bmp_compression=>$bi_rle8, bmp_bit_count => 8);
my $imoo = Imager->new;
if ($imoo->read(file=>'testout/t107_24bit.bmp')) {
print "not 12 # ",$imoo->errstr,"\n";
}
+# various invalid format tests
+# we have so many different test images to try to detect all the possible
+# failure paths in the code, adding these did detect real problems
+print "# catch various types of invalid bmp files\n";
+my $test_num = 13;
+my @tests =
+ (
+ # entries in each array ref are:
+ # - basename of an invalid BMP file
+ # - error message that should be produced
+ # - description of what is being tested
+ # - possible flag to indicate testing only on 32-bit machines
+ [ 'badplanes.bmp', 'not a BMP file', "invalid planes value" ],
+ [ 'badbits.bmp', 'unknown bit count for BMP file (5)',
+ 'should fail to read invalid bits' ],
+
+ # 1-bit/pixel BMPs
+ [ 'badused1.bmp', 'out of range colors used (3)',
+ 'out of range palette size (1-bit)' ],
+ [ 'badcomp1.bmp', 'unknown 1-bit BMP compression (1)',
+ 'invalid compression value (1-bit)' ],
+ [ 'bad1wid0.bmp', 'Image sizes must be positive',
+ 'width 0 (1-bit)' ],
+ [ 'bad4oflow.bmp', 'integer overflow calculating image allocation',
+ 'overflow integers on 32-bit machines (1-bit)', '32bitonly' ],
+ [ 'short1.bmp', 'failed reading 1-bit bmp data',
+ 'short 1-bit' ],
+
+ # 4-bit/pixel BMPs
+ [ 'badused4a.bmp', 'out of range colors used (272)',
+ 'should fail to read invalid pal size (272) (4-bit)' ],
+ [ 'badused4b.bmp', 'out of range colors used (17)',
+ 'should fail to read invalid pal size (17) (4-bit)' ],
+ [ 'badcomp4.bmp', 'unknown 4-bit BMP compression (1)',
+ 'invalid compression value (4-bit)' ],
+ [ 'short4.bmp', 'failed reading 4-bit bmp data',
+ 'short uncompressed 4-bit' ],
+ [ 'short4rle.bmp', 'missing data during decompression',
+ 'short compressed 4-bit' ],
+ [ 'bad4wid0.bmp', 'Image sizes must be positive',
+ 'width 0 (4-bit)' ],
+ [ 'bad4widbig.bmp', 'Image sizes must be positive',
+ 'width big (4-bit)' ],
+ [ 'bad4oflow.bmp', 'integer overflow calculating image allocation',
+ 'overflow integers on 32-bit machines (4-bit)', '32bitonly' ],
+
+ # 8-bit/pixel BMPs
+ [ 'bad8useda.bmp', 'out of range colors used (257)',
+ 'should fail to read invalid pal size (8-bit)' ],
+ [ 'bad8comp.bmp', 'unknown 8-bit BMP compression (2)',
+ 'invalid compression value (8-bit)' ],
+ [ 'short8.bmp', 'failed reading 8-bit bmp data',
+ 'short uncompressed 8-bit' ],
+ [ 'short8rle.bmp', 'missing data during decompression',
+ 'short compressed 8-bit' ],
+ [ 'bad8wid0.bmp', 'Image sizes must be positive',
+ 'width 0 (8-bit)' ],
+ [ 'bad8oflow.bmp', 'integer overflow calculating image allocation',
+ 'overflow integers on 32-bit machines (8-bit)', '32bitonly' ],
+
+ # 24-bit/pixel BMPs
+ [ 'short24.bmp', 'failed reading image data',
+ 'short 24-bit' ],
+ [ 'bad24wid0.bmp', 'Image sizes must be positive',
+ 'width 0 (24-bit)' ],
+ [ 'bad24oflow.bmp', 'integer overflow calculating image allocation',
+ 'overflow integers on 32-bit machines (24-bit)', '32bitonly' ],
+ [ 'bad24comp.bmp', 'unknown 24-bit BMP compression (4)',
+ 'bad compression (24-bit)' ],
+ );
+use Config;
+my $intsize = $Config{intsize};
+for my $test (@tests) {
+ my ($file, $error, $comment, $bit32only) = @$test;
+ if (!$bit32only || $intsize == 4) {
+ okn($test_num++, !$imoo->read(file=>"testimg/$file"), $comment);
+ isn($test_num++, $imoo->errstr, $error, "check error message");
+ }
+ else {
+ skipn($test_num, 2, "only tested on 32-bit machines");
+ $test_num += 2;
+ }
+}
+
sub write_test {
my ($test_num, $im, $filename) = @_;
local *FH;
sub read_test {
my ($test_num, $filename, $im, %tags) = @_;
local *FH;
+
+ print "# read_test: $filename\n";
+
+ $tags{i_format} = "bmp";
if (open FH, "< $filename") {
binmode FH;
for my $tag (keys %tags) {
if (my $index = Imager::i_tags_find($im_read, $tag, 0)) {
my ($name, $value) = Imager::i_tags_get($im_read, $index);
- if ($value != $tags{$tag}) {
- print "# tag $tag value mismatch $tags{$tag} != $value\n";
- $tags_ok = 0;
+ my $exp_value = $tags{$tag};
+ print "# tag $name = '$value' - expect '$exp_value'\n";
+ if ($exp_value =~ /\d/) {
+ if ($value != $tags{$tag}) {
+ print "# tag $tag value mismatch $tags{$tag} != $value\n";
+ $tags_ok = 0;
+ }
+ }
+ else {
+ if ($value ne $tags{$tag}) {
+ print "# tag $tag value mismatch $tags{$tag} != $value\n";
+ $tags_ok = 0;
+ }
}
}
}
projects / imager.git / commitdiff