Recent technical advances in hardware for displaying of immersive media have aroused a huge market interest in virtual reality (VR) and augmented reality (AR) applications. Although the initial interest was focused on omnidirectional () video applications, with the improvements in capture and processing technologies, volumetric video has recently started to become the center of attention (schreer2019). Volumetric videos capture the three-dimensional space and objects and have the potential to provide a better immersion compared to videos. Moreover, volumetric videos enable services with six-degrees-of-freedom (6DoF), allowing a viewer to freely change both the position in space and the orientation.
The enhanced immersion and interactivity provided by volumetric videos lead the way to novel use cases. Besides the entertainment use cases (e.g. gaming, sports replay), volumetric video is foreseen to play an important role in various culture, educational and commercial use cases. For example, capturing spaces for documentation of historical events, virtual lectures and classrooms, virtual museum visits and field trips are among the envisioned future use cases. Commercial applications such as real estate preview, industrial production monitoring, repair and maintenance tasks are among future use cases that can be realized in a more immersive fashion using volumetric video (apostolopoulos2012).
Although the computing power of mobile end devices has dramatically increased in the recent years, rendering rich volumetric objects is still a very demanding tasks for such devices. Moreover, there are yet no efficient hardware decoders implementations for decoding of volumetric content (e.g. point clouds or meshes). Software decoding of such content can be prohibitively expensive in terms of battery usage and real-time rendering requirements. One way of decreasing the processing load on the client is to avoid sending the full 3D data (volumetric content) to the client and instead send a 2D view corresponding to the position and orientation of the user. To achieve this, the expensive rendering process (conversion from volumetric to 2D) needs to be offloaded to a server infrastructure. Rendering 3D graphics on a powerful computing device (server) and displaying the results on another, less powerful computing device (client) connected through a network is typically known as remote (or interactive) rendering (shi2015). Such rendering servers can be deployed at a cloud computing platform such that the resources can flexibly be allocated and scaled up when more processing load is present.
An interactive cloud rendering system accepts user input from a client device to control a rendering application running on a server. The server renders the 3D graphics based on the user input (e.g, user’s viewport position and orientation) and typically encodes the rendering result into a 2D video stream. A 3D experience using AR or VR glasses can be enabled by frame-packing arrangement of two views for right and left eye, respectively. Depending on the viewport position and orientation of the client, camera pose of the rendered video is dynamically adapted by the cloud server. After a view (monoscopic or stereoscopic) has been rendered and encoded, the obtained video stream is transmitted to the client. The client can efficiently decode the video using its hardware video decoders and display the video stream to the user.
Cloud-based remote rendering of volumetric video brings several advantages: First, by avoiding the transmission of 3D content, network bandwidth requirements are reduced. Moreover, rendering on the client side is greatly simplified and rich rendering results can be provided to thin clients (such as mobile devices) with limited computing resources. This also allows playout of the content on legacy devices which do not have sufficient computing resources to render complex content. Despite these advantages, one major drawback of cloud rendering is the increased end-to-end (motion-to-photon) latency. Due to the added network latency and additional processing latency (rendering and encoding), the amount of time until an updated image is presented to the user is higher than a system based on local rendering. It is well-known that an increase in motion-to-photon latency may cause an unpleasant user experience and motion sickness (adelstein2003; allison2001). One way to alleviate the additional latency is to move the volumetric content to an edge server geographically closer to the user and thus decrease the network latency. Deploying latency-critical services at the edge of the Radio Access Network (RAN) is considered as a key technology for 5G deployments and is expected to enable the deployment and adoption of use cases such as interactive rendering (hu2015). In addition to the changes in the network architecture brought by the edge computing paradigm, usage of communication protocols such as WebRTC is also required for ultra-low latency video streaming applications (holmberg2015). Apart from network latency, processing latency at the rendering server is an additional significant latency component. Using fast hardware-based video encoders is critical for reducing the video compression latency while maintaining good quality and compression efficiency.
Another way of reducing the motion-to-photon latency is to predict the future user pose at the remote server and send the corresponding rendered image to the client. Thus, it is possible to reduce or even completely eliminate the motion-to-photon latency, if the pose is predicted for a prediction window equal to or larger than the motion-to-photon latency of the system (bao2016). Although using a prediction algorithm to drastically cut down the effective interaction latency is an attractive idea, the prediction accuracy of such algorithms may be a limiting factor. Thus, design of accurate prediction algorithms has been a popular research area, especially for the viewport prediction in videos (see Section 2.3). However, applicability of such algorithms to six degrees-of-freedom (6DoF) movement (i.e. translational and rotational) has not yet been investigated. In this paper, we present an edge-cloud based volumetric video streaming system, apply a statistical prediction model to forecast the 6DoF position of the user in future, and investigate the achieved rendering accuracy (offset) with the developed prediction model. Additionally, we describe our software architecture in detail and present a comprehensive analysis of the latency components in our system together with real motion-to-photon latency measurements.
In this section, we briefly review some of the works in the literature on volumetric video streaming, cloud rendering systems and user movement prediction techniques.
2.1. Volumetric video streaming
Volumetric video is one of the most prominent technologies for streaming of 6DoF content. It is typically captured using multiple synchronized cameras from all directions. Then, a dynamic 3D model (mesh or point cloud) is created from the captured views (schreer2019icip).
Some recent works in the literature presented initial architectures and techniques for streaming of volumetric videos. Qian et al. (qian2019) developed a proof-of-concept point cloud streaming system and introduced optimizations to reduce the motion-to-photon latency. Park et al. (park2019) designed an adaptive volumetric video streaming system that adapt the level-of-detail (LoD) of 3D tiles depending on the distance of the user. Furthermore, they introduced a greedy algorithm to allocate bits between different tiles across multiple objects for rate-utility optimization. Van der Hooft et al. (van2019) propose an adaptive streaming framework compliant to the recent point cloud compression standard MPEG V-PCC (schwarz2018). They use their framework for HTTP adaptive streaming of scenes with multiple dynamic point cloud objects and present a rate adaption algorithm that use information on the user’s position and focus. Petrangeli et al. (petrangeli2019) propose a streaming framework for AR applications that dynamically decides which virtual objects should be fetched from the server as well as their LoD levels, depending on the proximity of the user and likelihood of the user to view the object. Thus, they aim to maximize the object’s perceived visual quality. They carry out their experiments using an AR streaming prototype developed on an iOS device.
2.2. Cloud rendering systems
The concept of remote rendering has been first put forward to facilitate the processing of 3D graphics rendering when PCs did not have sufficient computational power for intensive graphics tasks. A detailed survey of interactive remote rendering systems in the literature was presented by Shi et al. (shi2015) In recent years, with increasing network speeds and the rise of mobile cloud computing, the concept has re-emerged in the context of cloud-based rendering of computer games as well as and volumetric videos.
In their further work, Shi et al. (shi2019) propose a mobile edge computing (MEC) system to stream VR scenes containing only the user’s Field-of-View (FoV) and a latency-adaptive margin around the FoV. They evaluate the performance of their prototype on a MEC node connected to an LTE testbed. Mangiante et al. (mangiante2017) propose an edge-based framework to perform FoV rendering of videos. Their system aims to optimize the required bandwidth as well as reduce the processing requirements and battery utilization.
Cloud rendering has also recently started to receive increasing interest from the industry, especially for cloud gaming services. Nvidia CloudXR (nvidia2019) provides an SDK to run immersive applications that require high computational power on Nvidia servers located in the cloud to deliver advanced graphics performances to thin clients. Google Stadia (google2019), a cloud gaming service operated by Google, has already been launched in November 2019. Microsoft is also expected to launch a similar cloud gaming service in 2020 under the name Project xCloud (microsoft2019) for game streaming with Xbox.
2.3. User movement prediction techniques
One important optimization to reduce the bandwidth requirements of the system and improve the user’s QoE is the prediction of the user’s future viewport. Several methods have been proposed in the literature for viewport prediction which rely on different kind of information obtained from i) various sensors, ii) content analysis, iii) statistical analysis (data-driven).
Sensor-based methods can be divided into two categories. Works such as (bao2016; bao2017; sanchez2019; aykut2018; oculus16) are specifically designed for VR applications and use the sensor information from HMD whereas the works in (barniv2005; koirala2015; bai2011) focus on inferring user motion based on some physiological data such as EEG and EMG signals. Bao et al. (bao2016) collected motion data in the three dimensions (yaw, pitch, roll) and exploited the auto-correlations in all three dimensions to predict viewer motions using regression techniques. Their findings indicate that a prediction time frame of 100-500 ms is feasible, and they obtain 45% bandwidth reduction compared to streaming the whole 360 content, with a 0.1% failure ratio (defined as the percentage of frames in which the viewer’s FoV is not completely transmitted). Sanchez et al. (sanchez2019) analyze the effect of E2E latency on a tile-based streaming system and propose an angular acceleration based prediction method to mitigate its impact on the observed fidelity. Barniv et al. (barniv2005)
exploit the myoelectric signals obtained from EMG devices to predict the impending motion. They train a neural network to map such signals to trajectory outputs and experiment combining EMG output with inertial (sensor) data. Their findings indicate that an anticipation time of 30-70 ms is achievable with low error rates. Bai et al.(bai2011) attempt to utilize EEG signals to anticipate human movement before it occurs. They report an average prediction time of 0.620.25 s; however, they also note that some predictions occur without subsequent actual movements (false positives).
Content-based methods such as (deabreu2017; ozcinar2018; ozcinar2019)deabreu2017) collect the center trajectories of viewports from several users and propose a method to transform the gathered data into saliency maps. Ozcinar et al. (ozcinar2018) create a new visual attention user dataset for omnidirectional videos and analyze the prediction performance of state-of-the-art visual attention models. In their follow-up work (ozcinar2019), they introduce an adaptive omnidirectional video streaming pipeline that optimizes DASH representations of omnidirectional content considering their visual attention maps. Fan et al. (fan2017) employ both sensor and content-related features to train two neural networks which accurately predict user fixations.
Data-driven methods such as (petrangeli2018; liu2017; xu2018) collect user statistics and try to predict the future user orientations by developing statistical models based on historical data. Petrangeli et al. (petrangeli2018) model the viewport evolution of a given user over time as a trajectory and cluster trajectories with similar viewing behaviors to calculate functions for each cluster which are used to predict future viewport at run-time. Liu et al. (liu2017) combine multiple data sources such as the viewing statistics of a video across users, viewing behaviors of multiple videos by a single user and other contextual cues to apply prediction-based prefetching of the future chunks. Xu et al. (xu2018)
leverage the probability distribution of the user’s orientation, and design an algorithm that prefetches segments by maximizing the expected quality.
Most of the reviewed work above focuses on prediction of 3DoF movement (only head rotation) for VR applications in order to optimize the streaming of omnidirectional () videos. However, prediction of 6DoF movement for more advanced augmented reality (AR) and extended reality (XR) applications is not yet addressed in the literature.
3. System Architecture
This section describes the overall architecture of our implemented cloud rendering system for volumetric video — the key components, their interactions with each other, and the echanged data between a client and a server.
3.1. Architecture overview
A simplified version of this architecture is shown in Figure 1. We note that this diagram only illustrates the most important system components and does not show every component implemented in our real system.
3.1.1. Server architecture
The server side implementation is split into two main parts: volumetric video player and a cross-platform cloud rendering library, each described further in more detail.
Volumetric video player
The volumetric video player is implemented in Unity and is playing a single MP4 file which has two tracks, one video track containing the texture of an volumetric object, and one mesh track containing the compressed meshes of that object. Before the playback of a volumetric video starts, the player application registers all game objects that are to be controlled from the outside. For example, the virtual camera of the rendered view as well as the volumetric object contained in the MP4 file are registered and later controlled by the client.
After initialization, the volumetric video player can start playing the MP4 file. Both tracks are demultiplexed and fed into the corresponding decoders; video decoder for texture track and mesh decoder for mesh track. After decoding, each mesh is synchronized with the corresponding texture and rendered to a scene. The rendered view of the scene is represented by a Unity RenderTexture that is passed to the cloud rendering library for further processing. While rendering the scene, the player concurrently asks the cloud rendering library for the latest positions of the relevant objects that were previously registered in the initialization phase.
Cloud Rendering Library
The cloud rendering library is a cross-platform library written in C++ that can be integrated in variety of applications. In the case of the Unity application, the cloud rendering library is integrated into the player as a native plugin. Furthermore, we use the same library in a stand-alone console application in order to perform motion-to-photon latency measurements for this work (please refer to Section 3.3 for details on our motion-to-photon latency measurements).
The library is utilising the GStreamer WebRTC plugin for low-latency video streaming between the client and the server that is integrated into a media pipeline as described in Section 3.2. In addition, the library provides interfaces for registering the objects of the rendered scene and for retrieving the latest client-controlled transformations of that objects while rendering the scene.
The most important modules of the library are the WebSocket Server, the GStreamer module, the Controller module and the Prediction Engine. Each of these modules runs asynchronously in its own thread to achieve high performance.
The WebSocket Server is used for exchanging signaling data between the client and the server. Such signaling data includes Session Description Protocol (SDP), Interactive Connectivity Establishment (ICE) as well as application-specific metadata for scene description. In addition, websocket connection can also be used for sending the control data, e.g.: changing the position and orientation of any registered game object or camera. Both, plain WebSockets as well as Secure WebSockets are supported which is important for running the system in real live scenarios.
The GStreamer module contains the media processing pipeline which takes the rendered texture as an input and processes it into a compressed video stream that is sent to the client using WebRTC plugin. The most important components of the media pipeline are described in Section 3.2 below.
The Controller module represents the logic of the application and controls further modules depending on the state of the application. For example, it closes the media pipeline if client disconnects, it re-initializes the media pipeline when a new client has connected, or updates the controllable objects based on the state of the Prediction Engine.
The Prediction Engine implements the prediction technique described in Section 6 and allows potential usage of other prediction techniques. Based on the previously received input from the client and the selected prediction technique, it updates the position of registered objects accordingly so that the rendering thread can render a scene which should represent the future state of the scene that the client will see after a certain prediction window time.
3.1.2. Client architecture
As shown in Figure 1, the complexity of the overall system is mainly concentrated on the server side. The client side architecture is depicted on the left side of the Figure 1 and is rather simple. It essentially consists of four modules: WebSocket Connection, WebRTC Connection, Video Decoder/Rendering, and the Application Logic itself.
Before the streaming session starts, the client establishes a WebSocket connection to the server and asks the server to send a description of the rendered scene. The server responds with a list of objects and parameters, which the client is later allowed to change. After receiving the scene description, the client replicates the scene and initiates a peer-to-peer WebRTC connection to the server. The server and the client begin the WebRTC negotiation process while sending SDP and ICE data over previously established WebSocket connection. Finally, the peer-to-peer connection is established and the client receives a video stream representing the current view of the 3D scene. At the same time the client can use the WebSocket connection, as well as RTC peer connection in order to send control data back to the server in order to change the properties of the scene. For example the client may change its viewport position or orientation, or it may rotate, move or scale any volumetric object in the scene.
But in general, the client-side architecture remains the same for both VR and AR use cases, and the most complex module in that architecture is the video decoder. Luckily, hardware video decoders for H.264 and HEVC are widely deployed in end devices which makes the application very lightweight in terms of required processing power.
3.2. Media pipeline
This section gives more details of the GStreamer media pipeline. The simplified structure of the media pipeline is shown in the bottom part of Figure 1. On the input side it takes a rendered texture which is pushed into media pipeline using GStreamer’s AppSource element.
Since the most graphics rendering APIs support only RGB texture formats and the video processing APIs mostly work on YCbCr formats, we have to use the GStreamer VideoConvert module to convert the RGBA texture to I420 format and prepare the texture for encoding. Unfortunately, this conversion step is mandatory, but as we show later in Section 4, the introduced latency by this block is negligible.
After conversion, the texture is passed to the encoder element, which can be set to any supported encoder on the system. Since latency is the most important metric for any cloud rendering service, we have evaluated the performance of different encoders in terms of encoding speed and quality for variety of encoders. We experimented with different encoders such as software based x264, x265 and SVT-HEVC as well as GPU-based Nvidia encoder (NVENC) focusing on their encoding latency and decided to integrate NVENC in our media pipeline due to its significantly greater encoding speed at a comparable picture quality for the latency requirements. For detailed results on encoder performance the reader is referred to Section 4.2.1.
After the texture is encoded the resulting video bitstream is packaged into RTP packets, encrypted and sent to the client using the WebRTC element. WebRTC was chosen as the delivery method since it allows us to achieve an ultra-low latency while using the peer-to-peer connection between the client and the server. In addition, WebRTC is already widely adopted by the web-browsers and platforms allowing our system to support a large variety of devices.
3.3. Latency measurement architecture
The most important metric to evaluate the overall performance of the entire system is the end-to-end latency also referred to as motion-to-photon latency which is defined in Eq. 1. For our particular implementation represents the time it takes for the client to send control data to the server, until the rendered texture representing the 3D scene (rendered with that control data) is finally decoded and rendered on the client’s screen. It is crucial to keep this value as low as possible since high may directly result in poor user QoE. Hence, we needed to find a way to automatically measure in order to evaluate the overall performance of our system.
For this purpose, we implemented a server-side console application which is using the same cloud rendering library as described in Section 3.1.1 but instead of using the volumetric video player as a source for rendered textures, it pushes pre-defined textures (known by the client) depending on the received control data. For example, if the client sends a control data telling the server application to move the main camera to postion , the server pushes texture into the media pipeline. Accordingly, sending the camera position to the server results in pushing of the texture into the media pipeline. Since the client knows exactly how the textures and look like, it can evaluate the incoming video stream and determine when the requested texture was rendered on the screen.
On the client side, we implemented a web-based application that connects to the server application described above and renders the received video stream to a canvas. Once the connection is established, the user can start the measurement session by defining the number of independent measurements. As soon as the client application sends to the server, it starts the timer and checks the canvas for on every web browser window repaint. According to the W3C recommendation (w3c2015), the web browser window repaint event matches the refresh rate of the display. As soon as the texture is detected the client stops the timer and computes the value for a single measurement . The client application continues the same process again but now sending the position to the server and waiting for to appear in order to compute . This procedure is repeated alternately until the desired number of independent measurements is collected.
In the following section, we present our evaluations of the collected measurements from the real system running on an Amazon EC2 instance.
4. Latency contributors
End-to-end (motion-to-photon) latency of our system is illustrated in Figure 2 and can be modeled using the following equation:
where , and consist of the following component latencies:
is the time for the client device (e.g. an HMD) to compute the user pose (position and orientation) using its tracker module. This computation is typically based on a fusion of the sensor data from IMUs and optical tracking, i.e. camera input. Although AR device cameras typically operate at 30-60 Hz, IMUs are much faster (on the order of 1000 Hz) and a reliable estimation of the user pose can be done based on the IMU data (daqri2018). Therefore, we consider to be negligible in our analysis.
is the time to compress a frame on the server and depends on the encoder type (hardware or software encoder), the resolution of the compressed picture and the encoding frame-rate. The selected frame-rate needs to be in the range of the video decoder level limits on the client side. We present a detailed latency and rate-distortion analysis of different encoders that we tested for our system in Section 4.2.1.
is the network round-trip time (RTT) which consists of , the time for the server to retrieve sensor data from the client, and the time for the server to transmit a compressed frame over a wireless connection to the client. and are not equal since the transmission delay of the compressed frame is much higher due to the significantly greater size of the compressed frame compared to the sensor data, which is only a few bytes.
is the time for the server to generate a new frame by rendering a view from the volumetric data based on the actual user pose. In general it can be set to match the frame rate of the encoder for a given rendered texture resolution.
is time to decode a compressed frame on the client and is typically much smaller than since video decoding is inherently a faster operation than video encoding. In addition, the end devices typically have hardware accelerated video decoders that further reduce latency.
depends on the refresh rate of the display. For a typical refresh rate of 60 Hz, the average value of is 8.3 ms, and the worst-case value is 16.6 ms in case the decoded frame misses the current VSync signal and has to wait in the frame buffer for the next VSync signal.
4.1. Motion-to-photon latency
As already mentioned in Section 3.3, we have developed a client and server application to measure the motion to photon latency of the entire system. To achieve this, we run the server application on the Amazon EC2 instance in the eu-central-1 region in Frankfurt, and the client application runs in a web browser on a PC in Berlin which is connected to the Internet over WiFi.
As described in Section 3.3, the server application is feeding the cloud rendering library with either the texture or depending on the input received from the client. These textures consist of simple vertical bars with different colors. Since we are using the second smallest instance type of Amazon EC2 (t2.micro) the size of each video frame is set to pixels and the encoder (x264 with zerolatency tuning and superfast preset) is running at approximately 80 fps. At the same time, the GStreamer pipeline records latency traces, which we evaluate in Section 4.2 to determine what portion of the measured is spent on the media pipeline processing.
The client application can send control data to the server both via a WebSocket connection as via a WebRTC peer-to-peer connection. We have evaluated both methods, and since the obtained latencies are very similar, we only show plots with WebSocket connection as data channel. The client performs 100 latency measurements as quickly as possible and calculates the average, minimum and maximum latency. Figure 3 shows the progression of the motion-to-photon latency measured for above scenario over 100 measurement cycles .
The figure shows that fluctuates between 41ms and 63ms and the average motion to photon latency is 58.44ms.
4.2. Media pipeline latency
Now that we have measured the total motion to photon latency , it is interesting to know how much latency is due to processing within the media pipeline. With this knowledge we are able to determine how much latency comes from the network and client rendering since:
GStreamer framework already provides an API for the media pipeline latency measurements that we used during our measurement session described above. Figure 4
shows a plot of the major latency contributors of the media pipeline over time. In addition, mean values and the standard deviation of these components are given in Table1.
From those values, we observe that the overall latency of the media pipeline is on average where the major contributor is the video encoder with almost 13ms. The encoding latency depends on the selected frame rate and can be further reduced by going to higher frame rates by using the NVENC encoder. However, the maximum frame-rate is limited by the target decoder level requirements and the resolution of the video. Second largest latency contributor of the media pipeline is the video convert element which is responsible for conversion of the video texture from RGBA to I420 with approximately 1.2ms latency on average.
Since the media pipeline latency measurements do not include , we can approximate it based on the rate at which the media pipeline is fed with the texture. The server application is feeding the media pipeline with textures at the rate of approximately 80 fps. This results in the average latency of . Therefore the overall server processing latency can be approximated as a sum of the media pipeline and the rendered latencies .
4.2.1. Encoder latency
To compare the performance of the Nvidia hardware encoder (NVENC) with other freely available software encoders, we performed some experiments on the dataset video dataset used by ISO/ITU Joint Video Exploration Team (JVET) in the Call for Proposals (CfP) for the next generation video coding standard Versatile Video Coding (VVC) (jvet_VVC_CfP). Table 2 shows the properties of these video sequences. Due to the low-latency requirements of our use case, we evaluated only the performance of the ultra-low latency presets of the considered encoders. For x264 and x265, we used the preset ultrafast and tuning zerolatency (ffmpeg_x264). Both for NVENC H.264 (NV-264) and NVENC HEVC (NV-265) encoders, we evaluated the presets default, high performance (hp), low-latency (ll) and low-latency-hp (llhp).
|Sequence||Resolution||Frame count||Frame rate|
In our experiments, first we characterized the rate-distortion (RD) performance in terms of PSNR over the bitrates . Figure 5 shows the obtained RD-curves for one 1080p (BQTerrace) and one 4K sequence (CatRobot1) for different encoders and in the case of NVENC also for different presets. Our results show that NV-265 has the best RD performance for all the test sequences and x264 has the worst. NV-264 performs significantly better than x264 and for some sequences even better than Intel SVT-HEVC and x265 (ultrafast preset, zerolatency tuning), especially at higher bitrates. SVT-HEVC and x265 have similar RD performances but SVT-HEVC seems to be slightly better on average.
Secondly, we measured the encoding performance (in terms of frames per second) with different encoders and low-latency presets of NVENC and x264/x265 as described above. We used constant bitrate encoding (CBR) as the rate control mode for all experiments. PSNR measurements were performed using the software VQMT111https://www.epfl.ch/labs/mmspg/downloads/vqmt/. Table 3 shows our results for all tested sequences using different encoders and presets. We observed that both NV-264 and NV-265 are significantly faster than x264, x265 (both with ultrafast preset and low latency tuning) and SVT-HEVC. Both NV-264 and NV-265 are able to encode 1080p and 4K videos with encoding rates up to fps and fps, respectively, using the NVENC preset hp. We observed that for some sequences, HEVC encoding turned out to be faster than H.264, especially when the hp preset was used. We believe that this difference is caused by a more efficient GPU implementation of the HEVC codec. All the low-latency presets tested in our experiments turn off B-frames to reduce latency, and the hp preset of NVENC additionally turns of CABAC and uses CAVLC for entropy coding (twitch2018). Despite the simpler entropy coding used by the hp preset, the RD performance is negligibly lower than the other NVENC presets at a considerably higher encoding speed. Thus, we conclude that hp preset is the most suitable NVENC preset for ultra-low latency applications. Figure 6 shows the encoding performance measurements together with the corresponding PSNR values for one 1080p (BQTerrace) and one 4K sequence (CatRobot1).
|Sequence||x264||NV-264 def.||NV-264 HP||NV-264 LL||NV-264 LLHP||NV-265 def.||NV-265 HP||NV-265 LL||NV-265 LLHP||SVT-HEVC||x265|
5. User movement traces
In order to develop a prediction technique that can accurately forecast the future user pose for a given prediction time, we first created user traces by collecting user movement data from an AR device while users were interacting with a virtual object overlaid on top of the real world. We used Microsoft Hololens (first version) as the AR device. Microsoft Hololens v1 has a 6DoF tracking module which allows to record both rotational and translational movements of users very accurately.
5.1. Data collection
We showed 7 users a static virtual object and recorded their movements in 6DoF space while they were inspecting the object. The users were not given any specific instructions for their movements but were only instructed to freely inspect the virtual object. We collected position (, , ) and rotational samples represented as quaternions (, , , ).
5.2. Data pre-processing
Since the raw sensor data we obtained from Microsoft Hololens was unevenly sampled (i.e. the temporal distance between two samples is not the same), we applied some pre-processing to resample and interpolate the data with a given sampling frequency. Our raw data contains about 60 unevenly-spaced samples per second. We upsampled the data by linearly interpolating between the position samples (x, y, z) and using Spherical Linear Interpolation of Rotations (SLERP)(shoemake1985) for interpolating the quaternions (, , , ). Thus, we obtained one sample at each 1 ms (1000 Hz). Sampling rate is an adjustable parameter in our framework; however, we set it to 1000 Hz since it matches well with the typical sampling rates of Inertial Measurement Units (IMU) used in augmented reality devices (daqri2018).
Our 6DoF user movement dataset is freely available on Github222A link will be provided after the review process. for further usage in research community.
6. Prediction method
6.1. Method description
We observe that the position (, , ) and rotation values (quaternions: , , , ) in our traces form separate time series and thus can be investigated independently. We use a simple Autoregression (AutoReg) model to predict future values. AutoReg is a commonly used technique for forecasting the future values of a time series. AutoReg models use a linear combination of the past values of a variable to forecast the future values of that variable (hyndman2018).
An AutoReg model of lag order can be written as
where is the true value of the timeseries at time ,
is the white noise,are the coefficients of the model. Such a model with lagged values is referred to as an
model, an autoregressive model of order. Some statistics software libraries can determine the lag order of the model automatically using statistical tests such as the Akaike Information Criterion (AIC) (akaike1973).
We created an AutoReg model using Python statsmodels library and saved the lag order and coefficients of the trained model. Our model has a lag order of meaning that it considers a history window of the past ms and predicts the next value using Eq. 6. We fit our model using the time series formed by the -coordinate in one of the randomly selected trace from our dataset. We observed that fitting the model to other traces does not cause a difference in performance. Furthermore, it turned out that the performance of the model trained by the x-coordinates is well suited also for the other translational and rotational values.
We use the created AutoReg model to predict the user’s translational movements corresponding to the three position values (, , ), and the user’s rotational movements correspoding to the four quaternions (, , , ). We perform the prediction of rotations in quaternion domain since quaternions are continuous real numbers that are uniquely defined and easier to deal with than the Euler angles (yaw, pitch, roll) which may lead to ambiguous representations of rotations in certain cases due to gimbal lock (diebel2006). Also, the numerical difference between two Euler angles that are very close on the unit circle (e.g. vs ) can be quite large causing discontinuities which may reduce the accuracy of the prediction algorithm. Quaternions allow smooth interpolation, avoid the gimbal lock, and can easily be converted to Euler angles which are better suited for understanding and visualizing the user’s orientation. Therefore, after prediction, we convert quaternions to Euler angles and evaluate the prediction accuracy in the domain of Euler angles.
6.2. Prediction accuracy and statistics
In our evaluation, we investigated the effect of prediction on the accuracy of the viewport of the rendered image displayed to the user, i.e. the rendering offset or error. Specifically, we compared the predicted user pose (for a certain prediction window ) to the real user pose. As a benchmark, we evaluated the case in which no prediction is performed and the viewport of the displayed rendered image lags behind the actual user position by a delay corresponding to the end-to-end (motion-to-photon) latency (). We performed our experiments for different end-to-end latencies ranging between 20-100 ms and set for each experiment such that the prediction model attempts to predict the pose that the user would have attained at the time that the rendered image is displayed to the user.
We used the following metrics for our evaluation
Mean Absolute Error (MAE)
Root Mean Squared Error (RMSE)
where and are the true user pose and the rendered user pose, respectively, and is the number of samples. We include RMSE as an error metric in our analysis to consider the effect of significant deviations from the true user pose.
Table 4 shows the amount of rendering error for the case in which the rendered image corresponds to a pose delayed by (no-prediction case). Table 5 shows the rendering error for our prediction method where the motion-to-photon latency is eliminated by setting (prediction case). We observe that for all considered prediction window times , prediction reduces the average rendering offsets of both rotational (yaw, pitch, roll) and positional (x, y, z) components.
Figure 7 visualizes the prediction and baseline (no prediction) cases by focusing on the time range seconds from two different user traces. We set the display latency ms and assume that the client has a display with a 100 Hz refresh rate, and the rendered images are displayed to the user every 10 ms (considering the worst-case display latency). As shown in the figure (purple shaded area), at the beginning of the session, the prediction module waits for a history window of ms to collect the required amount of samples for the autoregression model and make the first prediction, and then outputs the pose that the user is predicted to attain after a time of ms (green shaded area). We observe that the accuracy of the prediction results depends on the frequency of the abrupt, short-term changes of the user pose. If position or orientation linearly changes over a history window (without changing direction), resulting predictions are fairly accurate. Otherwise, if short-term changes are present within a history window, predicting the user pose usually brings a lower rendering accuracy than the no-prediction case.
Our results suggest that the fast short-term variations of the user pose require further considerations in order to display an accurately rendered image to the user, especially for the rotational changes of the user pose. One option is to apply further post-processing at the client before the rendered image is sent to the display to correct the rendering offset. This method is known as ”time-warping” and is already deployed today in virtual reality headsets (e.g. Oculus Rift) (van2016).
To show the effect of the prediction error on the rendered image and give an impression on how this error can be corrected by relatively simple client operations, we rendered the correct image and the image with an exemplary prediction error. We take the results from Table 5 for the prediction error and assume a maximum error value for the translational values of and for the rotational values , which approximately corresponds to a prediction window of ms. Figure 8 shows an illustration. The figure on the right side shows an overlay of the actual picture position and the predicted picture position. The figure on the left side shows an exemplary client side correction for the prediction error in x-direction by simply shifting the 2D video on the client side by a few pixels. For the other values or combination of the values, a more complex operation in shifting and resizing of the object should be able to achieve a reasonable quality after correction of the prediction error. However, this needs to be proven in future research by subjective tests.
As can be seen in the overlays, the prediction errors cause the so called ”Judder” effect, which leads to unacceptable QoE. However, since the prediction error for such short prediction windows is minimal, a simple correction on the client side can lead to good results. This is exemplary shown in the figure for an error in XPos direction. The client performs a simple left shift of the object which corrects the prediction error in that direction. For AR applications, the background is anyway removed before displaying and therefore, the shift in the background does not have an effect on the displayed picture.
Cloud rendering systems bring significant advantages for volumetric streaming in terms of reducing the required bandwidth and processing power of the client. However, these advantages come at the cost of increased motion-to-photon latency that makes it challenging to design a low-latency cloud rendering system for volumetric video streaming. To address these challenges, we designed an edge computing based volumetric streaming system to reduce the network latency. Furthermore, we developed an autoregression model to predict the 6DoF user movement and investigated its potential to further reduce the end-to-end (motion-to-photon) latency. Our results show that the developed prediction model reduces the positional rendering errors caused by the motion-to-photon latency. However, we also observe that very fast movements cannot be accurately captured by a prediction model. To compensate for such fast movements, additional means, such as time warping, are therefore required on the client side. Our results suggest that 6DoF user movement prediction is a promising component to optimize the motion-to-photon latency in edge cloud rendering systems. In combination with additional tools such as time warping on the client side, it has the potential to almost eliminate the motion-to-photon latency. As next step, our research aims to combine the user prediction model with a client side positional correction and analyze the effect of the positional error on the QoE through subjective tests.