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

assignment-client/src/audio/AudioMixer.cpp

@@ -141,11 +141,6 @@ int AudioMixer::addStreamToMixForListeningNodeWithStream(AudioMixerClientData* l
         return 0;
     }
     
-    // if the stream should be muted, bail
-    if (shouldMute(streamToAdd->getQuietestFrameLoudness())) {
-        return 0;
-    }
-    
     float bearingRelativeAngleToSource = 0.0f;
     float attenuationCoefficient = 1.0f;
     int numSamplesDelay = 0;
@@ -722,6 +717,29 @@ void AudioMixer::run() {
                 // That's how the popped audio data will be read for mixing (but only if the pop was successful)
                 nodeData->checkBuffersBeforeFrameSend();
             
+                // if the stream should be muted, send mute packet
+                if (shouldMute(nodeData->getAvatarAudioStream()->getQuietestFrameLoudness())) {
+                    static const int TIME_BETWEEN_MUTES = 5; // in secs
+                    if (usecTimestampNow() - nodeData->getAvatarAudioStream()->getLastMuted() >
+                        TIME_BETWEEN_MUTES * USECS_PER_SECOND) {
+                        int headerSize = numBytesForPacketHeaderGivenPacketType(PacketTypeMuteEnvironment);
+                        int packetSize = headerSize + sizeof(glm::vec3) + sizeof(float);
+                        
+                        // Fake data to force mute
+                        glm::vec3 position = nodeData->getAvatarAudioStream()->getPosition();
+                        float radius = 1.0f;
+                        
+                        char* packet = (char*)malloc(packetSize);
+                        populatePacketHeader(packet, PacketTypeMuteEnvironment);
+                        memcpy(packet + headerSize, &position, sizeof(glm::vec3));
+                        memcpy(packet + headerSize + sizeof(glm::vec3), &radius, sizeof(float));
+                        
+                        nodeList->writeDatagram(packet, packetSize, node);
+                        nodeData->getAvatarAudioStream()->setLastMutedNow();
+                        free(packet);
+                    }
+                }
+                
                 if (node->getType() == NodeType::Agent && node->getActiveSocket()
                     && nodeData->getAvatarAudioStream()) {
 

assignment-client/src/audio/AvatarAudioStream.cpp

@@ -14,7 +14,8 @@
 #include "AvatarAudioStream.h"
 
 AvatarAudioStream::AvatarAudioStream(bool isStereo, const InboundAudioStream::Settings& settings) :
-    PositionalAudioStream(PositionalAudioStream::Microphone, isStereo, settings)
+    PositionalAudioStream(PositionalAudioStream::Microphone, isStereo, settings),
+    _lastMuted(usecTimestampNow())
 {
 }
 

assignment-client/src/audio/AvatarAudioStream.h

@@ -19,13 +19,18 @@
 class AvatarAudioStream : public PositionalAudioStream {
 public:
     AvatarAudioStream(bool isStereo, const InboundAudioStream::Settings& settings);
-
+    
+    qint64 getLastMuted() const { return _lastMuted; }
+    void setLastMutedNow() { _lastMuted = usecTimestampNow(); }
+    
 private:
     // disallow copying of AvatarAudioStream objects
     AvatarAudioStream(const AvatarAudioStream&);
     AvatarAudioStream& operator= (const AvatarAudioStream&);
 
     int parseStreamProperties(PacketType type, const QByteArray& packetAfterSeqNum, int& numAudioSamples);
+    
+    qint64 _lastMuted;
 };
 
 #endif // hifi_AvatarAudioStream_h

interface/src/Application.cpp

@@ -724,11 +724,11 @@ void Application::paintGL() {
         displaySide(*whichCamera);
         glPopMatrix();
 
-        if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
+        if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
-            renderRearViewMirror(_mirrorViewRect);
-
-        } else if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
             _rearMirrorTools->render(true);
+        
+        } else if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
+            renderRearViewMirror(_mirrorViewRect);       
         }
 
         _glowEffect.render();
