src/w_wad.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // Copyright(C) 1993-1996 Id Software, Inc.
   5 // Copyright(C) 2005 Simon Howard
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 // 02111-1307, USA.
  21 //
  22 // DESCRIPTION:
  23 //      Handles WAD file header, directory, lump I/O.
  24 //
  25 //-----------------------------------------------------------------------------
  26
  27
  28
  29
  30 #include <ctype.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "doomdef.h"
  36 #include "doomtype.h"
  37
  38 #include "i_swap.h"
  39 #include "i_system.h"
  40 #include "i_video.h"
  41 #include "m_misc.h"
  42 #include "z_zone.h"
  43
  44 #include "w_wad.h"
  45
  46 typedef struct
  47 {
  48     // Should be "IWAD" or "PWAD".
  49     char                identification[4];
  50     int                 numlumps;
  51     int                 infotableofs;
  52 } PACKEDATTR wadinfo_t;
  53
  54
  55 typedef struct
  56 {
  57     int                 filepos;
  58     int                 size;
  59     char                name[8];
  60 } PACKEDATTR filelump_t;
  61
  62 //
  63 // GLOBALS
  64 //
  65
  66 // Location of each lump on disk.
  67
  68 lumpinfo_t *lumpinfo;
  69 unsigned int numlumps = 0;
  70
  71 // Hash table for fast lookups
  72
  73 static lumpinfo_t **lumphash;
  74
  75 static void ExtractFileBase(char *path, char *dest)
  76 {
  77     char*       src;
  78     int         length;
  79
  80     src = path + strlen(path) - 1;
  81
  82     // back up until a \ or the start
  83     while (src != path && *(src - 1) != DIR_SEPARATOR)
  84     {
  85         src--;
  86     }
  87
  88     // copy up to eight characters
  89     memset (dest,0,8);
  90     length = 0;
  91
  92     while (*src && *src != '.')
  93     {
  94         if (++length == 9)
  95             I_Error ("Filename base of %s >8 chars",path);
  96
  97         *dest++ = toupper((int)*src++);
  98     }
  99 }
 100
 101 // Hash function used for lump names.
 102
 103 unsigned int W_LumpNameHash(const char *s)
 104 {
 105     // This is the djb2 string hash function, modded to work on strings
 106     // that have a maximum length of 8.
 107
 108     unsigned int result = 5381;
 109     unsigned int i;
 110
 111     for (i=0; i < 8 && s[i] != '\0'; ++i)
 112     {
 113         result = ((result << 5) ^ result ) ^ toupper(s[i]);
 114     }
 115
 116     return result;
 117 }
 118
 119 //
 120 // LUMP BASED ROUTINES.
 121 //
 122
 123 //
 124 // W_AddFile
 125 // All files are optional, but at least one file must be
 126 //  found (PWAD, if all required lumps are present).
 127 // Files with a .wad extension are wadlink files
 128 //  with multiple lumps.
 129 // Other files are single lumps with the base filename
 130 //  for the lump name.
 131
 132 wad_file_t *W_AddFile (char *filename)
 133 {
 134     wadinfo_t header;
 135     lumpinfo_t *lump_p;
 136     unsigned int i;
 137     wad_file_t *wad_file;
 138     int length;
 139     int startlump;
 140     filelump_t *fileinfo;
 141     filelump_t *filerover;
 142
 143     // open the file and add to directory
 144
 145     wad_file = W_OpenFile(filename);
 146
 147     if (wad_file == NULL)
 148     {
 149         printf (" couldn't open %s\n", filename);
 150         return NULL;
 151     }
 152
 153     startlump = numlumps;
 154
 155     if (strcasecmp(filename+strlen(filename)-3 , "wad" ) )
 156     {
 157         // single lump file
 158
 159         // fraggle: Swap the filepos and size here.  The WAD directory
 160         // parsing code expects a little-endian directory, so will swap
 161         // them back.  Effectively we're constructing a "fake WAD directory"
 162         // here, as it would appear on disk.
 163
 164         fileinfo = Z_Malloc(sizeof(filelump_t), PU_STATIC, 0);
 165         fileinfo->filepos = LONG(0);
 166         fileinfo->size = LONG(wad_file->length);
 167
 168         // Name the lump after the base of the filename (without the
 169         // extension).
 170
 171         ExtractFileBase (filename, fileinfo->name);
 172         numlumps++;
 173     }
 174     else
 175     {
 176         // WAD file
 177         W_Read(wad_file, 0, &header, sizeof(header));
 178
 179         if (strncmp(header.identification,"IWAD",4))
 180         {
 181             // Homebrew levels?
 182             if (strncmp(header.identification,"PWAD",4))
 183             {
 184                 I_Error ("Wad file %s doesn't have IWAD "
 185                          "or PWAD id\n", filename);
 186             }
 187
 188             // ???modifiedgame = true;
 189         }
 190
 191         header.numlumps = LONG(header.numlumps);
 192         header.infotableofs = LONG(header.infotableofs);
 193         length = header.numlumps*sizeof(filelump_t);
 194         fileinfo = Z_Malloc(length, PU_STATIC, 0);
 195
 196         W_Read(wad_file, header.infotableofs, fileinfo, length);
 197         numlumps += header.numlumps;
 198     }
 199
 200     // Fill in lumpinfo
 201     lumpinfo = realloc(lumpinfo, numlumps * sizeof(lumpinfo_t));
 202
 203     if (lumpinfo == NULL)
 204     {
 205         I_Error ("Couldn't realloc lumpinfo");
 206     }
 207
 208     lump_p = &lumpinfo[startlump];
 209
 210     filerover = fileinfo;
 211
 212     for (i=startlump; i<numlumps; ++i)
 213     {
 214         lump_p->wad_file = wad_file;
 215         lump_p->position = LONG(filerover->filepos);
 216         lump_p->size = LONG(filerover->size);
 217         lump_p->cache = NULL;
 218         strncpy(lump_p->name, filerover->name, 8);
 219
 220         ++lump_p;
 221         ++filerover;
 222     }
 223
 224     Z_Free(fileinfo);
 225
 226     if (lumphash != NULL)
 227     {
 228         Z_Free(lumphash);
 229         lumphash = NULL;
 230     }
 231
 232     return wad_file;
 233 }
 234
 235
 236
 237 //
 238 // W_NumLumps
 239 //
 240 int W_NumLumps (void)
 241 {
 242     return numlumps;
 243 }
 244
 245
 246
 247 //
 248 // W_CheckNumForName
 249 // Returns -1 if name not found.
 250 //
 251
 252 int W_CheckNumForName (char* name)
 253 {
 254     lumpinfo_t *lump_p;
 255     int i;
 256
 257     // Do we have a hash table yet?
 258
 259     if (lumphash != NULL)
 260     {
 261         int hash;
 262
 263         // We do! Excellent.
 264
 265         hash = W_LumpNameHash(name) % numlumps;
 266
 267         for (lump_p = lumphash[hash]; lump_p != NULL; lump_p = lump_p->next)
 268         {
 269             if (!strncasecmp(lump_p->name, name, 8))
 270             {
 271                 return lump_p - lumpinfo;
 272             }
 273         }
 274     }
 275     else
 276     {
 277         // We don't have a hash table generate yet. Linear search :-(
 278         //
 279         // scan backwards so patch lump files take precedence
 280
 281         for (i=numlumps-1; i >= 0; --i)
 282         {
 283             if (!strncasecmp(lumpinfo[i].name, name, 8))
 284             {
 285                 return i;
 286             }
 287         }
 288     }
 289
 290     // TFB. Not found.
 291
 292     return -1;
 293 }
 294
 295
 296
 297
 298 //
 299 // W_GetNumForName
 300 // Calls W_CheckNumForName, but bombs out if not found.
 301 //
 302 int W_GetNumForName (char* name)
 303 {
 304     int i;
 305
 306     i = W_CheckNumForName (name);
 307
 308     if (i < 0)
 309     {
 310         I_Error ("W_GetNumForName: %s not found!", name);
 311     }
 312
 313     return i;
 314 }
 315
 316
 317 //
 318 // W_LumpLength
 319 // Returns the buffer size needed to load the given lump.
 320 //
 321 int W_LumpLength (unsigned int lump)
 322 {
 323     if (lump >= numlumps)
 324     {
 325         I_Error ("W_LumpLength: %i >= numlumps", lump);
 326     }
 327
 328     return lumpinfo[lump].size;
 329 }
 330
 331
 332
 333 //
 334 // W_ReadLump
 335 // Loads the lump into the given buffer,
 336 //  which must be >= W_LumpLength().
 337 //
 338 void W_ReadLump(unsigned int lump, void *dest)
 339 {
 340     int c;
 341     lumpinfo_t *l;
 342
 343     if (lump >= numlumps)
 344     {
 345         I_Error ("W_ReadLump: %i >= numlumps", lump);
 346     }
 347
 348     l = lumpinfo+lump;
 349
 350     I_BeginRead ();
 351
 352     c = W_Read(l->wad_file, l->position, dest, l->size);
 353
 354     if (c < l->size)
 355     {
 356         I_Error ("W_ReadLump: only read %i of %i on lump %i",
 357                  c, l->size, lump);
 358     }
 359
 360     I_EndRead ();
 361 }
 362
 363
 364
 365
 366 //
 367 // W_CacheLumpNum
 368 //
 369 // Load a lump into memory and return a pointer to a buffer containing
 370 // the lump data.
 371 //
 372 // 'tag' is the type of zone memory buffer to allocate for the lump
 373 // (usually PU_STATIC or PU_CACHE).  If the lump is loaded as
 374 // PU_STATIC, it should be released back using W_ReleaseLumpNum
 375 // when no longer needed (do not use Z_ChangeTag).
 376 //
 377
 378 void *W_CacheLumpNum(int lumpnum, int tag)
 379 {
 380     byte *result;
 381     lumpinfo_t *lump;
 382
 383     if ((unsigned)lumpnum >= numlumps)
 384     {
 385         I_Error ("W_CacheLumpNum: %i >= numlumps", lumpnum);
 386     }
 387
 388     lump = &lumpinfo[lumpnum];
 389
 390     // Get the pointer to return.  If the lump is in a memory-mapped
 391     // file, we can just return a pointer to within the memory-mapped
 392     // region.  If the lump is in an ordinary file, we may already
 393     // have it cached; otherwise, load it into memory.
 394
 395     if (lump->wad_file->mapped != NULL)
 396     {
 397         // Memory mapped file, return from the mmapped region.
 398
 399         result = lump->wad_file->mapped + lump->position;
 400     }
 401     else if (lump->cache != NULL)
 402     {
 403         // Already cached, so just switch the zone tag.
 404
 405         result = lump->cache;
 406         Z_ChangeTag(lump->cache, tag);
 407     }
 408     else
 409     {
 410         // Not yet loaded, so load it now
 411
 412         lump->cache = Z_Malloc(W_LumpLength(lumpnum), tag, &lump->cache);
 413         W_ReadLump (lumpnum, lump->cache);
 414         result = lump->cache;
 415     }
 416
 417     return result;
 418 }
 419
 420
 421
 422 //
 423 // W_CacheLumpName
 424 //
 425 void *W_CacheLumpName(char *name, int tag)
 426 {
 427     return W_CacheLumpNum(W_GetNumForName(name), tag);
 428 }
 429
 430 //
 431 // Release a lump back to the cache, so that it can be reused later
 432 // without having to read from disk again, or alternatively, discarded
 433 // if we run out of memory.
 434 //
 435 // Back in Vanilla Doom, this was just done using Z_ChangeTag
 436 // directly, but now that we have WAD mmap, things are a bit more
 437 // complicated ...
 438 //
 439
 440 void W_ReleaseLumpNum(int lumpnum)
 441 {
 442     lumpinfo_t *lump;
 443
 444     if ((unsigned)lumpnum >= numlumps)
 445     {
 446         I_Error ("W_ReleaseLumpNum: %i >= numlumps", lumpnum);
 447     }
 448
 449     lump = &lumpinfo[lumpnum];
 450
 451     if (lump->wad_file->mapped != NULL)
 452     {
 453         // Memory-mapped file, so nothing needs to be done here.
 454     }
 455     else
 456     {
 457         Z_ChangeTag(lump->cache, PU_CACHE);
 458     }
 459 }
 460
 461 void W_ReleaseLumpName(char *name)
 462 {
 463     W_ReleaseLumpNum(W_GetNumForName(name));
 464 }
 465
 466 #if 0
 467
 468 //
 469 // W_Profile
 470 //
 471 int             info[2500][10];
 472 int             profilecount;
 473
 474 void W_Profile (void)
 475 {
 476     int         i;
 477     memblock_t* block;
 478     void*       ptr;
 479     char        ch;
 480     FILE*       f;
 481     int         j;
 482     char        name[9];
 483
 484
 485     for (i=0 ; i<numlumps ; i++)
 486     {
 487         ptr = lumpinfo[i].cache;
 488         if (!ptr)
 489         {
 490             ch = ' ';
 491             continue;
 492         }
 493         else
 494         {
 495             block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
 496             if (block->tag < PU_PURGELEVEL)
 497                 ch = 'S';
 498             else
 499                 ch = 'P';
 500         }
 501         info[i][profilecount] = ch;
 502     }
 503     profilecount++;
 504
 505     f = fopen ("waddump.txt","w");
 506     name[8] = 0;
 507
 508     for (i=0 ; i<numlumps ; i++)
 509     {
 510         memcpy (name,lumpinfo[i].name,8);
 511
 512         for (j=0 ; j<8 ; j++)
 513             if (!name[j])
 514                 break;
 515
 516         for ( ; j<8 ; j++)
 517             name[j] = ' ';
 518
 519         fprintf (f,"%s ",name);
 520
 521         for (j=0 ; j<profilecount ; j++)
 522             fprintf (f,"    %c",info[i][j]);
 523
 524         fprintf (f,"\n");
 525     }
 526     fclose (f);
 527 }
 528
 529
 530 #endif
 531
 532 // Generate a hash table for fast lookups
 533
 534 void W_GenerateHashTable(void)
 535 {
 536     unsigned int i;
 537
 538     // Free the old hash table, if there is one
 539
 540     if (lumphash != NULL)
 541     {
 542         Z_Free(lumphash);
 543     }
 544
 545     // Generate hash table
 546     if (numlumps > 0)
 547     {
 548         lumphash = Z_Malloc(sizeof(lumpinfo_t *) * numlumps, PU_STATIC, NULL);
 549         memset(lumphash, 0, sizeof(lumpinfo_t *) * numlumps);
 550
 551         for (i=0; i<numlumps; ++i)
 552         {
 553             unsigned int hash;
 554
 555             hash = W_LumpNameHash(lumpinfo[i].name) % numlumps;
 556
 557             // Hook into the hash table
 558
 559             lumpinfo[i].next = lumphash[hash];
 560             lumphash[hash] = &lumpinfo[i];
 561         }
 562     }
 563
 564     // All done!
 565 }
 566