bmpman.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell
 * or otherwise commercially exploit the source or things you created based on the
 * source.
 *
*/
#ifndef NDEBUG
#define BMPMAN_NDEBUG
#endif

#define BMPMAN_INTERNAL

#ifdef _WIN32
#include <windows.h>
#endif

#include "anim/animplay.h"
#include "anim/packunpack.h"
#include "bmpman/bm_internal.h"
#include "bmpman/bmpman.h"
#include "ddsutils/ddsutils.h"
#include "debugconsole/console.h"
#include "globalincs/systemvars.h"
#include "graphics/2d.h"
#include "graphics/grinternal.h"
#include "io/key.h"
#include "io/timer.h"
#include "jpgutils/jpgutils.h"
#include "network/multiutil.h"
#include "palman/palman.h"
#include "parse/parselo.h"
#include "pcxutils/pcxutils.h"
#include "pngutils/pngutils.h"
#include "ship/ship.h"
#include "tgautils/tgautils.h"

#include <ctype.h>
#include <limits.h>
#include <iomanip>

// --------------------------------------------------------------------------------------------------------------------
// Private macros.

#define EFF_FILENAME_CHECK { if ( be->type == BM_TYPE_EFF ) strcpy_s( filename, be->info.ani.eff.filename ); else strcpy_s( filename, be->filename ); }
// --------------------------------------------------------------------------------------------------------------------
// Monitor variables
MONITOR(NumBitmapPage)
MONITOR(SizeBitmapPage)

// --------------------------------------------------------------------------------------------------------------------
// Definition of public variables (declared as extern in bmpman.h).
int GLOWMAP = -1;
int SPECMAP = -1;
int ENVMAP  = -1;
int NORMMAP = -1;
int HEIGHTMAP = -1;
int MISCMAP = -1;

int bm_texture_ram = 0;
int Bm_paging = 0;

// Extension type lists
const BM_TYPE bm_type_list[] = { BM_TYPE_DDS, BM_TYPE_TGA, BM_TYPE_PNG, BM_TYPE_JPG, BM_TYPE_PCX };
const char *bm_ext_list[] = { ".dds", ".tga", ".png", ".jpg", ".pcx" };
const int BM_NUM_TYPES = sizeof(bm_type_list) / sizeof(bm_type_list[0]);

const BM_TYPE bm_ani_type_list[] = { BM_TYPE_EFF, BM_TYPE_ANI };
const char *bm_ani_ext_list[] = { ".eff", ".ani" };
const int BM_ANI_NUM_TYPES = sizeof(bm_ani_type_list) / sizeof(bm_ani_type_list[0]);

void(*bm_set_components)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a) = NULL;
void(*bm_set_components_32)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a) = NULL;

// --------------------------------------------------------------------------------------------------------------------
// Declaration of protected variables (defined in cmdline.cpp).
extern int Cmdline_cache_bitmaps;

// --------------------------------------------------------------------------------------------------------------------
// Definition of public variables (declared as extern in bm_internal.h).
bitmap_entry bm_bitmaps[MAX_BITMAPS];

// --------------------------------------------------------------------------------------------------------------------
// Definition of private variables at file scope (static).
static int bm_inited = 0;
static uint Bm_next_signature = 0x1234;
static int  bm_next_handle = 1;
static int Bm_low_mem = 0;

static int Bm_max_ram = 0;

static int Bm_ignore_duplicates = 0;
static int Bm_ignore_load_count = 0;

// --------------------------------------------------------------------------------------------------------------------
// Declaration of private functions and templates(declared as static type func(type param);)

bitmap_lookup::bitmap_lookup(int bitmap_num):
        Bitmap_data(NULL)
{
        if ( !bm_is_valid(bitmap_num) ) return;

        Num_channels = 3;

        if ( bm_has_alpha_channel(bitmap_num) ) {
                Num_channels = 4;
        }

        int n = bitmap_num % MAX_BITMAPS;

        bitmap_entry *be = &bm_bitmaps[n];
        
        Width = be->bm.w;
        Height = be->bm.h;

        Bitmap_data = (ubyte*)vm_malloc(Width * Height * Num_channels * sizeof(ubyte));

        gr_get_bitmap_from_texture((void*)Bitmap_data, bitmap_num);
}

bitmap_lookup::~bitmap_lookup()
{
        if ( Bitmap_data != NULL ) {
                vm_free(Bitmap_data);
        }
}

bool bitmap_lookup::valid()
{
        return Bitmap_data != NULL;
}

float bitmap_lookup::map_texture_address(float address)
{
        // assume we're just wrapping
        return address - floorf(address);
}

float bitmap_lookup::get_channel_red(float u, float v)
{
        Assert( Bitmap_data != NULL );

        CLAMP(u, 0.0, 1.0f);
        CLAMP(v, 0.0, 1.0f);

        int x = fl2i(map_texture_address(u) * (Width-1));
        int y = fl2i(map_texture_address(v) * (Height-1));

        return i2fl(Bitmap_data[(y*Width + x)*Num_channels]) / 255.0f;
}

float bitmap_lookup::get_channel_green(float u, float v)
{
        Assert( Bitmap_data != NULL );

        CLAMP(u, 0.0, 1.0f);
        CLAMP(v, 0.0, 1.0f);

        int x = fl2i(map_texture_address(u) * (Width-1));
        int y = fl2i(map_texture_address(v) * (Height-1));

        return i2fl(Bitmap_data[(y*Width + x)*Num_channels + 1]) / 255.0f;
}

float bitmap_lookup::get_channel_blue(float u, float v)
{
        Assert( Bitmap_data != NULL );

        int x = fl2i(map_texture_address(u) * (Width-1));
        int y = fl2i(map_texture_address(v) * (Height-1));

        return i2fl(Bitmap_data[(y*Width + x)*Num_channels + 2]) / 255.0f;
}

float bitmap_lookup::get_channel_alpha(float u, float v)
{
        Assert( Bitmap_data != NULL );

        int x = fl2i(map_texture_address(u) * (Width-1));
        int y = fl2i(map_texture_address(v) * (Height-1));

        return i2fl(Bitmap_data[(y*Width + x)*Num_channels + 3]) / 255.0f;
}

static void bm_convert_format(bitmap *bmp, ubyte flags);

static void bm_free_data(int n, bool release = false);

static void bm_free_data_fast(int n);

static int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **ext_list, CFILE **img_cfp = NULL, int dir_type = CF_TYPE_ANY);

static int bm_load_sub_fast(const char *real_filename, int *handle, int dir_type = CF_TYPE_ANY, bool animated_type = false);

static int find_block_of(int n);

// --------------------------------------------------------------------------------------------------------------------
// Macro-defined functions

DCF(bm_frag, "Shows BmpMan fragmentation") {
        if (dc_optional_string_either("help", "--help")) {
                dc_printf("Displays a graphic showing the BmpMan fragmentation. Color key:\n");
                dc_printf("\tGray  : NONE\n");
                dc_printf("\tRed   : PCXn");
                dc_printf("\tGreen : USER, TGA, PNG, DDS, other\n");
                dc_printf("\tBlue  : ANI, EFF\n\n");

                dc_printf("Once done reviewing the graphic, press any key to return to the console\n");
                return;
        }

        gr_clear();

        int x = 0, y = 0;
        int xs = 2, ys = 2;
        int w = 4, h = 4;

        for (int i = 0; i<MAX_BITMAPS; i++) {
                switch (bm_bitmaps[i].type) {
                case BM_TYPE_NONE:
                        gr_set_color(128, 128, 128);
                        break;
                case BM_TYPE_PCX:
                        gr_set_color(255, 0, 0);
                        break;
                case BM_TYPE_USER:
                case BM_TYPE_TGA:
                case BM_TYPE_PNG:
                case BM_TYPE_DDS:
                        gr_set_color(0, 255, 0);
                        break;
                case BM_TYPE_ANI:
                case BM_TYPE_EFF:
                        gr_set_color(0, 0, 255);
                        break;
                default:
                        gr_set_color(0, 255, 0);
                        break;
                }

                gr_rect(x + xs, y + ys, w, h);
                x += w + xs + xs;
                if (x > 639) {
                        x = 0;
                        y += h + ys + ys;
                }
        }

        gr_flip();
        key_getch();
}

DCF(bm_used, "Shows BmpMan Slot Usage") {
        if (dc_optional_string_either("help", "--help")) {
                dc_printf("Displays used bmpman slots usage with a breakdown per filetype\n\n");
                return;
        }

        int none = 0, pcx = 0, user = 0, tga = 0, png = 0; int jpg = 0, dds = 0, ani = 0;
        int eff = 0, eff_dds = 0, eff_tga = 0, eff_png = 0, eff_jpg = 0, eff_pcx = 0;
        int render_target_dynamic = 0, render_target_static = 0;

        for (int i = 0; i<MAX_BITMAPS; i++) {
                switch (bm_bitmaps[i].type) {
                case BM_TYPE_NONE:
                        none++;
                        break;
                case BM_TYPE_PCX:
                        pcx++;
                        break;
                case BM_TYPE_USER:
                        user++;
                        break;
                case BM_TYPE_TGA:
                        tga++;
                        break;
                case BM_TYPE_PNG:
                        // TODO distinguish png(static) from apng
                        png++;
                        break;
                case BM_TYPE_JPG:
                        jpg++;
                        break;
                case BM_TYPE_DDS:
                        dds++;
                        break;
                case BM_TYPE_ANI:
                        ani++;
                        break;
                case BM_TYPE_EFF:
                        eff++;
                        switch (bm_bitmaps[i].info.ani.eff.type) {
                        case BM_TYPE_DDS:
                                eff_dds++;
                                break;
                        case BM_TYPE_TGA:
                                eff_tga++;
                                break;
                        case BM_TYPE_PNG:
                                eff_png++;
                                break;
                        case BM_TYPE_JPG:
                                eff_jpg++;
                                break;
                        case BM_TYPE_PCX:
                                eff_pcx++;
                                break;
                        default:
                                Warning(LOCATION, "Unhandled EFF image type (%i), get a coder!", bm_bitmaps[i].info.ani.eff.type);
                                break;
                        }
                        break;
                case BM_TYPE_RENDER_TARGET_STATIC:
                        render_target_static++;
                        break;
                case BM_TYPE_RENDER_TARGET_DYNAMIC:
                        render_target_dynamic++;
                        break;
                default:
                        Warning(LOCATION, "Unhandled image type (%i), get a coder!", bm_bitmaps[i].type);
                        break;
                }
        }

        SCP_stringstream text;
        text << "BmpMan Used Slots\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << pcx  << ", PCX\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << user << ", User\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << tga  << ", TGA\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << png  << ", PNG\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << jpg  << ", JPG\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << dds  << ", DDS\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << ani  << ", ANI\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << eff  << ", EFF\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << eff_dds  << ", EFF/DDS\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << eff_tga  << ", EFF/TGA\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << eff_png  << ", EFF/PNG\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << eff_jpg  << ", EFF/JPG\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << eff_pcx  << ", EFF/PCX\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << render_target_static  << ", Render/Static\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << render_target_dynamic  << ", Render/Dynamic\n";
        text << "  " << std::dec << std::setw(4) << std::setfill('0') << MAX_BITMAPS-none << "/" << MAX_BITMAPS  << ", Total\n";
        text << "\n";

        // TODO consider converting 1's to monospace to make debug console output prettier
        mprintf(("%s", text.str().c_str())); // log for ease for copying data
        dc_printf("%s", text.str().c_str()); // instant gratification
}


DCF(bmpman, "Shows/changes bitmap caching parameters and usage") {
        if (dc_optional_string_either("help", "--help")) {
                dc_printf("Usage: BmpMan [arg]\nWhere arg can be any of the following:\n");
                dc_printf("\tflush    Unloads all bitmaps.\n");
                dc_printf("\tram [x]  Sets max mem usage to x MB. (Set to 0 to have no limit.)\n");
                dc_printf("\t?        Displays status of Bitmap manager.\n");
                return;
        }

        if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?")) {
                dc_printf("Total RAM usage: %d bytes\n", bm_texture_ram);

                if (Bm_max_ram > 1024 * 1024) {
                        dc_printf("\tMax RAM allowed: %.1f MB\n", i2fl(Bm_max_ram) / (1024.0f*1024.0f));
                } else if (Bm_max_ram > 1024) {
                        dc_printf("\tMax RAM allowed: %.1f KB\n", i2fl(Bm_max_ram) / (1024.0f));
                } else if (Bm_max_ram > 0) {
                        dc_printf("\tMax RAM allowed: %d bytes\n", Bm_max_ram);
                } else {
                        dc_printf("\tNo RAM limit\n");
                }
                return;
        }


        if (dc_optional_string("flush")) {
                dc_printf("Total RAM usage before flush: %d bytes\n", bm_texture_ram);
                int i;
                for (i = 0; i < MAX_BITMAPS; i++) {
                        if (bm_bitmaps[i].type != BM_TYPE_NONE) {
                                bm_free_data(i);
                        }
                }
                dc_printf("Total RAM after flush: %d bytes\n", bm_texture_ram);
        } else if (dc_optional_string("ram")) {
                dc_stuff_int(&Bm_max_ram);

                if (Bm_max_ram > 0) {
                        dc_printf("BmpMan limited to %i, MB's\n", Bm_max_ram);
                        Bm_max_ram *= 1024 * 1024;
                } else if (Bm_max_ram == 0) {
                        dc_printf("!!BmpMan memory is unlimited!!\n");
                } else {
                        dc_printf("Illegal value. Must be non-negative.");
                }
        } else {
                dc_printf("<BmpMan> No argument given\n");
        }
}

