src/bniutils/tga.c

/*
    Copyright (C) 2000  Marco Ziech (mmz@gmx.net)
    Copyright (C) 2000  Ross Combs (rocombs@cs.nmsu.edu)

    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#include "common/setup_before.h"
#include <stdio.h>
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include <errno.h>
#include "compat/strerror.h"
#include "fileio.h"
#include "tga.h"
#include "common/setup_after.h"


static int rotate_updown(t_tgaimg *img);
static int rotate_leftright(t_tgaimg *img);
static int RLE_decompress(FILE *f, void *buf, int bufsize, int pixelsize);
static void RLE_write_pkt(FILE *f, t_tgapkttype pkttype, int len, void *data, int pixelsize);
static int RLE_compress(FILE *f, t_tgaimg const *img);


static int rotate_updown(t_tgaimg *img) {
        unsigned char *ndata;
        int pixelsize;
        int y;
        if (img == NULL) return -1;
        if (img->data == NULL) return -1;
        pixelsize = getpixelsize(img);
        if (pixelsize == 0) return -1;
        ndata = malloc(img->width*img->height*pixelsize);
        for (y = 0; y < img->height; y++) {
                memcpy(ndata + (y*img->width*pixelsize),
                       img->data + ((img->width*img->height*pixelsize)-((y+1)*img->width*pixelsize)),
                       img->width*pixelsize);
        }
        free(img->data);
        img->data = ndata;
        return 0;
}

static int rotate_leftright(t_tgaimg *img) {
        unsigned char *ndata, *datap;
        int pixelsize;
        int y,x;
        fprintf(stderr,"WARNING: rotate_leftright: this function is untested!\n");
        if (img == NULL) return -1;
        if (img->data == NULL) return -1;
        pixelsize = getpixelsize(img);
        if (pixelsize == 0) return -1;
        ndata = malloc(img->width*img->height*pixelsize);
        datap = img->data;
        for (y = 0; y < img->height; y++) {
                unsigned char *linep = (ndata + (((y+1)*img->width*pixelsize)-pixelsize));
                for (x = 0; x < img->width; x++) {
                        memcpy(linep,datap,pixelsize);
                        linep -= pixelsize;
                        datap += pixelsize;
                }
        }
        free(img->data);
        img->data = ndata;
        
        return 0;
}

extern int getpixelsize(t_tgaimg const *img) {
        switch (img->bpp) {
                case 8:
                        return 1;
                case 15:
                case 16:
                        return 2;
                case 24:
                        return 3;
                case 32:
                        return 4;
                default:
                        fprintf(stderr,"load_tga: color depth %u is not supported!\n",img->bpp);
                        return 0;
        }
}


extern t_tgaimg * new_tgaimg(unsigned int width, unsigned int height, unsigned int bpp, t_tgaimgtype imgtype) {
        t_tgaimg *img;
        
        img = malloc(sizeof(t_tgaimg));
        img->idlen = 0;
        img->cmaptype = tgacmap_none;
        img->imgtype = imgtype;
        img->cmapfirst = 0;
        img->cmaplen = 0;
        img->cmapes = 0;
        img->xorigin = 0;
        img->yorigin = 0;
        img->width = width;
        img->height = height;
        img->bpp = bpp;
        img->desc = 0; /* no attribute bits, top, left, and zero reserved */
        img->data = NULL;
        img->extareaoff = 0;
        img->devareaoff = 0;
        
        return img;
}

extern t_tgaimg * load_tgaheader(void) {
        t_tgaimg *img;
        
        img = malloc(sizeof(t_tgaimg));
        img->idlen = file_readb();
        img->cmaptype = file_readb();
        img->imgtype = file_readb();
        img->cmapfirst = file_readw_le();
        img->cmaplen = file_readw_le();
        img->cmapes = file_readb();
        img->xorigin = file_readw_le();
        img->yorigin = file_readw_le();
        img->width = file_readw_le();
        img->height = file_readw_le();
        img->bpp = file_readb();
        img->desc = file_readb();
        img->data = NULL;
        img->extareaoff = 0; /* ignored when reading */
        img->devareaoff = 0; /* ignored when reading */
        
        return img;
}

