[mupen64plus-pandora.git] / source / gles2glide64 / src / GlideHQ / TxCache.cpp

/*
 * Texture Filtering
 * Version:  1.0
 *
 * Copyright (C) 2007  Hiroshi Morii   All Rights Reserved.
 * Email koolsmoky(at)users.sourceforge.net
 * Web   http://www.3dfxzone.it/koolsmoky
 *
 * this is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * this is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNU Make; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifdef __MSC__
#pragma warning(disable: 4786)
#endif

#include <boost/filesystem.hpp>
#include <zlib.h>
#include "TxCache.h"
#include "TxDbg.h"
#include "../Glide64/m64p.h"
#include "../Glide64/Gfx_1.3.h"

TxCache::~TxCache()
{
  /* free memory, clean up, etc */
  clear();

  delete _txUtil;
}

TxCache::TxCache(int options, int cachesize, const wchar_t *datapath,
                 const wchar_t *cachepath, const wchar_t *ident,
                 dispInfoFuncExt callback)
{
  _txUtil = new TxUtil();

  _options = options;
  _cacheSize = cachesize;
  _callback = callback;
  _totalSize = 0;

  /* save path name */
  if (datapath)
    _datapath.assign(datapath);
  if (cachepath)
    _cachepath.assign(cachepath);

  /* save ROM name */
  if (ident)
    _ident.assign(ident);

  /* zlib memory buffers to (de)compress hires textures */
  if (_options & (GZ_TEXCACHE|GZ_HIRESTEXCACHE)) {
    _gzdest0   = TxMemBuf::getInstance()->get(0);
    _gzdest1   = TxMemBuf::getInstance()->get(1);
    _gzdestLen = (TxMemBuf::getInstance()->size_of(0) < TxMemBuf::getInstance()->size_of(1)) ?
                  TxMemBuf::getInstance()->size_of(0) : TxMemBuf::getInstance()->size_of(1);

    if (!_gzdest0 || !_gzdest1 || !_gzdestLen) {
      _options &= ~(GZ_TEXCACHE|GZ_HIRESTEXCACHE);
      _gzdest0 = NULL;
      _gzdest1 = NULL;
      _gzdestLen = 0;
    }
  }
}

boolean
TxCache::add(uint64 checksum, GHQTexInfo *info, int dataSize)
{
  /* NOTE: dataSize must be provided if info->data is zlib compressed. */

  if (!checksum || !info->data) return 0;

  uint8 *dest = info->data;
  uint16 format = info->format;

  if (!dataSize) {
    dataSize = _txUtil->sizeofTx(info->width, info->height, info->format);

    if (!dataSize) return 0;

    if (_options & (GZ_TEXCACHE|GZ_HIRESTEXCACHE)) {
      /* zlib compress it. compression level:1 (best speed) */
      uLongf destLen = _gzdestLen;
      dest = (dest == _gzdest0) ? _gzdest1 : _gzdest0;
      if (compress2(dest, &destLen, info->data, dataSize, 1) != Z_OK) {
        dest = info->data;
        DBG_INFO(80, L"Error: zlib compression failed!\n");
      } else {
        DBG_INFO(80, L"zlib compressed: %.02fkb->%.02fkb\n", (float)dataSize/1000, (float)destLen/1000);
        dataSize = destLen;
        format |= GR_TEXFMT_GZ;
      }
    }
  }

  /* if cache size exceeds limit, remove old cache */
  if (_cacheSize > 0) {
    _totalSize += dataSize;
    if ((_totalSize > _cacheSize) && !_cachelist.empty()) {
      /* _cachelist is arranged so that frequently used textures are in the back */
      std::list<uint64>::iterator itList = _cachelist.begin();
      while (itList != _cachelist.end()) {
        /* find it in _cache */
        std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(*itList);
        if (itMap != _cache.end()) {
          /* yep we have it. remove it. */
          _totalSize -= (*itMap).second->size;
          free((*itMap).second->info.data);
          delete (*itMap).second;
          _cache.erase(itMap);
        }
        itList++;

        /* check if memory cache has enough space */
        if (_totalSize <= _cacheSize)
          break;
      }
      /* remove from _cachelist */
      _cachelist.erase(_cachelist.begin(), itList);

      DBG_INFO(80, L"+++++++++\n");
    }
    _totalSize -= dataSize;
  }

  /* cache it */
  uint8 *tmpdata = (uint8*)malloc(dataSize);
  if (tmpdata) {
    TXCACHE *txCache = new TXCACHE;
    if (txCache) {
      /* we can directly write as we filter, but for now we get away
       * with doing memcpy after all the filtering is done.
       */
      memcpy(tmpdata, dest, dataSize);

      /* copy it */
      memcpy(&txCache->info, info, sizeof(GHQTexInfo));
      txCache->info.data = tmpdata;
      txCache->info.format = format;
      txCache->size = dataSize;

      /* add to cache */
      if (_cacheSize > 0) {
        _cachelist.push_back(checksum);
        txCache->it = --(_cachelist.end());
      }
      /* _cache[checksum] = txCache; */
      _cache.insert(std::map<uint64, TXCACHE*>::value_type(checksum, txCache));

#ifdef DEBUG
      DBG_INFO(80, L"[%5d] added!! crc:%08X %08X %d x %d gfmt:%x total:%.02fmb\n",
               _cache.size(), (uint32)(checksum >> 32), (uint32)(checksum & 0xffffffff),
               info->width, info->height, info->format, (float)_totalSize/1000000);

      DBG_INFO(80, L"smalllodlog2:%d largelodlog2:%d aspectratiolog2:%d\n",
               txCache->info.smallLodLog2, txCache->info.largeLodLog2, txCache->info.aspectRatioLog2);

      if (info->tiles) {
        DBG_INFO(80, L"tiles:%d un-tiled size:%d x %d\n", info->tiles, info->untiled_width, info->untiled_height);
      }

      if (_cacheSize > 0) {
        DBG_INFO(80, L"cache max config:%.02fmb\n", (float)_cacheSize/1000000);

        if (_cache.size() != _cachelist.size()) {
          DBG_INFO(80, L"Error: cache/cachelist mismatch! (%d/%d)\n", _cache.size(), _cachelist.size());
        }
      }
#endif

      /* total cache size */
      _totalSize += dataSize;

      return 1;
    }
    free(tmpdata);
  }

  return 0;
}

