More compiler fixes.

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;

CLTool/src/clwin32.cpp

@@ -1,3 +1,183 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <Windows.h>
+
+#include "BlockStats.h"
+#include "TexComp.h"
+#include "ImageFile.h"
+#include "Image.h"
+
+void PrintUsage() {
+   fprintf(stderr, "Usage: tc [-l] [-q <quality>] [-n <num>] [-simd] [-t <threads> [-j <jobs>]] <imagefile>\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;
+}

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();
 };
 
 ////////////////////////////////////////////////////////////////////////////////

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));

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];
 }