extern t_tgaimg * load_tga(FILE *f) {
        t_tgaimg *img;
        int pixelsize;
        
        file_rpush(f);
        img = load_tgaheader();
        
        /* make sure we understand the header fields */
        if (img->cmaptype != tgacmap_none) {
                fprintf(stderr,"load_tga: Color-mapped images are not (yet?) supported!\n");
                free(img);
                return NULL;
        }
        if (img->imgtype!=tgaimgtype_uncompressed_truecolor && img->imgtype!=tgaimgtype_rlecompressed_truecolor) {
                fprintf(stderr,"load_tga: imagetype %u is not supported. (only 2 and 10 are supported)\n",img->imgtype);
                free(img);
                return NULL;
        }
        
        pixelsize = getpixelsize(img);
        if (pixelsize == 0) {
                free(img);
                return NULL;
        }
        /* Skip the ID if there is one */
        if (img->idlen > 0) {
                fprintf(stderr,"load_tga: ID present, skipping %d bytes\n",img->idlen);
                if (fseek(f,img->idlen,SEEK_CUR)<0)
                        fprintf(stderr,"load_tga: could not seek %u bytes forward (fseek: %s)\n",img->idlen,pstrerror(errno));
        }
        
        /* Now, we can alloc img->data */
        img->data = malloc(img->width*img->height*pixelsize);
        if (img->imgtype == tgaimgtype_uncompressed_truecolor) {
                if (fread(img->data,pixelsize,img->width*img->height,f)<(unsigned)(img->width*img->height)) {
                        fprintf(stderr,"load_tga: error while reading data!\n");
                        free(img->data);
                        free(img);
                        return NULL;
                }
        }
        else { /* == tgaimgtype_rlecompressed_truecolor */
                if (RLE_decompress(f,img->data,img->width*img->height*pixelsize,pixelsize) < 0) {
                        fprintf(stderr,"load_tga: error while decompressing data!\n");
                        free(img->data);
                        free(img);
                        return NULL;
                }
        }
        file_rpop();
        if ((img->desc & tgadesc_horz) == 1) { /* right, want left */
                if (rotate_leftright(img)<0) {
                        fprintf(stderr,"ERROR: rotate_leftright failed!\n");
                }
        }
        if ((img->desc & tgadesc_vert) == 0) { /* bottom, want top */
                if (rotate_updown(img)<0) {
                        fprintf(stderr,"ERROR: rotate_updown failed!\n");
                }
        }
        return img;
}

extern int write_tga(FILE *f, t_tgaimg *img) {
        if (f == NULL) return -1;
        if (img == NULL) return -1;
        if (img->data == NULL) return -1;
        if (img->idlen!=0) return -1;
        if (img->cmaptype!=tgacmap_none) return -1;
        if (img->imgtype!=tgaimgtype_uncompressed_truecolor && img->imgtype!=tgaimgtype_rlecompressed_truecolor) return -1;
        file_wpush(f);
        
        file_writeb(img->idlen);
        file_writeb(img->cmaptype);
        file_writeb(img->imgtype);
        file_writew_le(img->cmapfirst);
        file_writew_le(img->cmaplen);
        file_writeb(img->cmapes);
        file_writew_le(img->xorigin);
        file_writew_le(img->yorigin);
        file_writew_le(img->width);
        file_writew_le(img->height);
        file_writeb(img->bpp);
        file_writeb(img->desc);
        
        if ((img->desc&tgadesc_horz)==1) { /* right, want left */
                fprintf(stderr,"write_tga: flipping horizontally\n");
                if (rotate_leftright(img)<0) {
                        fprintf(stderr,"ERROR: rotate_updown failed!\n");
                }
        }
        if ((img->desc&tgadesc_vert)==0) { /* bottom, want top */
                fprintf(stderr,"write_tga: flipping vertically\n");
                if (rotate_updown(img)<0) {
                        fprintf(stderr,"ERROR: rotate_updown failed!\n");
                }
        }
        if (img->imgtype==tgaimgtype_uncompressed_truecolor) {
                int pixelsize;
                
                pixelsize = getpixelsize(img);
                if (pixelsize == 0) return -1;
                if (fwrite(img->data,pixelsize,img->width*img->height,f)<(unsigned)(img->width*img->height)) {
                        fprintf(stderr,"write_tga: could not write %d pixels (fwrite: %s)\n",img->width*img->height,pstrerror(errno));
                        file_wpop();
                        return -1;
                }
        } else if (img->imgtype==tgaimgtype_rlecompressed_truecolor) {
                fprintf(stderr,"write_tga: using RLE compression\n");
                if (RLE_compress(f,img)<0) {
                        fprintf(stderr,"write_tga: RLE compression failed.\n");
                }
        }
        /* Write the file-footer */
        file_writed_le(img->extareaoff);
        file_writed_le(img->devareaoff);
        if (fwrite(TGAMAGIC,strlen(TGAMAGIC)+1,1,f)<1)
                fprintf(stderr,"write_tga: could not write TGA footer magic (fwrite: %s)\n",pstrerror(errno));
        /* Ready */
        file_wpop();
        return 0;
}