@@ -786,7 +786,7 @@ void Application::updateProjectionMatrix(Camera& camera, bool updateViewFrustum)
     // Tell our viewFrustum about this change, using the application camera
     if (updateViewFrustum) {
         loadViewFrustum(camera, _viewFrustum);
-        computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+        _viewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
 
         // If we're in Display Frustum mode, then we want to use the slightly adjust near/far clip values of the
         // _viewFrustumOffsetCamera, so that we can see more of the application content in the application's frustum
@@ -2009,25 +2009,17 @@ void Application::init() {
 
 void Application::closeMirrorView() {
     if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
-        Menu::getInstance()->triggerOption(MenuOption::Mirror);;
+        Menu::getInstance()->triggerOption(MenuOption::Mirror);
     }
 }
 
 void Application::restoreMirrorView() {
-    if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
-        Menu::getInstance()->triggerOption(MenuOption::Mirror);;
-    }
-
     if (!Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
         Menu::getInstance()->triggerOption(MenuOption::FullscreenMirror);
     }
 }
 
 void Application::shrinkMirrorView() {
-    if (!Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
-        Menu::getInstance()->triggerOption(MenuOption::Mirror);;
-    }
-
     if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
         Menu::getInstance()->triggerOption(MenuOption::FullscreenMirror);
     }
@@ -4314,8 +4306,6 @@ bool Application::isVSyncOn() const {
     if (wglewGetExtension("WGL_EXT_swap_control")) {
         int swapInterval = wglGetSwapIntervalEXT();
         return (swapInterval > 0);
-    } else {
-        return true;
     }
 #elif defined(Q_OS_LINUX)
     // TODO: write the poper code for linux
@@ -4326,10 +4316,9 @@ bool Application::isVSyncOn() const {
     } else {
         return true;
     }
-    */
+    */    
-#else
-    return true;
 #endif
+    return true;
 }
 
 bool Application::isVSyncEditable() const {
@@ -4344,7 +4333,6 @@ bool Application::isVSyncEditable() const {
         return true;
     }
     */
-#else
 #endif
     return false;
 }

interface/src/Audio.cpp

@@ -97,6 +97,9 @@ Audio::Audio(QObject* parent) :
     _muted(false),
     _reverb(false),
     _reverbOptions(&_scriptReverbOptions),
+    _gverb(NULL),
+    _iconColor(1.0f),
+    _iconPulseTimeReference(usecTimestampNow()),
     _processSpatialAudio(false),
     _spatialAudioStart(0),
     _spatialAudioFinish(0),
