Manycore architectures are gaining attention as a means to meet the performance and power demands of high-performance embedded systems. However, their widespread adoption is sometimes constrained by the need for mastering proprietary programming languages that are low-level and hinder portability. We propose the use of the concurrent programming language occam-pi as a high-level language for programming an emerging class of manycore architectures. We show how to map occam-pi programs to the manycore architecture Platform 2012 P2012. We describe the techniques used to translate the salient features of the language to the native programming model of the P2012. We present the results from a case study on a representative algorithm in the domain of real-time image processing: a complex algorithm for corner detection called Features from Accelerated Segment Test FAST. Our results show that the occam-pi program is much shorter, is easier to adapt and has a competitive performance when compared to versions programmed in the native programming model of P2012 and in OpenCL.

The majority of embedded application processors includes programmable GPUs capable of rendering complex 3D assets in real-time. Most of these assets are encoded in proprietary formats, limiting the possibility of exchange and dissemination. The MPEG-4 3DGC standard aims at solving this problem, in offering a compressed and comprehensive way to store and deliver animated, textured 3D assets across different platforms. In this paper, we presents the development of a Player developed on embedded, mobile and desktop platforms, capable of processing and rendering such models in real-time using OpenGL ES 2.0. In addition, extensions to the standards have been developed and proposed as amendment, pushing the 3DGC standard further to support modern, GPU-accelerated platforms.

Many-core architectures are becoming increasingly popular due to advances in open programming environments. Typical architectures are Graphics Processing Units (GPUs) and Homogenous Computing Fabrics, offering high computing parallelism in order to decrease execution time of computationally intensive algorithms, for example in Computer Vision. In this paper, a low complexity interest point detector has been written in OpenCL language and executed on different desktop and embedded computing platforms. The algorithm performs interest point detection in an image, around which there is enough distinctive information to enable further description. The algorithm has been optimized on the targeted platforms and performance and accuracy comparison has been performed.

This paper describes the global architecture and behavior of an ESSL compiler, based on the ES Shading Language for OpenGL ES 2.0 defined by the Khronos specification. This compiler is running at driver level, and processes shader code destined to run over a proprietary programmable 3D graphics pipeline functional model.

OpenVG is the 2D vector graphics API developed by Khronos. Full hardware acceleration of this API is not yet widely supported, unlike its 3D companion OpenGL ES. As a consequence, using ES compliant graphics hardware as a support for accelerating OpenVG comes naturally. In this paper, we summarize the four paint modes supported by OpenVG (color, linear gradient, radial gradient and pattern) and propose their possible implementation as GLSL ES fragment shaders running over an OpenGL ES compliant 3D graphics pipeline. We conclude with a proposal for enhancing the graphics hardware in order to support complex color ramps as supported by OpenVG.

Real-time 3D graphics is present today on various devices, from high-end PC powered by highly complex GPUs to more simple handheld consoles or mobile phones. All these solutions are based on an aging technique called immediate mode rasterization, very efficient for rendering simple scenes, but unable to capture essential visual features such as soft shadows, indirect lighting, real reflection and refractions, caustics, etc. Only global illumination algorithms are able to render such features. Moreover, the rendering time of a GPU increases linearly with the scene complexity, whereas a ray tracing solution shows a logarithmic progression. The aim of this paper is to present an overview of such global illumination algorithms, their common theoretical background and the advancements made to execute them in real-time.

The OpenGL ES standard has two active streams. The 1.X strand has a fixed functionality pipeline, whereas the 2.X versions feature flexible fragment and vertex shader units. In this paper we describe our implementation of version 1.1 over a 2.0 pipeline.