static int RLE_decompress(FILE *f, void *buf, int bufsize, int pixelsize) {
        unsigned char pt;
        unsigned char *bufp;
        unsigned char temp[8]; /* MAXPIXELSIZE */
        int bufi;
        int count;
        
        file_rpush(f);
        bufp = buf;
        for (bufi=0; bufi<bufsize; ) {
                pt = file_readb();
                if (feof(f)) {
                        fprintf(stderr,"RLE_decompress: after final packet only got %d of %d bytes\n",bufi,bufsize);
                        file_rpop();
                        return -1;
                }
                count = (pt & 0x7f)+1;
                if (bufi+count*pixelsize>bufsize) {
                        fprintf(stderr,"RLE_decompress: buffer too short for next packet (need %d bytes, have %d)\n",bufi+count*pixelsize,bufsize);
                        file_rpop();
                        return -1;
                }
                if ((pt & 0x80) == 0) { /* RAW PACKET */
                        if (fread(bufp,pixelsize,count,f)<(unsigned)count) {
                                if (feof(f))
                                        fprintf(stderr,"RLE_decompress: short RAW packet (expected %d bytes) (EOF)\n",pixelsize*count);
                                else
                                        fprintf(stderr,"RLE_decompress: short RAW packet (expected %d bytes) (fread: %s)\n",pixelsize*count,pstrerror(errno));
#if 0
                                file_rpop();
                                return -1;
#endif
                        }
                        bufp += count*pixelsize;
                        bufi += count*pixelsize;
                } else { /* RLE PACKET */
                        if (fread(temp,pixelsize,1,f) < 1) {
                                if (feof(f))
                                        fprintf(stderr,"RLE_decompress: short RLE packet (expected %d bytes) (EOF)\n",pixelsize);
                                else
                                        fprintf(stderr,"RLE_decompress: short RLE packet (expected %d bytes) (fread: %s)\n",pixelsize,pstrerror(errno));
#if 0
                                file_rpop();
                                return -1;
#endif
                        }
                        if (count<2) {
                                fprintf(stderr,"RLE_decompress: suspicious RLE repetition count %d\n",count);
                        }
                        for (;count > 0; count--) {
                                memcpy(bufp,temp,pixelsize);
                                bufp += pixelsize;
                                bufi += pixelsize;
                        }
                }
        }
        file_rpop();
        return 0;
}

static void RLE_write_pkt(FILE *f, t_tgapkttype pkttype, int len, void *data, int pixelsize) {
        unsigned char count;
        
        if (len<1 || len>128) {
                fprintf(stderr,"RLE_write_pkt: packet has bad length (%d bytes)\n",len);
                return;
        }
        if (pkttype==RLE) {
                if (len<2) {
                        fprintf(stderr,"RLE_write_pkt: RLE packet has bad length (%d bytes)\n",len);
                        return;
                }
                count = (unsigned char)(0x80 | (len-1));
                if (fwrite(&count, 1, 1, f)<1)
                        fprintf(stderr,"RLE_write_pkt: could not write RLE pixel count (fwrite: %s)\n",pstrerror(errno));
                if (fwrite(data, pixelsize, 1, f)<1)
                        fprintf(stderr,"RLE_write_pkt: could not write RLE pixel value (fwrite: %s)\n",pstrerror(errno));
        } else {
                count = (unsigned char) (len-1);
                if (fwrite(&count, 1, 1, f)<1)
                        fprintf(stderr,"RLE_write_pkt: could not write RAW pixel count (fwrite: %s)\n",pstrerror(errno));
                if (fwrite(data,pixelsize,len,f)<(unsigned)len)
                        fprintf(stderr,"RLE_write_pkt: could not write %d RAW pixels (fwrite: %s)\n",len,pstrerror(errno));
        }
}


static int RLE_compress(FILE *f, t_tgaimg const *img) {
        int pixelsize;
        unsigned char const *datap;
        unsigned char *pktdata;
        unsigned int pktlen;
        t_tgapkttype pkttype;
        unsigned char *pktdatap;
        unsigned int actual=0,perceived=0;
        int i;

        pkttype = RAW;
        pktdatap = NULL;
        
        if (img == NULL) return -1;
        if (img->data == NULL) return -1;
        pixelsize = getpixelsize(img);
        if (pixelsize == 0) return -1;
        
        datap = img->data;
        pktdata = malloc(img->width*img->height*pixelsize);
        pktlen = 0;
        
        for (i=0; i<img->width*img->height; ) {
                if (pktlen == 0) {
                        pktdatap = pktdata;
                        memcpy(pktdatap,datap,pixelsize);
                        pktlen++;
                        i++;
                        pktdatap += pixelsize;
                        datap += pixelsize;
                        pkttype = RAW;
                        continue;
                }
                if (pktlen == 1) {
                        if (memcmp(datap-pixelsize,datap,pixelsize)==0) {
                                pkttype = RLE;
                        }
                }
                if (pkttype == RLE) {
                        if (memcmp(datap-pixelsize,datap,pixelsize)!=0 || pktlen>=128) {
                                RLE_write_pkt(f,pkttype,pktlen,pktdata,pixelsize);
                                actual += 1+pixelsize;
                                perceived += pixelsize*pktlen;
                                pktlen = 0;
                        } else {
                                pktlen++;
                                i++;
                                datap += pixelsize;
                        }
                } else {
                        if (memcmp(datap-pixelsize,datap,pixelsize)==0 || pktlen>=129) {
                                datap -= pixelsize; /* push back last pixel */
                                i--;
                                if (i<0) fprintf(stderr,"BUG!\n");
                                pktlen--;
                                RLE_write_pkt(f,pkttype,pktlen,pktdata,pixelsize);
                                actual += 1+pixelsize*pktlen;
                                perceived += pixelsize*pktlen;
                                pktlen = 0;
                        } else {
                                memcpy(pktdatap,datap,pixelsize);
                                pktlen++;
                                i++;
                                pktdatap += pixelsize;
                                datap += pixelsize;
                        }
                }
        }
        if (pktlen) {
                RLE_write_pkt(f,pkttype,pktlen,pktdata,pixelsize);
                if (pkttype==RLE) {
                        actual += 1+pixelsize;
                        perceived += pixelsize*pktlen;
                } else {
                        actual += 1+pixelsize*pktlen;
                        perceived += pixelsize*pktlen;
                }
                pktlen = 0;
        }
        fprintf(stderr,"RLE_compress: wrote %u bytes (%u uncompressed)\n",actual,perceived);
        return 0;
}