boolean
TxCache::get(uint64 checksum, GHQTexInfo *info)
{
  if (!checksum || _cache.empty()) return 0;

  /* find a match in cache */
  std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(checksum);
  if (itMap != _cache.end()) {
    /* yep, we've got it. */
    memcpy(info, &(((*itMap).second)->info), sizeof(GHQTexInfo));

    /* push it to the back of the list */
    if (_cacheSize > 0) {
      _cachelist.erase(((*itMap).second)->it);
      _cachelist.push_back(checksum);
      ((*itMap).second)->it = --(_cachelist.end());
    }

    /* zlib decompress it */
    if (info->format & GR_TEXFMT_GZ) {
      uLongf destLen = _gzdestLen;
      uint8 *dest = (_gzdest0 == info->data) ? _gzdest1 : _gzdest0;
      if (uncompress(dest, &destLen, info->data, ((*itMap).second)->size) != Z_OK) {
        DBG_INFO(80, L"Error: zlib decompression failed!\n");
        return 0;
      }
      info->data = dest;
      info->format &= ~GR_TEXFMT_GZ;
      DBG_INFO(80, L"zlib decompressed: %.02fkb->%.02fkb\n", (float)(((*itMap).second)->size)/1000, (float)destLen/1000);
    }

    return 1;
  }

  return 0;
}

boolean
TxCache::save(const wchar_t *path, const wchar_t *filename, int config)
{
  if (!_cache.empty()) {
    /* dump cache to disk */
    char cbuf[MAX_PATH];

    boost::filesystem::wpath cachepath(path);
    boost::filesystem::create_directory(cachepath);

    /* Ugly hack to enable fopen/gzopen in Win9x */
#ifdef BOOST_WINDOWS_API
    wchar_t curpath[MAX_PATH];
    GETCWD(MAX_PATH, curpath);
    CHDIR(cachepath.wstring().c_str());
#else
    char curpath[MAX_PATH];
    wcstombs(cbuf, cachepath.wstring().c_str(), MAX_PATH);
    if (GETCWD(MAX_PATH, curpath) == NULL)
        ERRLOG("Error while retrieving working directory!");
    if (CHDIR(cbuf) != 0)
        ERRLOG("Error while changing current directory to '%s'!", cbuf);
#endif

    wcstombs(cbuf, filename, MAX_PATH);

    gzFile gzfp = gzopen(cbuf, "wb1");
    DBG_INFO(80, L"gzfp:%x file:%ls\n", gzfp, filename);
    if (gzfp) {
      /* write header to determine config match */
      gzwrite(gzfp, &config, 4);

      std::map<uint64, TXCACHE*>::iterator itMap = _cache.begin();
      while (itMap != _cache.end()) {
        uint8 *dest    = (*itMap).second->info.data;
        uint32 destLen = (*itMap).second->size;
        uint16 format  = (*itMap).second->info.format;

        /* to keep things simple, we save the texture data in a zlib uncompressed state. */
        /* sigh... for those who cannot wait the extra few seconds. changed to keep
         * texture data in a zlib compressed state. if the GZ_TEXCACHE or GZ_HIRESTEXCACHE
         * option is toggled, the cache will need to be rebuilt.
         */
        /*if (format & GR_TEXFMT_GZ) {
          dest = _gzdest0;
          destLen = _gzdestLen;
          if (dest && destLen) {
            if (uncompress(dest, &destLen, (*itMap).second->info.data, (*itMap).second->size) != Z_OK) {
              dest = NULL;
              destLen = 0;
            }
            format &= ~GR_TEXFMT_GZ;
          }
        }*/

        if (dest && destLen) {
          /* texture checksum */
          gzwrite(gzfp, &((*itMap).first), 8);

          /* other texture info */
          gzwrite(gzfp, &((*itMap).second->info.width), 4);
          gzwrite(gzfp, &((*itMap).second->info.height), 4);
          gzwrite(gzfp, &format, 2);

          gzwrite(gzfp, &((*itMap).second->info.smallLodLog2), 4);
          gzwrite(gzfp, &((*itMap).second->info.largeLodLog2), 4);
          gzwrite(gzfp, &((*itMap).second->info.aspectRatioLog2), 4);

          gzwrite(gzfp, &((*itMap).second->info.tiles), 4);
          gzwrite(gzfp, &((*itMap).second->info.untiled_width), 4);
          gzwrite(gzfp, &((*itMap).second->info.untiled_height), 4);

          gzwrite(gzfp, &((*itMap).second->info.is_hires_tex), 1);

          gzwrite(gzfp, &destLen, 4);
          gzwrite(gzfp, dest, destLen);
        }

        itMap++;

        /* not ready yet */
        /*if (_callback)
          (*_callback)(L"Total textures saved to HDD: %d\n", std::distance(itMap, _cache.begin()));*/
      }
      gzclose(gzfp);
    }

    if (CHDIR(curpath) != 0)
        ERRLOG("Error while changing current directory back to original path of '%s'!", curpath);
  }

  return _cache.empty();
}

