vertex arrays renamed to varray_ and exposed to rest of engine
[divverent/darkplaces.git] / image.c
1
2 #include "quakedef.h"
3
4 int             image_width;
5 int             image_height;
6
7 void Image_GammaRemapRGB(qbyte *in, qbyte *out, int pixels, qbyte *gammar, qbyte *gammag, qbyte *gammab)
8 {
9         while (pixels--)
10         {
11                 out[0] = gammar[in[0]];
12                 out[1] = gammag[in[1]];
13                 out[2] = gammab[in[2]];
14                 in += 3;
15                 out += 3;
16         }
17 }
18
19 // note: pal must be 32bit color
20 void Image_Copy8bitRGBA(qbyte *in, qbyte *out, int pixels, int *pal)
21 {
22         int *iout = (void *)out;
23         while (pixels >= 8)
24         {
25                 iout[0] = pal[in[0]];
26                 iout[1] = pal[in[1]];
27                 iout[2] = pal[in[2]];
28                 iout[3] = pal[in[3]];
29                 iout[4] = pal[in[4]];
30                 iout[5] = pal[in[5]];
31                 iout[6] = pal[in[6]];
32                 iout[7] = pal[in[7]];
33                 in += 8;
34                 iout += 8;
35                 pixels -= 8;
36         }
37         if (pixels & 4)
38         {
39                 iout[0] = pal[in[0]];
40                 iout[1] = pal[in[1]];
41                 iout[2] = pal[in[2]];
42                 iout[3] = pal[in[3]];
43                 in += 4;
44                 iout += 4;
45         }
46         if (pixels & 2)
47         {
48                 iout[0] = pal[in[0]];
49                 iout[1] = pal[in[1]];
50                 in += 2;
51                 iout += 2;
52         }
53         if (pixels & 1)
54                 iout[0] = pal[in[0]];
55 }
56
57 /*
58 =================================================================
59
60   PCX Loading
61
62 =================================================================
63 */
64
65 typedef struct
66 {
67     char        manufacturer;
68     char        version;
69     char        encoding;
70     char        bits_per_pixel;
71     unsigned short      xmin,ymin,xmax,ymax;
72     unsigned short      hres,vres;
73     unsigned char       palette[48];
74     char        reserved;
75     char        color_planes;
76     unsigned short      bytes_per_line;
77     unsigned short      palette_type;
78     char        filler[58];
79 } pcx_t;
80
81 /*
82 ============
83 LoadPCX
84 ============
85 */
86 qbyte* LoadPCX (qbyte *f, int matchwidth, int matchheight)
87 {
88         pcx_t pcx;
89         qbyte *palette, *a, *b, *image_rgba, *fin, *pbuf, *enddata;
90         int x, y, x2, dataByte;
91
92         if (loadsize < sizeof(pcx) + 768)
93         {
94                 Con_Printf ("Bad pcx file\n");
95                 return NULL;
96         }
97
98         fin = f;
99
100         memcpy(&pcx, fin, sizeof(pcx));
101         fin += sizeof(pcx);
102
103         // LordHavoc: big-endian support ported from QF newtree
104         pcx.xmax = LittleShort (pcx.xmax);
105         pcx.xmin = LittleShort (pcx.xmin);
106         pcx.ymax = LittleShort (pcx.ymax);
107         pcx.ymin = LittleShort (pcx.ymin);
108         pcx.hres = LittleShort (pcx.hres);
109         pcx.vres = LittleShort (pcx.vres);
110         pcx.bytes_per_line = LittleShort (pcx.bytes_per_line);
111         pcx.palette_type = LittleShort (pcx.palette_type);
112
113         if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 || pcx.bits_per_pixel != 8 || pcx.xmax > 320 || pcx.ymax > 256)
114         {
115                 Con_Printf ("Bad pcx file\n");
116                 return NULL;
117         }
118
119         if (matchwidth && (pcx.xmax+1) != matchwidth)
120         {
121                 return NULL;
122         }
123         if (matchheight && (pcx.ymax+1) != matchheight)
124         {
125                 return NULL;
126         }
127
128         image_width = pcx.xmax+1;
129         image_height = pcx.ymax+1;
130
131         palette = f + loadsize - 768;
132
133         image_rgba = Mem_Alloc(tempmempool, image_width*image_height*4);
134         if (!image_rgba)
135         {
136                 Con_Printf("LoadPCX: not enough memory for %i by %i image\n", image_width, image_height);
137                 return NULL;
138         }
139         pbuf = image_rgba + image_width*image_height*3;
140         enddata = palette;
141
142         for (y = 0;y < image_height && fin < enddata;y++)
143         {
144                 a = pbuf + y * image_width;
145                 for (x = 0;x < image_width && fin < enddata;)
146                 {
147                         dataByte = *fin++;
148                         if(dataByte >= 0xC0)
149                         {
150                                 if (fin >= enddata)
151                                         break;
152                                 x2 = x + (dataByte & 0x3F);
153                                 dataByte = *fin++;
154                                 if (x2 > image_width)
155                                         x2 = image_width; // technically an error
156                                 while(x < x2)
157                                         a[x++] = dataByte;
158                         }
159                         else
160                                 a[x++] = dataByte;
161                 }
162                 fin += pcx.bytes_per_line - image_width; // the number of bytes per line is always forced to an even number
163                 while(x < image_width)
164                         a[x++] = 0;
165         }
166
167         a = image_rgba;
168         b = pbuf;
169
170         for(x = 0;x < image_width*image_height;x++)
171         {
172                 y = *b++ * 3;
173                 *a++ = palette[y];
174                 *a++ = palette[y+1];
175                 *a++ = palette[y+2];
176                 *a++ = 255;
177         }
178
179         return image_rgba;
180 }
181
182 /*
183 =========================================================
184
185 TARGA LOADING
186
187 =========================================================
188 */
189
190 typedef struct _TargaHeader
191 {
192         unsigned char   id_length, colormap_type, image_type;
193         unsigned short  colormap_index, colormap_length;
194         unsigned char   colormap_size;
195         unsigned short  x_origin, y_origin, width, height;
196         unsigned char   pixel_size, attributes;
197 }
198 TargaHeader;
199
200 TargaHeader             targa_header;
201
202
203 /*
204 =============
205 LoadTGA
206 =============
207 */
208 qbyte *LoadTGA (qbyte *f, int matchwidth, int matchheight)
209 {
210         int x, y, row_inc;
211         unsigned char red, green, blue, alpha, run, runlen;
212         qbyte *pixbuf, *image_rgba, *fin, *enddata;
213
214         if (loadsize < 18+3)
215                 return NULL;
216         targa_header.id_length = f[0];
217         targa_header.colormap_type = f[1];
218         targa_header.image_type = f[2];
219
220         targa_header.colormap_index = f[3] + f[4] * 256;
221         targa_header.colormap_length = f[5] + f[6] * 256;
222         targa_header.colormap_size = f[7];
223         targa_header.x_origin = f[8] + f[9] * 256;
224         targa_header.y_origin = f[10] + f[11] * 256;
225         targa_header.width = f[12] + f[13] * 256;
226         targa_header.height = f[14] + f[15] * 256;
227         if (matchwidth && targa_header.width != matchwidth)
228                 return NULL;
229         if (matchheight && targa_header.height != matchheight)
230                 return NULL;
231         targa_header.pixel_size = f[16];
232         targa_header.attributes = f[17];
233
234         if (targa_header.image_type != 2 && targa_header.image_type != 10)
235         {
236                 Con_Printf ("LoadTGA: Only type 2 and 10 targa RGB images supported\n");
237                 return NULL;
238         }
239
240         if (targa_header.colormap_type != 0     || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24))
241         {
242                 Con_Printf ("LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
243                 return NULL;
244         }
245
246         enddata = f + loadsize;
247
248         image_width = targa_header.width;
249         image_height = targa_header.height;
250
251         image_rgba = Mem_Alloc(tempmempool, image_width * image_height * 4);
252         if (!image_rgba)
253         {
254                 Con_Printf ("LoadTGA: not enough memory for %i by %i image\n", image_width, image_height);
255                 return NULL;
256         }
257
258         fin = f + 18;
259         if (targa_header.id_length != 0)
260                 fin += targa_header.id_length;  // skip TARGA image comment
261
262         // If bit 5 of attributes isn't set, the image has been stored from bottom to top
263         if ((targa_header.attributes & 0x20) == 0)
264         {
265                 pixbuf = image_rgba + (image_height - 1)*image_width*4;
266                 row_inc = -image_width*4*2;
267         }
268         else
269         {
270                 pixbuf = image_rgba;
271                 row_inc = 0;
272         }
273
274         if (targa_header.image_type == 2)
275         {
276                 // Uncompressed, RGB images
277                 if (targa_header.pixel_size == 24)
278                 {
279                         if (fin + image_width * image_height * 3 <= enddata)
280                         {
281                                 for(y = 0;y < image_height;y++)
282                                 {
283                                         for(x = 0;x < image_width;x++)
284                                         {
285                                                 *pixbuf++ = fin[2];
286                                                 *pixbuf++ = fin[1];
287                                                 *pixbuf++ = fin[0];
288                                                 *pixbuf++ = 255;
289                                                 fin += 3;
290                                         }
291                                         pixbuf += row_inc;
292                                 }
293                         }
294                 }
295                 else
296                 {
297                         if (fin + image_width * image_height * 4 <= enddata)
298                         {
299                                 for(y = 0;y < image_height;y++)
300                                 {
301                                         for(x = 0;x < image_width;x++)
302                                         {
303                                                 *pixbuf++ = fin[2];
304                                                 *pixbuf++ = fin[1];
305                                                 *pixbuf++ = fin[0];
306                                                 *pixbuf++ = fin[3];
307                                                 fin += 4;
308                                         }
309                                         pixbuf += row_inc;
310                                 }
311                         }
312                 }
313         }
314         else if (targa_header.image_type==10)
315         {
316                 // Runlength encoded RGB images
317                 x = 0;
318                 y = 0;
319                 while (y < image_height && fin < enddata)
320                 {
321                         runlen = *fin++;
322                         if (runlen & 0x80)
323                         {
324                                 // RLE compressed run
325                                 runlen = 1 + (runlen & 0x7f);
326                                 if (targa_header.pixel_size == 24)
327                                 {
328                                         if (fin + 3 > enddata)
329                                                 break;
330                                         blue = *fin++;
331                                         green = *fin++;
332                                         red = *fin++;
333                                         alpha = 255;
334                                 }
335                                 else
336                                 {
337                                         if (fin + 4 > enddata)
338                                                 break;
339                                         blue = *fin++;
340                                         green = *fin++;
341                                         red = *fin++;
342                                         alpha = *fin++;
343                                 }
344
345                                 while (runlen && y < image_height)
346                                 {
347                                         run = runlen;
348                                         if (run > image_width - x)
349                                                 run = image_width - x;
350                                         x += run;
351                                         runlen -= run;
352                                         while(run--)
353                                         {
354                                                 *pixbuf++ = red;
355                                                 *pixbuf++ = green;
356                                                 *pixbuf++ = blue;
357                                                 *pixbuf++ = alpha;
358                                         }
359                                         if (x == image_width)
360                                         {
361                                                 // end of line, advance to next
362                                                 x = 0;
363                                                 y++;
364                                                 pixbuf += row_inc;
365                                         }
366                                 }
367                         }
368                         else
369                         {
370                                 // RLE uncompressed run
371                                 runlen = 1 + (runlen & 0x7f);
372                                 while (runlen && y < image_height)
373                                 {
374                                         run = runlen;
375                                         if (run > image_width - x)
376                                                 run = image_width - x;
377                                         x += run;
378                                         runlen -= run;
379                                         if (targa_header.pixel_size == 24)
380                                         {
381                                                 if (fin + run * 3 > enddata)
382                                                         break;
383                                                 while(run--)
384                                                 {
385                                                         *pixbuf++ = fin[2];
386                                                         *pixbuf++ = fin[1];
387                                                         *pixbuf++ = fin[0];
388                                                         *pixbuf++ = 255;
389                                                         fin += 3;
390                                                 }
391                                         }
392                                         else
393                                         {
394                                                 if (fin + run * 4 > enddata)
395                                                         break;
396                                                 while(run--)
397                                                 {
398                                                         *pixbuf++ = fin[2];
399                                                         *pixbuf++ = fin[1];
400                                                         *pixbuf++ = fin[0];
401                                                         *pixbuf++ = fin[3];
402                                                         fin += 4;
403                                                 }
404                                         }
405                                         if (x == image_width)
406                                         {
407                                                 // end of line, advance to next
408                                                 x = 0;
409                                                 y++;
410                                                 pixbuf += row_inc;
411                                         }
412                                 }
413                         }
414                 }
415         }
416         return image_rgba;
417 }
418
419 /*
420 ============
421 LoadLMP
422 ============
423 */
424 qbyte *LoadLMP (qbyte *f, int matchwidth, int matchheight)
425 {
426         qbyte *image_rgba;
427         int width, height;
428
429         if (loadsize < 9)
430         {
431                 Con_Printf("LoadLMP: invalid LMP file\n");
432                 return NULL;
433         }
434
435         // parse the very complicated header *chuckle*
436         width = f[0] + f[1] * 256 + f[2] * 65536 + f[3] * 16777216;
437         height = f[4] + f[5] * 256 + f[6] * 65536 + f[7] * 16777216;
438         if ((unsigned) width > 4096 || (unsigned) height > 4096)
439         {
440                 Con_Printf("LoadLMP: invalid size\n");
441                 return NULL;
442         }
443         if ((matchwidth && width != matchwidth) || (matchheight && height != matchheight))
444                 return NULL;
445
446         if (loadsize < 8 + width * height)
447         {
448                 Con_Printf("LoadLMP: invalid LMP file\n");
449                 return NULL;
450         }
451
452         image_width = width;
453         image_height = height;
454
455         image_rgba = Mem_Alloc(tempmempool, image_width * image_height * 4);
456         if (!image_rgba)
457         {
458                 Con_Printf("LoadLMP: not enough memory for %i by %i image\n", image_width, image_height);
459                 return NULL;
460         }
461         Image_Copy8bitRGBA(f + 8, image_rgba, image_width * image_height, d_8to24table);
462         return image_rgba;
463 }
464
465 /*
466 ============
467 LoadLMP
468 ============
469 */
470 qbyte *LoadLMPAs8Bit (qbyte *f, int matchwidth, int matchheight)
471 {
472         qbyte *image_8bit;
473         int width, height;
474
475         if (loadsize < 9)
476         {
477                 Con_Printf("LoadLMPAs8Bit: invalid LMP file\n");
478                 return NULL;
479         }
480
481         // parse the very complicated header *chuckle*
482         width = f[0] + f[1] * 256 + f[2] * 65536 + f[3] * 16777216;
483         height = f[4] + f[5] * 256 + f[6] * 65536 + f[7] * 16777216;
484         if ((unsigned) width > 4096 || (unsigned) height > 4096)
485         {
486                 Con_Printf("LoadLMPAs8Bit: invalid size\n");
487                 return NULL;
488         }
489         if ((matchwidth && width != matchwidth) || (matchheight && height != matchheight))
490                 return NULL;
491
492         if (loadsize < 8 + width * height)
493         {
494                 Con_Printf("LoadLMPAs8Bit: invalid LMP file\n");
495                 return NULL;
496         }
497
498         image_width = width;
499         image_height = height;
500
501         image_8bit = Mem_Alloc(tempmempool, image_width * image_height);
502         if (!image_8bit)
503         {
504                 Con_Printf("LoadLMPAs8Bit: not enough memory for %i by %i image\n", image_width, image_height);
505                 return NULL;
506         }
507         memcpy(image_8bit, f + 8, image_width * image_height);
508         return image_8bit;
509 }
510
511 void Image_StripImageExtension (char *in, char *out)
512 {
513         char *end, *temp;
514         end = in + strlen(in);
515         if ((end - in) >= 4)
516         {
517                 temp = end - 4;
518                 if (strcmp(temp, ".tga") == 0 || strcmp(temp, ".pcx") == 0 || strcmp(temp, ".lmp") == 0)
519                         end = temp;
520                 while (in < end)
521                         *out++ = *in++;
522                 *out++ = 0;
523         }
524         else
525                 strcpy(out, in);
526 }
527
528 qbyte *loadimagepixels (char *filename, qboolean complain, int matchwidth, int matchheight)
529 {
530         qbyte *f, *data;
531         char basename[256], name[256], *c;
532         Image_StripImageExtension(filename, basename); // strip .tga, .pcx and .lmp extensions to allow replacement by other types
533         // replace *'s with #, so commandline utils don't get confused when dealing with the external files
534         for (c = basename;*c;c++)
535                 if (*c == '*')
536                         *c = '#';
537         sprintf (name, "textures/%s.tga", basename);
538         f = COM_LoadFile(name, true);
539         if (f)
540         {
541                 data = LoadTGA (f, matchwidth, matchheight);
542                 Mem_Free(f);
543                 return data;
544         }
545         sprintf (name, "textures/%s.pcx", basename);
546         f = COM_LoadFile(name, true);
547         if (f)
548         {
549                 data = LoadPCX (f, matchwidth, matchheight);
550                 Mem_Free(f);
551                 return data;
552         }
553         sprintf (name, "%s.tga", basename);
554         f = COM_LoadFile(name, true);
555         if (f)
556         {
557                 data = LoadTGA (f, matchwidth, matchheight);
558                 Mem_Free(f);
559                 return data;
560         }
561         sprintf (name, "%s.pcx", basename);
562         f = COM_LoadFile(name, true);
563         if (f)
564         {
565                 data = LoadPCX (f, matchwidth, matchheight);
566                 Mem_Free(f);
567                 return data;
568         }
569         sprintf (name, "%s.lmp", basename);
570         f = COM_LoadFile(name, true);
571         if (f)
572         {
573                 data = LoadLMP (f, matchwidth, matchheight);
574                 Mem_Free(f);
575                 return data;
576         }
577         if (complain)
578                 Con_Printf ("Couldn't load %s.tga, .pcx, .lmp\n", filename);
579         return NULL;
580 }
581
582 int image_makemask (qbyte *in, qbyte *out, int size)
583 {
584         int             i, count;
585         count = 0;
586         for (i = 0;i < size;i++)
587         {
588                 out[0] = out[1] = out[2] = 255;
589                 out[3] = in[3];
590                 if (in[3] != 255)
591                         count++;
592                 in += 4;
593                 out += 4;
594         }
595         return count;
596 }
597
598 qbyte* loadimagepixelsmask (char* filename, qboolean complain, int matchwidth, int matchheight)
599 {
600         qbyte *in, *data;
601         in = data = loadimagepixels(filename, complain, matchwidth, matchheight);
602         if (!data)
603                 return NULL;
604         if (image_makemask(data, data, image_width * image_height))
605                 return data; // some transparency
606         else
607         {
608                 Mem_Free(data);
609                 return NULL; // all opaque
610         }
611 }
612
613 rtexture_t *loadtextureimage (rtexturepool_t *pool, char* filename, int matchwidth, int matchheight, qboolean complain, qboolean mipmap, qboolean precache)
614 {
615         qbyte *data;
616         rtexture_t *rt;
617         if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
618                 return 0;
619         rt = R_LoadTexture (pool, filename, image_width, image_height, data, TEXTYPE_RGBA, TEXF_ALPHA | (mipmap ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
620         Mem_Free(data);
621         return rt;
622 }
623
624 rtexture_t *loadtextureimagemask (rtexturepool_t *pool, char* filename, int matchwidth, int matchheight, qboolean complain, qboolean mipmap, qboolean precache)
625 {
626         qbyte *data;
627         rtexture_t *rt;
628         if (!(data = loadimagepixelsmask (filename, complain, matchwidth, matchheight)))
629                 return 0;
630         rt = R_LoadTexture (pool, filename, image_width, image_height, data, TEXTYPE_RGBA, TEXF_ALPHA | (mipmap ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
631         Mem_Free(data);
632         return rt;
633 }
634
635 rtexture_t *image_masktex;
636 rtexture_t *loadtextureimagewithmask (rtexturepool_t *pool, char* filename, int matchwidth, int matchheight, qboolean complain, qboolean mipmap, qboolean precache)
637 {
638         int count;
639         qbyte *data;
640         char *filename2;
641         rtexture_t *rt;
642         image_masktex = NULL;
643         if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
644                 return 0;
645         rt = R_LoadTexture (pool, filename, image_width, image_height, data, TEXTYPE_RGBA, TEXF_ALPHA | (mipmap ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
646         count = image_makemask(data, data, image_width * image_height);
647         if (count)
648         {
649                 filename2 = Mem_Alloc(tempmempool, strlen(filename) + 6);
650                 sprintf(filename2, "%s_mask", filename);
651                 image_masktex = R_LoadTexture (pool, filename2, image_width, image_height, data, TEXTYPE_RGBA, TEXF_ALPHA | (mipmap ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
652                 Mem_Free(filename2);
653         }
654         Mem_Free(data);
655         return rt;
656 }
657
658 qboolean Image_WriteTGARGB_preflipped (char *filename, int width, int height, qbyte *data)
659 {
660         qboolean ret;
661         qbyte *buffer, *in, *out, *end;
662
663         buffer = Mem_Alloc(tempmempool, width*height*3 + 18);
664
665         memset (buffer, 0, 18);
666         buffer[2] = 2;          // uncompressed type
667         buffer[12] = (width >> 0) & 0xFF;
668         buffer[13] = (width >> 8) & 0xFF;
669         buffer[14] = (height >> 0) & 0xFF;
670         buffer[15] = (height >> 8) & 0xFF;
671         buffer[16] = 24;        // pixel size
672
673         // swap rgb to bgr
674         in = data;
675         out = buffer + 18;
676         end = in + width*height*3;
677         for (;in < end;in += 3)
678         {
679                 *out++ = in[2];
680                 *out++ = in[1];
681                 *out++ = in[0];
682         }
683         ret = COM_WriteFile (filename, buffer, width*height*3 + 18 );
684
685         Mem_Free(buffer);
686         return ret;
687 }
688
689 void Image_WriteTGARGB (char *filename, int width, int height, qbyte *data)
690 {
691         int y;
692         qbyte *buffer, *in, *out, *end;
693
694         buffer = Mem_Alloc(tempmempool, width*height*3 + 18);
695
696         memset (buffer, 0, 18);
697         buffer[2] = 2;          // uncompressed type
698         buffer[12] = (width >> 0) & 0xFF;
699         buffer[13] = (width >> 8) & 0xFF;
700         buffer[14] = (height >> 0) & 0xFF;
701         buffer[15] = (height >> 8) & 0xFF;
702         buffer[16] = 24;        // pixel size
703
704         // swap rgb to bgr and flip upside down
705         out = buffer + 18;
706         for (y = height - 1;y >= 0;y--)
707         {
708                 in = data + y * width * 3;
709                 end = in + width * 3;
710                 for (;in < end;in += 3)
711                 {
712                         *out++ = in[2];
713                         *out++ = in[1];
714                         *out++ = in[0];
715                 }
716         }
717         COM_WriteFile (filename, buffer, width*height*3 + 18 );
718
719         Mem_Free(buffer);
720 }
721
722 void Image_WriteTGARGBA (char *filename, int width, int height, qbyte *data)
723 {
724         int y;
725         qbyte *buffer, *in, *out, *end;
726
727         buffer = Mem_Alloc(tempmempool, width*height*4 + 18);
728
729         memset (buffer, 0, 18);
730         buffer[2] = 2;          // uncompressed type
731         buffer[12] = (width >> 0) & 0xFF;
732         buffer[13] = (width >> 8) & 0xFF;
733         buffer[14] = (height >> 0) & 0xFF;
734         buffer[15] = (height >> 8) & 0xFF;
735         buffer[16] = 32;        // pixel size
736
737         // swap rgba to bgra and flip upside down
738         out = buffer + 18;
739         for (y = height - 1;y >= 0;y--)
740         {
741                 in = data + y * width * 4;
742                 end = in + width * 4;
743                 for (;in < end;in += 4)
744                 {
745                         *out++ = in[2];
746                         *out++ = in[1];
747                         *out++ = in[0];
748                         *out++ = in[3];
749                 }
750         }
751         COM_WriteFile (filename, buffer, width*height*4 + 18 );
752
753         Mem_Free(buffer);
754 }
755
756 qboolean Image_CheckAlpha(qbyte *data, int size, qboolean rgba)
757 {
758         qbyte *end;
759         if (rgba)
760         {
761                 // check alpha bytes
762                 for (end = data + size * 4, data += 3;data < end;data += 4)
763                         if (*data < 255)
764                                 return 1;
765         }
766         else
767         {
768                 // color 255 is transparent
769                 for (end = data + size;data < end;data++)
770                         if (*data == 255)
771                                 return 1;
772         }
773         return 0;
774 }
775
776 static void Image_Resample32LerpLine (qbyte *in, qbyte *out, int inwidth, int outwidth)
777 {
778         int             j, xi, oldx = 0, f, fstep, endx, lerp;
779         fstep = (int) (inwidth*65536.0f/outwidth);
780         endx = (inwidth-1);
781         for (j = 0,f = 0;j < outwidth;j++, f += fstep)
782         {
783                 xi = f >> 16;
784                 if (xi != oldx)
785                 {
786                         in += (xi - oldx) * 4;
787                         oldx = xi;
788                 }
789                 if (xi < endx)
790                 {
791                         lerp = f & 0xFFFF;
792                         *out++ = (qbyte) ((((in[4] - in[0]) * lerp) >> 16) + in[0]);
793                         *out++ = (qbyte) ((((in[5] - in[1]) * lerp) >> 16) + in[1]);
794                         *out++ = (qbyte) ((((in[6] - in[2]) * lerp) >> 16) + in[2]);
795                         *out++ = (qbyte) ((((in[7] - in[3]) * lerp) >> 16) + in[3]);
796                 }
797                 else // last pixel of the line has no pixel to lerp to
798                 {
799                         *out++ = in[0];
800                         *out++ = in[1];
801                         *out++ = in[2];
802                         *out++ = in[3];
803                 }
804         }
805 }
806
807 static void Image_Resample24LerpLine (qbyte *in, qbyte *out, int inwidth, int outwidth)
808 {
809         int             j, xi, oldx = 0, f, fstep, endx, lerp;
810         fstep = (int) (inwidth*65536.0f/outwidth);
811         endx = (inwidth-1);
812         for (j = 0,f = 0;j < outwidth;j++, f += fstep)
813         {
814                 xi = f >> 16;
815                 if (xi != oldx)
816                 {
817                         in += (xi - oldx) * 3;
818                         oldx = xi;
819                 }
820                 if (xi < endx)
821                 {
822                         lerp = f & 0xFFFF;
823                         *out++ = (qbyte) ((((in[3] - in[0]) * lerp) >> 16) + in[0]);
824                         *out++ = (qbyte) ((((in[4] - in[1]) * lerp) >> 16) + in[1]);
825                         *out++ = (qbyte) ((((in[5] - in[2]) * lerp) >> 16) + in[2]);
826                 }
827                 else // last pixel of the line has no pixel to lerp to
828                 {
829                         *out++ = in[0];
830                         *out++ = in[1];
831                         *out++ = in[2];
832                 }
833         }
834 }
835
836 int resamplerowsize = 0;
837 qbyte *resamplerow1 = NULL;
838 qbyte *resamplerow2 = NULL;
839 mempool_t *resamplemempool = NULL;
840
841 #define LERPBYTE(i) r = resamplerow1[i];out[i] = (qbyte) ((((resamplerow2[i] - r) * lerp) >> 16) + r)
842 void Image_Resample32Lerp(void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
843 {
844         int i, j, r, yi, oldy, f, fstep, lerp, endy = (inheight-1), inwidth4 = inwidth*4, outwidth4 = outwidth*4;
845         qbyte *inrow, *out;
846         out = outdata;
847         fstep = (int) (inheight*65536.0f/outheight);
848
849         inrow = indata;
850         oldy = 0;
851         Image_Resample32LerpLine (inrow, resamplerow1, inwidth, outwidth);
852         Image_Resample32LerpLine (inrow + inwidth4, resamplerow2, inwidth, outwidth);
853         for (i = 0, f = 0;i < outheight;i++,f += fstep)
854         {
855                 yi = f >> 16;
856                 if (yi < endy)
857                 {
858                         lerp = f & 0xFFFF;
859                         if (yi != oldy)
860                         {
861                                 inrow = (qbyte *)indata + inwidth4*yi;
862                                 if (yi == oldy+1)
863                                         memcpy(resamplerow1, resamplerow2, outwidth4);
864                                 else
865                                         Image_Resample32LerpLine (inrow, resamplerow1, inwidth, outwidth);
866                                 Image_Resample32LerpLine (inrow + inwidth4, resamplerow2, inwidth, outwidth);
867                                 oldy = yi;
868                         }
869                         j = outwidth - 4;
870                         while(j >= 0)
871                         {
872                                 LERPBYTE( 0);
873                                 LERPBYTE( 1);
874                                 LERPBYTE( 2);
875                                 LERPBYTE( 3);
876                                 LERPBYTE( 4);
877                                 LERPBYTE( 5);
878                                 LERPBYTE( 6);
879                                 LERPBYTE( 7);
880                                 LERPBYTE( 8);
881                                 LERPBYTE( 9);
882                                 LERPBYTE(10);
883                                 LERPBYTE(11);
884                                 LERPBYTE(12);
885                                 LERPBYTE(13);
886                                 LERPBYTE(14);
887                                 LERPBYTE(15);
888                                 out += 16;
889                                 resamplerow1 += 16;
890                                 resamplerow2 += 16;
891                                 j -= 4;
892                         }
893                         if (j & 2)
894                         {
895                                 LERPBYTE( 0);
896                                 LERPBYTE( 1);
897                                 LERPBYTE( 2);
898                                 LERPBYTE( 3);
899                                 LERPBYTE( 4);
900                                 LERPBYTE( 5);
901                                 LERPBYTE( 6);
902                                 LERPBYTE( 7);
903                                 out += 8;
904                                 resamplerow1 += 8;
905                                 resamplerow2 += 8;
906                         }
907                         if (j & 1)
908                         {
909                                 LERPBYTE( 0);
910                                 LERPBYTE( 1);
911                                 LERPBYTE( 2);
912                                 LERPBYTE( 3);
913                                 out += 4;
914                                 resamplerow1 += 4;
915                                 resamplerow2 += 4;
916                         }
917                         resamplerow1 -= outwidth4;
918                         resamplerow2 -= outwidth4;
919                 }
920                 else
921                 {
922                         if (yi != oldy)
923                         {
924                                 inrow = (qbyte *)indata + inwidth4*yi;
925                                 if (yi == oldy+1)
926                                         memcpy(resamplerow1, resamplerow2, outwidth4);
927                                 else
928                                         Image_Resample32LerpLine (inrow, resamplerow1, inwidth, outwidth);
929                                 oldy = yi;
930                         }
931                         memcpy(out, resamplerow1, outwidth4);
932                 }
933         }
934 }
935
936 void Image_Resample32Nearest(void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
937 {
938         int i, j;
939         unsigned frac, fracstep;
940         // relies on int being 4 bytes
941         int *inrow, *out;
942         out = outdata;
943
944         fracstep = inwidth*0x10000/outwidth;
945         for (i = 0;i < outheight;i++)
946         {
947                 inrow = (int *)indata + inwidth*(i*inheight/outheight);
948                 frac = fracstep >> 1;
949                 j = outwidth - 4;
950                 while (j >= 0)
951                 {
952                         out[0] = inrow[frac >> 16];frac += fracstep;
953                         out[1] = inrow[frac >> 16];frac += fracstep;
954                         out[2] = inrow[frac >> 16];frac += fracstep;
955                         out[3] = inrow[frac >> 16];frac += fracstep;
956                         out += 4;
957                         j -= 4;
958                 }
959                 if (j & 2)
960                 {
961                         out[0] = inrow[frac >> 16];frac += fracstep;
962                         out[1] = inrow[frac >> 16];frac += fracstep;
963                         out += 2;
964                 }
965                 if (j & 1)
966                 {
967                         out[0] = inrow[frac >> 16];frac += fracstep;
968                         out += 1;
969                 }
970         }
971 }
972
973 void Image_Resample24Lerp(void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
974 {
975         int i, j, r, yi, oldy, f, fstep, lerp, endy = (inheight-1), inwidth3 = inwidth * 3, outwidth3 = outwidth * 3;
976         qbyte *inrow, *out;
977         out = outdata;
978         fstep = (int) (inheight*65536.0f/outheight);
979
980         inrow = indata;
981         oldy = 0;
982         Image_Resample24LerpLine (inrow, resamplerow1, inwidth, outwidth);
983         Image_Resample24LerpLine (inrow + inwidth3, resamplerow2, inwidth, outwidth);
984         for (i = 0, f = 0;i < outheight;i++,f += fstep)
985         {
986                 yi = f >> 16;
987                 if (yi < endy)
988                 {
989                         lerp = f & 0xFFFF;
990                         if (yi != oldy)
991                         {
992                                 inrow = (qbyte *)indata + inwidth3*yi;
993                                 if (yi == oldy+1)
994                                         memcpy(resamplerow1, resamplerow2, outwidth3);
995                                 else
996                                         Image_Resample24LerpLine (inrow, resamplerow1, inwidth, outwidth);
997                                 Image_Resample24LerpLine (inrow + inwidth3, resamplerow2, inwidth, outwidth);
998                                 oldy = yi;
999                         }
1000                         j = outwidth - 4;
1001                         while(j >= 0)
1002                         {
1003                                 LERPBYTE( 0);
1004                                 LERPBYTE( 1);
1005                                 LERPBYTE( 2);
1006                                 LERPBYTE( 3);
1007                                 LERPBYTE( 4);
1008                                 LERPBYTE( 5);
1009                                 LERPBYTE( 6);
1010                                 LERPBYTE( 7);
1011                                 LERPBYTE( 8);
1012                                 LERPBYTE( 9);
1013                                 LERPBYTE(10);
1014                                 LERPBYTE(11);
1015                                 out += 12;
1016                                 resamplerow1 += 12;
1017                                 resamplerow2 += 12;
1018                                 j -= 4;
1019                         }
1020                         if (j & 2)
1021                         {
1022                                 LERPBYTE( 0);
1023                                 LERPBYTE( 1);
1024                                 LERPBYTE( 2);
1025                                 LERPBYTE( 3);
1026                                 LERPBYTE( 4);
1027                                 LERPBYTE( 5);
1028                                 out += 6;
1029                                 resamplerow1 += 6;
1030                                 resamplerow2 += 6;
1031                         }
1032                         if (j & 1)
1033                         {
1034                                 LERPBYTE( 0);
1035                                 LERPBYTE( 1);
1036                                 LERPBYTE( 2);
1037                                 out += 3;
1038                                 resamplerow1 += 3;
1039                                 resamplerow2 += 3;
1040                         }
1041                         resamplerow1 -= outwidth3;
1042                         resamplerow2 -= outwidth3;
1043                 }
1044                 else
1045                 {
1046                         if (yi != oldy)
1047                         {
1048                                 inrow = (qbyte *)indata + inwidth3*yi;
1049                                 if (yi == oldy+1)
1050                                         memcpy(resamplerow1, resamplerow2, outwidth3);
1051                                 else
1052                                         Image_Resample24LerpLine (inrow, resamplerow1, inwidth, outwidth);
1053                                 oldy = yi;
1054                         }
1055                         memcpy(out, resamplerow1, outwidth3);
1056                 }
1057         }
1058 }
1059
1060 void Image_Resample24Nolerp(void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
1061 {
1062         int i, j, f, inwidth3 = inwidth * 3;
1063         unsigned frac, fracstep;
1064         qbyte *inrow, *out;
1065         out = outdata;
1066
1067         fracstep = inwidth*0x10000/outwidth;
1068         for (i = 0;i < outheight;i++)
1069         {
1070                 inrow = (qbyte *)indata + inwidth3*(i*inheight/outheight);
1071                 frac = fracstep >> 1;
1072                 j = outwidth - 4;
1073                 while (j >= 0)
1074                 {
1075                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1076                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1077                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1078                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1079                         j -= 4;
1080                 }
1081                 if (j & 2)
1082                 {
1083                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1084                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1085                         out += 2;
1086                 }
1087                 if (j & 1)
1088                 {
1089                         f = (frac >> 16)*3;*out++ = inrow[f+0];*out++ = inrow[f+1];*out++ = inrow[f+2];frac += fracstep;
1090                         out += 1;
1091                 }
1092         }
1093 }
1094
1095 /*
1096 ================
1097 Image_Resample
1098 ================
1099 */
1100 void Image_Resample (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight, int bytesperpixel, int quality)
1101 {
1102         if (resamplerowsize < outwidth*4)
1103         {
1104                 if (resamplerow1)
1105                         Mem_Free(resamplerow1);
1106                 resamplerowsize = outwidth*4;
1107                 if (!resamplemempool)
1108                         resamplemempool = Mem_AllocPool("Image Scaling Buffer");
1109                 resamplerow1 = Mem_Alloc(resamplemempool, resamplerowsize*2);
1110                 resamplerow2 = resamplerow1 + resamplerowsize;
1111         }
1112         if (bytesperpixel == 4)
1113         {
1114                 if (quality)
1115                         Image_Resample32Lerp(indata, inwidth, inheight, outdata, outwidth, outheight);
1116                 else
1117                         Image_Resample32Nearest(indata, inwidth, inheight, outdata, outwidth, outheight);
1118         }
1119         else if (bytesperpixel == 3)
1120         {
1121                 if (quality)
1122                         Image_Resample24Lerp(indata, inwidth, inheight, outdata, outwidth, outheight);
1123                 else
1124                         Image_Resample24Nolerp(indata, inwidth, inheight, outdata, outwidth, outheight);
1125         }
1126         else
1127                 Sys_Error("Image_Resample: unsupported bytesperpixel %i\n", bytesperpixel);
1128 }
1129
1130 // in can be the same as out
1131 void Image_MipReduce(qbyte *in, qbyte *out, int *width, int *height, int destwidth, int destheight, int bytesperpixel)
1132 {
1133         int x, y, nextrow;
1134         nextrow = *width * bytesperpixel;
1135         if (*width > destwidth)
1136         {
1137                 *width >>= 1;
1138                 if (*height > destheight)
1139                 {
1140                         // reduce both
1141                         *height >>= 1;
1142                         if (bytesperpixel == 4)
1143                         {
1144                                 for (y = 0;y < *height;y++)
1145                                 {
1146                                         for (x = 0;x < *width;x++)
1147                                         {
1148                                                 out[0] = (qbyte) ((in[0] + in[4] + in[nextrow  ] + in[nextrow+4]) >> 2);
1149                                                 out[1] = (qbyte) ((in[1] + in[5] + in[nextrow+1] + in[nextrow+5]) >> 2);
1150                                                 out[2] = (qbyte) ((in[2] + in[6] + in[nextrow+2] + in[nextrow+6]) >> 2);
1151                                                 out[3] = (qbyte) ((in[3] + in[7] + in[nextrow+3] + in[nextrow+7]) >> 2);
1152                                                 out += 4;
1153                                                 in += 8;
1154                                         }
1155                                         in += nextrow; // skip a line
1156                                 }
1157                         }
1158                         else if (bytesperpixel == 3)
1159                         {
1160                                 for (y = 0;y < *height;y++)
1161                                 {
1162                                         for (x = 0;x < *width;x++)
1163                                         {
1164                                                 out[0] = (qbyte) ((in[0] + in[3] + in[nextrow  ] + in[nextrow+3]) >> 2);
1165                                                 out[1] = (qbyte) ((in[1] + in[4] + in[nextrow+1] + in[nextrow+4]) >> 2);
1166                                                 out[2] = (qbyte) ((in[2] + in[5] + in[nextrow+2] + in[nextrow+5]) >> 2);
1167                                                 out += 3;
1168                                                 in += 6;
1169                                         }
1170                                         in += nextrow; // skip a line
1171                                 }
1172                         }
1173                         else
1174                                 Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
1175                 }
1176                 else
1177                 {
1178                         // reduce width
1179                         if (bytesperpixel == 4)
1180                         {
1181                                 for (y = 0;y < *height;y++)
1182                                 {
1183                                         for (x = 0;x < *width;x++)
1184                                         {
1185                                                 out[0] = (qbyte) ((in[0] + in[4]) >> 1);
1186                                                 out[1] = (qbyte) ((in[1] + in[5]) >> 1);
1187                                                 out[2] = (qbyte) ((in[2] + in[6]) >> 1);
1188                                                 out[3] = (qbyte) ((in[3] + in[7]) >> 1);
1189                                                 out += 4;
1190                                                 in += 8;
1191                                         }
1192                                 }
1193                         }
1194                         else if (bytesperpixel == 3)
1195                         {
1196                                 for (y = 0;y < *height;y++)
1197                                 {
1198                                         for (x = 0;x < *width;x++)
1199                                         {
1200                                                 out[0] = (qbyte) ((in[0] + in[3]) >> 1);
1201                                                 out[1] = (qbyte) ((in[1] + in[4]) >> 1);
1202                                                 out[2] = (qbyte) ((in[2] + in[5]) >> 1);
1203                                                 out += 3;
1204                                                 in += 6;
1205                                         }
1206                                 }
1207                         }
1208                         else
1209                                 Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
1210                 }
1211         }
1212         else
1213         {
1214                 if (*height > destheight)
1215                 {
1216                         // reduce height
1217                         *height >>= 1;
1218                         if (bytesperpixel == 4)
1219                         {
1220                                 for (y = 0;y < *height;y++)
1221                                 {
1222                                         for (x = 0;x < *width;x++)
1223                                         {
1224                                                 out[0] = (qbyte) ((in[0] + in[nextrow  ]) >> 1);
1225                                                 out[1] = (qbyte) ((in[1] + in[nextrow+1]) >> 1);
1226                                                 out[2] = (qbyte) ((in[2] + in[nextrow+2]) >> 1);
1227                                                 out[3] = (qbyte) ((in[3] + in[nextrow+3]) >> 1);
1228                                                 out += 4;
1229                                                 in += 4;
1230                                         }
1231                                         in += nextrow; // skip a line
1232                                 }
1233                         }
1234                         else if (bytesperpixel == 3)
1235                         {
1236                                 for (y = 0;y < *height;y++)
1237                                 {
1238                                         for (x = 0;x < *width;x++)
1239                                         {
1240                                                 out[0] = (qbyte) ((in[0] + in[nextrow  ]) >> 1);
1241                                                 out[1] = (qbyte) ((in[1] + in[nextrow+1]) >> 1);
1242                                                 out[2] = (qbyte) ((in[2] + in[nextrow+2]) >> 1);
1243                                                 out += 3;
1244                                                 in += 3;
1245                                         }
1246                                         in += nextrow; // skip a line
1247                                 }
1248                         }
1249                         else
1250                                 Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
1251                 }
1252                 else
1253                         Sys_Error("Image_MipReduce: desired size already achieved\n");
1254         }
1255 }
1256