Merge branch 'master' of https://github.com/highfidelity/hifi into skin

interface/src/CrashReporter.cpp

@@ -10,16 +10,20 @@
 //
 
 
-#ifdef HAS_BUGSPLAT
+#include "Application.h"
 #include "CrashReporter.h"
 
+#ifdef _WIN32
 #include <new.h>
 #include <Windows.h>
+#include <DbgHelp.h>
 
 #include <csignal>
-
 #include <QDebug>
 
+
+#pragma comment(lib, "Dbghelp.lib")
+
 // SetUnhandledExceptionFilter can be overridden by the CRT at the point that an error occurs. More information
 // can be found here: http://www.codeproject.com/Articles/154686/SetUnhandledExceptionFilter-and-the-C-C-Runtime-Li
 // A fairly common approach is to patch the SetUnhandledExceptionFilter so that it cannot be overridden and so
@@ -77,13 +81,37 @@ BOOL redirectLibraryFunctionToFunction(char* library, char* function, void* fn)
     return bRet;
 }
 
+void printStackTrace(ULONG framesToSkip = 1) {
+    HANDLE process = GetCurrentProcess();
+    SymInitialize(process, NULL, TRUE);
+    void* stack[100];
+    uint16_t frames = CaptureStackBackTrace(framesToSkip, 100, stack, NULL);
+    SYMBOL_INFO* symbol = (SYMBOL_INFO *)calloc(sizeof(SYMBOL_INFO) + 256 * sizeof(char), 1);
+    symbol->MaxNameLen = 255;
+    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+
+    for (uint16_t i = 0; i < frames; ++i) {
+        SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol);
+        qWarning() << QString("%1: %2 - 0x%0X").arg(QString::number(frames - i - 1), QString(symbol->Name), QString::number(symbol->Address, 16));
+    }
+
+    free(symbol);
+
+    // Try to force the log to sync to the filesystem
+    auto app = qApp;
+    if (app && app->getLogger()) {
+        app->getLogger()->sync();
+    }
+}
 
 void handleSignal(int signal) {
     // Throw so BugSplat can handle
     throw(signal);
 }
 
-void handlePureVirtualCall() {
+void __cdecl handlePureVirtualCall() {
+    qWarning() << "Pure virtual function call detected";
+    printStackTrace(2);
     // Throw so BugSplat can handle
     throw("ERROR: Pure virtual call");
 }
@@ -107,6 +135,8 @@ _purecall_handler __cdecl noop_set_purecall_handler(_purecall_handler pNew) {
     return nullptr;
 }
 
+#ifdef HAS_BUGSPLAT
+
 static const DWORD BUG_SPLAT_FLAGS = MDSF_PREVENTHIJACKING | MDSF_USEGUARDMEMORY;
 
 CrashReporter::CrashReporter(QString bugSplatDatabase, QString bugSplatApplicationName, QString version)
@@ -133,3 +163,4 @@ CrashReporter::CrashReporter(QString bugSplatDatabase, QString bugSplatApplicati
     }
 }
 #endif
+#endif

interface/src/FileLogger.cpp

@@ -115,3 +115,7 @@ QString FileLogger::getLogData() {
     }
     return result;
 }
+
+void FileLogger::sync() {
+    _persistThreadInstance->waitIdle();
+}

interface/src/FileLogger.h

@@ -28,6 +28,7 @@ public:
     virtual void addMessage(const QString&) override;
     virtual QString getLogData() override;
     virtual void locateLog() override;
+    void sync();
 
 signals:
     void rollingLogFile(QString newFilename);

libraries/audio/src/AudioHRTF.cpp

@@ -10,7 +10,6 @@
 //
 
 #include <math.h>
-#include <stdint.h>
 #include <string.h>
 #include <assert.h>
 
@@ -119,68 +118,18 @@ static void FIR_1x4_SSE(float* src, float* dst0, float* dst1, float* dst2, float
     }
 }
 
