Abstract: In this paper, we present a GPU-based out-of-core rendering approach under the many-lights rendering framework. Many-lights rendering is an efficient and scalable rendering framework for a large number of lights. But when the data sizes of lights and geometry are both beyond the in-core memory storage size, the data management of these two out-of-core data becomes critical and challenging. In our approach, we formulate such a data management as a graph traversal optimization problem that first builds out-of-core lights and geometry data into a graph, and then guides shading computations by finding a shortest path to visit all vertices in the graph. Based on the proposed data management, we develop a GPU-based out-of-GPU-core rendering algorithm that manages data between the CPU host memory and the GPU device memory. Two main steps are taken in the algorithm: the out-of-core data preparation to pack data into optimal data layouts for the many-lights rendering, and the out-of-core shading using graph-based data management. We demonstrate our algorithm on scenes with out-of-core detailed geometry and out-of-core lights. Results show that our approach generates complex global illumination effects with increased data access coherence and has one order of magnitude performance gain over the CPU-based approach.

Abstract: Technologies related to intermediary graphics rendition are generally described. In some examples, an intermediary computing device may store graphics models in a model store. A server computing device may generate and send a compositing flow to the intermediary computing device. The compositing flow may comprise model identifiers and model rendering information. The intermediary computing device may retrieve models identified in the compositing flow from the model store, and provide the identified models and model rendering information to a Graphics Processing Unit (GPU) for rendering. The GPU may render graphics for delivery via a network to a client device.

Abstract: Within this paper, we present a novel, straightforward progressive encoding scheme for general triangle soups, which is particularly well-suited for mobile and Web-based environments due to its minimal requirements on the client's hardware and software. Our rapid encoding method uses a hierarchy of quantization to effectively reorder the original primitive data into several nested levels of detail. The resulting stateless buffer can progressively be transferred as-is to the GPU, where clustering is efficiently performed in parallel during rendering. We combine our approach with a crack-free mesh partitioning scheme to obtain a straightforward method for fast streaming and basic view-dependent LOD control.

Abstract: Many non-photorealistic rendering techniques exist to produce artistic effects from given images. Inspired by various artists, interesting effects can be produced by using a minimal rendering, where the minimum refers to the number of tones as well as the number and complexity of the primitives used for rendering. Our method is based on various computer vision techniques, and uses a combination of refined lines and blocks (potentially simplified), as well as a small number of tones, to produce abstracted artistic rendering with sufficient elements from the original image. We also considered a variety of methods to produce different artistic styles, such as colour and 2-tone drawings, and use semantic information to improve renderings for faces. By changing some intuitive parameters a wide range of visually pleasing results can be produced. Our method is fully automatic. We demonstrate the effectiveness of our method with extensive experiments and a user study.

Abstract: This disclosure describes techniques for using bounding regions to perform tile-based rendering with a graphics processing unit (GPU) that supports an on-chip, tessellation-enabled graphics rendering pipeline. Instead of generating binning data based on rasterized versions of the actual primitives to be rendered, the techniques of this disclosure may generate binning data based on a bounding region that encompasses one or more of the primitives to be rendered. Moreover, the binning data may be generated based on data that is generated by at least one tessellation processing stage of an on-chip, tessellation-enabled graphics rendering pipeline that is implemented by the GPU. The techniques of this disclosure may, in some examples, be used to improve the performance of an on-chip, tessellation-enabled GPU when performing tile-based rendering without sacrificing the quality of the resulting rendered image.

Abstract: Three-dimensional (3D) scene rendering is implemented in the form of a pipeline in graphics processing units (GPUs). In different stages of the pipeline, different types of data get accessed. These include, for instance, vertex, depth, stencil, render target (same as pixel color), and texture sampler data. The GPUs traditionally include small caches for vertex, render target, depth, and stencil data as well as multi-level caches for the texture sampler units. Recent introduction of reasonably large last-level caches (LLCs) shared among these data streams in discrete as well as integrated graphics hardware architectures has opened up new opportunities for improving 3D rendering. The GPUs equipped with such large LLCs can enjoy far-flung intra- and inter-stream reuses. However, there is no comprehensive study that can help graphics cache architects understand how to effectively manage a large multi-megabyte LLC shared between different 3D graphics streams. In this paper, we characterize the intra-stream and inter-stream reuses in 52 frames captured from eight DirectX game titles and four DirectX benchmark applications spanning three different frame resolutions. Based on this characterization, we propose graphics stream-aware probabilistic caching (GSPC) that dynamically learns the reuse probabilities and accordingly manages the LLC of the GPU. Our detailed trace-driven simulation of a typical GPU equipped with 768 shader thread contexts, twelve fixed-function texture samplers, and an 8 MB 16-way LLC shows that GSPC saves up to 29.6% and on average 13.1% LLC misses across 52 frames compared to the baseline state-of-the-art two-bit dynamic re-reference interval prediction (DRRIP) policy. These savings in the LLC misses result in a speedup of up to 18.2% and on average 8.0%. On a 16 MB LLC, the average speedup achieved by GSPC further improves to 11.8% compared to DRRIP.

