main/piggy.c

   1 /* $Id: piggy.c,v 1.34 2003-08-02 18:17:50 btb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * Functions for managing the pig files.
  18  *
  19  * Old Log:
  20  * Revision 1.16  1995/11/09  17:27:47  allender
  21  * put in missing quote on new gauge name
  22  *
  23  * Revision 1.15  1995/11/08  17:28:03  allender
  24  * add PC gauges to gauge list of non-substitutatble bitmaps
  25  *
  26  * Revision 1.14  1995/11/08  15:14:49  allender
  27  * fixed horrible bug where the piggy cache size was incorrect
  28  * for mac shareware
  29  *
  30  * Revision 1.13  1995/11/03  12:53:37  allender
  31  * shareware changes
  32  *
  33  * Revision 1.12  1995/10/21  22:25:14  allender
  34  * added bald guy cheat
  35  *
  36  * Revision 1.11  1995/10/20  22:42:15  allender
  37  * changed load path of descent.pig to :data:descent.pig
  38  *
  39  * Revision 1.10  1995/10/20  00:08:01  allender
  40  * put in event loop calls when loading data (hides it nicely
  41  * from user) so TM can get it's strokes stuff
  42  *
  43  * Revision 1.9  1995/09/13  08:48:01  allender
  44  * added lower memory requirement to load alternate bitmaps
  45  *
  46  * Revision 1.8  1995/08/16  09:39:13  allender
  47  * moved "loading" text up a little
  48  *
  49  * Revision 1.7  1995/08/08  13:54:26  allender
  50  * added macsys header file
  51  *
  52  * Revision 1.6  1995/07/12  12:49:56  allender
  53  * total hack for bitmaps > 512 bytes wide -- check these by name
  54  *
  55  * Revision 1.5  1995/07/05  16:47:05  allender
  56  * kitchen stuff
  57  *
  58  * Revision 1.4  1995/06/23  08:55:28  allender
  59  * make "loading data" text y loc based off of curcanv
  60  *
  61  * Revision 1.3  1995/06/08  14:08:52  allender
  62  * PPC aligned data sets
  63  *
  64  * Revision 1.2  1995/05/26  06:54:27  allender
  65  * removed refences to sound data at end of pig file (since they will
  66  * now be Macintosh snd resources for effects
  67  *
  68  * Revision 1.1  1995/05/16  15:29:51  allender
  69  * Initial revision
  70  *
  71  * Revision 2.10  1995/10/07  13:17:26  john
  72  * Made all bitmaps paged out by default.
  73  *
  74  * Revision 2.9  1995/04/14  14:05:24  john
  75  * *** empty log message ***
  76  *
  77  * Revision 2.8  1995/04/12  13:39:37  john
  78  * Fixed bug with -lowmem not working.
  79  *
  80  * Revision 2.7  1995/03/29  23:23:17  john
  81  * Fixed major bug with sounds not building into pig right.
  82  *
  83  * Revision 2.6  1995/03/28  18:05:00  john
  84  * Fixed it so you don't have to delete pig after changing bitmaps.tbl
  85  *
  86  * Revision 2.5  1995/03/16  23:13:06  john
  87  * Fixed bug with piggy paging in bitmap not checking for disk
  88  * error, hence bogifying textures if you pull the CD out.
  89  *
  90  * Revision 2.4  1995/03/14  16:22:27  john
  91  * Added cdrom alternate directory stuff.
  92  *
  93  * Revision 2.3  1995/03/06  15:23:20  john
  94  * New screen techniques.
  95  *
  96  * Revision 2.2  1995/02/27  13:13:40  john
  97  * Removed floating point.
  98  *
  99  * Revision 2.1  1995/02/27  12:31:25  john
 100  * Made work without editor.
 101  *
 102  * Revision 2.0  1995/02/27  11:28:02  john
 103  * New version 2.0, which has no anonymous unions, builds with
 104  * Watcom 10.0, and doesn't require parsing BITMAPS.TBL.
 105  *
 106  * Revision 1.85  1995/02/09  12:54:24  john
 107  * Made paged out bitmaps have bm_data be a valid pointer
 108  * instead of NULL, in case anyone accesses it.
 109  *
 110  * Revision 1.84  1995/02/09  12:50:59  john
 111  * Bullet-proofed the piggy loading code.
 112  *
 113  * Revision 1.83  1995/02/07  17:08:51  john
 114  * Added some error handling stuff instead of asserts.
 115  *
 116  * Revision 1.82  1995/02/03  17:06:48  john
 117  * Changed sound stuff to allow low memory usage.
 118  * Also, changed so that Sounds isn't an array of digi_sounds, it
 119  * is a ubyte pointing into GameSounds, this way the digi.c code that
 120  * locks sounds won't accidentally unlock a sound that is already playing, but
 121  * since it's Sounds[soundno] is different, it would erroneously be unlocked.
 122  *
 123  * Revision 1.81  1995/02/02  21:56:39  matt
 124  * Added data for new gauge bitmaps
 125  *
 126  * Revision 1.80  1995/02/01  23:31:57  john
 127  * Took out loading bar.
 128  *
 129  * Revision 1.79  1995/01/28  15:13:18  allender
 130  * bumped up Piggy_bitmap_cache_size
 131  *
 132  * Revision 1.78  1995/01/26  12:30:43  john
 133  * Took out prev.
 134  *
 135  * Revision 1.77  1995/01/26  12:12:17  john
 136  * Made buffer be big for bitmaps.
 137  *
 138  * Revision 1.76  1995/01/25  20:15:38  john
 139  * Made editor allocate all mem.
 140  *
 141  * Revision 1.75  1995/01/25  14:52:56  john
 142  * Made bitmap buffer be 1.5 MB.
 143  *
 144  * Revision 1.74  1995/01/22  16:03:19  mike
 145  * localization.
 146  *
 147  * Revision 1.73  1995/01/22  15:58:36  mike
 148  * localization
 149  *
 150  * Revision 1.72  1995/01/18  20:51:20  john
 151  * Took out warnings.
 152  *
 153  * Revision 1.71  1995/01/18  20:47:21  john
 154  * Added code to allocate sounds & bitmaps into diff
 155  * buffers, also made sounds not be compressed for registered.
 156  *
 157  * Revision 1.70  1995/01/18  15:08:41  john
 158  * Added start/stop time around paging.
 159  * Made paging clear screen around globe.
 160  *
 161  * Revision 1.69  1995/01/18  10:07:51  john
 162  *
 163  * Took out debugging mprintfs.
 164  *
 165  * Revision 1.68  1995/01/17  14:27:42  john
 166  * y
 167  *
 168  * Revision 1.67  1995/01/17  12:14:39  john
 169  * Made walls, object explosion vclips load at level start.
 170  *
 171  * Revision 1.66  1995/01/15  13:15:44  john
 172  * Made so that paging always happens, lowmem just loads less.
 173  * Also, make KB load print to hud.
 174  *
 175  * Revision 1.65  1995/01/15  11:56:28  john
 176  * Working version of paging.
 177  *
 178  * Revision 1.64  1995/01/14  19:17:07  john
 179  * First version of new bitmap paging code.
 180  *
 181  * Revision 1.63  1994/12/15  12:26:44  john
 182  * Added -nolowmem function.
 183  *
 184  * Revision 1.62  1994/12/14  21:12:26  john
 185  * Fixed bug with page fault when exiting and using
 186  * -nosound.
 187  *
 188  * Revision 1.61  1994/12/14  11:35:31  john
 189  * Evened out thermometer for pig read.
 190  *
 191  * Revision 1.60  1994/12/14  10:51:00  john
 192  * Sped up sound loading.
 193  *
 194  * Revision 1.59  1994/12/14  10:12:08  john
 195  * Sped up pig loading.
 196  *
 197  * Revision 1.58  1994/12/13  09:14:47  john
 198  * *** empty log message ***
 199  *
 200  * Revision 1.57  1994/12/13  09:12:57  john
 201  * Made the bar always fill up.
 202  *
 203  * Revision 1.56  1994/12/13  03:49:08  john
 204  * Made -lowmem not load the unnecessary bitmaps.
 205  *
 206  * Revision 1.55  1994/12/06  16:06:35  john
 207  * Took out piggy sorting.
 208  *
 209  * Revision 1.54  1994/12/06  15:11:14  john
 210  * Fixed bug with reading pigs.
 211  *
 212  * Revision 1.53  1994/12/06  14:14:47  john
 213  * Added code to set low mem based on memory.
 214  *
 215  * Revision 1.52  1994/12/06  14:01:10  john
 216  * Fixed bug that was causing -lowmem all the time..
 217  *
 218  * Revision 1.51  1994/12/06  13:33:48  john
 219  * Added lowmem option.
 220  *
 221  * Revision 1.50  1994/12/05  19:40:10  john
 222  * If -nosound or no sound card selected, don't load sounds from pig.
 223  *
 224  * Revision 1.49  1994/12/05  12:17:44  john
 225  * Added code that locks/unlocks digital sounds on demand.
 226  *
 227  * Revision 1.48  1994/12/05  11:39:03  matt
 228  * Fixed little mistake
 229  *
 230  * Revision 1.47  1994/12/05  09:29:22  john
 231  * Added clength to the sound field.
 232  *
 233  * Revision 1.46  1994/12/04  15:27:15  john
 234  * Fixed my stupid bug that looked at -nosound instead of digi_driver_card
 235  * to see whether or not to lock down sound memory.
 236  *
 237  * Revision 1.45  1994/12/03  14:17:00  john
 238  * Took out my debug mprintf.
 239  *
 240  * Revision 1.44  1994/12/03  13:32:37  john
 241  * Fixed bug with offscreen bitmap.
 242  *
 243  * Revision 1.43  1994/12/03  13:07:13  john
 244  * Made the pig read/write compressed sounds.
 245  *
 246  * Revision 1.42  1994/12/03  11:48:51  matt
 247  * Added option to not dump sounds to pigfile
 248  *
 249  * Revision 1.41  1994/12/02  20:02:20  matt
 250  * Made sound files constant match constant for table
 251  *
 252  * Revision 1.40  1994/11/29  11:03:09  adam
 253  * upped # of sounds
 254  *
 255  * Revision 1.39  1994/11/27  23:13:51  matt
 256  * Made changes for new mprintf calling convention
 257  *
 258  * Revision 1.38  1994/11/20  18:40:34  john
 259  * MAde the piggy.lst and piggy.all not dump for release.
 260  *
 261  * Revision 1.37  1994/11/19  23:54:45  mike
 262  * up number of bitmaps for shareware version.
 263  *
 264  * Revision 1.36  1994/11/19  19:53:05  mike
 265  * change MAX_BITMAP_FILES
 266  *
 267  * Revision 1.35  1994/11/19  10:42:56  matt
 268  * Increased number of bitmaps for non-shareware version
 269  *
 270  * Revision 1.34  1994/11/19  09:11:52  john
 271  * Added avg_color to bitmaps saved in pig.
 272  *
 273  * Revision 1.33  1994/11/19  00:07:05  john
 274  * Fixed bug with 8 char sound filenames not getting read from pig.
 275  *
 276  * Revision 1.32  1994/11/18  22:24:54  john
 277  * Added -bigpig command line that doesn't rle your pig.
 278  *
 279  * Revision 1.31  1994/11/18  21:56:53  john
 280  * Added a better, leaner pig format.
 281  *
 282  * Revision 1.30  1994/11/16  12:06:16  john
 283  * Fixed bug with calling .bbms abms.
 284  *
 285  * Revision 1.29  1994/11/16  12:00:56  john
 286  * Added piggy.all dump.
 287  *
 288  * Revision 1.28  1994/11/10  21:16:02  adam
 289  * nothing important
 290  *
 291  * Revision 1.27  1994/11/10  13:42:00  john
 292  * Made sounds not lock down if using -nosound.
 293  *
 294  * Revision 1.26  1994/11/09  19:55:40  john
 295  * Added full rle support with texture rle caching.
 296  *
 297  * Revision 1.25  1994/11/09  16:36:42  john
 298  * First version with RLE bitmaps in Pig.
 299  *
 300  * Revision 1.24  1994/10/27  19:42:59  john
 301  * Disable the piglet option.
 302  *
 303  * Revision 1.23  1994/10/27  18:51:40  john
 304  * Added -piglet option that only loads needed textures for a
 305  * mine.  Only saved ~1MB, and code still doesn't free textures
 306  * before you load a new mine.
 307  *
 308  * Revision 1.22  1994/10/25  13:11:42  john
 309  * Made the sounds sort. Dumped piggy.lst.
 310  *
 311  * Revision 1.21  1994/10/06  17:06:23  john
 312  * Took out rle stuff.
 313  *
 314  * Revision 1.20  1994/10/06  15:45:36  adam
 315  * bumped MAX_BITMAP_FILES again!
 316  *
 317  * Revision 1.19  1994/10/06  11:01:17  yuan
 318  * Upped MAX_BITMAP_FILES
 319  *
 320  * Revision 1.18  1994/10/06  10:44:45  john
 321  * Added diagnostic message and psuedo run-length-encoder
 322  * to see how much memory we would save by storing bitmaps
 323  * in a RLE method.  Also, I commented out the code that
 324  * stores 4K bitmaps on a 4K boundry to reduce pig size
 325  * a bit.
 326  *
 327  * Revision 1.17  1994/10/04  20:03:13  matt
 328  * Upped maximum number of bitmaps
 329  *
 330  * Revision 1.16  1994/10/03  18:04:20  john
 331  * Fixed bug with data_offset not set right for bitmaps
 332  * that are 64x64 and not aligned on a 4k boundry.
 333  *
 334  * Revision 1.15  1994/09/28  11:30:55  john
 335  * changed inferno.pig to descent.pig, changed the way it
 336  * is read.
 337  *
 338  * Revision 1.14  1994/09/22  16:14:17  john
 339  * Redid intro sequecing.
 340  *
 341  * Revision 1.13  1994/09/19  14:42:47  john
 342  * Locked down sounds with Virtual memory.
 343  *
 344  * Revision 1.12  1994/09/10  17:31:52  mike
 345  * Increase number of loadable bitmaps.
 346  *
 347  * Revision 1.11  1994/09/01  19:32:49  mike
 348  * Boost texture map allocation.
 349  *
 350  * Revision 1.10  1994/08/16  11:51:02  john
 351  * Added grwased pigs.
 352  *
 353  * Revision 1.9  1994/07/06  09:18:03  adam
 354  * upped bitmap #s
 355  *
 356  * Revision 1.8  1994/06/20  22:02:15  matt
 357  * Fixed bug from last change
 358  *
 359  * Revision 1.7  1994/06/20  21:33:18  matt
 360  * Made bm.h not include sounds.h, to reduce dependencies
 361  *
 362  * Revision 1.6  1994/06/20  16:52:19  john
 363  * cleaned up init output a bit.
 364  *
 365  * Revision 1.5  1994/06/08  14:20:57  john
 366  * Made piggy dump before going into game.
 367  *
 368  * Revision 1.4  1994/06/02  18:59:22  matt
 369  * Clear selector field of bitmap loaded from pig file
 370  *
 371  * Revision 1.3  1994/05/06  15:31:41  john
 372  * Made name field a bit longer.
 373  *
 374  * Revision 1.2  1994/05/06  13:02:44  john
 375  * Added piggy stuff; worked on supertransparency
 376  *
 377  * Revision 1.1  1994/05/06  11:47:26  john
 378  * Initial revision
 379  *
 380  *
 381  */
 382
 383
 384 #ifdef HAVE_CONFIG_H
 385 #include <conf.h>
 386 #endif
 387
 388 #ifdef RCS
 389 static char rcsid[] = "$Id: piggy.c,v 1.34 2003-08-02 18:17:50 btb Exp $";
 390 #endif
 391
 392
 393 #include <stdio.h>
 394 #include <string.h>
 395
 396 #include "pstypes.h"
 397 #include "strutil.h"
 398 #include "inferno.h"
 399 #include "gr.h"
 400 #include "u_mem.h"
 401 #include "iff.h"
 402 #include "mono.h"
 403 #include "error.h"
 404 #include "sounds.h"
 405 #include "songs.h"
 406 #include "bm.h"
 407 #include "bmread.h"
 408 #include "hash.h"
 409 #include "args.h"
 410 #include "palette.h"
 411 #include "gamefont.h"
 412 #include "rle.h"
 413 #include "screens.h"
 414 #include "piggy.h"
 415 #include "texmerge.h"
 416 #include "paging.h"
 417 #include "game.h"
 418 #include "text.h"
 419 #include "cfile.h"
 420 #include "newmenu.h"
 421 #include "byteswap.h"
 422 #include "findfile.h"
 423 #include "makesig.h"
 424
 425 #ifndef MACINTOSH
 426 //      #include "unarj.h"
 427 #else
 428         #include <Strings.h>            // MacOS Toolbox header
 429         #include <Files.h>
 430         #include <unistd.h>
 431 #endif
 432
 433 //#define NO_DUMP_SOUNDS        1   //if set, dump bitmaps but not sounds
 434
 435 #define DEFAULT_PIGFILE_REGISTERED      "groupa.pig"
 436 #define DEFAULT_PIGFILE_SHAREWARE       "d2demo.pig"
 437 #define DEFAULT_HAMFILE_REGISTERED      "descent2.ham"
 438 #define DEFAULT_HAMFILE_SHAREWARE       "d2demo.ham"
 439
 440 #define D1_PALETTE "palette.256"
 441
 442 #define DEFAULT_PIGFILE (cfexist(DEFAULT_PIGFILE_REGISTERED)?DEFAULT_PIGFILE_REGISTERED:DEFAULT_PIGFILE_SHAREWARE)
 443 #define DEFAULT_HAMFILE (cfexist(DEFAULT_HAMFILE_REGISTERED)?DEFAULT_HAMFILE_REGISTERED:DEFAULT_HAMFILE_SHAREWARE)
 444 #define DEFAULT_SNDFILE ((Piggy_hamfile_version < 3)?DEFAULT_HAMFILE_SHAREWARE:(digi_sample_rate==SAMPLE_RATE_22K)?"descent2.s22":"descent2.s11")
 445
 446 #define MAC_ALIEN1_PIGSIZE      5013035
 447 #define MAC_ALIEN2_PIGSIZE      4909916
 448 #define MAC_FIRE_PIGSIZE        4969035
 449 #define MAC_GROUPA_PIGSIZE      4929684 // also used for mac shareware
 450 #define MAC_ICE_PIGSIZE         4923425
 451 #define MAC_WATER_PIGSIZE       4832403
 452
 453 ubyte *BitmapBits = NULL;
 454 ubyte *SoundBits = NULL;
 455
 456 typedef struct BitmapFile {
 457         char    name[15];
 458 } BitmapFile;
 459
 460 typedef struct SoundFile {
 461         char    name[15];
 462 } SoundFile;
 463
 464 hashtable AllBitmapsNames;
 465 hashtable AllDigiSndNames;
 466
 467 int Num_bitmap_files = 0;
 468 int Num_sound_files = 0;
 469
 470 digi_sound GameSounds[MAX_SOUND_FILES];
 471 int SoundOffset[MAX_SOUND_FILES];
 472 grs_bitmap GameBitmaps[MAX_BITMAP_FILES];
 473
 474 alias alias_list[MAX_ALIASES];
 475 int Num_aliases=0;
 476
 477 int Must_write_hamfile = 0;
 478 int Num_bitmap_files_new = 0;
 479 int Num_sound_files_new = 0;
 480 BitmapFile AllBitmaps[ MAX_BITMAP_FILES ];
 481 static SoundFile AllSounds[ MAX_SOUND_FILES ];
 482
 483 int Piggy_hamfile_version = 0;
 484
 485 int piggy_low_memory = 0;
 486
 487 int Piggy_bitmap_cache_size = 0;
 488 int Piggy_bitmap_cache_next = 0;
 489 ubyte * Piggy_bitmap_cache_data = NULL;
 490 static int GameBitmapOffset[MAX_BITMAP_FILES];
 491 static ubyte GameBitmapFlags[MAX_BITMAP_FILES];
 492 ushort GameBitmapXlat[MAX_BITMAP_FILES];
 493
 494 #define PIGGY_BUFFER_SIZE (2400*1024)
 495
 496 #ifdef MACINTOSH
 497 #define PIGGY_SMALL_BUFFER_SIZE (1400*1024)             // size of buffer when piggy_low_memory is set
 498
 499 #ifdef SHAREWARE
 500 #undef PIGGY_BUFFER_SIZE
 501 #undef PIGGY_SMALL_BUFFER_SIZE
 502
 503 #define PIGGY_BUFFER_SIZE (2000*1024)
 504 #define PIGGY_SMALL_BUFFER_SIZE (1100 * 1024)
 505 #endif          // SHAREWARE
 506
 507 #endif
 508
 509 int piggy_page_flushed = 0;
 510
 511 #define DBM_FLAG_ABM            64
 512
 513 #define BM_FLAGS_TO_COPY (BM_FLAG_TRANSPARENT | BM_FLAG_SUPER_TRANSPARENT \
 514                          | BM_FLAG_NO_LIGHTING | BM_FLAG_RLE | BM_FLAG_RLE_BIG)
 515
 516 ubyte BigPig = 0;
 517
 518 #ifdef MACINTOSH
 519         extern short    cd_VRefNum;
 520         extern void             ConcatPStr(StringPtr dst, StringPtr src);
 521         extern int              ConvertPToCStr(StringPtr inPStr, char* outCStrBuf);
 522         extern int              ConvertCToPStr(char* inCStr, StringPtr outPStrBuf);
 523 #endif
 524
 525 int piggy_is_substitutable_bitmap( char * name, char * subst_name );
 526
 527 #ifdef EDITOR
 528 void piggy_write_pigfile(char *filename);
 529 static void write_int(int i,FILE *file);
 530 #endif
 531
 532 void swap_0_255(grs_bitmap *bmp)
 533 {
 534         int i;
 535
 536         for (i = 0; i < bmp->bm_h * bmp->bm_w; i++) {
 537                 if(bmp->bm_data[i] == 0)
 538                         bmp->bm_data[i] = 255;
 539                 else if (bmp->bm_data[i] == 255)
 540                         bmp->bm_data[i] = 0;
 541         }
 542 }
 543
 544 bitmap_index piggy_register_bitmap( grs_bitmap * bmp, char * name, int in_file )
 545 {
 546         bitmap_index temp;
 547         Assert( Num_bitmap_files < MAX_BITMAP_FILES );
 548
 549         temp.index = Num_bitmap_files;
 550
 551         if (!in_file)   {
 552 #ifdef EDITOR
 553                 if ( FindArg("-macdata") )
 554                         swap_0_255( bmp );
 555 #endif
 556                 if ( !BigPig )  gr_bitmap_rle_compress( bmp );
 557                 Num_bitmap_files_new++;
 558         }
 559
 560         strncpy( AllBitmaps[Num_bitmap_files].name, name, 12 );
 561         hashtable_insert( &AllBitmapsNames, AllBitmaps[Num_bitmap_files].name, Num_bitmap_files );
 562         GameBitmaps[Num_bitmap_files] = *bmp;
 563         if ( !in_file ) {
 564                 GameBitmapOffset[Num_bitmap_files] = 0;
 565                 GameBitmapFlags[Num_bitmap_files] = bmp->bm_flags;
 566         }
 567         Num_bitmap_files++;
 568
 569         return temp;
 570 }
 571
 572 int piggy_register_sound( digi_sound * snd, char * name, int in_file )
 573 {
 574         int i;
 575
 576         Assert( Num_sound_files < MAX_SOUND_FILES );
 577
 578         strncpy( AllSounds[Num_sound_files].name, name, 12 );
 579         hashtable_insert( &AllDigiSndNames, AllSounds[Num_sound_files].name, Num_sound_files );
 580         GameSounds[Num_sound_files] = *snd;
 581         if ( !in_file ) {
 582                 SoundOffset[Num_sound_files] = 0;
 583         }
 584
 585         i = Num_sound_files;
 586
 587         if (!in_file)
 588                 Num_sound_files_new++;
 589
 590         Num_sound_files++;
 591         return i;
 592 }
 593
 594 bitmap_index piggy_find_bitmap( char * name )
 595 {
 596         bitmap_index bmp;
 597         int i;
 598         char *t;
 599
 600         bmp.index = 0;
 601
 602         if ((t=strchr(name,'#'))!=NULL)
 603                 *t=0;
 604
 605         for (i=0;i<Num_aliases;i++)
 606                 if (stricmp(name,alias_list[i].alias_name)==0) {
 607                         if (t) {                //extra stuff for ABMs
 608                                 static char temp[FILENAME_LEN];
 609                                 _splitpath(alias_list[i].file_name, NULL, NULL, temp, NULL );
 610                                 name = temp;
 611                                 strcat(name,"#");
 612                                 strcat(name,t+1);
 613                         }
 614                         else
 615                                 name=alias_list[i].file_name;
 616                         break;
 617                 }
 618
 619         if (t)
 620                 *t = '#';
 621
 622         i = hashtable_search( &AllBitmapsNames, name );
 623         Assert( i != 0 );
 624         if ( i < 0 )
 625                 return bmp;
 626
 627         bmp.index = i;
 628         return bmp;
 629 }
 630
 631 int piggy_find_sound( char * name )
 632 {
 633         int i;
 634
 635         i = hashtable_search( &AllDigiSndNames, name );
 636
 637         if ( i < 0 )
 638                 return 255;
 639
 640         return i;
 641 }
 642
 643 CFILE * Piggy_fp = NULL;
 644
 645 #define FILENAME_LEN 13
 646
 647 char Current_pigfile[FILENAME_LEN] = "";
 648
 649 void piggy_close_file()
 650 {
 651         if ( Piggy_fp ) {
 652                 cfclose( Piggy_fp );
 653                 Piggy_fp        = NULL;
 654                 Current_pigfile[0] = 0;
 655         }
 656 }
 657
 658 int Pigfile_initialized=0;
 659
 660 #define PIGFILE_ID              MAKE_SIG('G','I','P','P') //PPIG
 661 #define PIGFILE_VERSION         2
 662
 663 extern char CDROM_dir[];
 664
 665 int request_cd(void);
 666
 667
 668 #ifdef MACINTOSH
 669
 670 //copies a pigfile from the CD to the current dir
 671 //retuns file handle of new pig
 672 CFILE *copy_pigfile_from_cd(char *filename)             // MACINTOSH VERSION
 673 {
 674         // C Stuff
 675         char                    sourcePathAndFileCStr[255] = "";
 676         char                    destPathAndFileCStr[255]        = "";
 677         FILEFINDSTRUCT  find;
 678         FILE*                   sourceFile      = NULL;
 679         FILE*                   destFile        = NULL;
 680         const int               BUF_SIZE = 4096;
 681         ubyte                   buf[BUF_SIZE];
 682
 683         // Mac Stuff
 684         Str255                  sourcePathAndFilePStr = "\p";
 685         Str255                  destPathAndFilePStr = "\p";
 686         Str255                  pigfileNamePStr = "\p";
 687         HParamBlockRec  theSourcePigHFSParams;
 688         HParamBlockRec  theDestPigHFSParams;
 689         OSErr                   theErr = noErr;
 690         char                    oldDirCStr[255] = "";
 691
 692         getcwd(oldDirCStr, 255);
 693
 694         show_boxed_message("Copying bitmap data from CD...");
 695         gr_palette_load(gr_palette);    //I don't think this line is really needed
 696
 697         chdir(":Data");
 698         //First, delete all PIG files currently in the directory
 699         if( !FileFindFirst( "*.pig", &find ) )
 700         {
 701                 do
 702                 {
 703                         remove(find.name);
 704                 } while( !FileFindNext( &find ) );
 705
 706                 FileFindClose();
 707         }
 708         chdir(oldDirCStr);
 709
 710         //Now, copy over new pig
 711         songs_stop_redbook();           //so we can read off the cd
 712
 713         // make the source path "<cd volume>:Data:filename.pig"
 714 //MWA   ConvertCToPStr(filename, pigfileNamePStr);
 715
 716 //MWA   ConcatPStr(sourcePathAndFilePStr, "\pDescent II:Data:");        // volume ID is cd_VRefNum
 717 //MWA   ConcatPStr(sourcePathAndFilePStr, pigfileNamePStr);
 718
 719         strupr(filename);
 720         strcpy(sourcePathAndFileCStr, "Descent II:Data:");
 721         strcat(sourcePathAndFileCStr, filename);
 722
 723         // make the destination path "<default directory>:Data:filename.pig"
 724 //MWA   ConcatPStr(destPathAndFilePStr, "\p:Data:");
 725 //MWA   ConcatPStr(destPathAndFilePStr, pigfileNamePStr);
 726 //MWA   ConvertPToCStr(sourcePathAndFilePStr, sourcePathAndFileCStr);
 727 //MWA   ConvertPToCStr(destPathAndFilePStr, destPathAndFileCStr);
 728
 729         strcpy(destPathAndFileCStr, ":Data:");
 730         strcat(destPathAndFileCStr, filename);
 731
 732         strcpy(sourcePathAndFilePStr, sourcePathAndFileCStr);
 733         strcpy(destPathAndFilePStr, destPathAndFileCStr);
 734         c2pstr(sourcePathAndFilePStr);
 735         c2pstr(destPathAndFilePStr);
 736
 737         do {
 738                 // Open the source file
 739                 sourceFile = fopen(sourcePathAndFileCStr,"rb");
 740
 741                 if (!sourceFile) {
 742
 743                         if (request_cd() == -1)
 744                                 Error("Cannot load file <%s> from CD",filename);
 745                 }
 746
 747         } while (!sourceFile);
 748
 749
 750         // Get the time stamp from the source file
 751         theSourcePigHFSParams.fileParam.ioCompletion    = nil;
 752         theSourcePigHFSParams.fileParam.ioNamePtr               = sourcePathAndFilePStr;
 753         theSourcePigHFSParams.fileParam.ioVRefNum               = cd_VRefNum;
 754         theSourcePigHFSParams.fileParam.ioFDirIndex     = 0;
 755         theSourcePigHFSParams.fileParam.ioDirID         = 0;
 756
 757         theErr = PBHGetFInfo(&theSourcePigHFSParams, false);
 758         if (theErr != noErr)
 759         {
 760                 // Error getting file time stamp!! Why? JTS
 761                 Error("Can't get old file time stamp: <%s>\n", sourcePathAndFileCStr);
 762         }
 763
 764         // Copy the file over
 765         // C Stuff......
 766
 767         // Open the destination file
 768         destFile = fopen(destPathAndFileCStr,"wb");
 769         if (!destFile)
 770         {
 771                 Error("Cannot create file: <%s>\n", destPathAndFileCStr);
 772         }
 773
 774         // Copy bytes until the end of the source file
 775         while (!feof(sourceFile))
 776         {
 777                 int bytes_read;
 778                 int x;
 779
 780                 bytes_read = fread(buf,1,BUF_SIZE,sourceFile);
 781                 if (ferror(sourceFile))
 782                         Error("Cannot read from file <%s>: %s", sourcePathAndFileCStr, strerror(errno));
 783
 784 // Assert is bogus              Assert(bytes_read == BUF_SIZE || feof(sourceFile));
 785
 786                 fwrite(buf,1,bytes_read,destFile);
 787                 if (ferror(destFile))
 788                         Error("Cannot write to file <%s>: %s",destPathAndFileCStr, strerror(errno));
 789         }
 790
 791         // close the source/dest files
 792         if (fclose(sourceFile))
 793                 Error("Error closing file <%s>: %s", sourcePathAndFileCStr, strerror(errno));
 794         if (fclose(destFile))
 795                 Error("Error closing file <%s>: %s", destPathAndFileCStr, strerror(errno));
 796
 797         // Get the current hfs data for the new file
 798         theDestPigHFSParams.fileParam.ioCompletion      = nil;
 799         theDestPigHFSParams.fileParam.ioNamePtr         = destPathAndFilePStr;
 800         theDestPigHFSParams.fileParam.ioVRefNum         = 0;
 801         theDestPigHFSParams.fileParam.ioFDirIndex       = 0;
 802         theDestPigHFSParams.fileParam.ioDirID           = 0;
 803         theErr = PBHGetFInfo(&theDestPigHFSParams, false);
 804         if ((theErr != noErr) || (theDestPigHFSParams.fileParam.ioResult != noErr))
 805         {
 806                 // Error getting file time stamp!! Why? JTS
 807                 Error("Can't get destination pig file information: <%s>\n", destPathAndFileCStr);
 808         }
 809
 810         // Reset this data !!!!! or else the relative pathname won't work, could use just filename instead but, oh well.
 811         theDestPigHFSParams.fileParam.ioNamePtr         = destPathAndFilePStr;
 812         theDestPigHFSParams.fileParam.ioVRefNum         = 0;
 813         theDestPigHFSParams.fileParam.ioFDirIndex       = 0;
 814         theDestPigHFSParams.fileParam.ioDirID           = 0;
 815
 816         // Copy the time stamp from the source file info
 817         theDestPigHFSParams.fileParam.ioFlCrDat = theSourcePigHFSParams.fileParam.ioFlCrDat;
 818         theDestPigHFSParams.fileParam.ioFlMdDat = theSourcePigHFSParams.fileParam.ioFlMdDat;
 819         theDestPigHFSParams.fileParam.ioFlFndrInfo.fdType = 'PGGY';
 820         theDestPigHFSParams.fileParam.ioFlFndrInfo.fdCreator = 'DCT2';
 821
 822         // Set the dest file's time stamp to the source file's time stamp values
 823         theErr = PBHSetFInfo(&theDestPigHFSParams, false);
 824
 825         if ((theErr != noErr) || (theDestPigHFSParams.fileParam.ioResult != noErr))
 826         {
 827                 Error("Can't set destination pig file time stamp: <%s>\n", destPathAndFileCStr);
 828         }
 829
 830         theErr = PBHGetFInfo(&theDestPigHFSParams, false);
 831
 832         return cfopen(destPathAndFileCStr, "rb");
 833 }
 834
 835 #else   //PC Version of copy_pigfile_from_cd is below
 836
 837 //copies a pigfile from the CD to the current dir
 838 //retuns file handle of new pig
 839 CFILE *copy_pigfile_from_cd(char *filename)
 840 {
 841         char name[80];
 842         FILEFINDSTRUCT find;
 843         int ret;
 844
 845         return cfopen(filename, "rb");
 846         show_boxed_message("Copying bitmap data from CD...");
 847         gr_palette_load(gr_palette);    //I don't think this line is really needed
 848
 849         //First, delete all PIG files currently in the directory
 850
 851         if( !FileFindFirst( "*.pig", &find ) ) {
 852                 do      {
 853                         cfile_delete(find.name);
 854                 } while( !FileFindNext( &find ) );
 855                 FileFindClose();
 856         }
 857
 858         //Now, copy over new pig
 859
 860         songs_stop_redbook();           //so we can read off the cd
 861
 862         //new code to unarj file
 863         strcpy(name,CDROM_dir);
 864         strcat(name,"descent2.sow");
 865
 866         do {
 867 //              ret = unarj_specific_file(name,filename,filename);
 868 // DPH:FIXME
 869
 870                 ret = !EXIT_SUCCESS;
 871
 872                 if (ret != EXIT_SUCCESS) {
 873
 874                         //delete file, so we don't leave partial file
 875                         cfile_delete(filename);
 876
 877                         #ifndef MACINTOSH
 878                         if (request_cd() == -1)
 879                         #endif
 880                                 //NOTE LINK TO ABOVE IF
 881                                 Error("Cannot load file <%s> from CD",filename);
 882                 }
 883
 884         } while (ret != EXIT_SUCCESS);
 885
 886         return cfopen(filename, "rb");
 887 }
 888
 889 #endif // end of ifdef MAC around copy_pigfile_from_cd
 890
 891 //initialize a pigfile, reading headers
 892 //returns the size of all the bitmap data
 893 void piggy_init_pigfile(char *filename)
 894 {
 895         int i;
 896         char temp_name[16];
 897         char temp_name_read[16];
 898         grs_bitmap temp_bitmap;
 899         DiskBitmapHeader bmh;
 900         int header_size, N_bitmaps, data_size, data_start;
 901         #ifdef MACINTOSH
 902         char name[255];         // filename + path for the mac
 903         #endif
 904
 905         piggy_close_file();             //close old pig if still open
 906
 907         //rename pigfile for shareware
 908         if (stricmp(DEFAULT_PIGFILE, DEFAULT_PIGFILE_SHAREWARE) == 0 && !cfexist(filename))
 909                 filename = DEFAULT_PIGFILE_SHAREWARE;
 910
 911         #ifndef MACINTOSH
 912                 Piggy_fp = cfopen( filename, "rb" );
 913         #else
 914                 sprintf(name, ":Data:%s", filename);
 915                 Piggy_fp = cfopen( name, "rb" );
 916
 917                 #ifdef SHAREWARE        // if we are in the shareware version, we must have the pig by now.
 918                         if (Piggy_fp == NULL)
 919                         {
 920                                 Error("Cannot load required file <%s>",name);
 921                         }
 922                 #endif  // end of if def shareware
 923
 924         #endif
 925
 926         if (!Piggy_fp) {
 927                 #ifdef EDITOR
 928                         return;         //if editor, ok to not have pig, because we'll build one
 929                 #else
 930                         Piggy_fp = copy_pigfile_from_cd(filename);
 931                 #endif
 932         }
 933
 934         if (Piggy_fp) {                         //make sure pig is valid type file & is up-to-date
 935                 int pig_id,pig_version;
 936
 937                 pig_id = cfile_read_int(Piggy_fp);
 938                 pig_version = cfile_read_int(Piggy_fp);
 939                 if (pig_id != PIGFILE_ID || pig_version != PIGFILE_VERSION) {
 940                         cfclose(Piggy_fp);              //out of date pig
 941                         Piggy_fp = NULL;                        //..so pretend it's not here
 942                 }
 943         }
 944
 945         if (!Piggy_fp) {
 946
 947                 #ifdef EDITOR
 948                         return;         //if editor, ok to not have pig, because we'll build one
 949                 #else
 950                         Error("Cannot load required file <%s>",filename);
 951                 #endif
 952         }
 953
 954         strncpy(Current_pigfile,filename,sizeof(Current_pigfile));
 955
 956         N_bitmaps = cfile_read_int(Piggy_fp);
 957
 958         header_size = N_bitmaps*DISKBITMAPHEADER_SIZE;
 959
 960         data_start = header_size + cftell(Piggy_fp);
 961
 962         data_size = cfilelength(Piggy_fp) - data_start;
 963
 964         Num_bitmap_files = 1;
 965
 966         for (i=0; i<N_bitmaps; i++ )    {
 967                 DiskBitmapHeader_read(&bmh, Piggy_fp);
 968                 memcpy( temp_name_read, bmh.name, 8 );
 969                 temp_name_read[8] = 0;
 970                 if ( bmh.dflags & DBM_FLAG_ABM )
 971                         sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
 972                 else
 973                         strcpy( temp_name, temp_name_read );
 974                 memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
 975                 temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
 976                 temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
 977                 temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
 978                 temp_bitmap.avg_color = bmh.avg_color;
 979                 temp_bitmap.bm_data = Piggy_bitmap_cache_data;
 980
 981                 GameBitmapFlags[i+1] = bmh.flags & BM_FLAGS_TO_COPY;
 982
 983                 GameBitmapOffset[i+1] = bmh.offset + data_start;
 984                 Assert( (i+1) == Num_bitmap_files );
 985                 piggy_register_bitmap( &temp_bitmap, temp_name, 1 );
 986         }
 987
 988 #ifdef EDITOR
 989         Piggy_bitmap_cache_size = data_size + (data_size/10);   //extra mem for new bitmaps
 990         Assert( Piggy_bitmap_cache_size > 0 );
 991 #else
 992         Piggy_bitmap_cache_size = PIGGY_BUFFER_SIZE;
 993         #ifdef MACINTOSH
 994         if (piggy_low_memory)
 995                 Piggy_bitmap_cache_size = PIGGY_SMALL_BUFFER_SIZE;
 996         #endif
 997 #endif
 998         BitmapBits = d_malloc( Piggy_bitmap_cache_size );
 999         if ( BitmapBits == NULL )
1000                 Error( "Not enough memory to load bitmaps\n" );
1001         Piggy_bitmap_cache_data = BitmapBits;
1002         Piggy_bitmap_cache_next = 0;
1003
1004         #if defined(MACINTOSH) && defined(SHAREWARE)
1005 //      load_exit_models();
1006         #endif
1007
1008         Pigfile_initialized=1;
1009 }
1010
1011 #define FILENAME_LEN 13
1012 #define MAX_BITMAPS_PER_BRUSH 30
1013
1014 extern int compute_average_pixel(grs_bitmap *new);
1015
1016 //reads in a new pigfile (for new palette)
1017 //returns the size of all the bitmap data
1018 void piggy_new_pigfile(char *pigname)
1019 {
1020         int i;
1021         char temp_name[16];
1022         char temp_name_read[16];
1023         grs_bitmap temp_bitmap;
1024         DiskBitmapHeader bmh;
1025         int header_size, N_bitmaps, data_size, data_start;
1026         int must_rewrite_pig = 0;
1027         #ifdef MACINTOSH
1028         char name[255];
1029         #endif
1030
1031         strlwr(pigname);
1032
1033         //rename pigfile for shareware
1034         if (stricmp(DEFAULT_PIGFILE, DEFAULT_PIGFILE_SHAREWARE) == 0 && !cfexist(pigname))
1035                 pigname = DEFAULT_PIGFILE_SHAREWARE;
1036
1037         if (strnicmp(Current_pigfile,pigname,sizeof(Current_pigfile))==0)
1038                 return;         //already have correct pig
1039
1040         if (!Pigfile_initialized) {                     //have we ever opened a pigfile?
1041                 piggy_init_pigfile(pigname);            //..no, so do initialization stuff
1042                 return;
1043         }
1044         else
1045                 piggy_close_file();             //close old pig if still open
1046
1047         Piggy_bitmap_cache_next = 0;            //free up cache
1048
1049         strncpy(Current_pigfile,pigname,sizeof(Current_pigfile));
1050
1051         #ifndef MACINTOSH
1052                 Piggy_fp = cfopen( pigname, "rb" );
1053         #else
1054                 sprintf(name, ":Data:%s", pigname);
1055                 Piggy_fp = cfopen( name, "rb" );
1056
1057                 #ifdef SHAREWARE        // if we are in the shareware version, we must have the pig by now.
1058                         if (Piggy_fp == NULL)
1059                         {
1060                                 Error("Cannot load required file <%s>",name);
1061                         }
1062                 #endif  // end of if def shareware
1063         #endif
1064
1065         #ifndef EDITOR
1066         if (!Piggy_fp)
1067                 Piggy_fp = copy_pigfile_from_cd(pigname);
1068         #endif
1069
1070         if (Piggy_fp) {  //make sure pig is valid type file & is up-to-date
1071                 int pig_id,pig_version;
1072
1073                 pig_id = cfile_read_int(Piggy_fp);
1074                 pig_version = cfile_read_int(Piggy_fp);
1075                 if (pig_id != PIGFILE_ID || pig_version != PIGFILE_VERSION) {
1076                         cfclose(Piggy_fp);              //out of date pig
1077                         Piggy_fp = NULL;                        //..so pretend it's not here
1078                 }
1079         }
1080
1081 #ifndef EDITOR
1082         if (!Piggy_fp)
1083                 Error("Cannot open correct version of <%s>", pigname);
1084 #endif
1085
1086         if (Piggy_fp) {
1087
1088                 N_bitmaps = cfile_read_int(Piggy_fp);
1089
1090                 header_size = N_bitmaps*DISKBITMAPHEADER_SIZE;
1091
1092                 data_start = header_size + cftell(Piggy_fp);
1093
1094                 data_size = cfilelength(Piggy_fp) - data_start;
1095
1096                 for (i=1; i<=N_bitmaps; i++ )   {
1097                         DiskBitmapHeader_read(&bmh, Piggy_fp);
1098                         memcpy( temp_name_read, bmh.name, 8 );
1099                         temp_name_read[8] = 0;
1100
1101                         if ( bmh.dflags & DBM_FLAG_ABM )
1102                                 sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
1103                         else
1104                                 strcpy( temp_name, temp_name_read );
1105
1106                         //Make sure name matches
1107                         if (strcmp(temp_name,AllBitmaps[i].name)) {
1108                                 //Int3();       //this pig is out of date.  Delete it
1109                                 must_rewrite_pig=1;
1110                         }
1111
1112                         strcpy(AllBitmaps[i].name,temp_name);
1113
1114                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
1115
1116                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
1117                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
1118                         temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
1119                         temp_bitmap.avg_color = bmh.avg_color;
1120                         temp_bitmap.bm_data = Piggy_bitmap_cache_data;
1121
1122                         GameBitmapFlags[i] = bmh.flags & BM_FLAGS_TO_COPY;
1123
1124                         GameBitmapOffset[i] = bmh.offset + data_start;
1125
1126                         GameBitmaps[i] = temp_bitmap;
1127                 }
1128         }
1129         else
1130                 N_bitmaps = 0;          //no pigfile, so no bitmaps
1131
1132         #ifndef EDITOR
1133
1134         Assert(N_bitmaps == Num_bitmap_files-1);
1135
1136         #else
1137
1138         if (must_rewrite_pig || (N_bitmaps < Num_bitmap_files-1)) {
1139                 int size;
1140
1141                 //re-read the bitmaps that aren't in this pig
1142
1143                 for (i=N_bitmaps+1;i<Num_bitmap_files;i++) {
1144                         char *p;
1145
1146                         p = strchr(AllBitmaps[i].name,'#');
1147
1148                         if (p) {                //this is an ABM
1149                                 char abmname[FILENAME_LEN];
1150                                 int fnum;
1151                                 grs_bitmap * bm[MAX_BITMAPS_PER_BRUSH];
1152                                 int iff_error;          //reference parm to avoid warning message
1153                                 ubyte newpal[768];
1154                                 char basename[FILENAME_LEN];
1155                                 int nframes;
1156
1157                                 strcpy(basename,AllBitmaps[i].name);
1158                                 basename[p-AllBitmaps[i].name] = 0;             //cut off "#nn" part
1159
1160                                 sprintf( abmname, "%s.abm", basename );
1161
1162                                 iff_error = iff_read_animbrush(abmname,bm,MAX_BITMAPS_PER_BRUSH,&nframes,newpal);
1163
1164                                 if (iff_error != IFF_NO_ERROR)  {
1165                                         mprintf((1,"File %s - IFF error: %s",abmname,iff_errormsg(iff_error)));
1166                                         Error("File %s - IFF error: %s",abmname,iff_errormsg(iff_error));
1167                                 }
1168
1169                                 for (fnum=0;fnum<nframes; fnum++)       {
1170                                         char tempname[20];
1171                                         int SuperX;
1172
1173                                         sprintf( tempname, "%s#%d", basename, fnum );
1174
1175                                         //SuperX = (GameBitmaps[i+fnum].bm_flags&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
1176                                         SuperX = (GameBitmapFlags[i+fnum]&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
1177                                         //above makes assumption that supertransparent color is 254
1178
1179                                         if ( iff_has_transparency )
1180                                                 gr_remap_bitmap_good( bm[fnum], newpal, iff_transparent_color, SuperX );
1181                                         else
1182                                                 gr_remap_bitmap_good( bm[fnum], newpal, -1, SuperX );
1183
1184                                         bm[fnum]->avg_color = compute_average_pixel(bm[fnum]);
1185
1186 #ifdef EDITOR
1187                                         if ( FindArg("-macdata") )
1188                                                 swap_0_255( bm[fnum] );
1189 #endif
1190                                         if ( !BigPig ) gr_bitmap_rle_compress( bm[fnum] );
1191
1192                                         if (bm[fnum]->bm_flags & BM_FLAG_RLE)
1193                                                 size = *((int *) bm[fnum]->bm_data);
1194                                         else
1195                                                 size = bm[fnum]->bm_w * bm[fnum]->bm_h;
1196
1197                                         memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],bm[fnum]->bm_data,size);
1198                                         d_free(bm[fnum]->bm_data);
1199                                         bm[fnum]->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1200                                         Piggy_bitmap_cache_next += size;
1201
1202                                         GameBitmaps[i+fnum] = *bm[fnum];
1203
1204                                         // -- mprintf( (0, "U" ));
1205                                         d_free( bm[fnum] );
1206                                 }
1207
1208                                 i += nframes-1;         //filled in multiple bitmaps
1209                         }
1210                         else {          //this is a BBM
1211
1212                                 grs_bitmap * new;
1213                                 ubyte newpal[256*3];
1214                                 int iff_error;
1215                                 char bbmname[FILENAME_LEN];
1216                                 int SuperX;
1217
1218                                 MALLOC( new, grs_bitmap, 1 );
1219
1220                                 sprintf( bbmname, "%s.bbm", AllBitmaps[i].name );
1221                                 iff_error = iff_read_bitmap(bbmname,new,BM_LINEAR,newpal);
1222
1223                                 new->bm_handle=0;
1224                                 if (iff_error != IFF_NO_ERROR)          {
1225                                         mprintf((1, "File %s - IFF error: %s",bbmname,iff_errormsg(iff_error)));
1226                                         Error("File %s - IFF error: %s",bbmname,iff_errormsg(iff_error));
1227                                 }
1228
1229                                 SuperX = (GameBitmapFlags[i]&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
1230                                 //above makes assumption that supertransparent color is 254
1231
1232                                 if ( iff_has_transparency )
1233                                         gr_remap_bitmap_good( new, newpal, iff_transparent_color, SuperX );
1234                                 else
1235                                         gr_remap_bitmap_good( new, newpal, -1, SuperX );
1236
1237                                 new->avg_color = compute_average_pixel(new);
1238
1239 #ifdef EDITOR
1240                                 if ( FindArg("-macdata") )
1241                                         swap_0_255( new );
1242 #endif
1243                                 if ( !BigPig )  gr_bitmap_rle_compress( new );
1244
1245                                 if (new->bm_flags & BM_FLAG_RLE)
1246                                         size = *((int *) new->bm_data);
1247                                 else
1248                                         size = new->bm_w * new->bm_h;
1249
1250                                 memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],new->bm_data,size);
1251                                 d_free(new->bm_data);
1252                                 new->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1253                                 Piggy_bitmap_cache_next += size;
1254
1255                                 GameBitmaps[i] = *new;
1256
1257                                 d_free( new );
1258
1259                                 // -- mprintf( (0, "U" ));
1260                         }
1261                 }
1262
1263                 //@@Dont' do these things which are done when writing
1264                 //@@for (i=0; i < Num_bitmap_files; i++ )       {
1265                 //@@    bitmap_index bi;
1266                 //@@    bi.index = i;
1267                 //@@    PIGGY_PAGE_IN( bi );
1268                 //@@}
1269                 //@@
1270                 //@@piggy_close_file();
1271
1272                 piggy_write_pigfile(pigname);
1273
1274                 Current_pigfile[0] = 0;                 //say no pig, to force reload
1275
1276                 piggy_new_pigfile(pigname);             //read in just-generated pig
1277
1278
1279         }
1280         #endif  //ifdef EDITOR
1281
1282 }
1283
1284 ubyte bogus_data[64*64];
1285 grs_bitmap bogus_bitmap;
1286 ubyte bogus_bitmap_initialized=0;
1287 digi_sound bogus_sound;
1288
1289 #define HAMFILE_ID              MAKE_SIG('!','M','A','H') //HAM!
1290 #define HAMFILE_VERSION 3
1291 //version 1 -> 2:  save marker_model_num
1292 //version 2 -> 3:  removed sound files
1293
1294 #define SNDFILE_ID              MAKE_SIG('D','N','S','D') //DSND
1295 #define SNDFILE_VERSION 1
1296
1297 int read_hamfile()
1298 {
1299         CFILE * ham_fp = NULL;
1300         int ham_id;
1301         int sound_offset = 0;
1302         #ifdef MACINTOSH
1303         char name[255];
1304         #endif
1305
1306         #ifndef MACINTOSH
1307         ham_fp = cfopen( DEFAULT_HAMFILE, "rb" );
1308         #else
1309         sprintf(name, ":Data:%s", DEFAULT_HAMFILE );
1310         ham_fp = cfopen( name, "rb" );
1311         #endif
1312
1313         if (ham_fp == NULL) {
1314                 Must_write_hamfile = 1;
1315                 return 0;
1316         }
1317
1318         //make sure ham is valid type file & is up-to-date
1319         ham_id = cfile_read_int(ham_fp);
1320         Piggy_hamfile_version = cfile_read_int(ham_fp);
1321         if (ham_id != HAMFILE_ID)
1322                 Error("Cannot open ham file %s\n", DEFAULT_HAMFILE);
1323 #if 0
1324         if (ham_id != HAMFILE_ID || Piggy_hamfile_version != HAMFILE_VERSION) {
1325                 Must_write_hamfile = 1;
1326                 cfclose(ham_fp);                                                //out of date ham
1327                 return 0;
1328         }
1329 #endif
1330
1331         if (Piggy_hamfile_version < 3) // hamfile contains sound info
1332                 sound_offset = cfile_read_int(ham_fp);
1333
1334         #ifndef EDITOR
1335         {
1336                 //int i;
1337
1338                 bm_read_all(ham_fp);
1339                 cfread( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1340                 // no swap here?
1341                 //for (i = 0; i < MAX_BITMAP_FILES; i++) {
1342                         //GameBitmapXlat[i] = INTEL_SHORT(GameBitmapXlat[i]);
1343                         //printf("GameBitmapXlat[%d] = %d\n", i, GameBitmapXlat[i]);
1344                 //}
1345         }
1346         #endif
1347
1348         if (Piggy_hamfile_version < 3) {
1349                 int N_sounds;
1350                 int sound_start;
1351                 int header_size;
1352                 int i;
1353                 DiskSoundHeader sndh;
1354                 digi_sound temp_sound;
1355                 char temp_name_read[16];
1356                 int sbytes = 0;
1357
1358                 cfseek(ham_fp, sound_offset, SEEK_SET);
1359                 N_sounds = cfile_read_int(ham_fp);
1360
1361                 sound_start = cftell(ham_fp);
1362
1363                 header_size = N_sounds * DISKSOUNDHEADER_SIZE;
1364
1365                 //Read sounds
1366
1367                 for (i=0; i<N_sounds; i++ ) {
1368                         DiskSoundHeader_read(&sndh, ham_fp);
1369                         temp_sound.length = sndh.length;
1370                         temp_sound.data = (ubyte *)(sndh.offset + header_size + sound_start);
1371                         SoundOffset[Num_sound_files] = sndh.offset + header_size + sound_start;
1372                         memcpy( temp_name_read, sndh.name, 8 );
1373                         temp_name_read[8] = 0;
1374                         piggy_register_sound( &temp_sound, temp_name_read, 1 );
1375 #ifdef MACINTOSH
1376                         if (piggy_is_needed(i))
1377 #endif          // note link to if.
1378                                 sbytes += sndh.length;
1379                         //mprintf(( 0, "%d bytes of sound\n", sbytes ));
1380                 }
1381
1382                 SoundBits = d_malloc( sbytes + 16 );
1383                 if ( SoundBits == NULL )
1384                         Error( "Not enough memory to load sounds\n" );
1385
1386                 mprintf(( 0, "\nBitmaps: %d KB   Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
1387
1388                 //      piggy_read_sounds(ham_fp);
1389
1390         }
1391
1392         cfclose(ham_fp);
1393
1394         return 1;
1395
1396 }
1397
1398 int read_sndfile()
1399 {
1400         CFILE * snd_fp = NULL;
1401         int snd_id,snd_version;
1402         int N_sounds;
1403         int sound_start;
1404         int header_size;
1405         int i,size, length;
1406         DiskSoundHeader sndh;
1407         digi_sound temp_sound;
1408         char temp_name_read[16];
1409         int sbytes = 0;
1410         #ifdef MACINTOSH
1411         char name[255];
1412         #endif
1413
1414         #ifndef MACINTOSH
1415         snd_fp = cfopen( DEFAULT_SNDFILE, "rb" );
1416         #else
1417         sprintf( name, ":Data:%s", DEFAULT_SNDFILE );
1418         snd_fp = cfopen( name, "rb");
1419         #endif
1420
1421         if (snd_fp == NULL)
1422                 return 0;
1423
1424         //make sure soundfile is valid type file & is up-to-date
1425         snd_id = cfile_read_int(snd_fp);
1426         snd_version = cfile_read_int(snd_fp);
1427         if (snd_id != SNDFILE_ID || snd_version != SNDFILE_VERSION) {
1428                 cfclose(snd_fp);                                                //out of date sound file
1429                 return 0;
1430         }
1431
1432         N_sounds = cfile_read_int(snd_fp);
1433
1434         sound_start = cftell(snd_fp);
1435         size = cfilelength(snd_fp) - sound_start;
1436         length = size;
1437         mprintf( (0, "\nReading data (%d KB) ", size/1024 ));
1438
1439         header_size = N_sounds*sizeof(DiskSoundHeader);
1440
1441         //Read sounds
1442
1443         for (i=0; i<N_sounds; i++ ) {
1444                 DiskSoundHeader_read(&sndh, snd_fp);
1445                 //size -= sizeof(DiskSoundHeader);
1446                 temp_sound.length = sndh.length;
1447                 temp_sound.data = (ubyte *)(sndh.offset + header_size + sound_start);
1448                 SoundOffset[Num_sound_files] = sndh.offset + header_size + sound_start;
1449                 memcpy( temp_name_read, sndh.name, 8 );
1450                 temp_name_read[8] = 0;
1451                 piggy_register_sound( &temp_sound, temp_name_read, 1 );
1452                 #ifdef MACINTOSH
1453                 if (piggy_is_needed(i))
1454                 #endif          // note link to if.
1455                 sbytes += sndh.length;
1456                 //mprintf(( 0, "%d bytes of sound\n", sbytes ));
1457         }
1458
1459         SoundBits = d_malloc( sbytes + 16 );
1460         if ( SoundBits == NULL )
1461                 Error( "Not enough memory to load sounds\n" );
1462
1463         mprintf(( 0, "\nBitmaps: %d KB   Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
1464
1465 //      piggy_read_sounds(snd_fp);
1466
1467         cfclose(snd_fp);
1468
1469         return 1;
1470 }
1471
1472 int piggy_init(void)
1473 {
1474         int ham_ok=0,snd_ok=0;
1475         int i;
1476
1477         hashtable_init( &AllBitmapsNames, MAX_BITMAP_FILES );
1478         hashtable_init( &AllDigiSndNames, MAX_SOUND_FILES );
1479
1480         for (i=0; i<MAX_SOUND_FILES; i++ )      {
1481                 GameSounds[i].length = 0;
1482                 GameSounds[i].data = NULL;
1483                 SoundOffset[i] = 0;
1484         }
1485
1486         for (i=0; i<MAX_BITMAP_FILES; i++ )
1487                 GameBitmapXlat[i] = i;
1488
1489         if ( !bogus_bitmap_initialized )        {
1490                 int i;
1491                 ubyte c;
1492                 bogus_bitmap_initialized = 1;
1493                 memset( &bogus_bitmap, 0, sizeof(grs_bitmap) );
1494                 bogus_bitmap.bm_w = bogus_bitmap.bm_h = bogus_bitmap.bm_rowsize = 64;
1495                 bogus_bitmap.bm_data = bogus_data;
1496                 c = gr_find_closest_color( 0, 0, 63 );
1497                 for (i=0; i<4096; i++ ) bogus_data[i] = c;
1498                 c = gr_find_closest_color( 63, 0, 0 );
1499                 // Make a big red X !
1500                 for (i=0; i<64; i++ )   {
1501                         bogus_data[i*64+i] = c;
1502                         bogus_data[i*64+(63-i)] = c;
1503                 }
1504                 piggy_register_bitmap( &bogus_bitmap, "bogus", 1 );
1505                 bogus_sound.length = 64*64;
1506                 bogus_sound.data = bogus_data;
1507                 GameBitmapOffset[0] = 0;
1508         }
1509
1510         if ( FindArg( "-bigpig" ))
1511                 BigPig = 1;
1512
1513         if ( FindArg( "-lowmem" ))
1514                 piggy_low_memory = 1;
1515
1516         if ( FindArg( "-nolowmem" ))
1517                 piggy_low_memory = 0;
1518
1519         if (piggy_low_memory)
1520                 digi_lomem = 1;
1521
1522         WIN(DDGRLOCK(dd_grd_curcanv));
1523                 gr_set_curfont( SMALL_FONT );
1524                 gr_set_fontcolor(gr_find_closest_color_current( 20, 20, 20 ),-1 );
1525                 gr_printf( 0x8000, grd_curcanv->cv_h-20, "%s...", TXT_LOADING_DATA );
1526         WIN(DDGRUNLOCK(dd_grd_curcanv));
1527
1528 #if 1 //def EDITOR //need for d1 mission briefings
1529         piggy_init_pigfile(DEFAULT_PIGFILE);
1530 #endif
1531
1532         snd_ok = ham_ok = read_hamfile();
1533
1534         if (Piggy_hamfile_version >= 3)
1535                 snd_ok = read_sndfile();
1536
1537         atexit(piggy_close);
1538
1539         mprintf ((0,"HamOk=%d SndOk=%d\n",ham_ok,snd_ok));
1540         return (ham_ok && snd_ok);               //read ok
1541 }
1542
1543 int piggy_is_needed(int soundnum)
1544 {
1545         int i;
1546
1547         if ( !digi_lomem ) return 1;
1548
1549         for (i=0; i<MAX_SOUNDS; i++ )   {
1550                 if ( (AltSounds[i] < 255) && (Sounds[AltSounds[i]] == soundnum) )
1551                         return 1;
1552         }
1553         return 0;
1554 }
1555
1556
1557 void piggy_read_sounds(void)
1558 {
1559         CFILE * fp = NULL;
1560         ubyte * ptr;
1561         int i, sbytes;
1562         #ifdef MACINTOSH
1563         char name[255];
1564         #endif
1565
1566         ptr = SoundBits;
1567         sbytes = 0;
1568
1569         #ifndef MACINTOSH
1570         fp = cfopen( DEFAULT_SNDFILE, "rb" );
1571         #else
1572         sprintf( name, ":Data:%s", DEFAULT_SNDFILE );
1573         fp = cfopen( name, "rb");
1574         #endif
1575
1576         if (fp == NULL)
1577                 return;
1578
1579         for (i=0; i<Num_sound_files; i++ )      {
1580                 digi_sound *snd = &GameSounds[i];
1581
1582                 if ( SoundOffset[i] > 0 )       {
1583                         if ( piggy_is_needed(i) )       {
1584                                 cfseek( fp, SoundOffset[i], SEEK_SET );
1585
1586                                 // Read in the sound data!!!
1587                                 snd->data = ptr;
1588                                 ptr += snd->length;
1589                                 sbytes += snd->length;
1590                                 cfread( snd->data, snd->length, 1, fp );
1591                         }
1592                         else
1593                                 snd->data = (ubyte *) -1;
1594                 }
1595         }
1596
1597         cfclose(fp);
1598
1599         mprintf(( 0, "\nActual Sound usage: %d KB\n", sbytes/1024 ));
1600
1601 }
1602
1603
1604 extern int descent_critical_error;
1605 extern unsigned descent_critical_deverror;
1606 extern unsigned descent_critical_errcode;
1607
1608 char * crit_errors[13] = { "Write Protected", "Unknown Unit", "Drive Not Ready", "Unknown Command", "CRC Error", \
1609 "Bad struct length", "Seek Error", "Unknown media type", "Sector not found", "Printer out of paper", "Write Fault", \
1610 "Read fault", "General Failure" };
1611
1612 void piggy_critical_error()
1613 {
1614         grs_canvas * save_canv;
1615         grs_font * save_font;
1616         int i;
1617         save_canv = grd_curcanv;
1618         save_font = grd_curcanv->cv_font;
1619         gr_palette_load( gr_palette );
1620         i = nm_messagebox( "Disk Error", 2, "Retry", "Exit", "%s\non drive %c:", crit_errors[descent_critical_errcode&0xf], (descent_critical_deverror&0xf)+'A'  );
1621         if ( i == 1 )
1622                 exit(1);
1623         gr_set_current_canvas(save_canv);
1624         grd_curcanv->cv_font = save_font;
1625 }
1626
1627 void piggy_bitmap_page_in( bitmap_index bitmap )
1628 {
1629         grs_bitmap * bmp;
1630         int i,org_i,temp;
1631
1632         org_i = 0;
1633
1634         i = bitmap.index;
1635         Assert( i >= 0 );
1636         Assert( i < MAX_BITMAP_FILES );
1637         Assert( i < Num_bitmap_files );
1638         Assert( Piggy_bitmap_cache_size > 0 );
1639
1640         if ( i < 1 ) return;
1641         if ( i >= MAX_BITMAP_FILES ) return;
1642         if ( i >= Num_bitmap_files ) return;
1643
1644         if ( GameBitmapOffset[i] == 0 ) return;         // A read-from-disk bitmap!!!
1645
1646         if ( piggy_low_memory ) {
1647                 org_i = i;
1648                 i = GameBitmapXlat[i];          // Xlat for low-memory settings!
1649         }
1650
1651         bmp = &GameBitmaps[i];
1652
1653         if ( bmp->bm_flags & BM_FLAG_PAGED_OUT )        {
1654                 stop_time();
1655
1656         ReDoIt:
1657                 descent_critical_error = 0;
1658                 cfseek( Piggy_fp, GameBitmapOffset[i], SEEK_SET );
1659                 if ( descent_critical_error )   {
1660                         piggy_critical_error();
1661                         goto ReDoIt;
1662                 }
1663
1664                 bmp->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1665                 bmp->bm_flags = GameBitmapFlags[i];
1666
1667                 if ( bmp->bm_flags & BM_FLAG_RLE )      {
1668                         int zsize = 0;
1669                         descent_critical_error = 0;
1670                         zsize = cfile_read_int(Piggy_fp);
1671                         if ( descent_critical_error )   {
1672                                 piggy_critical_error();
1673                                 goto ReDoIt;
1674                         }
1675
1676                         // GET JOHN NOW IF YOU GET THIS ASSERT!!!
1677                         //Assert( Piggy_bitmap_cache_next+zsize < Piggy_bitmap_cache_size );
1678                         if ( Piggy_bitmap_cache_next+zsize >= Piggy_bitmap_cache_size ) {
1679                                 Int3();
1680                                 piggy_bitmap_page_out_all();
1681                                 goto ReDoIt;
1682                         }
1683                         descent_critical_error = 0;
1684                         temp = cfread( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next+4], 1, zsize-4, Piggy_fp );
1685                         if ( descent_critical_error )   {
1686                                 piggy_critical_error();
1687                                 goto ReDoIt;
1688                         }
1689
1690 #ifndef MACDATA
1691                         switch (cfilelength(Piggy_fp)) {
1692                         default:
1693                                 if (!FindArg("-macdata"))
1694                                         break;
1695                                 // otherwise, fall through...
1696                         case MAC_ALIEN1_PIGSIZE:
1697                         case MAC_ALIEN2_PIGSIZE:
1698                         case MAC_FIRE_PIGSIZE:
1699                         case MAC_GROUPA_PIGSIZE:
1700                         case MAC_ICE_PIGSIZE:
1701                         case MAC_WATER_PIGSIZE:
1702                                 rle_swap_0_255( bmp );
1703                                 memcpy(&zsize, bmp->bm_data, 4);
1704                                 break;
1705                         }
1706 #endif
1707
1708                         memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], &zsize, sizeof(int) );
1709                         Piggy_bitmap_cache_next += zsize;
1710                         if ( Piggy_bitmap_cache_next+zsize >= Piggy_bitmap_cache_size ) {
1711                                 Int3();
1712                                 piggy_bitmap_page_out_all();
1713                                 goto ReDoIt;
1714                         }
1715
1716                 } else {
1717                         // GET JOHN NOW IF YOU GET THIS ASSERT!!!
1718                         Assert( Piggy_bitmap_cache_next+(bmp->bm_h*bmp->bm_w) < Piggy_bitmap_cache_size );
1719                         if ( Piggy_bitmap_cache_next+(bmp->bm_h*bmp->bm_w) >= Piggy_bitmap_cache_size ) {
1720                                 piggy_bitmap_page_out_all();
1721                                 goto ReDoIt;
1722                         }
1723                         descent_critical_error = 0;
1724                         temp = cfread( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], 1, bmp->bm_h*bmp->bm_w, Piggy_fp );
1725                         if ( descent_critical_error )   {
1726                                 piggy_critical_error();
1727                                 goto ReDoIt;
1728                         }
1729                         Piggy_bitmap_cache_next+=bmp->bm_h*bmp->bm_w;
1730
1731 #ifndef MACDATA
1732                         switch (cfilelength(Piggy_fp)) {
1733                         default:
1734                                 if (!FindArg("-macdata"))
1735                                         break;
1736                                 // otherwise, fall through...
1737                         case MAC_ALIEN1_PIGSIZE:
1738                         case MAC_ALIEN2_PIGSIZE:
1739                         case MAC_FIRE_PIGSIZE:
1740                         case MAC_GROUPA_PIGSIZE:
1741                         case MAC_ICE_PIGSIZE:
1742                         case MAC_WATER_PIGSIZE:
1743                                 swap_0_255( bmp );
1744                                 break;
1745                         }
1746 #endif
1747                 }
1748
1749                 //@@if ( bmp->bm_selector ) {
1750                 //@@#if !defined(WINDOWS) && !defined(MACINTOSH)
1751                 //@@    if (!dpmi_modify_selector_base( bmp->bm_selector, bmp->bm_data ))
1752                 //@@            Error( "Error modifying selector base in piggy.c\n" );
1753                 //@@#endif
1754                 //@@}
1755
1756                 start_time();
1757         }
1758
1759         if ( piggy_low_memory ) {
1760                 if ( org_i != i )
1761                         GameBitmaps[org_i] = GameBitmaps[i];
1762         }
1763
1764 //@@Removed from John's code:
1765 //@@#ifndef WINDOWS
1766 //@@    if ( bmp->bm_selector ) {
1767 //@@            if (!dpmi_modify_selector_base( bmp->bm_selector, bmp->bm_data ))
1768 //@@                    Error( "Error modifying selector base in piggy.c\n" );
1769 //@@    }
1770 //@@#endif
1771
1772 }
1773
1774 void piggy_bitmap_page_out_all()
1775 {
1776         int i;
1777
1778         Piggy_bitmap_cache_next = 0;
1779
1780         piggy_page_flushed++;
1781
1782         texmerge_flush();
1783         rle_cache_flush();
1784
1785         for (i=0; i<Num_bitmap_files; i++ )             {
1786                 if ( GameBitmapOffset[i] > 0 )  {       // Don't page out bitmaps read from disk!!!
1787                         GameBitmaps[i].bm_flags = BM_FLAG_PAGED_OUT;
1788                         GameBitmaps[i].bm_data = Piggy_bitmap_cache_data;
1789                 }
1790         }
1791
1792         mprintf(( 0, "Flushing piggy bitmap cache\n" ));
1793 }
1794
1795 void piggy_load_level_data()
1796 {
1797         piggy_bitmap_page_out_all();
1798         paging_touch_all();
1799 }
1800
1801 #ifdef EDITOR
1802
1803 void change_filename_ext( char *dest, char *src, char *ext );
1804
1805 void piggy_write_pigfile(char *filename)
1806 {
1807         FILE *pig_fp;
1808         int bitmap_data_start,data_offset;
1809         DiskBitmapHeader bmh;
1810         int org_offset;
1811         char subst_name[32];
1812         int i;
1813         FILE *fp1,*fp2;
1814         char tname[FILENAME_LEN];
1815
1816         // -- mprintf( (0, "Paging in all piggy bitmaps..." ));
1817         for (i=0; i < Num_bitmap_files; i++ )   {
1818                 bitmap_index bi;
1819                 bi.index = i;
1820                 PIGGY_PAGE_IN( bi );
1821         }
1822         // -- mprintf( (0, "\n" ));
1823
1824         piggy_close_file();
1825
1826         // -- mprintf( (0, "Creating %s...",filename ));
1827
1828         pig_fp = fopen( filename, "wb" );       //open PIG file
1829         Assert( pig_fp!=NULL );
1830
1831         write_int(PIGFILE_ID,pig_fp);
1832         write_int(PIGFILE_VERSION,pig_fp);
1833
1834         Num_bitmap_files--;
1835         fwrite( &Num_bitmap_files, sizeof(int), 1, pig_fp );
1836         Num_bitmap_files++;
1837
1838         bitmap_data_start = ftell(pig_fp);
1839         bitmap_data_start += (Num_bitmap_files-1)*DISKBITMAPHEADER_SIZE;
1840         data_offset = bitmap_data_start;
1841
1842         change_filename_ext(tname,filename,"lst");
1843         fp1 = fopen( tname, "wt" );
1844         change_filename_ext(tname,filename,"all");
1845         fp2 = fopen( tname, "wt" );
1846
1847         for (i=1; i < Num_bitmap_files; i++ )   {
1848                 int *size;
1849                 grs_bitmap *bmp;
1850
1851                 {
1852                         char * p, *p1;
1853                         p = strchr(AllBitmaps[i].name,'#');
1854                         if (p)  {
1855                                 int n;
1856                                 p1 = p; p1++;
1857                                 n = atoi(p1);
1858                                 *p = 0;
1859                                 if (fp2 && n==0)
1860                                         fprintf( fp2, "%s.abm\n", AllBitmaps[i].name );
1861                                 memcpy( bmh.name, AllBitmaps[i].name, 8 );
1862                                 Assert( n <= 63 );
1863                                 bmh.dflags = DBM_FLAG_ABM + n;
1864                                 *p = '#';
1865                         }else {
1866                                 if (fp2)
1867                                         fprintf( fp2, "%s.bbm\n", AllBitmaps[i].name );
1868                                 memcpy( bmh.name, AllBitmaps[i].name, 8 );
1869                                 bmh.dflags = 0;
1870                         }
1871                 }
1872                 bmp = &GameBitmaps[i];
1873
1874                 Assert( !(bmp->bm_flags&BM_FLAG_PAGED_OUT) );
1875
1876                 if (fp1)
1877                         fprintf( fp1, "BMP: %s, size %d bytes", AllBitmaps[i].name, bmp->bm_rowsize * bmp->bm_h );
1878                 org_offset = ftell(pig_fp);
1879                 bmh.offset = data_offset - bitmap_data_start;
1880                 fseek( pig_fp, data_offset, SEEK_SET );
1881
1882                 if ( bmp->bm_flags & BM_FLAG_RLE )      {
1883                         size = (int *)bmp->bm_data;
1884                         fwrite( bmp->bm_data, sizeof(ubyte), *size, pig_fp );
1885                         data_offset += *size;
1886                         if (fp1)
1887                                 fprintf( fp1, ", and is already compressed to %d bytes.\n", *size );
1888                 } else {
1889                         fwrite( bmp->bm_data, sizeof(ubyte), bmp->bm_rowsize * bmp->bm_h, pig_fp );
1890                         data_offset += bmp->bm_rowsize * bmp->bm_h;
1891                         if (fp1)
1892                                 fprintf( fp1, ".\n" );
1893                 }
1894                 fseek( pig_fp, org_offset, SEEK_SET );
1895                 Assert( GameBitmaps[i].bm_w < 4096 );
1896                 bmh.width = (GameBitmaps[i].bm_w & 0xff);
1897                 bmh.wh_extra = ((GameBitmaps[i].bm_w >> 8) & 0x0f);
1898                 Assert( GameBitmaps[i].bm_h < 4096 );
1899                 bmh.height = GameBitmaps[i].bm_h;
1900                 bmh.wh_extra |= ((GameBitmaps[i].bm_h >> 4) & 0xf0);
1901                 bmh.flags = GameBitmaps[i].bm_flags;
1902                 if (piggy_is_substitutable_bitmap( AllBitmaps[i].name, subst_name ))    {
1903                         bitmap_index other_bitmap;
1904                         other_bitmap = piggy_find_bitmap( subst_name );
1905                         GameBitmapXlat[i] = other_bitmap.index;
1906                         bmh.flags |= BM_FLAG_PAGED_OUT;
1907                         //mprintf(( 0, "Skipping bitmap %d\n", i ));
1908                         //mprintf(( 0, "Marking '%s' as substitutible\n", AllBitmaps[i].name ));
1909                 } else  {
1910                         bmh.flags &= ~BM_FLAG_PAGED_OUT;
1911                 }
1912                 bmh.avg_color=GameBitmaps[i].avg_color;
1913                 fwrite( &bmh, DISKBITMAPHEADER_SIZE, 1, pig_fp );                    // Mark as a bitmap
1914         }
1915
1916         fclose(pig_fp);
1917
1918         mprintf( (0, " Dumped %d assorted bitmaps.\n", Num_bitmap_files ));
1919         fprintf( fp1, " Dumped %d assorted bitmaps.\n", Num_bitmap_files );
1920
1921         fclose(fp1);
1922         fclose(fp2);
1923
1924 }
1925
1926 static void write_int(int i,FILE *file)
1927 {
1928         if (fwrite( &i, sizeof(i), 1, file) != 1)
1929                 Error( "Error reading int in gamesave.c" );
1930
1931 }
1932
1933 void piggy_dump_all()
1934 {
1935         int i, xlat_offset;
1936         FILE * ham_fp;
1937         int org_offset,data_offset=0;
1938         DiskSoundHeader sndh;
1939         int sound_data_start=0;
1940         FILE *fp1,*fp2;
1941
1942         #ifdef NO_DUMP_SOUNDS
1943         Num_sound_files = 0;
1944         Num_sound_files_new = 0;
1945         #endif
1946
1947         if (!Must_write_hamfile && (Num_bitmap_files_new == 0) && (Num_sound_files_new == 0) )
1948                 return;
1949
1950         fp1 = fopen( "ham.lst", "wt" );
1951         fp2 = fopen( "ham.all", "wt" );
1952
1953         if (Must_write_hamfile || Num_bitmap_files_new) {
1954
1955                 mprintf( (0, "Creating %s...",DEFAULT_HAMFILE));
1956
1957                 ham_fp = fopen( DEFAULT_HAMFILE, "wb" );                       //open HAM file
1958                 Assert( ham_fp!=NULL );
1959
1960                 write_int(HAMFILE_ID,ham_fp);
1961                 write_int(HAMFILE_VERSION,ham_fp);
1962
1963                 bm_write_all(ham_fp);
1964                 xlat_offset = ftell(ham_fp);
1965                 fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1966                 //Dump bitmaps
1967
1968                 if (Num_bitmap_files_new)
1969                         piggy_write_pigfile(DEFAULT_PIGFILE);
1970
1971                 //free up memeory used by new bitmaps
1972                 for (i=Num_bitmap_files-Num_bitmap_files_new;i<Num_bitmap_files;i++)
1973                         d_free(GameBitmaps[i].bm_data);
1974
1975                 //next thing must be done after pig written
1976                 fseek( ham_fp, xlat_offset, SEEK_SET );
1977                 fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1978
1979                 fclose(ham_fp);
1980                 mprintf( (0, "\n" ));
1981         }
1982
1983         if (Num_sound_files_new) {
1984
1985                 mprintf( (0, "Creating %s...",DEFAULT_HAMFILE));
1986                 // Now dump sound file
1987                 ham_fp = fopen( DEFAULT_SNDFILE, "wb" );
1988                 Assert( ham_fp!=NULL );
1989
1990                 write_int(SNDFILE_ID,ham_fp);
1991                 write_int(SNDFILE_VERSION,ham_fp);
1992
1993                 fwrite( &Num_sound_files, sizeof(int), 1, ham_fp );
1994
1995                 mprintf( (0, "\nDumping sounds..." ));
1996
1997                 sound_data_start = ftell(ham_fp);
1998                 sound_data_start += Num_sound_files*sizeof(DiskSoundHeader);
1999                 data_offset = sound_data_start;
2000
2001                 for (i=0; i < Num_sound_files; i++ )    {
2002                         digi_sound *snd;
2003
2004                         snd = &GameSounds[i];
2005                         strcpy( sndh.name, AllSounds[i].name );
2006                         sndh.length = GameSounds[i].length;
2007                         sndh.offset = data_offset - sound_data_start;
2008
2009                         org_offset = ftell(ham_fp);
2010                         fseek( ham_fp, data_offset, SEEK_SET );
2011
2012                         sndh.data_length = GameSounds[i].length;
2013                         fwrite( snd->data, sizeof(ubyte), snd->length, ham_fp );
2014                         data_offset += snd->length;
2015                         fseek( ham_fp, org_offset, SEEK_SET );
2016                         fwrite( &sndh, sizeof(DiskSoundHeader), 1, ham_fp );                    // Mark as a bitmap
2017
2018                         fprintf( fp1, "SND: %s, size %d bytes\n", AllSounds[i].name, snd->length );
2019                         fprintf( fp2, "%s.raw\n", AllSounds[i].name );
2020                 }
2021
2022                 fclose(ham_fp);
2023                 mprintf( (0, "\n" ));
2024         }
2025
2026         fprintf( fp1, "Total sound size: %d bytes\n", data_offset-sound_data_start);
2027         mprintf( (0, " Dumped %d assorted sounds.\n", Num_sound_files ));
2028         fprintf( fp1, " Dumped %d assorted sounds.\n", Num_sound_files );
2029
2030         fclose(fp1);
2031         fclose(fp2);
2032
2033         // Never allow the game to run after building ham.
2034         exit(0);
2035 }
2036
2037 #endif
2038
2039 void piggy_close()
2040 {
2041         piggy_close_file();
2042
2043         if (BitmapBits)
2044                 d_free(BitmapBits);
2045
2046         if ( SoundBits )
2047                 d_free( SoundBits );
2048
2049         hashtable_free( &AllBitmapsNames );
2050         hashtable_free( &AllDigiSndNames );
2051
2052 }
2053
2054 int piggy_does_bitmap_exist_slow( char * name )
2055 {
2056         int i;
2057
2058         for (i=0; i<Num_bitmap_files; i++ )     {
2059                 if ( !strcmp( AllBitmaps[i].name, name) )
2060                         return 1;
2061         }
2062         return 0;
2063 }
2064
2065
2066 #define NUM_GAUGE_BITMAPS 23
2067 char * gauge_bitmap_names[NUM_GAUGE_BITMAPS] = {
2068         "gauge01", "gauge01b",
2069         "gauge02", "gauge02b",
2070         "gauge06", "gauge06b",
2071         "targ01", "targ01b",
2072         "targ02", "targ02b",
2073         "targ03", "targ03b",
2074         "targ04", "targ04b",
2075         "targ05", "targ05b",
2076         "targ06", "targ06b",
2077         "gauge18", "gauge18b",
2078         "gauss1", "helix1",
2079         "phoenix1"
2080 };
2081
2082
2083 int piggy_is_gauge_bitmap( char * base_name )
2084 {
2085         int i;
2086         for (i=0; i<NUM_GAUGE_BITMAPS; i++ )    {
2087                 if ( !stricmp( base_name, gauge_bitmap_names[i] ))
2088                         return 1;
2089         }
2090
2091         return 0;
2092 }
2093
2094 int piggy_is_substitutable_bitmap( char * name, char * subst_name )
2095 {
2096         int frame;
2097         char * p;
2098         char base_name[ 16 ];
2099
2100         strcpy( subst_name, name );
2101         p = strchr( subst_name, '#' );
2102         if ( p )        {
2103                 frame = atoi( &p[1] );
2104                 *p = 0;
2105                 strcpy( base_name, subst_name );
2106                 if ( !piggy_is_gauge_bitmap( base_name ))       {
2107                         sprintf( subst_name, "%s#%d", base_name, frame+1 );
2108                         if ( piggy_does_bitmap_exist_slow( subst_name )  )      {
2109                                 if ( frame & 1 ) {
2110                                         sprintf( subst_name, "%s#%d", base_name, frame-1 );
2111                                         return 1;
2112                                 }
2113                         }
2114                 }
2115         }
2116         strcpy( subst_name, name );
2117         return 0;
2118 }
2119
2120
2121
2122 #ifdef WINDOWS
2123 //      New Windows stuff
2124
2125 //      windows bitmap page in
2126 //              Page in a bitmap, if ddraw, then page it into a ddsurface in
2127 //              'video' memory.  if that fails, page it in normally.
2128
2129 void piggy_bitmap_page_in_w( bitmap_index bitmap, int ddraw )
2130 {
2131 }
2132
2133
2134 //      Essential when switching video modes!
2135
2136 void piggy_bitmap_page_out_all_w()
2137 {
2138 }
2139
2140 #endif // WINDOWS
2141
2142
2143 /*
2144  * Functions for loading replacement textures
2145  *  1) From .pog files
2146  *  2) From descent.pig (for loading d1 levels)
2147  */
2148
2149 extern void change_filename_extension( char *dest, char *src, char *new_ext );
2150 extern char last_palette_loaded_pig[];
2151
2152 ubyte *Bitmap_replacement_data=NULL;
2153
2154 void free_bitmap_replacements()
2155 {
2156         if (Bitmap_replacement_data) {
2157                 d_free(Bitmap_replacement_data);
2158                 Bitmap_replacement_data = NULL;
2159         }
2160 }
2161
2162 void load_bitmap_replacements(char *level_name)
2163 {
2164         char ifile_name[FILENAME_LEN];
2165         CFILE *ifile;
2166         int i;
2167
2168         //first, free up data allocated for old bitmaps
2169         free_bitmap_replacements();
2170
2171         change_filename_extension(ifile_name, level_name, ".POG" );
2172
2173         ifile = cfopen(ifile_name,"rb");
2174
2175         if (ifile) {
2176                 int id,version,n_bitmaps;
2177                 int bitmap_data_size;
2178                 ushort *indices;
2179
2180                 id = cfile_read_int(ifile);
2181                 version = cfile_read_int(ifile);
2182
2183                 if (id != MAKE_SIG('G','O','P','D') || version != 1) {
2184                         cfclose(ifile);
2185                         return;
2186                 }
2187
2188                 n_bitmaps = cfile_read_int(ifile);
2189
2190                 MALLOC( indices, ushort, n_bitmaps );
2191
2192                 for (i = 0; i < n_bitmaps; i++)
2193                         indices[i] = cfile_read_short(ifile);
2194
2195                 bitmap_data_size = cfilelength(ifile) - cftell(ifile) - DISKBITMAPHEADER_SIZE * n_bitmaps;
2196                 MALLOC( Bitmap_replacement_data, ubyte, bitmap_data_size );
2197
2198                 for (i=0;i<n_bitmaps;i++) {
2199                         DiskBitmapHeader bmh;
2200                         grs_bitmap temp_bitmap;
2201
2202                         DiskBitmapHeader_read(&bmh, ifile);
2203
2204                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
2205
2206                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
2207                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
2208                         temp_bitmap.avg_color = bmh.avg_color;
2209                         temp_bitmap.bm_data = Bitmap_replacement_data + bmh.offset;
2210
2211                         temp_bitmap.bm_flags |= bmh.flags & BM_FLAGS_TO_COPY;
2212
2213                         GameBitmaps[indices[i]] = temp_bitmap;
2214                 }
2215
2216                 cfread(Bitmap_replacement_data,1,bitmap_data_size,ifile);
2217
2218                 d_free(indices);
2219
2220                 cfclose(ifile);
2221
2222                 last_palette_loaded_pig[0]= 0;  //force pig re-load
2223
2224                 texmerge_flush();       //for re-merging with new textures
2225         }
2226
2227         atexit(free_bitmap_replacements);
2228 }
2229
2230 #define FIRST_D1_TEXTURE 722
2231 #define LAST_D1_STATIC_TEXTURE 1042//1342 //afterwards, we have door frames and stuff
2232 #define FIRST_D2_TEXTURE 1243
2233
2234 void load_d1_bitmap_replacements()
2235 {
2236         CFILE * d1_Piggy_fp;
2237         grs_bitmap temp_bitmap;
2238         DiskBitmapHeader bmh;
2239         int pig_data_start, bitmap_header_start, bitmap_data_start;
2240         int N_bitmaps, zsize;
2241         int d1_index, d2_index;
2242         ubyte colormap[256];
2243         ubyte *next_bitmap; // to which address we write the next bitmap
2244
2245         d1_Piggy_fp = cfopen( D1_PIGFILE, "rb" );
2246
2247         if (!d1_Piggy_fp)
2248                 return; // use d2 bitmaps instead...
2249
2250         //first, free up data allocated for old bitmaps
2251         free_bitmap_replacements();
2252
2253         // read d1 palette, build colormap
2254         {
2255                 int freq[256];
2256                 ubyte d1_palette[256*3];
2257                 CFILE * palette_file = cfopen(D1_PALETTE, "rb" );
2258                 Assert( palette_file );
2259                 Assert( cfilelength( palette_file ) == 9472 );
2260                 cfread( d1_palette, 256, 3, palette_file);
2261                 cfclose( palette_file );
2262                 build_colormap_good( d1_palette, colormap, freq );
2263                 // don't change transparencies:
2264                 colormap[254] = 254;
2265                 colormap[255] = 255;
2266         }
2267
2268         switch (cfilelength(d1_Piggy_fp)) {
2269         case D1_SHAREWARE_10_PIGSIZE:
2270         case D1_SHAREWARE_PIGSIZE:
2271                 pig_data_start = 0;
2272                 break;
2273         default:
2274                 Int3();
2275         case D1_PIGSIZE:
2276         case D1_OEM_PIGSIZE:
2277         case D1_MAC_PIGSIZE:
2278         case D1_MAC_SHARE_PIGSIZE:
2279                 //int i;
2280                 pig_data_start = cfile_read_int(d1_Piggy_fp );
2281                 bm_read_all_d1( d1_Piggy_fp );
2282                 //for (i = 0; i < 1800; i++) GameBitmapXlat[i] = cfile_read_short(d1_Piggy_fp);
2283                 break;
2284         }
2285
2286         cfseek( d1_Piggy_fp, pig_data_start, SEEK_SET );
2287         N_bitmaps = cfile_read_int(d1_Piggy_fp);
2288         {
2289                 int N_sounds = cfile_read_int(d1_Piggy_fp);
2290                 int header_size = N_bitmaps * DISKBITMAPHEADER_D1_SIZE
2291                         + N_sounds * DISKSOUNDHEADER_SIZE;
2292                 bitmap_header_start = pig_data_start + 2 * sizeof(int);
2293                 bitmap_data_start = bitmap_header_start + header_size;
2294         }
2295
2296         MALLOC( Bitmap_replacement_data, ubyte, cfilelength(d1_Piggy_fp) - bitmap_data_start ); // too much
2297         //TODO: handle case where b_r_d == 0! (have to convert textures, return, not bm_read_all_d1)
2298
2299         next_bitmap = Bitmap_replacement_data;
2300
2301         for (d1_index=1; d1_index<=N_bitmaps; d1_index++ ) {
2302                 // only change wall texture bitmaps
2303                 if (d1_index >= FIRST_D1_TEXTURE && d1_index <= LAST_D1_STATIC_TEXTURE) {
2304                         d2_index = d1_index + FIRST_D2_TEXTURE - FIRST_D1_TEXTURE;
2305
2306                         cfseek(d1_Piggy_fp, bitmap_header_start + (d1_index-1) * DISKBITMAPHEADER_D1_SIZE, SEEK_SET);
2307                         DiskBitmapHeader_d1_read(&bmh, d1_Piggy_fp);
2308
2309                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
2310
2311                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
2312                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
2313                         temp_bitmap.avg_color = bmh.avg_color;
2314
2315                         //GameBitmapFlags[convert_d1_bitmap_num(d1_index)] = 0;
2316
2317                         temp_bitmap.bm_flags |= bmh.flags & BM_FLAGS_TO_COPY;
2318
2319                         temp_bitmap.bm_data = next_bitmap;
2320
2321                         cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2322                         zsize = cfile_read_int(d1_Piggy_fp);
2323                         cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2324                         cfread(next_bitmap, 1, zsize, d1_Piggy_fp);
2325
2326                         switch(cfilelength(d1_Piggy_fp)) {
2327                         case D1_MAC_PIGSIZE:
2328                         case D1_MAC_SHARE_PIGSIZE:
2329                                 rle_swap_0_255(&temp_bitmap);
2330                         }
2331                         rle_remap(&temp_bitmap, colormap);
2332
2333                         GameBitmaps[d2_index] = temp_bitmap;
2334
2335                         memcpy(&zsize, temp_bitmap.bm_data, 4);
2336                         next_bitmap += zsize;
2337                 }
2338         }
2339
2340         cfclose(d1_Piggy_fp);
2341
2342         last_palette_loaded_pig[0]= 0;  //force pig re-load
2343
2344         texmerge_flush();       //for re-merging with new textures
2345
2346         atexit(free_bitmap_replacements);
2347 }
2348
2349
2350 extern int extra_bitmap_num;
2351
2352 /*
2353  * Find and load the named bitmap from descent.pig
2354  * similar to read_extra_bitmap_iff
2355  */
2356 bitmap_index read_extra_bitmap_d1_pig(char *name)
2357 {
2358         bitmap_index bitmap_num;
2359         grs_bitmap * new = &GameBitmaps[extra_bitmap_num];
2360
2361         bitmap_num.index = 0;
2362
2363         {
2364                 CFILE *d1_Piggy_fp;
2365                 int i;
2366                 DiskBitmapHeader bmh;
2367                 int pig_data_start, bitmap_header_start, bitmap_data_start;
2368                 int N_bitmaps, zsize;
2369                 ubyte colormap[256];
2370
2371                 d1_Piggy_fp = cfopen(D1_PIGFILE, "rb");
2372                 if (!d1_Piggy_fp)
2373                 {
2374                         con_printf(CON_DEBUG, "could not open %s\n", D1_PIGFILE);
2375                         return bitmap_num;
2376                 }
2377
2378                 // read d1 palette, build colormap
2379                 {
2380                         int freq[256];
2381                         ubyte d1_palette[256*3];
2382                         CFILE * palette_file = cfopen(D1_PALETTE, "rb");
2383                         if (!palette_file || cfilelength(palette_file) != 9472)
2384                         {
2385                                 con_printf(CON_DEBUG, "could not open %s\n", D1_PALETTE);
2386                                 return bitmap_num;
2387                         }
2388                         cfread( d1_palette, 256, 3, palette_file);
2389                         cfclose( palette_file );
2390                         build_colormap_good( d1_palette, colormap, freq );
2391                         // don't change transparencies:
2392                         colormap[254] = 254;
2393                         colormap[255] = 255;
2394                 }
2395
2396                 switch (cfilelength(d1_Piggy_fp)) {
2397                 case D1_SHAREWARE_10_PIGSIZE:
2398                 case D1_SHAREWARE_PIGSIZE:
2399                         pig_data_start = 0;
2400                         break;
2401                 default:
2402                         Int3();
2403                 case D1_PIGSIZE:
2404                 case D1_OEM_PIGSIZE:
2405                 case D1_MAC_PIGSIZE:
2406                 case D1_MAC_SHARE_PIGSIZE:
2407                         pig_data_start = cfile_read_int(d1_Piggy_fp);
2408                         break;
2409                 }
2410
2411                 cfseek(d1_Piggy_fp, pig_data_start, SEEK_SET);
2412                 N_bitmaps = cfile_read_int(d1_Piggy_fp);
2413                 {
2414                         int N_sounds = cfile_read_int(d1_Piggy_fp);
2415                         int header_size = N_bitmaps * DISKBITMAPHEADER_D1_SIZE
2416                                 + N_sounds * DISKSOUNDHEADER_SIZE;
2417                         bitmap_header_start = pig_data_start + 2 * sizeof(int);
2418                         bitmap_data_start = bitmap_header_start + header_size;
2419                 }
2420
2421                 for (i = 0; i < N_bitmaps; i++)
2422                 {
2423                         DiskBitmapHeader_d1_read(&bmh, d1_Piggy_fp);
2424                         if (!strnicmp(bmh.name, name, 8))
2425                                 break;
2426                 }
2427
2428                 if (strnicmp(bmh.name, name, 8))
2429                 {
2430                         con_printf(CON_DEBUG, "could not find bitmap %s\n", name);
2431                         return bitmap_num;
2432                 }
2433
2434                 memset( new, 0, sizeof(grs_bitmap) );
2435
2436                 new->bm_w = new->bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
2437                 new->bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
2438                 new->avg_color = bmh.avg_color;
2439
2440                 new->bm_flags |= bmh.flags & BM_FLAGS_TO_COPY;
2441
2442                 if ( bmh.flags & BM_FLAG_RLE )
2443                 {
2444                         cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2445                         zsize = cfile_read_int(d1_Piggy_fp);
2446                 }
2447                 else
2448                         zsize = new->bm_w * new->bm_h;
2449                 new->bm_data = d_malloc(zsize);
2450                 cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2451                 cfread(new->bm_data, 1, zsize, d1_Piggy_fp);
2452
2453                 switch(cfilelength(d1_Piggy_fp)) {
2454                 case D1_MAC_PIGSIZE:
2455                 case D1_MAC_SHARE_PIGSIZE:
2456                         rle_swap_0_255(new);
2457                 }
2458                 rle_remap(new, colormap);
2459
2460                 cfclose(d1_Piggy_fp);
2461         }
2462
2463         new->avg_color = 0;     //compute_average_pixel(new);
2464
2465         bitmap_num.index = extra_bitmap_num;
2466
2467         GameBitmaps[extra_bitmap_num++] = *new;
2468
2469         return bitmap_num;
2470 }
2471
2472
2473 #ifndef FAST_FILE_IO
2474 /*
2475  * reads a bitmap_index structure from a CFILE
2476  */
2477 void bitmap_index_read(bitmap_index *bi, CFILE *fp)
2478 {
2479         bi->index = cfile_read_short(fp);
2480 }
2481
2482 /*
2483  * reads n bitmap_index structs from a CFILE
2484  */
2485 int bitmap_index_read_n(bitmap_index *bi, int n, CFILE *fp)
2486 {
2487         int i;
2488
2489         for (i = 0; i < n; i++)
2490                 bi[i].index = cfile_read_short(fp);
2491         return i;
2492 }
2493
2494 /*
2495  * reads a DiskBitmapHeader structure from a CFILE
2496  */
2497 void DiskBitmapHeader_read(DiskBitmapHeader *dbh, CFILE *fp)
2498 {
2499         cfread(dbh->name, 8, 1, fp);
2500         dbh->dflags = cfile_read_byte(fp);
2501         dbh->width = cfile_read_byte(fp);
2502         dbh->height = cfile_read_byte(fp);
2503         dbh->wh_extra = cfile_read_byte(fp);
2504         dbh->flags = cfile_read_byte(fp);
2505         dbh->avg_color = cfile_read_byte(fp);
2506         dbh->offset = cfile_read_int(fp);
2507 }
2508
2509 /*
2510  * reads a DiskSoundHeader structure from a CFILE
2511  */
2512 void DiskSoundHeader_read(DiskSoundHeader *dsh, CFILE *fp)
2513 {
2514         cfread(dsh->name, 8, 1, fp);
2515         dsh->length = cfile_read_int(fp);
2516         dsh->data_length = cfile_read_int(fp);
2517         dsh->offset = cfile_read_int(fp);
2518 }
2519 #endif // FAST_FILE_IO
2520
2521 /*
2522  * reads a descent 1 DiskBitmapHeader structure from a CFILE
2523  */
2524 void DiskBitmapHeader_d1_read(DiskBitmapHeader *dbh, CFILE *fp)
2525 {
2526         cfread(dbh->name, 8, 1, fp);
2527         dbh->dflags = cfile_read_byte(fp);
2528         dbh->width = cfile_read_byte(fp);
2529         dbh->height = cfile_read_byte(fp);
2530         dbh->wh_extra = 0;
2531         dbh->flags = cfile_read_byte(fp);
2532         dbh->avg_color = cfile_read_byte(fp);
2533         dbh->offset = cfile_read_int(fp);
2534 }