-//
-// Detect AVX/AVX2 support
-//
-
-#if defined(_MSC_VER)
-
-#include <intrin.h>
-
-static bool cpuSupportsAVX() {
-    int info[4];
-    int mask = (1 << 27) | (1 << 28);   // OSXSAVE and AVX
-
-    __cpuidex(info, 0x1, 0);
-
-    bool result = false;
-    if ((info[2] & mask) == mask) {
-
-        if ((_xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
-            result = true;
-        }
-    }
-    return result;
-}
-
-#elif defined(__GNUC__)
-
-#include <cpuid.h>
-
-static bool cpuSupportsAVX() {
-    unsigned int eax, ebx, ecx, edx;
-    unsigned int mask = (1 << 27) | (1 << 28);   // OSXSAVE and AVX
-
-    bool result = false;
-    if (__get_cpuid(0x1, &eax, &ebx, &ecx, &edx) && ((ecx & mask) == mask)) {
-
-        __asm__("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0));
-        if ((eax & 0x6) == 0x6) {
-            result = true;
-        }
-    }
-    return result;    
-}
-
-#else
-
-static bool cpuSupportsAVX() {
-    return false;
-}
-
-#endif
-
 //
 // Runtime CPU dispatch
 //
 
-typedef void FIR_1x4_t(float* src, float* dst0, float* dst1, float* dst2, float* dst3, float coef[4][HRTF_TAPS], int numFrames);
+#include "CPUDetect.h"
-FIR_1x4_t FIR_1x4_AVX;  // separate compilation with VEX-encoding enabled
+
+void FIR_1x4_AVX(float* src, float* dst0, float* dst1, float* dst2, float* dst3, float coef[4][HRTF_TAPS], int numFrames);
 
 static void FIR_1x4(float* src, float* dst0, float* dst1, float* dst2, float* dst3, float coef[4][HRTF_TAPS], int numFrames) {
 
-    static FIR_1x4_t* f = cpuSupportsAVX() ? FIR_1x4_AVX : FIR_1x4_SSE; // init on first call
+    static auto f = cpuSupportsAVX() ? FIR_1x4_AVX : FIR_1x4_SSE;
-    (*f)(src, dst0, dst1, dst2, dst3, coef, numFrames);                 // dispatch
+    (*f)(src, dst0, dst1, dst2, dst3, coef, numFrames); // dispatch
 }
 
 // 4 channel planar to interleaved

libraries/audio/src/AudioHRTF.h

@@ -32,7 +32,7 @@ public:
     // input: mono source
     // output: interleaved stereo mix buffer (accumulates into existing output)
     // index: HRTF subject index
-    // azimuth: clockwise panning angle [0, 360] in degrees
+    // azimuth: clockwise panning angle in radians
     // gain: gain factor for distance attenuation
     // numFrames: must be HRTF_BLOCK in this version
     //

libraries/shared/src/GenericQueueThread.h

@@ -12,9 +12,10 @@
 
 #include <stdint.h>
 
-#include <QQueue>
+#include <QtCore/QElapsedTimer>
-#include <QMutex>
+#include <QtCore/QMutex>
-#include <QWaitCondition>
+#include <QtCore/QQueue>
+#include <QtCore/QWaitCondition>
 
 #include "GenericThread.h"
 #include "NumericalConstants.h"
@@ -35,6 +36,25 @@ public:
         _hasItems.wakeAll();
     }
 
+    void waitIdle(uint32_t maxWaitMs = UINT32_MAX) {
+        QElapsedTimer timer;
+        timer.start();
+
+        // FIXME this will work as long as the thread doing the wait
+        // is the only thread which can add work to the queue.  
+        // It would be better if instead we had a queue empty condition to wait on
+        // that would ensure that we get woken as soon as we're idle the very 
+        // first time the queue was empty.
+        while (timer.elapsed() < maxWaitMs) {
+            lock();
+            if (!_items.size()) {
+                unlock();
+                return;
+            }
+            unlock();
+        }
+    }
+
 protected:
     virtual void queueItemInternal(const T& t) {
         _items.push_back(t);
@@ -44,6 +64,7 @@ protected:
         return MSECS_PER_SECOND;
     }
 
+
     virtual bool process() {
         lock();
         if (!_items.size()) {