DCF(bmpslots, "Writes bitmap slot info to fs2_open.log") {
        if (dc_optional_string_either("help", "--help")) {
                dc_printf("Usage: bmpslots\n");
                dc_printf("\tWrites bitmap slot info to fs2_open.log\n");
                return;
        }
        bm_print_bitmaps();
}

// --------------------------------------------------------------------------------------------------------------------
// Definition of all functions, in alphabetical order
void bm_clean_slot(int n) {
        bm_free_data(n);
}

void bm_close() {
        int i;
        if (bm_inited) {
                for (i = 0; i<MAX_BITMAPS; i++) {
                        bm_free_data(i);                        // clears flags, bbp, data, etc
                }
                bm_inited = 0;
        }
}

int bm_create(int bpp, int w, int h, void *data, int flags) {
        if (bpp == 8) {
                Assert(flags & BMP_AABITMAP);
        } else {
                Assert((bpp == 16) || (bpp == 24) || (bpp == 32));
        }

        if (!bm_inited) bm_init();

        int n = -1;

        for (int i = MAX_BITMAPS - 1; i >= 0; i--) {
                if (bm_bitmaps[i].type == BM_TYPE_NONE) {
                        n = i;
                        break;
                }
        }

        Assert(n > -1);

        // Out of bitmap slots
        if (n == -1)
                return -1;

        // make sure that we have valid data
        if (data == NULL) {
                Int3();
                return -1;
        }

        memset(&bm_bitmaps[n], 0, sizeof(bitmap_entry));

        sprintf(bm_bitmaps[n].filename, "TMP%dx%d+%d", w, h, bpp);
        bm_bitmaps[n].type = BM_TYPE_USER;
        bm_bitmaps[n].comp_type = BM_TYPE_NONE;
        bm_bitmaps[n].palette_checksum = 0;

        bm_bitmaps[n].bm.w = (short)w;
        bm_bitmaps[n].bm.h = (short)h;
        bm_bitmaps[n].bm.rowsize = (short)w;
        bm_bitmaps[n].bm.bpp = (ubyte)bpp;
        bm_bitmaps[n].bm.flags = (ubyte)flags;
        bm_bitmaps[n].bm.data = 0;
        bm_bitmaps[n].bm.palette = NULL;

        bm_bitmaps[n].info.user.bpp = (ubyte)bpp;
        bm_bitmaps[n].info.user.data = data;
        bm_bitmaps[n].info.user.flags = (ubyte)flags;

        bm_bitmaps[n].signature = Bm_next_signature++;

        bm_bitmaps[n].handle = bm_get_next_handle() * MAX_BITMAPS + n;
        bm_bitmaps[n].last_used = -1;
        bm_bitmaps[n].mem_taken = (w * h * (bpp >> 3));

        bm_bitmaps[n].load_count++;

        bm_update_memory_used(n, (int)bm_bitmaps[n].mem_taken);

        gr_bm_create(n);

        return bm_bitmaps[n].handle;
}

void bm_convert_format(bitmap *bmp, ubyte flags) {
        int idx;

        // no transparency for 24 bpp images
        if (!(flags & BMP_AABITMAP) && (bmp->bpp == 24))
                return;

        if (Is_standalone) {
                Assert(bmp->bpp == 8);
                return;
        } else {
                if (flags & BMP_AABITMAP)
                        Assert(bmp->bpp == 8);
                else
                        Assert((bmp->bpp == 16) || (bmp->bpp == 32));
        }

        // maybe swizzle to be an xparent texture
        if (!(bmp->flags & BMP_TEX_XPARENT) && (flags & BMP_TEX_XPARENT)) {
                for (idx = 0; idx<bmp->w*bmp->h; idx++) {
                        // if the pixel is transparent
                        if (((ushort*)bmp->data)[idx] == Gr_t_green.mask) {
                                ((ushort*)bmp->data)[idx] = 0;
                        }
                }

                bmp->flags |= BMP_TEX_XPARENT;
        }
}

void bm_free_data(int n, bool release)
{
        bitmap_entry *be;
        bitmap *bmp;

        Assert( (n >= 0) && (n < MAX_BITMAPS) );

        be = &bm_bitmaps[n];
        bmp = &be->bm;

        gr_bm_free_data(n, release);

        // If there isn't a bitmap in this structure, don't
        // do anything but clear out the bitmap info
        if (be->type==BM_TYPE_NONE)
                goto SkipFree;

        // Don't free up memory for user defined bitmaps, since
        // BmpMan isn't the one in charge of allocating/deallocing them.
        if (be->type==BM_TYPE_USER) {
#ifdef BMPMAN_NDEBUG
                if ( be->data_size != 0 )
                        bm_texture_ram -= be->data_size;
#endif
                goto SkipFree;
        }

        // If this bitmap doesn't have any data to free, skip
        // the freeing it part of this.
        if (bmp->data == 0) {
#ifdef BMPMAN_NDEBUG
                if ( be->data_size != 0 )
                        bm_texture_ram -= be->data_size;
#endif
                goto SkipFree;
        }

        // Free up the data now!
#ifdef BMPMAN_NDEBUG
        bm_texture_ram -= be->data_size;
#endif
        vm_free((void *)bmp->data);

        // reset the load_count to at least 1, don't do this in SkipFree though
        // since the real count ends up wrong
        be->load_count = 1;

SkipFree:

        // Clear out & reset the bitmap data structure
        bmp->flags = 0;
        bmp->bpp = 0;
        bmp->data = 0;
        bmp->palette = NULL;
#ifdef BMPMAN_NDEBUG
        be->data_size = 0;
#endif
        be->signature = Bm_next_signature++;
}

void bm_free_data_fast(int n)
{
        bitmap_entry *be;
        bitmap *bmp;

        Assert( (n >= 0) && (n < MAX_BITMAPS) );

        be = &bm_bitmaps[n];
        bmp = &be->bm;

        // If there isn't a bitmap in this structure, don't
        // do anything but clear out the bitmap info
        if (be->type == BM_TYPE_NONE)
                return;

        // Don't free up memory for user defined bitmaps, since
        // BmpMan isn't the one in charge of allocating/deallocing them.
        if (be->type == BM_TYPE_USER) {
#ifdef BMPMAN_NDEBUG
                if ( be->data_size != 0 )
                        bm_texture_ram -= be->data_size;
#endif
                return;
        }

        // If this bitmap doesn't have any data to free, skip
        // the freeing it part of this.
        if (bmp->data == 0) {
#ifdef BMPMAN_NDEBUG
                if ( be->data_size != 0 ) {
                        bm_texture_ram -= be->data_size;
                        be->data_size = 0;
                }
#endif
                return;
        }

        // Free up the data now!
#ifdef BMPMAN_NDEBUG
        bm_texture_ram -= be->data_size;
        be->data_size = 0;
#endif
        vm_free((void *)bmp->data);
        bmp->data = 0;
}

int bm_get_cache_slot(int bitmap_id, int separate_ani_frames) {
        int n = bitmap_id % MAX_BITMAPS;

        Assert(n >= 0);
        Assert(bm_bitmaps[n].handle == bitmap_id);              // INVALID BITMAP HANDLE

        bitmap_entry    *be = &bm_bitmaps[n];

        if ((!separate_ani_frames) && ((be->type == BM_TYPE_ANI) || (be->type == BM_TYPE_EFF))) {
                return be->info.ani.first_frame;
        }

        return n;

}

void bm_get_components(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a) {
        int bit_32 = 0;

        if ((gr_screen.bits_per_pixel == 32) && (Gr_current_red == &Gr_red)) {
                bit_32 = 1;
        }

        if (r != NULL) {
                if (bit_32) {
                        *r = ubyte(((*((unsigned int*)pixel) & Gr_current_red->mask) >> Gr_current_red->shift)*Gr_current_red->scale);
                } else {
                        *r = ubyte(((((unsigned short*)pixel)[0] & Gr_current_red->mask) >> Gr_current_red->shift)*Gr_current_red->scale);
                }
        }

        if (g != NULL) {
                if (bit_32) {
                        *g = ubyte(((*((unsigned int*)pixel) & Gr_current_green->mask) >> Gr_current_green->shift)*Gr_current_green->scale);
                } else {
                        *g = ubyte(((((unsigned short*)pixel)[0] & Gr_current_green->mask) >> Gr_current_green->shift)*Gr_current_green->scale);
                }
        }

        if (b != NULL) {
                if (bit_32) {
                        *b = ubyte(((*((unsigned int*)pixel) & Gr_current_blue->mask) >> Gr_current_blue->shift)*Gr_current_blue->scale);
                } else {
                        *b = ubyte(((((unsigned short*)pixel)[0] & Gr_current_blue->mask) >> Gr_current_blue->shift)*Gr_current_blue->scale);
                }
        }

        // get the alpha value
        if (a != NULL) {
                *a = 1;

                Assert(!bit_32);
                if (!(((unsigned short*)pixel)[0] & 0x8000)) {
                        *a = 0;
                }
        }
}

const char *bm_get_filename(int handle) {
        int n;

        n = handle % MAX_BITMAPS;
        Assert(bm_bitmaps[n].handle == handle);         // INVALID BITMAP HANDLE
        return bm_bitmaps[n].filename;
}

void bm_get_filename(int bitmapnum, char *filename) {
        if (!bm_is_valid(bitmapnum)) {
                strcpy(filename, "");
                return;
        }

        int n = bitmapnum % MAX_BITMAPS;

        Assert(n >= 0);

        // return filename
        strcpy(filename, bm_bitmaps[n].filename);
}

void bm_get_frame_usage(int *ntotal, int *nnew) {
#ifdef BMPMAN_NDEBUG
        int i;

        *ntotal = 0;
        *nnew = 0;

        for (i = 0; i<MAX_BITMAPS; i++) {
                if ((bm_bitmaps[i].type != BM_TYPE_NONE) && (bm_bitmaps[i].used_this_frame)) {
                        if (!bm_bitmaps[i].used_last_frame) {
                                *nnew += (int)bm_bitmaps[i].mem_taken;
                        }
                        *ntotal += (int)bm_bitmaps[i].mem_taken;
                }
                bm_bitmaps[i].used_last_frame = bm_bitmaps[i].used_this_frame;
                bm_bitmaps[i].used_this_frame = 0;
        }
#endif
}

int bm_get_info(int handle, int *w, int * h, ubyte * flags, int *nframes, int *fps) {
        bitmap * bmp;

        if (!bm_inited) return -1;

        int bitmapnum = handle % MAX_BITMAPS;

#ifndef NDEBUG
        if (bm_bitmaps[bitmapnum].handle != handle) {
                mprintf(("bm_get_info - %s: bm_bitmaps[%d].handle = %d, handle = %d\n", bm_bitmaps[bitmapnum].filename, bitmapnum, bm_bitmaps[bitmapnum].handle, handle));
        }
#endif

        Assertion(bm_bitmaps[bitmapnum].handle == handle, "Invalid bitmap handle %d passed to bm_get_info().\nThis might be due to an invalid animation somewhere else.\n", handle);            // INVALID BITMAP HANDLE!

        if ((bm_bitmaps[bitmapnum].type == BM_TYPE_NONE) || (bm_bitmaps[bitmapnum].handle != handle)) {
                if (w) *w = 0;
                if (h) *h = 0;
                if (flags) *flags = 0;
                if (nframes) *nframes = 0;
                if (fps) *fps = 0;
                return -1;
        }

        bmp = &(bm_bitmaps[bitmapnum].bm);

        if (w) *w = bmp->w;
        if (h) *h = bmp->h;
        if (flags) *flags = bmp->flags;

        if ((bm_bitmaps[bitmapnum].type == BM_TYPE_ANI) || (bm_bitmaps[bitmapnum].type == BM_TYPE_EFF)) {
                if (nframes) {
                        *nframes = bm_bitmaps[bitmapnum].info.ani.num_frames;
                }
                if (fps) {
                        *fps = bm_bitmaps[bitmapnum].info.ani.fps;
                }

                return bm_bitmaps[bm_bitmaps[bitmapnum].info.ani.first_frame].handle;
        } else {
                if (nframes) {
                        *nframes = 1;
                }
                if (fps) {
                        *fps = 0;
                }

                return handle;
        }
}