Abstract: A set of tools, in the form of a software developers kit (SDK) for a graphics rendering system, is provided to improve overall graphics operations. In general, the tools are directed to analyzing a scene tree and optimizing its presentation to one or more graphics processing units (GPUs) so as to improve rendering operations. This overall goal is provided through a number of different capabilities, each of which is presented to software developers through a new applications programming interface (API).

Abstract: Parallel rendering of large polygonal models with transparency is challenging due to the need for alpha-correct blending and compositing, which is costly for very large models with high depth complexity and spatial overlap. In this paper we compare the performance of raster-based rendering methods on mesh models of neurons using two applications, one of which is specifically tailored to the neuroscience application domain, the other a general purpose visualization tool with domain specific additions. The first implements both sort-first and sort-last and uses a scene graph style traversal to cull objects, and dual depth peeling for order independent transparency, whilst the other uses a simpler brute force data-parallel approach with sort last composition. The advantages and trade offs of these approaches are discussed.We present the optimized algorithms needed to achieve interactive frame rates for a non-trivial, real-world parallel rendering scenario. We show that a generic data visualization application can provide competitive performance when optimizing its rendering pipeline, with some loss of capability over an optimized domain-specific application.

Abstract: Typical field-of-view (fov) of visual feedback in virtual reality applications is generally limited. In some cases, e.g. in videogames, the provided fov can be artificially increased, using simple perspective projection methods. In this paper, we design and evaluate different visualization techniques, inspired by the cartography domain, for navigating in virtual environments (VE) with a 360° horizontal fov of the scene. We have conducted an evaluation of different methods compared to a rendering method of reference, i.e. a perspective projection, in a basic navigation task. Our results confirm that using any omnidirectional rendering method could lead to more efficient navigation in terms of average task completion time. Among the different 360° projection methods, the subjective preference was significantly given to a cylindrical projection method (equirectangular). Taken together, our results suggest that omnidirectional rendering could be used in virtual reality applications in which fast navigation or full and rapid visual exploration are important. They pave the way to novel kinds of visual cues and visual rendering methods in virtual reality.

Abstract: As visualization is applied to larger data sets residing in more diverse hardware environments, visualization frameworks need to adapt. Rendering techniques are currently a major limiter since they tend to be built around central processing with all of the geometric data present. This is not a fundamental requirement of information visualization. This paper presents Abstract Rendering (AR), a technique for eliminating the centralization requirement while preserving some forms of interactivity. AR is based on the observation that pixels are fundamentally bins, and that rendering is essentially a binning process on a lattice of bins. By providing a more flexible binning process, the majority of rendering can be done with the geometric information stored out-of-core. Only the bin representations need to reside in memory. This approach enables: (1) rendering on large datasets without requiring large amounts of working memory, (2) novel and useful control over image composition, (3) a direct means of distributing the rendering task across processes, and (4) high-performance interaction techniques on large datasets. This paper introduces AR in a theoretical context, provides an overview of an implementation, and discusses how it has been applied to large-scale data visualization problems.

Abstract: It is impossible to directly visualize all of the items of a large dataset at once. Often, the number of items exceeds the number of pixels. Since direct representation is not a reliable option, a variety of methods have been developed for dealing with indirect representation. Such methods include clustering and intelligent filtering to reduce the number of items being considered in the first place. However, these techniques impose a high computational and interpretation costs. The alternative is to employ techniques to directly deal with the over-plotting that occurs. that occurs when there are too many items to display without overlapping. Over-plotting techniques include alpha composition, color weaving and selective plotting. Each of these has variants that yield different cognitive or computational optimizations. Unfortunately, most advanced over-plotting techniques are wrapped up in specific libraries. Experimenting with different techniques is cumbersome because they have not been provided with uniform interfaces or in a single runtime. This paper presents Abstract Rendering, a recasting of the rendering process that enables concise expression of many over-plotting techniques. Furthermore, the Abstract Rendering formulation yields efficient execution strategies. Combined, it is practical to explore different over-plotting techniques for large data without requiring significant alteration to existing pipelines.

