diff --git a/Source/Core/Common/Common.vcproj b/Source/Core/Common/Common.vcproj index 0e478e686a..cee7a849b9 100644 --- a/Source/Core/Common/Common.vcproj +++ b/Source/Core/Common/Common.vcproj @@ -701,10 +701,6 @@ RelativePath=".\Src\IniFile.h" > - - diff --git a/Source/Core/Common/Src/LinearDiskCache.cpp b/Source/Core/Common/Src/LinearDiskCache.cpp deleted file mode 100644 index 5e634ce3a8..0000000000 --- a/Source/Core/Common/Src/LinearDiskCache.cpp +++ /dev/null @@ -1,172 +0,0 @@ -// Copyright (C) 2003 Dolphin Project. - -// This program 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, version 2.0. - -// This program 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 2.0 for more details. - -// A copy of the GPL 2.0 should have been included with the program. -// If not, see http://www.gnu.org/licenses/ - -// Official SVN repository and contact information can be found at -// http://code.google.com/p/dolphin-emu/ - -#include "LinearDiskCache.h" - -static const char ID[4] = {'D', 'C', 'A', 'C'}; - -// Update this to the current SVN revision every time you change shader generation code. -// We don't automatically get this from SVN_REV because that would mean regenerating the -// shader cache for every revision, graphics-related or not, which is simply annoying. -const int version = 6306; - -LinearDiskCache::LinearDiskCache() - : file_(NULL), num_entries_(0) { -} - -void LinearDiskCache::WriteHeader() { - fwrite(ID, 4, 1, file_); - fwrite(&version, 4, 1, file_); -} - -bool LinearDiskCache::ValidateHeader() { - char header_id[4]; - int header_version; - fread(&header_id, 4, 1, file_); - fread(&header_version, 4, 1, file_); - if (memcmp(header_id, ID, 4) != 0) - return false; - if (header_version != version) - return false; - return true; -} - -int LinearDiskCache::OpenAndRead(const char *filename, LinearDiskCacheReader *reader) { - if (file_) - { - ERROR_LOG(VIDEO, "LinearDiskCache trying to open an alredy opened cache"); - return 0; - } - int items_read_count = 0; - file_ = fopen(filename, "rb"); - int file_size = 0; - if (file_) { - fseek(file_, 0, SEEK_END); - file_size = (int)ftell(file_); - } - - bool file_corrupt = false; - if (file_size == 0) { - if (file_) - fclose(file_); - // Reopen for writing. - file_ = fopen(filename, "wb"); - // Cache empty, let's initialize a header. - WriteHeader(); - num_entries_ = 0; - } else { - // file_ must be != 0 here. - // Back to the start we go. - fseek(file_, 0, SEEK_SET); - // Check that the file is valid - if (!ValidateHeader()) { - // Not valid - delete the file and start over. - fclose(file_); - unlink(filename); - - // PanicAlert("LinearDiskCache file header broken."); - - file_ = fopen(filename, "wb"); - WriteHeader(); - num_entries_ = 0; - } else { - // Valid - blow through it. - // We're past the header already thanks to ValidateHeader. - while (!feof(file_)) { - int key_size, value_size; - size_t key_size_size = fread(&key_size, 1, sizeof(key_size), file_); - size_t value_size_size = fread(&value_size, 1, sizeof(value_size), file_); - if (key_size_size == 0 && value_size_size == 0) { - // I guess feof isn't doing it's job - we're at the end. - break; - } - if (key_size <= 0 || value_size < 0 || key_size_size != 4 || value_size_size != 4) { - // PanicAlert("Disk cache file %s corrupted/truncated! ks: %i vs %i kss %i vss %i", filename, - // key_size, value_size, key_size_size, value_size_size); - file_corrupt = true; - break; - } - u8 *key = new u8[key_size]; - u8 *value = new u8[value_size]; - int actual_key_size = (int)fread(key, 1, key_size, file_); - int actual_value_size = (int)fread(value, 1, value_size, file_); - if (actual_key_size != key_size || actual_value_size != value_size) { - // PanicAlert("Disk cache file %s corrupted/truncated! ks: %i actual ks: %i vs: %i actual vs: %i", filename, - // key_size, actual_key_size, value_size, actual_value_size); - file_corrupt = true; - } else { - reader->Read(key, key_size, value, value_size); - items_read_count++; - } - delete [] key; - delete [] value; - } - fclose(file_); - // Done reading. - - // Reopen file for append. - // At this point, ftell() will be at the end of the file, - // which happens to be exactly what we want. - file_ = fopen(filename, "ab"); - fseek(file_, 0, SEEK_END); - } - } - - if (file_corrupt) { - // Restore sanity, start over. - fclose(file_); - unlink(filename); - - file_ = fopen(filename, "wb+"); - WriteHeader(); - } - - return items_read_count; -} - -void LinearDiskCache::Append( - const u8 *key, int key_size, const u8 *value, int value_size) { - // Should do a check that we don't already have "key"? - fwrite(&key_size, 1, sizeof(key_size), file_); - fwrite(&value_size, 1, sizeof(value_size), file_); - fwrite(key, 1, key_size, file_); - fwrite(value, 1, value_size, file_); -} - -void LinearDiskCache::Sync() { - if (file_) - { - fflush(file_); - } - else - { - ERROR_LOG(VIDEO, "LinearDiskCache trying to sync closed cache"); - } -} - -void LinearDiskCache::Close() { - if (file_) - { - fclose(file_); - file_ = 0; - num_entries_ = 0; - } - else - { - ERROR_LOG(VIDEO, "LinearDiskCache trying to close an alredy closed cache"); - } -} diff --git a/Source/Core/Common/Src/LinearDiskCache.h b/Source/Core/Common/Src/LinearDiskCache.h index 7827c7c15b..07a0eec129 100644 --- a/Source/Core/Common/Src/LinearDiskCache.h +++ b/Source/Core/Common/Src/LinearDiskCache.h @@ -19,21 +19,35 @@ #define _LINEAR_DISKCACHE #include "Common.h" +#include -#include -#include +// Update this to the current SVN revision every time you change shader generation code. +// We don't automatically get this from SVN_REV because that would mean regenerating the +// shader cache for every revision, graphics-related or not, which is simply annoying. +enum +{ + LINEAR_DISKCACHE_VER = 6420 +}; // On disk format: -// uint32 'DCAC' -// uint32 version; // svn_rev -// uint32 key_length; -// uint32 value_length; -// .... key; -// .... value; +//header{ +// u32 'DCAC'; +// u32 version; // svn_rev +// u16 sizeof(key_type); +// u16 sizeof(value_type); +//} -class LinearDiskCacheReader { +//key_value_pair{ +// u32 value_size; +// key_type key; +// value_type[value_size] value; +//} + +template +class LinearDiskCacheReader +{ public: - virtual void Read(const u8 *key, int key_size, const u8 *value, int value_size) = 0; + virtual void Read(const K &key, const V *value, u32 value_size) = 0; }; // Dead simple unsorted key-value store with append functionality. @@ -44,24 +58,123 @@ public: // Not tuned for extreme performance but should be reasonably fast. // Does not support keys or values larger than 2GB, which should be reasonable. // Keys must have non-zero length; values can have zero length. -class LinearDiskCache { -public: - LinearDiskCache(); - // Returns the number of items read from the cache. - int OpenAndRead(const char *filename, LinearDiskCacheReader *reader); - void Close(); - void Sync(); +// K and V are some POD type +// K : the key type +// V : value array type +template +class LinearDiskCache +{ +public: + // return number of read entries + u32 OpenAndRead(const char *filename, LinearDiskCacheReader &reader) + { + using std::ios_base; + + // close any currently opened file + Close(); + + // try opening for reading/writing + m_file.open(filename, ios_base::in | ios_base::out | ios_base::binary); + + if (m_file.is_open() && ValidateHeader()) + { + // good header, read some key/value pairs + u32 num_entries = 0; + K key; + + V *value = NULL; + u32 value_size; + + while (Read(&value_size)) + { + delete[] value; + value = new V[value_size]; + + // read key/value and pass to reader + if (Read(&key) && Read(value, value_size)) + reader.Read(key, value, value_size); + else + break; + + ++num_entries; + } + + delete[] value; + return num_entries; + } + + // failed to open file for reading or bad header + // close and recreate file + Close(); + m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary); + WriteHeader(); + return 0; + } + + void Sync() + { + m_file.flush(); + } + + void Close() + { + if (m_file.is_open()) + m_file.close(); + // clear any error flags + m_file.clear(); + } // Appends a key-value pair to the store. - void Append(const u8 *key, int key_size, const u8 *value, int value_size); + void Append(const K &key, const V *value, u32 value_size) + { + // TODO: Should do a check that we don't already have "key"? + Write(&value_size); + Write(&key); + Write(value, value_size); + } private: - void WriteHeader(); - bool ValidateHeader(); + void WriteHeader() + { + Write(&m_header); + } - FILE *file_; - int num_entries_; + bool ValidateHeader() + { + char file_header[sizeof(Header)]; + + return (Read(file_header, sizeof(Header)) + && !memcmp((const char*)&m_header, file_header, sizeof(Header))); + } + + template + bool Write(const D *data, u32 count = 1) + { + return m_file.write((const char*)data, count * sizeof(D)).good(); + } + + template + bool Read(const D *data, u32 count = 1) + { + return m_file.read((char*)data, count * sizeof(D)).good(); + } + + struct Header + { + Header() + : id(*(u32*)"DCAC") + , ver(LINEAR_DISKCACHE_VER) + , key_t_size(sizeof(K)) + , value_t_size(sizeof(V)) + {} + + const u32 id, ver; + const u16 key_t_size, value_t_size; + + } m_header; + + std::fstream m_file; }; #endif // _LINEAR_DISKCACHE diff --git a/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.cpp b/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.cpp index 0a2b719e5d..c186a36204 100644 --- a/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.cpp +++ b/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.cpp @@ -26,7 +26,7 @@ namespace D3D { // bytecode->shader -ID3D11VertexShader* CreateVertexShaderFromByteCode(void* bytecode, unsigned int len) +ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len) { ID3D11VertexShader* v_shader; HRESULT hr = D3D::device->CreateVertexShader(bytecode, len, NULL, &v_shader); @@ -71,7 +71,7 @@ bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob) } // bytecode->shader -ID3D11PixelShader* CreatePixelShaderFromByteCode(void* bytecode, unsigned int len) +ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len) { ID3D11PixelShader* p_shader; HRESULT hr = D3D::device->CreatePixelShader(bytecode, len, NULL, &p_shader); diff --git a/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.h b/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.h index 737a10dff7..75cb58c6cf 100644 --- a/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.h +++ b/Source/Plugins/Plugin_VideoDX11/Src/D3DShader.h @@ -21,8 +21,8 @@ namespace D3D { - ID3D11VertexShader* CreateVertexShaderFromByteCode(void* bytecode, unsigned int len); - ID3D11PixelShader* CreatePixelShaderFromByteCode(void* bytecode, unsigned int len); + ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len); + ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len); // The returned bytecode buffers should be Release()d. bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob); diff --git a/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.cpp b/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.cpp index d83fba4dfd..4dd0338539 100644 --- a/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.cpp +++ b/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.cpp @@ -38,7 +38,7 @@ extern int frameCount; PixelShaderCache::PSCache PixelShaderCache::PixelShaders; const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry; -LinearDiskCache g_ps_disk_cache; +LinearDiskCache g_ps_disk_cache; ID3D11PixelShader* s_ColorMatrixProgram = NULL; ID3D11PixelShader* s_ColorCopyProgram = NULL; @@ -158,17 +158,12 @@ void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const } // this class will load the precompiled shaders into our cache -class PixelShaderCacheInserter : public LinearDiskCacheReader { +class PixelShaderCacheInserter : public LinearDiskCacheReader +{ public: - void Read(const u8* key, int key_size, const u8* value, int value_size) + void Read(const PIXELSHADERUID &key, const u8 *value, u32 value_size) { - PIXELSHADERUID uid; - if (key_size != sizeof(uid)) { - ERROR_LOG(VIDEO, "Wrong key size in pixel shader cache"); - return; - } - memcpy(&uid, key, key_size); - PixelShaderCache::InsertByteCode(uid, (void*)value, value_size); + PixelShaderCache::InsertByteCode(key, value, value_size); } }; @@ -205,7 +200,7 @@ void PixelShaderCache::Init() char cache_filename[MAX_PATH]; sprintf(cache_filename, "%sdx11-%s-ps.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id); PixelShaderCacheInserter inserter; - g_ps_disk_cache.OpenAndRead(cache_filename, &inserter); + g_ps_disk_cache.OpenAndRead(cache_filename, inserter); } // ONLY to be used during shutdown. @@ -266,7 +261,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components) } // Insert the bytecode into the caches - g_ps_disk_cache.Append((u8*)&uid, sizeof(uid), (const u8*)pbytecode->Data(), pbytecode->Size()); + g_ps_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size()); g_ps_disk_cache.Sync(); bool result = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size()); @@ -275,7 +270,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components) return result; } -bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, void* bytecode, unsigned int bytecodelen) +bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const void* bytecode, unsigned int bytecodelen) { ID3D11PixelShader* shader = D3D::CreatePixelShaderFromByteCode(bytecode, bytecodelen); if (shader == NULL) diff --git a/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.h b/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.h index b1d114e3b4..37c2b9155f 100644 --- a/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.h +++ b/Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.h @@ -33,7 +33,7 @@ public: static void Clear(); static void Shutdown(); static bool SetShader(DSTALPHA_MODE dstAlphaMode, u32 components); - static bool InsertByteCode(const PIXELSHADERUID &uid, void* bytecode, unsigned int bytecodelen); + static bool InsertByteCode(const PIXELSHADERUID &uid, const void* bytecode, unsigned int bytecodelen); static ID3D11PixelShader* GetColorMatrixProgram(); static ID3D11PixelShader* GetColorCopyProgram(); diff --git a/Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.cpp b/Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.cpp index b1419460db..8fdbe7cd20 100644 --- a/Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.cpp +++ b/Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.cpp @@ -40,7 +40,7 @@ static ID3D11VertexShader* ClearVertexShader = NULL; static ID3D11InputLayout* SimpleLayout = NULL; static ID3D11InputLayout* ClearLayout = NULL; -LinearDiskCache g_vs_disk_cache; +LinearDiskCache g_vs_disk_cache; ID3D11VertexShader* VertexShaderCache::GetSimpleVertexShader() { return SimpleVertexShader; } ID3D11VertexShader* VertexShaderCache::GetClearVertexShader() { return ClearVertexShader; } @@ -81,21 +81,15 @@ void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const } // this class will load the precompiled shaders into our cache -class VertexShaderCacheInserter : public LinearDiskCacheReader { +class VertexShaderCacheInserter : public LinearDiskCacheReader +{ public: - void Read(const u8 *key, int key_size, const u8 *value, int value_size) + void Read(const VERTEXSHADERUID &key, const u8 *value, u32 value_size) { - VERTEXSHADERUID uid; - if (key_size != sizeof(uid)) - { - ERROR_LOG(VIDEO, "Wrong key size in vertex shader cache"); - return; - } - memcpy(&uid, key, key_size); - D3DBlob* blob = new D3DBlob(value_size, value); - VertexShaderCache::InsertByteCode(uid, blob); + VertexShaderCache::InsertByteCode(key, blob); blob->Release(); + } }; @@ -183,7 +177,7 @@ void VertexShaderCache::Init() char cache_filename[MAX_PATH]; sprintf(cache_filename, "%sdx11-%s-vs.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id); VertexShaderCacheInserter inserter; - g_vs_disk_cache.OpenAndRead(cache_filename, &inserter); + g_vs_disk_cache.OpenAndRead(cache_filename, inserter); } void VertexShaderCache::Clear() @@ -238,7 +232,7 @@ bool VertexShaderCache::SetShader(u32 components) PanicAlert("Failed to compile Vertex Shader %s %d:\n\n%s", __FILE__, __LINE__, code); return false; } - g_vs_disk_cache.Append((u8*)&uid, sizeof(uid), (const u8*)pbytecode->Data(), pbytecode->Size()); + g_vs_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size()); g_vs_disk_cache.Sync(); bool result = InsertByteCode(uid, pbytecode); diff --git a/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp b/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp index 208a7f9fbb..4732c58631 100644 --- a/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp +++ b/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp @@ -41,7 +41,7 @@ PixelShaderCache::PSCache PixelShaderCache::PixelShaders; const PixelShaderCache::PSCacheEntry *PixelShaderCache::last_entry; -static LinearDiskCache g_ps_disk_cache; +static LinearDiskCache g_ps_disk_cache; static std::set unique_shaders; #define MAX_SSAA_SHADERS 3 @@ -87,17 +87,12 @@ void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const D3D::dev->SetPixelShaderConstantF(const_number, f, count); } -class PixelShaderCacheInserter : public LinearDiskCacheReader { +class PixelShaderCacheInserter : public LinearDiskCacheReader +{ public: - void Read(const u8 *key, int key_size, const u8 *value, int value_size) + void Read(const PIXELSHADERUID &key, const u8 *value, u32 value_size) { - PIXELSHADERUID uid; - if (key_size != sizeof(uid)) { - ERROR_LOG(VIDEO, "Wrong key size in pixel shader cache"); - return; - } - memcpy(&uid, key, key_size); - PixelShaderCache::InsertByteCode(uid, value, value_size, false); + PixelShaderCache::InsertByteCode(key, value, value_size, false); } }; @@ -239,7 +234,7 @@ void PixelShaderCache::Init() char cache_filename[MAX_PATH]; sprintf(cache_filename, "%sdx9-%s-ps.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id); PixelShaderCacheInserter inserter; - g_ps_disk_cache.OpenAndRead(cache_filename, &inserter); + g_ps_disk_cache.OpenAndRead(cache_filename, inserter); } // ONLY to be used during shutdown. @@ -345,7 +340,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components) } // Insert the bytecode into the caches - g_ps_disk_cache.Append((u8 *)&uid, sizeof(uid), bytecode, bytecodelen); + g_ps_disk_cache.Append(uid, bytecode, bytecodelen); g_ps_disk_cache.Sync(); // And insert it into the shader cache. diff --git a/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp b/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp index c55b927101..4310f5464b 100644 --- a/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp +++ b/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp @@ -42,7 +42,7 @@ const VertexShaderCache::VSCacheEntry *VertexShaderCache::last_entry; static LPDIRECT3DVERTEXSHADER9 SimpleVertexShader[MAX_SSAA_SHADERS]; static LPDIRECT3DVERTEXSHADER9 ClearVertexShader; -LinearDiskCache g_vs_disk_cache; +LinearDiskCache g_vs_disk_cache; LPDIRECT3DVERTEXSHADER9 VertexShaderCache::GetSimpleVertexShader(int level) { @@ -54,7 +54,6 @@ LPDIRECT3DVERTEXSHADER9 VertexShaderCache::GetClearVertexShader() return ClearVertexShader; } - void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) { const float f[4] = { f1, f2, f3, f4 }; @@ -85,19 +84,12 @@ void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const } // this class will load the precompiled shaders into our cache -class VertexShaderCacheInserter : public LinearDiskCacheReader { +class VertexShaderCacheInserter : public LinearDiskCacheReader +{ public: - void Read(const u8 *key, int key_size, const u8 *value, int value_size) + void Read(const VERTEXSHADERUID &key, const u8 *value, u32 value_size) { - VERTEXSHADERUID uid; - if (key_size != sizeof(uid)) - { - ERROR_LOG(VIDEO, "Wrong key size in vertex shader cache"); - return; - } - memcpy(&uid, key, key_size); - - VertexShaderCache::InsertByteCode(uid, value, value_size, false); + VertexShaderCache::InsertByteCode(key, value, value_size, false); } }; @@ -182,7 +174,7 @@ void VertexShaderCache::Init() char cache_filename[MAX_PATH]; sprintf(cache_filename, "%sdx9-%s-vs.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id); VertexShaderCacheInserter inserter; - g_vs_disk_cache.OpenAndRead(cache_filename, &inserter); + g_vs_disk_cache.OpenAndRead(cache_filename, inserter); } void VertexShaderCache::Clear() @@ -257,7 +249,7 @@ bool VertexShaderCache::SetShader(u32 components) } return false; } - g_vs_disk_cache.Append((u8 *)&uid, sizeof(uid), bytecode, bytecodelen); + g_vs_disk_cache.Append(uid, bytecode, bytecodelen); g_vs_disk_cache.Sync(); bool result = InsertByteCode(uid, bytecode, bytecodelen, true);