#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "../compatibility/tnz4.h"
#include "../compatibility/inforegion.h"
#include "filebmp.h"
/*
typedef unsigned long ULONG;
typedef unsigned short USHORT;
typedef unsigned char UCHAR;
typedef unsigned int UINT;
typedef void IMAGERGB;
typedef struct {USHORT m,b,g,r;} SPIXEL;
#define CASE break; case
#define __OR ; case
#define DEFAULT break; default
#define TRUE 1
#define FALSE 0
#define NIL (void*)0
*/
typedef enum {
BMP_NONE,
BMP_BW,
BMP_GREY16,
BMP_GREY16C,
BMP_GREY256,
BMP_GREY256C,
BMP_CMAPPED16,
BMP_CMAPPED16C,
BMP_CMAPPED256,
BMP_CMAPPED256C,
BMP_RGB
} BMP_SUBTYPE;
/*
typedef struct bmpimage {
int xsize,ysize;
LPIXEL *buffer;
BMP_SUBTYPE type;
} IMAGE;
*/
#define UNUSED_REDUCE_COLORS
/*---------------------------------------------------------------------------*/
/*-- Defines ----------------------------------------------------------------*/
#define BMP_BI_RGB 0
#define BMP_BI_RLE8 1
#define BMP_BI_RLE4 2
#define BMP_WIN_OS2_OLD 12
#define BMP_WIN_NEW 40
#define BMP_OS2_NEW 64
#define BMP_READ_INFO 1
#define BMP_READ_IMAGE 2
#define BMP_FERROR(fp) (ferror(fp) || feof(fp))
#define BMP_RMAP(x) (x & 0xe0) | ((x & 0xe0) >> 3) | ((x & 0xc0) >> 6)
#define BMP_GMAP(x) ((x & 0x1c) << 3) | (x & 0x1c) | ((x & 0x18) >> 3)
#define BMP_BMAP(x) ((x & 0x03) << 6) | ((x & 0x03) << 4) | ((x & 0x03) << 2) | (x & 0x03)
#define BMP_RMAP16(x) ((x & 0xc0) << 0) | ((x & 0xc0) >> 2) | ((x & 0xc0) >> 4) | ((x & 0xc0) >> 6)
#define BMP_GMAP16(x) ((x & 0x60) << 1) | ((x & 0x60) >> 1) | ((x & 0x60) >> 3) | ((x & 0x60) >> 5)
#define BMP_BMAP16(x) ((x & 0x30) << 2) | ((x & 0x30) << 0) | ((x & 0x30) >> 2) | ((x & 0x30) >> 4)
#define BMP_CUT(a, b, c) \
{ \
if (a < b) \
a = b; \
else if (a > c) \
a = c; \
}
#define BMP_REDUCE_COLORS(r, g, b) ((r & 0xe0) | ((g & 0xe0) >> 3) | ((b & 0xc0) >> 6))
#define BMP_ADD_ERROR(pix, weight) \
{ \
tmp = (pix).r + ((r1 * weight) >> 4); \
BMP_CUT(tmp, 0, 255); \
(pix).r = tmp; \
tmp = (pix).g + ((g1 * weight) >> 4); \
BMP_CUT(tmp, 0, 255); \
(pix).g = tmp; \
tmp = (pix).b + ((b1 * weight) >> 4); \
BMP_CUT(tmp, 0, 255); \
(pix).b = tmp; \
}
#define BMP_ADD_ERROR_BW(pix, error) \
{ \
tmp = (pix).r + (error); \
BMP_CUT(tmp, 0, 255); \
(pix).r = tmp; \
tmp = (pix).g + (error); \
BMP_CUT(tmp, 0, 255); \
(pix).g = tmp; \
tmp = (pix).b + (error); \
BMP_CUT(tmp, 0, 255); \
(pix).b = tmp; \
}
/*---------------------------------------------------------------------------*/
/*-- Structures and Enums ---------------------------------------------------*/
typedef struct
{
UINT bfSize;
UINT bfOffBits;
UINT biSize;
UINT biWidth;
UINT biHeight;
UINT biPlanes;
UINT biBitCount;
UINT biCompression;
UINT biSizeImage;
UINT biXPelsPerMeter;
UINT biYPelsPerMeter;
UINT biClrUsed;
UINT biClrImportant;
UINT biFilesize;
UINT biPad;
} BMP_HEADER;
/*---------------------------------------------------------------------------*/
/*-- Prototypes -------------------------------------------------------------*/
int load_bmp_header(FILE *fp, BMP_HEADER **pHd);
int write_bmp_header(FILE *fp, BMP_HEADER *hd);
void release_bmp_header(BMP_HEADER *hd);
int write_bmp_palette(FILE *fp, int nc, UCHAR *b, UCHAR *g, UCHAR *r);
int make_bmp_palette(int colors, int grey, UCHAR *r, UCHAR *g, UCHAR *b);
BMP_SUBTYPE bmp_get_colorstyle(IMAGE *img);
int error_checking_bmp(BMP_HEADER *hd);
int read_bmp_line(FILE *fp, void *line,
UINT w, UINT h, UCHAR **map, BMP_SUBTYPE type);
int write_bmp_line(FILE *fp, void *line_buffer,
UINT w, UINT row, UCHAR *map, BMP_SUBTYPE type);
int skip_bmp_lines(FILE *fp, UINT w, UINT rows, int whence, BMP_SUBTYPE type);
/*---------------------------------------------------------------------------*/
/*-- Local Prototypes -------------------------------------------------------*/
static UINT getshort(FILE *fp);
static UINT getint(FILE *fp);
static void putshort(FILE *fp, int value);
static void putint(FILE *fp, int value);
static int img_read_bmp_generic(const MYSTRING fname, int type, IMAGE **);
#ifndef UNUSED_REDUCE_COLORS
static UCHAR *reduce_colors(UCHAR *buffin, int xsize, int ysize,
UCHAR *rmap, UCHAR *gmap, UCHAR *bmap, int nc);
#endif
static int loadBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT h, UCHAR *r, UCHAR *g, UCHAR *b);
static int loadBMP4(FILE *fp, LPIXEL *pic, UINT w, UINT h, UINT comp, UCHAR *r, UCHAR *g, UCHAR *b);
static int loadBMP8(FILE *fp, LPIXEL *pic, UINT w, UINT h, UINT comp, UCHAR *r, UCHAR *g, UCHAR *b);
static int loadBMP24(FILE *fp, LPIXEL *pic, UINT w, UINT h);
static int writeBMP1(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);
static int writeBMP4(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);
static int writeBMPC4(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);
static int writeBMP8(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);
static int writeBMPC8(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);
static int writeBMP24(FILE *fp, UCHAR *pic24, UINT w, UINT h, UCHAR *map);
static int load_lineBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map);
static int load_lineBMP4(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map);
static int load_lineBMPC4(FILE *fp, LPIXEL *pic, UINT w, UINT y, UCHAR **map);
static int load_lineBMP8(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map);
static int load_lineBMPC8(FILE *fp, LPIXEL *pic, UINT w, UINT y, UCHAR **map);
static int load_lineBMP24(FILE *fp, LPIXEL *pic, UINT w, UINT padb);
static int line_writeBMP1(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc);
static int line_writeBMP4(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc);
static int line_writeBMPC4(FILE *fp, UCHAR *pic8, UINT w, UINT row, UCHAR *pc2nc);
static int line_writeBMP8(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc);
static int line_writeBMPC8(FILE *fp, UCHAR *pic8, UINT w, UINT row, UCHAR *pc2nc);
static int line_writeBMP24(FILE *fp, LPIXEL *pp, UINT w, UINT padb);
static int skip_rowsBMP1(FILE *fp, UINT w, UINT pad, UINT rows, int whence);
static int skip_rowsBMP4(FILE *fp, UINT w, UINT pad, UINT rows, int whence);
static int skip_rowsBMPC4(FILE *fp, UINT rows);
static int skip_rowsBMP8(FILE *fp, UINT w, UINT pad, UINT rows, int whence);
static int skip_rowsBMPC8(FILE *fp, UINT rows);
static int skip_rowsBMP24(FILE *fp, UINT w, UINT pad, UINT rows, int whence);
#define BMP_DEBUG 0
#define __BMP_WRITE_LINE_BY_LINE
#define __BMP_READ_LINE_BY_LINE
/*---------------------------------------------------------------------------*/
int read_bmp_line(FILE *fp, void *line_buffer,
UINT w, UINT row, UCHAR **map, BMP_SUBTYPE type)
/*---------------------------------------------------------------------------*/
{
LPIXEL *pic = (LPIXEL *)line_buffer;
unsigned int pad;
int rv = 0;
switch (type) {
case BMP_BW:
pad = ((w + 31) / 32) * 32;
rv = load_lineBMP1(fp, pic, w, pad, map);
CASE BMP_GREY16 : __OR BMP_CMAPPED16 : pad = ((w + 7) / 8) * 8;
rv = load_lineBMP4(fp, pic, w, pad, map);
CASE BMP_GREY16C : __OR BMP_CMAPPED16C : rv = load_lineBMPC4(fp, pic, w, row, map);
if (rv == -1)
rv = 1;
else if (rv == -2)
rv = 0;
else if (rv == -3)
rv = 0;
else
rv = 0;
CASE BMP_GREY256 : __OR BMP_CMAPPED256 : pad = ((w + 3) / 4) * 4;
rv = load_lineBMP8(fp, pic, w, pad, map);
CASE BMP_GREY256C : __OR BMP_CMAPPED256C : rv = load_lineBMPC8(fp, pic, w, row, map);
if (rv == -1)
rv = 1;
else if (rv == -2)
rv = 0;
else if (rv == -3)
rv = 0;
else
rv = 0;
CASE BMP_RGB : pad = (4 - ((w * 3) % 4)) & 0x03;
rv = load_lineBMP24(fp, pic, w, pad);
DEFAULT:
break;
}
return !rv; /* return 0 for unsuccess */
}
/*---------------------------------------------------------------------------*/
int write_bmp_line(FILE *fp, void *line_buffer,
UINT w, UINT row, UCHAR *map, BMP_SUBTYPE type)
/*---------------------------------------------------------------------------*/
{
UCHAR *pic = (UCHAR *)line_buffer;
LPIXEL *p24 = (LPIXEL *)line_buffer;
unsigned int pad;
int rv = 0;
switch (type) {
case BMP_BW:
pad = ((w + 31) / 32) * 32;
rv = line_writeBMP1(fp, pic, w, pad, map);
CASE BMP_GREY16 : __OR BMP_CMAPPED16 : pad = ((w + 7) / 8) * 8;
rv = line_writeBMP4(fp, pic, w, pad, map);
CASE BMP_GREY16C : __OR BMP_CMAPPED16C : rv = line_writeBMPC4(fp, pic, w, row, map);
CASE BMP_GREY256 : __OR BMP_CMAPPED256 : pad = ((w + 3) / 4) * 4;
rv = line_writeBMP8(fp, pic, w, pad, map);
CASE BMP_GREY256C : __OR BMP_CMAPPED256C : rv = line_writeBMPC8(fp, pic, w, row, map);
CASE BMP_RGB : pad = (4 - ((w * 3) % 4)) & 0x03;
rv = line_writeBMP24(fp, p24, w, pad);
DEFAULT:
break;
}
return rv; /* 0 for unsuccess */
}
/*---------------------------------------------------------------------------*/
int skip_bmp_lines(FILE *fp, UINT w, UINT rows, int whence, BMP_SUBTYPE type)
/*---------------------------------------------------------------------------*/
{
unsigned int pad;
int rv = 0;
switch (type) {
case BMP_BW:
pad = ((w + 31) / 32) * 32;
rv = skip_rowsBMP1(fp, w, pad, rows, whence);
CASE BMP_GREY16 : __OR BMP_CMAPPED16 : pad = ((w + 7) / 8) * 8;
rv = skip_rowsBMP4(fp, w, pad, rows, whence);
CASE BMP_GREY16C : __OR BMP_CMAPPED16C : rv = skip_rowsBMPC4(fp, rows);
CASE BMP_GREY256 : __OR BMP_CMAPPED256 : pad = ((w + 3) / 4) * 4;
rv = skip_rowsBMP8(fp, w, pad, rows, whence);
CASE BMP_GREY256C : __OR BMP_CMAPPED256C : rv = skip_rowsBMPC8(fp, rows);
CASE BMP_RGB : pad = (4 - ((w * 3) % 4)) & 0x03;
rv = skip_rowsBMP24(fp, w, pad, rows, whence);
DEFAULT:
break;
}
return !rv;
}
/*---------------------------------------------------------------------------*/
int error_checking_bmp(BMP_HEADER *hd)
/*---------------------------------------------------------------------------*/
{
/* error checking */
if ((hd->biBitCount != 1 &&
hd->biBitCount != 4 &&
hd->biBitCount != 8 &&
hd->biBitCount != 24) ||
hd->biPlanes != 1 || hd->biCompression > BMP_BI_RLE4) {
return UNSUPPORTED_BMP_FORMAT;
}
/* error checking */
if (((hd->biBitCount == 1 || hd->biBitCount == 24) &&
hd->biCompression != BMP_BI_RGB) ||
(hd->biBitCount == 4 && hd->biCompression == BMP_BI_RLE8) ||
(hd->biBitCount == 8 && hd->biCompression == BMP_BI_RLE4)) {
return UNSUPPORTED_BMP_FORMAT;
}
return OK;
}
/*---------------------------------------------------------------------------*/
int load_bmp_header(FILE *fp, BMP_HEADER **header)
/*---------------------------------------------------------------------------*/
{
BMP_HEADER *hd = NULL;
int c, c1;
*header = NULL;
hd = (BMP_HEADER *)calloc((size_t)1, sizeof(BMP_HEADER));
if (!hd)
return OUT_OF_MEMORY;
/* figure out the file size */
fseek(fp, 0L, SEEK_END);
hd->biFilesize = ftell(fp);
fseek(fp, 0L, 0);
/* read the file type (first two bytes) */
c = getc(fp);
c1 = getc(fp);
if (c != 'B' || c1 != 'M') {
free(hd);
return UNSUPPORTED_BMP_FORMAT;
}
hd->bfSize = getint(fp);
/* reserved and ignored */
getshort(fp);
getshort(fp);
hd->bfOffBits = getint(fp);
hd->biSize = getint(fp);
if (hd->biSize == BMP_WIN_NEW || hd->biSize == BMP_OS2_NEW) {
hd->biWidth = getint(fp);
hd->biHeight = getint(fp);
hd->biPlanes = getshort(fp);
hd->biBitCount = getshort(fp);
hd->biCompression = getint(fp);
hd->biSizeImage = getint(fp);
hd->biXPelsPerMeter = getint(fp);
hd->biYPelsPerMeter = getint(fp);
hd->biClrUsed = getint(fp);
hd->biClrImportant = getint(fp);
} else /* old bitmap format */
{
hd->biWidth = getshort(fp);
hd->biHeight = getshort(fp);
hd->biPlanes = getshort(fp);
hd->biBitCount = getshort(fp);
/* Not in old versions so have to compute them */
hd->biSizeImage = (((hd->biPlanes *
hd->biBitCount *
hd->biWidth) +
31) /
32) *
4 * hd->biHeight;
hd->biCompression = BMP_BI_RGB;
hd->biXPelsPerMeter = 0;
hd->biYPelsPerMeter = 0;
hd->biClrUsed = 0;
hd->biClrImportant = 0;
}
if (BMP_DEBUG) {
printf("\nLoadBMP:\tbfSize=%u, bfOffBits=%u\n", hd->bfSize,
hd->bfOffBits);
printf("\t\tbiSize=%u, biWidth=%u, biHeight=%u, biPlanes=%u\n",
hd->biSize,
hd->biWidth,
hd->biHeight,
hd->biPlanes);
printf("\t\tbiBitCount=%u, biCompression=%u, biSizeImage=%u\n",
hd->biBitCount,
hd->biCompression,
hd->biSizeImage);
printf("\t\tbiX,YPelsPerMeter=%u,%u biClrUsed=%u, biClrImp=%u\n",
hd->biXPelsPerMeter,
hd->biYPelsPerMeter,
hd->biClrUsed,
hd->biClrImportant);
}
if (BMP_FERROR(fp)) {
free(hd);
return UNEXPECTED_EOF;
}
*header = hd;
return OK;
}
/*---------------------------------------------------------------------------*/
void release_bmp_header(BMP_HEADER *hd)
/*---------------------------------------------------------------------------*/
{
if (hd)
free(hd);
}
#ifndef __LIBSIMAGE__
/*---------------------------------------------------------------------------*/
int img_read_bmp(const MYSTRING fname, IMAGE **pimg)
/*---------------------------------------------------------------------------*/
{
return img_read_bmp_generic(fname, BMP_READ_IMAGE, pimg);
}
/*---------------------------------------------------------------------------*/
static int img_read_bmp_generic(const MYSTRING fname, int type, IMAGE **pimg)
/*---------------------------------------------------------------------------*/
{
int retCode = OK;
UCHAR r[256], g[256], b[256];
BMP_HEADER *hd = NULL;
IMAGE *img = NULL;
int rv, c, i;
LPIXEL *pic;
FILE *fp;
*pimg = 0;
/* returns 'NULL' on unsuccess */
pic = (LPIXEL *)NULL;
/* open image file */
fp = _wfopen(fname, L"rb");
if (!fp)
return CANT_OPEN_FILE;
/* load up the image header */
retCode = load_bmp_header(fp, &hd);
if (retCode != OK)
goto ERROR;
/* error checking */
if ((hd->biBitCount != 1 &&
hd->biBitCount != 4 &&
hd->biBitCount != 8 &&
hd->biBitCount != 24) ||
hd->biPlanes != 1 || hd->biCompression > BMP_BI_RLE4) {
retCode = UNSUPPORTED_BMP_FORMAT;
goto ERROR;
}
/* error checking */
if (((hd->biBitCount == 1 || hd->biBitCount == 24) &&
hd->biCompression != BMP_BI_RGB) ||
(hd->biBitCount == 4 && hd->biCompression == BMP_BI_RLE8) ||
(hd->biBitCount == 8 && hd->biCompression == BMP_BI_RLE4)) {
retCode = UNSUPPORTED_BMP_FORMAT;
goto ERROR;
}
img = new_img();
img->type = TOONZRGB;
if (type == BMP_READ_INFO) {
fclose(fp);
img->xSBsize = img->xsize = hd->biWidth;
img->ySBsize = img->ysize = hd->biHeight;
release_bmp_header(hd);
*pimg = img;
return OK;
}
allocate_pixmap(img, (int)hd->biWidth, (int)hd->biHeight);
/* hd->biPad; */
if (hd->biSize != BMP_WIN_OS2_OLD) {
/* skip ahead to colormap, using biSize */
c = hd->biSize - 40; /* 40 bytes read from biSize to biClrImportant */
for (i = 0; i < c; i++)
getc(fp);
hd->biPad = hd->bfOffBits - (hd->biSize + 14);
}
/* load up colormap, if any */
if (hd->biBitCount != 24) {
int i, cmaplen;
/*cmaplen = (hd->biClrUsed) ? hd->biClrUsed : 1 << hd->biBitCount;*/
if (hd->biClrUsed)
cmaplen = hd->biClrUsed;
else
cmaplen = 1 << hd->biBitCount;
for (i = 0; i < cmaplen; i++) {
b[i] = getc(fp);
g[i] = getc(fp);
r[i] = getc(fp);
if (hd->biSize != BMP_WIN_OS2_OLD) {
getc(fp);
hd->biPad -= 4;
}
}
if (BMP_FERROR(fp)) {
retCode = UNEXPECTED_EOF;
goto ERROR;
}
if (BMP_DEBUG) {
printf("LoadBMP: BMP colormap: (RGB order)\n");
for (i = 0; i < cmaplen; i++)
printf("%02x%02x%02x ", r[i], g[i], b[i]);
printf("\n\n");
}
}
if (hd->biSize != BMP_WIN_OS2_OLD) {
/* Waste any unused bytes between the colour map (if present)
and the start of the actual bitmap data.
*/
while (hd->biPad > 0) {
(void)getc(fp);
hd->biPad--;
}
}
/* create 32 bit image buffer */
pic = (LPIXEL *)img->buffer;
/* load up the image */
switch (hd->biBitCount) {
case 1:
rv = loadBMP1(fp, pic, hd->biWidth, hd->biHeight, r, g, b);
CASE 4 : rv = loadBMP4(fp, pic, hd->biWidth, hd->biHeight, hd->biCompression, r, g, b);
CASE 8 : rv = loadBMP8(fp, pic, hd->biWidth, hd->biHeight, hd->biCompression, r, g, b);
CASE 24 : rv = loadBMP24(fp, pic, hd->biWidth, hd->biHeight);
DEFAULT:
retCode = UNSUPPORTED_BMP_FORMAT;
goto ERROR;
}
if (rv) {
retCode = UNEXPECTED_EOF;
goto ERROR;
}
fclose(fp);
release_bmp_header(hd);
*pimg = img;
return OK;
ERROR:
fclose(fp);
release_bmp_header(hd);
if (img) {
TFREE(img->buffer)
TFREE(img)
}
return retCode;
}
#endif /* __LIBSIMAGE__ */
static int img_read_bmp_region(const MYSTRING fname, IMAGE **pimg, int x1, int y1, int x2, int y2, int scale)
{
UCHAR r[256], g[256], b[256] /* ,*map[3] */;
LPIXEL *line = NULL;
UINT line_size = 0;
BMP_HEADER *hd = NULL;
EXT_INFO_REGION info;
BMP_SUBTYPE subtype;
LPIXEL *pic, *appo;
IMAGE *img = NULL;
UINT start_offset;
UINT c, i, j;
char buf[512];
FILE *fp;
UINT pad;
enum BMP_ERROR_CODE bmp_error = OK;
/* initialize some variables */
i = pad = 0;
/* returns 'NULL' on unsuccess */
pic = (LPIXEL *)NULL;
/* open image file */
fp = _wfopen(fname, L"rb");
if (!fp) {
return CANT_OPEN_FILE;
}
/* load up the image header */
load_bmp_header(fp, &hd);
if (!hd)
goto ERROR;
/* error checking */
if ((hd->biBitCount != 1 &&
hd->biBitCount != 4 &&
hd->biBitCount != 8 &&
hd->biBitCount != 24) ||
hd->biPlanes != 1 || hd->biCompression > BMP_BI_RLE4) {
sprintf(buf, "Bogus BMP File! (bitCount=%d, Planes=%d, Compression=%d)",
hd->biBitCount, hd->biPlanes, hd->biCompression);
bmp_error = UNSUPPORTED_BMP_FORMAT;
goto ERROR;
}
/* error checking */
if (((hd->biBitCount == 1 || hd->biBitCount == 24) &&
hd->biCompression != BMP_BI_RGB) ||
(hd->biBitCount == 4 && hd->biCompression == BMP_BI_RLE8) ||
(hd->biBitCount == 8 && hd->biCompression == BMP_BI_RLE4)) {
sprintf(buf, "Bogus BMP File! (bitCount=%d, Compression=%d)",
hd->biBitCount, hd->biCompression);
bmp_error = UNSUPPORTED_BMP_FORMAT;
goto ERROR;
}
img = new_img();
img->type = TOONZRGB;
img->xsize = hd->biWidth;
img->ysize = hd->biHeight;
img->xSBsize = hd->biWidth;
img->ySBsize = hd->biHeight;
img->x_dpi = (double)(hd->biXPelsPerMeter / 39);
img->y_dpi = (double)(hd->biYPelsPerMeter / 39);
hd->biPad = 0;
if (hd->biSize != BMP_WIN_OS2_OLD) {
/* skip ahead to colormap, using biSize */
c = hd->biSize - 40; /* 40 bytes read from biSize to biClrImportant */
for (i = 0; i < c; i++)
getc(fp);
hd->biPad = hd->bfOffBits - (hd->biSize + 14);
}
/* load up colormap, if any */
if (hd->biBitCount != 24) {
int i, cmaplen;
/*cmaplen = (hd->biClrUsed) ? hd->biClrUsed : 1 << hd->biBitCount;*/
if (hd->biClrUsed)
cmaplen = hd->biClrUsed;
else
cmaplen = hd->biBitCount;
for (i = 0; i < cmaplen; i++) {
b[i] = getc(fp);
g[i] = getc(fp);
r[i] = getc(fp);
if (hd->biSize != BMP_WIN_OS2_OLD) {
getc(fp);
hd->biPad -= 4;
}
}
if (BMP_FERROR(fp)) {
bmp_error = UNEXPECTED_EOF;
goto ERROR;
}
if (BMP_DEBUG) {
printf("LoadBMP: BMP colormap: (RGB order)\n");
for (i = 0; i < cmaplen; i++)
printf("%02x%02x%02x ", r[i], g[i], b[i]);
printf("\n\n");
}
}
if (hd->biSize != BMP_WIN_OS2_OLD) {
/* Waste any unused bytes between the colour map (if present)
and the start of the actual bitmap data.
*/
while (hd->biPad > 0) {
(void)getc(fp);
hd->biPad--;
}
}
/* get information about the portion of the image to load */
get_info_region(&info, x1, y1, x2, y2, scale,
(int)hd->biWidth, (int)hd->biHeight, TNZ_BOTLEFT);
/* create 32 bit image buffer */
if (!allocate_pixmap(img, info.xsize, info.ysize)) {
bmp_error = OUT_OF_MEMORY;
goto ERROR;
}
start_offset = info.y_offset * info.xsize + info.x_offset;
pic = ((LPIXEL *)img->buffer) + start_offset;
if (line_size < hd->biWidth + 32) {
line_size = hd->biWidth + 32;
if (!line)
TCALLOC((LPIXEL *)line, (size_t)line_size)
else
TREALLOC(line, line_size)
}
if (!line) {
bmp_error = OUT_OF_MEMORY;
goto ERROR;
}
switch (hd->biBitCount) {
case 1:
pad = ((hd->biWidth + 31) / 32) * 32;
CASE 4 : pad = ((hd->biWidth + 7) / 8) * 8;
CASE 8 : pad = ((hd->biWidth + 3) / 4) * 4;
CASE 24 : pad = (4 - ((hd->biWidth * 3) % 4)) & 0x03;
DEFAULT:
/* segnala errore ed esci */
break;
}
subtype = bmp_get_colorstyle(img);
if (subtype == BMP_NONE)
goto ERROR;
if (info.y_offset > 0)
info.scanNrow++;
if (info.x_offset > 0)
info.scanNcol++;
/* print_info_region(&info); */
if (info.startScanRow > 0)
skip_bmp_lines(fp, hd->biWidth, (unsigned int)(info.startScanRow - 1), (unsigned int)SEEK_CUR, subtype);
for (i = 0; i < (UINT)info.scanNrow; i++) {
if (load_lineBMP24(fp, line, hd->biWidth, pad))
goto ERROR;
/* QUESTO SWITCH VA AGGIUSTATO!
switch (subtype)
{
CASE BMP_BW:
if (load_lineBMP1(fp, line, hd->biWidth, pad, map))
goto ERROR;
CASE BMP_GREY16:
__OR BMP_CMAPPED16:
if (load_lineBMP4(fp, line, hd->biWidth, pad, map))
goto ERROR;
CASE BMP_GREY16C:
__OR BMP_CMAPPED16C:
if (load_lineBMPC4(fp, line, hd->biWidth, i, map)==-1)
goto ERROR;
CASE BMP_GREY256:
__OR BMP_CMAPPED256:
if (load_lineBMP8(fp, line, hd->biWidth, pad, map))
goto ERROR;
CASE BMP_GREY256C:
__OR BMP_CMAPPED256C:
if (load_lineBMPC8(fp, line, hd->biWidth, i, map)==-1)
goto ERROR;
CASE BMP_RGB:
if (load_lineBMP24(fp, line, hd->biWidth, pad))
goto ERROR;
}
*/
for (appo = pic, j = c = 0; j < (UINT)info.scanNcol; j++, c += info.step)
*appo++ = *(line + info.startScanCol + c);
pic += info.xsize;
skip_bmp_lines(fp, hd->biWidth, (unsigned int)(info.step - 1), (unsigned int)SEEK_CUR, subtype);
}
/*
if (BMP_FERROR(fp))
{
bmp_error(fname, "File appears truncated. Winging it.\n");
goto ERROR;
}
*/
fclose(fp);
release_bmp_header(hd);
TFREE(line);
*pimg = img;
return OK;
ERROR:
printf("error: (row=%d)\n", i);
fclose(fp);
release_bmp_header(hd);
if (img)
free_img(img);
TFREE(line);
return bmp_error;
}
/*---------------------------------------------------------------------------*/
static int loadBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT h, UCHAR *r, UCHAR *g, UCHAR *b)
/*---------------------------------------------------------------------------*/
{
UINT i, j, c, bitnum, padw, rv;
UCHAR byte;
LPIXEL *pp;
#ifdef BMP_READ_LINE_BY_LINE
UCHAR *map[3];
map[0] = r;
map[1] = g;
map[2] = b;
#endif
rv = c = 0;
padw = ((w + 31) / 32) * 32; /* 'w', padded to be a multiple of 32 */
for (i = 0; i < h; i++) {
#ifdef BMP_READ_LINE_BY_LINE
pp = pic + (i * w);
rv = load_lineBMP1(fp, pp, w, padw, map);
if (rv)
break;
#else
pp = pic + (i * w);
for (j = bitnum = 0; j < padw; j++, bitnum++) {
if ((bitnum & 7) == 0) /* read the next byte */
{
c = getc(fp);
bitnum = 0;
}
if (j < w) {
byte = (c & 0x80) ? 1 : 0;
c <<= 1;
pp->r = r[byte];
pp->g = g[byte];
pp->b = b[byte];
pp->m = 255;
pp++;
}
}
if (BMP_FERROR(fp))
break;
#endif
}
if (BMP_FERROR(fp))
rv = 1;
return rv;
}
/*---------------------------------------------------------------------------*/
int load_lineBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map)
/*---------------------------------------------------------------------------*/
{
UINT j, c, bitnum;
UCHAR byte;
LPIXEL *pp;
for (c = 0, pp = pic, j = bitnum = 0; j < padw; j++, bitnum++) {
if ((bitnum & 7) == 0) /* read the next byte */
{
c = getc(fp);
bitnum = 0;
}
if (j < w) {
byte = (c & 0x80) ? 1 : 0;
c <<= 1;
pp->r = map[0][byte];
pp->g = map[1][byte];
pp->b = map[2][byte];
pp->m = 255;
pp++;
}
}
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
static int skip_rowsBMP1(FILE *fp, UINT w, UINT pad, UINT rows, int whence)
/*---------------------------------------------------------------------------*/
{
UINT offset = pad * rows;
UINT i, bitnum;
for (i = bitnum = 0; i < offset; i++, bitnum++) {
if ((bitnum & 7) == 0) {
getc(fp);
bitnum = 0;
}
}
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
static int loadBMP4(FILE *fp,
LPIXEL *pic, UINT w, UINT h, UINT comp, UCHAR *r, UCHAR *g, UCHAR *b)
/*---------------------------------------------------------------------------*/
{
UINT i, j, c, c1, x, y, nybnum, padw, rv;
UCHAR byte;
LPIXEL *pp;
#ifdef BMP_READ_LINE_BY_LINE
UCHAR *map[3];
map[0] = r;
map[1] = g;
map[2] = b;
#endif
rv = 0;
c = c1 = 0;
if (comp == BMP_BI_RGB) /* read uncompressed data */
{
padw = ((w + 7) / 8) * 8; /* 'w' padded to a multiple of 8pix (32 bits) */
for (i = 0; i < h; i++) {
pp = pic + (i * w);
#ifdef BMP_READ_LINE_BY_LINE
rv = load_lineBMP4(fp, pp, w, padw, map);
if (rv)
break;
#else
for (j = nybnum = 0; j < padw; j++, nybnum++) {
if ((nybnum & 1) == 0) /* read next byte */
{
c = getc(fp);
nybnum = 0;
}
if (j < w) {
byte = (c & 0xf0) >> 4;
c <<= 4;
pp->r = r[byte];
pp->g = g[byte];
pp->b = b[byte];
pp->m = 255;
pp++;
}
}
if (BMP_FERROR(fp))
break;
#endif
}
} else if (comp == BMP_BI_RLE4) /* read RLE4 compressed data */
{
x = y = 0;
pp = pic + x + (y)*w;
while (y < h) {
#ifdef BMP_READ_LINE_BY_LINE
rv = load_lineBMPC4(fp, pp, w, y, map);
if (rv == -1) {
rv = 1;
break;
} else if (rv == -2) {
rv = 0;
y++;
pp = pic + y * w;
} else if (rv == -3) {
rv = 0;
break;
} else {
y += (rv / w);
pp = pic + rv;
rv = 0;
}
#else
c = getc(fp);
if ((int)c == EOF) {
rv = 1;
break;
}
if (c) /* encoded mode */
{
c1 = getc(fp);
for (i = 0; i < c; i++, x++, pp++) {
byte = (i & 1) ? (c1 & 0x0f) : ((c1 >> 4) & 0x0f);
pp->r = r[byte];
pp->g = g[byte];
pp->b = b[byte];
pp->m = 255;
}
} else /* c==0x00 : escape codes */
{
c = getc(fp);
if ((int)c == EOF) {
rv = 1;
break;
}
if (c == 0x00) /* end of line */
{
x = 0;
y++;
if (y < h)
pp = pic + x + (y)*w;
} else if (c == 0x01)
break; /* end of pic */
else if (c == 0x02) /* delta */
{
c = getc(fp);
x += c;
c = getc(fp);
y += c;
if (y < h)
pp = pic + x + (y)*w;
} else /* absolute mode */
{
for (i = 0; i < c; i++, x++, pp++) {
if ((i & 1) == 0)
c1 = getc(fp);
byte = (i & 1) ? (c1 & 0x0f) : ((c1 >> 4) & 0x0f);
pp->r = r[byte];
pp->g = g[byte];
pp->b = b[byte];
pp->m = 255;
}
if (((c & 3) == 1) || ((c & 3) == 2)) /* read pad byte */
getc(fp);
}
}
if (BMP_FERROR(fp))
break;
#endif
}
} else {
return 1;
}
if (BMP_FERROR(fp))
rv = 1;
return rv;
}
/*---------------------------------------------------------------------------*/
int load_lineBMP4(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map)
/*---------------------------------------------------------------------------*/
{
UINT nybnum, j, c;
UCHAR byte;
LPIXEL *pp;
for (c = 0, pp = pic, j = nybnum = 0; j < padw; j++, nybnum++) {
if ((nybnum & 1) == 0) /* read next byte */
{
c = getc(fp);
nybnum = 0;
}
if (j < w) {
byte = (c & 0xf0) >> 4;
c <<= 4;
pp->r = map[0][byte];
pp->g = map[1][byte];
pp->b = map[2][byte];
pp->m = 255;
pp++;
}
}
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
static int skip_rowsBMP4(FILE *fp, UINT w, UINT pad, UINT rows, int whence)
/*---------------------------------------------------------------------------*/
{
UINT offset = pad * rows;
UINT i, nybnum;
for (i = nybnum = 0; i < offset; i++, nybnum++) {
if ((nybnum & 1) == 0) {
getc(fp);
nybnum = 0;
}
}
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
int load_lineBMPC4(FILE *fp, LPIXEL *pic, UINT w, UINT y, UCHAR **map)
/*---------------------------------------------------------------------------*/
{
UINT i, c, c1, x;
UCHAR byte;
LPIXEL *pp;
/*
* Codici di ritorno:
*
* -1: incontrata la file del file (EOF)
* -2: incontrata la fine della linea (Escape code 0x00 0x00)
* -3: incontrata la fine dell' immagine (Escape code 0x00 0x01)
* altro: incontrato un delta (Escape code 0x00 0x02)
*/
/* initialize some variables */
x = 0;
pp = pic;
c = c1 = 0;
while (1) {
c = getc(fp);
if ((int)c == EOF)
return -1;
if (c) { /* encoded mode */
c1 = getc(fp);
for (i = 0; i < c; i++, x++, pp++) {
byte = (i & 1) ? (c1 & 0x0f) : ((c1 >> 4) & 0x0f);
pp->r = map[0][byte];
pp->g = map[1][byte];
pp->b = map[2][byte];
pp->m = 255;
}
} else /* c==0x00 : escape codes */
{
c = getc(fp);
if ((int)c == EOF)
return -1;
if (c == 0x00) /* end of line */
return -2;
else if (c == 0x01) /* end of pic */
return -3;
else if (c == 0x02) /* delta */
{
c = getc(fp);
x += c;
c = getc(fp);
y += c;
return (x + y * w);
} else /* absolute mode */
{
for (i = 0; i < c; i++, x++, pp++) {
if ((i & 1) == 0)
c1 = getc(fp);
byte = (i & 1) ? (c1 & 0x0f) : ((c1 >> 4) & 0x0f);
pp->r = map[0][byte];
pp->g = map[1][byte];
pp->b = map[2][byte];
pp->m = 255;
}
if (((c & 3) == 1) || ((c & 3) == 2)) /* read pad byte */
getc(fp);
}
}
if (BMP_FERROR(fp))
break;
}
return -1;
}
/*---------------------------------------------------------------------------*/
static int skip_rowsBMPC4(FILE *fp, UINT rows)
/*---------------------------------------------------------------------------*/
{
UINT i, c, c1, rv = 0;
while (rows > 0) {
c = getc(fp);
switch (c) {
case 0x00:
c = getc(fp);
switch (c) {
case 0x00:
rows--;
CASE 0x01 : rows = 0;
CASE 0x02 : c1 = getc(fp); /* x buffer offest */
c1 = getc(fp); /* y buffer offest */
rows -= c1;
DEFAULT:
for (i = 0; i < c; i++) {
if ((i & 1) == 0)
getc(fp);
}
if (((c & 3) == 1) || ((c & 3) == 2))
getc(fp);
}
DEFAULT:
c1 = getc(fp);
}
}
if (BMP_FERROR(fp))
rv = 1;
return rv;
}
/*---------------------------------------------------------------------------*/
static int loadBMP8(FILE *fp,
LPIXEL *pic, UINT w, UINT h, UINT comp, UCHAR *r, UCHAR *g, UCHAR *b)
/*---------------------------------------------------------------------------*/
{
UINT i, j, c, c1, padw, x, y, rv;
LPIXEL *pp;
#ifdef BMP_READ_LINE_BY_LINE
UCHAR *map[3];
map[0] = r;
map[1] = g;
map[2] = b;
#endif
rv = 0;
if (comp == BMP_BI_RGB) /* read uncompressed data */
{
padw = ((w + 3) / 4) * 4; /* 'w' padded to a multiple of 4pix (32 bits) */
for (i = 0; i < h; i++) {
#ifdef BMP_READ_LINE_BY_LINE
pp = pic + (i * w);
rv = load_lineBMP8(fp, pp, w, padw, map);
if (rv)
break;
#else
pp = pic + (i * w);
for (j = 0; j < padw; j++) {
c = getc(fp);
if ((int)c == EOF)
rv = 1;
if (j < w) {
pp->r = r[c];
pp->g = g[c];
pp->b = b[c];
pp->m = 255;
pp++;
}
}
if (BMP_FERROR(fp))
break;
#endif
}
} else if (comp == BMP_BI_RLE8) /* read RLE8 compressed data */
{
x = y = 0;
pp = pic + x + y * w;
while (y < h) {
#ifdef BMP_READ_LINE_BY_LINE
rv = load_lineBMPC8(fp, pp, w, y, map);
if (rv == -1) {
rv = 1;
break;
} else if (rv == -2) {
rv = 0;
y++;
pp = pic + y * w;
} else if (rv == -3) {
rv = 0;
break;
} else {
y += (rv / w);
pp = pic + rv;
rv = 0;
}
#else
c = getc(fp);
if ((int)c == EOF) {
rv = 1;
break;
}
if (c) { /* encoded mode */
c1 = getc(fp);
for (i = 0; i < c; i++, x++, pp++) {
pp->r = r[c1];
pp->g = g[c1];
pp->b = b[c1];
pp->m = 255;
}
} else /* c==0x00 : escape codes */
{
c = getc(fp);
if ((int)c == EOF) {
rv = 1;
break;
}
if (c == 0x00) /* end of line */
{
x = 0;
y++;
pp = pic + x + y * w;
} else if (c == 0x01)
break; /* end of pic */
else if (c == 0x02) /* delta */
{
c = getc(fp);
x += c;
c = getc(fp);
y += c;
pp = pic + x + y * w;
} else /* absolute mode */
{
for (i = 0; i < c; i++, x++, pp++) {
c1 = getc(fp);
pp->r = r[c1];
pp->g = g[c1];
pp->b = b[c1];
pp->m = 255;
}
if (c & 1) /* odd length run: read an extra pad byte */
getc(fp);
}
}
if (BMP_FERROR(fp))
break;
#endif
}
} else {
return 1;
}
if (BMP_FERROR(fp))
rv = 1;
return rv;
}
/*---------------------------------------------------------------------------*/
int load_lineBMP8(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map)
/*---------------------------------------------------------------------------*/
{
UINT j, c, rv = 0;
LPIXEL *pp;
for (pp = pic, j = 0; j < padw; j++) {
c = getc(fp);
if ((int)c == EOF) {
rv = 1;
break;
}
if (j < w) {
pp->r = map[0][c];
pp->g = map[1][c];
pp->b = map[2][c];
pp->m = 255;
pp++;
}
}
if (BMP_FERROR(fp))
rv = 1;
return rv;
}
/*---------------------------------------------------------------------------*/
static int skip_rowsBMP8(FILE *fp, UINT w, UINT pad, UINT rows, int whence)
/*---------------------------------------------------------------------------*/
{
UINT offset = pad * rows;
fseek(fp, (long)offset, whence);
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
int load_lineBMPC8(FILE *fp, LPIXEL *pic, UINT w, UINT y, UCHAR **map)
/*---------------------------------------------------------------------------*/
{
int i, c, c1, x;
LPIXEL *pp;
/*
* Codici di ritorno:
*
* -1: incontrata la file del file (EOF)
* -2: incontrata la fine della linea (Escape code 0x00 0x00)
* -3: incontrata la fine dell' immagine (Escape code 0x00 0x01)
* altro: incontrato un delta (Escape code 0x00 0x02)
*/
x = 0;
pp = pic;
while (1) {
c = getc(fp);
if (c == EOF)
return -1;
if (c) { /* encoded mode */
c1 = getc(fp);
for (i = 0; i < c; i++, x++, pp++) {
pp->r = map[0][c1];
pp->g = map[1][c1];
pp->b = map[2][c1];
pp->m = 255;
}
} else /* c==0x00 : escape codes */
{
c = getc(fp);
if (c == EOF)
return -1;
if (c == 0x00) /* end of line */
return -2;
else if (c == 0x01) /* end of pic */
return -3;
else if (c == 0x02) /* delta */
{
c = getc(fp);
x += c;
c = getc(fp);
y += c;
return (x + y * w);
} else /* absolute mode */
{
for (i = 0; i < c; i++, x++, pp++) {
c1 = getc(fp);
pp->r = map[0][c1];
pp->g = map[1][c1];
pp->b = map[2][c1];
pp->m = 255;
}
if (c & 1) /* odd length run: read an extra pad byte */
getc(fp);
}
}
}
}
/*---------------------------------------------------------------------------*/
static int skip_rowsBMPC8(FILE *fp, UINT rows)
/*---------------------------------------------------------------------------*/
{
int i, c, c1, rv = 0;
while (rows > 0) {
c = getc(fp);
switch (c) {
case 0x00:
c = getc(fp);
switch (c) {
case 0x00:
rows--;
CASE 0x01 : rows = 0;
CASE 0x02 : c1 = getc(fp); /* x buffer offest */
c1 = getc(fp); /* y buffer offest */
rows -= c1;
DEFAULT:
for (i = 0; i < c; i++)
getc(fp);
if (c & 1)
getc(fp);
}
DEFAULT:
c1 = getc(fp);
}
}
if (BMP_FERROR(fp))
rv = 1;
return rv;
}
/*---------------------------------------------------------------------------*/
static int loadBMP24(FILE *fp, LPIXEL *pic, UINT w, UINT h)
/*---------------------------------------------------------------------------*/
{
UINT i, j, padb, rv;
LPIXEL *pp;
rv = 0;
padb = (4 - ((w * 3) % 4)) & 0x03; /* # of pad bytes to read at EOscanline */
for (i = 0; i < h; i++) {
#ifdef BMP_READ_LINE_BY_LINE
pp = pic + i * w;
rv = load_lineBMP24(fp, pp, w, padb);
#else
for (pp = pic + i * w, j = 0; j < w; j++, pp++) {
pp->b = getc(fp); /* blue */
pp->g = getc(fp); /* green */
pp->r = getc(fp); /* red */
pp->m = 255;
}
for (j = 0; j < padb; j++)
getc(fp);
rv = (BMP_FERROR(fp));
#endif
if (rv)
break;
}
return rv;
}
/*---------------------------------------------------------------------------*/
int load_lineBMP24(FILE *fp, LPIXEL *pic, UINT w, UINT padb)
/*---------------------------------------------------------------------------*/
{
LPIXEL *pp;
UINT j;
for (pp = pic, j = 0; j < w; j++, pp++) {
pp->b = getc(fp); /* blue */
pp->g = getc(fp); /* green */
pp->r = getc(fp); /* red */
pp->m = 255;
}
for (j = 0; j < padb; j++)
getc(fp);
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
static int skip_rowsBMP24(FILE *fp, UINT w, UINT pad, UINT rows, int whence)
/*---------------------------------------------------------------------------*/
{
UINT offset = (w * 3 + pad) * rows;
fseek(fp, (long)offset, whence);
return (BMP_FERROR(fp));
}
/*---------------------------------------------------------------------------*/
/*-- BMP WRITE --------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
BMP_SUBTYPE bmp_get_colorstyle(IMAGE *img)
/*---------------------------------------------------------------------------*/
{
return img->type;
}
/*---------------------------------------------------------------------------*/
int write_bmp_header(FILE *fp, BMP_HEADER *hd)
/*---------------------------------------------------------------------------*/
{
putc('B', fp);
putc('M', fp); /* BMP file magic number */
putint(fp, (int)hd->bfSize);
putshort(fp, 0); /* reserved1 */
putshort(fp, 0); /* reserved2 */
putint(fp, (int)hd->bfOffBits); /* offset from BOfile to BObitmap */
putint(fp, (int)hd->biSize); /* size of bitmap info header */
putint(fp, (int)hd->biWidth); /* width */
putint(fp, (int)hd->biHeight); /* height */
putshort(fp, (int)hd->biPlanes); /* must be '1' */
putshort(fp, (int)hd->biBitCount); /* 1,4,8, or 24 */
putint(fp, (int)hd->biCompression); /* BMP_BI_RGB, BMP_BI_RLE8 or BMP_BI_RLE4 */
putint(fp, (int)hd->biSizeImage); /* size of raw image data */
putint(fp, (int)hd->biXPelsPerMeter); /* dpi * 39" per meter */
putint(fp, (int)hd->biYPelsPerMeter); /* dpi * 39" per meter */
putint(fp, (int)hd->biClrUsed); /* colors used in cmap */
putint(fp, (int)hd->biClrImportant); /* same as above */
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
int write_bmp_palette(FILE *fp, int nc, UCHAR *b, UCHAR *g, UCHAR *r)
/*---------------------------------------------------------------------------*/
{
int i;
for (i = 0; i < nc; i++) {
putc(b[i], fp);
putc(g[i], fp);
putc(r[i], fp);
putc(0, fp);
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
#ifndef __LIBSIMAGE__
/*---------------------------------------------------------------------------*/
int img_write_bmp(const MYSTRING fname, IMAGE *img)
/*---------------------------------------------------------------------------*/
{
int (*write_function)(FILE *fp, UCHAR *pic, UINT w, UINT h, UCHAR *map);
int h, w, i, nc, nbits, bperlin, comp;
UCHAR val;
UCHAR pc2nc[256], r1[256], g1[256], b1[256];
UCHAR *pic, *graypic;
BMP_SUBTYPE subtype;
BMP_HEADER hd;
FILE *fp;
subtype = bmp_get_colorstyle(img);
if (subtype == BMP_NONE)
return UNSUPPORTED_BMP_FORMAT;
fp = _wfopen(fname, L"wb");
if (!fp)
return CANT_OPEN_FILE;
graypic = NULL;
nc = 0;
nbits = 0;
comp = 0;
h = img->ysize;
w = img->xsize;
pic = (UCHAR *)img->buffer;
switch (subtype) {
case BMP_BW:
__OR BMP_GREY16 : __OR BMP_GREY16C :
__OR BMP_CMAPPED256 : __OR BMP_CMAPPED256C : return UNSUPPORTED_BMP_FORMAT;
CASE BMP_GREY256 : __OR BMP_GREY256C : nbits = 8;
CASE BMP_RGB : nbits = 24;
DEFAULT:
goto BMP_WRITE_ERROR;
}
/* number bytes written per line */
bperlin = ((w * nbits + 31) / 32) * 4;
/* compute filesize and write it */
i = 14 + /* size of bitmap file header */
40 + /* size of bitmap info header */
(nc * 4) + /* size of colormap */
bperlin * h; /* size of image data */
switch (nbits) {
case 4:
comp = (comp == TRUE) ? BMP_BI_RLE4 : BMP_BI_RGB;
CASE 8 : comp = (comp == TRUE) ? BMP_BI_RLE8 : BMP_BI_RGB;
DEFAULT:
comp = BMP_BI_RGB;
}
/* fill image header */
hd.bfSize = i;
hd.bfOffBits = 14 + 40 + (nc * 4);
hd.biSize = 40;
hd.biWidth = w;
hd.biHeight = h;
hd.biPlanes = 1;
hd.biBitCount = nbits;
hd.biCompression = comp;
hd.biSizeImage = bperlin * h;
hd.biXPelsPerMeter = 0 * 39;
hd.biYPelsPerMeter = 0 * 39;
hd.biClrUsed = nc;
hd.biClrImportant = nc;
if (!write_bmp_header(fp, &hd))
goto BMP_WRITE_ERROR;
write_bmp_palette(fp, nc, b1, g1, r1);
switch (nbits) {
case 1:
write_function = writeBMP1;
CASE 4 : if (comp == BMP_BI_RGB) write_function = writeBMP4;
else write_function = writeBMPC4;
CASE 8 : if (comp == BMP_BI_RGB) write_function = writeBMP8;
else write_function = writeBMPC8;
CASE 24 : write_function = writeBMP24;
DEFAULT:
goto BMP_WRITE_ERROR;
}
/* write out the image */
val = write_function(fp, pic, (unsigned int)w, (unsigned int)h, pc2nc);
if (graypic)
free(graypic);
fclose(fp);
/* 0 failed , 1 ok */
return val == 1 ? OK : WRITE_ERROR;
BMP_WRITE_ERROR:
fclose(fp);
if (graypic)
free(graypic);
_wremove(fname);
return WRITE_ERROR;
}
#endif /* __LIBSIMAGE__ */
/*---------------------------------------------------------------------------*/
static int writeBMP1(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UINT i, j, c, bitnum, padw;
UCHAR *pp;
padw = ((w + 31) / 32) * 32; /* 'w', padded to be a multiple of 32 */
for (i = 0; i < h; i++) {
pp = pic8 + (i * w);
#ifdef BMP_WRITE_LINE_BY_LINE
if (line_writeBMP1(fp, pp, w, padw, pc2nc) == FALSE)
return FALSE;
#else
for (j = bitnum = c = 0; j <= padw; j++, bitnum++) {
if (bitnum == 8) /* write the next byte */
{
putc((int)c, fp);
bitnum = c = 0;
}
c <<= 1;
if (j < w) {
c |= (pc2nc[*pp++] & 0x01);
}
}
#endif
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int line_writeBMP1(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UCHAR *pp = pic8;
UINT j, c, bitnum;
for (j = bitnum = c = 0; j <= padw; j++, bitnum++) {
if (bitnum == 8) /* write the next byte */
{
putc((int)c, fp);
bitnum = c = 0;
}
c <<= 1;
if (j < w) {
c |= (pc2nc[*pp++] & 0x01);
}
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int writeBMP4(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UINT i, j, c, nybnum, padw;
UCHAR *pp;
padw = ((w + 7) / 8) * 8; /* 'w' padded to a multiple of 8pix (32 bits) */
for (i = 0; i < h; i++) {
pp = pic8 + (i * w);
#ifdef BMP_WRITE_LINE_BY_LINE
if (line_writeBMP4(fp, pp, w, padw, pc2nc) == FALSE)
return FALSE;
#else
for (j = nybnum = c = 0; j <= padw; j++, nybnum++) {
if (nybnum == 2) /* write next byte */
{
putc((int)(c & 0xff), fp);
nybnum = c = 0;
}
c <<= 4;
if (j < w) {
c |= (pc2nc[*pp] & 0x0f);
pp++;
}
}
#endif
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int line_writeBMP4(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UINT j, c, nybnum;
UCHAR *pp = pic8;
for (j = nybnum = c = 0; j <= padw; j++, nybnum++) {
if (nybnum == 2) /* write next byte */
{
putc((int)(c & 0xff), fp);
nybnum = c = 0;
}
c <<= 4;
if (j < w) {
c |= (pc2nc[*pp] & 0x0f);
pp++;
}
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int writeBMPC4(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UCHAR *pp1, *pp2, *pp3, byte1, byte2;
UINT i, cnt;
for (i = 0; i < h; i++) {
pp1 = pic8 + i * w;
pp2 = pp1 + 2;
pp3 = pp1 + w + 2;
for (; pp2 < pp3; pp2 += 2) {
cnt = 2;
byte1 = ((pc2nc[*pp1] << 4) & 0xf0) | (pc2nc[*(pp1 + 1)] & 0x0f);
byte2 = ((pc2nc[*pp2] << 4) & 0xf0) | (pc2nc[*(pp2 + 1)] & 0x0f);
if (byte1 != byte2) {
putc((int)cnt, fp);
putc(byte1, fp);
pp1 = pp2;
} else {
while (cnt <= 254 && pp2 < pp3) {
cnt += 2;
pp2 += 2;
byte2 = ((pc2nc[*pp2] << 4) & 0xf0) | (pc2nc[*(pp2 + 1)] & 0x0f);
if (byte1 != byte2 || cnt >= 254 || pp2 + 2 > pp3) {
if (pp2 + 2 > pp3)
cnt -= 2;
putc((int)cnt, fp);
putc(byte1, fp);
break;
}
}
pp1 = pp2;
}
}
putc(0x00, fp);
putc(0x00, fp);
if (BMP_FERROR(fp))
return FALSE;
}
putc(0x00, fp);
putc(0x01, fp);
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int line_writeBMPC4(FILE *fp, UCHAR *pic8, UINT w, UINT row, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UCHAR *pp1, *pp2, *pp3, byte1, byte2;
UINT cnt;
pp1 = pic8 + row * w;
pp2 = pp1 + 2;
pp3 = pp1 + w + 2;
for (; pp2 < pp3; pp2 += 2) {
cnt = 2;
byte1 = ((pc2nc[*pp1] << 4) & 0xf0) | (pc2nc[*(pp1 + 1)] & 0x0f);
byte2 = ((pc2nc[*pp2] << 4) & 0xf0) | (pc2nc[*(pp2 + 1)] & 0x0f);
if (byte1 != byte2) {
putc((int)cnt, fp);
putc(byte1, fp);
pp1 = pp2;
} else {
while (cnt <= 254 && pp2 < pp3) {
cnt += 2;
pp2 += 2;
byte2 = ((pc2nc[*pp2] << 4) & 0xf0) | (pc2nc[*(pp2 + 1)] & 0x0f);
if (byte1 != byte2 || cnt >= 254 || pp2 + 2 > pp3) {
if (pp2 + 2 > pp3)
cnt -= 2;
putc((int)cnt, fp);
putc(byte1, fp);
break;
}
}
pp1 = pp2;
}
}
putc(0x00, fp);
putc(0x00, fp);
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int writeBMP8(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UINT i, j, padw;
UCHAR *pp;
padw = ((w + 3) / 4) * 4; /* 'w' padded to a multiple of 4pix (32 bits) */
for (i = 0; i < h; i++) {
pp = pic8 + (i * w);
#ifdef BMP_WRITE_LINE_BY_LINE
if (line_writeBMP8(fp, pp, w, padw, pc2nc) == FALSE)
return FALSE;
#else
/* for (j=0; j<w; j++) putc(pc2nc[*pp++], fp);*/
for (j = 0; j < w; j++) {
putc(*pp, fp);
pp++;
}
for (; j < padw; j++)
putc(0, fp);
#endif
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int line_writeBMP8(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UCHAR *pp = pic8;
UINT j;
for (j = 0; j < w; j++)
putc(pc2nc[*pp++], fp);
for (; j < padw; j++)
putc(0, fp);
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int writeBMPC8(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UCHAR *pp1, *pp2, *pp3, byte1, byte2;
UINT i, cnt;
for (i = 0; i < h; i++) {
pp1 = pic8 + i * w;
pp2 = pp1 + 1;
pp3 = pp1 + w + 1;
for (; pp2 < pp3; pp2++) {
cnt = 1;
byte1 = pc2nc[*pp1];
byte2 = pc2nc[*pp2];
if (byte1 != byte2) {
putc((int)cnt, fp);
putc(byte1, fp);
pp1 = pp2;
} else {
while (cnt <= 254 && pp2 < pp3) {
cnt++;
pp2++;
byte2 = pc2nc[*pp2];
if (byte1 != byte2 || cnt >= 254 || pp2 + 1 > pp3) {
if (pp2 + 1 > pp3)
cnt--;
putc((int)cnt, fp);
putc(byte1, fp);
break;
}
}
pp1 = pp2;
}
}
putc(0x00, fp);
putc(0x00, fp);
if (BMP_FERROR(fp))
return FALSE;
}
putc(0x00, fp);
putc(0x01, fp);
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int line_writeBMPC8(FILE *fp, UCHAR *pic8, UINT w, UINT row, UCHAR *pc2nc)
/*---------------------------------------------------------------------------*/
{
UCHAR *pp1, *pp2, *pp3, byte1, byte2;
UINT cnt;
pp1 = pic8 + row * w;
pp2 = pp1 + 1;
pp3 = pp1 + w + 1;
for (; pp2 < pp3; pp2++) {
cnt = 1;
byte1 = pc2nc[*pp1];
byte2 = pc2nc[*pp2];
if (byte1 != byte2) {
putc((int)cnt, fp);
putc(byte1, fp);
pp1 = pp2;
} else {
while (cnt <= 254 && pp2 < pp3) {
cnt++;
pp2++;
byte2 = pc2nc[*pp2];
if (byte1 != byte2 || cnt >= 254 || pp2 + 1 > pp3) {
if (pp2 + 1 > pp3)
cnt--;
putc((int)cnt, fp);
putc(byte1, fp);
break;
}
}
pp1 = pp2;
}
}
putc(0x00, fp);
putc(0x00, fp);
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int writeBMP24(FILE *fp, UCHAR *pic24, UINT w, UINT h, UCHAR *whence)
/*---------------------------------------------------------------------------*/
{
UINT i, j, padb;
LPIXEL *pixel;
UCHAR *pp;
/* pc2nc not used */
padb = (4 - ((w * 3) % 4)) & 0x03; /* # of pad bytes to write at EOscanline */
for (i = 0; i < h; i++) {
pp = pic24 + (i * w * 4);
pixel = (LPIXEL *)pp;
#ifdef BMP_WRITE_LINE_BY_LINE
if (line_writeBMP24(fp, pixel, w, padb) == FALSE)
return FALSE;
#else
for (j = 0; j < w; j++) {
putc(pixel->b, fp);
putc(pixel->g, fp);
putc(pixel->r, fp);
pixel++;
}
for (j = 0; j < padb; j++)
putc(0, fp);
#endif
}
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int line_writeBMP24(FILE *fp, LPIXEL *pp, UINT w, UINT padb)
/*---------------------------------------------------------------------------*/
{
UINT j;
for (j = 0; j < w; j++) {
putc(pp->b, fp);
putc(pp->g, fp);
putc(pp->r, fp);
pp++;
}
for (j = 0; j < padb; j++)
putc(0, fp);
if (BMP_FERROR(fp))
return FALSE;
return TRUE;
}
#ifndef __LIBSIMAGE__
#ifndef UNUSED_REDUCE_COLORS
/*---------------------------------------------------------------------------*/
static UCHAR *reduce_colors(UCHAR *buffin, int xsize, int ysize,
UCHAR *rmap, UCHAR *gmap, UCHAR *bmap, int nc)
/*---------------------------------------------------------------------------*/
{
LPIXEL *curr_pix, *next_pix, *prev_pix, *buffer;
static LPIXEL *mbuffer = NULL;
static UCHAR *ret_buf = NULL;
static int outbuf_size = 0;
static int buffin_size = 0;
int r1, g1, b1, dim;
int i, j, tmp;
int imax, jmax;
UCHAR *outbuf;
USHORT val;
dim = xsize * ysize;
if (dim > outbuf_size) {
if (!ret_buf)
TCALLOC(ret_buf, dim)
else
TREALLOC(ret_buf, dim);
if (!ret_buf)
return NULL;
outbuf_size = dim;
}
if (dim > buffin_size) {
if (!mbuffer)
TCALLOC(mbuffer, dim)
else
TREALLOC(mbuffer, dim);
if (!ret_buf)
return NULL;
buffin_size = dim;
}
memcpy(mbuffer, buffin, dim * sizeof(LPIXEL));
buffer = mbuffer;
outbuf = ret_buf;
imax = ysize - 1;
jmax = xsize - 1;
for (i = 0; i < ysize; i++) {
curr_pix = buffer;
buffer += xsize;
next_pix = buffer;
prev_pix = NIL;
for (j = 0; j < xsize; j++) {
r1 = curr_pix->r;
g1 = curr_pix->g;
b1 = curr_pix->b;
val = BMP_REDUCE_COLORS(r1, g1, b1);
*(outbuf++) = (unsigned char)val;
/* errors on colors */
r1 -= rmap[val];
g1 -= gmap[val];
b1 -= bmap[val];
if (j != jmax)
BMP_ADD_ERROR(curr_pix[1], 7) /* RIGHT */
if (i != imax) /* UP */
{
BMP_ADD_ERROR(*next_pix, 5)
if (j > 0)
BMP_ADD_ERROR(*prev_pix, 3) /* UP LEFT */
if (j != jmax)
BMP_ADD_ERROR(next_pix[1], 1) /* UP RIGHT */
prev_pix = next_pix;
next_pix++;
}
curr_pix++;
}
}
return ret_buf;
}
#endif
#endif /* __LIBSIMAGE__ */
/*---------------------------------------------------------------------------*/
int make_bmp_palette(int colors, int grey, UCHAR *r, UCHAR *g, UCHAR *b)
/*---------------------------------------------------------------------------*/
{
int i, j, ind, val;
switch (colors) {
case 2:
for (i = 0; i < 2; i++)
r[i] = g[i] = b[i] = i * 255;
CASE 16 : for (i = 0; i < 16; i++)
{
for (j = 0; j < 16; j++) {
ind = i * 16 + j;
val = i * 16;
r[ind] = g[ind] = b[ind] = val;
}
}
CASE 256 : if (grey)
{
for (i = 0; i < 256; i++)
r[i] = g[i] = b[i] = i;
}
else
{
for (i = 0; i < 256; i++) {
r[i] = BMP_RMAP(i);
g[i] = BMP_GMAP(i);
b[i] = BMP_BMAP(i);
}
}
DEFAULT:
return FALSE;
}
return TRUE;
}
/*---------------------------------------------------------------------------*/
static UINT getshort(FILE *fp)
/*---------------------------------------------------------------------------*/
{
int c = getc(fp),
c1 = getc(fp);
return ((UINT)c) + (((UINT)c1) << 8);
}
/*---------------------------------------------------------------------------*/
static UINT getint(FILE *fp)
/*---------------------------------------------------------------------------*/
{
int c = getc(fp),
c1 = getc(fp),
c2 = getc(fp),
c3 = getc(fp);
return (((UINT)c) << 0) +
(((UINT)c1) << 8) +
(((UINT)c2) << 16) +
(((UINT)c3) << 24);
}
/*---------------------------------------------------------------------------*/
static void putshort(FILE *fp, int i)
/*---------------------------------------------------------------------------*/
{
int c = (((UINT)i)) & 0xff,
c1 = (((UINT)i) >> 8) & 0xff;
putc(c, fp);
putc(c1, fp);
}
/*---------------------------------------------------------------------------*/
static void putint(FILE *fp, int i)
/*---------------------------------------------------------------------------*/
{
int c = ((UINT)i) & 0xff,
c1 = (((UINT)i) >> 8) & 0xff,
c2 = (((UINT)i) >> 16) & 0xff,
c3 = (((UINT)i) >> 24) & 0xff;
putc(c, fp);
putc(c1, fp);
putc(c2, fp);
putc(c3, fp);
}
/*---------------------------------------------------------------------------*/
int writebmp(const MYSTRING filename, int xsize, int ysize, void *buffer, int bpp)
{
IMAGE img;
img.xsize = xsize;
img.ysize = ysize;
img.buffer = buffer;
switch (bpp) {
case 8:
img.type = BMP_GREY256C;
CASE 32 : img.type = BMP_RGB;
}
return img_write_bmp(filename, &img);
}
/*---------------------------------------------------------------------------*/
int readbmp(const MYSTRING filename, int *xsize, int *ysize, void **buffer)
{
IMAGE *img;
int retCode = img_read_bmp(filename, &img);
if (retCode != OK) {
*xsize = *ysize = 0;
*buffer = 0;
} else {
*xsize = img->xsize;
*ysize = img->ysize;
*buffer = img->buffer;
img->buffer = 0;
free_img(img);
}
return retCode;
}
/*---------------------------------------------------------------------------*/
int readbmpregion(const MYSTRING filename, void **pimg, int x1, int y1, int x2, int y2, int scale)
{
IMAGE *img;
int retCode = img_read_bmp_region(filename, &img, x1, y1, x2, y2, scale);
if (retCode != OK) {
*pimg = 0;
} else {
*pimg = img->buffer;
free(img);
}
return retCode;
}
/*---------------------------------------------------------------------------*/
int readbmp_size(const MYSTRING fname, int *lx, int *ly)
{
IMAGE *img;
int retCode = img_read_bmp_generic(fname, BMP_READ_INFO, &img);
if (retCode == OK) {
*lx = img->xsize;
*ly = img->ysize;
free(img);
}
return retCode;
}
/*---------------------------------------------------------------------------*/
int readbmp_bbox(const MYSTRING fname, int *x0, int *y0, int *x1, int *y1)
{
IMAGE *img;
int retCode = img_read_bmp_generic(fname, BMP_READ_INFO, &img);
if (retCode == OK) {
*x0 = 0;
*x1 = 0;
*x1 = img->xsize - 1;
*y1 = img->ysize - 1;
free(img);
}
return retCode;
}