2af46a6f7721761f3b2f30f68e95471d46481751
[xonotic/netradiant.git] / tools / quake3 / q3map2 / image.c
1 /* -------------------------------------------------------------------------------
2
3    Copyright (C) 1999-2007 id Software, Inc. and contributors.
4    For a list of contributors, see the accompanying CONTRIBUTORS file.
5
6    This file is part of GtkRadiant.
7
8    GtkRadiant is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    GtkRadiant is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GtkRadiant; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21
22    ----------------------------------------------------------------------------------
23
24    This code has been altered significantly from its original form, to support
25    several games based on the Quake III Arena engine, in the form of "Q3Map2."
26
27    ------------------------------------------------------------------------------- */
28
29
30
31 /* marker */
32 #define IMAGE_C
33
34
35
36 /* dependencies */
37 #include "q3map2.h"
38
39
40
41 /* -------------------------------------------------------------------------------
42
43    this file contains image pool management with reference counting. note: it isn't
44    reentrant, so only call it from init/shutdown code or wrap calls in a mutex
45
46    ------------------------------------------------------------------------------- */
47
48 /*
49    LoadDDSBuffer()
50    loads a dxtc (1, 3, 5) dds buffer into a valid rgba image
51  */
52
53 static void LoadDDSBuffer( byte *buffer, int size, byte **pixels, int *width, int *height ){
54         int w, h;
55         ddsPF_t pf;
56
57
58         /* dummy check */
59         if ( buffer == NULL || size <= 0 || pixels == NULL || width == NULL || height == NULL ) {
60                 return;
61         }
62
63         /* null out */
64         *pixels = 0;
65         *width = 0;
66         *height = 0;
67
68         /* get dds info */
69         if ( DDSGetInfo( (ddsBuffer_t*) buffer, &w, &h, &pf ) ) {
70                 Sys_Printf( "WARNING: Invalid DDS texture\n" );
71                 return;
72         }
73
74         /* only certain types of dds textures are supported */
75         if ( pf != DDS_PF_ARGB8888 && pf != DDS_PF_DXT1 && pf != DDS_PF_DXT3 && pf != DDS_PF_DXT5 ) {
76                 Sys_Printf( "WARNING: Only DDS texture formats ARGB8888, DXT1, DXT3, and DXT5 are supported (%d)\n", pf );
77                 return;
78         }
79
80         /* create image pixel buffer */
81         *width = w;
82         *height = h;
83         *pixels = safe_malloc( w * h * 4 );
84
85         /* decompress the dds texture */
86         DDSDecompress( (ddsBuffer_t*) buffer, *pixels );
87 }
88
89
90
91 /*
92    PNGReadData()
93    callback function for libpng to read from a memory buffer
94    note: this function is a total hack, as it reads/writes the png struct directly!
95  */
96
97 typedef struct pngBuffer_s
98 {
99         byte    *buffer;
100         int size, offset;
101 } pngBuffer_t;
102
103 void PNGReadData( png_struct *png, png_byte *buffer, png_size_t size ){
104         pngBuffer_t     *pb = (pngBuffer_t*) png_get_io_ptr( png );
105
106
107         if ( ( pb->offset + size ) > pb->size ) {
108                 size = ( pb->size - pb->offset );
109         }
110         memcpy( buffer, &pb->buffer[ pb->offset ], size );
111         pb->offset += size;
112         //%     Sys_Printf( "Copying %d bytes from 0x%08X to 0x%08X (offset: %d of %d)\n", size, &pb->buffer[ pb->offset ], buffer, pb->offset, pb->size );
113 }
114
115
116
117 /*
118    LoadPNGBuffer()
119    loads a png file buffer into a valid rgba image
120  */
121
122 static void LoadPNGBuffer( byte *buffer, int size, byte **pixels, int *width, int *height ){
123         png_struct  *png;
124         png_info    *info, *end;
125     pngBuffer_t pb;
126         int i, bitDepth, colorType, channels;
127         png_uint_32 w, h;
128         byte        **rowPointers;
129
130         /* dummy check */
131         if ( buffer == NULL || size <= 0 || pixels == NULL || width == NULL || height == NULL ) {
132                 return;
133         }
134
135         /* null out */
136         *pixels = 0;
137         *width = 0;
138         *height = 0;
139
140         /* determine if this is a png file */
141         if ( png_sig_cmp( buffer, 0, 8 ) != 0 ) {
142                 Sys_Printf( "WARNING: Invalid PNG file\n" );
143                 return;
144         }
145
146         /* create png structs */
147         png = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
148         if ( png == NULL ) {
149                 Sys_Printf( "WARNING: Unable to create PNG read struct\n" );
150                 return;
151         }
152
153         info = png_create_info_struct( png );
154         if ( info == NULL ) {
155                 Sys_Printf( "WARNING: Unable to create PNG info struct\n" );
156                 png_destroy_read_struct( &png, NULL, NULL );
157                 return;
158         }
159
160         end = png_create_info_struct( png );
161         if ( end == NULL ) {
162                 Sys_Printf( "WARNING: Unable to create PNG end info struct\n" );
163                 png_destroy_read_struct( &png, &info, NULL );
164                 return;
165         }
166
167         /* set read callback */
168     pb.buffer = buffer;
169     pb.size = size;
170     pb.offset = 0;
171         png_set_read_fn( png, (void*)&pb, PNGReadData );
172
173         /* set error longjmp */
174         if ( setjmp( png_jmpbuf(png) ) ) {
175                 Sys_Printf( "WARNING: An error occurred reading PNG image\n" );
176                 png_destroy_read_struct( &png, &info, &end );
177                 return;
178         }
179
180         /* fixme: add proper i/o stuff here */
181
182         /* read png info */
183         png_read_info( png, info );
184
185         /* read image header chunk */
186         png_get_IHDR( png, info,
187                                   &w, &h, &bitDepth, &colorType, NULL, NULL, NULL );
188
189         /* read number of channels */
190         channels = png_get_channels( png, info );
191
192         /* the following will probably bork on certain types of png images, but hey... */
193
194         /* force indexed/gray/trans chunk to rgb */
195         if ( ( colorType == PNG_COLOR_TYPE_PALETTE && bitDepth <= 8 ) ||
196                  ( colorType == PNG_COLOR_TYPE_GRAY && bitDepth <= 8 ) ||
197                  png_get_valid( png, info, PNG_INFO_tRNS ) ) {
198                 png_set_expand( png );
199         }
200
201         /* strip 16bpc -> 8bpc */
202         if ( bitDepth == 16 ) {
203                 png_set_strip_16( png );
204         }
205
206         /* pad rgb to rgba */
207         if ( bitDepth == 8 && colorType == PNG_COLOR_TYPE_RGB ) {
208                 png_set_filler( png, 255, PNG_FILLER_AFTER );
209         }
210
211         /* create image pixel buffer */
212         *width = w;
213         *height = h;
214         *pixels = safe_malloc( w * h * 4 );
215
216         /* create row pointers */
217         rowPointers = safe_malloc( h * sizeof( byte* ) );
218         for ( i = 0; i < h; i++ )
219                 rowPointers[ i ] = *pixels + ( i * w * 4 );
220
221         /* read the png */
222         png_read_image( png, rowPointers );
223
224         /* clean up */
225         free( rowPointers );
226         png_destroy_read_struct( &png, &info, &end );
227
228 }
229
230
231
232 /*
233    ImageInit()
234    implicitly called by every function to set up image list
235  */
236
237 static void ImageInit( void ){
238         int i;
239
240
241         if ( numImages <= 0 ) {
242                 /* clear images (fixme: this could theoretically leak) */
243                 memset( images, 0, sizeof( images ) );
244
245                 /* generate *bogus image */
246                 images[ 0 ].name = safe_malloc( strlen( DEFAULT_IMAGE ) + 1 );
247                 strcpy( images[ 0 ].name, DEFAULT_IMAGE );
248                 images[ 0 ].filename = safe_malloc( strlen( DEFAULT_IMAGE ) + 1 );
249                 strcpy( images[ 0 ].filename, DEFAULT_IMAGE );
250                 images[ 0 ].width = 64;
251                 images[ 0 ].height = 64;
252                 images[ 0 ].refCount = 1;
253                 images[ 0 ].pixels = safe_malloc( 64 * 64 * 4 );
254                 for ( i = 0; i < ( 64 * 64 * 4 ); i++ )
255                         images[ 0 ].pixels[ i ] = 255;
256         }
257 }
258
259
260
261 /*
262    ImageFree()
263    frees an rgba image
264  */
265
266 void ImageFree( image_t *image ){
267         /* dummy check */
268         if ( image == NULL ) {
269                 return;
270         }
271
272         /* decrement refcount */
273         image->refCount--;
274
275         /* free? */
276         if ( image->refCount <= 0 ) {
277                 if ( image->name != NULL ) {
278                         free( image->name );
279                 }
280                 image->name = NULL;
281                 if ( image->filename != NULL ) {
282                         free( image->filename );
283                 }
284                 image->filename = NULL;
285                 free( image->pixels );
286                 image->width = 0;
287                 image->height = 0;
288                 numImages--;
289         }
290 }
291
292
293
294 /*
295    ImageFind()
296    finds an existing rgba image and returns a pointer to the image_t struct or NULL if not found
297  */
298
299 image_t *ImageFind( const char *filename ){
300         int i;
301         char name[ 1024 ];
302
303
304         /* init */
305         ImageInit();
306
307         /* dummy check */
308         if ( filename == NULL || filename[ 0 ] == '\0' ) {
309                 return NULL;
310         }
311
312         /* strip file extension off name */
313         strcpy( name, filename );
314         StripExtension( name );
315
316         /* search list */
317         for ( i = 0; i < MAX_IMAGES; i++ )
318         {
319                 if ( images[ i ].name != NULL && !strcmp( name, images[ i ].name ) ) {
320                         return &images[ i ];
321                 }
322         }
323
324         /* no matching image found */
325         return NULL;
326 }
327
328
329
330 /*
331    ImageLoad()
332    loads an rgba image and returns a pointer to the image_t struct or NULL if not found
333  */
334
335 image_t *ImageLoad( const char *filename ){
336         int i;
337         image_t     *image;
338         char name[ 1024 ];
339         int size;
340         byte        *buffer = NULL;
341
342
343         /* init */
344         ImageInit();
345
346         /* dummy check */
347         if ( filename == NULL || filename[ 0 ] == '\0' ) {
348                 return NULL;
349         }
350
351         /* strip file extension off name */
352         strcpy( name, filename );
353         StripExtension( name );
354
355         /* try to find existing image */
356         image = ImageFind( name );
357         if ( image != NULL ) {
358                 image->refCount++;
359                 return image;
360         }
361
362         /* none found, so find first non-null image */
363         image = NULL;
364         for ( i = 0; i < MAX_IMAGES; i++ )
365         {
366                 if ( images[ i ].name == NULL ) {
367                         image = &images[ i ];
368                         break;
369                 }
370         }
371
372         /* too many images? */
373         if ( image == NULL ) {
374                 Error( "MAX_IMAGES (%d) exceeded, there are too many image files referenced by the map.", MAX_IMAGES );
375         }
376
377         /* set it up */
378         image->name = safe_malloc( strlen( name ) + 1 );
379         strcpy( image->name, name );
380
381         /* attempt to load tga */
382         StripExtension( name );
383         strcat( name, ".tga" );
384         size = vfsLoadFile( (const char*) name, (void**) &buffer, 0 );
385         if ( size > 0 ) {
386                 LoadTGABuffer( buffer, buffer + size, &image->pixels, &image->width, &image->height );
387         }
388         else
389         {
390                 /* attempt to load png */
391                 StripExtension( name );
392                 strcat( name, ".png" );
393                 size = vfsLoadFile( (const char*) name, (void**) &buffer, 0 );
394                 if ( size > 0 ) {
395                         LoadPNGBuffer( buffer, size, &image->pixels, &image->width, &image->height );
396                 }
397                 else
398                 {
399                         /* attempt to load jpg */
400                         StripExtension( name );
401                         strcat( name, ".jpg" );
402                         size = vfsLoadFile( (const char*) name, (void**) &buffer, 0 );
403                         if ( size > 0 ) {
404                                 if ( LoadJPGBuff( buffer, size, &image->pixels, &image->width, &image->height ) == -1 && image->pixels != NULL ) {
405                                         Sys_Printf( "WARNING: LoadJPGBuff: %s\n", (unsigned char*) image->pixels );
406                                 }
407                         }
408                         else
409                         {
410                                 /* attempt to load dds */
411                                 StripExtension( name );
412                                 strcat( name, ".dds" );
413                                 size = vfsLoadFile( (const char*) name, (void**) &buffer, 0 );
414                                 if ( size > 0 ) {
415                                         LoadDDSBuffer( buffer, size, &image->pixels, &image->width, &image->height );
416
417                                         /* debug code */
418                                         #if 1
419                                         {
420                                                 ddsPF_t pf;
421                                                 DDSGetInfo( (ddsBuffer_t*) buffer, NULL, NULL, &pf );
422                                                 Sys_Printf( "pf = %d\n", pf );
423                                                 if ( image->width > 0 ) {
424                                                         StripExtension( name );
425                                                         strcat( name, "_converted.tga" );
426                                                         WriteTGA( "C:\\games\\quake3\\baseq3\\textures\\rad\\dds_converted.tga", image->pixels, image->width, image->height );
427                                                 }
428                                         }
429                                         #endif
430                                 }
431                         }
432                 }
433         }
434
435         /* free file buffer */
436         free( buffer );
437
438         /* make sure everything's kosher */
439         if ( size <= 0 || image->width <= 0 || image->height <= 0 || image->pixels == NULL ) {
440                 //%     Sys_Printf( "size = %d  width = %d  height = %d  pixels = 0x%08x (%s)\n",
441                 //%             size, image->width, image->height, image->pixels, name );
442                 free( image->name );
443                 image->name = NULL;
444                 return NULL;
445         }
446
447         /* set filename */
448         image->filename = safe_malloc( strlen( name ) + 1 );
449         strcpy( image->filename, name );
450
451         /* set count */
452         image->refCount = 1;
453         numImages++;
454
455         /* return the image */
456         return image;
457 }