/* bmpread.c reads any bitmap I could get for testing */
/* Alexander.Schulz@stud.uni-karlsruhe.de */
/*
* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
* ----------------------------------------------------------------------------
*/
#include "config.h"
#include
#include
#include
#include
#include "bmp.h"
#include "bmp-load.h"
#include "libgimp/stdplugins-intl.h"
/* huffman.h is auto-generated by generate-huffman.c
* and defines:
* - blackroot
* - whiteroot
* - nodebuffer[]
* (look for it in the build directory)
*/
struct Huffnode
{
signed short left;
signed short right;
unsigned short value : 13;
unsigned short leaf : 1;
unsigned short makeup : 1;
};
#include "huffman.h"
enum Bmpformat
{
BMPFMT_RGB,
BMPFMT_RGB_64,
BMPFMT_INDEXED,
BMPFMT_RLE,
BMPFMT_HUFFMAN
};
struct Fileinfo
{
FILE *file;
gint width;
gint height;
guchar *rowbuf;
guint64 bytes_per_row;
gint bpp;
gint channels;
gint bytesperchannel;
gint ncolors;
guchar colormap[3 * 256];
gboolean gray;
BitmapChannel masks[4];
gint tile_height;
gint tile_n;
/* RLE state */
gint xpos;
gint file_ypos;
gboolean needs_alpha;
/* Huffman state */
guint32 bitbuf;
gint buflen;
gint black;
};
static GimpImage * ReadImage (struct Fileinfo *fi,
GFile *gfile,
gint compression,
GError **error);
static gint load_rgb_64 (struct Fileinfo *fi,
guchar *dest);
static gint load_rgb (struct Fileinfo *fi,
guchar *dest);
static gint load_indexed (struct Fileinfo *fi,
guchar *dest);
static gint load_rle (struct Fileinfo *fi,
guchar *dest);
static gint load_huffman (struct Fileinfo *fi,
guchar *dest);
static gint huff_decode (guint32 *bitbuf,
gint *buflen,
FILE *file,
gint black);
static gint huff_findnode (guint32 bitbuf,
gint buflen,
gint black,
gint *found);
static void huff_fillbuf (guint32 *bitbuf,
gint *buflen,
FILE *file);
static gint huff_find_eol (guint32 *bitbuf,
gint *buflen,
FILE *file);
static gint huff_skip_eol (guint32 *bitbuf,
gint *buflen,
FILE *file);
static gint32
ToL (const guchar *buffer)
{
return (buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
}
static guint32
ToLn (const guchar *buffer, gint n)
{
gint i;
guint32 result = 0;
for (i = 0; i < n; i++)
{
result |= ((guint32) buffer[i]) << (8 * i);
}
return result;
}
static gint16
ToS (const guchar *buffer)
{
return (buffer[0] | buffer[1] << 8);
}
static gboolean
read_colormap (FILE *fd,
guchar *buffer,
gint number,
gint size,
gboolean *gray)
{
gint i;
*gray = (number > 2);
for (i = 0; i < number ; i++)
{
guchar rgb[4];
if (! ReadOK (fd, rgb, size))
{
g_message (_("Bad colormap"));
return FALSE;
}
/* BMP colormap entries are in BGR order */
buffer[3 * i + 0] = rgb[2];
buffer[3 * i + 1] = rgb[1];
buffer[3 * i + 2] = rgb[0];
*gray = ((*gray) && (rgb[0] == rgb[1]) && (rgb[1] == rgb[2]));
}
return TRUE;
}
static void
set_default_masks (gushort biBitCnt,
BitmapChannel *masks)
{
switch (biBitCnt)
{
case 24:
case 32:
masks[0].mask = 0x00ff0000;
masks[1].mask = 0x0000ff00;
masks[2].mask = 0x000000ff;
masks[3].mask = 0x00000000;
break;
case 16:
/* 5 bits per channel */
masks[0].mask = 0x00007c00;
masks[1].mask = 0x000003e0;
masks[2].mask = 0x0000001f;
masks[3].mask = 0x00000000;
break;
default:
break;
}
}
static void
read_masks (guint32 *tmp,
BitmapChannel *masks)
{
gint i;
for (i = 0; i < 4; i++)
{
masks[i].mask = tmp[i];
}
}
static void
digest_masks (BitmapChannel *masks)
{
gint i;
for (i = 0; i < 4; i++)
{
guint32 mask = masks[i].mask;
gint nbits = 0;
gint offset = 0;
while (mask && ! (mask & 1))
{
mask >>= 1;
offset++;
}
while (mask)
{
mask >>= 1;
nbits++;
}
masks[i].shiftin = offset;
masks[i].max_value = (gfloat) ((1 << nbits) - 1);
masks[i].nbits = nbits;
}
}
GimpImage *
load_image (GFile *gfile, GError **error)
{
struct Fileinfo fi;
BitmapFileHead bitmap_file_head;
BitmapHead bitmap_head;
guchar buffer[124];
gint maxcolors;
gint colorsize;
GimpImage *image = NULL;
gchar magick[2];
gimp_progress_init_printf (_("Opening '%s'"), gimp_file_get_utf8_name (gfile));
memset (&fi, 0, sizeof fi);
memset (&bitmap_file_head, 0, sizeof bitmap_file_head);
memset (&bitmap_head, 0, sizeof bitmap_head);
fi.file = g_fopen (g_file_peek_path (gfile), "rb");
if (! fi.file)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for reading: %s"),
gimp_file_get_utf8_name (gfile), g_strerror (errno));
goto out;
}
if (! ReadOK (fi.file, magick, 2) ||
! (! strncmp (magick, "BA", 2) ||
! strncmp (magick, "BM", 2) ||
! strncmp (magick, "IC", 2) ||
! strncmp (magick, "PT", 2) ||
! strncmp (magick, "CI", 2) ||
! strncmp (magick, "CP", 2)))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
while (! strncmp (magick, "BA", 2))
{
if (! ReadOK (fi.file, buffer, 12))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"),
gimp_file_get_utf8_name (gfile));
goto out;
}
if (! ReadOK (fi.file, magick, 2))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"),
gimp_file_get_utf8_name (gfile));
goto out;
}
}
if (! ReadOK (fi.file, buffer, 12))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
/* bring them to the right byteorder. */
bitmap_file_head.bfSize = ToL (&buffer[0x00]);
bitmap_file_head.zzHotX = ToS (&buffer[0x04]);
bitmap_file_head.zzHotY = ToS (&buffer[0x06]);
bitmap_file_head.bfOffs = ToL (&buffer[0x08]);
if (ReadOK (fi.file, buffer, 4))
bitmap_head.biSize = ToL (&buffer[0x00]);
if (bitmap_head.biSize < 12)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
memset (buffer, 0, sizeof buffer);
if (! ReadOK (fi.file, buffer + 4, MIN (bitmap_head.biSize, sizeof buffer) - 4))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading BMP file header from '%s'"),
gimp_file_get_utf8_name (gfile));
goto out;
}
/* OS/2 headers store width and height as unsigned, Windows headers as signed.
* We make no attempt to distinguish between those (which would be possible
* in some but not all cases) but always err on the Windows/signed side.
* The only time we'll ever be wrong would be OS/2 1.x files with dimensions
* larger than 32k (1.x files are from an era when 1024x768 was huge!) or
* OS/2 2.x images wider or higher than 2 billion pixels -- which is way
* over GIMP's limit anyway.
*/
if (bitmap_head.biSize == 12)
{
/* BITMAPCOREHEADER and OS21XBITMAPHEADER use 16bit int for
* width and height and have 3-byte color table entries */
colorsize = 3;
bitmap_head.biWidth = ToS (&buffer[4]);
bitmap_head.biHeight = ToS (&buffer[6]);
bitmap_head.biPlanes = ToS (&buffer[8]);
bitmap_head.biBitCnt = ToS (&buffer[10]);
}
else if (bitmap_head.biSize >= 16)
{
/* all others use 32bit ints and have 4-byte color table entries */
colorsize = 4;
/* BITMAPINFOHEADER / OS22XBITMAPHEADER */
bitmap_head.biWidth = ToL (&buffer[4]);
bitmap_head.biHeight = ToL (&buffer[8]);
bitmap_head.biPlanes = ToS (&buffer[12]);
bitmap_head.biBitCnt = ToS (&buffer[14]);
bitmap_head.biCompr = ToL (&buffer[16]);
bitmap_head.biSizeIm = ToL (&buffer[20]);
bitmap_head.biXPels = ToL (&buffer[24]);
bitmap_head.biYPels = ToL (&buffer[28]);
bitmap_head.biClrUsed = ToL (&buffer[32]);
bitmap_head.biClrImp = ToL (&buffer[36]);
/* OS22XBITMAPHEADER might write garbage into mask values, but
* they will be ignored because there is no OS/2 BITFIELDS bmp.
* Likewise for the following V4 fields, which would only be used
* when the header size is larger than any valid OS/2 header.
*/
bitmap_head.masks[0] = ToL (&buffer[40]);
bitmap_head.masks[1] = ToL (&buffer[44]);
bitmap_head.masks[2] = ToL (&buffer[48]);
bitmap_head.masks[3] = ToL (&buffer[52]);
/* the remaining fields (BITMAPV4HEADER/BITMAPV5HEADER) are
* currently not used, but in case color profile support is
* later added, here they are */
/* BITMAPV4HEADER */
bitmap_head.bV4CSType = ToL (&buffer[56]);
for (int i = 0; i < 9; i++)
{
/* endpoints are stored as 2.30 */
bitmap_head.bV4Endpoints[i] = (gdouble) ToL (&buffer[60 + 4 * i]) / 0x40000000UL;
}
/* gamma is stored as 16.16 */
bitmap_head.bV4GammaRed = ToL (&buffer[96]) / 65536.0;
bitmap_head.bV4GammaGreen = ToL (&buffer[100]) / 65536.0;
bitmap_head.bV4GammaBlue = ToL (&buffer[104]) / 65536.0;
/* BITMAPV5HEADER */
bitmap_head.bV5Intent = ToL (&buffer[108]);
bitmap_head.bV5ProfileData = ToL (&buffer[112]);
bitmap_head.bV5ProfileSize = ToL (&buffer[116]);
bitmap_head.bV5Reserved = ToL (&buffer[120]);
if (bitmap_head.biSize > sizeof buffer)
{
/* fast-forward to end of (future) larger headers */
if (fseek (fi.file, bitmap_head.biSize - sizeof buffer, SEEK_CUR))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"),
gimp_file_get_utf8_name (gfile));
goto out;
}
}
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
/* identify OS/2 specific compressions and assign our own values */
if (bitmap_head.biSize <= 64)
{
if (bitmap_head.biCompr == BI_BITFIELDS && bitmap_head.biBitCnt == 1)
{
/* BCA_HUFFMAN1D */
bitmap_head.biCompr = BI_OS2_HUFFMAN;
}
else if (bitmap_head.biCompr == BI_JPEG && bitmap_head.biBitCnt == 24)
{
/* BCA_RLE24 */
bitmap_head.biCompr = BI_OS2_RLE24;
}
}
if (bitmap_head.biSize <= 40 &&
(bitmap_head.biCompr == BI_BITFIELDS || bitmap_head.biCompr == BI_ALPHABITFIELDS))
{
/* BITMAPINFOHEADER stores masks right after (not as part of) header */
gint nmasks;
nmasks = bitmap_head.biCompr == BI_BITFIELDS ? 3 : 4;
if (! ReadOK (fi.file, buffer, nmasks * sizeof (guint32)))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading BMP file header from '%s'"),
gimp_file_get_utf8_name (gfile));
goto out;
}
for (int i = 0; i < nmasks; i++)
{
bitmap_head.masks[i] = ToL (&buffer[4 * i]);
}
}
switch (bitmap_head.biBitCnt)
{
case 1:
case 2:
case 4:
case 8:
switch (bitmap_head.biCompr)
{
case BI_RGB:
case BI_RLE4:
case BI_RLE8:
case BI_OS2_HUFFMAN:
if ((bitmap_head.biCompr == BI_RLE4 && bitmap_head.biBitCnt != 4) ||
(bitmap_head.biCompr == BI_RLE8 && bitmap_head.biBitCnt != 8) ||
(bitmap_head.biCompr == BI_OS2_HUFFMAN && bitmap_head.biBitCnt != 1))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"),
gimp_file_get_utf8_name (gfile));
goto out;
}
maxcolors = (bitmap_file_head.bfOffs - bitmap_head.biSize - 14) / colorsize;
fi.ncolors = bitmap_head.biClrUsed == 0 ? 1 << bitmap_head.biBitCnt
: bitmap_head.biClrUsed;
fi.ncolors = MIN (256, MIN (fi.ncolors, maxcolors));
if (fi.ncolors < 1 ||
! read_colormap (fi.file, fi.colormap, fi.ncolors, colorsize, &fi.gray))
{
if (bitmap_head.biCompr == BI_OS2_HUFFMAN)
{
/* It's unclear whether Huffman files require a color map
* or if they can be implicitly black & white. We'll create
* one if the file didn't contain a color map.
*/
fi.ncolors = 2;
for (int c = 0; c < 3; c++)
{
fi.colormap[0 + c] = 0;
fi.colormap[3 + c] = 255;
}
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"),
gimp_file_get_utf8_name (gfile));
goto out;
}
}
break;
default:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported compression (%u) in BMP file from '%s'"),
bitmap_head.biCompr > 100 ? bitmap_head.biCompr - 100
: bitmap_head.biCompr,
gimp_file_get_utf8_name (gfile));
goto out;
}
break;
case 16:
case 24:
case 32:
switch (bitmap_head.biCompr)
{
case BI_BITFIELDS:
case BI_ALPHABITFIELDS:
read_masks (&bitmap_head.masks[0], fi.masks);
digest_masks (fi.masks);
break;
case BI_RGB:
set_default_masks (bitmap_head.biBitCnt, fi.masks);
digest_masks (fi.masks);
break;
case BI_OS2_RLE24:
if (bitmap_head.biBitCnt != 24)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"),
gimp_file_get_utf8_name (gfile));
goto out;
}
break;
default:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported compression (%u) in BMP file from '%s'"),
bitmap_head.biCompr > 100 ? bitmap_head.biCompr - 100
: bitmap_head.biCompr,
gimp_file_get_utf8_name (gfile));
goto out;
}
break;
case 64:
if (bitmap_head.biCompr != BI_RGB)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported compression (%u) in BMP file from '%s'"),
bitmap_head.biCompr > 100 ? bitmap_head.biCompr - 100
: bitmap_head.biCompr,
gimp_file_get_utf8_name (gfile));
goto out;
}
break;
default:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
/* Sanity checks */
if (bitmap_head.biPlanes != 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
fi.bytes_per_row = (((guint64) bitmap_head.biWidth * bitmap_head.biBitCnt + 31) / 32) * 4;
if (fi.bytes_per_row > G_MAXSIZE || bitmap_head.biWidth > GIMP_MAX_IMAGE_SIZE ||
bitmap_head.biWidth < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported or invalid image width: %d"),
(int) bitmap_head.biWidth);
goto out;
}
if (bitmap_head.biHeight < G_MININT + 1 || /* +1 because |G_MININT| > G_MAXINT. */
ABS (bitmap_head.biHeight) > GIMP_MAX_IMAGE_SIZE || bitmap_head.biHeight == 0)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported or invalid image height: %d"),
(int) bitmap_head.biHeight);
goto out;
}
if (fseek (fi.file, bitmap_file_head.bfOffs, SEEK_SET))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s' is not a valid BMP file"), gimp_file_get_utf8_name (gfile));
goto out;
}
fi.width = bitmap_head.biWidth;
fi.height = ABS (bitmap_head.biHeight);
fi.bpp = bitmap_head.biBitCnt;
image = ReadImage (&fi, gfile, bitmap_head.biCompr, error);
if (! image)
goto out;
if (bitmap_head.biXPels > 0 &&
bitmap_head.biYPels > 0)
{
/* Fixed up from scott@asofyet's changes last year, njl195 */
gdouble xresolution;
gdouble yresolution;
/* I don't agree with scott's feeling that Gimp should be trying
* to "fix" metric resolution translations, in the long term
* Gimp should be SI (metric) anyway, but we haven't told the
* Americans that yet
*/
xresolution = bitmap_head.biXPels * 0.0254;
yresolution = bitmap_head.biYPels * 0.0254;
gimp_image_set_resolution (image, xresolution, yresolution);
}
if (bitmap_head.biHeight < 0)
gimp_image_flip (image, GIMP_ORIENTATION_VERTICAL);
out:
if (fi.file)
fclose (fi.file);
return image;
}
static GimpImage *
ReadImage (struct Fileinfo *fi,
GFile *gfile,
gint compression,
GError **error)
{
gint ypos;
GimpImage *image;
GimpLayer *layer;
GeglBuffer *buffer;
gint i, cur_progress, max_progress;
GimpImageBaseType base_type;
GimpImageType image_type;
GimpPrecision precision_type = GIMP_PRECISION_U8_NON_LINEAR;
const Babl *format = NULL;
guchar *dest = NULL;
gsize dest_size = 0;
gsize rowstride;
gint maxbits;
gint eof = FALSE;
enum Bmpformat bmpfmt = 0;
switch (fi->bpp)
{
case 64:
base_type = GIMP_RGB;
image_type = GIMP_RGBA_IMAGE;
fi->channels = 4;
format = babl_format ("RGBA float");
precision_type = GIMP_PRECISION_FLOAT_LINEAR;
bmpfmt = BMPFMT_RGB_64;
fi->bytesperchannel = 4;
break;
case 32:
case 24:
case 16:
base_type = GIMP_RGB;
if (fi->masks[3].mask != 0 || compression == BI_OS2_RLE24)
{
image_type = GIMP_RGBA_IMAGE;
fi->channels = 4;
}
else
{
image_type = GIMP_RGB_IMAGE;
fi->channels = 3;
}
for (i = 0, maxbits = 0; i < fi->channels; i++)
maxbits = MAX (maxbits, fi->masks[i].nbits);
if (maxbits <= 8 || compression == BI_OS2_RLE24)
{
fi->bytesperchannel = 1;
precision_type = GIMP_PRECISION_U8_NON_LINEAR;
}
else if (maxbits <= 16)
{
fi->bytesperchannel = 2;
precision_type = GIMP_PRECISION_U16_NON_LINEAR;
}
else
{
fi->bytesperchannel = 4;
precision_type = GIMP_PRECISION_U32_NON_LINEAR;
}
if (compression == BI_OS2_RLE24)
bmpfmt = BMPFMT_RLE;
else
bmpfmt = BMPFMT_RGB;
break;
case 8:
case 4:
case 2:
case 1:
if (fi->gray)
{
base_type = GIMP_GRAY;
image_type = GIMP_GRAY_IMAGE;
}
else
{
base_type = GIMP_INDEXED;
image_type = GIMP_INDEXED_IMAGE;
}
fi->channels = 1;
fi->bytesperchannel = 1;
switch (compression)
{
case BI_RGB:
bmpfmt = BMPFMT_INDEXED;
break;
case BI_RLE4:
case BI_RLE8:
if (fi->gray)
image_type = GIMP_GRAYA_IMAGE;
else
image_type = GIMP_INDEXEDA_IMAGE;
fi->channels = 2;
fi->bytesperchannel = 1;
bmpfmt = BMPFMT_RLE;
break;
case BI_OS2_HUFFMAN:
bmpfmt = BMPFMT_HUFFMAN;
break;
}
break;
default:
g_message (_("Unsupported or invalid bitdepth."));
return NULL;
}
fi->tile_height = MIN (gimp_tile_height (), fi->height);
if ((guint64) fi->width * fi->tile_height < G_MAXSIZE / (fi->channels * fi->bytesperchannel))
{
dest_size = (gsize) fi->width * fi->tile_height * fi->channels * fi->bytesperchannel;
dest = g_try_malloc0 (dest_size);
fi->rowbuf = g_try_malloc (MAX (4, fi->bytes_per_row));
}
if (! (dest && fi->rowbuf))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Image dimensions too large: width %d x height %d"),
fi->width, fi->height);
g_free (dest);
g_free (fi->rowbuf);
return NULL;
}
image = gimp_image_new_with_precision (fi->width, fi->height, base_type, precision_type);
layer = gimp_layer_new (image, _("Background"),
fi->width, fi->height,
image_type, 100,
gimp_image_get_default_new_layer_mode (image));
gimp_image_insert_layer (image, layer, NULL, 0);
buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer));
rowstride = (gsize) fi->width * fi->channels * fi->bytesperchannel;
cur_progress = 0;
max_progress = fi->height;
fi->tile_n = 0;
fi->file_ypos = fi->height - 1;
for (ypos = fi->height - 1; ypos >= 0 && ! eof; ypos--)
{
gsize offset = (fi->tile_height - fi->tile_n - 1) * rowstride;
switch (bmpfmt)
{
case BMPFMT_RGB:
if (! load_rgb (fi, dest + offset))
eof = TRUE;
break;
case BMPFMT_RGB_64:
if (! load_rgb_64 (fi, dest + offset))
eof = TRUE;
break;
case BMPFMT_INDEXED:
if (! load_indexed (fi, dest + offset))
eof = TRUE;
break;
case BMPFMT_RLE:
if (fi->file_ypos < ypos)
break;
if (! load_rle (fi, dest + offset))
eof = TRUE;
break;
case BMPFMT_HUFFMAN:
if (! load_huffman (fi, dest + offset))
eof = TRUE;
break;
}
cur_progress++;
if ((cur_progress % 5) == 0)
gimp_progress_update ((gdouble) cur_progress / max_progress);
if (++fi->tile_n == fi->tile_height || ypos <= 0 || eof)
{
/* we are filling the dest buffer backwards, so we need an offset to dest in
* case the tile_height isn't fully used (when tile_n < tile_height)
*/
offset = (fi->tile_height - fi->tile_n) * rowstride;
gegl_buffer_set (buffer, GEGL_RECTANGLE (0, ypos, fi->width, fi->tile_n), 0, format,
dest + offset, GEGL_AUTO_ROWSTRIDE);
memset (dest, 0, dest_size);
fi->tile_n = 0;
}
}
g_object_unref (buffer);
g_free (dest);
if (! fi->gray && fi->bpp <= 8)
gimp_palette_set_colormap (gimp_image_get_palette (image), babl_format ("R'G'B' u8"),
fi->colormap, fi->ncolors * 3);
gimp_progress_update (1.0);
if (bmpfmt == BMPFMT_RLE && ! fi->needs_alpha)
gimp_layer_flatten (layer);
return image;
}
static gint
load_rgb (struct Fileinfo *fi, guchar *dest)
{
gint xpos, i;
gint32 px;
gdouble d;
guint16 *dest16;
guint32 *dest32;
if (! ReadOK (fi->file, fi->rowbuf, fi->bytes_per_row))
return FALSE;
dest16 = (guint16 *) dest;
dest32 = (guint32 *) dest;
for (xpos = 0; xpos < fi->width; xpos++)
{
px = ToLn (&fi->rowbuf[xpos * (fi->bpp / 8)], fi->bpp / 8);
for (i = 0; i < fi->channels; i++)
{
d = ((px & fi->masks[i].mask) >> fi->masks[i].shiftin) / fi->masks[i].max_value;
if (fi->bytesperchannel == 1)
*dest++ = d * 0x00ff + 0.5;
else if (fi->bytesperchannel == 2)
*dest16++ = d * 0xffffUL + 0.5;
else
*dest32++ = d * 0xffffffffUL + 0.5;
}
}
return TRUE;
}
static gint
load_rgb_64 (struct Fileinfo *fi, guchar *dest)
{
gint xpos, i;
gfloat *destflt;
if (! ReadOK (fi->file, fi->rowbuf, fi->bytes_per_row))
return FALSE;
destflt = (gfloat *) dest;
for (xpos = 0; xpos < fi->width; ++xpos)
{
/* Values are stored as BGRA in s2.13 fixed point format;
* s2.13 has a range of -4.0 to 3.999...
*/
for (i = 4; i >= 0; i -= 2)
{
*destflt++ = ToS (&fi->rowbuf[(xpos * 8) + i]) / 8192.0;
}
/* Alpha Channel */
*destflt++ = ToS (&fi->rowbuf[(xpos * 8) + 6]) / 8192.0;
}
return TRUE;
}
static gint
load_indexed (struct Fileinfo *fi, guchar *dest)
{
gint xpos, val, shift;
if (! ReadOK (fi->file, fi->rowbuf, fi->bytes_per_row))
return FALSE;
for (xpos = 0; xpos < fi->width; xpos++)
{
val = fi->rowbuf[xpos / (8 / fi->bpp)];
shift = 8 - fi->bpp * ((xpos % (8 / fi->bpp)) + 1);
*dest = (val & (((1 << fi->bpp) - 1) << shift)) >> shift;
*dest = MIN (*dest, fi->ncolors - 1);
if (fi->gray)
*dest = fi->colormap[*dest * 3];
dest++;
}
return TRUE;
}
static gint
load_rle (struct Fileinfo *fi, guchar *basedest)
{
gint shift, i, j;
guchar *dest;
/* dest must be (re)calculated inside loop, because RLE can skip pixles */
while (fi->xpos <= fi->width)
{
if (! ReadOK (fi->file, fi->rowbuf, 2))
{
g_message (_("The bitmap ends unexpectedly."));
fi->needs_alpha = TRUE;
return FALSE;
}
if (fi->rowbuf[0] != 0)
{
/* encoded run, row_buf[0] == number of repeats */
if (fi->bpp <= 8)
{
for (j = 0; (j < fi->rowbuf[0]) && (fi->xpos < fi->width);)
{
for (i = 1; (i <= 8 / fi->bpp) && (fi->xpos < fi->width) &&
(j < fi->rowbuf[0]);
i++, fi->xpos++, j++)
{
shift = 8 - i * fi->bpp;
dest = basedest + fi->xpos * fi->channels;
dest[0] = (fi->rowbuf[1] & (((1 << fi->bpp) - 1) << shift)) >> shift;
dest[0] = MIN (dest[0], fi->ncolors - 1);
if (fi->gray)
dest[0] = fi->colormap[dest[0] * 3];
dest[1] = 0xff; /* alpha */
}
}
}
else
{
/* read remaining 2 rgb components */
if (! ReadOK (fi->file, fi->rowbuf + 2, 2))
{
g_message (_("The bitmap ends unexpectedly."));
fi->needs_alpha = TRUE;
return FALSE;
}
for (i = 0; (i < fi->rowbuf[0]) && (fi->xpos < fi->width); i++, fi->xpos++)
{
dest = basedest + fi->xpos * fi->channels;
for (gint c = 0; c < 3; c++)
dest[2 - c] = fi->rowbuf[1 + c];
dest[3] = 0xff; /* alpha */
}
}
}
else if (fi->rowbuf[0] == 0 && fi->rowbuf[1] > 2)
{
/* literal run */
gint n = fi->rowbuf[1];
for (i = 0; i < n && fi->xpos < fi->width; i++, fi->xpos++)
{
if (fi->bpp >= 8 || i % 2 == 0) /* RLE4 only needs new byte every 2 pixels */
{
if (! ReadOK (fi->file, fi->rowbuf, fi->bpp <= 8 ? 1 : 3))
{
g_message (_("The bitmap ends unexpectedly."));
fi->needs_alpha = TRUE;
return FALSE;
}
}
dest = basedest + fi->xpos * fi->channels;
switch (fi->bpp)
{
case 8:
dest[0] = fi->rowbuf[0];
break;
case 4:
dest[0] = (fi->rowbuf[0] >> (4 * ((i + 1) % 2))) & 0x0f;
break;
case 24:
for (gint c = 0; c < 3; c++)
dest[2 - c] = fi->rowbuf[c];
break;
}
dest[fi->channels - 1] = 0xff; /* alpha */
}
/* pad to 16-bit boundary */
if ((fi->bpp == 4 ? (n + 1) / 2 : n) % 2)
{
if (EOF == getc (fi->file))
{
g_message (_("The bitmap ends unexpectedly."));
fi->needs_alpha = TRUE;
return FALSE;
}
}
}
else if ((fi->rowbuf[0] == 0) && (fi->rowbuf[1] == 0))
/* Line end */
{
if (fi->xpos < fi->width)
fi->needs_alpha = TRUE;
fi->xpos = 0;
fi->file_ypos--;
break;
}
else if ((fi->rowbuf[0] == 0) && (fi->rowbuf[1] == 1))
/* Bitmap end */
{
if (fi->xpos < fi->width || fi->file_ypos > 0)
fi->needs_alpha = TRUE;
return FALSE;
}
else if ((fi->rowbuf[0] == 0) && (fi->rowbuf[1] == 2))
/* Deltarecord */
{
if (! ReadOK (fi->file, fi->rowbuf, 2))
{
g_message (_("The bitmap ends unexpectedly."));
fi->needs_alpha = TRUE;
return FALSE;
}
if (fi->rowbuf[0] >= fi->width - fi->xpos || fi->rowbuf[1] >= fi->file_ypos)
{
/* delta points outside image, we cannot reasonably recover */
fi->needs_alpha = TRUE;
return FALSE;
}
if (fi->rowbuf[0] + fi->rowbuf[1] > 0)
fi->needs_alpha = TRUE;
fi->xpos += fi->rowbuf[0];
fi->file_ypos -= fi->rowbuf[1];
if (fi->rowbuf[1] > 0)
break;
}
}
return TRUE;
}
static gint
load_huffman (struct Fileinfo *fi, guchar *dest)
{
gint xpos = 0, len, i;
while (xpos < fi->width)
{
huff_fillbuf (&fi->bitbuf, &fi->buflen, fi->file);
if (fi->buflen == 0)
return FALSE;
if ((fi->bitbuf & 0xff000000UL) == 0)
{
/* any sequence that starts with 8 or more 0s is considered eol */
if (! huff_skip_eol (&fi->bitbuf, &fi->buflen, fi->file))
return FALSE;
if (xpos == 0) /* ignore eol at beginning of line */
continue;
}
else
{
len = huff_decode (&fi->bitbuf, &fi->buflen, fi->file, fi->black);
if (len >= 0 && len <= fi->width - xpos)
{
for (i = 0; i < len; i++, xpos++)
*dest++ = fi->black;
fi->black = ! fi->black;
continue;
}
else
{
/* Invalid bit sequence, look for next eol to re-sync */
if (! huff_find_eol (&fi->bitbuf, &fi->buflen, fi->file))
return FALSE;
break;
}
}
}
fi->black = 0; /* every new row starts with white sequence */
return TRUE;
}
static gint
huff_decode (guint32 *bitbuf, gint *buflen, FILE *file, gint black)
{
gint idx;
gint bits_used = 0;
gint result = 0;
do
{
huff_fillbuf (bitbuf, buflen, file);
bits_used = huff_findnode (*bitbuf, *buflen, black, &idx);
if (idx == -1)
{
/* invalid bit sequenct encountered */
return -1;
}
result += nodebuffer[idx].value;
*bitbuf <<= bits_used;
*buflen -= bits_used;
}
while (nodebuffer[idx].makeup && result < G_MAXINT - 2560);
return nodebuffer[idx].makeup ? -1 : result;
}
static gint
huff_findnode (guint32 bitbuf, gint buflen, gint black, gint *found)
{
gint idx;
gint bits_used = 0;
idx = black ? blackroot : whiteroot;
while (idx != -1 && ! nodebuffer[idx].leaf && bits_used < buflen)
{
if (bitbuf & 0x80000000UL)
idx = nodebuffer[idx].right;
else
idx = nodebuffer[idx].left;
bits_used++;
bitbuf <<= 1;
}
*found = idx;
return idx != -1 ? bits_used : 0;
}
static void
huff_fillbuf (guint32 *bitbuf, gint *buflen, FILE *file)
{
gint byte;
while (*buflen <= 24)
{
if (EOF == (byte = fgetc (file)))
return;
*bitbuf |= (guint32) byte << (24 - *buflen);
*buflen += 8;
}
}
static gint
huff_find_eol (guint32 *bitbuf, gint *buflen, FILE *file)
{
/* look for the next full 12-bit eol sequence,
* discarding anything else
*/
huff_fillbuf (bitbuf, buflen, file);
while (*buflen > 11)
{
if ((*bitbuf & 0xffe00000UL) == 0)
{
*bitbuf <<= 11;
*buflen -= 11;
return huff_skip_eol (bitbuf, buflen, file);
}
*bitbuf <<= 1;
*buflen -= 1;
if (*buflen < 12)
huff_fillbuf (bitbuf, buflen, file);
}
return FALSE;
}
static gint
huff_skip_eol (guint32 *bitbuf, gint *buflen, FILE *file)
{
/* skip any number of 0s and the next 1 */
huff_fillbuf (bitbuf, buflen, file);
while (*buflen > 0)
{
if (*bitbuf == 0)
{
*buflen = 0;
huff_fillbuf (bitbuf, buflen, file);
continue;
}
while ((*bitbuf & 0x80000000UL) == 0)
{
*bitbuf <<= 1;
*buflen -= 1;
}
*bitbuf <<= 1;
*buflen -= 1;
return TRUE;
}
return FALSE;
}