boolean
TxCache::load(const wchar_t *path, const wchar_t *filename, int config)
{
  /* find it on disk */
  char cbuf[MAX_PATH];

  boost::filesystem::wpath cachepath(path);

#ifdef BOOST_WINDOWS_API
  wchar_t curpath[MAX_PATH];
  GETCWD(MAX_PATH, curpath);
  CHDIR(cachepath.wstring().c_str());
#else
  char curpath[MAX_PATH];
  wcstombs(cbuf, cachepath.wstring().c_str(), MAX_PATH);
  if (GETCWD(MAX_PATH, curpath) == NULL)
      ERRLOG("Error while retrieving working directory!");
  if (CHDIR(cbuf) != 0)
      ERRLOG("Error while changing current directory to '%s'!", cbuf);
#endif

  wcstombs(cbuf, filename, MAX_PATH);

  gzFile gzfp = gzopen(cbuf, "rb");
  DBG_INFO(80, L"gzfp:%x file:%ls\n", gzfp, filename);
  if (gzfp) {
    /* yep, we have it. load it into memory cache. */
    int dataSize;
    uint64 checksum;
    GHQTexInfo tmpInfo;
    int tmpconfig;
    /* read header to determine config match */
    gzread(gzfp, &tmpconfig, 4);

    if (tmpconfig == config) {
      do {
        memset(&tmpInfo, 0, sizeof(GHQTexInfo));

        gzread(gzfp, &checksum, 8);

        gzread(gzfp, &tmpInfo.width, 4);
        gzread(gzfp, &tmpInfo.height, 4);
        gzread(gzfp, &tmpInfo.format, 2);

        gzread(gzfp, &tmpInfo.smallLodLog2, 4);
        gzread(gzfp, &tmpInfo.largeLodLog2, 4);
        gzread(gzfp, &tmpInfo.aspectRatioLog2, 4);

        gzread(gzfp, &tmpInfo.tiles, 4);
        gzread(gzfp, &tmpInfo.untiled_width, 4);
        gzread(gzfp, &tmpInfo.untiled_height, 4);

        gzread(gzfp, &tmpInfo.is_hires_tex, 1);

        gzread(gzfp, &dataSize, 4);

        tmpInfo.data = (uint8*)malloc(dataSize);
        if (tmpInfo.data) {
          gzread(gzfp, tmpInfo.data, dataSize);

          /* add to memory cache */
          add(checksum, &tmpInfo, (tmpInfo.format & GR_TEXFMT_GZ) ? dataSize : 0);

          free(tmpInfo.data);
        } else {
          gzseek(gzfp, dataSize, SEEK_CUR);
        }

        /* skip in between to prevent the loop from being tied down to vsync */
        if (_callback && (!(_cache.size() % 100) || gzeof(gzfp)))
          (*_callback)(L"[%d] total mem:%.02fmb - %ls\n", _cache.size(), (float)_totalSize/1000000, filename);

      } while (!gzeof(gzfp));
      gzclose(gzfp);
    } else {
      if ((tmpconfig & HIRESTEXTURES_MASK) != (config & HIRESTEXTURES_MASK)) {
        const char *conf_str;
        if ((tmpconfig & HIRESTEXTURES_MASK) == NO_HIRESTEXTURES)
          conf_str = "0";
        else if ((tmpconfig & HIRESTEXTURES_MASK) == RICE_HIRESTEXTURES)
          conf_str = "1";
        else
          conf_str = "set to an unsupported format";

        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs must be %s", conf_str);
      }
      if ((tmpconfig & COMPRESS_HIRESTEX) != (config & COMPRESS_HIRESTEX))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_cmpr must be %s", (tmpconfig & COMPRESS_HIRESTEX) ? "True" : "False");
      if ((tmpconfig & COMPRESSION_MASK) != (config & COMPRESSION_MASK) && (tmpconfig & COMPRESS_HIRESTEX)) {
        const char *conf_str;
        if ((tmpconfig & COMPRESSION_MASK) == FXT1_COMPRESSION)
          conf_str = "1";
        else if ((tmpconfig & COMPRESSION_MASK) == S3TC_COMPRESSION)
          conf_str = "0";
        else
          conf_str = "set to an unsupported format";

        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_cmpr must be %s", conf_str);
      }
      if ((tmpconfig & TILE_HIRESTEX) != (config & TILE_HIRESTEX))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_tile must be %s", (tmpconfig & TILE_HIRESTEX) ? "True" : "False");
      if ((tmpconfig & FORCE16BPP_HIRESTEX) != (config & FORCE16BPP_HIRESTEX))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_f16bpp must be %s", (tmpconfig & FORCE16BPP_HIRESTEX) ? "True" : "False");
      if ((tmpconfig & GZ_HIRESTEXCACHE) != (config & GZ_HIRESTEXCACHE))
        WriteLog(M64MSG_WARNING, "ghq_hirs_gz must be %s", (tmpconfig & GZ_HIRESTEXCACHE) ? "True" : "False");
      if ((tmpconfig & LET_TEXARTISTS_FLY) != (config & LET_TEXARTISTS_FLY))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_let_texartists_fly must be %s", (tmpconfig & LET_TEXARTISTS_FLY) ? "True" : "False");

      if ((tmpconfig & FILTER_MASK) != (config & FILTER_MASK)) {
        const char *conf_str;
        if ((tmpconfig & FILTER_MASK) == NO_FILTER)
          conf_str = "0";
        else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_1)
          conf_str = "1";
        else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_2)
          conf_str = "2";
        else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_3)
          conf_str = "3";
        else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_4)
          conf_str = "4";
        else if ((tmpconfig & FILTER_MASK) == SHARP_FILTER_1)
          conf_str = "5";
        else if ((tmpconfig & FILTER_MASK) == SHARP_FILTER_2)
          conf_str = "6";
        else
          conf_str = "set to an unsupported format";
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_fltr must be %s", conf_str);
      }

      if ((tmpconfig & ENHANCEMENT_MASK) != (config & ENHANCEMENT_MASK)) {
        const char *conf_str;
        if ((tmpconfig & ENHANCEMENT_MASK) == NO_ENHANCEMENT)
          conf_str = "0";
        else if ((tmpconfig & ENHANCEMENT_MASK) == X2_ENHANCEMENT)
          conf_str = "2";
        else if ((tmpconfig & ENHANCEMENT_MASK) == X2SAI_ENHANCEMENT)
          conf_str = "3";
        else if ((tmpconfig & ENHANCEMENT_MASK) == HQ2X_ENHANCEMENT)
          conf_str = "4";
        else if ((tmpconfig & ENHANCEMENT_MASK) == HQ2XS_ENHANCEMENT)
          conf_str = "5";
        else if ((tmpconfig & ENHANCEMENT_MASK) == LQ2X_ENHANCEMENT)
          conf_str = "6";
        else if ((tmpconfig & ENHANCEMENT_MASK) == LQ2XS_ENHANCEMENT)
          conf_str = "7";
        else if ((tmpconfig & ENHANCEMENT_MASK) == HQ4X_ENHANCEMENT)
          conf_str = "8";
        else
          conf_str = "set to an unsupported format";
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht must be %s", conf_str);
      }

      if ((tmpconfig & COMPRESS_TEX) != (config & COMPRESS_TEX))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht_cmpr must be %s", (tmpconfig & COMPRESS_TEX) ? "True" : "False");
      if ((tmpconfig & FORCE16BPP_TEX) != (config & FORCE16BPP_TEX))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht_f16bpp must be %s", (tmpconfig & FORCE16BPP_TEX) ? "True" : "False");
      if ((tmpconfig & GZ_TEXCACHE) != (config & GZ_TEXCACHE))
        WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht_gz must be %s", (tmpconfig & GZ_TEXCACHE) ? "True" : "False");
    }
  }

  if (CHDIR(curpath) != 0)
      ERRLOG("Error while changing current directory back to original path of '%s'!", curpath);

  return !_cache.empty();
}