@@ -544,7 +547,7 @@ void Audio::addReverb(int16_t* samplesData, int numSamples, QAudioFormat& audioF
         gverb_do(_gverb, value, &lValue, &rValue);
 
         // Mix, accounting for clipping, the left and right channels. Ignore the rest.
-        for (unsigned int j = sample; j < sample + audioFormat.channelCount(); j++) {
+        for (int j = sample; j < sample + audioFormat.channelCount(); j++) {
             if (j == sample) {
                 // left channel
                 int lResult = glm::clamp((int)(samplesData[j] * dryFraction + lValue * wetFraction), -32768, 32767);
@@ -1342,8 +1345,11 @@ void Audio::handleAudioByteArray(const QByteArray& audioByteArray, const AudioIn
         QAudioOutput* localSoundOutput = new QAudioOutput(getNamedAudioDeviceForMode(QAudio::AudioOutput, _outputAudioDeviceName), localFormat, this);
         
         QIODevice* localIODevice = localSoundOutput->start();
-        qDebug() << "Writing" << audioByteArray.size() << "to" << localIODevice;
+        if (localIODevice) {
-        localIODevice->write(audioByteArray);
+            localIODevice->write(audioByteArray);
+        } else {
+            qDebug() << "Unable to handle audio byte array. Error:" << localSoundOutput->error();
+        }
     } else {
         qDebug() << "Audio::handleAudioByteArray called with an empty byte array. Sound is likely still downloading.";
     }
@@ -1390,23 +1396,37 @@ void Audio::renderToolBox(int x, int y, bool boxed) {
     _iconBounds = QRect(x, y, MUTE_ICON_SIZE, MUTE_ICON_SIZE);
     if (!_muted) {
         glBindTexture(GL_TEXTURE_2D, _micTextureId);
+        _iconColor = 1.0f;
     } else {
         glBindTexture(GL_TEXTURE_2D, _muteTextureId);
+        
+        // Make muted icon pulsate
+        static const float PULSE_MIN = 0.4f;
+        static const float PULSE_MAX = 1.0f;
+        static const float PULSE_FREQUENCY = 1.0f; // in Hz
+        qint64 now = usecTimestampNow();
+        if (now - _iconPulseTimeReference > USECS_PER_SECOND) {
+            // Prevents t from getting too big, which would diminish glm::cos precision
+            _iconPulseTimeReference = now - ((now - _iconPulseTimeReference) % USECS_PER_SECOND);
+        }
+        float t = (float)(now - _iconPulseTimeReference) / (float)USECS_PER_SECOND;
+        float pulseFactor = (glm::cos(t * PULSE_FREQUENCY * 2.0f * PI) + 1.0f) / 2.0f;
+        _iconColor = PULSE_MIN + (PULSE_MAX - PULSE_MIN) * pulseFactor;
     }
 
-    glColor3f(1,1,1);
+    glColor3f(_iconColor, _iconColor, _iconColor);
     glBegin(GL_QUADS);
 
-    glTexCoord2f(1, 1);
+    glTexCoord2f(1.0f, 1.0f);
     glVertex2f(_iconBounds.left(), _iconBounds.top());
 
-    glTexCoord2f(0, 1);
+    glTexCoord2f(0.0f, 1.0f);
     glVertex2f(_iconBounds.right(), _iconBounds.top());
 
-    glTexCoord2f(0, 0);
+    glTexCoord2f(0.0f, 0.0f);
     glVertex2f(_iconBounds.right(), _iconBounds.bottom());
 
-    glTexCoord2f(1, 0);
+    glTexCoord2f(1.0f, 0.0f);
     glVertex2f(_iconBounds.left(), _iconBounds.bottom());
 
     glEnd();

interface/src/Audio.h

@@ -248,11 +248,13 @@ private:
     AudioEffectOptions _scriptReverbOptions;
     AudioEffectOptions _zoneReverbOptions;
     AudioEffectOptions* _reverbOptions;
-    ty_gverb *_gverb;
+    ty_gverb* _gverb;
     GLuint _micTextureId;
     GLuint _muteTextureId;
     GLuint _boxTextureId;
     QRect _iconBounds;
+    float _iconColor;
+    qint64 _iconPulseTimeReference;
     
     /// Audio callback in class context.
     inline void performIO(int16_t* inputLeft, int16_t* outputLeft, int16_t* outputRight);

interface/src/Menu.cpp

@@ -386,7 +386,7 @@ Menu::Menu() :
 
 #if defined(Q_OS_MAC)
 #else
-        QAction* vsyncAction = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderTargetFramerateVSyncOn, 0, true, this, SLOT(changeVSync()));
+        addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderTargetFramerateVSyncOn, 0, true, this, SLOT(changeVSync()));
 #endif
     }
 

interface/src/gpu/Batch.cpp

@@ -106,7 +106,7 @@ void Batch::setInputStream(Slot startChannel, const BufferStream& stream) {
         const Buffers& buffers = stream.getBuffers();
         const Offsets& offsets = stream.getOffsets();
         const Offsets& strides = stream.getStrides();
-        for (int i = 0; i < buffers.size(); i++) {
+        for (unsigned int i = 0; i < buffers.size(); i++) {
             setInputBuffer(startChannel + i, buffers[i], offsets[i], strides[i]);
         }
     }

interface/src/gpu/GLBackend.cpp

@@ -31,15 +31,15 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
 
     (&::gpu::GLBackend::do_glEnable),
     (&::gpu::GLBackend::do_glDisable),
-
+
     (&::gpu::GLBackend::do_glEnableClientState),
     (&::gpu::GLBackend::do_glDisableClientState),
 
     (&::gpu::GLBackend::do_glCullFace),
     (&::gpu::GLBackend::do_glAlphaFunc),
 
-    (&::gpu::GLBackend::do_glDepthFunc),
+    (&::gpu::GLBackend::do_glDepthFunc),
-    (&::gpu::GLBackend::do_glDepthMask),
+    (&::gpu::GLBackend::do_glDepthMask),
     (&::gpu::GLBackend::do_glDepthRange),
 
     (&::gpu::GLBackend::do_glBindBuffer),
@@ -57,18 +57,18 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::GLBackend::do_glPushMatrix),
     (&::gpu::GLBackend::do_glPopMatrix),
     (&::gpu::GLBackend::do_glMultMatrixf),
-    (&::gpu::GLBackend::do_glLoadMatrixf),
+    (&::gpu::GLBackend::do_glLoadMatrixf),
-    (&::gpu::GLBackend::do_glLoadIdentity),
+    (&::gpu::GLBackend::do_glLoadIdentity),
-    (&::gpu::GLBackend::do_glRotatef),
+    (&::gpu::GLBackend::do_glRotatef),
-    (&::gpu::GLBackend::do_glScalef),
+    (&::gpu::GLBackend::do_glScalef),
-    (&::gpu::GLBackend::do_glTranslatef),
+    (&::gpu::GLBackend::do_glTranslatef),
 
-    (&::gpu::GLBackend::do_glDrawArrays),
+    (&::gpu::GLBackend::do_glDrawArrays),
     (&::gpu::GLBackend::do_glDrawRangeElements),
-
+
-    (&::gpu::GLBackend::do_glColorPointer),
+    (&::gpu::GLBackend::do_glColorPointer),
-    (&::gpu::GLBackend::do_glNormalPointer),
+    (&::gpu::GLBackend::do_glNormalPointer),
-    (&::gpu::GLBackend::do_glTexCoordPointer),
+    (&::gpu::GLBackend::do_glTexCoordPointer),
     (&::gpu::GLBackend::do_glVertexPointer),
 
     (&::gpu::GLBackend::do_glVertexAttribPointer),
@@ -77,7 +77,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
 
     (&::gpu::GLBackend::do_glColor4f),
 
-    (&::gpu::GLBackend::do_glMaterialf),
+    (&::gpu::GLBackend::do_glMaterialf),
     (&::gpu::GLBackend::do_glMaterialfv),
 };
 
@@ -112,9 +112,8 @@ static const GLenum _elementTypeToGLType[NUM_TYPES]= {
 
 GLBackend::GLBackend() :
 
-    _inputFormat(0),
-    _inputAttributeActivation(0),
     _needInputFormatUpdate(true),
+    _inputFormat(0),
 
     _inputBuffersState(0),
     _inputBuffers(_inputBuffersState.size(), BufferPointer(0)),
@@ -122,7 +121,8 @@ GLBackend::GLBackend() :
     _inputBufferStrides(_inputBuffersState.size(), 0),
 
     _indexBuffer(0),
-    _indexBufferOffset(0)
+    _indexBufferOffset(0),
+    _inputAttributeActivation(0)
 {
 
 }
@@ -138,7 +138,7 @@ void GLBackend::renderBatch(Batch& batch) {
 
     GLBackend backend;
 
-    for (int i = 0; i < numCommands; i++) {
+    for (unsigned int i = 0; i < numCommands; i++) {
         CommandCall call = _commandCalls[(*command)];
         (backend.*(call))(batch, *offset);
         command++;
@@ -203,7 +203,7 @@ void GLBackend::do_drawIndexed(Batch& batch, uint32 paramOffset) {
 
     GLenum glType = _elementTypeToGLType[_indexBufferType];
 
-    glDrawElements(mode, numIndices, glType, (GLvoid*)(startIndex + _indexBufferOffset));
+    glDrawElements(mode, numIndices, glType, reinterpret_cast<GLvoid*>(startIndex + _indexBufferOffset));
     CHECK_GL_ERROR();
 }
 
@@ -265,7 +265,7 @@ void GLBackend::updateInput() {
             }
 
             // Manage Activation what was and what is expected now
-            for (int i = 0; i < newActivation.size(); i++) {
+            for (unsigned int i = 0; i < newActivation.size(); i++) {
                 bool newState = newActivation[i];
                 if (newState != _inputAttributeActivation[i]) {
 #if defined(SUPPORT_LEGACY_OPENGL)
@@ -314,7 +314,7 @@ void GLBackend::updateInput() {
                         CHECK_GL_ERROR();
                         _inputBuffersState[bufferNum] = false;
 
-                        for (int i = 0; i < channel._slots.size(); i++) {
+                        for (unsigned int i = 0; i < channel._slots.size(); i++) {
                             const Stream::Attribute& attrib = attributes.at(channel._slots[i]);
                             GLuint slot = attrib._slot;
                             GLuint count = attrib._element.getDimensionCount();
@@ -325,16 +325,16 @@ void GLBackend::updateInput() {
                             if (slot < NUM_CLASSIC_ATTRIBS) {
                                 switch (slot) {
                                 case Stream::POSITION:
-                                    glVertexPointer(count, type, stride, (GLvoid*)pointer);
+                                    glVertexPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));
                                     break;
                                 case Stream::NORMAL:
-                                    glNormalPointer(type, stride, (GLvoid*)pointer);
+                                    glNormalPointer(type, stride, reinterpret_cast<GLvoid*>(pointer));
                                     break;
                                 case Stream::COLOR:
-                                    glColorPointer(count, type, stride, (GLvoid*)pointer);
+                                    glColorPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));
                                     break;
                                 case Stream::TEXCOORD:
-                                    glTexCoordPointer(count, type, stride, (GLvoid*)pointer); 
+                                    glTexCoordPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer)); 
                                     break;
                                 };
                             } else {
@@ -342,7 +342,8 @@ void GLBackend::updateInput() {
                             {
                             #endif
                                 GLboolean isNormalized = attrib._element.isNormalized();
-                                glVertexAttribPointer(slot, count, type, isNormalized, stride, (GLvoid*)pointer);
+                                glVertexAttribPointer(slot, count, type, isNormalized, stride,
+                                    reinterpret_cast<GLvoid*>(pointer));
                             }
                             CHECK_GL_ERROR();
                         }

interface/src/gpu/Resource.cpp

@@ -8,6 +8,8 @@
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
+
+#include "Context.h"
 #include "Resource.h"
 
 #include <QDebug>

interface/src/renderer/Model.cpp

@@ -479,9 +479,7 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
         float bestDistance = std::numeric_limits<float>::max();
         float distanceToSubMesh;
         BoxFace subMeshFace;
-        BoxFace bestSubMeshFace;
         int subMeshIndex = 0;
-        int bestSubMeshIndex = -1;
     
         // If we hit the models box, then consider the submeshes...
         foreach(const AABox& subMeshBox, _calculatedMeshBoxes) {
@@ -489,10 +487,9 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
 
             if (subMeshBox.findRayIntersection(origin, direction, distanceToSubMesh, subMeshFace)) {
                 if (distanceToSubMesh < bestDistance) {
-                    bestSubMeshIndex = subMeshIndex;
                     bestDistance = distanceToSubMesh;
-                    bestSubMeshFace = subMeshFace;
                     intersectedSomething = true;
+                    face = subMeshFace;
                     extraInfo = geometry.getModelNameOfMesh(subMeshIndex);
                 }
             }

interface/src/ui/ApplicationOverlay.cpp

@@ -984,7 +984,9 @@ void ApplicationOverlay::renderAudioMeter() {
     const int AUDIO_METER_X = MIRROR_VIEW_LEFT_PADDING + MUTE_ICON_SIZE + AUDIO_METER_INSET + AUDIO_METER_GAP;
 
     int audioMeterY;
-    if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
+    bool boxed = Menu::getInstance()->isOptionChecked(MenuOption::Mirror) &&
+        !Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror);
+    if (boxed) {
         audioMeterY = MIRROR_VIEW_HEIGHT + AUDIO_METER_GAP + MUTE_ICON_PADDING;
     } else {
         audioMeterY = AUDIO_METER_GAP + MUTE_ICON_PADDING;
@@ -1022,9 +1024,7 @@ void ApplicationOverlay::renderAudioMeter() {
         renderCollisionOverlay(glWidget->width(), glWidget->height(), magnitude, 1.0f);
     }
 
-    audio->renderToolBox(MIRROR_VIEW_LEFT_PADDING + AUDIO_METER_GAP,
+    audio->renderToolBox(MIRROR_VIEW_LEFT_PADDING + AUDIO_METER_GAP, audioMeterY, boxed);
-                         audioMeterY,
-                         Menu::getInstance()->isOptionChecked(MenuOption::Mirror));
 
     audio->renderScope(glWidget->width(), glWidget->height());
 

interface/src/ui/RearMirrorTools.cpp

@@ -156,6 +156,9 @@ void RearMirrorTools::displayIcon(QRect bounds, QRect iconBounds, GLuint texture
     }
     glEnd();
     glPopMatrix();
+    
+    glMatrixMode(GL_MODELVIEW);
+    
     glBindTexture(GL_TEXTURE_2D, 0);
     glDisable(GL_TEXTURE_2D);
 }

interface/src/ui/TextRenderer.cpp

@@ -129,7 +129,7 @@ int TextRenderer::draw(int x, int y, const char* str) {
                                                         leftBottom.x, rightTop.y, ls, tt, };
 
         const int NUM_COLOR_SCALARS_PER_GLYPH = 4;
-        unsigned int colorBuffer[NUM_COLOR_SCALARS_PER_GLYPH] = { compactColor, compactColor, compactColor, compactColor };
+        int colorBuffer[NUM_COLOR_SCALARS_PER_GLYPH] = { compactColor, compactColor, compactColor, compactColor };
 
         gpu::Buffer::Size offset = sizeof(vertexBuffer) * _numGlyphsBatched;
         gpu::Buffer::Size colorOffset = sizeof(colorBuffer) * _numGlyphsBatched;
@@ -181,9 +181,9 @@ TextRenderer::TextRenderer(const Properties& properties) :
     _color(properties.color),
     _glyphsBuffer(new gpu::Buffer()),
     _glyphsColorBuffer(new gpu::Buffer()),
-    _numGlyphsBatched(0),
     _glyphsStreamFormat(new gpu::Stream::Format()),
-    _glyphsStream(new gpu::BufferStream())
+    _glyphsStream(new gpu::BufferStream()),
+    _numGlyphsBatched(0)
 {
     _glyphsStreamFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::POS_XYZ), 0);
     const int NUM_POS_COORDS = 2;

libraries/avatars/src/Player.cpp

@@ -297,7 +297,7 @@ void Player::play() {
     _injector->setOptions(_options);
 }
 
-void Player::setCurrentFrame(unsigned int currentFrame) {
+void Player::setCurrentFrame(int currentFrame) {
     if (_recording && currentFrame >= _recording->getFrameNumber()) {
         stopPlaying();
         return;
@@ -314,7 +314,7 @@ void Player::setCurrentFrame(unsigned int currentFrame) {
     }
 }
 
-void Player::setCurrentTime(unsigned int currentTime) {
+void Player::setCurrentTime(int currentTime) {
     if (currentTime >= _recording->getLength()) {
         stopPlaying();
         return;
@@ -393,7 +393,7 @@ bool Player::computeCurrentFrame() {
         _currentFrame = 0;
     }
     
-    quint64 elapsed = glm::clamp(Player::elapsed() - _audioOffset, (qint64)0, (qint64)_recording->getLength());
+    qint64 elapsed = glm::clamp(Player::elapsed() - _audioOffset, (qint64)0, (qint64)_recording->getLength());
     while(_currentFrame >= 0 &&
           _recording->getFrameTimestamp(_currentFrame) > elapsed) {
         --_currentFrame;

libraries/avatars/src/Player.h

@@ -44,8 +44,8 @@ public slots:
     void loadRecording(RecordingPointer recording);
     void play();
     
-    void setCurrentFrame(unsigned int currentFrame);
+    void setCurrentFrame(int currentFrame);
-    void setCurrentTime(unsigned int currentTime);
+    void setCurrentTime(int currentTime);
 
     void setVolume(float volume);
     void setAudioOffset(int audioOffset);
@@ -87,4 +87,4 @@ private:
     bool _useSkeletonURL;
 };
 
-#endif // hifi_Player_h
+#endif // hifi_Player_h