tor-browser

VRPuppetCommandBuffer.cpp (17869B)

---

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "VRPuppetCommandBuffer.h"
#include "prthread.h"
#include "mozilla/ClearOnShutdown.h"

namespace mozilla::gfx {

static StaticRefPtr<VRPuppetCommandBuffer> sVRPuppetCommandBufferSingleton;

/* static */
VRPuppetCommandBuffer& VRPuppetCommandBuffer::Get() {
 if (sVRPuppetCommandBufferSingleton == nullptr) {
   sVRPuppetCommandBufferSingleton = new VRPuppetCommandBuffer();
   ClearOnShutdown(&sVRPuppetCommandBufferSingleton);
 }
 return *sVRPuppetCommandBufferSingleton;
}

/* static */
bool VRPuppetCommandBuffer::IsCreated() {
 return sVRPuppetCommandBufferSingleton != nullptr;
}

VRPuppetCommandBuffer::VRPuppetCommandBuffer()
   : mMutex("VRPuppetCommandBuffer::mMutex") {
 MOZ_COUNT_CTOR(VRPuppetCommandBuffer);
 MOZ_ASSERT(sVRPuppetCommandBufferSingleton == nullptr);
 Reset();
}

VRPuppetCommandBuffer::~VRPuppetCommandBuffer() {
 MOZ_COUNT_DTOR(VRPuppetCommandBuffer);
}

void VRPuppetCommandBuffer::Submit(const nsTArray<uint64_t>& aBuffer) {
 MutexAutoLock lock(mMutex);
 mBuffer.AppendElements(aBuffer);
 mEnded = false;
 mEndedWithTimeout = false;
}

bool VRPuppetCommandBuffer::HasEnded() {
 MutexAutoLock lock(mMutex);
 return mEnded;
}

void VRPuppetCommandBuffer::Reset() {
 MutexAutoLock lock(mMutex);
 memset(&mPendingState, 0, sizeof(VRSystemState));
 memset(&mCommittedState, 0, sizeof(VRSystemState));
 for (int iControllerIdx = 0; iControllerIdx < kVRControllerMaxCount;
      iControllerIdx++) {
   for (int iHaptic = 0; iHaptic < kNumPuppetHaptics; iHaptic++) {
     mHapticPulseRemaining[iControllerIdx][iHaptic] = 0.0f;
     mHapticPulseIntensity[iControllerIdx][iHaptic] = 0.0f;
   }
 }
 mDataOffset = 0;
 mPresentationRequested = false;
 mFrameSubmitted = false;
 mFrameAccepted = false;
 mTimeoutDuration = 10.0f;
 mWaitRemaining = 0.0f;
 mBlockedTime = 0.0f;
 mTimerElapsed = 0.0f;
 mEnded = true;
 mEndedWithTimeout = false;
 mLastRunTimestamp = TimeStamp();
 mTimerSamples.Clear();
 mBuffer.Clear();
}

bool VRPuppetCommandBuffer::RunCommand(uint64_t aCommand, double aDeltaTime) {
 /**
  * Run a single command.  If the command is blocking on a state change and
  * can't be executed, return false.
  *
  * VRPuppetCommandBuffer::RunCommand is only called by
  *VRPuppetCommandBuffer::Run(), which is already holding the mutex.
  *
  * Note that VRPuppetCommandBuffer::RunCommand may potentially be called >1000
  *times per frame. It might not hurt to add an assert here, but we should
  *avoid adding code which may potentially malloc (eg string handling) even for
  *debug builds here.  This function will need to be reasonably fast, even in
  *debug builds which will be using it during tests.
  **/
 switch ((VRPuppet_Command)(aCommand & 0xff00000000000000)) {
   case VRPuppet_Command::VRPuppet_End:
     CompleteTest(false);
     break;
   case VRPuppet_Command::VRPuppet_ClearAll:
     memset(&mPendingState, 0, sizeof(VRSystemState));
     memset(&mCommittedState, 0, sizeof(VRSystemState));
     mPresentationRequested = false;
     mFrameSubmitted = false;
     mFrameAccepted = false;
     break;
   case VRPuppet_Command::VRPuppet_ClearController: {
     uint8_t controllerIdx = aCommand & 0x00000000000000ff;
     if (controllerIdx < kVRControllerMaxCount) {
       mPendingState.controllerState[controllerIdx].Clear();
     }
   } break;
   case VRPuppet_Command::VRPuppet_Timeout:
     mTimeoutDuration = (double)(aCommand & 0x00000000ffffffff) / 1000.0f;
     break;
   case VRPuppet_Command::VRPuppet_Wait:
     if (mWaitRemaining == 0.0f) {
       mWaitRemaining = (double)(aCommand & 0x00000000ffffffff) / 1000.0f;
       // Wait timer started, block
       return false;
     }
     mWaitRemaining -= aDeltaTime;
     if (mWaitRemaining > 0.0f) {
       // Wait timer still running, block
       return false;
     }
     // Wait timer has elapsed, unblock
     mWaitRemaining = 0.0f;
     break;
   case VRPuppet_Command::VRPuppet_WaitSubmit:
     if (!mFrameSubmitted) {
       return false;
     }
     break;
   case VRPuppet_Command::VRPuppet_CaptureFrame:
     // TODO - Capture the frame and record the output (Bug 1555180)
     break;
   case VRPuppet_Command::VRPuppet_AcknowledgeFrame:
     mFrameSubmitted = false;
     mFrameAccepted = true;
     break;
   case VRPuppet_Command::VRPuppet_RejectFrame:
     mFrameSubmitted = false;
     mFrameAccepted = false;
     break;
   case VRPuppet_Command::VRPuppet_WaitPresentationStart:
     if (!mPresentationRequested) {
       return false;
     }
     break;
   case VRPuppet_Command::VRPuppet_WaitPresentationEnd:
     if (mPresentationRequested) {
       return false;
     }
     break;
   case VRPuppet_Command::VRPuppet_WaitHapticIntensity: {
     // 0x0800cchhvvvvvvvv - VRPuppet_WaitHapticIntensity(c, h, v)
     uint8_t iControllerIdx = (aCommand & 0x0000ff0000000000) >> 40;
     if (iControllerIdx >= kVRControllerMaxCount) {
       // Puppet test is broken, ensure it fails
       return false;
     }
     uint8_t iHapticIdx = (aCommand & 0x000000ff00000000) >> 32;
     if (iHapticIdx >= kNumPuppetHaptics) {
       // Puppet test is broken, ensure it fails
       return false;
     }
     uint32_t iHapticIntensity =
         aCommand & 0x00000000ffffffff;  // interpreted as 16.16 fixed point

     SimulateHaptics(aDeltaTime);
     uint64_t iCurrentIntensity =
         round(mHapticPulseIntensity[iControllerIdx][iHapticIdx] *
               (1 << 16));  // convert to 16.16 fixed point
     if (iCurrentIntensity > 0xffffffff) {
       iCurrentIntensity = 0xffffffff;
     }
     if (iCurrentIntensity != iHapticIntensity) {
       return false;
     }
   } break;

   case VRPuppet_Command::VRPuppet_StartTimer:
     mTimerElapsed = 0.0f;
     break;
   case VRPuppet_Command::VRPuppet_StopTimer:
     mTimerSamples.AppendElements(mTimerElapsed);
     // TODO - Return the timer samples to Javascript once the command buffer
     // is complete (Bug 1555182)
     break;

   case VRPuppet_Command::VRPuppet_UpdateDisplay:
     mDataOffset = (uint8_t*)&mPendingState.displayState -
                   (uint8_t*)&mPendingState + (aCommand & 0x00000000ffffffff);
     break;
   case VRPuppet_Command::VRPuppet_UpdateSensor:
     mDataOffset = (uint8_t*)&mPendingState.sensorState -
                   (uint8_t*)&mPendingState + (aCommand & 0x00000000ffffffff);
     break;
   case VRPuppet_Command::VRPuppet_UpdateControllers:
     mDataOffset = (uint8_t*)&mPendingState.controllerState -
                   (uint8_t*)&mPendingState + (aCommand & 0x00000000ffffffff);
     break;
   case VRPuppet_Command::VRPuppet_Commit:
     memcpy(&mCommittedState, &mPendingState, sizeof(VRSystemState));
     break;

   case VRPuppet_Command::VRPuppet_Data7:
     WriteData((aCommand & 0x00ff000000000000) >> 48);
     [[fallthrough]];
     // Purposefully, no break
   case VRPuppet_Command::VRPuppet_Data6:
     WriteData((aCommand & 0x0000ff0000000000) >> 40);
     [[fallthrough]];
     // Purposefully, no break
   case VRPuppet_Command::VRPuppet_Data5:
     WriteData((aCommand & 0x000000ff00000000) >> 32);
     [[fallthrough]];
     // Purposefully, no break
   case VRPuppet_Command::VRPuppet_Data4:
     WriteData((aCommand & 0x00000000ff000000) >> 24);
     [[fallthrough]];
     // Purposefully, no break
   case VRPuppet_Command::VRPuppet_Data3:
     WriteData((aCommand & 0x0000000000ff0000) >> 16);
     [[fallthrough]];
     // Purposefully, no break
   case VRPuppet_Command::VRPuppet_Data2:
     WriteData((aCommand & 0x000000000000ff00) >> 8);
     [[fallthrough]];
     // Purposefully, no break
   case VRPuppet_Command::VRPuppet_Data1:
     WriteData(aCommand & 0x00000000000000ff);
     break;
 }
 return true;
}

void VRPuppetCommandBuffer::WriteData(uint8_t aData) {
 if (mDataOffset && mDataOffset < sizeof(VRSystemState)) {
   ((uint8_t*)&mPendingState)[mDataOffset++] = aData;
 }
}

void VRPuppetCommandBuffer::Run() {
 MutexAutoLock lock(mMutex);
 TimeStamp now = TimeStamp::Now();
 double deltaTime = 0.0f;
 if (!mLastRunTimestamp.IsNull()) {
   deltaTime = (now - mLastRunTimestamp).ToSeconds();
 }
 mLastRunTimestamp = now;
 mTimerElapsed += deltaTime;
 size_t transactionLength = 0;
 while (transactionLength < mBuffer.Length() && !mEnded) {
   if (RunCommand(mBuffer[transactionLength], deltaTime)) {
     mBlockedTime = 0.0f;
     transactionLength++;
   } else {
     mBlockedTime += deltaTime;
     if (mBlockedTime > mTimeoutDuration) {
       CompleteTest(true);
     }
     // If a command is blocked, we don't increment transactionLength,
     // allowing the command to be retried on the next cycle
     break;
   }
 }
 mBuffer.RemoveElementsAt(0, transactionLength);
}

void VRPuppetCommandBuffer::Run(VRSystemState& aState) {
 Run();
 // We don't want to stomp over some members
 bool bEnumerationCompleted = aState.enumerationCompleted;
 bool bShutdown = aState.displayState.shutdown;
 uint32_t minRestartInterval = aState.displayState.minRestartInterval;

 // Overwrite it all
 memcpy(&aState, &mCommittedState, sizeof(VRSystemState));

 // Restore the members
 aState.enumerationCompleted = bEnumerationCompleted;
 aState.displayState.shutdown = bShutdown;
 aState.displayState.minRestartInterval = minRestartInterval;
}

void VRPuppetCommandBuffer::StartPresentation() {
 mPresentationRequested = true;
 Run();
}

void VRPuppetCommandBuffer::StopPresentation() {
 mPresentationRequested = false;
 Run();
}

bool VRPuppetCommandBuffer::SubmitFrame() {
 // Emulate blocking behavior of various XR API's as
 // described by puppet script
 mFrameSubmitted = true;
 mFrameAccepted = false;
 while (true) {
   Run();
   if (!mFrameSubmitted || mEnded) {
     break;
   }
   PR_Sleep(PR_INTERVAL_NO_WAIT);  // Yield
 }

 return mFrameAccepted;
}

void VRPuppetCommandBuffer::VibrateHaptic(uint32_t aControllerIdx,
                                         uint32_t aHapticIndex,
                                         float aIntensity, float aDuration) {
 if (aHapticIndex >= kNumPuppetHaptics ||
     aControllerIdx >= kVRControllerMaxCount) {
   return;
 }

 // We must Run() before and after updating haptic state to avoid script
 // deadlocks
 // The deadlocks would be caused by scripts that include two
 // VRPuppet_WaitHapticIntensity commands.  If
 // VRPuppetCommandBuffer::VibrateHaptic() is called twice without advancing
 // through the command buffer with VRPuppetCommandBuffer::Run() in between,
 // the first VRPuppet_WaitHapticInensity may not see the transient value that
 // it is waiting for, thus blocking forever and deadlocking the script.
 Run();
 mHapticPulseRemaining[aControllerIdx][aHapticIndex] = aDuration;
 mHapticPulseIntensity[aControllerIdx][aHapticIndex] = aIntensity;
 Run();
}

void VRPuppetCommandBuffer::StopVibrateHaptic(uint32_t aControllerIdx) {
 if (aControllerIdx >= kVRControllerMaxCount) {
   return;
 }
 // We must Run() before and after updating haptic state to avoid script
 // deadlocks
 Run();
 for (int iHaptic = 0; iHaptic < kNumPuppetHaptics; iHaptic++) {
   mHapticPulseRemaining[aControllerIdx][iHaptic] = 0.0f;
   mHapticPulseIntensity[aControllerIdx][iHaptic] = 0.0f;
 }
 Run();
}

void VRPuppetCommandBuffer::StopAllHaptics() {
 // We must Run() before and after updating haptic state to avoid script
 // deadlocks
 Run();
 for (int iControllerIdx = 0; iControllerIdx < kVRControllerMaxCount;
      iControllerIdx++) {
   for (int iHaptic = 0; iHaptic < kNumPuppetHaptics; iHaptic++) {
     mHapticPulseRemaining[iControllerIdx][iHaptic] = 0.0f;
     mHapticPulseIntensity[iControllerIdx][iHaptic] = 0.0f;
   }
 }
 Run();
}

void VRPuppetCommandBuffer::SimulateHaptics(double aDeltaTime) {
 for (int iControllerIdx = 0; iControllerIdx < kVRControllerMaxCount;
      iControllerIdx++) {
   for (int iHaptic = 0; iHaptic < kNumPuppetHaptics; iHaptic++) {
     if (mHapticPulseIntensity[iControllerIdx][iHaptic] > 0.0f) {
       mHapticPulseRemaining[iControllerIdx][iHaptic] -= aDeltaTime;
       if (mHapticPulseRemaining[iControllerIdx][iHaptic] <= 0.0f) {
         mHapticPulseRemaining[iControllerIdx][iHaptic] = 0.0f;
         mHapticPulseIntensity[iControllerIdx][iHaptic] = 0.0f;
       }
     }
   }
 }
}

void VRPuppetCommandBuffer::CompleteTest(bool aTimedOut) {
 mEndedWithTimeout = aTimedOut;
 mEnded = true;
}

/**
*  Generates a sequence of VRPuppet_Data# commands, as described
*  in VRPuppetCommandBuffer.h, to encode the changes to be made to
*  a "destination" structure to match the "source" structure.
*  As the commands are encoded, the destination structure is updated
*  to match the source.
*
* @param aBuffer
*     The buffer in which the commands will be appended.
* @param aSrcStart
*     Byte pointer to the start of the structure that
*     will be copied from.
* @param aDstStart
*     Byte pointer to the start of the structure that
*     will be copied to.
* @param aLength
*     Length of the structure that will be copied.
* @param aUpdateCommand
*     VRPuppet_... command indicating which structure is being
*     copied:
*     VRPuppet_Command::VRPuppet_UpdateDisplay:
*         A single VRDisplayState struct
*     VRPuppet_Command::VRPuppet_UpdateSensor:
*         A single VRHMDSensorState struct
*     VRPuppet_Command::VRPuppet_UpdateControllers:
*         An array of VRControllerState structs with a
*         count of kVRControllerMaxCount
*/
void VRPuppetCommandBuffer::EncodeStruct(nsTArray<uint64_t>& aBuffer,
                                        uint8_t* aSrcStart, uint8_t* aDstStart,
                                        size_t aLength,
                                        VRPuppet_Command aUpdateCommand) {
 // Naive implementation, but will not be executed in realtime, so will not
 // affect test timer results. Could be improved to avoid unaligned reads and
 // to use SSE.

 // Pointer to source byte being compared+copied
 uint8_t* src = aSrcStart;

 // Pointer to destination byte being compared+copied
 uint8_t* dst = aDstStart;

 // Number of bytes packed into bufData
 uint8_t bufLen = 0;

 // 64-bits to be interpreted as up to 7 separate bytes
 // This will form the lower 56 bits of the command
 uint64_t bufData = 0;

 // purgebuffer takes the bytes stored in bufData and generates a VRPuppet
 // command representing those bytes as "VRPuppet Data".
 // VRPUppet_Data1 encodes 1 byte
 // VRPuppet_Data2 encodes 2 bytes
 // and so on, until..
 // VRPuppet_Data7 encodes 7 bytes
 // This command is appended to aBuffer, then bufLen and bufData are reset
 auto purgeBuffer = [&]() {
   // Only emit a command if there are data bytes in bufData
   if (bufLen > 0) {
     MOZ_ASSERT(bufLen <= 7);
     uint64_t command = (uint64_t)VRPuppet_Command::VRPuppet_Data1;
     command += ((uint64_t)VRPuppet_Command::VRPuppet_Data2 -
                 (uint64_t)VRPuppet_Command::VRPuppet_Data1) *
                (bufLen - 1);
     command |= bufData;
     aBuffer.AppendElement(command);
     bufLen = 0;
     bufData = 0;
   }
 };

 // Loop through the bytes of the structs.
 // While copying the struct at aSrcStart to aDstStart,
 // the differences are encoded as VRPuppet commands and
 // appended to aBuffer.
 for (size_t i = 0; i < aLength; i++) {
   if (*src != *dst) {
     // This byte is different

     // Copy the byte to the destination
     *dst = *src;

     if (bufLen == 0) {
       // This is the start of a new span of changed bytes

       // Output a command to specify the offset of the
       // span.
       aBuffer.AppendElement((uint64_t)aUpdateCommand + i);

       // Store this first byte in bufData.
       // We will batch up to 7 bytes in one VRPuppet_DataXX
       // command, so we won't emit it yet.
       bufLen = 1;
       bufData = *src;
     } else if (bufLen <= 6) {
       // This is the continuation of a span of changed bytes.
       // There is room to add more bytes to bufData.

       // Store the next byte in bufData.
       // We will batch up to 7 bytes in one VRPuppet_DataXX
       // command, so we won't emit it yet.
       bufData = (bufData << 8) | *src;
       bufLen++;
     } else {
       MOZ_ASSERT(bufLen == 7);
       // This is the continuation of a span of changed bytes.
       // There are already 7 bytes in bufData, so we must emit
       // the VRPuppet_Data7 command for the prior bytes before
       // starting a new command.
       aBuffer.AppendElement((uint64_t)VRPuppet_Command::VRPuppet_Data7 +
                             bufData);

       // Store this byte to be included in the next VRPuppet_DataXX
       // command.
       bufLen = 1;
       bufData = *src;
     }
   } else {
     // This byte is the same.
     // If there are bytes in bufData, the span has now ended and we must
     // emit a VRPuppet_DataXX command for the accumulated bytes.
     // purgeBuffer will not emit any commands if there are no bytes
     // accumulated.
     purgeBuffer();
   }
   // Advance to the next source and destination byte.
   ++src;
   ++dst;
 }
 // In the event that the very last byte of the structs differ, we must
 // ensure that the accumulated bytes are emitted as a VRPuppet_DataXX
 // command.
 purgeBuffer();
}

}  // namespace mozilla::gfx