Abstract: This paper presents a mathematical model for predicting power consumption of a mobile device when it is rendering 3D graphics. The model is based on 3D primitives (triangles, render batches, texels), and hence is hardware agnostic. With the model, a complexity of any given 3D scene can be predicted already at a production phase without access to the actual target hardware. This paper describes how the power consumption model is derived. The model is verified with measurements of real-world content and hardware. With the given hardware, 3D data and given verification scenarios, the model is able to predict the total power consumption with an error ranging from 0.3% to 3.2%.

Abstract: General purpose computing on GPUs (GPGPU) has experienced rapid growth over the last several years as new application realms are explored and traditional highly parallel algorithms are adapted to this computational substrate. However, a large portion of the parallel workload space, both in emerging and traditional domains, remains ill-suited for GPGPU deployment due to high reliance on atomic operations, particularly as global synchronization mechanisms. Unlike the sophisticated synchronization primitives available on supercomputers, GPGPU applications must rely on slow atomic operations on shared data. Further, unlike general purpose processors which take advantage of coherent L1 caches to speed up atomic operations, the cost and complexity of coherency on the GPU, coupled with the fact that a GPU's primary revenue stream - graphics rendering - does not benefit, means that new approaches are needed to improve atomics on the GPU. In this paper, we present a mechanism for implementing low-cost coherence and speculative acquisition of atomic data on the GPU that allows applications that utilize atomics to greater extents than is generally accepted practice today, to perform much better than they do on current hardware. As our results show, these unconventional applications can realize non-trivial performance improvements approaching 20% with our proposed system. With this mechanism, the scope of applications that can be accelerated by these commodity, highly-parallel pieces of hardware can be greatly expanded.

Abstract: Some examples include testing of software able to render a content item on a display of an electronic device. The testing may include capturing images of rendered portions of a content item and comparing the captured images with previously obtained reference images that have been verified to be correctly rendered. The testing techniques can be applied to conversion software that converts digital content items from one format to another and/or testing of the converted content items themselves. Additionally, content presentation software that displays digital content items on an electronic device, such as by interacting with rendering software, may also be tested using a similar technique.

Abstract: A graphics rendering system is provided for controlling the rendering of images to manage expected errors. The graphics rendering system receives a specification of a render task to be performed to render an image of a graphics scene and then identifies computing devices that each have a graphics processing unit. The graphics rendering system directs each of the identified computing devices to render the image specified by the render task such that each identified computing device renders the same image. When the graphics rendering system detects that a computing device has completed the render task successfully, it provides the image rendered by that computing device as the rendered image of the render task such that any other image rendered by another of the computing devices is not needed.

Abstract: We present an algorithm for realtime rendering of large-scale city models with procedurally generated facades. By using highly detailed assets like windows, doors, and decoration such city models can provide an extremely high geometric level of detail but on the downside they also consist of billions of polygons which makes it infeasible to even store them as explicit polygonal meshes. Moreover, when rendering urban scenes usually only a very small fraction of the city is actually visible which calls for effective culling mechanisms. For procedural textures there are efficient screen space techniques that evaluate, e.g., a split grammar on a per-pixel basis in the fragment shader and thus render a textured facade in a view dependent manner. We take this idea further by introducing 3D geometric detail in addition to flat textures. Our approach is a two-pass procedure that first renders a flat procedural facade. During rasterization the fragment shader triggers the instantiation of a detailed asset whenever a geometric facade element is potentially visible. The set of instantiated detail models are then rendered in a second pass. The major challenges arise from the fact that geometric details belonging to a facade can be visible even if the base polygon of the facade itself is not visible. Hence we propose measures to conservatively estimate visibility without introducing excessive redundancy. We further extend our technique by a simple level of detail mechanism that switches to baked textures (of the assets) depending on the distance to the camera. We demonstrate that our technique achieves realtime frame rates for large-scale city models with massive detail on current commodity graphics hardware.