int bm_get_next_handle() {
        //bm_next_handle used to wrap around to 1 if it was over 30000. Now, believe it or not, but that is actually not uncommon;
        //as bitmaps get allocated and released, bm_next_handle could get there far more often than you'd think.
        //The check introduced below is intended to replace this behaviour with one that ensures we won't be seeing handle collisions
        //for a very long time.

        bm_next_handle++;

        //Due to the way bm_next_handle is used to generate the /actual/ bitmap handles ( (bm_next_handle * MAX_BITMAPS) + free slot index in bm_bitmaps[]),
        //this check is necessary to ensure we don't start giving out negative handles all of a sudden.
        if ((bm_next_handle + 1) > INT_MAX / MAX_BITMAPS) {
                bm_next_handle = 1;
                mprintf(("BMPMAN: bitmap handles wrapped back to 1\n"));
        }

        return bm_next_handle;
}

int bm_get_num_mipmaps(int num) {
        int n = num % MAX_BITMAPS;

        Assert(n >= 0);
        Assert(num == bm_bitmaps[n].handle);

        if (bm_bitmaps[n].num_mipmaps == 0)
                return 1;

        return bm_bitmaps[n].num_mipmaps;
}

void bm_get_palette(int handle, ubyte *pal, char *name) {
        char *filename;
        int w, h;

        int n = handle % MAX_BITMAPS;
        Assert(bm_bitmaps[n].handle == handle);         // INVALID BITMAP HANDLE

        filename = bm_bitmaps[n].filename;

        if (name) {
                strcpy(name, filename);
        }

        int pcx_error = pcx_read_header(filename, NULL, &w, &h, NULL, pal);
        if (pcx_error != PCX_ERROR_NONE) {
                // Error(LOCATION, "Couldn't open '%s'\n", filename );
        }
}

uint bm_get_signature(int handle) {
        if (!bm_inited) bm_init();

        int bitmapnum = handle % MAX_BITMAPS;
        Assertion(bm_bitmaps[bitmapnum].handle == handle, "Invalid bitmap handle %d passed to bm_get_signature().\nThis might be due to an invalid animation somewhere else.\n", handle);               // INVALID BITMAP HANDLE!

        return bm_bitmaps[bitmapnum].signature;
}

size_t bm_get_size(int handle) {
        int n = handle % MAX_BITMAPS;

        Assert(n >= 0);
        Assert(handle == bm_bitmaps[n].handle);

        return bm_bitmaps[n].mem_taken;
}

int bm_get_tcache_type(int num) {
        if (bm_is_compressed(num))
                return TCACHE_TYPE_COMPRESSED;

        return TCACHE_TYPE_NORMAL;
}

BM_TYPE bm_get_type(int handle) {
        if (!bm_inited) bm_init();

        int bitmapnum = handle % MAX_BITMAPS;
        Assertion(bm_bitmaps[bitmapnum].handle == handle, "Invalid bitmap handle %d passed to bm_get_type().\nThis might be due to an invalid animation somewhere else.\n", handle);            // INVALID BITMAP HANDLE!

        return bm_bitmaps[bitmapnum].type;
}

bool bm_has_alpha_channel(int handle) {
        int n = handle % MAX_BITMAPS;

        Assert(n >= 0);
        Assert(handle == bm_bitmaps[n].handle);

        // assume that PCX never has a real alpha channel (it may be 32-bit, but without any alpha)
        if (bm_bitmaps[n].type == BM_TYPE_PCX)
                return 0;

        return (bm_bitmaps[n].bm.true_bpp == 32);
}

void bm_init() {
        int i;

        mprintf(("Size of bitmap info = " SIZE_T_ARG " KB\n", sizeof(bm_bitmaps) / 1024));
        mprintf(("Size of bitmap extra info = " SIZE_T_ARG " bytes\n", sizeof(bm_extra_info)));

        if (!bm_inited) {
                bm_inited = 1;
                atexit(bm_close);
        }

        for (i = 0; i<MAX_BITMAPS; i++) {
                bm_bitmaps[i].filename[0] = '\0';
                bm_bitmaps[i].type = BM_TYPE_NONE;
                bm_bitmaps[i].comp_type = BM_TYPE_NONE;
                bm_bitmaps[i].dir_type = CF_TYPE_ANY;
                bm_bitmaps[i].info.user.data = NULL;
                bm_bitmaps[i].mem_taken = 0;
                bm_bitmaps[i].bm.data = 0;
                bm_bitmaps[i].bm.palette = NULL;
                bm_bitmaps[i].info.ani.eff.type = BM_TYPE_NONE;
                bm_bitmaps[i].info.ani.eff.filename[0] = '\0';
#ifdef BMPMAN_NDEBUG
                bm_bitmaps[i].data_size = 0;
                bm_bitmaps[i].used_count = 0;
                bm_bitmaps[i].used_last_frame = 0;
                bm_bitmaps[i].used_this_frame = 0;
#endif
                bm_bitmaps[i].load_count = 0;

                gr_bm_init(i);

                bm_free_data(i);        // clears flags, bbp, data, etc
        }
}

int bm_is_compressed(int num) {
        int n = num % MAX_BITMAPS;
        BM_TYPE type = BM_TYPE_NONE;

        //duh
        if (!Use_compressed_textures)
                return 0;

        Assert(n >= 0);
        Assert(num == bm_bitmaps[n].handle);

        type = bm_bitmaps[n].comp_type;

        switch (type) {
        case BM_TYPE_NONE:
        case BM_TYPE_DDS:
                return 0;

        case BM_TYPE_DXT1:
                return DDS_DXT1;

        case BM_TYPE_DXT3:
                return DDS_DXT3;

        case BM_TYPE_DXT5:
                return DDS_DXT5;

        case BM_TYPE_CUBEMAP_DXT1:
                return DDS_CUBEMAP_DXT1;

        case BM_TYPE_CUBEMAP_DXT3:
                return DDS_CUBEMAP_DXT3;

        case BM_TYPE_CUBEMAP_DXT5:
                return DDS_CUBEMAP_DXT5;

        default:
                return 0;
        }
}

int bm_is_render_target(int bitmap_id) {
        int n = bitmap_id % MAX_BITMAPS;

        Assert(n >= 0);
        Assert(bitmap_id == bm_bitmaps[n].handle);

        if (!((bm_bitmaps[n].type == BM_TYPE_RENDER_TARGET_STATIC) || (bm_bitmaps[n].type == BM_TYPE_RENDER_TARGET_DYNAMIC))) {
                return 0;
        }

        return bm_bitmaps[n].type;
}

int bm_is_valid(int handle) {
        // Ensure that certain known false or out of range handles are quickly returned as invalid,
        // prior to utilising the handle in a way which leads to memory access outside bm_bitmaps[]
        if (!bm_inited) return 0;
        if (handle < 0) return 0;

        return (bm_bitmaps[handle % MAX_BITMAPS].handle == handle);
}


// Load an image and validate it while retrieving information for later use
// Input:       type            = current BM_TYPE_*
//                      n                       = location in bm_bitmaps[]
//                      filename        = name of the current file
//                      img_cfp         = already open CFILE handle, if available
//
// Output:      w                       = bmp width
//                      h                       = bmp height
//                      bpp                     = bmp bits per pixel
//                      c_type          = output for an updated BM_TYPE_*
//                      mm_lvl          = number of mipmap levels for the image
//                      size            = size of the data contained in the image
static int bm_load_info(BM_TYPE type, int n, const char *filename, CFILE *img_cfp, int *w, int *h, int *bpp, BM_TYPE *c_type, int *mm_lvl, int *size)
{
        int dds_ct;

        if (type == BM_TYPE_DDS) {
                int dds_error = dds_read_header(filename, img_cfp, w, h, bpp, &dds_ct, mm_lvl, size);

                if (dds_error != DDS_ERROR_NONE) {
                        mprintf(("DDS ERROR: Couldn't open '%s' -- %s\n", filename, dds_error_string(dds_error)));
                        return -1;
                }

                switch (dds_ct) {
                case DDS_DXT1:
                        *c_type = BM_TYPE_DXT1;
                        break;

                case DDS_DXT3:
                        *c_type = BM_TYPE_DXT3;
                        break;

                case DDS_DXT5:
                        *c_type = BM_TYPE_DXT5;
                        break;

                case DDS_UNCOMPRESSED:
                        *c_type = BM_TYPE_DDS;
                        break;

                case DDS_CUBEMAP_DXT1:
                        *c_type = BM_TYPE_CUBEMAP_DXT1;
                        break;

                case DDS_CUBEMAP_DXT3:
                        *c_type = BM_TYPE_CUBEMAP_DXT3;
                        break;

                case DDS_CUBEMAP_DXT5:
                        *c_type = BM_TYPE_CUBEMAP_DXT5;
                        break;

                case DDS_CUBEMAP_UNCOMPRESSED:
                        *c_type = BM_TYPE_CUBEMAP_DDS;
                        break;

                default:
                        Error(LOCATION, "Bad DDS file compression! Not using DXT1,3,5: %s", filename);
                        return -1;
                }
        }
        // if its a tga file
        else if (type == BM_TYPE_TGA) {
                int tga_error = targa_read_header(filename, img_cfp, w, h, bpp, NULL);
                if (tga_error != TARGA_ERROR_NONE) {
                        mprintf(("tga: Couldn't open '%s'\n", filename));
                        return -1;
                }
        }
        // if its a png file
        else if (type == BM_TYPE_PNG) {
                int png_error = png_read_header(filename, img_cfp, w, h, bpp, NULL);
                if (png_error != PNG_ERROR_NONE) {
                        mprintf(("png: Couldn't open '%s'\n", filename));
                        return -1;
                }
        }
        // if its a jpg file
        else if (type == BM_TYPE_JPG) {
                int jpg_error = jpeg_read_header(filename, img_cfp, w, h, bpp, NULL);
                if (jpg_error != JPEG_ERROR_NONE) {
                        mprintf(("jpg: Couldn't open '%s'\n", filename));
                        return -1;
                }
        }
        // if its a pcx file
        else if (type == BM_TYPE_PCX) {
                int pcx_error = pcx_read_header(filename, img_cfp, w, h, bpp, NULL);
                if (pcx_error != PCX_ERROR_NONE) {
                        mprintf(("pcx: Couldn't open '%s'\n", filename));
                        return -1;
                }
        }
        else {
                Assertion(false, "Unknown file type specified! This is probably a coding error.");

                return -1;
        }

        return 0;
}

int bm_load(const char *real_filename) {
        int i, free_slot = -1;
        int w, h, bpp = 8;
        int rc = 0;
        int bm_size = 0, mm_lvl = 0;
        char filename[MAX_FILENAME_LEN];
        BM_TYPE type = BM_TYPE_NONE;
        BM_TYPE c_type = BM_TYPE_NONE;
        CFILE *img_cfp = NULL;
        int handle = -1;

        if (!bm_inited)
                bm_init();

        // if no file was passed then get out now
        if ((real_filename == NULL) || (strlen(real_filename) <= 0))
                return -1;

        // make sure no one passed an extension
        memset(filename, 0, MAX_FILENAME_LEN);
        strncpy(filename, real_filename, MAX_FILENAME_LEN - 1);
        char *p = strrchr(filename, '.');
        if (p) {
                mprintf(("Someone passed an extension to bm_load for file '%s'\n", real_filename));
                *p = 0;
        }

        // If we are standalone server keep replacing the 'right_bracket' (right side help bracket) as the filename
        // should keep the game happy while loading only single pcx file which the needs to be present in any case
        if (Is_standalone) {
                char standalone_filename[MAX_FILENAME_LEN] = "right_bracket";
                strcpy_s(filename, standalone_filename);
        }

        // safety catch for strcat...
        // MAX_FILENAME_LEN-5 == '.' plus 3 letter ext plus NULL terminator
        if (strlen(filename) > MAX_FILENAME_LEN - 5) {
                Warning(LOCATION, "Passed filename, '%s', is too long to support an extension!!\n\nMaximum length, minus the extension, is %i characters.\n", filename, MAX_FILENAME_LEN - 5);
                return -1;
        }

        // Lets find out what type it is
        {
                // see if it's already loaded (checks for any type with filename)
                if (bm_load_sub_fast(filename, &handle))
                        return handle;

                // if we are still here then we need to fall back to a file-based search
                int rval = bm_load_sub_slow(filename, BM_NUM_TYPES, bm_ext_list, &img_cfp);

                if (rval < 0)
                        return -1;

                strcat_s(filename, bm_ext_list[rval]);
                type = bm_type_list[rval];
        }

        Assert(type != BM_TYPE_NONE);

        // Find an open slot
        for (i = 0; i < MAX_BITMAPS; i++) {
                if (bm_bitmaps[i].type == BM_TYPE_NONE) {
                        free_slot = i;
                        break;
                }
        }

        if (free_slot < 0) {
                Assertion(free_slot < 0, "Could not find free BMPMAN slot for bitmap: %s", real_filename);
                goto Done;
        }

        rc = bm_load_info(type, free_slot, filename, img_cfp, &w, &h, &bpp, &c_type, &mm_lvl, &bm_size);

        if (rc != 0)
                goto Done;

        if ((bm_size <= 0) && (w) && (h) && (bpp))
                bm_size = (w * h * (bpp >> 3));


        handle = bm_get_next_handle() * MAX_BITMAPS + free_slot;

        // ensure fields are cleared out from previous bitmap
        memset(&bm_bitmaps[free_slot], 0, sizeof(bitmap_entry));

        // Mark the slot as filled, because cf_read might load a new bitmap
        // into this slot.
        strncpy(bm_bitmaps[free_slot].filename, filename, MAX_FILENAME_LEN - 1);
        bm_bitmaps[free_slot].type = type;
        bm_bitmaps[free_slot].comp_type = c_type;
        bm_bitmaps[free_slot].signature = Bm_next_signature++;
        bm_bitmaps[free_slot].bm.w = (short)w;
        bm_bitmaps[free_slot].bm.rowsize = (short)w;
        bm_bitmaps[free_slot].bm.h = (short)h;
        bm_bitmaps[free_slot].bm.bpp = 0;
        bm_bitmaps[free_slot].bm.true_bpp = (ubyte)bpp;
        bm_bitmaps[free_slot].bm.flags = 0;
        bm_bitmaps[free_slot].bm.data = 0;
        bm_bitmaps[free_slot].bm.palette = NULL;
        bm_bitmaps[free_slot].num_mipmaps = mm_lvl;
        bm_bitmaps[free_slot].mem_taken = (size_t)bm_size;
        bm_bitmaps[free_slot].dir_type = CF_TYPE_ANY;
        bm_bitmaps[free_slot].palette_checksum = 0;
        bm_bitmaps[free_slot].handle = handle;
        bm_bitmaps[free_slot].last_used = -1;

        bm_bitmaps[free_slot].load_count++;

Done:
        if (img_cfp != NULL)
                cfclose(img_cfp);

        return handle;
}

