Introduction to video streaming on SGX through v3dfx-basePrabindh Sundareson
v3dfx-base is a set of reusable classes, offering support for imgstream and eglimage based video streaming on TI SGX platforms like Beagleboard, DM3730 EVM, and TI 81xx platforms. QGLWidget wrapper support has been added.
By Eduardo Lima.
If you are running Linux on an Intel GPU, chances are that your graphics driver just got much better. Mesa, the most popular open source OpenGL implementation, has got a new intermediate language to represent GLSL shader programs. It is called NIR, and is based on modern knowledge on compilers and GPU architecture. The Intel i965 driver is fully powered by NIR now, after support to non-scalar shaders has been recently added.
This talk will give the audience a tour around the work done during 2015, that culminated in the rewrite of the i965 non-scalar backend to use NIR, and was released in Mesa 11.0. It will present a brief technical overview of how NIR integrates into a Mesa backend, some important considerations, and the main challenges we faced. It will also illustrate the benefits of the new backend by comparing to the old one in terms of performance and backend code complexity.
(c) 2016 FOSDEM VZW
CC BY 2.0 BE
https://archive.fosdem.org/2016/
LCU14 209- LLVM Linux
---------------------------------------------------
Speaker: Behan Webster
Date: September 16, 2014
---------------------------------------------------
★ Session Summary ★
This session will provide an update on the status of the LLVMLinux project; a project which is cooperating with both the Linux kernel and LLVM communities to build the Linux kernel with Clang/LLVM. This talk will also cover new things in LLVM which make clang even more attractive to the kernel community. LLVM is an extensive compiler technology suite which is already commonplace from Android/Renderscript and OpenCL through to high performance computing clusters.
---------------------------------------------------
★ Resources ★
Zerista: http://lcu14.zerista.com/event/member/137735
Google Event: https://plus.google.com/u/0/events/cp34l6uc5rmu189qn8eq3ps3bkc
Video: https://www.youtube.com/watch?v=gcVQxjb6iQ4&list=UUIVqQKxCyQLJS6xvSmfndLA
Etherpad: http://pad.linaro.org/p/lcu14-209
---------------------------------------------------
★ Event Details ★
Linaro Connect USA - #LCU14
September 15-19th, 2014
Hyatt Regency San Francisco Airport
---------------------------------------------------
http://www.linaro.org
http://connect.linaro.org
Kata Container & gVisor provide approaches to securely isolate containers by keeping them out of the direct kernel space. Kata Container uses virtual machines with lightweight kernels to isolate containers, while gVisor uses a userspace kernel implemented in Go to provide isolation. Both aim to protect the host kernel by preventing containers from accessing kernel resources directly. Kata Container has a larger memory footprint than gVisor due to its use of virtual machines, but provides stronger isolation of containers.
There is ongoing confusion, and some contention, over the right way to use the QThread class. Part of the confusion comes from the uniqueness of QThread, which is significantly different from other threading classes. There are two valid patterns of QThread use, and each pattern is best suited for different use cases. Errors will arise when mixing these two patterns, or applying them inappropriately.
This presentation will look at different patterns of threading in general, and examine in detail the two usage patterns for QThread. This talk will also cover how QThread works inside, how to communicate between threads, provide examples, and point out the pitfalls to avoid.
How to make a high-quality Node.js app, Nikita GalkinSigma Software
This document discusses how to build high quality Node.js applications. It covers attributes of quality like understandability, modifiability, portability, reliability, efficiency, usability, and testability. For each attribute, it provides examples of what could go wrong and best practices to achieve that attribute, such as using dependency injection for modifiability, environment variables for portability, and graceful shutdown for reliability. It also discusses Node.js programming paradigms like callbacks, promises, and async/await and recommends best practices for testing Node.js applications.
Building a Big Data Machine Learning PlatformCliff Click
This document discusses H2O, an open-source platform for doing parallel distributed machine learning. H2O can be accessed via REST and JSON, R, Python, and Java. It provides algorithms like generalized linear models, random forests, and deep learning. Sparkling Water allows moving data between Spark RDDs and H2O frames. Simple data-parallel coding in H2O uses MapReduce-style programming. This allows writing distributed algorithms easily in Java or Scala with good performance.
OpenGL is a powerful, low-level graphics toolkit with a steep learning curve that allows access to accelerated GPU hardware. Using OpenGL, developers achieve high fidelity, animated graphics ubiquitous in games, screen productions and scientific software.
Join us for a one-hour webinar and we will give a comprehensive overview of the many aspects of OpenGL development where Qt provides advanced interfaces that let the developer focus on the tasks instead of dealing with repetitive and error-prone, platform dependent issues.
Introduction to video streaming on SGX through v3dfx-basePrabindh Sundareson
v3dfx-base is a set of reusable classes, offering support for imgstream and eglimage based video streaming on TI SGX platforms like Beagleboard, DM3730 EVM, and TI 81xx platforms. QGLWidget wrapper support has been added.
By Eduardo Lima.
If you are running Linux on an Intel GPU, chances are that your graphics driver just got much better. Mesa, the most popular open source OpenGL implementation, has got a new intermediate language to represent GLSL shader programs. It is called NIR, and is based on modern knowledge on compilers and GPU architecture. The Intel i965 driver is fully powered by NIR now, after support to non-scalar shaders has been recently added.
This talk will give the audience a tour around the work done during 2015, that culminated in the rewrite of the i965 non-scalar backend to use NIR, and was released in Mesa 11.0. It will present a brief technical overview of how NIR integrates into a Mesa backend, some important considerations, and the main challenges we faced. It will also illustrate the benefits of the new backend by comparing to the old one in terms of performance and backend code complexity.
(c) 2016 FOSDEM VZW
CC BY 2.0 BE
https://archive.fosdem.org/2016/
LCU14 209- LLVM Linux
---------------------------------------------------
Speaker: Behan Webster
Date: September 16, 2014
---------------------------------------------------
★ Session Summary ★
This session will provide an update on the status of the LLVMLinux project; a project which is cooperating with both the Linux kernel and LLVM communities to build the Linux kernel with Clang/LLVM. This talk will also cover new things in LLVM which make clang even more attractive to the kernel community. LLVM is an extensive compiler technology suite which is already commonplace from Android/Renderscript and OpenCL through to high performance computing clusters.
---------------------------------------------------
★ Resources ★
Zerista: http://lcu14.zerista.com/event/member/137735
Google Event: https://plus.google.com/u/0/events/cp34l6uc5rmu189qn8eq3ps3bkc
Video: https://www.youtube.com/watch?v=gcVQxjb6iQ4&list=UUIVqQKxCyQLJS6xvSmfndLA
Etherpad: http://pad.linaro.org/p/lcu14-209
---------------------------------------------------
★ Event Details ★
Linaro Connect USA - #LCU14
September 15-19th, 2014
Hyatt Regency San Francisco Airport
---------------------------------------------------
http://www.linaro.org
http://connect.linaro.org
Kata Container & gVisor provide approaches to securely isolate containers by keeping them out of the direct kernel space. Kata Container uses virtual machines with lightweight kernels to isolate containers, while gVisor uses a userspace kernel implemented in Go to provide isolation. Both aim to protect the host kernel by preventing containers from accessing kernel resources directly. Kata Container has a larger memory footprint than gVisor due to its use of virtual machines, but provides stronger isolation of containers.
There is ongoing confusion, and some contention, over the right way to use the QThread class. Part of the confusion comes from the uniqueness of QThread, which is significantly different from other threading classes. There are two valid patterns of QThread use, and each pattern is best suited for different use cases. Errors will arise when mixing these two patterns, or applying them inappropriately.
This presentation will look at different patterns of threading in general, and examine in detail the two usage patterns for QThread. This talk will also cover how QThread works inside, how to communicate between threads, provide examples, and point out the pitfalls to avoid.
How to make a high-quality Node.js app, Nikita GalkinSigma Software
This document discusses how to build high quality Node.js applications. It covers attributes of quality like understandability, modifiability, portability, reliability, efficiency, usability, and testability. For each attribute, it provides examples of what could go wrong and best practices to achieve that attribute, such as using dependency injection for modifiability, environment variables for portability, and graceful shutdown for reliability. It also discusses Node.js programming paradigms like callbacks, promises, and async/await and recommends best practices for testing Node.js applications.
Building a Big Data Machine Learning PlatformCliff Click
This document discusses H2O, an open-source platform for doing parallel distributed machine learning. H2O can be accessed via REST and JSON, R, Python, and Java. It provides algorithms like generalized linear models, random forests, and deep learning. Sparkling Water allows moving data between Spark RDDs and H2O frames. Simple data-parallel coding in H2O uses MapReduce-style programming. This allows writing distributed algorithms easily in Java or Scala with good performance.
OpenGL is a powerful, low-level graphics toolkit with a steep learning curve that allows access to accelerated GPU hardware. Using OpenGL, developers achieve high fidelity, animated graphics ubiquitous in games, screen productions and scientific software.
Join us for a one-hour webinar and we will give a comprehensive overview of the many aspects of OpenGL development where Qt provides advanced interfaces that let the developer focus on the tasks instead of dealing with repetitive and error-prone, platform dependent issues.
This document discusses improving debugging of the Linux kernel using the open source debugger GDB. It begins with an overview of existing ways to debug the kernel using GDB, including via KGDB, Qemu, and JTAG probes like OpenOCD. It then discusses the concept of adding "Linux awareness" to GDB, which would allow it to better understand kernel concepts like threads and modules. Finally, it outlines three approaches to implementing this awareness: via a GDB scripting extension, in the GDB stub, or with a C extension to GDB. The overall goal is to make GDB a more full-featured and useful tool for kernel debugging.
OSDC 2015: Roland Kammerer | DRBD9: Managing High-Available Storage in Many-N...NETWAYS
The document discusses DRBD, a tool for managing high-availability storage in many-node setups. It introduces the new drbdmanage tool, which handles complexity in multi-node DRBD clusters by managing nodes, resources, volumes and distributing configurations. Drbdmanage also works with OpenStack's Cinder volume service to provide highly-available block storage. Key features of DRBD 9 include multi-node replication, auto-promotion of resources, and a transport abstraction layer enabling high-speed RDMA connectivity.
Presented at the Bossa'10 conference in Manaus, Brazil. The presentation talks about the direction in which the Qt widgets are being developed and introduces the idea of Controls to Qt and QML.
This document provides an overview of the FreeRTOS real-time operating system. It discusses FreeRTOS's task management features including task creation, states, data structures, and blocking behavior. It describes how tasks can create other tasks and pass parameters. It also summarizes FreeRTOS configuration options, licensing, and commercial variants.
The document discusses Qt widgets in depth, covering several topics:
- Widgets and window systems, how widgets interact with underlying windowing systems.
- Flags and attributes, the different types of flags and attributes that can be set on widgets.
- The future of Qt widgets, exploring potential future directions for the widget API and its relationship to the graphics view framework.
As the first class of system security, We studied on usage of GDB. After finishing the description about GDB, We had the time of experimentation.
For the practice, you can join and download the file including two flags at http://cafe.naver.com/artofthings/2063.
How to write multi threaded applications using Qt:
In the slides you'll learn about 3 alternatives, all of which allow running tasks simultaneously in Qt applications, and understand the use cases leading to choosing each.
This document provides an introduction and overview of parallel programming with CUDA and OpenCL. It outlines key topics like the CUDA and OpenCL architectures, programming languages, and terminology. Code examples are provided to demonstrate basic CUDA concepts like kernels, memory allocation, and using blocks and threads to perform array addition in parallel on the GPU. The document also briefly discusses matrix multiplication and optimizations like using shared memory.
This document provides an overview of using QtScript to add scripting capabilities to Qt applications. It discusses embedding the QtScript engine, exposing C++ objects and APIs to scripts, debugging scripts, and integrating QtScript with Qt's meta-object system. The presentation includes examples of calculating values from scripts, configuring the script environment, calling into scripts from C++, and debugging scripts. The goal is to give attendees an understanding of how to make their Qt applications scriptable using QtScript.
This document discusses Grand Central Dispatch (GCD), Apple's API for managing application concurrency. GCD makes it easy to divide work into background tasks or blocks that can be executed concurrently across multiple queues and threads. It provides serial and concurrent dispatch queues, and functions for asynchronously or synchronously dispatching blocks of work and controlling the execution of tasks.
This document provides instructions on configuring and troubleshooting the NetWitness Log Decoder. It begins with basic configuration steps like adding a log decoder, setting the capture interface, and starting capture. It then covers potential capture failures due to issues like disk space, parser errors, and describes how to analyze logs and configurations to diagnose the problems. The document also demonstrates how to ingest logs and view them in the log decoder and concentrator. It provides tips on troubleshooting log ingestion issues and checking that the log decoder is capturing logs received on port 514.
Unconventional webapps with gwt:elemental & html5firenze-gtug
This document discusses using GWT's Elemental library to enable unconventional web applications using WebRTC, WebGL, and WebGL. Elemental allows direct access to HTML5 features from Java code. The document provides examples of using WebRTC to access cameras, using WebGL for 3D rendering and processing video textures, and integrating the NyARToolkit library with GWT to enable augmented reality applications in the browser without plugins.
Qt Everywhere is a C++ abstraction platform that provides a complete portability layer for C++ applications across Windows, Linux, and Mac operating systems through frameworks like QtCore, QtNetwork, and QtXml that standardize APIs for file systems, networking, threading, and other common needs; while the standard C++ library is limited, Qt offers mature classes that make everyday C++ programming tasks easy and portable.
ceph::errorator<> throw/catch-free, compile time-checked exceptions for seast...ScyllaDB
The document discusses an error handling library called "errorator" that provides compile-time checked exceptions for seastar futures. Errorator avoids exceptions by using error codes and allows type-safe error handling without performance penalties from exceptions. It works by creating a specialized future type for each set of allowed error codes. Errorator futures can safely chain callbacks while preserving error type information without exceptions. This avoids issues with scalability of exceptions in high concurrency applications like seastar.
GDB can debug programs by running them under its control. It allows inspecting and modifying program state through breakpoints, watchpoints, and examining variables and memory. GDB supports debugging optimized code, multi-threaded programs, and performing tasks like stepping, continuing, and backtracing through the call stack. It can also automate debugging through commands, scripts, and breakpoint actions.
A Brief Introduction to the Qt Application FrameworkZachary Blair
The document discusses the Qt framework for cross-platform GUI and application development. It introduces Qt's container classes like QList and QMap, string handling class QString, and widget and GUI programming using signals and slots. Qt provides a standard set of widgets that look native on different platforms. It uses a signal/slot system and parent-child relationships for memory management. Developers can write code once and deploy applications across desktop and embedded platforms.
This document provides an overview and introduction to Qt for beginners. It covers the key features of Qt including writing code once to target multiple platforms. The agenda includes a C++ refresher on core concepts like objects, classes and signals/slots. It demonstrates a basic "Hello World" application in both C++ and QML. Core Qt classes covered are containers, iterators, QObject and signals/slots. The document looks ahead to covering more advanced Qt topics in future parts.
This document discusses using Qt Quick to recreate the UI of a TV streaming application, including configuring Qt Creator, creating views with ListView and PathView, using models and delegates, embedding QML in C++ applications, dynamically loading QML pages, and implementing a stack to navigate between pages.
Extended and embedding: containerd update & project use casesPhil Estes
A talk given at FOSDEM 2020 in the containers devroom on the current status of the CNCF containerd project as well as a dive into the ways users are extending and embedding containerd in other platforms and projects.
The document discusses the Qt Graphics View Framework, which provides a model-view architecture for 2D graphics. It consists of three main components: QGraphicsItems that are added to a QGraphicsScene canvas, and one or more QGraphicsViews to display the scene. QGraphicsItems can represent GUI elements and respond to events. The QGraphicsScene manages items and event propagation. QGraphicsViews visualize the scene and translate between scene and screen coordinates. The framework provides features like transformations, animation, collision detection and drag-and-drop.
This document discusses improving debugging of the Linux kernel using the open source debugger GDB. It begins with an overview of existing ways to debug the kernel using GDB, including via KGDB, Qemu, and JTAG probes like OpenOCD. It then discusses the concept of adding "Linux awareness" to GDB, which would allow it to better understand kernel concepts like threads and modules. Finally, it outlines three approaches to implementing this awareness: via a GDB scripting extension, in the GDB stub, or with a C extension to GDB. The overall goal is to make GDB a more full-featured and useful tool for kernel debugging.
OSDC 2015: Roland Kammerer | DRBD9: Managing High-Available Storage in Many-N...NETWAYS
The document discusses DRBD, a tool for managing high-availability storage in many-node setups. It introduces the new drbdmanage tool, which handles complexity in multi-node DRBD clusters by managing nodes, resources, volumes and distributing configurations. Drbdmanage also works with OpenStack's Cinder volume service to provide highly-available block storage. Key features of DRBD 9 include multi-node replication, auto-promotion of resources, and a transport abstraction layer enabling high-speed RDMA connectivity.
Presented at the Bossa'10 conference in Manaus, Brazil. The presentation talks about the direction in which the Qt widgets are being developed and introduces the idea of Controls to Qt and QML.
This document provides an overview of the FreeRTOS real-time operating system. It discusses FreeRTOS's task management features including task creation, states, data structures, and blocking behavior. It describes how tasks can create other tasks and pass parameters. It also summarizes FreeRTOS configuration options, licensing, and commercial variants.
The document discusses Qt widgets in depth, covering several topics:
- Widgets and window systems, how widgets interact with underlying windowing systems.
- Flags and attributes, the different types of flags and attributes that can be set on widgets.
- The future of Qt widgets, exploring potential future directions for the widget API and its relationship to the graphics view framework.
As the first class of system security, We studied on usage of GDB. After finishing the description about GDB, We had the time of experimentation.
For the practice, you can join and download the file including two flags at http://cafe.naver.com/artofthings/2063.
How to write multi threaded applications using Qt:
In the slides you'll learn about 3 alternatives, all of which allow running tasks simultaneously in Qt applications, and understand the use cases leading to choosing each.
This document provides an introduction and overview of parallel programming with CUDA and OpenCL. It outlines key topics like the CUDA and OpenCL architectures, programming languages, and terminology. Code examples are provided to demonstrate basic CUDA concepts like kernels, memory allocation, and using blocks and threads to perform array addition in parallel on the GPU. The document also briefly discusses matrix multiplication and optimizations like using shared memory.
This document provides an overview of using QtScript to add scripting capabilities to Qt applications. It discusses embedding the QtScript engine, exposing C++ objects and APIs to scripts, debugging scripts, and integrating QtScript with Qt's meta-object system. The presentation includes examples of calculating values from scripts, configuring the script environment, calling into scripts from C++, and debugging scripts. The goal is to give attendees an understanding of how to make their Qt applications scriptable using QtScript.
This document discusses Grand Central Dispatch (GCD), Apple's API for managing application concurrency. GCD makes it easy to divide work into background tasks or blocks that can be executed concurrently across multiple queues and threads. It provides serial and concurrent dispatch queues, and functions for asynchronously or synchronously dispatching blocks of work and controlling the execution of tasks.
This document provides instructions on configuring and troubleshooting the NetWitness Log Decoder. It begins with basic configuration steps like adding a log decoder, setting the capture interface, and starting capture. It then covers potential capture failures due to issues like disk space, parser errors, and describes how to analyze logs and configurations to diagnose the problems. The document also demonstrates how to ingest logs and view them in the log decoder and concentrator. It provides tips on troubleshooting log ingestion issues and checking that the log decoder is capturing logs received on port 514.
Unconventional webapps with gwt:elemental & html5firenze-gtug
This document discusses using GWT's Elemental library to enable unconventional web applications using WebRTC, WebGL, and WebGL. Elemental allows direct access to HTML5 features from Java code. The document provides examples of using WebRTC to access cameras, using WebGL for 3D rendering and processing video textures, and integrating the NyARToolkit library with GWT to enable augmented reality applications in the browser without plugins.
Qt Everywhere is a C++ abstraction platform that provides a complete portability layer for C++ applications across Windows, Linux, and Mac operating systems through frameworks like QtCore, QtNetwork, and QtXml that standardize APIs for file systems, networking, threading, and other common needs; while the standard C++ library is limited, Qt offers mature classes that make everyday C++ programming tasks easy and portable.
ceph::errorator<> throw/catch-free, compile time-checked exceptions for seast...ScyllaDB
The document discusses an error handling library called "errorator" that provides compile-time checked exceptions for seastar futures. Errorator avoids exceptions by using error codes and allows type-safe error handling without performance penalties from exceptions. It works by creating a specialized future type for each set of allowed error codes. Errorator futures can safely chain callbacks while preserving error type information without exceptions. This avoids issues with scalability of exceptions in high concurrency applications like seastar.
GDB can debug programs by running them under its control. It allows inspecting and modifying program state through breakpoints, watchpoints, and examining variables and memory. GDB supports debugging optimized code, multi-threaded programs, and performing tasks like stepping, continuing, and backtracing through the call stack. It can also automate debugging through commands, scripts, and breakpoint actions.
A Brief Introduction to the Qt Application FrameworkZachary Blair
The document discusses the Qt framework for cross-platform GUI and application development. It introduces Qt's container classes like QList and QMap, string handling class QString, and widget and GUI programming using signals and slots. Qt provides a standard set of widgets that look native on different platforms. It uses a signal/slot system and parent-child relationships for memory management. Developers can write code once and deploy applications across desktop and embedded platforms.
This document provides an overview and introduction to Qt for beginners. It covers the key features of Qt including writing code once to target multiple platforms. The agenda includes a C++ refresher on core concepts like objects, classes and signals/slots. It demonstrates a basic "Hello World" application in both C++ and QML. Core Qt classes covered are containers, iterators, QObject and signals/slots. The document looks ahead to covering more advanced Qt topics in future parts.
This document discusses using Qt Quick to recreate the UI of a TV streaming application, including configuring Qt Creator, creating views with ListView and PathView, using models and delegates, embedding QML in C++ applications, dynamically loading QML pages, and implementing a stack to navigate between pages.
Extended and embedding: containerd update & project use casesPhil Estes
A talk given at FOSDEM 2020 in the containers devroom on the current status of the CNCF containerd project as well as a dive into the ways users are extending and embedding containerd in other platforms and projects.
The document discusses the Qt Graphics View Framework, which provides a model-view architecture for 2D graphics. It consists of three main components: QGraphicsItems that are added to a QGraphicsScene canvas, and one or more QGraphicsViews to display the scene. QGraphicsItems can represent GUI elements and respond to events. The QGraphicsScene manages items and event propagation. QGraphicsViews visualize the scene and translate between scene and screen coordinates. The framework provides features like transformations, animation, collision detection and drag-and-drop.
GraalVM allows building native applications from Java and other JVM languages. It includes a new just-in-time compiler called Graal and the Truffle framework for building language interpreters. GraalVM also includes Sulong, which allows running LLVM-based languages on the JVM. The presenter discussed using GraalVM to build a native executable for a Zookeeper CLI tool called zkstat from Java code using techniques like ahead-of-time compilation with SubstrateVM, configuring reflection, and building a Docker image for distribution.
SDK – Software Development Kit
Boost data processing at the edge for general applications and processor intensive algorithms
AI – Artificial Intelligence
High performance deep neural network (DNN) engine to deploy any AI or machine learning module at the edge
ROS2 Executor plugin
Executor for ROS2 able to process up to 10 times more data with up to 50% reduction in CPU consumption.
GPU (Graphic Processing Unit)
High parallelisation of GPU to increase the processing data rate and GPU utilization
This document discusses container technologies including App Container (appc) and rkt. It provides an overview of appc components like the image format, discovery, and executor. It then discusses rkt, an implementation of appc, describing its modular architecture with stages 0-2 and use of systemd and cgroups for isolation. It also touches on rkt security, networking, and integration with systemd and user namespaces.
Klepsydra Streaming Distribution Optimiser (SDO):
• • • •
•
Runs on a separate computer
Executes several dry runs on the OBC
Collect statistics
Runs a genetic algorithm to find the optimal solution for latency, power or throughput
The main variable to optimise is the distribution of layers are the two dimension of the threading model.
This document describes the setup and architecture of a Red Hat Storage Cluster using Global File System (GFS), Clustered Logical Volume Manager (CLVM), and Global Network Block Device (GNBD). GFS allows nodes to share block-level storage over the network as if it were locally attached. GNBD exports block devices over TCP/IP to GFS nodes. CLVM provides cluster-wide logical volume management on top of shared block devices. The cluster uses components like CMAN, DLM, and fencing for distributed coordination and locking across nodes.
WebGL is a JavaScript API for rendering interactive 3D graphics and 2D graphics within any compatible web browser without the use of plug-ins. It uses OpenGL ES 2.0 to render animations and interactive effects on browsers. Some key features of WebGL include requestAnimationFrame() for rendering animations, GLSL shaders to program the GPU, and allowing JavaScript to directly interact with the GPU. The document provides examples of using Three.js and Blender to load 3D models into WebGL and render them, as well as examples of drawing directly with WebGL.
PgQ Generic high-performance queue for PostgreSQLelliando dias
PgQ is a generic high-performance queue for PostgreSQL. It allows for processing of data created in transactions at a later time in a high-throughput, low-latency, and robust manner. This is achieved by exporting PostgreSQL's MVCC visibility information which allows querying events that occurred between snapshots in a efficient manner without locking. PgQ provides APIs for easily inserting and consuming events in batches between snapshots.
idsecconf2023 - Satria Ady Pradana - Launch into the Stratus-phere Adversary ...idsecconf
Adversary Simulation pada lingkungan cloud memiliki karakteristik unik sehingga memerlukan pendekatan khusus. Stratus menawarkan fleksibilitas dalam melakukan simulasi attack secara native pada lingkungan cloud. Presentasi ini akan memberikan penjelasan tentang penggunaan Stratus dalam adversary simulation dan bagaimana mengembangkan skenario khusus sesuai kebutuhan.
GDAL (Geospatial Data Abstraction Library) is a translator library for raster and vector geospatial data formats. It supports over 140 raster and vector data formats and has tools for data translation and processing. Key GDAL utilities include gdalinfo for reporting metadata, gdal_translate for format conversion, gdalwarp for image warping and projection changes, and gdal_merge for mosaicking multiple rasters. GDAL is open source and works across many operating systems.
Porting the Source Engine to Linux: Valve's Lessons Learnedbasisspace
These slides discuss the techniques applied to porting a large, commercial AAA engine from Windows to Linux. It includes the lessons learned along the way, and pitfalls we ran into to help serve as a warning to other developers.
LibGDX is an open source, cross-platform game development framework. It allows developers to write games that can be deployed to desktop, Android, iOS, and HTML5 web browsers. LibGDX provides tools for game development including asset management, 2D and 3D graphics rendering, input handling, audio playback, and more. It aims to be highly performant and optimized for mobile platforms. Getting started involves creating a project, adding the LibGDX libraries, and implementing the ApplicationListener interface.
Building a sensor network controller using Apache Felix as the main software component. Describes architecture of an OSGi-based application and features provided by OSGi.
CUDA is a parallel computing platform and programming model developed by Nvidia that allows software developers and researchers to utilize GPUs for general purpose processing. CUDA allows developers to achieve up to 100x performance gains over CPU-only applications. CUDA works by having the CPU copy input data to GPU memory, executing a kernel program on the GPU that runs in parallel across many threads, and copying the results back to CPU memory. Key GPU memories that can be used in CUDA programs include shared memory for thread cooperation, textures for cached reads, and constants for read-only data.
Android 5.0 Lollipop brings huge change, compare to before.
This report includes statistics from source code with data and hidden features from source code & git log investigation.
This is a presentation I presented at NVIDIA AI Conference in Korea. It's about building the largest GPU - DGX-2, the most powerful supercomputer in one node.
WebGL and COLLADA were discussed as technologies for 3D rendering and asset interchange on the web. The presentation covered the history and capabilities of both standards. It also described approaches for loading COLLADA assets into WebGL, such as preprocessing COLLADA into JSON or loading XML directly and parsing it with JavaScript. Optimizing COLLADA assets for WebGL rendering through techniques like quantization and compression was also mentioned.
Similar to Ultrasound Image Viewer - Qt + SGX (20)
With the increasing needs of intelligent and autonomous systems to sense, move and react with the surroundings, it is a clear necessity to train such systems with as much relevant data as can be obtained. However, there are many challenges in obtaining real world data, particularly in a 3D environment. In this talk, I will cover some of the recent advances in Graphics and Computing techniques in 3D processing and their possible application in dynamic settings for autonomous systems. A vision of how synthetic data could be relevant in the future of intelligent systems is presented, along with the challenges. Backup material covers latest papers on the subject
This document provides an overview of GPU algorithms and trends in mid-2018. It discusses why GPUs are useful, the evolution of GPU programming models, and typical algorithms like image processing, deep learning, and graphics. It also covers bandwidth analysis tools, hardware advances, programming models like CUDA and C++ AMP, and improving performance through profiling and optimization. Emerging areas discussed include compute-in-flash, deep learning and operating systems, and using AI for space travel challenges.
Machine learning in the Indian Context - IEEE talk at SRM InstitutePrabindh Sundareson
An introduction to the key concepts of machine learning, and 4 case studies in the Indian context - Medicine, Language, Privacy, and Quality of life. Presented at SRM Institute, Chennai, Apr 2018
IEEE Communications Disability Special Interest Group and Visually Impaired Focus Group formed under the IEEE Standards Association is organizing its 2nd Hackathon on Enabling Ability in Disability through Standards & Technology hosted by R V College of Engineering, Mysore Rd, Bengaluru with the theme of Consumer Level Assistive Devices/ Applications. Winners would get to demo at ICCE-Asia 2017.
Updated Program Outline for ICCE Asia 2017 Bengaluru. Consists of keynotes from Cyient, Qualcomm, Revxx, IIT Madras, WiE Track, Panels, and Startup competitions on the floor.
The document discusses innovation and location factors that influence it. It notes that the Bangalore chapter of the IEEE Consumer Electronics Society has been recognized as the best chapter for helping practitioners improve capabilities and mentor new engineers. It outlines the innovation pipeline process and importance of strong education, research institutions, private sector support, and governance. While Silicon Valley has been highly innovative, the document suggests India, Karnataka, and Bangalore could also foster innovation due to lower costs and a strong ecosystem. Foundational research leads to breakthroughs but applications change rapidly, so both have value if one is prepared for change.
This document provides an introduction to Open Shading Language (OSL), including:
- OSL was developed at Sony Imageworks to describe shaders for use in rendering pipelines for movies. It uses the LLVM infrastructure.
- OSL allows accurately replicating measured surface properties like BRDFs to flexibly represent surface properties in rendered scenes.
- In OSL, shaders define functions that return surface, displacement, volume properties or new shaders, rather than directly calculating pixel colors. Reflectance and transmittance are modeled as functions called "closures".
- OSL closures compute an explicit symbolic description of how surfaces or volumes scatter light, which can be evaluated, sampled
Growth of CE and its critical role in various advances including sensors, displays, machine intelligence, automotive and other areas. Invited Lecture at Oxford.
Three.js is a JavaScript library for rendering 3D graphics in a web browser. It uses WebGL to render scenes made of objects like meshes, materials, lights and textures. A basic Three.js program creates a renderer, camera and scene, then adds objects to the scene and calls renderer.render() to display the scene. Key APIs include those for lights, geometries, materials, textures and offscreen rendering using render targets. Shaders can be passed to materials for custom rendering effects.
GFX Part 7 - Introduction to Rendering Targets in OpenGL ESPrabindh Sundareson
This document discusses rendering targets in OpenGL and OpenGL ES. It explains that a rendering context is required before drawing a scene, and that rendering can target either the window system framebuffer or an offscreen framebuffer object (FBO). FBOs allow offscreen rendering and render-to-texture capabilities. The document provides examples of programming with FBOs, including generating and binding FBOs, attaching textures and renderbuffers, and switching between onscreen and offscreen rendering targets. It also discusses considerations for porting OpenGL code to OpenGL ES.
GFX Part 6 - Introduction to Vertex and Fragment Shaders in OpenGL ESPrabindh Sundareson
This document discusses shaders in OpenGL ES, including:
1. Vertices define 3D geometry and are operated on by vertex shaders. Fragments are pixels produced by rasterizing primitives.
2. Shader characteristics include uniforms, attributes, varyings, and gl_Position. Programs contain related vertex and fragment shaders.
3. Vertex shaders operate on vertices and attributes. Fragment shaders operate on rasterized fragments and interpolated varyings to produce gl_FragColor.
4. A program combines a vertex and fragment shader. Functions, constructs, and invariance are discussed for shader programming. Special effects techniques like fog, particles, and shadows are also covered.
GFX Part 5 - Introduction to Object Transformations in OpenGL ESPrabindh Sundareson
The document discusses transformations in 3D graphics. It explains that OpenGL ES uses a right-handed coordinate system where negative z-values go into the screen, while GLKit uses a left-handed system. It also covers matrix operations for translation, rotation, projection and viewport transformations to position and render 3D objects correctly. Real-life 3D models are stored using vertices, indices, normals and texture coordinates, and tools like Blender and Assimp can be used to import and export 3D models.
Vertices are 3D points that define geometry in 3D space. They are outputs of 3D modeling tools. Rendering vertices involves complex floating point matrix operations and transformations to convert them to triangles for rendering. Key aspects of vertices include their position attributes like (x,y,z) as well as other attributes like normals and texture coordinates. Optimizing vertex rendering involves reducing data transfer between the CPU and GPU by using vertex buffer objects (VBOs) and indices to reference shared vertices. VBOs allow vertex data to be stored and referenced directly from GPU memory.
This document discusses the C, F, F APIs in GPU programming, specifically clear, flush, and finish. It explains that clear clears the target view area to the specified color. Flush ensures pending operations are kicked off but does not wait for completion, while finish ensures operations are kicked off and waits for completion. It also discusses how clear can help the GPU avoid unnecessary memory reads by discarding previous content. Deferred rendering is described as the GPU applying intelligence to determine what draw calls or portions of draw calls need to be executed. The role of viewport in determining the draw area is also mentioned. WebGL handles initial platform configuration through the browser, while native code requires handling display, surface, and context creation directly through APIs like
GFX Part 1 - Introduction to GPU HW and OpenGL ES specificationsPrabindh Sundareson
Introduction to OpenGL ES and GPU Programming portion of the 7 part session on GFX workshops. Introduces the OpenGL ES specifications from Khronos and provides a perspective of current GPU architectures.
John Carmack discussed his career in game development over the past 20 years since creating Doom. Some of the key points he made include: ideas that were once considered impossible are now possible and contributing to new applications; startups need to focus on the near future while established companies can plan further ahead; and latency in audio, sensors, and other systems still needs to be improved for virtual reality applications despite fast processors. He also noted the challenges and opportunities that virtual reality presents for reaching large audiences.
This document contains an OpenGL ES quiz from the GFX2014 Advanced Graphics Workshop held in Bangalore in March 2014. The quiz is divided into logical sections on OpenGL topics presented in the workshop. Participants can take the online quiz by clicking the "Q" icon on the provided webpage link. The quiz contains multiple choice questions testing knowledge of OpenGL ES specifications, including topics like primitive types, clipping, and instanced rendering.
What is an RPA CoE? Session 2 – CoE RolesDianaGray10
In this session, we will review the players involved in the CoE and how each role impacts opportunities.
Topics covered:
• What roles are essential?
• What place in the automation journey does each role play?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
This talk will cover ScyllaDB Architecture from the cluster-level view and zoom in on data distribution and internal node architecture. In the process, we will learn the secret sauce used to get ScyllaDB's high availability and superior performance. We will also touch on the upcoming changes to ScyllaDB architecture, moving to strongly consistent metadata and tablets.
Must Know Postgres Extension for DBA and Developer during MigrationMydbops
Mydbops Opensource Database Meetup 16
Topic: Must-Know PostgreSQL Extensions for Developers and DBAs During Migration
Speaker: Deepak Mahto, Founder of DataCloudGaze Consulting
Date & Time: 8th June | 10 AM - 1 PM IST
Venue: Bangalore International Centre, Bangalore
Abstract: Discover how PostgreSQL extensions can be your secret weapon! This talk explores how key extensions enhance database capabilities and streamline the migration process for users moving from other relational databases like Oracle.
Key Takeaways:
* Learn about crucial extensions like oracle_fdw, pgtt, and pg_audit that ease migration complexities.
* Gain valuable strategies for implementing these extensions in PostgreSQL to achieve license freedom.
* Discover how these key extensions can empower both developers and DBAs during the migration process.
* Don't miss this chance to gain practical knowledge from an industry expert and stay updated on the latest open-source database trends.
Mydbops Managed Services specializes in taking the pain out of database management while optimizing performance. Since 2015, we have been providing top-notch support and assistance for the top three open-source databases: MySQL, MongoDB, and PostgreSQL.
Our team offers a wide range of services, including assistance, support, consulting, 24/7 operations, and expertise in all relevant technologies. We help organizations improve their database's performance, scalability, efficiency, and availability.
Contact us: info@mydbops.com
Visit: https://www.mydbops.com/
Follow us on LinkedIn: https://in.linkedin.com/company/mydbops
For more details and updates, please follow up the below links.
Meetup Page : https://www.meetup.com/mydbops-databa...
Twitter: https://twitter.com/mydbopsofficial
Blogs: https://www.mydbops.com/blog/
Facebook(Meta): https://www.facebook.com/mydbops/
Dandelion Hashtable: beyond billion requests per second on a commodity serverAntonios Katsarakis
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
What is an RPA CoE? Session 1 – CoE VisionDianaGray10
In the first session, we will review the organization's vision and how this has an impact on the COE Structure.
Topics covered:
• The role of a steering committee
• How do the organization’s priorities determine CoE Structure?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
"$10 thousand per minute of downtime: architecture, queues, streaming and fin...Fwdays
Direct losses from downtime in 1 minute = $5-$10 thousand dollars. Reputation is priceless.
As part of the talk, we will consider the architectural strategies necessary for the development of highly loaded fintech solutions. We will focus on using queues and streaming to efficiently work and manage large amounts of data in real-time and to minimize latency.
We will focus special attention on the architectural patterns used in the design of the fintech system, microservices and event-driven architecture, which ensure scalability, fault tolerance, and consistency of the entire system.
From Natural Language to Structured Solr Queries using LLMsSease
This talk draws on experimentation to enable AI applications with Solr. One important use case is to use AI for better accessibility and discoverability of the data: while User eXperience techniques, lexical search improvements, and data harmonization can take organizations to a good level of accessibility, a structural (or “cognitive” gap) remains between the data user needs and the data producer constraints.
That is where AI – and most importantly, Natural Language Processing and Large Language Model techniques – could make a difference. This natural language, conversational engine could facilitate access and usage of the data leveraging the semantics of any data source.
The objective of the presentation is to propose a technical approach and a way forward to achieve this goal.
The key concept is to enable users to express their search queries in natural language, which the LLM then enriches, interprets, and translates into structured queries based on the Solr index’s metadata.
This approach leverages the LLM’s ability to understand the nuances of natural language and the structure of documents within Apache Solr.
The LLM acts as an intermediary agent, offering a transparent experience to users automatically and potentially uncovering relevant documents that conventional search methods might overlook. The presentation will include the results of this experimental work, lessons learned, best practices, and the scope of future work that should improve the approach and make it production-ready.
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
"NATO Hackathon Winner: AI-Powered Drug Search", Taras KlobaFwdays
This is a session that details how PostgreSQL's features and Azure AI Services can be effectively used to significantly enhance the search functionality in any application.
In this session, we'll share insights on how we used PostgreSQL to facilitate precise searches across multiple fields in our mobile application. The techniques include using LIKE and ILIKE operators and integrating a trigram-based search to handle potential misspellings, thereby increasing the search accuracy.
We'll also discuss how the azure_ai extension on PostgreSQL databases in Azure and Azure AI Services were utilized to create vectors from user input, a feature beneficial when users wish to find specific items based on text prompts. While our application's case study involves a drug search, the techniques and principles shared in this session can be adapted to improve search functionality in a wide range of applications. Join us to learn how PostgreSQL and Azure AI can be harnessed to enhance your application's search capability.
Getting the Most Out of ScyllaDB Monitoring: ShareChat's TipsScyllaDB
ScyllaDB monitoring provides a lot of useful information. But sometimes it’s not easy to find the root of the problem if something is wrong or even estimate the remaining capacity by the load on the cluster. This talk shares our team's practical tips on: 1) How to find the root of the problem by metrics if ScyllaDB is slow 2) How to interpret the load and plan capacity for the future 3) Compaction strategies and how to choose the right one 4) Important metrics which aren’t available in the default monitoring setup.
GlobalLogic Java Community Webinar #18 “How to Improve Web Application Perfor...GlobalLogic Ukraine
Під час доповіді відповімо на питання, навіщо потрібно підвищувати продуктивність аплікації і які є найефективніші способи для цього. А також поговоримо про те, що таке кеш, які його види бувають та, основне — як знайти performance bottleneck?
Відео та деталі заходу: https://bit.ly/45tILxj
In our second session, we shall learn all about the main features and fundamentals of UiPath Studio that enable us to use the building blocks for any automation project.
📕 Detailed agenda:
Variables and Datatypes
Workflow Layouts
Arguments
Control Flows and Loops
Conditional Statements
💻 Extra training through UiPath Academy:
Variables, Constants, and Arguments in Studio
Control Flow in Studio
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.
Northern Engraving | Modern Metal Trim, Nameplates and Appliance PanelsNorthern Engraving
What began over 115 years ago as a supplier of precision gauges to the automotive industry has evolved into being an industry leader in the manufacture of product branding, automotive cockpit trim and decorative appliance trim. Value-added services include in-house Design, Engineering, Program Management, Test Lab and Tool Shops.
2. Qt Dynamic Image Viewer
based on v3dfx-base
• This implementation tests video/image streaming
functionality via SGX GPU, using V3dfxGLScene,
for an Ultrasound image viewer.
– This application draws data into a GraphicsView with
V3dfxGLScene, and updates data in drawBackground()
• This application showcases the capability of
v3dfx-base, with ARGB input, with multiple (128
layers of) blending, all with <10% CPU loading
– With a regular glTexImage2D mode of texturing, this
would take 100% CPU, and lower fps rates
• Every frame shows a different angle of view
5. V3dfx-base Introduction
• Allows applications to integrate video streaming with SGX
without writing platform specific code in a re-usable way
– Support for imgstream AND eglimage through same API
deviceClass = new TISGXStreamIMGSTREAMDevice(); deviceClass = new TISGXStreamEGLIMAGEDevice();
texClass = new TISGXStreamTexIMGSTREAM(); texClass = new TISGXStreamTexEGLIMAGE();
deviceClass->qTexImage2DBuf(paArray); deviceClass->qTexImage2DBuf(paArray);
deviceClass->dqTexImage2DBuf(freeArray); deviceClass->dqTexImage2DBuf(freeArray);
channel 1 channel n channel 1 channel n channel n channel n
device device
device n
n+1 n+2
v3dfx-base
5
6. Is / Is Not
• Handles rapidly changing textures (RGB, YUV)
WHAT IT • Supports imgstream
• Supports eglimage
• Supports both imgstream and eglimage with single API
• Reusable class, delivered as “v3dfx-base.a” (ARM library)
IS • Needs Graphics SDK with eglimage/imgstream support
• Targeted to support multi-threaded operation (WIP)
• Targeted to support cropping (WIP)
WHAT IT • Does not initialise GL state, EGL state for application
• Does not do drawing (glDrawArray, glDrawElement)
• Does not do eglSwapBuffer
IS NOT • Does not provide fancy GLSL shaders
6
7. Underneath the hood – Target
Execution
-Contiguous buffer (preferred), allocated by customer application as texture input
-Customer application does drawing in its native way
-Dynamically update texture buffers using qTexImage2DBuf(), signal_draw() and dqTexImage2DBuf() calls
v3dfx-base.a
Customer application
linked in app, Qt wrapper ..
v3dfx-base (v3dfx-base.a) library archive
GL_IMG_texture_stream2
GL_OES_EGL_image_external
IMGSTREAM EGLIMAGE
User Mode SGX binary
User Mode SGX binary
bufferclass_ti
Kernel driver
SGX HW
7
8. Underneath the hood – raw API
deviceClass = new TISGXStreamIMGSTREAMDevice(); deviceClass = new TISGXStreamEGLIMAGEDevice();
texClass = new TISGXStreamTexIMGSTREAM(); texClass = new TISGXStreamTexEGLIMAGE();
deviceClass->qTexImage2DBuf(paArray); deviceClass->qTexImage2DBuf(paArray);
deviceClass->dqTexImage2DBuf(freeArray); deviceClass->dqTexImage2DBuf(freeArray);
channel 1 channel n channel 1 channel n channel n channel n
device device
device n
n+1 n+2
v3dfx-base
GL_IMG_texture_stream2 GL_OES_EGL_image_external
User Mode SGX binary User Mode SGX binary
bufferclass_ti
Kernel driver
SGX HW
8
13. Source Code organisation
– Base API implementation
• v3dfx-base/api
– Provides both imgstream and eglimage implementation as raw C++ classes
– Reusable Qt classes
• v3dfx-base/platforms/Qt
– (GraphicsItem based) – in progress
• v3dfx-base/platforms/qtQGL
– (QGLWidget based) – completed
– Test applications
• v3dfx-base/test/imgstream
– Raw (full screen, no window manager) test for imgstream based streaming
• v3dfx-base/test/eglimage
– Raw (full screen, no window manager) test for eglimage based streaming
• v3dfx-base/test/platforms/qtQGL
– Qt – QGLWidget based class, test for both imgstream and eglimage
• v3dfx-base/test/platforms/qt
– Qt – QGraphicsItem based class, test for both imgstream and eglimage (WIP)
13