Abstract: This disclosure describes techniques for rendering a plurality of primitives that includes at least two different types of primitives during the execution of a single draw call command. This disclosure also describes techniques for rendering a plurality of primitives using tessellation domains of different tessellation domain types during the execution of a single draw call command. The techniques of this disclosure may, in some examples, reduce the complexity and processing overhead for user applications, reduce the number of times that the rendering state of the graphics rendering pipeline needs to be switched during the drawing of a graphics scene, and/or reduce the number of times that shader programs need to be reloaded into different processing stages of a graphics pipeline during the rendering of a graphics scene.

Abstract: Many approaches have been developed to visualize 3D city scenes, most of which exhibit the visualization results in a uniform rendering style. This paper presents an expressive rendering approach for visualizing large-scale 3D city scenes with various rendering styles integrated in a seamless way. Each view is actually a combination of the photorealistic rendering and the nonphotorealistic rendering to highlight the information that is interesting for the users and de-emphasize the other that is less important. At run-time, the users are allowed to specify their interested locations interactively. Our system automatically computes the salience of each location and illustrates the entire scene with emphasis in the area of interests. The GPU-based implementation enables interactive realtime performance. Our implementation of a system demonstrates benefits in many applications such as 3D GPS navigation, tourist information, etc. We have performed a pilot user evaluation of the effect for users to access information in 3D city.

Abstract: Using colors for thematic mapping is a fundamental approach in visualization, and has become essential for 3D virtual environments to effectively communicate multidimensional, thematic information. Preserving depth cues within these environments to emphasize spatial relations between geospatial features remains an important issue. A variety of rendering techniques have been developed to preserve depth cues in 3D information visualization, including shading, global illumination, and image stylization. However, these techniques alter color values, which may lead to ambiguity in a color mapping and loss of information. Depending on the applied rendering techniques and color mapping, this loss should be reduced while still preserving depth cues when communicating thematic information. This paper presents the results of a quantitative and qualitative user study that evaluates the impact of rendering techniques on information and spatial perception when using visualization of thematic data in 3D virtual environments. We report the results of this study with respect to four perception-related tasks, showing significant differences in error rate and task completion time for different rendering techniques and color mappings.

Abstract: Mobile devices such as smartphones and tablets play an increasing role in today's working environment. The variety of computer platforms increased in the same way, which makes the development of cross-platform applications even more challenging. Tele-Board is a real-time remote collaboration system based on the Java programming language. Therefore, it cannot be run on most mobile devices. In order to overcome this limitation, we redeveloped the system on the basis of HTML5 technology. We present an approach for combining web based networking and rendering in a single application for real-time collaboration based on SVG, HTML5 Canvas, Websockets, and Web workers. In our prototype we implemented optimization mechanisms leveraging the Canvas API's rendering flexibility. This way, our canvas based rendering performs better than a respective SVG version. Moreover, our solution integrates server communication effectively so that the rendering performance is hardly influenced by user input.

Abstract: Computer-generated images are an essential part of today's life where an increasing demand for richer images requires more and more visual detail. e quality of resulting images is strongly dependent on the representation of the underlying surface geometry. is is particularly important in the movie industry where subdivision surfaces have evolved into an industry standard. While subdivision surfaces provide artists with a sophisticated level of exibility for modeling, the corresponding image generation is computationally expensive. For this reason, movie productions perform rendering offline on large-scale render farms. In this thesis we present techniques that facilitate the use of high-quality movie content in real-time applications that run on commodity desktop computers. We utilize modern graphics hardware and use hardware tessellation to generate surface geometry on-they based on patches. e key advantage of hardware tessellation is the ability to generate geometry on-chip and to rasterize obtained polygons directly, thus minimizing memory I/O and enabling cost-effective animations since only patch control points need to be updated every frame. We rst convert subdivision surfaces into patch primitives that can be processed by the tessellation unit. en patches are directly evaluated rather than by iterative subdivision. In addition, we add highfrequency surface detail on top of a base surface by using an analytic displacement function. Both displaced surface positions and corresponding normals are obtained from this function and the underlying subdivision surface. We further present techniques to speed up rendering by culling hidden patches, thus avoiding unnecessary computations. For interaction amongst objects themselves we also present a method that performs collision detection on hardware-tessellated dynamic objects. In conclusion, we provide a comprehensive solution for using subdivision surfaces in realtime applications. We believe that the next generation of games and authoring tools will bene t from our techniques in order to allow for rendering and animating highly detailed surfaces.