int bm_load(const SCP_string& filename) {
        return bm_load(filename.c_str());
}

bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int *nfps, int *key, BM_TYPE *type) {
        int frames = 0, fps = 30, keyframe = 0;
        char ext[8];
        BM_TYPE c_type = BM_TYPE_NONE;
        char file_text[1024];
        char file_text_raw[1024];

        memset(ext, 0, sizeof(ext));
        memset(file_text, 0, sizeof(file_text));
        memset(file_text_raw, 0, sizeof(file_text_raw));

        // pause anything that may happen to be parsing right now
        pause_parse();

        try
        {
                // now start parsing the EFF
                read_file_text(filename, dir_type, file_text, file_text_raw);
                reset_parse(file_text);

                required_string("$Type:");
                stuff_string(ext, F_NAME, sizeof(ext));

                required_string("$Frames:");
                stuff_int(&frames);

                if (optional_string("$FPS:"))
                        stuff_int(&fps);

                if (optional_string("$Keyframe:"))
                        stuff_int(&keyframe);
        }
        catch (const parse::ParseException& e)
        {
                mprintf(("BMPMAN: Unable to parse '%s'!  Error message = %s.\n", filename, e.what()));
                unpause_parse();
                return false;
        }

        // done with EFF so unpause parsing so whatever can continue
        unpause_parse();

        if (!stricmp(NOX("dds"), ext)) {
                c_type = BM_TYPE_DDS;
        } else if (!stricmp(NOX("tga"), ext)) {
                c_type = BM_TYPE_TGA;
        } else if (!stricmp(NOX("png"), ext)) {
                c_type = BM_TYPE_PNG;
        } else if (!stricmp(NOX("jpg"), ext)) {
                c_type = BM_TYPE_JPG;
        } else if (!stricmp(NOX("pcx"), ext)) {
                c_type = BM_TYPE_PCX;
        } else {
                mprintf(("BMPMAN: Unknown file type in EFF parse!\n"));
                return false;
        }

        // did we do anything?
        if (c_type == BM_TYPE_NONE || frames == 0) {
                mprintf(("BMPMAN: EFF parse ERROR!\n"));
                return false;
        }

        if (type)
                *type = c_type;

        if (nframes)
                *nframes = frames;

        if (nfps)
                *nfps = fps;

        if (key)
                *key = keyframe;

        return true;
}


