QNX Core Graphics Technology
QNX core graphics technology is delivered with the QNX Software Development Platform (SDP). It is a set of tools and runtime components for creating sophisticated displays that feature accelerated 2D and 3D graphics rendering with little CPU overhead. It is an appropriate graphics solution for projects that involve:
- 2D and 3D (OpenGL ES) APIs without the need for screen builder tools
- Third-party graphical products built with QNX core graphics technology
QNX core graphics technology is based on a clean-room and certified implementation of the industry standard OpenGL ES API. It allows developers to leverage a base of existing OpenGL code as well as industry programming expertise.
- Programming environment (headers and libraries) for developing 2D and 3D applications
- Sample code illustrating 2D, 3D, video capture, image manipulation, cursor control and use of fonts
- Drivers for graphic controllers
- Runtime libraries for 2D drawing, layering control, and video capture
- Runtime libraries for 3D (OpenGL ES API certified)
- Runtime libraries for font and image rendering
- Graphic display manager
Reduced BOM costs
Applications built using QNX core graphics technology load only the graphical services they need, keeping memory requirements as low as possible, while high-performance drivers get the best possible performance from low-end hardware.
Low deployment costs
The software modularity of QNX core graphics technology facilitates deployment only of required features, for savings in software development and hardware.
OpenGL ES source code is provided as part of QNX core graphics technology. It allow projects to draw on large industry base of programming expertise, while the standards based 3D environment keeps developer learning curve and ramp up time to a minimum.
The QNX composition manager facilitates integration with applications built on other technologies, such as Adobe Flash.
QNX Core Graphics technology includes the QNX Graphics Framework (GF), the QNX OpenGL ES implementation, and the QNX Composition Manager.
QNX Core Graphics is an excellent library for creating and implementation application user interfaces on hardware that cannot support the overhead of a full windowing system. It provides the services needed to support interfaces ranging from the smallest 2D environment to full-featured 3D environments.
Features supported by QNX Core Graphics include:
- integration with graphics device layering facilities
- 2D hardware acceleration, where supported by the GPU
- 3D hardware acceleration, where supported by the GPU
- multi-buffering for flicker-free animations
Applications built with QNX Core Graphics typically use a variety of components, including:
- the QNX Graphics Framework, which provides a framework for creating 2D application user interfaces without the overhead of a full windowing system
- OpenGL ES for 3D interfaces
- an input manager for mouse and keyboard management
- the font rendering system
- the image rendering library
The architecture allows applications to render directly to hardware, making them faster and more responsive in an embedded environment where resources are limited.
QNX Graphics Framework
The QNX Graphics Framework (GF) is perfect for embedded environments, where it can be used as the basic graphics layer for:
- simple, full screen interfaces
- complex windowing systems with multiple application GUIs
- a porting layer for existing user interfaces
The GF provides applications direct access to graphics drivers, and hardware acceleration where possible.
Multiple threads and applications
While the GF is intended for full screen application user interfaces, it can handle multiple threads and multiple applications — including GF applications running alongside QNX® Photon microGUI® applications.
QNX Core Graphics includes a the GF's comprehensive 2D API library. This API supports key 2D graphics capabilities, such as drawing, rendering, layering, alphablending, association of drawing surfaces to contexts, and so on.
QNX Core Graphics supports the OpenGL ES 1.0 specification, a well-defined subset of OpenGL designed for 3D graphics in embedded applications. The QNX Neutrino implementation of OpenGL ES supports the Common profile and EGL platform interface layers.
The GF implements a client/server model:
- The server manages device resources (such as memory and layers) and hardware access.
- The client (GF application) renders directly to the hardware.
Clients can obtain a lock to ensure that only one thread or application has access to the hardware at a time.
The server provides robustness by catching abnormal client termination, cleaning up resources after termination, and reviving the shared mutex if it was held by an abnormally terminated client.
The server includes a monitor process that brokers client access to hardware, allocates video memory, and handles application termination (both normal and abnormal) by releasing allocated memory and, if necessary, locked hardware. This monitor is invisible to GF clients — all interactions are handled internally by the library.
Third-party or existing in-house graphics frameworks for underlying features perfroming tasks such as 2D and 3D drawing, or provided image and font support can easily use QNX Core Graphics. Developers only need to create simple wrapper routines to abstract the drawing operations for QNX Core Graphics.
The QNX composition manager is an OpenKODE-compliant lightweight composited windowing system that allows developers to merge the output of multiple windows and processes (Flash, native code applications, browsers) on to a single display — even with lower cost graphics controllers that donít support hardware layering.
The QNX composition Manager supports hardware display layers and software-emulated display layers, and enables the easy creation of transparency holes in video and flash content.
The QNX composition manager can be configured to use available compositing hardware so as to best meet the needs of a particular system. For example, on a system requiring frequent updates, it might be configured to maximize its use of layers available on a display controller, while on a system requiring less frequent updates it might use a 2D core to perform the same task.
Enabling the HMI
The QNX composition manager allows an HMI to interact with applications without manipulating the applications themselves, and without incurring any overhead from message passing.
An HMI can use OpenKODE extensions to receive events whenever a window is created, realized, or destroyed, or whenever properties for a given window are changed. The API enables the HMI to change the properties of any application's window, giving it complete control over the layout of the display, without directly interacting with the application.
The lists below identify key features supported by QNX Core Graphics.
2D graphic primitives
- rectangles, polylines, polygons, blitting
- alpha, chroma and raster operations
- accelerated alpha-maps
- OpenGL® ES API Common Profile version 1.0 — floating point and fixed point libraries Images
- BMP, GIF, JPEG and PNG formats
- smooth resizing and scaling
- Adobe Type 1 and Type 2
- Bitstreamô Stroke Fonts (including Chinese and Japanese)
- borders and outlines
- international fonts (UTF-8)
- scalable fonts
- hinting and kerning
Video capture API
- up/down hardware scaling
- RGB and YUV formats
Where supported by hardware:
- drawing surface to layer association
- layer ordering
- on or off for individual layers
- alphablending and chromacolor between layers
- source and destination viewport sizing and scaling, and panning control
- OpenGL ES libraries
- 2D libraries
- software-only OpenGL ES libraries, providing 3D support for graphics chips that have no 3D hardware acceleration
- the QNX composition manager
- image loading library supporting multiple image formats
- font libraries
- sample applications pre-compiled for testing 2D and 3D graphics
- Graphics Framework developer's guide
- OpenGL ES 1.0 documentation set
- Font Fusion API document
Sample source code
- 2D samples — draw rectangle, load and display image, load and display text, etc.
- 3D samples — vertex arrays, texture maps, etc.
- layer control — turn on/off layer, change chromacolor, etc.
Hardware-accelerated graphics drivers are used wherever possible, for both 2D and 3D graphics. When hardware acceleration is not supported, QNX Core Graphics provides appropriate software fallback routines.
- Fujitsu Coral B/P/PA graphics driver
- Fujitsu Carmine graphics driver
- Intel Extreme2 (855GM) graphics
- VESABios graphics driver for x86, VESA-compliant graphics controllers
- VMware graphics driver for QNX VMware sessions
Additional graphics drivers are provided in individual BSPs (Board Support Packages).
- QNX SDP 6.4.0 or more recent, on X86, PPC, SH4 and ARM target systems.
- QNX Momentics® IDE 6.3.0 or more recent
- QNX Core Graphics windowing system requires a license for each runtime if it is distributed with a customer product.
Developers working with QNX® Core Graphics technology can use combinations of displays, layers, surfaces and contexts to build very complex screens from simple applications
2D trend graph with touch screen
- 2D monitor display with touch screen and using high speed trend graphs.
The 2D navigation example below shows a graphics environment that supports four layers. Three layers are being used: one for 2D map display, one for menu/touch screen and another for warning messages. The developer may choose to build this type of screen as one complete program or as three separate programs. Proper use of chromakey and alphablending enable the visibility between the layers.
A four-layer 2D navigation system using alpha-blending to display menus and emergency notices.
Adding 3D is simple as developing an OpenGL ES program and either replacing the 2D program with the 3D upgrade or running the OpenGL ES program on the same layer as 2D (split screen).
A 3D map application built with QNX Core Graphics and the OpenGL ES API.
Adding a web browser becomes as simple as starting the QNX® Photon microGUI® on a graphic layer, then running a custom web browser application developed with the QNX web browser technology development kit.
A kiosk information system built with QNX Core Graphics and the OpenGL ES API.
QNX® core graphics technology is undergoing continuous improvement. Features provided since its initial release include:
Upcoming QNX SDP 6.5
- Improvements to functions and return codes
QNX SDP 6.4.1
- Support for Intel Poulsbo graphics
- Optimizations of several APIs
QNX SDP 6.4
- Support for video driver with the QNX software 3D graphics module
- Video drivers are shipped separately from QNX core graphics technology
- QNX core graphics technology and QNX® Photon® microGUI® applications share the same environment