495 lines
11 KiB
C
495 lines
11 KiB
C
/*
|
|
* Portions of this file are copyright Rebirth contributors and licensed as
|
|
* described in COPYING.txt.
|
|
* Portions of this file are copyright Parallax Software and licensed
|
|
* according to the Parallax license below.
|
|
* See COPYING.txt for license details.
|
|
|
|
THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
|
|
SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
|
|
END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
|
|
ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
|
|
IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
|
|
SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
|
|
FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
|
|
CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
|
|
AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
|
|
COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <alloc.h>
|
|
|
|
#include "iff.h"
|
|
|
|
#define MIN(a,b) ((a<b)?a:b)
|
|
|
|
#define MAKE_SIG(a,b,c,d) (((long)(a)<<24)+((long)(b)<<16)+((c)<<8)+(d))
|
|
|
|
#define form_sig MAKE_SIG('F','O','R','M')
|
|
#define ilbm_sig MAKE_SIG('I','L','B','M')
|
|
#define body_sig MAKE_SIG('B','O','D','Y')
|
|
#define pbm_sig MAKE_SIG('P','B','M',' ')
|
|
#define bmhd_sig MAKE_SIG('B','M','H','D')
|
|
#define cmap_sig MAKE_SIG('C','M','A','P')
|
|
|
|
void printsig(long s)
|
|
{
|
|
char *t=(char *) &s;
|
|
|
|
/* printf("%c%c%c%c",*(&s+3),*(&s+2),*(&s+1),s);*/
|
|
printf("%c%c%c%c",t[3],t[2],t[1],t[0]);
|
|
}
|
|
|
|
long get_sig(FILE *f)
|
|
{
|
|
char s[4];
|
|
|
|
if ((s[3]=getc(f))==EOF) return(EOF);
|
|
if ((s[2]=getc(f))==EOF) return(EOF);
|
|
if ((s[1]=getc(f))==EOF) return(EOF);
|
|
if ((s[0]=getc(f))==EOF) return(EOF);
|
|
|
|
return(*((long *) s));
|
|
}
|
|
|
|
int put_sig(long sig,FILE *f)
|
|
{
|
|
char *s = (char *) &sig;
|
|
|
|
putc(s[3],f);
|
|
putc(s[2],f);
|
|
putc(s[1],f);
|
|
return putc(s[0],f);
|
|
|
|
}
|
|
|
|
int get_word(FILE *f)
|
|
{
|
|
unsigned char c0,c1;
|
|
|
|
c1=getc(f);
|
|
c0=getc(f);
|
|
|
|
if (c0==0xff) return(EOF);
|
|
|
|
return(((int)c1<<8) + c0);
|
|
|
|
}
|
|
|
|
char get_byte(FILE *f)
|
|
{
|
|
return getc(f);
|
|
}
|
|
|
|
char put_byte(unsigned char c,FILE *f)
|
|
{
|
|
return putc(c,f);
|
|
}
|
|
|
|
int put_word(int n,FILE *f)
|
|
{
|
|
unsigned char c0,c1;
|
|
|
|
c0 = (n & 0xff00) >> 8;
|
|
c1 = n & 0xff;
|
|
|
|
put_byte(c0,f);
|
|
return put_byte(c1,f);
|
|
}
|
|
|
|
int put_long(long n,FILE *f)
|
|
{
|
|
int n0,n1;
|
|
|
|
n0 = (int) ((n & 0xffff0000l) >> 16);
|
|
n1 = (int) (n & 0xffff);
|
|
|
|
put_word(n0,f);
|
|
return put_word(n1,f);
|
|
|
|
}
|
|
|
|
long get_long(FILE *f)
|
|
{
|
|
unsigned char c0,c1,c2,c3;
|
|
|
|
c3=getc(f);
|
|
c2=getc(f);
|
|
c1=getc(f);
|
|
c0=getc(f);
|
|
|
|
//printf("get_long %x %x %x %x\n",c3,c2,c1,c0);
|
|
|
|
// if (c0==0xff) return(EOF);
|
|
|
|
return(((long)c3<<24) + ((long)c2<<16) + ((long)c1<<8) + c0);
|
|
|
|
}
|
|
|
|
void parse_bmhd(FILE *ifile,long len,struct bitmap_header *bitmap_header)
|
|
{
|
|
len++; /* so no "parm not used" warning */
|
|
|
|
// debug("parsing bmhd len=%ld\n",len);
|
|
|
|
bitmap_header->w = get_word(ifile);
|
|
bitmap_header->h = get_word(ifile);
|
|
bitmap_header->x = get_word(ifile);
|
|
bitmap_header->y = get_word(ifile);
|
|
|
|
bitmap_header->nplanes = get_byte(ifile);
|
|
bitmap_header->masking = get_byte(ifile);
|
|
bitmap_header->compression = get_byte(ifile);
|
|
get_byte(ifile); /* skip pad */
|
|
|
|
bitmap_header->transparentcolor = get_word(ifile);
|
|
bitmap_header->xaspect = get_byte(ifile);
|
|
bitmap_header->yaspect = get_byte(ifile);
|
|
|
|
bitmap_header->pagewidth = get_word(ifile);
|
|
bitmap_header->pageheight = get_word(ifile);
|
|
|
|
// debug("w,h=%d,%d x,y=%d,%d\n",w,h,x,y);
|
|
// debug("nplanes=%d, masking=%d ,compression=%d, transcolor=%d\n",nplanes,masking,compression,transparentcolor);
|
|
|
|
}
|
|
|
|
|
|
// the buffer pointed to by raw_data is stuffed with a pointer to decompressed pixel data
|
|
int parse_body_pbm(FILE *ifile,long len,struct bitmap_header *bitmap_header)
|
|
{
|
|
unsigned char huge *p=bitmap_header->raw_data;
|
|
int width=bitmap_header->w;
|
|
long cnt,old_cnt;
|
|
char n;
|
|
int nn,wid_cnt;
|
|
char ignore;
|
|
|
|
if (bitmap_header->compression == cmpNone) { /* no compression */
|
|
int x,y;
|
|
|
|
for (y=bitmap_header->h;y;y--) {
|
|
for (x=bitmap_header->w;x;x--) *p++=getc(ifile);
|
|
if (bitmap_header->w & 1) ignore = getc(ifile);
|
|
}
|
|
|
|
}
|
|
else if (bitmap_header->compression == cmpByteRun1)
|
|
for (old_cnt=cnt=len,wid_cnt=width;cnt>0;) {
|
|
unsigned char c;
|
|
|
|
if (old_cnt-cnt > 2048) {
|
|
// printf(".");
|
|
old_cnt=cnt;
|
|
}
|
|
|
|
if (wid_cnt <= 0) wid_cnt = width;
|
|
|
|
n=getc(ifile);
|
|
if (n >= 0) { // copy next n+1 bytes from source, they are not compressed
|
|
nn = (int) n+1;
|
|
cnt -= nn+1;
|
|
wid_cnt -= nn;
|
|
if (wid_cnt==-1) --nn;
|
|
while (nn--) *p++=getc(ifile);
|
|
if (wid_cnt==-1) ignore = getc(ifile); /* extra char */
|
|
}
|
|
else if (n>=-127) { // next -n + 1 bytes are following byte
|
|
cnt -= 2;
|
|
c=getc(ifile);
|
|
nn = (int) -n+1;
|
|
wid_cnt -= nn;
|
|
if (wid_cnt==-1) --nn;
|
|
while (nn--) *p++=c;
|
|
}
|
|
|
|
}
|
|
|
|
if (len & 1) ignore = getc(ifile);
|
|
|
|
if (ignore) ignore++; // haha, suppress the evil warning message
|
|
|
|
return IFF_NO_ERROR;
|
|
}
|
|
|
|
// the buffer pointed to by raw_data is stuffed with a pointer to bitplane pixel data
|
|
int parse_body_ilbm(FILE *ifile,long len,struct bitmap_header *bitmap_header)
|
|
{
|
|
unsigned char huge *p=bitmap_header->raw_data;
|
|
int width=bitmap_header->w;
|
|
long cnt,old_cnt;
|
|
char n;
|
|
int nn,wid_cnt;
|
|
char ignore;
|
|
|
|
if (bitmap_header->compression == cmpNone) { /* no compression */
|
|
int x,y;
|
|
|
|
for (y=bitmap_header->h;y;y--) {
|
|
for (x=bitmap_header->w;x;x--) *p++=getc(ifile);
|
|
if (bitmap_header->w & 1) ignore = getc(ifile);
|
|
}
|
|
|
|
}
|
|
else if (bitmap_header->compression == cmpByteRun1)
|
|
for (old_cnt=cnt=len,wid_cnt=width;cnt>0;) {
|
|
unsigned char c;
|
|
|
|
if (old_cnt-cnt > 2048) {
|
|
// printf(".");
|
|
old_cnt=cnt;
|
|
}
|
|
|
|
if (wid_cnt <= 0) wid_cnt = width;
|
|
|
|
n=getc(ifile);
|
|
if (n >= 0) { // copy next n+1 bytes from source, they are not compressed
|
|
nn = (int) n+1;
|
|
cnt -= nn+1;
|
|
wid_cnt -= nn;
|
|
if (wid_cnt==-1) --nn;
|
|
while (nn--) *p++=getc(ifile);
|
|
if (wid_cnt==-1) ignore = getc(ifile); /* extra char */
|
|
}
|
|
else if (n>=-127) { // next -n + 1 bytes are following byte
|
|
cnt -= 2;
|
|
c=getc(ifile);
|
|
nn = (int) -n+1;
|
|
wid_cnt -= nn;
|
|
if (wid_cnt==-1) --nn;
|
|
while (nn--) *p++=c;
|
|
}
|
|
|
|
}
|
|
|
|
if (len & 1) ignore = getc(ifile);
|
|
|
|
if (ignore) ignore++; // haha, suppress the evil warning message
|
|
|
|
return IFF_NO_ERROR;
|
|
}
|
|
|
|
void skip_chunk(FILE *ifile,long len)
|
|
{
|
|
len = len+1 & ~1;
|
|
fseek(ifile,len,SEEK_CUR);
|
|
}
|
|
|
|
// Pass pointer to opened file, and to empty bitmap header.
|
|
int parse_iff(FILE *ifile,struct bitmap_header *bitmap_header)
|
|
{
|
|
long sig,form_len,len,form_type;
|
|
char ignore;
|
|
|
|
sig=get_sig(ifile);
|
|
|
|
// printsig(sig);
|
|
|
|
if (sig==form_sig) {
|
|
|
|
form_len = get_long(ifile);
|
|
form_len++; /* get rid of never used message */
|
|
|
|
form_type = get_sig(ifile);
|
|
|
|
// printf(" %ld ",form_len);
|
|
// printsig(form_type);
|
|
// printf("\n");
|
|
|
|
if ((form_type == pbm_sig) || (form_type == ilbm_sig)) {
|
|
|
|
if (form_type == pbm_sig)
|
|
bitmap_header->type = PBM_TYPE;
|
|
else
|
|
bitmap_header->type = ILBM_TYPE;
|
|
|
|
while ((sig=get_sig(ifile)) != EOF) {
|
|
|
|
len=get_long(ifile);
|
|
|
|
// printf(" ");
|
|
// printsig(sig);
|
|
// printf(" %ld\n",len);
|
|
|
|
switch (sig) {
|
|
|
|
case bmhd_sig:
|
|
|
|
parse_bmhd(ifile,len,bitmap_header);
|
|
|
|
if (! (bitmap_header->raw_data = farmalloc((long) bitmap_header->w * bitmap_header->h))) return IFF_NO_MEM;
|
|
|
|
break;
|
|
|
|
case cmap_sig:
|
|
{
|
|
int ncolors=(int) (len/3),cnum;
|
|
unsigned char r,g,b;
|
|
|
|
for (cnum=0;cnum<ncolors;cnum++) {
|
|
r=getc(ifile);
|
|
g=getc(ifile);
|
|
b=getc(ifile);
|
|
r >>= 2; bitmap_header->palette[cnum].r = r;
|
|
g >>= 2; bitmap_header->palette[cnum].g = g;
|
|
b >>= 2; bitmap_header->palette[cnum].b = b;
|
|
}
|
|
if (len & 1) ignore = getc(ifile);
|
|
|
|
break;
|
|
}
|
|
|
|
case body_sig:
|
|
{
|
|
int r;
|
|
switch (form_type) {
|
|
case pbm_sig:
|
|
if (!(r=parse_body_pbm(ifile,len,bitmap_header))) return r;
|
|
break;
|
|
case ilbm_sig:
|
|
if (!(r=parse_body_ilbm(ifile,len,bitmap_header))) return r;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
skip_chunk(ifile,len);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else return IFF_UNKNOWN_FORM;
|
|
}
|
|
else
|
|
{printf("Not an IFF file\n"); return IFF_NOT_IFF;}
|
|
|
|
if (ignore) ignore++;
|
|
|
|
return IFF_NO_ERROR; /* ok! */
|
|
}
|
|
|
|
#define BMHD_SIZE 20
|
|
|
|
int write_bmhd(FILE *ofile,struct bitmap_header *bitmap_header)
|
|
{
|
|
|
|
put_sig(bmhd_sig,ofile);
|
|
put_long((long) BMHD_SIZE,ofile);
|
|
|
|
put_word(bitmap_header->w,ofile);
|
|
put_word(bitmap_header->h,ofile);
|
|
put_word(bitmap_header->x,ofile);
|
|
put_word(bitmap_header->y,ofile);
|
|
|
|
put_byte(bitmap_header->nplanes,ofile);
|
|
put_byte(bitmap_header->masking,ofile);
|
|
put_byte(bitmap_header->compression,ofile);
|
|
put_byte(0,ofile); /* pad */
|
|
|
|
put_word(bitmap_header->transparentcolor,ofile);
|
|
put_byte(bitmap_header->xaspect,ofile);
|
|
put_byte(bitmap_header->yaspect,ofile);
|
|
|
|
put_word(bitmap_header->pagewidth,ofile);
|
|
put_word(bitmap_header->pageheight,ofile);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
int write_huge(unsigned char huge *huge_ptr,long len,FILE *f)
|
|
{
|
|
unsigned char temp_buffer[256],*t;
|
|
|
|
//printf("write_huge %ld\n",len);
|
|
|
|
while (len) {
|
|
int n,wsize = (int) MIN(len,256);
|
|
|
|
//printf("len,wsize=%ld,%d\n",len,wsize);
|
|
for (t=temp_buffer,n=wsize;n--;) *t++ = *huge_ptr++;
|
|
|
|
fwrite(temp_buffer,wsize,1,f);
|
|
|
|
len -= wsize;
|
|
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int write_pal(FILE *ofile,struct bitmap_header *bitmap_header)
|
|
{
|
|
int i;
|
|
|
|
int n_colors = 1<<bitmap_header->nplanes;
|
|
|
|
put_sig(cmap_sig,ofile);
|
|
// put_long(sizeof(struct pal_entry) * n_colors,ofile);
|
|
put_long(3 * n_colors,ofile);
|
|
|
|
//printf("new write pal %d %d\n",3,n_colors);
|
|
|
|
for (i=0; i<256; i++) {
|
|
unsigned char r,g,b;
|
|
r = bitmap_header->palette[i].r * 4;
|
|
g = bitmap_header->palette[i].g * 4;
|
|
b = bitmap_header->palette[i].b * 4;
|
|
fputc(r,ofile);
|
|
fputc(g,ofile);
|
|
fputc(b,ofile);
|
|
}
|
|
|
|
//printf("write pal %d %d\n",sizeof(struct pal_entry),n_colors);
|
|
// fwrite(bitmap_header->palette,sizeof(struct pal_entry),n_colors,ofile);
|
|
|
|
return 1;
|
|
}
|
|
|
|
#define EVEN(a) ((a+1)&0xfffffffel)
|
|
|
|
int write_body(FILE *ofile,struct bitmap_header *bitmap_header)
|
|
{
|
|
int w=bitmap_header->w,h=bitmap_header->h;
|
|
int y,odd=w&1;
|
|
long len = EVEN(w) * h;
|
|
unsigned char huge *p=bitmap_header->raw_data;
|
|
|
|
put_sig(body_sig,ofile);
|
|
put_long(len,ofile);
|
|
|
|
for (y=bitmap_header->h;y--;) {
|
|
|
|
write_huge(p,bitmap_header->w,ofile);
|
|
if (odd) putc(0,ofile);
|
|
p+=bitmap_header->w;
|
|
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int write_pbm(FILE *ofile,struct bitmap_header *bitmap_header) /* writes a pbm iff file */
|
|
{
|
|
long raw_size = EVEN(bitmap_header->w) * bitmap_header->h;
|
|
long pbm_size = 4 + BMHD_SIZE + 8 + EVEN(raw_size) + sizeof(struct pal_entry)*(1<<bitmap_header->nplanes)+8;
|
|
|
|
//printf("write_pbm\n");
|
|
|
|
put_sig(form_sig,ofile);
|
|
put_long(pbm_size+8,ofile);
|
|
put_sig(pbm_sig,ofile);
|
|
|
|
write_bmhd(ofile,bitmap_header);
|
|
|
|
write_pal(ofile,bitmap_header);
|
|
|
|
write_body(ofile,bitmap_header);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|