static int bm_load_image_data(const char *filename, int handle, int bitmapnum, ubyte bpp, ubyte flags, bool nodebug)
{
        BM_TYPE c_type = BM_TYPE_NONE;
        ubyte true_bpp;

        bitmap_entry *be = &bm_bitmaps[bitmapnum];
        bitmap *bmp = &be->bm;

        Assert(!Is_standalone);

        if (bmp->true_bpp > bpp)
                true_bpp = bmp->true_bpp;
        else
                true_bpp = bpp;

        // don't do a bpp check here since it could be different in OGL - taylor
        if (bmp->data == 0) {
                Assert(be->ref_count == 1);

                if (be->type != BM_TYPE_USER && !nodebug) {
                        if (bmp->data == 0)
                                nprintf(("BmpMan", "Loading %s for the first time.\n", be->filename));
                }

                if (!Bm_paging) {
                        if (be->type != BM_TYPE_USER && !nodebug)
                                nprintf(("Paging", "Loading %s (%dx%dx%d)\n", be->filename, bmp->w, bmp->h, true_bpp));
                }

                // select proper format
                if (flags & BMP_AABITMAP)
                        BM_SELECT_ALPHA_TEX_FORMAT();
                else if (flags & BMP_TEX_ANY)
                        BM_SELECT_TEX_FORMAT();
                else
                        BM_SELECT_SCREEN_FORMAT();

                // make sure we use the real graphic type for EFFs
                if (be->type == BM_TYPE_EFF) {
                        c_type = be->info.ani.eff.type;
                }
                else {
                        c_type = be->type;
                }

                switch (c_type)
                {
                case BM_TYPE_PCX:
                        bm_lock_pcx(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                case BM_TYPE_ANI:
                        bm_lock_ani(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                case BM_TYPE_TGA:
                        bm_lock_tga(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                case BM_TYPE_PNG:
                        //libpng handles compression with zlib
                        bm_lock_png(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                case BM_TYPE_JPG:
                        bm_lock_jpg(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                case BM_TYPE_DDS:
                case BM_TYPE_DXT1:
                case BM_TYPE_DXT3:
                case BM_TYPE_DXT5:
                case BM_TYPE_CUBEMAP_DDS:
                case BM_TYPE_CUBEMAP_DXT1:
                case BM_TYPE_CUBEMAP_DXT3:
                case BM_TYPE_CUBEMAP_DXT5:
                        bm_lock_dds(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                case BM_TYPE_USER:
                        bm_lock_user(handle, bitmapnum, be, bmp, true_bpp, flags);
                        break;

                default:
                        Warning(LOCATION, "Unsupported type in bm_lock -- %d\n", c_type);
                        return -1;
                }

                // always go back to screen format
                BM_SELECT_SCREEN_FORMAT();

                // make sure we actually did something
                if (!(bmp->data))
                        return -1;
        }

        return 0;
}

int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *keyframe, int can_drop_frames, int dir_type) {
        int     i, n;
        anim    the_anim;
        CFILE   *img_cfp = NULL;
        char filename[MAX_FILENAME_LEN];
        int reduced = 0;
        int anim_fps = 0, anim_frames = 0, key = 0;
        int anim_width = 0, anim_height = 0;
        BM_TYPE type = BM_TYPE_NONE, eff_type = BM_TYPE_NONE, c_type = BM_TYPE_NONE;
        int bpp = 0, mm_lvl = 0, img_size = 0;
        char clean_name[MAX_FILENAME_LEN];

        if (!bm_inited)
                bm_init();

        // set defaults for frame count and fps before going any further
        if (nframes)
                *nframes = 0;

        if (fps)
                *fps = 0;

        if (keyframe)
                *keyframe = 0;

        memset(filename, 0, MAX_FILENAME_LEN);
        strncpy(filename, real_filename, MAX_FILENAME_LEN - 1);
        char *p = strchr(filename, '.');
        if (p) {
                mprintf(("Someone passed an extension to bm_load_animation for file '%s'\n", real_filename));
                *p = 0;
        }

        // If we are standalone server keep replacing the 'cursorweb' (mouse cursor) as the filename
        // should keep the game happy while loading only single ani file which the needs to be present in any case
        if (Is_standalone) {
                char standalone_filename[MAX_FILENAME_LEN] = "cursorweb";
                strcpy_s(filename, standalone_filename);
        }

        // safety catch for strcat...
        // MAX_FILENAME_LEN-5 == '.' plus 3 letter ext plus NULL terminator
        if (strlen(filename) > MAX_FILENAME_LEN - 5) {
                Warning(LOCATION, "Passed filename, '%s', is too long to support an extension!!\n\nMaximum length, minus the extension, is %i characters.\n", filename, MAX_FILENAME_LEN - 5);
                return -1;
        }

        // used later if EFF type
        strcpy_s(clean_name, filename);

        // Lets find out what type it is
        {
                int handle = -1;

                // do a search for any previously loaded files (looks at filename only)
                if (bm_load_sub_fast(filename, &handle, dir_type, true)) {
                        n = handle % MAX_BITMAPS;
                        Assert(bm_bitmaps[n].handle == handle);

                        if (nframes)
                                *nframes = bm_bitmaps[n].info.ani.num_frames;

                        if (fps)
                                *fps = bm_bitmaps[n].info.ani.fps;

                        if (keyframe)
                                *keyframe = bm_bitmaps[n].info.ani.keyframe;

                        return handle;
                }

                // if we are still here then we need to fall back to a file-based search
                int rval = bm_load_sub_slow(filename, BM_ANI_NUM_TYPES, bm_ani_ext_list, &img_cfp, dir_type);

                if (rval < 0)
                        return -1;

                strcat_s(filename, bm_ani_ext_list[rval]);
                type = bm_ani_type_list[rval];
        }

        // If we found an animation then there is an extra 5 char size limit to adhere to. We don't do this check earlier since it's only needed if we found an anim
        // an ANI needs about 5 extra characters to have the "[###]" frame designator
        // an EFF needs 5 extra characters for each frame filename too, which just happens to be the same length as the frame designator needed otherwise
        // MAX_FILENAME_LEN-10 == 5 character frame designator plus '.' plus 3 letter ext plus NULL terminator
        // we only check for -5 here since the filename should already have the extension on it, and it must have passed the previous check
        if (strlen(filename) > MAX_FILENAME_LEN - 5) {
                Warning(LOCATION, "Passed filename, '%s', is too long to support an extension and frames!!\n\nMaximum length for an ANI/EFF, minus the extension, is %i characters.\n", filename, MAX_FILENAME_LEN - 10);
                return -1;
        }

        // it's an effect file, any readable image type with eff being txt
        if (type == BM_TYPE_EFF) {
                if (!bm_load_and_parse_eff(filename, dir_type, &anim_frames, &anim_fps, &key, &eff_type)) {
                        mprintf(("BMPMAN: Error reading EFF\n"));
                        return -1;
                } else {
                        mprintf(("BMPMAN: Found EFF (%s) with %d frames at %d fps.\n", filename, anim_frames, anim_fps));
                }
        }
        // regular ani file
        else if (type == BM_TYPE_ANI) {
#ifndef NDEBUG
                // for debug of ANI sizes
                strcpy_s(the_anim.name, real_filename);
#endif
                anim_read_header(&the_anim, img_cfp);

                anim_frames = the_anim.total_frames;
                anim_fps = the_anim.fps;
                anim_width = the_anim.width;
                anim_height = the_anim.height;
                bpp = 8;
                img_size = (anim_width * anim_height * bpp);
                //we only care if there are 2 keyframes - first frame, other frame to jump to for ship/weapons
                //mainhall door anis hav every frame as keyframe, so we don't care
                //other anis only have the first frame
                if (the_anim.num_keys == 2) {
                        the_anim.keys = (key_frame*)vm_malloc(sizeof(key_frame) * the_anim.num_keys);
                        Assert(the_anim.keys != NULL);

                        for (i = 0; i<the_anim.num_keys; i++) {
                                the_anim.keys[i].frame_num = 0;
                                cfread(&the_anim.keys[i].frame_num, 2, 1, img_cfp);
                                cfread(&the_anim.keys[i].offset, 4, 1, img_cfp);
                                the_anim.keys[i].frame_num = INTEL_INT(the_anim.keys[i].frame_num); //-V570
                                the_anim.keys[i].offset = INTEL_INT(the_anim.keys[i].offset); //-V570
                        }
                        //some retail anis have their keyframes reversed
                        key = MAX(the_anim.keys[0].frame_num, the_anim.keys[1].frame_num);
                        
                        vm_free(the_anim.keys);
                        the_anim.keys = nullptr;
                }
        } else {
                return -1;
        }

        if ((can_drop_frames) && (type != BM_TYPE_EFF)) {
                if (Bm_low_mem == 1) {
                        reduced = 1;
                        anim_frames = (anim_frames + 1) / 2;
                        anim_fps = (anim_fps / 2);
                } else if (Bm_low_mem == 2) {
                        anim_frames = 1;
                }
        }


        n = find_block_of(anim_frames);

        if (n < 0) {
                if (img_cfp != NULL)
                        cfclose(img_cfp);

                return -1;
        }

        int first_handle = bm_get_next_handle();

        for (i = 0; i < anim_frames; i++) {
                memset(&bm_bitmaps[n + i], 0, sizeof(bitmap_entry));

                if (type == BM_TYPE_EFF) {
                        bm_bitmaps[n + i].info.ani.eff.type = eff_type;
                        sprintf(bm_bitmaps[n + i].info.ani.eff.filename, "%s_%.4d", clean_name, i);

                        // bm_load_info() returns non-0 on failure
                        if (bm_load_info(eff_type, n + i, bm_bitmaps[n + i].info.ani.eff.filename, NULL, &anim_width, &anim_height, &bpp, &c_type, &mm_lvl, &img_size)) {
                                // if we didn't get anything then bail out now
                                if (i == 0) {
                                        Warning(LOCATION, "EFF: No frame images were found.  EFF, %s, is invalid.\n", filename);

                                        if (img_cfp != NULL)
                                                cfclose(img_cfp);

                                        return -1;
                                }

                                Warning(LOCATION, "EFF: Unable to load all frames for '%s', stopping at #%d\n", filename, i);

                                // reset total frames to current
                                anim_frames = i;

                                // update all previous frames with the new count
                                for (int j = 0; j<anim_frames; j++)
                                        bm_bitmaps[n + j].info.ani.num_frames = anim_frames;

                                break;
                        }

                        if ((img_size <= 0) && (anim_width) && (anim_height) && (bpp)) {
                                img_size = (anim_width * anim_height * (bpp >> 3));
                        }
                }

                bm_bitmaps[n + i].info.ani.first_frame = n;
                bm_bitmaps[n + i].info.ani.num_frames = anim_frames;
                bm_bitmaps[n + i].info.ani.fps = (ubyte)anim_fps;
                bm_bitmaps[n + i].info.ani.keyframe = key;
                bm_bitmaps[n + i].bm.w = (short)anim_width;
                bm_bitmaps[n + i].bm.rowsize = (short)anim_width;
                bm_bitmaps[n + i].bm.h = (short)anim_height;
                if (reduced) {
                        bm_bitmaps[n + i].bm.w /= 2;
                        bm_bitmaps[n + i].bm.rowsize /= 2;
                        bm_bitmaps[n + i].bm.h /= 2;
                }
                bm_bitmaps[n + i].bm.flags = 0;
                bm_bitmaps[n + i].bm.bpp = 0;
                bm_bitmaps[n + i].bm.true_bpp = (ubyte)bpp;
                bm_bitmaps[n + i].bm.data = 0;
                bm_bitmaps[n + i].bm.palette = NULL;
                bm_bitmaps[n + i].type = type;
                bm_bitmaps[n + i].comp_type = c_type;
                bm_bitmaps[n + i].palette_checksum = 0;
                bm_bitmaps[n + i].signature = Bm_next_signature++;
                bm_bitmaps[n + i].handle = first_handle*MAX_BITMAPS + n + i;
                bm_bitmaps[n + i].last_used = -1;
                bm_bitmaps[n + i].num_mipmaps = mm_lvl;
                bm_bitmaps[n + i].mem_taken = (size_t)img_size;
                bm_bitmaps[n + i].dir_type = dir_type;

                bm_bitmaps[n + i].load_count++;

                if (i == 0) {
                        sprintf(bm_bitmaps[n + i].filename, "%s", filename);
                } else {
                        sprintf(bm_bitmaps[n + i].filename, "%s[%d]", filename, i);
                }

        }

        if (nframes)
                *nframes = anim_frames;

        if (fps)
                *fps = anim_fps;

        if (img_cfp != NULL)
                cfclose(img_cfp);

        if (keyframe)
                *keyframe = key;

        return bm_bitmaps[n].handle;
}

int bm_load_duplicate(const char *filename) {
        int ret;

        // ignore duplicates
        Bm_ignore_duplicates = 1;

        // load
        ret = bm_load(filename);

        // back to normal
        Bm_ignore_duplicates = 0;

        return ret;
}

int bm_load_either(const char *filename, int *nframes, int *fps, int *keyframe, int can_drop_frames, int dir_type) {
        if (nframes != NULL)
                *nframes = 0;
        if (fps != NULL)
                *fps = 0;
        int tidx = bm_load_animation(filename, nframes, fps, keyframe, can_drop_frames, dir_type);
        if (tidx == -1) {
                tidx = bm_load(filename);
                if (tidx != -1 && nframes != NULL)
                        *nframes = 1;
        }

        return tidx;
}

int bm_load_sub_fast(const char *real_filename, int *handle, int dir_type, bool animated_type) {
        if (Bm_ignore_duplicates)
                return 0;

        int i;

        for (i = 0; i < MAX_BITMAPS; i++) {
                if (bm_bitmaps[i].type == BM_TYPE_NONE)
                        continue;

                if (bm_bitmaps[i].dir_type != dir_type)
                        continue;

                bool animated = ((bm_bitmaps[i].type == BM_TYPE_EFF) || (bm_bitmaps[i].type == BM_TYPE_ANI));

                if (animated_type && !animated)
                        continue;
                else if (!animated_type && animated)
                        continue;

                if (!strextcmp(real_filename, bm_bitmaps[i].filename)) {
                        nprintf(("BmpFastLoad", "Found bitmap %s -- number %d\n", bm_bitmaps[i].filename, i));
                        bm_bitmaps[i].load_count++;
                        *handle = bm_bitmaps[i].handle;
                        return 1;
                }
        }

        // not found to be loaded already
        return 0;
}

int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **ext_list, CFILE **img_cfp, int dir_type) {
        char full_path[MAX_PATH];
        int size = 0, offset = 0;
        int rval = -1;

        rval = cf_find_file_location_ext(real_filename, num_ext, ext_list, dir_type, sizeof(full_path) - 1, full_path, &size, &offset, 0);

        // could not be found, or is invalid for some reason
        if ((rval < 0) || (rval >= num_ext))
                return -1;

        CFILE *test = cfopen_special(full_path, "rb", size, offset, dir_type);

        if (test != NULL) {
                if (img_cfp != NULL)
                        *img_cfp = test;

                return rval;
        }

        // umm, that's not good...
        return -1;
}

bitmap * bm_lock(int handle, ubyte bpp, ubyte flags, bool nodebug) {
        bitmap                  *bmp;
        bitmap_entry    *be;

        if (!bm_inited) bm_init();

        int bitmapnum = handle % MAX_BITMAPS;

        Assertion(bm_bitmaps[bitmapnum].handle == handle, "Invalid handle %d passed to bm_lock. This might be due to an animation elsewhere in the code being too short.\n", handle);           // INVALID BITMAP HANDLE

        // to fix a couple of OGL bpp passes, force 8bit on AABITMAP - taylor
        if (flags & BMP_AABITMAP)
                bpp = 8;

        // if we're on a standalone server, aways for it to lock to 8 bits
        if (Is_standalone) {
                bpp = 8;
                flags = 0;
        }
        // otherwise do it as normal
        else {
                if (flags & BMP_AABITMAP) {
                        Assert(bpp == 8);
                } else if ((flags & BMP_TEX_NONCOMP) && (!(flags & BMP_TEX_COMP))) {
                        Assert(bpp >= 16);  // cheating but bpp passed isn't what we normally end up with
                } else if ((flags & BMP_TEX_DXT1) || (flags & BMP_TEX_DXT3) || (flags & BMP_TEX_DXT5)) {
                        Assert(bpp >= 16); // cheating but bpp passed isn't what we normally end up with
                } else if (flags & BMP_TEX_CUBEMAP) {
                        Assert((bm_bitmaps[bitmapnum].type == BM_TYPE_CUBEMAP_DDS) ||
                                (bm_bitmaps[bitmapnum].type == BM_TYPE_CUBEMAP_DXT1) ||
                                (bm_bitmaps[bitmapnum].type == BM_TYPE_CUBEMAP_DXT3) ||
                                (bm_bitmaps[bitmapnum].type == BM_TYPE_CUBEMAP_DXT5));
                        Assert(bpp >= 16);
                } else {
                        Assert(0);              //?
                }
        }

        be = &bm_bitmaps[bitmapnum];
        bmp = &be->bm;

        // If you hit this assert, chances are that someone freed the
        // wrong bitmap and now someone is trying to use that bitmap.
        // See John.
        Assert(be->type != BM_TYPE_NONE);

        // Increment ref count for bitmap since lock was made on it.
        Assert(be->ref_count >= 0);
        be->ref_count++;                                        // Lock it before we page in data; this prevents a callback from freeing this
        // as it gets read in

        // Mark this bitmap as used this frame
#ifdef BMPMAN_NDEBUG
        if (be->used_this_frame < 255) {
                be->used_this_frame++;
        }
#endif

        // read the file data
        if (bm_load_image_data(be->filename, handle, bitmapnum, bpp, flags, nodebug) == -1) {
                // oops, this isn't good - reset and return NULL
                bm_unlock( handle );
                bm_unload( handle );

                return NULL;
        }
        
        if (!gr_bm_data(bitmapnum, bmp)) {
                // graphics subsystem failed, reset and return NULL
                bm_unlock( handle );
                bm_unload( handle );

                return NULL;
        }

        MONITOR_INC(NumBitmapPage, 1);
        MONITOR_INC(SizeBitmapPage, bmp->w*bmp->h);

        if ((be->type == BM_TYPE_ANI) || (be->type == BM_TYPE_EFF)) {
                int i, first = bm_bitmaps[bitmapnum].info.ani.first_frame;

                for (i = 0; i< bm_bitmaps[first].info.ani.num_frames; i++) {
                        // Mark all the bitmaps in this bitmap or animation as recently used
                        bm_bitmaps[first + i].last_used = timer_get_milliseconds();

#ifdef BMPMAN_NDEBUG
                        // Mark all the bitmaps in this bitmap or animation as used for the usage tracker.
                        bm_bitmaps[first + i].used_count++;
#endif

                        bm_bitmaps[first + i].used_flags = flags;
                }
        } else {
                // Mark all the bitmaps in this bitmap or animation as recently used
                be->last_used = timer_get_milliseconds();

#ifdef BMPMAN_NDEBUG
                // Mark all the bitmaps in this bitmap or animation as used for the usage tracker.
                be->used_count++;
#endif
                be->used_flags = flags;
        }

        return bmp;
}

void bm_lock_ani(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        anim                            *the_anim;
        anim_instance   *the_anim_instance;
        bitmap                  *bm;
        ubyte                           *frame_data;
        int                             size, i;
        int                             first_frame, nframes;

        first_frame = be->info.ani.first_frame;
        nframes = bm_bitmaps[first_frame].info.ani.num_frames;

        if ((the_anim = anim_load(bm_bitmaps[first_frame].filename, bm_bitmaps[first_frame].dir_type)) == NULL) {
                nprintf(("BMPMAN", "Error opening %s in bm_lock\n", be->filename));
                return;
        }

        if ((the_anim_instance = init_anim_instance(the_anim, bpp)) == NULL) {
                nprintf(("BMPMAN", "Error opening %s in bm_lock\n", be->filename));
                anim_free(the_anim);
                return;
        }

        int can_drop_frames = 0;

        if (the_anim->total_frames != bm_bitmaps[first_frame].info.ani.num_frames) {
                can_drop_frames = 1;
        }

        bm = &bm_bitmaps[first_frame].bm;
        size = bm->w * bm->h * (bpp >> 3);
        be->mem_taken = (size_t)size;

        Assert(size > 0);

        for (i = 0; i<nframes; i++) {
                be = &bm_bitmaps[first_frame + i];
                bm = &bm_bitmaps[first_frame + i].bm;

                // Unload any existing data
                bm_free_data(first_frame + i);

                bm->flags = 0;

                // briefing editor in Fred2 uses aabitmaps (ani's) - force to 8 bit
                bm->bpp = Is_standalone ? (ubyte)8 : bpp;

                bm->data = (ptr_u)bm_malloc(first_frame + i, size);

                frame_data = anim_get_next_raw_buffer(the_anim_instance, 0, flags & BMP_AABITMAP ? 1 : 0, bm->bpp);

                ubyte *dptr, *sptr;

                sptr = frame_data;
                dptr = (ubyte *)bm->data;

                if ((bm->w != the_anim->width) || (bm->h != the_anim->height)) {
                        // Scale it down
                        // 8 bit
                        if (bpp == 8) {
                                int w, h;
                                fix u, utmp, v, du, dv;

                                u = v = 0;

                                du = (the_anim->width*F1_0) / bm->w;
                                dv = (the_anim->height*F1_0) / bm->h;

                                for (h = 0; h < bm->h; h++) {
                                        ubyte *drow = &dptr[bm->w * h];
                                        ubyte *srow = &sptr[f2i(v)*the_anim->width];

                                        utmp = u;

                                        for (w = 0; w < bm->w; w++) {
                                                *drow++ = srow[f2i(utmp)];
                                                utmp += du;
                                        }
                                        v += dv;
                                }
                        }
                        // 16 bpp
                        else {
                                int w, h;
                                fix u, utmp, v, du, dv;

                                u = v = 0;

                                du = (the_anim->width*F1_0) / bm->w;
                                dv = (the_anim->height*F1_0) / bm->h;

                                for (h = 0; h < bm->h; h++) {
                                        unsigned short *drow = &((unsigned short*)dptr)[bm->w * h];
                                        unsigned short *srow = &((unsigned short*)sptr)[f2i(v)*the_anim->width];

                                        utmp = u;

                                        for (w = 0; w < bm->w; w++) {
                                                *drow++ = srow[f2i(utmp)];
                                                utmp += du;
                                        }
                                        v += dv;
                                }
                        }
                } else {
                        // 1-to-1 mapping
                        memcpy(dptr, sptr, size);
                }

                bm_convert_format(bm, flags);

                // Skip a frame
                if ((i < nframes - 1) && can_drop_frames) {
                        frame_data = anim_get_next_raw_buffer(the_anim_instance, 0, flags & BMP_AABITMAP ? 1 : 0, bm->bpp);
                }
        }

        free_anim_instance(the_anim_instance);
        anim_free(the_anim);
}

void bm_lock_dds(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        ubyte *data = NULL;
        int error;
        ubyte dds_bpp = 0;
        char filename[MAX_FILENAME_LEN];

        // free any existing data
        bm_free_data(bitmapnum);

        Assert(be->mem_taken > 0);
        Assert(&be->bm == bmp);

        data = (ubyte*)bm_malloc(bitmapnum, be->mem_taken);

        if (data == NULL)
                return;

        memset(data, 0, be->mem_taken);

        // make sure we are using the correct filename in the case of an EFF.
        // this will populate filename[] whether it's EFF or not
        EFF_FILENAME_CHECK;

        error = dds_read_bitmap(filename, data, &dds_bpp, be->dir_type);

#if BYTE_ORDER == BIG_ENDIAN
        // same as with TGA, we need to byte swap 16 & 32-bit, uncompressed, DDS images
        if ((be->comp_type == BM_TYPE_DDS) || (be->comp_type == BM_TYPE_CUBEMAP_DDS)) {
                size_t i = 0;

                if (dds_bpp == 32) {
                        unsigned int *swap_tmp;

                        for (i = 0; i < be->mem_taken; i += 4) {
                                swap_tmp = (unsigned int *)(data + i);
                                *swap_tmp = INTEL_INT(*swap_tmp);
                        }
                } else if (dds_bpp == 16) {
                        unsigned short *swap_tmp;

                        for (i = 0; i < be->mem_taken; i += 2) {
                                swap_tmp = (unsigned short *)(data + i);
                                *swap_tmp = INTEL_SHORT(*swap_tmp);
                        }
                }
        }
#endif

        bmp->bpp = dds_bpp;
        bmp->data = (ptr_u)data;
        bmp->flags = 0;

        if (error != DDS_ERROR_NONE) {
                bm_free_data(bitmapnum);
                return;
        }

#ifdef BMPMAN_NDEBUG
        Assert(be->data_size > 0);
#endif
}

void bm_lock_jpg(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        ubyte *data = NULL;
        int d_size = 0;
        int jpg_error = JPEG_ERROR_INVALID;
        char filename[MAX_FILENAME_LEN];

        // Unload any existing data
        bm_free_data(bitmapnum);

        d_size = (bpp >> 3);

        // allocate bitmap data
        Assert(be->mem_taken > 0);
        data = (ubyte*)bm_malloc(bitmapnum, be->mem_taken);

        if (data == NULL)
                return;

        memset(data, 0, be->mem_taken);

        bmp->bpp = bpp;
        bmp->data = (ptr_u)data;
        bmp->palette = NULL;

        Assert(&be->bm == bmp);

        // make sure we are using the correct filename in the case of an EFF.
        // this will populate filename[] whether it's EFF or not
        EFF_FILENAME_CHECK;

        jpg_error = jpeg_read_bitmap(filename, data, NULL, d_size, be->dir_type);

        if (jpg_error != JPEG_ERROR_NONE) {
                bm_free_data(bitmapnum);
                return;
        }

#ifdef BMPMAN_NDEBUG
        Assert(be->data_size > 0);
#endif
}

void bm_lock_pcx(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        ubyte *data;
        int pcx_error;
        char filename[MAX_FILENAME_LEN];

        // Unload any existing data
        bm_free_data(bitmapnum);

        be->mem_taken = (bmp->w * bmp->h * (bpp >> 3));
        data = (ubyte *)bm_malloc(bitmapnum, be->mem_taken);
        bmp->bpp = bpp;
        bmp->data = (ptr_u)data;
        bmp->palette = (bpp == 8) ? gr_palette : NULL;
        memset(data, 0, be->mem_taken);

        Assert(&be->bm == bmp);
#ifdef BMPMAN_NDEBUG
        Assert(be->data_size > 0);
#endif

        // some sanity checks on flags
        Assert(!((flags & BMP_AABITMAP) && (flags & BMP_TEX_ANY)));                                             // no aabitmap textures

        // make sure we are using the correct filename in the case of an EFF.
        // this will populate filename[] whether it's EFF or not
        EFF_FILENAME_CHECK;

        pcx_error = pcx_read_bitmap(filename, data, NULL, (bpp >> 3), (flags & BMP_AABITMAP), 0, be->dir_type);

        if (pcx_error != PCX_ERROR_NONE) {
                mprintf(("Couldn't load PCX!!! (%s)\n", filename));
                return;
        }

#ifdef BMPMAN_NDEBUG
        Assert(be->data_size > 0);
#endif

        bmp->flags = 0;

        bm_convert_format(bmp, flags);
}

void bm_lock_png(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        ubyte *data = NULL;
        //assume 32 bit - libpng should expand everything
        int d_size;
        int png_error = PNG_ERROR_INVALID;
        char filename[MAX_FILENAME_LEN];

        // Unload any existing data
        bm_free_data(bitmapnum);

        // allocate bitmap data
        Assert(bmp->w * bmp->h > 0);

        //if it's not 32-bit, we expand when we read it
        bmp->bpp = 32;
        d_size = bmp->bpp >> 3;
        //we waste memory if it turns out to be 24-bit, but the way this whole thing works is dodgy anyway
        data = (ubyte*)bm_malloc(bitmapnum, bmp->w * bmp->h * d_size);
        if (data == NULL)
                return;
        memset(data, 0, bmp->w * bmp->h * d_size);
        bmp->data = (ptr_u)data;
        bmp->palette = NULL;

        Assert(&be->bm == bmp);

        // make sure we are using the correct filename in the case of an EFF.
        // this will populate filename[] whether it's EFF or not
        EFF_FILENAME_CHECK;

        //bmp->bpp gets set correctly in here after reading into memory
        png_error = png_read_bitmap(filename, data, &bmp->bpp, d_size, be->dir_type);

        if (png_error != PNG_ERROR_NONE) {
                bm_free_data(bitmapnum);
                return;
        }

#ifdef BMPMAN_NDEBUG
        Assert(be->data_size > 0);
#endif
}

void bm_lock_tga(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        ubyte *data = NULL;
        int d_size, byte_size;
        char filename[MAX_FILENAME_LEN];

        // Unload any existing data
        bm_free_data(bitmapnum);

        if (Is_standalone) {
                Assert(bpp == 8);
        } else {
                Assert((bpp == 16) || (bpp == 24) || (bpp == 32));
        }

        // allocate bitmap data
        byte_size = (bpp >> 3);

        Assert(byte_size);
        Assert(be->mem_taken > 0);

        data = (ubyte*)bm_malloc(bitmapnum, be->mem_taken);

        if (data) {
                memset(data, 0, be->mem_taken);
                d_size = byte_size;
        } else {
                return;
        }

        bmp->bpp = bpp;
        bmp->data = (ptr_u)data;
        bmp->palette = NULL;

        Assert(&be->bm == bmp);
#ifdef BMPMAN_NDEBUG
        Assert(be->data_size > 0);
#endif

        int tga_error;

        // make sure we are using the correct filename in the case of an EFF.
        // this will populate filename[] whether it's EFF or not
        EFF_FILENAME_CHECK;

        tga_error = targa_read_bitmap(filename, data, NULL, d_size, be->dir_type);

        if (tga_error != TARGA_ERROR_NONE) {
                bm_free_data(bitmapnum);
                return;
        }

        bmp->flags = 0;

        bm_convert_format(bmp, flags);
}

void bm_lock_user(int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags) {
        // Unload any existing data
        bm_free_data(bitmapnum);

        if ((bpp != be->info.user.bpp) && !(flags & BMP_AABITMAP))
                bpp = be->info.user.bpp;

        switch (bpp) {
        case 32:        // user 32-bit bitmap
                bmp->bpp = bpp;
                bmp->flags = be->info.user.flags;
                bmp->data = (ptr_u)be->info.user.data;
                break;

        case 24:        // user 24-bit bitmap
                bmp->bpp = bpp;
                bmp->flags = be->info.user.flags;
                bmp->data = (ptr_u)be->info.user.data;
                break;

        case 16:                        // user 16 bit bitmap
                bmp->bpp = bpp;
                bmp->flags = be->info.user.flags;
                bmp->data = (ptr_u)be->info.user.data;
                break;

        case 8:                 // Going from 8 bpp to something (probably only for aabitmaps)
                Assert(flags & BMP_AABITMAP);
                bmp->bpp = bpp;
                bmp->flags = be->info.user.flags;
                bmp->data = (ptr_u)be->info.user.data;
                break;

        default:
                Error(LOCATION, "Unhandled user bitmap conversion from %d to %d bpp", be->info.user.bpp, bmp->bpp);
                break;
        }

        bm_convert_format(bmp, flags);
}

int bm_make_render_target(int width, int height, int flags) {
        int i, n;
        int mm_lvl = 0;
        // final w and h may be different from passed width and height
        int w = width, h = height;
        ubyte bpp = 32;
        int size = 0;

        if (!bm_inited)
                bm_init();

        // Find an open slot (starting from the end)
        for (n = -1, i = MAX_BITMAPS - 1; i >= 0; i--) {
                if (bm_bitmaps[i].type == BM_TYPE_NONE) {
                        n = i;
                        break;
                }
        }

        // Out of bitmap slots
        if (n == -1)
                return -1;

        if (!gr_bm_make_render_target(n, &w, &h, &bpp, &mm_lvl, flags))
                return -1;

        Assert(mm_lvl > 0);

        if (flags & BMP_FLAG_RENDER_TARGET_STATIC) {
                // data size
                size = (w * h * (bpp >> 3));

                if (mm_lvl > 1) {
                        // include size of all mipmap levels (there should be a full chain)
                        size += (size / 3) - 1;
                }

                // make sure to count all faces if a cubemap
                if (flags & BMP_FLAG_CUBEMAP) {
                        size *= 6;
                }
        }

        // ensure fields are cleared out from previous bitmap
        memset(&bm_bitmaps[n], 0, sizeof(bitmap_entry));

        bm_bitmaps[n].type = (flags & BMP_FLAG_RENDER_TARGET_STATIC) ? BM_TYPE_RENDER_TARGET_STATIC : BM_TYPE_RENDER_TARGET_DYNAMIC;
        bm_bitmaps[n].signature = Bm_next_signature++;
        sprintf(bm_bitmaps[n].filename, "RT_%dx%d+%d", w, h, bpp);
        bm_bitmaps[n].bm.w = (short)w;
        bm_bitmaps[n].bm.h = (short)h;
        bm_bitmaps[n].bm.rowsize = (short)w;
        bm_bitmaps[n].bm.bpp = (ubyte)bpp;
        bm_bitmaps[n].bm.true_bpp = (ubyte)bpp;
        bm_bitmaps[n].bm.flags = (ubyte)flags;
        bm_bitmaps[n].bm.data = 0;
        bm_bitmaps[n].bm.palette = NULL;
        bm_bitmaps[n].num_mipmaps = mm_lvl;
        bm_bitmaps[n].mem_taken = (size_t)size;
        bm_bitmaps[n].dir_type = CF_TYPE_ANY;

        bm_bitmaps[n].palette_checksum = 0;
        bm_bitmaps[n].handle = bm_get_next_handle() * MAX_BITMAPS + n;
        bm_bitmaps[n].last_used = -1;

        if (bm_bitmaps[n].mem_taken) {
                bm_bitmaps[n].bm.data = (ptr_u)bm_malloc(n, bm_bitmaps[n].mem_taken);
        }

        return bm_bitmaps[n].handle;
}

void *bm_malloc(int n, int size) {
        Assert((n >= 0) && (n < MAX_BITMAPS));

        if (size <= 0)
                return NULL;

#ifdef BMPMAN_NDEBUG
        Assert(bm_bitmaps[n].data_size == 0);
        bm_bitmaps[n].data_size += size;
        bm_texture_ram += size;
#endif

        return vm_malloc(size);
}

void bm_page_in_aabitmap(int bitmapnum, int nframes) {
        int i;
        int n = bitmapnum % MAX_BITMAPS;

        if (n == -1)
                return;

        Assert(bm_bitmaps[n].handle == bitmapnum);

        for (i = 0; i<nframes; i++) {
                bm_bitmaps[n + i].preloaded = 2;

                bm_bitmaps[n + i].preload_count++;

                bm_bitmaps[n + i].used_flags = BMP_AABITMAP;
        }
}

void bm_page_in_start() {
        int i;

        Bm_paging = 1;

        // Mark all as inited
        for (i = 0; i < MAX_BITMAPS; i++) {
                if (!Cmdline_cache_bitmaps && (bm_bitmaps[i].type != BM_TYPE_NONE)) {
                        bm_unload_fast(bm_bitmaps[i].handle);
                }
                bm_bitmaps[i].preloaded = 0;
                bm_bitmaps[i].preload_count = 0;
#ifdef BMPMAN_NDEBUG
                bm_bitmaps[i].used_count = 0;
#endif
                bm_bitmaps[i].used_flags = 0;
        }

        gr_bm_page_in_start();
}

void bm_page_in_stop() {
        int i;

#ifndef NDEBUG
        char busy_text[60];
#endif

        nprintf(("BmpInfo", "BMPMAN: Loading all used bitmaps.\n"));

        // Load all the ones that are supposed to be loaded for this level.
        int n = 0;

        int bm_preloading = 1;

        for (i = 0; i < MAX_BITMAPS; i++) {
                if ((bm_bitmaps[i].type != BM_TYPE_NONE) && (bm_bitmaps[i].type != BM_TYPE_RENDER_TARGET_DYNAMIC) && (bm_bitmaps[i].type != BM_TYPE_RENDER_TARGET_STATIC)) {
                        if (bm_bitmaps[i].preloaded) {
                                if (bm_preloading) {
                                        if (!gr_preload(bm_bitmaps[i].handle, (bm_bitmaps[i].preloaded == 2))) {
                                                mprintf(("Out of VRAM.  Done preloading.\n"));
                                                bm_preloading = 0;
                                        }
                                } else {
                                        bm_lock(bm_bitmaps[i].handle, (bm_bitmaps[i].used_flags == BMP_AABITMAP) ? 8 : 16, bm_bitmaps[i].used_flags);
                                        if (bm_bitmaps[i].ref_count >= 1) {
                                                bm_unlock( bm_bitmaps[i].handle );
                                        }
                                }

                                n++;

                                multi_send_anti_timeout_ping();

                                if ((bm_bitmaps[i].info.ani.first_frame == 0) || (bm_bitmaps[i].info.ani.first_frame == i)) {
#ifndef NDEBUG
                                        memset(busy_text, 0, sizeof(busy_text));

                                        strcat_s(busy_text, "** BmpMan: ");
                                        strcat_s(busy_text, bm_bitmaps[i].filename);
                                        strcat_s(busy_text, " **");

                                        game_busy(busy_text);
#else
                                        game_busy();
#endif
                                }
                        } else {
                                bm_unload_fast(bm_bitmaps[i].handle);
                        }
                }
        }

        nprintf(("BmpInfo", "BMPMAN: Loaded %d bitmaps that are marked as used for this level.\n", n));

        int total_bitmaps = 0;
        for (i = 0; i < MAX_BITMAPS; i++) {
                if (bm_bitmaps[i].type != BM_TYPE_NONE) {
                        total_bitmaps++;
                }
                if (bm_bitmaps[i].type == BM_TYPE_USER) {
                        mprintf(("User bitmap '%s'\n", bm_bitmaps[i].filename));
                }
        }

        mprintf(("Bmpman: %d/%d bitmap slots in use.\n", total_bitmaps, MAX_BITMAPS));

        Bm_paging = 0;
}

void bm_page_in_texture(int bitmapnum, int nframes) {
        int i;
        int n = bitmapnum % MAX_BITMAPS;

        if (bitmapnum < 0)
                return;

        Assertion((bm_bitmaps[n].handle == bitmapnum), "bitmapnum = %i, n = %i, bm_bitmaps[n].handle = %i", bitmapnum, n, bm_bitmaps[n].handle);

        if (nframes <= 0) {
                if ((bm_bitmaps[n].type == BM_TYPE_ANI) || (bm_bitmaps[n].type == BM_TYPE_EFF))
                        nframes = bm_bitmaps[n].info.ani.num_frames;
                else
                        nframes = 1;
        }

        for (i = 0; i < nframes; i++) {
                bm_bitmaps[n + i].preloaded = 1;

                bm_bitmaps[n + i].preload_count++;

                bm_bitmaps[n + i].used_flags = BMP_TEX_OTHER;

                //check if its compressed
                switch (bm_bitmaps[n + i].comp_type) {
                case BM_TYPE_NONE:
                        continue;

                case BM_TYPE_DXT1:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_DXT1;
                        continue;

                case BM_TYPE_DXT3:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_DXT3;
                        continue;

                case BM_TYPE_DXT5:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_DXT5;
                        continue;

                case BM_TYPE_CUBEMAP_DXT1:
                case BM_TYPE_CUBEMAP_DXT3:
                case BM_TYPE_CUBEMAP_DXT5:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_CUBEMAP;
                        continue;

                default:
                        continue;
                }
        }
}

void bm_page_in_xparent_texture(int bitmapnum, int nframes) {
        int i;
        int n = bitmapnum % MAX_BITMAPS;

        if (n == -1)
                return;

        Assert(bm_bitmaps[n].handle == bitmapnum);

        for (i = 0; i < nframes; i++) {
                bm_bitmaps[n + i].preloaded = 3;

                bm_bitmaps[n + i].preload_count++;

                bm_bitmaps[n + i].used_flags = BMP_TEX_XPARENT;

                //check if its compressed
                switch (bm_bitmaps[n + i].comp_type) {
                case BM_TYPE_NONE:
                        continue;

                case BM_TYPE_DXT1:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_DXT1;
                        continue;

                case BM_TYPE_DXT3:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_DXT3;
                        continue;

                case BM_TYPE_DXT5:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_DXT5;
                        continue;

                case BM_TYPE_CUBEMAP_DXT1:
                case BM_TYPE_CUBEMAP_DXT3:
                case BM_TYPE_CUBEMAP_DXT5:
                        bm_bitmaps[n + i].used_flags = BMP_TEX_CUBEMAP;
                        continue;

                default:
                        continue;
                }
        }
}

bool bm_page_out(int handle) {
        int n = handle % MAX_BITMAPS;

        Assert(n >= 0);
        Assert(handle == bm_bitmaps[n].handle);

        // in case it's already been released
        if (bm_bitmaps[n].type == BM_TYPE_NONE)
                return 0;

        // it's possible to hit < 0 here when model_page_out_textures() is
        // called from anywhere other than in a mission
        if (bm_bitmaps[n].preload_count > 0) {
                nprintf(("BmpMan",
                         "PAGE-OUT: %s - preload_count remaining: %d\n",
                         bm_bitmaps[n].filename,
                         bm_bitmaps[n].preload_count));

                // lets decrease it for next time around
                bm_bitmaps[n].preload_count--;

                return 0;
        }

        return (bm_unload(handle) == 1);
}

void bm_print_bitmaps() {
#ifdef BMPMAN_NDEBUG
        int i;

        for (i = 0; i<MAX_BITMAPS; i++) {
                if (bm_bitmaps[i].type != BM_TYPE_NONE) {
                        if (bm_bitmaps[i].data_size) {
                                nprintf(("BMP DEBUG", "BMPMAN = num: %d, name: %s, handle: %d - (%s) size: %.3fM\n", i, bm_bitmaps[i].filename, bm_bitmaps[i].handle, bm_bitmaps[i].data_size ? NOX("*LOCKED*") : NOX(""), ((float)bm_bitmaps[i].data_size / 1024.0f) / 1024.0f));
                        } else {
                                nprintf(("BMP DEBUG", "BMPMAN = num: %d, name: %s, handle: %d\n", i, bm_bitmaps[i].filename, bm_bitmaps[i].handle));
                        }
                }
        }
        nprintf(("BMP DEBUG", "BMPMAN = LOCKED memory usage: %.3fM\n", ((float)bm_texture_ram / 1024.0f) / 1024.0f));
#endif
}

int bm_release(int handle, int clear_render_targets) {
        Assert(handle >= 0);

        bitmap_entry *be;

        int n = handle % MAX_BITMAPS;

        Assert((n >= 0) && (n < MAX_BITMAPS));
        be = &bm_bitmaps[n];

        if (be->type == BM_TYPE_NONE) {
                return 0;       // Already been released?
        }

        Assertion(be->handle == handle, "Invalid bitmap handle number %d (expected %d) for %s passed to bm_release()\n", be->handle, handle, be->filename);

        if (!clear_render_targets && ((be->type == BM_TYPE_RENDER_TARGET_STATIC) || (be->type == BM_TYPE_RENDER_TARGET_DYNAMIC))) {
                nprintf(("BmpMan", "Tried to release a render target!\n"));
                return 0;
        }

        // If it is locked, cannot free it.
        if (be->ref_count != 0) {
                nprintf(("BmpMan", "Tried to release %s that has a lock count of %d.. not releasing\n", be->filename, be->ref_count));
                return 0;
        }

        // kind of like ref_count except it gets around the lock/unlock usage problem
        // this gets set for each bm_load() call so we can make sure and not unload it
        // from memory, even if we *can*, until it's really not needed anymore
        if (be->load_count > 0)
                be->load_count--;

        if (be->load_count != 0) {
                nprintf(("BmpMan", "Tried to release %s that has a load count of %d.. not releasing\n", be->filename, be->load_count + 1));
                return 0;
        }

        if (be->type != BM_TYPE_USER) {
                nprintf(("BmpMan", "Releasing bitmap %s in slot %i with handle %i\n", be->filename, n, handle));
        }

        // be sure that all frames of an ani are unloaded - taylor
        if ((be->type == BM_TYPE_ANI) || (be->type == BM_TYPE_EFF)) {
                int i, first = be->info.ani.first_frame, total = bm_bitmaps[first].info.ani.num_frames;

                for (i = 0; i < total; i++) {
                        bm_free_data(first + i, true);          // clears flags, bbp, data, etc

                        memset(&bm_bitmaps[first + i], 0, sizeof(bitmap_entry));

                        bm_bitmaps[first + i].type = BM_TYPE_NONE;
                        bm_bitmaps[first + i].comp_type = BM_TYPE_NONE;
                        bm_bitmaps[first + i].dir_type = CF_TYPE_ANY;
                        // Fill in bogus structures!

                        // For debugging:
                        strcpy_s(bm_bitmaps[first + i].filename, "IVE_BEEN_RELEASED!");
                        bm_bitmaps[first + i].signature = 0xDEADBEEF;                                                                   // a unique signature identifying the data
                        bm_bitmaps[first + i].palette_checksum = 0xDEADBEEF;                                                    // checksum used to be sure bitmap is in current palette

                        // bookeeping
                        bm_bitmaps[first + i].ref_count = -1;                                                                   // Number of locks on bitmap.  Can't unload unless ref_count is 0.

                        // Stuff needed for animations
                        bm_bitmaps[first + i].info.ani.first_frame = -1;

                        bm_bitmaps[first + i].handle = -1;
                }
        } else {
                bm_free_data(n, true);          // clears flags, bbp, data, etc

                memset(&bm_bitmaps[n], 0, sizeof(bitmap_entry));

                bm_bitmaps[n].type = BM_TYPE_NONE;
                bm_bitmaps[n].comp_type = BM_TYPE_NONE;
                bm_bitmaps[n].dir_type = CF_TYPE_ANY;
                // Fill in bogus structures!

                // For debugging:
                strcpy_s(bm_bitmaps[n].filename, "IVE_BEEN_RELEASED!");
                bm_bitmaps[n].signature = 0xDEADBEEF;                                                                   // a unique signature identifying the data
                bm_bitmaps[n].palette_checksum = 0xDEADBEEF;                                                    // checksum used to be sure bitmap is in current palette

                // bookeeping
                bm_bitmaps[n].ref_count = -1;                                                                   // Number of locks on bitmap.  Can't unload unless ref_count is 0.

                // Stuff needed for animations
                bm_bitmaps[n].info.ani.first_frame = -1;

                bm_bitmaps[n].handle = -1;
        }

        return 1;
}

int bm_reload(int bitmap_handle, const char* filename) {
        if (!bm_inited)
                bm_init();

        // if no file was passed then get out now
        if ((filename == NULL) || (strlen(filename) <= 0))
                return -1;

        int bitmapnum = bitmap_handle % MAX_BITMAPS;

        if (bm_bitmaps[bitmapnum].type == BM_TYPE_NONE)
                return -1;

        if (bm_bitmaps[bitmapnum].ref_count) {
                nprintf(("BmpMan", "Trying to reload a bitmap that is still locked. Filename: %s, ref_count: %d", bm_bitmaps[bitmapnum].filename, bm_bitmaps[bitmapnum].ref_count));
                return -1;
        }

        strcpy_s(bm_bitmaps[bitmapnum].filename, filename);
        return bitmap_handle;
}

void BM_SELECT_ALPHA_TEX_FORMAT() {
        Gr_current_red = &Gr_ta_red;
        Gr_current_green = &Gr_ta_green;
        Gr_current_blue = &Gr_ta_blue;
        Gr_current_alpha = &Gr_ta_alpha;

        // setup pointers
        bm_set_components_32 = bm_set_components_argb_32_tex;
        // should always assume that 16-bit is the default request
        bm_set_components = bm_set_components_argb_16_tex;
}

void BM_SELECT_SCREEN_FORMAT() {
        Gr_current_red = &Gr_red;
        Gr_current_green = &Gr_green;
        Gr_current_blue = &Gr_blue;
        Gr_current_alpha = &Gr_alpha;

        // setup pointers
        bm_set_components_32 = bm_set_components_argb_32_screen;
        // should always assume that 16-bit is the default request
        bm_set_components = bm_set_components_argb_16_screen;
}

void BM_SELECT_TEX_FORMAT() {
        Gr_current_red = &Gr_t_red;
        Gr_current_green = &Gr_t_green;
        Gr_current_blue = &Gr_t_blue;
        Gr_current_alpha = &Gr_t_alpha;

        // setup pointers
        bm_set_components_32 = bm_set_components_argb_32_tex;
        // should always assume that 16-bit is the default request
        bm_set_components = bm_set_components_argb_16_tex;
}

void bm_set_components_argb_16_screen(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av) {
        if (*av == 0) {
                *((unsigned short*)pixel) = (unsigned short)Gr_current_green->mask;
                return;
        }

        *((unsigned short*)pixel) = (unsigned short)(((int)*rv / Gr_current_red->scale) << Gr_current_red->shift);
        *((unsigned short*)pixel) |= (unsigned short)(((int)*gv / Gr_current_green->scale) << Gr_current_green->shift);
        *((unsigned short*)pixel) |= (unsigned short)(((int)*bv / Gr_current_blue->scale) << Gr_current_blue->shift);
}

void bm_set_components_argb_16_tex(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av) {
        if (*av == 0) {
                *((unsigned short*)pixel) = 0;
                return;
        }

        *((unsigned short*)pixel) = (unsigned short)(((int)*rv / Gr_current_red->scale) << Gr_current_red->shift);
        *((unsigned short*)pixel) |= (unsigned short)(((int)*gv / Gr_current_green->scale) << Gr_current_green->shift);
        *((unsigned short*)pixel) |= (unsigned short)(((int)*bv / Gr_current_blue->scale) << Gr_current_blue->shift);
        *((unsigned short*)pixel) |= (unsigned short)(Gr_current_alpha->mask);
}

void bm_set_components_argb_32_screen(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av) {
        if (*av == 0) {
                *((unsigned int*)pixel) = (unsigned int)Gr_current_green->mask;
                return;
        }

        *((unsigned int*)pixel) = (unsigned int)(((int)*rv / Gr_current_red->scale) << Gr_current_red->shift);
        *((unsigned int*)pixel) |= (unsigned int)(((int)*gv / Gr_current_green->scale) << Gr_current_green->shift);
        *((unsigned int*)pixel) |= (unsigned int)(((int)*bv / Gr_current_blue->scale) << Gr_current_blue->shift);
}

void bm_set_components_argb_32_tex(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av) {
        if (*av == 0) {
                *((unsigned int*)pixel) = 0;
                return;
        }

        *((unsigned int*)pixel) = (unsigned int)(((int)*rv / Gr_current_red->scale) << Gr_current_red->shift);
        *((unsigned int*)pixel) |= (unsigned int)(((int)*gv / Gr_current_green->scale) << Gr_current_green->shift);
        *((unsigned int*)pixel) |= (unsigned int)(((int)*bv / Gr_current_blue->scale) << Gr_current_blue->shift);
        *((unsigned int*)pixel) |= (unsigned int)(Gr_current_alpha->mask);
}

void bm_set_low_mem(int mode) {
        Assert((mode >= 0) && (mode <= 2));

        CLAMP(mode, 0, 2);
        Bm_low_mem = mode;
}

bool bm_set_render_target(int handle, int face) {
        int n = handle % MAX_BITMAPS;

        if (n >= 0) {
                Assert(handle == bm_bitmaps[n].handle);

                if ((bm_bitmaps[n].type != BM_TYPE_RENDER_TARGET_STATIC) && (bm_bitmaps[n].type != BM_TYPE_RENDER_TARGET_DYNAMIC)) {
                        // odds are that someone passed a normal texture created with bm_load()
                        mprintf(("Trying to set invalid bitmap (slot: %i, handle: %i) as render target!\n", n, handle));
                        return false;
                }
        }

        if (gr_bm_set_render_target(n, face)) {
                if (gr_screen.rendering_to_texture == -1) {
                        //if we are moving from the back buffer to a texture save whatever the current settings are
                        gr_screen.save_max_w = gr_screen.max_w;
                        gr_screen.save_max_h = gr_screen.max_h;

                        gr_screen.save_max_w_unscaled = gr_screen.max_w_unscaled;
                        gr_screen.save_max_h_unscaled = gr_screen.max_h_unscaled;

                        gr_screen.save_max_w_unscaled_zoomed = gr_screen.max_w_unscaled_zoomed;
                        gr_screen.save_max_h_unscaled_zoomed = gr_screen.max_h_unscaled_zoomed;

                        gr_screen.save_center_w = gr_screen.center_w;
                        gr_screen.save_center_h = gr_screen.center_h;

                        gr_screen.save_center_offset_x = gr_screen.center_offset_x;
                        gr_screen.save_center_offset_y = gr_screen.center_offset_y;
                }

                if (n < 0) {
                        gr_screen.max_w = gr_screen.save_max_w;
                        gr_screen.max_h = gr_screen.save_max_h;

                        gr_screen.max_w_unscaled = gr_screen.save_max_w_unscaled;
                        gr_screen.max_h_unscaled = gr_screen.save_max_h_unscaled;

                        gr_screen.max_w_unscaled_zoomed = gr_screen.save_max_w_unscaled_zoomed;
                        gr_screen.max_h_unscaled_zoomed = gr_screen.save_max_h_unscaled_zoomed;

                        gr_screen.center_w = gr_screen.save_center_w;
                        gr_screen.center_h = gr_screen.save_center_h;

                        gr_screen.center_offset_x = gr_screen.save_center_offset_x;
                        gr_screen.center_offset_y = gr_screen.save_center_offset_y;
                } else {
                        gr_screen.max_w = bm_bitmaps[n].bm.w;
                        gr_screen.max_h = bm_bitmaps[n].bm.h;

                        gr_screen.max_w_unscaled = bm_bitmaps[n].bm.w;
                        gr_screen.max_h_unscaled = bm_bitmaps[n].bm.h;

                        gr_screen.max_w_unscaled_zoomed = bm_bitmaps[n].bm.w;
                        gr_screen.max_h_unscaled_zoomed = bm_bitmaps[n].bm.h;

                        gr_screen.center_w = bm_bitmaps[n].bm.w;
                        gr_screen.center_h = bm_bitmaps[n].bm.h;

                        gr_screen.center_offset_x = 0;
                        gr_screen.center_offset_y = 0;
                }

                gr_screen.rendering_to_face = face;
                gr_screen.rendering_to_texture = n;

                gr_reset_clip();

                if (gr_screen.mode == GR_OPENGL) {
                        extern void opengl_setup_viewport();
                        opengl_setup_viewport();
                }

                return true;
        }

        return false;
}

int bm_unload(int handle, int clear_render_targets, bool nodebug) {
        bitmap_entry *be;
        bitmap *bmp;

        int n = handle % MAX_BITMAPS;

        Assert((n >= 0) && (n < MAX_BITMAPS));
        be = &bm_bitmaps[n];
        bmp = &be->bm;

        if (!clear_render_targets && ((be->type == BM_TYPE_RENDER_TARGET_STATIC) || (be->type == BM_TYPE_RENDER_TARGET_DYNAMIC))) {
                return -1;
        }

        if (be->type == BM_TYPE_NONE) {
                return -1;              // Already been released
        }

        Assert(be->handle == handle);           // INVALID BITMAP HANDLE!

        // If it is locked, cannot free it.
        if (be->ref_count != 0 && !nodebug) {
                nprintf(("BmpMan", "Tried to unload %s that has a lock count of %d.. not unloading\n", be->filename, be->ref_count));
                return 0;
        }

        // kind of like ref_count except it gets around the lock/unlock usage problem
        // this gets set for each bm_load() call so we can make sure and not unload it
        // from memory, even if we *can*, until it's really not needed anymore
        if (!Bm_ignore_load_count) {
                if (be->load_count > 0)
                        be->load_count--;

                if (be->load_count != 0 && !nodebug) {
                        nprintf(("BmpMan", "Tried to unload %s that has a load count of %d.. not unloading\n", be->filename, be->load_count + 1));
                        return 0;
                }
        }

        // be sure that all frames of an ani are unloaded - taylor
        if ((be->type == BM_TYPE_ANI) || (be->type == BM_TYPE_EFF)) {
                int i, first = be->info.ani.first_frame;

                // for the unload all case, don't try to unload every frame of every frame
                // all additional frames automatically get unloaded with the first one
                if ((n > be->info.ani.first_frame) && (bm_bitmaps[first].bm.data == 0))
                        return 1;

                for (i = 0; i < bm_bitmaps[first].info.ani.num_frames; i++) {
                        if (!nodebug)
                                nprintf(("BmpMan", "Unloading %s frame %d.  %dx%dx%d\n", be->filename, i, bmp->w, bmp->h, bmp->bpp));
                        bm_free_data(first + i);                // clears flags, bbp, data, etc
                }
        } else {
                if (!nodebug)
                        nprintf(("BmpMan", "Unloading %s.  %dx%dx%d\n", be->filename, bmp->w, bmp->h, bmp->bpp));
                bm_free_data(n);                // clears flags, bbp, data, etc
        }

        return 1;
}

void bm_unload_all() {
        int i;

        // since bm_unload_all() should only be called from game_shutdown() it should be
        // safe to ignore load_count's and unload anyway
        Bm_ignore_load_count = 1;

        for (i = 0; i < MAX_BITMAPS; i++) {
                if (bm_bitmaps[i].type != BM_TYPE_NONE) {
                        bm_unload(bm_bitmaps[i].handle, 1);
                }
        }

        Bm_ignore_load_count = 0;
}

int bm_unload_fast(int handle, int clear_render_targets) {
        bitmap_entry *be;
        bitmap *bmp;

        int n = handle % MAX_BITMAPS;

        Assert((n >= 0) && (n < MAX_BITMAPS));
        be = &bm_bitmaps[n];
        bmp = &be->bm;

        if (be->type == BM_TYPE_NONE) {
                return -1;              // Already been released
        }

        if (be->type == BM_TYPE_USER) {
                return -1;
        }

        if (!clear_render_targets && ((be->type == BM_TYPE_RENDER_TARGET_STATIC) || (be->type == BM_TYPE_RENDER_TARGET_DYNAMIC))) {
                return -1;
        }

        // If it is locked, cannot free it.
        if (be->ref_count != 0) {
                nprintf(("BmpMan", "Tried to unload_fast %s that has a lock count of %d.. not unloading\n", be->filename, be->ref_count));
                return 0;
        }

        Assert(be->handle == handle);           // INVALID BITMAP HANDLE!

        // unlike bm_unload(), we handle each frame of an animation separately, for safer use in the graphics API
        nprintf(("BmpMan", "Fast-unloading %s.  %dx%dx%d\n", be->filename, bmp->w, bmp->h, bmp->bpp));
        bm_free_data_fast(n);           // clears flags, bbp, data, etc

        return 1;
}

void bm_unlock(int handle) {
        bitmap_entry    *be;

        if (!bm_inited) bm_init();

        int bitmapnum = handle % MAX_BITMAPS;

#ifndef NDEBUG
        if (bm_bitmaps[bitmapnum].handle != handle) {
                mprintf(("bm_unlock - %s: bm_bitmaps[%d].handle = %d, handle = %d\n", bm_bitmaps[bitmapnum].filename, bitmapnum, bm_bitmaps[bitmapnum].handle, handle));
        }
#endif

        Assert(bm_bitmaps[bitmapnum].handle == handle); // INVALID BITMAP HANDLE

        Assert((bitmapnum >= 0) && (bitmapnum < MAX_BITMAPS));

        be = &bm_bitmaps[bitmapnum];

        be->ref_count--;
        Assert(be->ref_count >= 0);             // Trying to unlock data more times than lock was called!!!
}

void bm_update_memory_used(int n, int size)
{
        Assert( (n >= 0) && (n < MAX_BITMAPS) );
        Assert( size >= 0 );

#ifdef BMPMAN_NDEBUG
        Assert( bm_bitmaps[n].data_size == 0 );
        bm_bitmaps[n].data_size += size;
        bm_texture_ram += size;
#endif
}

int find_block_of(int n)
{
        int i, cnt = 0, nstart = 0;

        if (n < 1) {
                Int3();
                return -1;
        }

        for (i = 0; i < MAX_BITMAPS; i++) {
                if (bm_bitmaps[i].type == BM_TYPE_NONE) {
                        if (cnt == 0)
                                nstart = i;

                        cnt++;
                } else {
                        cnt = 0;
                }

                if (cnt == n)
                        return nstart;
        }

        return -1;
}