extern void destroy_img(t_tgaimg * img) {
        if (img == NULL) return;
        
        if (img->data)
                free(img->data);
        free(img);
}

extern void print_tga_info(t_tgaimg const * img, FILE * fp) {
        unsigned int interleave;
        unsigned int attrbits;
        char const * typestr;
        char const * cmapstr;
        char const * horzstr;
        char const * vertstr;
        char const * intlstr;
        
        if (!img || !fp)
                return;
        
        interleave = ((img->desc&tgadesc_interleave1)!=0)*2+((img->desc&tgadesc_interleave2)!=0);
        attrbits = img->desc&(tgadesc_attrbits0|tgadesc_attrbits1|tgadesc_attrbits2|tgadesc_attrbits3);
        switch (img->imgtype) {
        case tgaimgtype_empty:
                typestr = "No Image Data Included";
                break;
        case tgaimgtype_uncompressed_mapped:
                typestr = "Uncompressed, Color-mapped Image";
                break;
        case tgaimgtype_uncompressed_truecolor:
                typestr = "Uncompressed, True-color Image";
                break;
        case tgaimgtype_uncompressed_monochrome:
                typestr = "Uncompressed, Black-and-white image";
                break;
        case tgaimgtype_rlecompressed_mapped:
                typestr = "Run-length encoded, Color-mapped Image";
                break;
        case tgaimgtype_rlecompressed_truecolor:
                typestr = "Run-length encoded, True-color Image";
                break;
        case tgaimgtype_rlecompressed_monochrome:
                typestr = "Run-length encoded, Black-and-white image";
                break;
        case tgaimgtype_huffman_mapped:
                typestr = "Huffman encoded, Color-mapped image";
                break;
        case tgaimgtype_huffman_4pass_mapped:
                typestr = "Four-pass Huffman encoded, Color-mapped image";
                break;
        default:
                typestr = "unknown";
        }
        switch (img->cmaptype) {
        case tgacmap_none:
                cmapstr = "None";
                break;
        case tgacmap_included:
                cmapstr = "Included";
                break;
        default:
                cmapstr = "Unknown";
        }
        if ((img->desc&tgadesc_horz)==0) {
                horzstr = "left";
        } else {
                horzstr = "right";
        }
        if ((img->desc&tgadesc_vert)==0) {
                vertstr = "bottom";
        } else {
                vertstr = "top";
        }
        switch (interleave) {
        case 0:
                intlstr = "none";
                break;
        case 2:
                intlstr = "two way";
                break;
        case 3:
                intlstr = "four way";
                break;
        case 4:
        default:
                intlstr = "unknown";
                break;
        }
        
        fprintf(fp,"TGAHeader: IDLength=%u ColorMapType=%u(%s)\n",img->idlen,img->cmaptype,cmapstr);
        fprintf(fp,"TGAHeader: ImageType=%u(%s)\n",img->imgtype,typestr);
        fprintf(fp,"TGAHeader: ColorMap: FirstEntryIndex=%u ColorMapLength=%u\n",img->cmapfirst,img->cmaplen);
        fprintf(fp,"TGAHeader: ColorMap: ColorMapEntrySize=%ubits\n",img->cmapes);
        fprintf(fp,"TGAHeader: X-origin=%u Y-origin=%u Width=%u(0x%x) Height=%u(0x%x)\n",img->xorigin,img->yorigin,img->width,img->width,img->height,img->height);
        fprintf(fp,"TGAHeader: PixelDepth=%ubits ImageDescriptor=0x%02x(%u attribute bits, origin is %s %s, interleave=%s)\n",img->bpp,img->desc,attrbits,vertstr,horzstr,intlstr);
}
1	/*
2	Copyright (C) 2000 Marco Ziech (mmz@gmx.net)
3	Copyright (C) 2000 Ross Combs (rocombs@cs.nmsu.edu)
4
5	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 2 of the License, or
8	(at your option) any later version.
9
10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*/
19	#include "common/setup_before.h"
20	#include <stdio.h>
21	#ifdef STDC_HEADERS
22	# include <stdlib.h>
23	#else
24	# ifdef HAVE_MALLOC_H
25	# include <malloc.h>
26	# endif
27	#endif
28	#ifdef HAVE_STRING_H
29	# include <string.h>
30	#else
31	# ifdef HAVE_STRINGS_H
32	# include <strings.h>
33	# endif
34	#endif
35	#include <errno.h>
36	#include "compat/strerror.h"
37	#include "fileio.h"
38	#include "tga.h"
39	#include "common/setup_after.h"
40
41
42	static int rotate_updown(t_tgaimg *img);
43	static int rotate_leftright(t_tgaimg *img);
44	static int RLE_decompress(FILE f, void buf, int bufsize, int pixelsize);
45	static void RLE_write_pkt(FILE f, t_tgapkttype pkttype, int len, void data, int pixelsize);
46	static int RLE_compress(FILE f, t_tgaimg const img);
47
48
49	static int rotate_updown(t_tgaimg *img) {
50	unsigned char *ndata;
51	int pixelsize;
52	int y;
53	if (img == NULL) return -1;
54	if (img->data == NULL) return -1;
55	pixelsize = getpixelsize(img);
56	if (pixelsize == 0) return -1;
57	ndata = malloc(img->widthimg->heightpixelsize);
58	for (y = 0; y < img->height; y++) {
59	memcpy(ndata + (yimg->widthpixelsize),
60	img->data + ((img->widthimg->heightpixelsize)-((y+1)img->widthpixelsize)),
61	img->width*pixelsize);
62	}
63	free(img->data);
64	img->data = ndata;
65	return 0;
66	}
67
68	static int rotate_leftright(t_tgaimg *img) {
69	unsigned char ndata, datap;
70	int pixelsize;
71	int y,x;
72	fprintf(stderr,"WARNING: rotate_leftright: this function is untested!\n");
73	if (img == NULL) return -1;
74	if (img->data == NULL) return -1;
75	pixelsize = getpixelsize(img);
76	if (pixelsize == 0) return -1;
77	ndata = malloc(img->widthimg->heightpixelsize);
78	datap = img->data;
79	for (y = 0; y < img->height; y++) {
80	unsigned char linep = (ndata + (((y+1)img->width*pixelsize)-pixelsize));
81	for (x = 0; x < img->width; x++) {
82	memcpy(linep,datap,pixelsize);
83	linep -= pixelsize;
84	datap += pixelsize;
85	}
86	}
87	free(img->data);
88	img->data = ndata;
89
90	return 0;
91	}
92
93	extern int getpixelsize(t_tgaimg const *img) {
94	switch (img->bpp) {
95	case 8:
96	return 1;
97	case 15:
98	case 16:
99	return 2;
100	case 24:
101	return 3;
102	case 32:
103	return 4;
104	default:
105	fprintf(stderr,"load_tga: color depth %u is not supported!\n",img->bpp);
106	return 0;
107	}
108	}
109
110
111	extern t_tgaimg * new_tgaimg(unsigned int width, unsigned int height, unsigned int bpp, t_tgaimgtype imgtype) {
112	t_tgaimg *img;
113
114	img = malloc(sizeof(t_tgaimg));
115	img->idlen = 0;
116	img->cmaptype = tgacmap_none;
117	img->imgtype = imgtype;
118	img->cmapfirst = 0;
119	img->cmaplen = 0;
120	img->cmapes = 0;
121	img->xorigin = 0;
122	img->yorigin = 0;
123	img->width = width;
124	img->height = height;
125	img->bpp = bpp;
126	img->desc = 0; /* no attribute bits, top, left, and zero reserved */
127	img->data = NULL;
128	img->extareaoff = 0;
129	img->devareaoff = 0;
130
131	return img;
132	}
133
134	extern t_tgaimg * load_tgaheader(void) {
135	t_tgaimg *img;
136
137	img = malloc(sizeof(t_tgaimg));
138	img->idlen = file_readb();
139	img->cmaptype = file_readb();
140	img->imgtype = file_readb();
141	img->cmapfirst = file_readw_le();
142	img->cmaplen = file_readw_le();
143	img->cmapes = file_readb();
144	img->xorigin = file_readw_le();
145	img->yorigin = file_readw_le();
146	img->width = file_readw_le();
147	img->height = file_readw_le();
148	img->bpp = file_readb();
149	img->desc = file_readb();
150	img->data = NULL;
151	img->extareaoff = 0; /* ignored when reading */
152	img->devareaoff = 0; /* ignored when reading */
153
154	return img;
155	}
156
157	extern t_tgaimg * load_tga(FILE *f) {
158	t_tgaimg *img;
159	int pixelsize;
160
161	file_rpush(f);
162	img = load_tgaheader();
163
164	/* make sure we understand the header fields */
165	if (img->cmaptype != tgacmap_none) {
166	fprintf(stderr,"load_tga: Color-mapped images are not (yet?) supported!\n");
167	free(img);
168	return NULL;
169	}
170	if (img->imgtype!=tgaimgtype_uncompressed_truecolor && img->imgtype!=tgaimgtype_rlecompressed_truecolor) {
171	fprintf(stderr,"load_tga: imagetype %u is not supported. (only 2 and 10 are supported)\n",img->imgtype);
172	free(img);
173	return NULL;
174	}
175
176	pixelsize = getpixelsize(img);
177	if (pixelsize == 0) {
178	free(img);
179	return NULL;
180	}
181	/* Skip the ID if there is one */
182	if (img->idlen > 0) {
183	fprintf(stderr,"load_tga: ID present, skipping %d bytes\n",img->idlen);
184	if (fseek(f,img->idlen,SEEK_CUR)<0)
185	fprintf(stderr,"load_tga: could not seek %u bytes forward (fseek: %s)\n",img->idlen,pstrerror(errno));
186	}
187
188	/* Now, we can alloc img->data */
189	img->data = malloc(img->widthimg->heightpixelsize);
190	if (img->imgtype == tgaimgtype_uncompressed_truecolor) {
191	if (fread(img->data,pixelsize,img->widthimg->height,f)<(unsigned)(img->widthimg->height)) {
192	fprintf(stderr,"load_tga: error while reading data!\n");
193	free(img->data);
194	free(img);
195	return NULL;
196	}
197	}
198	else { /* == tgaimgtype_rlecompressed_truecolor */
199	if (RLE_decompress(f,img->data,img->widthimg->heightpixelsize,pixelsize) < 0) {
200	fprintf(stderr,"load_tga: error while decompressing data!\n");
201	free(img->data);
202	free(img);
203	return NULL;
204	}
205	}
206	file_rpop();
207	if ((img->desc & tgadesc_horz) == 1) { /* right, want left */
208	if (rotate_leftright(img)<0) {
209	fprintf(stderr,"ERROR: rotate_leftright failed!\n");
210	}
211	}
212	if ((img->desc & tgadesc_vert) == 0) { /* bottom, want top */
213	if (rotate_updown(img)<0) {
214	fprintf(stderr,"ERROR: rotate_updown failed!\n");
215	}
216	}
217	return img;
218	}
219
220	extern int write_tga(FILE f, t_tgaimg img) {
221	if (f == NULL) return -1;
222	if (img == NULL) return -1;
223	if (img->data == NULL) return -1;
224	if (img->idlen!=0) return -1;
225	if (img->cmaptype!=tgacmap_none) return -1;
226	if (img->imgtype!=tgaimgtype_uncompressed_truecolor && img->imgtype!=tgaimgtype_rlecompressed_truecolor) return -1;
227	file_wpush(f);
228
229	file_writeb(img->idlen);
230	file_writeb(img->cmaptype);
231	file_writeb(img->imgtype);
232	file_writew_le(img->cmapfirst);
233	file_writew_le(img->cmaplen);
234	file_writeb(img->cmapes);
235	file_writew_le(img->xorigin);
236	file_writew_le(img->yorigin);
237	file_writew_le(img->width);
238	file_writew_le(img->height);
239	file_writeb(img->bpp);
240	file_writeb(img->desc);
241
242	if ((img->desc&tgadesc_horz)==1) { /* right, want left */
243	fprintf(stderr,"write_tga: flipping horizontally\n");
244	if (rotate_leftright(img)<0) {
245	fprintf(stderr,"ERROR: rotate_updown failed!\n");
246	}
247	}
248	if ((img->desc&tgadesc_vert)==0) { /* bottom, want top */
249	fprintf(stderr,"write_tga: flipping vertically\n");
250	if (rotate_updown(img)<0) {
251	fprintf(stderr,"ERROR: rotate_updown failed!\n");
252	}
253	}
254	if (img->imgtype==tgaimgtype_uncompressed_truecolor) {
255	int pixelsize;
256
257	pixelsize = getpixelsize(img);
258	if (pixelsize == 0) return -1;
259	if (fwrite(img->data,pixelsize,img->widthimg->height,f)<(unsigned)(img->widthimg->height)) {
260	fprintf(stderr,"write_tga: could not write %d pixels (fwrite: %s)\n",img->width*img->height,pstrerror(errno));
261	file_wpop();
262	return -1;
263	}
264	} else if (img->imgtype==tgaimgtype_rlecompressed_truecolor) {
265	fprintf(stderr,"write_tga: using RLE compression\n");
266	if (RLE_compress(f,img)<0) {
267	fprintf(stderr,"write_tga: RLE compression failed.\n");
268	}
269	}
270	/* Write the file-footer */
271	file_writed_le(img->extareaoff);
272	file_writed_le(img->devareaoff);
273	if (fwrite(TGAMAGIC,strlen(TGAMAGIC)+1,1,f)<1)
274	fprintf(stderr,"write_tga: could not write TGA footer magic (fwrite: %s)\n",pstrerror(errno));
275	/* Ready */
276	file_wpop();
277	return 0;
278	}
279
280	static int RLE_decompress(FILE f, void buf, int bufsize, int pixelsize) {
281	unsigned char pt;
282	unsigned char *bufp;
283	unsigned char temp[8]; /* MAXPIXELSIZE */
284	int bufi;
285	int count;
286
287	file_rpush(f);
288	bufp = buf;
289	for (bufi=0; bufi<bufsize; ) {
290	pt = file_readb();
291	if (feof(f)) {
292	fprintf(stderr,"RLE_decompress: after final packet only got %d of %d bytes\n",bufi,bufsize);
293	file_rpop();
294	return -1;
295	}
296	count = (pt & 0x7f)+1;
297	if (bufi+count*pixelsize>bufsize) {
298	fprintf(stderr,"RLE_decompress: buffer too short for next packet (need %d bytes, have %d)\n",bufi+count*pixelsize,bufsize);
299	file_rpop();
300	return -1;
301	}
302	if ((pt & 0x80) == 0) { /* RAW PACKET */
303	if (fread(bufp,pixelsize,count,f)<(unsigned)count) {
304	if (feof(f))
305	fprintf(stderr,"RLE_decompress: short RAW packet (expected %d bytes) (EOF)\n",pixelsize*count);
306	else
307	fprintf(stderr,"RLE_decompress: short RAW packet (expected %d bytes) (fread: %s)\n",pixelsize*count,pstrerror(errno));
308	#if 0
309	file_rpop();
310	return -1;
311	#endif
312	}
313	bufp += count*pixelsize;
314	bufi += count*pixelsize;
315	} else { /* RLE PACKET */
316	if (fread(temp,pixelsize,1,f) < 1) {
317	if (feof(f))
318	fprintf(stderr,"RLE_decompress: short RLE packet (expected %d bytes) (EOF)\n",pixelsize);
319	else
320	fprintf(stderr,"RLE_decompress: short RLE packet (expected %d bytes) (fread: %s)\n",pixelsize,pstrerror(errno));
321	#if 0
322	file_rpop();
323	return -1;
324	#endif
325	}
326	if (count<2) {
327	fprintf(stderr,"RLE_decompress: suspicious RLE repetition count %d\n",count);
328	}
329	for (;count > 0; count--) {
330	memcpy(bufp,temp,pixelsize);
331	bufp += pixelsize;
332	bufi += pixelsize;
333	}
334	}
335	}
336	file_rpop();
337	return 0;
338	}
339
340	static void RLE_write_pkt(FILE f, t_tgapkttype pkttype, int len, void data, int pixelsize) {
341	unsigned char count;
342
343	if (len<1 \|\| len>128) {
344	fprintf(stderr,"RLE_write_pkt: packet has bad length (%d bytes)\n",len);
345	return;
346	}
347	if (pkttype==RLE) {
348	if (len<2) {
349	fprintf(stderr,"RLE_write_pkt: RLE packet has bad length (%d bytes)\n",len);
350	return;
351	}
352	count = (unsigned char)(0x80 \| (len-1));
353	if (fwrite(&count, 1, 1, f)<1)
354	fprintf(stderr,"RLE_write_pkt: could not write RLE pixel count (fwrite: %s)\n",pstrerror(errno));
355	if (fwrite(data, pixelsize, 1, f)<1)
356	fprintf(stderr,"RLE_write_pkt: could not write RLE pixel value (fwrite: %s)\n",pstrerror(errno));
357	} else {
358	count = (unsigned char) (len-1);
359	if (fwrite(&count, 1, 1, f)<1)
360	fprintf(stderr,"RLE_write_pkt: could not write RAW pixel count (fwrite: %s)\n",pstrerror(errno));
361	if (fwrite(data,pixelsize,len,f)<(unsigned)len)
362	fprintf(stderr,"RLE_write_pkt: could not write %d RAW pixels (fwrite: %s)\n",len,pstrerror(errno));
363	}
364	}
365
366
367	static int RLE_compress(FILE f, t_tgaimg const img) {
368	int pixelsize;
369	unsigned char const *datap;
370	unsigned char *pktdata;
371	unsigned int pktlen;
372	t_tgapkttype pkttype;
373	unsigned char *pktdatap;
374	unsigned int actual=0,perceived=0;
375	int i;
376
377	pkttype = RAW;
378	pktdatap = NULL;
379
380	if (img == NULL) return -1;
381	if (img->data == NULL) return -1;
382	pixelsize = getpixelsize(img);
383	if (pixelsize == 0) return -1;
384
385	datap = img->data;
386	pktdata = malloc(img->widthimg->heightpixelsize);
387	pktlen = 0;
388
389	for (i=0; i<img->width*img->height; ) {
390	if (pktlen == 0) {
391	pktdatap = pktdata;
392	memcpy(pktdatap,datap,pixelsize);
393	pktlen++;
394	i++;
395	pktdatap += pixelsize;
396	datap += pixelsize;
397	pkttype = RAW;
398	continue;
399	}
400	if (pktlen == 1) {
401	if (memcmp(datap-pixelsize,datap,pixelsize)==0) {
402	pkttype = RLE;
403	}
404	}
405	if (pkttype == RLE) {
406	if (memcmp(datap-pixelsize,datap,pixelsize)!=0 \|\| pktlen>=128) {
407	RLE_write_pkt(f,pkttype,pktlen,pktdata,pixelsize);
408	actual += 1+pixelsize;
409	perceived += pixelsize*pktlen;
410	pktlen = 0;
411	} else {
412	pktlen++;
413	i++;
414	datap += pixelsize;
415	}
416	} else {
417	if (memcmp(datap-pixelsize,datap,pixelsize)==0 \|\| pktlen>=129) {
418	datap -= pixelsize; /* push back last pixel */
419	i--;
420	if (i<0) fprintf(stderr,"BUG!\n");
421	pktlen--;
422	RLE_write_pkt(f,pkttype,pktlen,pktdata,pixelsize);
423	actual += 1+pixelsize*pktlen;
424	perceived += pixelsize*pktlen;
425	pktlen = 0;
426	} else {
427	memcpy(pktdatap,datap,pixelsize);
428	pktlen++;
429	i++;
430	pktdatap += pixelsize;
431	datap += pixelsize;
432	}
433	}
434	}
435	if (pktlen) {
436	RLE_write_pkt(f,pkttype,pktlen,pktdata,pixelsize);
437	if (pkttype==RLE) {
438	actual += 1+pixelsize;
439	perceived += pixelsize*pktlen;
440	} else {
441	actual += 1+pixelsize*pktlen;
442	perceived += pixelsize*pktlen;
443	}
444	pktlen = 0;
445	}
446	fprintf(stderr,"RLE_compress: wrote %u bytes (%u uncompressed)\n",actual,perceived);
447	return 0;
448	}
449
450	extern void destroy_img(t_tgaimg * img) {
451	if (img == NULL) return;
452
453	if (img->data)
454	free(img->data);
455	free(img);
456	}
457
458	extern void print_tga_info(t_tgaimg const * img, FILE * fp) {
459	unsigned int interleave;
460	unsigned int attrbits;
461	char const * typestr;
462	char const * cmapstr;
463	char const * horzstr;
464	char const * vertstr;
465	char const * intlstr;
466
467	if (!img \|\| !fp)
468	return;
469
470	interleave = ((img->desc&tgadesc_interleave1)!=0)*2+((img->desc&tgadesc_interleave2)!=0);
471	attrbits = img->desc&(tgadesc_attrbits0\|tgadesc_attrbits1\|tgadesc_attrbits2\|tgadesc_attrbits3);
472	switch (img->imgtype) {
473	case tgaimgtype_empty:
474	typestr = "No Image Data Included";
475	break;
476	case tgaimgtype_uncompressed_mapped:
477	typestr = "Uncompressed, Color-mapped Image";
478	break;
479	case tgaimgtype_uncompressed_truecolor:
480	typestr = "Uncompressed, True-color Image";
481	break;
482	case tgaimgtype_uncompressed_monochrome:
483	typestr = "Uncompressed, Black-and-white image";
484	break;
485	case tgaimgtype_rlecompressed_mapped:
486	typestr = "Run-length encoded, Color-mapped Image";
487	break;
488	case tgaimgtype_rlecompressed_truecolor:
489	typestr = "Run-length encoded, True-color Image";
490	break;
491	case tgaimgtype_rlecompressed_monochrome:
492	typestr = "Run-length encoded, Black-and-white image";
493	break;
494	case tgaimgtype_huffman_mapped:
495	typestr = "Huffman encoded, Color-mapped image";
496	break;
497	case tgaimgtype_huffman_4pass_mapped:
498	typestr = "Four-pass Huffman encoded, Color-mapped image";
499	break;
500	default:
501	typestr = "unknown";
502	}
503	switch (img->cmaptype) {
504	case tgacmap_none:
505	cmapstr = "None";
506	break;
507	case tgacmap_included:
508	cmapstr = "Included";
509	break;
510	default:
511	cmapstr = "Unknown";
512	}
513	if ((img->desc&tgadesc_horz)==0) {
514	horzstr = "left";
515	} else {
516	horzstr = "right";
517	}
518	if ((img->desc&tgadesc_vert)==0) {
519	vertstr = "bottom";
520	} else {
521	vertstr = "top";
522	}
523	switch (interleave) {
524	case 0:
525	intlstr = "none";
526	break;
527	case 2:
528	intlstr = "two way";
529	break;
530	case 3:
531	intlstr = "four way";
532	break;
533	case 4:
534	default:
535	intlstr = "unknown";
536	break;
537	}
538
539	fprintf(fp,"TGAHeader: IDLength=%u ColorMapType=%u(%s)\n",img->idlen,img->cmaptype,cmapstr);
540	fprintf(fp,"TGAHeader: ImageType=%u(%s)\n",img->imgtype,typestr);
541	fprintf(fp,"TGAHeader: ColorMap: FirstEntryIndex=%u ColorMapLength=%u\n",img->cmapfirst,img->cmaplen);
542	fprintf(fp,"TGAHeader: ColorMap: ColorMapEntrySize=%ubits\n",img->cmapes);
543	fprintf(fp,"TGAHeader: X-origin=%u Y-origin=%u Width=%u(0x%x) Height=%u(0x%x)\n",img->xorigin,img->yorigin,img->width,img->width,img->height,img->height);
544	fprintf(fp,"TGAHeader: PixelDepth=%ubits ImageDescriptor=0x%02x(%u attribute bits, origin is %s %s, interleave=%s)\n",img->bpp,img->desc,attrbits,vertstr,horzstr,intlstr);
545	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1