Abstract: One embodiment of the present invention includes approaches for processing graphics primitives associated with cache tiles when rendering an image. A set of graphics primitives associated with a first render target configuration is received from a first portion of a graphics processing pipeline, and the set of graphics primitives is stored in a memory. A condition is detected indicating that the set of graphics primitives is ready for processing, and a cache tile is selected that intersects at least one graphics primitive in the set of graphics primitives. At least one graphics primitive in the set of graphics primitives that intersects the cache tile is transmitted to a second portion of the graphics processing pipeline for processing. One advantage of the disclosed embodiments is that graphics primitives and associated data are more likely to remain stored on-chip during cache tile rendering, thereby reducing power consumption and improving rendering performance.

Abstract: Introduction: Basic Concepts Coordinate spaces, transformations Graphics pipeline Working with the windowing system Colors. Color models Raster algorithms Hidden surface removal Lighting models and shading Transforms in 2D Vectors and matrices Transforms in 2D Basic linear transformations Homogeneous coordinates Geometric Algorithms in 2D Line from two points Classification of a point relative to the line Classification of a circle relative to the line Classification of an axis-aligned bounding box (AABB) relative to the line Computing the area of triangle and polygon Intersection of two lines Intersection of two line segments Closest point on the line to the given point Distance from point to line segment Checking whether the given polygon is convex Check whether the point lies inside the given polygon Clipping line segment to a convex polygon, Cyrus-Beck algorithm Clipping a polygon: Sutherland-Hodgman algorithm Clipping a polygon to a convex polygon Barycentric coordinates Transformations in 3D, Projections, Quaternions 3D vectors and matrices. Dot and vector (cross) products Linear transformations-scale, reflection, rotation, and shear Reflection relative to a plane Rotation around an arbitrary vector (direction) Euler transformation Translation, affine transformation and homogeneous coordinates Rigid-body transformation Normal transformation Projections Coordinate systems in 3D, translations between different coordinate systems Quaternions: Representation of orientation in 3D using quaternions, quaternion interpolation Basic Raster Algorithms Raster grid, connectivity of raster grid, 4-connectivity, and 8-connectivity Bresenheim's line algorithm Bresenheim's circle algorithm Triangle filling Flood fill algorithm Color and Color Models CIEXY Z color space RGB color space CMY and CMYK color spaces HSV and HSL color spaces Gamma correction Y uv and Y CBCR color spaces Perceptually uniform color spaces, L*u*v* and L*a*b* color spaces sRGB color space Basic freeglut and GLEW for OpenGL Rendering freeglut initialization Window creation Processing events Using the GLEW library Wrapping freeglut in a C++ class Hidden Surface Removal Basic notions Ray casting z-buffer Hierarchical z-buffer Priority algorithms Portals Potentially visible sets (PVS), computing PVS via portals Hardware occlusion queries and their usage Modern OpenGL: The Beginning History of OpenGL Main concepts of OpenGL Programmable pipeline Our first OpenGL program First OpenGL program using C++ classes Parameter interpolation Matrix operations Rotating the object by mouse Working with meshes Working with textures Instancing Framebuffer object and rendering into a texture Point sprite in OpenGL Working with Large 2D/3D Data Sets Bounding volumes Regular grids Nested (hierarchical) grids Quad-trees and Oct-trees kD-tree Binary space partitioning (BSP) tree Bounding volume hierarchy (BVH) R-trees Mixed structures Curves and Surfaces: Geometric Modeling Representation of curves and surfaces Elements of differential geometry, tangent space, curvature Bezier and Hermite curves and surfaces Interpolation Splines Surfaces of revolution Subdivision of curves and surfaces Basics of Animation Coordinates interpolation Orientation interpolation Key-frame animation Skeletal animation Path following Lighting Models Diffuse (Lambert) model Phong model Blinn-Phong model Ward isotropic model Minnaert lighting Lommel-Seeliger lighting Rim lighting Distance attenuation Reflection, Fresnel coefficient, and its approximations Strauss lighting model Anisotropic lighting Bidirectional reflection distribution function (BRDF) Oren-Nayar model Cook-Torrance model Ashikhmin-Shirley model Image-based lighting (IBL) Spherical harmonics and their usage for lighting Advanced OpenGL Implementation of lighting models Geometry shaders Transform feedback Multiple render targets (MRT) Uniform blocks and uniform buffers Tessellation OpenGL ES 2 WebGL GPU Image Processing Sampling, aliasing, filters Sepia effect Effects based on color transformations Edge detect filters Emboss filter Blur filters, Gaussian blur, separable filters Old-film effect Sharpness filter Image denoising, bilateral filter Special Effects in OpenGL Reflections Volumetric/layered fog Billboards, particle systems, soft particles Bumpmapping Reflection and refraction, environment mapping Fur rendering Parallax, relief and cone step mapping Sky rendering, Perez all-weather model Screen-space ambient occlusion (SSAO) Modeling depth of field High dynamic range (HDR) rendering Realistic water rendering Deferred rendering Light prepass rendering Ambient cubes Reflective shadow maps Splatting indirect illumination Basics of GPGPU What is GPGPU Basics of OpenCL Basics of CUDA Basics of linear algebra in OpenCL OpenCL-OpenGL interoperability Elements of Procedural Texturing and Modeling Fractals, Mandelbrot, and Julia sets Fractal mountains L-systems Perlin noise, turbulence, fBm Modeling marble, water, clouds with Perlin noise Cellular textures Non-Photorealistic Rendering Cartoon rendering Extended cartoon rendering Gooch lighting model Watercolor rendering Bibliography