boolean
TxCache::del(uint64 checksum)
{
  if (!checksum || _cache.empty()) return 0;

  std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(checksum);
  if (itMap != _cache.end()) {

    /* for texture cache (not hi-res cache) */
    if (!_cachelist.empty()) _cachelist.erase(((*itMap).second)->it);

    /* remove from cache */
    free((*itMap).second->info.data);
    _totalSize -= (*itMap).second->size;
    delete (*itMap).second;
    _cache.erase(itMap);

    DBG_INFO(80, L"removed from cache: checksum = %08X %08X\n", (uint32)(checksum & 0xffffffff), (uint32)(checksum >> 32));

    return 1;
  }

  return 0;
}

boolean
TxCache::is_cached(uint64 checksum)
{
  std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(checksum);
  if (itMap != _cache.end()) return 1;

  return 0;
}

void
TxCache::clear()
{
  if (!_cache.empty()) {
    std::map<uint64, TXCACHE*>::iterator itMap = _cache.begin();
    while (itMap != _cache.end()) {
      free((*itMap).second->info.data);
      delete (*itMap).second;
      itMap++;
    }
    _cache.clear();
  }

  if (!_cachelist.empty()) _cachelist.clear();

  _totalSize = 0;
}
Commit	Line	Data
98e75f2d	1	/*
	2	* Texture Filtering
	3	* Version: 1.0
	4	*
	5	* Copyright (C) 2007 Hiroshi Morii All Rights Reserved.
	6	* Email koolsmoky(at)users.sourceforge.net
	7	* Web http://www.3dfxzone.it/koolsmoky
	8	*
	9	* this is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2, or (at your option)
	12	* any later version.
	13	*
	14	* this is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with GNU Make; see the file COPYING. If not, write to
	21	* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
	22	*/
	23
	24	#ifdef __MSC__
	25	#pragma warning(disable: 4786)
	26	#endif
	27
	28	#include <boost/filesystem.hpp>
	29	#include <zlib.h>
	30	#include "TxCache.h"
	31	#include "TxDbg.h"
	32	#include "../Glide64/m64p.h"
	33	#include "../Glide64/Gfx_1.3.h"
	34
	35	TxCache::~TxCache()
	36	{
	37	/* free memory, clean up, etc */
	38	clear();
	39
	40	delete _txUtil;
	41	}
	42
	43	TxCache::TxCache(int options, int cachesize, const wchar_t *datapath,
	44	const wchar_t cachepath, const wchar_t ident,
	45	dispInfoFuncExt callback)
	46	{
	47	_txUtil = new TxUtil();
	48
	49	_options = options;
	50	_cacheSize = cachesize;
	51	_callback = callback;
	52	_totalSize = 0;
	53
	54	/* save path name */
	55	if (datapath)
	56	_datapath.assign(datapath);
	57	if (cachepath)
	58	_cachepath.assign(cachepath);
	59
	60	/* save ROM name */
	61	if (ident)
	62	_ident.assign(ident);
	63
	64	/* zlib memory buffers to (de)compress hires textures */
65	if (_options & (GZ_TEXCACHE\|GZ_HIRESTEXCACHE)) {
66	_gzdest0 = TxMemBuf::getInstance()->get(0);
67	_gzdest1 = TxMemBuf::getInstance()->get(1);
68	_gzdestLen = (TxMemBuf::getInstance()->size_of(0) < TxMemBuf::getInstance()->size_of(1)) ?
69	TxMemBuf::getInstance()->size_of(0) : TxMemBuf::getInstance()->size_of(1);
70
71	if (!_gzdest0 \|\| !_gzdest1 \|\| !_gzdestLen) {
72	_options &= ~(GZ_TEXCACHE\|GZ_HIRESTEXCACHE);
73	_gzdest0 = NULL;
74	_gzdest1 = NULL;
75	_gzdestLen = 0;
76	}
77	}
78	}
79
80	boolean
81	TxCache::add(uint64 checksum, GHQTexInfo *info, int dataSize)
82	{
83	/* NOTE: dataSize must be provided if info->data is zlib compressed. */
84
85	if (!checksum \|\| !info->data) return 0;
86
87	uint8 *dest = info->data;
88	uint16 format = info->format;
89
90	if (!dataSize) {
91	dataSize = _txUtil->sizeofTx(info->width, info->height, info->format);
92
93	if (!dataSize) return 0;
94
95	if (_options & (GZ_TEXCACHE\|GZ_HIRESTEXCACHE)) {
96	/* zlib compress it. compression level:1 (best speed) */
97	uLongf destLen = _gzdestLen;
98	dest = (dest == _gzdest0) ? _gzdest1 : _gzdest0;
99	if (compress2(dest, &destLen, info->data, dataSize, 1) != Z_OK) {
100	dest = info->data;
101	DBG_INFO(80, L"Error: zlib compression failed!\n");
102	} else {
103	DBG_INFO(80, L"zlib compressed: %.02fkb->%.02fkb\n", (float)dataSize/1000, (float)destLen/1000);
104	dataSize = destLen;
105	format \|= GR_TEXFMT_GZ;
106	}
107	}
108	}
109
110	/* if cache size exceeds limit, remove old cache */
111	if (_cacheSize > 0) {
112	_totalSize += dataSize;
113	if ((_totalSize > _cacheSize) && !_cachelist.empty()) {
114	/* _cachelist is arranged so that frequently used textures are in the back */
115	std::list<uint64>::iterator itList = _cachelist.begin();
116	while (itList != _cachelist.end()) {
117	/* find it in _cache */
118	std::map<uint64, TXCACHE>::iterator itMap = _cache.find(itList);
119	if (itMap != _cache.end()) {
120	/* yep we have it. remove it. */
121	_totalSize -= (*itMap).second->size;
122	free((*itMap).second->info.data);
123	delete (*itMap).second;
124	_cache.erase(itMap);
125	}
126	itList++;
127
128	/* check if memory cache has enough space */
129	if (_totalSize <= _cacheSize)
130	break;
131	}
132	/* remove from _cachelist */
133	_cachelist.erase(_cachelist.begin(), itList);
134
135	DBG_INFO(80, L"+++++++++\n");
136	}
137	_totalSize -= dataSize;
138	}
139
140	/* cache it */
141	uint8 tmpdata = (uint8)malloc(dataSize);
142	if (tmpdata) {
143	TXCACHE *txCache = new TXCACHE;
144	if (txCache) {
145	/* we can directly write as we filter, but for now we get away
146	* with doing memcpy after all the filtering is done.
147	*/
148	memcpy(tmpdata, dest, dataSize);
149
150	/* copy it */
151	memcpy(&txCache->info, info, sizeof(GHQTexInfo));
152	txCache->info.data = tmpdata;
153	txCache->info.format = format;
154	txCache->size = dataSize;
155
156	/* add to cache */
157	if (_cacheSize > 0) {
158	_cachelist.push_back(checksum);
159	txCache->it = --(_cachelist.end());
160	}
161	/* _cache[checksum] = txCache; */
162	_cache.insert(std::map<uint64, TXCACHE*>::value_type(checksum, txCache));
163
164	#ifdef DEBUG
165	DBG_INFO(80, L"[%5d] added!! crc:%08X %08X %d x %d gfmt:%x total:%.02fmb\n",
166	_cache.size(), (uint32)(checksum >> 32), (uint32)(checksum & 0xffffffff),
167	info->width, info->height, info->format, (float)_totalSize/1000000);
168
169	DBG_INFO(80, L"smalllodlog2:%d largelodlog2:%d aspectratiolog2:%d\n",
170	txCache->info.smallLodLog2, txCache->info.largeLodLog2, txCache->info.aspectRatioLog2);
171
172	if (info->tiles) {
173	DBG_INFO(80, L"tiles:%d un-tiled size:%d x %d\n", info->tiles, info->untiled_width, info->untiled_height);
174	}
175
176	if (_cacheSize > 0) {
177	DBG_INFO(80, L"cache max config:%.02fmb\n", (float)_cacheSize/1000000);
178
179	if (_cache.size() != _cachelist.size()) {
180	DBG_INFO(80, L"Error: cache/cachelist mismatch! (%d/%d)\n", _cache.size(), _cachelist.size());
181	}
182	}
183	#endif
184
185	/* total cache size */
186	_totalSize += dataSize;
187
188	return 1;
189	}
190	free(tmpdata);
191	}
192
193	return 0;
194	}
195
196	boolean
197	TxCache::get(uint64 checksum, GHQTexInfo *info)
198	{
199	if (!checksum \|\| _cache.empty()) return 0;
200
201	/* find a match in cache */
202	std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(checksum);
203	if (itMap != _cache.end()) {
204	/* yep, we've got it. */
205	memcpy(info, &(((*itMap).second)->info), sizeof(GHQTexInfo));
206
207	/* push it to the back of the list */
208	if (_cacheSize > 0) {
209	_cachelist.erase(((*itMap).second)->it);
210	_cachelist.push_back(checksum);
211	((*itMap).second)->it = --(_cachelist.end());
212	}
213
214	/* zlib decompress it */
215	if (info->format & GR_TEXFMT_GZ) {
216	uLongf destLen = _gzdestLen;
217	uint8 *dest = (_gzdest0 == info->data) ? _gzdest1 : _gzdest0;
218	if (uncompress(dest, &destLen, info->data, ((*itMap).second)->size) != Z_OK) {
219	DBG_INFO(80, L"Error: zlib decompression failed!\n");
220	return 0;
221	}
222	info->data = dest;
223	info->format &= ~GR_TEXFMT_GZ;
224	DBG_INFO(80, L"zlib decompressed: %.02fkb->%.02fkb\n", (float)(((*itMap).second)->size)/1000, (float)destLen/1000);
225	}
226
227	return 1;
228	}
229
230	return 0;
231	}
232
233	boolean
234	TxCache::save(const wchar_t path, const wchar_t filename, int config)
235	{
236	if (!_cache.empty()) {
237	/* dump cache to disk */
238	char cbuf[MAX_PATH];
239
240	boost::filesystem::wpath cachepath(path);
241	boost::filesystem::create_directory(cachepath);
242
243	/* Ugly hack to enable fopen/gzopen in Win9x */
244	#ifdef BOOST_WINDOWS_API
245	wchar_t curpath[MAX_PATH];
246	GETCWD(MAX_PATH, curpath);
247	CHDIR(cachepath.wstring().c_str());
248	#else
249	char curpath[MAX_PATH];
250	wcstombs(cbuf, cachepath.wstring().c_str(), MAX_PATH);
251	if (GETCWD(MAX_PATH, curpath) == NULL)
252	ERRLOG("Error while retrieving working directory!");
253	if (CHDIR(cbuf) != 0)
254	ERRLOG("Error while changing current directory to '%s'!", cbuf);
255	#endif
256
257	wcstombs(cbuf, filename, MAX_PATH);
258
259	gzFile gzfp = gzopen(cbuf, "wb1");
260	DBG_INFO(80, L"gzfp:%x file:%ls\n", gzfp, filename);
261	if (gzfp) {
262	/* write header to determine config match */
263	gzwrite(gzfp, &config, 4);
264
265	std::map<uint64, TXCACHE*>::iterator itMap = _cache.begin();
266	while (itMap != _cache.end()) {
267	uint8 dest = (itMap).second->info.data;
268	uint32 destLen = (*itMap).second->size;
269	uint16 format = (*itMap).second->info.format;
270
271	/* to keep things simple, we save the texture data in a zlib uncompressed state. */
272	/* sigh... for those who cannot wait the extra few seconds. changed to keep
273	* texture data in a zlib compressed state. if the GZ_TEXCACHE or GZ_HIRESTEXCACHE
274	* option is toggled, the cache will need to be rebuilt.
275	*/
276	/*if (format & GR_TEXFMT_GZ) {
277	dest = _gzdest0;
278	destLen = _gzdestLen;
279	if (dest && destLen) {
280	if (uncompress(dest, &destLen, (itMap).second->info.data, (itMap).second->size) != Z_OK) {
281	dest = NULL;
282	destLen = 0;
283	}
284	format &= ~GR_TEXFMT_GZ;
285	}
286	}*/
287
288	if (dest && destLen) {
289	/* texture checksum */
290	gzwrite(gzfp, &((*itMap).first), 8);
291
292	/* other texture info */
293	gzwrite(gzfp, &((*itMap).second->info.width), 4);
294	gzwrite(gzfp, &((*itMap).second->info.height), 4);
295	gzwrite(gzfp, &format, 2);
296
297	gzwrite(gzfp, &((*itMap).second->info.smallLodLog2), 4);
298	gzwrite(gzfp, &((*itMap).second->info.largeLodLog2), 4);
299	gzwrite(gzfp, &((*itMap).second->info.aspectRatioLog2), 4);
300
301	gzwrite(gzfp, &((*itMap).second->info.tiles), 4);
302	gzwrite(gzfp, &((*itMap).second->info.untiled_width), 4);
303	gzwrite(gzfp, &((*itMap).second->info.untiled_height), 4);
304
305	gzwrite(gzfp, &((*itMap).second->info.is_hires_tex), 1);
306
307	gzwrite(gzfp, &destLen, 4);
308	gzwrite(gzfp, dest, destLen);
309	}
310
311	itMap++;
312
313	/* not ready yet */
314	/*if (_callback)
315	(_callback)(L"Total textures saved to HDD: %d\n", std::distance(itMap, _cache.begin()));/
316	}
317	gzclose(gzfp);
318	}
319
320	if (CHDIR(curpath) != 0)
321	ERRLOG("Error while changing current directory back to original path of '%s'!", curpath);
322	}
323
324	return _cache.empty();
325	}
326
327	boolean
328	TxCache::load(const wchar_t path, const wchar_t filename, int config)
329	{
330	/* find it on disk */
331	char cbuf[MAX_PATH];
332
333	boost::filesystem::wpath cachepath(path);
334
335	#ifdef BOOST_WINDOWS_API
336	wchar_t curpath[MAX_PATH];
337	GETCWD(MAX_PATH, curpath);
338	CHDIR(cachepath.wstring().c_str());
339	#else
340	char curpath[MAX_PATH];
341	wcstombs(cbuf, cachepath.wstring().c_str(), MAX_PATH);
342	if (GETCWD(MAX_PATH, curpath) == NULL)
343	ERRLOG("Error while retrieving working directory!");
344	if (CHDIR(cbuf) != 0)
345	ERRLOG("Error while changing current directory to '%s'!", cbuf);
346	#endif
347
348	wcstombs(cbuf, filename, MAX_PATH);
349
350	gzFile gzfp = gzopen(cbuf, "rb");
351	DBG_INFO(80, L"gzfp:%x file:%ls\n", gzfp, filename);
352	if (gzfp) {
353	/* yep, we have it. load it into memory cache. */
354	int dataSize;
355	uint64 checksum;
356	GHQTexInfo tmpInfo;
357	int tmpconfig;
358	/* read header to determine config match */
359	gzread(gzfp, &tmpconfig, 4);
360
361	if (tmpconfig == config) {
362	do {
363	memset(&tmpInfo, 0, sizeof(GHQTexInfo));
364
365	gzread(gzfp, &checksum, 8);
366
367	gzread(gzfp, &tmpInfo.width, 4);
368	gzread(gzfp, &tmpInfo.height, 4);
369	gzread(gzfp, &tmpInfo.format, 2);
370
371	gzread(gzfp, &tmpInfo.smallLodLog2, 4);
372	gzread(gzfp, &tmpInfo.largeLodLog2, 4);
373	gzread(gzfp, &tmpInfo.aspectRatioLog2, 4);
374
375	gzread(gzfp, &tmpInfo.tiles, 4);
376	gzread(gzfp, &tmpInfo.untiled_width, 4);
377	gzread(gzfp, &tmpInfo.untiled_height, 4);
378
379	gzread(gzfp, &tmpInfo.is_hires_tex, 1);
380
381	gzread(gzfp, &dataSize, 4);
382
383	tmpInfo.data = (uint8*)malloc(dataSize);
384	if (tmpInfo.data) {
385	gzread(gzfp, tmpInfo.data, dataSize);
386
387	/* add to memory cache */
388	add(checksum, &tmpInfo, (tmpInfo.format & GR_TEXFMT_GZ) ? dataSize : 0);
389
390	free(tmpInfo.data);
391	} else {
392	gzseek(gzfp, dataSize, SEEK_CUR);
393	}
394
395	/* skip in between to prevent the loop from being tied down to vsync */
396	if (_callback && (!(_cache.size() % 100) \|\| gzeof(gzfp)))
397	(*_callback)(L"[%d] total mem:%.02fmb - %ls\n", _cache.size(), (float)_totalSize/1000000, filename);
398
399	} while (!gzeof(gzfp));
400	gzclose(gzfp);
401	} else {
402	if ((tmpconfig & HIRESTEXTURES_MASK) != (config & HIRESTEXTURES_MASK)) {
403	const char *conf_str;
404	if ((tmpconfig & HIRESTEXTURES_MASK) == NO_HIRESTEXTURES)
405	conf_str = "0";
406	else if ((tmpconfig & HIRESTEXTURES_MASK) == RICE_HIRESTEXTURES)
407	conf_str = "1";
408	else
409	conf_str = "set to an unsupported format";
410
411	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs must be %s", conf_str);
412	}
413	if ((tmpconfig & COMPRESS_HIRESTEX) != (config & COMPRESS_HIRESTEX))
414	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_cmpr must be %s", (tmpconfig & COMPRESS_HIRESTEX) ? "True" : "False");
415	if ((tmpconfig & COMPRESSION_MASK) != (config & COMPRESSION_MASK) && (tmpconfig & COMPRESS_HIRESTEX)) {
416	const char *conf_str;
417	if ((tmpconfig & COMPRESSION_MASK) == FXT1_COMPRESSION)
418	conf_str = "1";
419	else if ((tmpconfig & COMPRESSION_MASK) == S3TC_COMPRESSION)
420	conf_str = "0";
421	else
422	conf_str = "set to an unsupported format";
423
424	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_cmpr must be %s", conf_str);
425	}
426	if ((tmpconfig & TILE_HIRESTEX) != (config & TILE_HIRESTEX))
427	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_tile must be %s", (tmpconfig & TILE_HIRESTEX) ? "True" : "False");
428	if ((tmpconfig & FORCE16BPP_HIRESTEX) != (config & FORCE16BPP_HIRESTEX))
429	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_f16bpp must be %s", (tmpconfig & FORCE16BPP_HIRESTEX) ? "True" : "False");
430	if ((tmpconfig & GZ_HIRESTEXCACHE) != (config & GZ_HIRESTEXCACHE))
431	WriteLog(M64MSG_WARNING, "ghq_hirs_gz must be %s", (tmpconfig & GZ_HIRESTEXCACHE) ? "True" : "False");
432	if ((tmpconfig & LET_TEXARTISTS_FLY) != (config & LET_TEXARTISTS_FLY))
433	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_hirs_let_texartists_fly must be %s", (tmpconfig & LET_TEXARTISTS_FLY) ? "True" : "False");
434
435	if ((tmpconfig & FILTER_MASK) != (config & FILTER_MASK)) {
436	const char *conf_str;
437	if ((tmpconfig & FILTER_MASK) == NO_FILTER)
438	conf_str = "0";
439	else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_1)
440	conf_str = "1";
441	else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_2)
442	conf_str = "2";
443	else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_3)
444	conf_str = "3";
445	else if ((tmpconfig & FILTER_MASK) == SMOOTH_FILTER_4)
446	conf_str = "4";
447	else if ((tmpconfig & FILTER_MASK) == SHARP_FILTER_1)
448	conf_str = "5";
449	else if ((tmpconfig & FILTER_MASK) == SHARP_FILTER_2)
450	conf_str = "6";
451	else
452	conf_str = "set to an unsupported format";
453	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_fltr must be %s", conf_str);
454	}
455
456	if ((tmpconfig & ENHANCEMENT_MASK) != (config & ENHANCEMENT_MASK)) {
457	const char *conf_str;
458	if ((tmpconfig & ENHANCEMENT_MASK) == NO_ENHANCEMENT)
459	conf_str = "0";
460	else if ((tmpconfig & ENHANCEMENT_MASK) == X2_ENHANCEMENT)
461	conf_str = "2";
462	else if ((tmpconfig & ENHANCEMENT_MASK) == X2SAI_ENHANCEMENT)
463	conf_str = "3";
464	else if ((tmpconfig & ENHANCEMENT_MASK) == HQ2X_ENHANCEMENT)
465	conf_str = "4";
466	else if ((tmpconfig & ENHANCEMENT_MASK) == HQ2XS_ENHANCEMENT)
467	conf_str = "5";
468	else if ((tmpconfig & ENHANCEMENT_MASK) == LQ2X_ENHANCEMENT)
469	conf_str = "6";
470	else if ((tmpconfig & ENHANCEMENT_MASK) == LQ2XS_ENHANCEMENT)
471	conf_str = "7";
472	else if ((tmpconfig & ENHANCEMENT_MASK) == HQ4X_ENHANCEMENT)
473	conf_str = "8";
474	else
475	conf_str = "set to an unsupported format";
476	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht must be %s", conf_str);
477	}
478
479	if ((tmpconfig & COMPRESS_TEX) != (config & COMPRESS_TEX))
480	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht_cmpr must be %s", (tmpconfig & COMPRESS_TEX) ? "True" : "False");
481	if ((tmpconfig & FORCE16BPP_TEX) != (config & FORCE16BPP_TEX))
482	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht_f16bpp must be %s", (tmpconfig & FORCE16BPP_TEX) ? "True" : "False");
483	if ((tmpconfig & GZ_TEXCACHE) != (config & GZ_TEXCACHE))
484	WriteLog(M64MSG_WARNING, "Ignored texture cache due to incompatible setting: ghq_enht_gz must be %s", (tmpconfig & GZ_TEXCACHE) ? "True" : "False");
485	}
486	}
487
488	if (CHDIR(curpath) != 0)
489	ERRLOG("Error while changing current directory back to original path of '%s'!", curpath);
490
491	return !_cache.empty();
492	}
493
494	boolean
495	TxCache::del(uint64 checksum)
496	{
497	if (!checksum \|\| _cache.empty()) return 0;
498
499	std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(checksum);
500	if (itMap != _cache.end()) {
501
502	/* for texture cache (not hi-res cache) */
503	if (!_cachelist.empty()) _cachelist.erase(((*itMap).second)->it);
504
505	/* remove from cache */
506	free((*itMap).second->info.data);
507	_totalSize -= (*itMap).second->size;
508	delete (*itMap).second;
509	_cache.erase(itMap);
510
511	DBG_INFO(80, L"removed from cache: checksum = %08X %08X\n", (uint32)(checksum & 0xffffffff), (uint32)(checksum >> 32));
512
513	return 1;
514	}
515
516	return 0;
517	}
518
519	boolean
520	TxCache::is_cached(uint64 checksum)
521	{
522	std::map<uint64, TXCACHE*>::iterator itMap = _cache.find(checksum);
523	if (itMap != _cache.end()) return 1;
524
525	return 0;
526	}
527
528	void
529	TxCache::clear()
530	{
531	if (!_cache.empty()) {
532	std::map<uint64, TXCACHE*>::iterator itMap = _cache.begin();
533	while (itMap != _cache.end()) {
534	free((*itMap).second->info.data);
535	delete (*itMap).second;
536	itMap++;
537	}
538	_cache.clear();
539	}
540
541	if (!_cachelist.empty()) _cachelist.clear();
542
543	_totalSize = 0;
544	}