diff --git a/BPTCEncoder/src/BC7Compressor.cpp b/BPTCEncoder/src/BC7Compressor.cpp index bcfa8a4..ae9883a 100755 --- a/BPTCEncoder/src/BC7Compressor.cpp +++ b/BPTCEncoder/src/BC7Compressor.cpp @@ -2337,7 +2337,7 @@ namespace BC7C assert(idxMode < 2); assert(rotMode < 4); - assert(shapeIdx < ((mode == 0)? 16 : 64)); + assert(shapeIdx < uint32((mode == 0)? 16 : 64)); uint32 cp = attrs->colorChannelPrecision; const uint32 shift = 8 - cp; diff --git a/CLTool/src/clwin32.cpp b/CLTool/src/clwin32.cpp index 202de88..0fde80a 100644 --- a/CLTool/src/clwin32.cpp +++ b/CLTool/src/clwin32.cpp @@ -1,3 +1,183 @@ +#include +#include +#include +#include + +#include "BlockStats.h" +#include "TexComp.h" +#include "ImageFile.h" +#include "Image.h" + +void PrintUsage() { + fprintf(stderr, "Usage: tc [-l] [-q ] [-n ] [-simd] [-t [-j ]] \n"); +} + +void ExtractBasename(const char *filename, char *buf, uint32 bufSz) { + size_t len = strlen(filename); + const char *end = filename + len; + while(--end != filename) { + if(*end == '.') + { + uint32 numChars = int32(end - filename + 1); + uint32 toCopy = (numChars > bufSz)? bufSz : numChars; + memcpy(buf, filename, toCopy); + buf[toCopy - 1] = '\0'; + return; + } + } +} int main(int argc, char **argv) { -} + + int fileArg = 1; + if(fileArg == argc) { + PrintUsage(); + exit(1); + } + + int numJobs = 0; + int quality = 50; + int numThreads = 1; + int numCompressions = 1; + bool bUseSIMD = false; + bool bSaveLog = false; + + bool knowArg = false; + do { + knowArg = false; + + if(strcmp(argv[fileArg], "-n") == 0) { + fileArg++; + + if(fileArg == argc || (numCompressions = atoi(argv[fileArg])) < 0) { + PrintUsage(); + exit(1); + } + + fileArg++; + knowArg = true; + continue; + } + + if(strcmp(argv[fileArg], "-l") == 0) { + fileArg++; + bSaveLog = true; + knowArg = true; + continue; + } + + if(strcmp(argv[fileArg], "-simd") == 0) { + fileArg++; + bUseSIMD = true; + knowArg = true; + continue; + } + + if(strcmp(argv[fileArg], "-t") == 0) { + fileArg++; + + if(fileArg == argc || (numThreads = atoi(argv[fileArg])) < 1) { + PrintUsage(); + exit(1); + } + + fileArg++; + knowArg = true; + continue; + } + + if(strcmp(argv[fileArg], "-q") == 0) { + fileArg++; + + if(fileArg == argc || (quality = atoi(argv[fileArg])) < 0) { + PrintUsage(); + exit(1); + } + + fileArg++; + knowArg = true; + continue; + } + + if(strcmp(argv[fileArg], "-j") == 0) { + fileArg++; + + if(fileArg == argc || (numJobs = atoi(argv[fileArg])) < 0) { + PrintUsage(); + exit(1); + } + + fileArg++; + knowArg = true; + continue; + } + + } while(knowArg && fileArg < argc); + + if(numThreads > 1 && bSaveLog) { + bSaveLog = false; + fprintf(stderr, "WARNING: Will not save log because implementation is not thread safe.\n" + "If you'd like, send a complaint to pavel@cs.unc.edu to get this done faster.\n"); + } + + if(fileArg == argc) { + PrintUsage(); + exit(1); + } + + char basename[256]; + ExtractBasename(argv[fileArg], basename, 256); + + ImageFile file (argv[fileArg]); + if(!file.Load()) { + fprintf(stderr, "Error loading file: %s\n", argv[fileArg]); + return 1; + } + + const Image *img = file.GetImage(); + + int numBlocks = (img->GetWidth() * img->GetHeight())/16; + BlockStatManager *statManager = NULL; + if(bSaveLog) { + statManager = new BlockStatManager(numBlocks); + } + + SCompressionSettings settings; + settings.bUseSIMD = bUseSIMD; + settings.iNumThreads = numThreads; + settings.iQuality = quality; + settings.iNumCompressions = numCompressions; + settings.iJobSize = numJobs; + settings.pStatManager = statManager; + + CompressedImage *ci = img->Compress(settings); + if(NULL == ci) { + fprintf(stderr, "Error compressing image!\n"); + return 1; + } + + double PSNR = img->ComputePSNR(*ci); + if(PSNR > 0.0) { + fprintf(stdout, "PSNR: %.3f\n", PSNR); + } + else { + fprintf(stderr, "Error computing PSNR\n"); + } + + if(bSaveLog) { + strcat_s(basename, ".log"); + statManager->ToFile(basename); + basename[strlen(basename) - 4] = '\0'; + } + strcat_s(basename, "-bc7.png"); + Image cImg (*ci); + ImageFile cImgFile (basename, eFileFormat_PNG, cImg); + cImgFile.Write(); + + // Cleanup + delete ci; + if(statManager) + delete statManager; + + return 0; +} \ No newline at end of file diff --git a/Core/include/Thread.h b/Core/include/Thread.h index b7435e1..b66ee63 100644 --- a/Core/include/Thread.h +++ b/Core/include/Thread.h @@ -3,6 +3,11 @@ #include "TexCompTypes.h" +//!HACK! Apparently MSVC has issues with Yield()...???? +#ifdef _MSC_VER +#undef Yield +#endif + //////////////////////////////////////////////////////////////////////////////// // // Base implementation @@ -68,9 +73,9 @@ class TCThread : public TCThreadBase { public: TCThread(TCCallable &); - - void Join(); + static void Yield(); + void Join(); }; //////////////////////////////////////////////////////////////////////////////// diff --git a/Core/src/StopWatchWin32.cpp b/Core/src/StopWatchWin32.cpp index c51965b..e711ff9 100755 --- a/Core/src/StopWatchWin32.cpp +++ b/Core/src/StopWatchWin32.cpp @@ -39,6 +39,8 @@ public: } }; +StopWatch::StopWatch() : impl(new StopWatchImpl) { } + StopWatch::StopWatch(const StopWatch &other) { impl = new StopWatchImpl(); memcpy(impl, other.impl, sizeof(StopWatchImpl)); diff --git a/Core/src/WorkerQueue.cpp b/Core/src/WorkerQueue.cpp index 113fa09..f41d13e 100644 --- a/Core/src/WorkerQueue.cpp +++ b/Core/src/WorkerQueue.cpp @@ -231,7 +231,7 @@ WorkerThread::EAction WorkerQueue::AcceptThreadData(uint32 threadIdx) { const uint8 *WorkerQueue::GetSrcForThread(const int threadIdx) const { assert(m_Offsets[threadIdx] >= 0); assert(threadIdx >= 0); - assert(threadIdx < m_NumThreads); + assert(threadIdx < int(m_NumThreads)); const uint32 inBufBlockSz = 16 * 4; return m_InBuf + m_Offsets[threadIdx] * inBufBlockSz; @@ -240,7 +240,7 @@ const uint8 *WorkerQueue::GetSrcForThread(const int threadIdx) const { uint8 *WorkerQueue::GetDstForThread(const int threadIdx) const { assert(m_Offsets[threadIdx] >= 0); assert(threadIdx >= 0); - assert(threadIdx < m_NumThreads); + assert(threadIdx < int(m_NumThreads)); const uint32 outBufBlockSz = 16; return m_OutBuf + m_Offsets[threadIdx] * outBufBlockSz; @@ -249,7 +249,7 @@ uint8 *WorkerQueue::GetDstForThread(const int threadIdx) const { uint32 WorkerQueue::GetNumBlocksForThread(const int threadIdx) const { assert(m_Offsets[threadIdx] >= 0); assert(threadIdx >= 0); - assert(threadIdx < m_NumThreads); + assert(threadIdx < int(m_NumThreads)); return m_NumBlocks[threadIdx]; }