Abstract: Performing high quality 3D visualizations on mobile devices, while tantalizingly close in many areas, is still a quite difficult task. This is especially true for 3D volume rendering of digital medical images. Allowing this would empower medical personnel a powerful tool to diagnose and treat patients and train the next generation of physicians. This research focuses on performing real time volume rendering of digital medical images on iOS devices using custom developed GPU shaders for orthogonal texture slicing. An interactive volume renderer was designed and developed with several new features including dynamic modification of render resolutions, an incremental render loop, a shader-based clipping algorithm to support OpenGL ES 2.0, and an internal backface culling algorithm for properly sorting rendered geometry with alpha blending. The application was developed using several application programming interfaces (APIs) such as OpenSceneGraph (OSG) as the primary graphics renderer coupled with iOS Cocoa Touch for user interaction, and DCMTK for DICOM I/O. The developed application rendered volume datasets over 450 slices up to 50-60 frames per second, depending on the specific model of the iOS device. All rendering is done locally on the device so no Internet connection is required.

Abstract: In some examples, aspects of this disclosure relate to a method for rendering an image. For example, the method includes generating visibility information indicating visible primitives of the image. The method also includes rendering the image using a binning configuration, wherein the binning configuration is based on the visibility information.

Abstract: Synthesizing global illumination effects is a vast field of research for both offline and real-time rendering. While the most important goals for offline rendering are realism and physical correctness, real-time rendering approaches additionally need to be sufficiently fast. In this paper we present a fast and novel global illumination approach capable to realize indirect illumination for diffuse and glossy surfaces based on thousands of virtual area lights even for dynamic scenes. To achieve real-time performance we calculate indirect light influence only on sparse scene points in model-space and interpolate the results for the entire visible scene. A novel shading technique is proposed to support high-frequency indirect lighting effects such as view-dependent glossy reflections without introducing temporal incoherence in dynamic scenes. Since our approach does not require any pre-computation it may be applied to Mixed Reality applications improving the visual integration of virtual content.

Abstract: In this paper, a video rendering ASIC for multiview automultiscopic displays using an image domain warping approach is presented. The video rendering core is able to synthesize up to nine interleaved views from full-HD (1080p) stereoscopic 3D input footage. The design employs elliptical weighted average (EWA) splatting to perform the image resampling. We use the mathematical properties of the Gaussian filters of EWA splatting to analytically integrate display anti-aliasing into the resampling step. The use of realistic assumptions on the image transformation enable a hardware architecture that operates on a video stream in scan-line fashion and that does not require an off-chip memory. The ASIC, fabricated in a 65nm CMOS technology, runs at 260MHz and is able to deliver 28.7 interleaved full-HD (1080p) frames per second with eight views enabled. It has a core power dissipation of 550mW and its complexity is 6.8 MGE, including 4.36 MBit SRAM macros.