Content
Search Results
Index
Loading, please wait ...

Loading

  • QNX Momentics IDE User's Guide
    • Working with QNX Momentics IDE
      • Get to know Eclipse
      • What's new in the IDE?
      • Starting the IDE
      • Preparing your target
      • Creating a target connection
    • Developing Projects with the IDE
      • Creating a QNX project
      • Writing code
      • Adding libraries
      • Building a QNX project
      • Running an application
    • Debugging Applications
      • Selecting a tool for debugging
      • Launching an application with the debugger attached
        • Debug perspective controls
      • Attaching the debugger to a running process
      • Debugging a core file
      • Debugging a child process
      • Debugging libraries
      • Debugging over a serial connection
      • Debugging non-IDE code
    • Unit Testing
      • Writing and building test programs
      • Running test programs
      • Measuring code coverage
        • Combining results from multiple sessions
      • Importing Code Coverage results
      • Exporting Code Coverage results
    • Analyzing Memory Usage and Finding Memory Problems
      • Monitoring memory and resource consumption
        • Monitoring memory consumption at the system level
        • Monitoring memory consumption at the process level
        • Monitoring resource usage for a process
      • Analyzing heap memory usage
        • Analyzing heap memory usage with System Information and the debugger
        • Analyzing heap memory usage with Memory Analysis
        • Analyzing heap memory usage with Valgrind Massif
        • Analyzing heap memory usage with Application Profiler
        • Analyzing heap memory usage with libc allocator API
      • Finding improper memory usage
        • Finding memory corruption with Valgrind Memcheck
        • Finding memory corruption with Memory Analysis
        • Finding thread synchronization problems with Valgrind Helgrind
      • Finding memory leaks
        • Finding memory leaks with Memory Analysis
        • Finding memory leaks with Valgrind Memcheck
        • Finding unused memory with Valgrind Massif
      • Optimizing an application after analysis
      • Configuring shared library support
      • Running memory-analyzing tools from the command line
      • Attaching Memory Analysis to a running process
      • Controlling librcheck
        • Controlling librcheck through signals
        • Controlling librcheck through API calls
      • Importing results from memory-analyzing sessions
        • Importing Memory Analysis data
        • Importing Valgrind logs
      • Exporting results from memory-analyzing sessions
        • Exporting Memory Analysis data
        • Exporting Valgrind logs
    • Analyzing Performance
      • Monitoring performance
        • Monitoring performance of processes
        • Monitoring performance of threads
      • Profiling applications
        • Sampling execution position and counting function calls
        • Measuring function runtimes
        • Profiling system activity with function instrumentation enabled
        • Attaching Application Profiler to a running process
        • Comparing profiling session results
      • Investigating performance bottlenecks
        • Analyzing cache usage with Valgrind Cachegrind
      • Configuring shared library support
      • Measuring application performance from the command line
      • Controlling profiling at runtime
        • Controlling profiling through signals
        • Controlling profiling through API calls
      • Importing performance analysis results
        • Importing Application Profiler data
      • Exporting performance analysis results
        • Exporting Application Profiler data
    • Analyzing System Behavior
      • Analyzing kernel activity with the System Profiler
        • Running a kernel event trace
        • Interpreting trace data in the System Profiler
          • Locating sources of high CPU usage
          • Isolating client and server CPU loads
          • Examining interrupt handling times
          • Detecting priority inversion
        • Interpreting trace data outside of the IDE
      • Controlling kernel event tracing
        • Controlling kernel event tracing through API calls
      • Importing and exporting kernel event trace results
    • Building QNX OS Images
      • Overview of OS images
        • Types of images you can create
        • Project layout
        • BSP filename conventions
      • Creating a QNX System Builder project
      • Modifying an OS image
      • Building an OS image
      • Downloading an image to your target
    • Reference
      • Switching between SDKs
      • Configuring host-target communication
        • IP communication
          • Securing qconn
        • Serial communication
      • Supported target types
        • Configuring a QNX target
        • Creating a QNX virtual machine
        • Controlling a QNX virtual machine
      • QNX C/C++ Project properties
      • QNX perspectives
      • Editors
      • Build configurations
      • Adding debug symbols and instrumentation code to binaries
      • Creating a non-QNX project
      • Managing launch configurations
        • Creating a launch configuration
          • Launch modes
          • QNX launch configuration types
          • QNX launch configuration properties
        • Editing a launch configuration
        • Importing launch configurations
      • Integrated tools
        • Application Profiler
        • Code Coverage
        • Memory Analysis
        • System Information
          • APS View
          • Connection Information
          • Malloc Information
          • Memory Information
          • Process Information
          • Signal Information
          • System Resources
          • System Summary
          • Target File System Navigator
          • Target Navigator
        • System Profiler
          • How kernel event tracing works
            • Kernel event trace log configuration
          • System Profiler editor
          • Client/Server CPU Statistics
          • Condition Statistics
          • Event Data
          • Event Owner Statistics
          • Filters
          • General Statistics
          • Thread Call Stack
          • Thread State Snapshot
          • Timeline State Colors
          • Trace Event Log
          • Why Running?
        • Valgrind
      • Updating the IDE
    • JTAG: Debugging with Lauterbach TRACE32
      • Prerequisites
      • Installing the Lauterbach TRACE32 In-Circuit Debugger software
      • Installing the Target Communication Framework (TCF) in the IDE
      • Installing the TRACE32 TCF Eclipse plugin
      • Building applications and an OS image for TRACE32-ICD debugging
      • Creating a TRACE32 startup script
      • Creating a launch configuration for debugging an OS image
      • Starting a TRACE32-ICD debugging session
  • QNX Software Development Platform
    • Quickstart Guide
      • Requirements
      • 1. Installing QNX SDP and QNX Momentics IDE onto the development host
      • 2. Creating the QNX Neutrino RTOS target system
      • 3. Creating a program project
      • 4. Compiling and linking
      • 5. Running and debugging the program
      • Making the program your own
    • OS Components
      • Adaptive Partitioning User's Guide
        • What is Adaptive Partitioning?
          • System and user requirements
          • The thread scheduler
        • Quickstart: Adaptive Partitioning Thread Scheduler
        • Thread Scheduler Details
          • Keeping track of CPU time
          • How is CPU time divided between partitions?
            • Underload
            • Free time
            • Full load
            • Summary of scheduling behavior
          • Partition inheritance
          • Critical threads
            • Bankruptcy
          • Adaptive partitioning thread scheduler and other thread schedulers
          • Using the thread scheduler and multicore together
        • Setting Up and Using the Adaptive Partitioning Thread Scheduler
          • Building an image
          • Creating scheduler partitions
          • Launching a process in a partition
          • Viewing partition use
        • Considerations for the Thread Scheduler
          • Determining the number of scheduler partitions and their contents
          • Choosing the percentage of CPU for each partition
            • Setting budgets to zero
            • Setting budgets for resource managers
          • Choosing the window size
            • Accuracy
            • Delays compared to priority scheduling
          • Practical limits
          • Uncontrolled interactions between scheduler partitions
        • Security for Scheduler Partitions
        • Testing and Debugging
          • Instrumented kernel trace events
          • Using the IDE (trace events)
          • Using other methods
          • Emergency access to the system
        • Sample Buildfile
        • Glossary
      • Boot Optimization Guide
        • About the System Startup Sequence
        • Optimizing the Loading and Launching of the OS
          • Optimize the bootloader
          • Optimize your image scan
          • Generic techniques to reduce the size of the IFS
          • Reduce the size of the startup program
          • Remove unnecessary debug printing
          • Optimize use of system and secondary disks
          • Use compression strategies
        • Optimizing the Platform Application Stack
          • Reorder the startup program
          • Make careful use of the default boot script
          • Consider the placement of waitfor statements
        • Measuring Boot Times
          • Using timestamp to measure startup times
          • Measuring the time to copy from flash to RAM
        • Optimizing Screen Startup Times
          • Screen startup optimizations at a glance
          • Configure a primary and a secondary IFS on the System
            • Example for the NXP i.MX6 SABRE for Smart Devices Platform board
          • Optimize the Screen configuration file
          • Optimize the boot script
          • A minimalist buildfile
          • Optimize the splash screen application
            • Choose how to render to a display
            • Avoid using a framebuffer
            • Optimizing the use of calls to APIs
            • Optimize the usage of windows from Screen
            • Use multiple threads
            • Use statically linked libraries
          • Other techniques and troubleshooting
      • Building Embedded Systems
        • Overview
          • The boot process
          • BSP components
            • Initial Program Loader (IPL)
            • Image Filesystem (IFS)
            • Startup program
            • Boot scripts
            • Drivers
          • Other components
        • Working with QNX BSPs
          • Getting and extracting a BSP
          • BSP structure and contents
          • The BSP Makefile
          • Building a BSP
          • Transferring an IFS to a target platform
          • Transferring an OS image to an x86_64 target platform
          • Booting QNX Neutrino
        • Initial Program Loaders (IPLs)
          • From reset to startup
          • x86 disk boot IPLs
          • ARM IPLs
          • Image storage
            • Image storage methods
          • The startup header
            • The info member
          • Customizing an IPL
          • Optimizing an IPL
        • Startup Programs
          • Startup tasks
            • Hardware initialization
            • Debug startup tasks
          • Source code directories
          • Source code structure
          • Modifying the startup program
        • Kernel Callouts
          • Kernel callout categories
            • Kernel debug
            • Interrupt controller
            • Timer and clock
            • System reset
            • Cache control
            • Custom
          • Writing a kernel callout
            • Kernel callout start and end macros
            • Patching the kernel callout code
            • Allocating read/write storage
            • interrupt_id_*() and interrupt_eoi_*()
        • System Page
          • system_private
          • asinfo
          • hwinfo
            • Tags
            • Items
            • Building the hwinfo section
          • cpuinfo
          • cacheattr
          • qtime
          • callout
          • intrinfo
          • smp
          • un
        • OS Images
          • Deciding what goes on the target
          • Building an OS image
          • Building a flash filesystem image
            • Sockets and partitions
            • mkefs and its buildfile
            • File compression
          • Creating a new filesystem on your target
          • Combining multiple image files
        • OS Image Buildfiles
          • Buildfile syntax
          • Buildfile structure and contents
          • The bootstrap file
          • Scripts
          • Environment variables
          • The rest of the buildfile
          • Board-specific information
          • Including files in the image
            • Changing where mkifs looks for files
            • Including many files
            • Adding missing shared libraries automatically
            • Location of files on the target
          • File ownership and permissions
          • System configuration
        • IPL Library
          • enable_cache()
          • image_download_8250()
          • image_download_ser()
          • image_scan(), image_scan_2()
          • image_setup(), image_setup_2()
          • image_start(), image_start_2()
          • init_8250()
          • int15_copy()
          • jump()
          • print_byte()
          • print_char()
          • print_long()
          • print_sl()
          • print_string()
          • print_var()
          • print_word()
          • protected_mode()
          • uart_hex8
          • uart_hex16
          • uart_hex32
          • uart_init
          • uart_put
          • uart_string
          • uart32_hex8
          • uart32_hex16
          • uart32_hex32
          • uart32_init
          • uart32_put
          • uart32_string
        • Startup Library
          • add_cache()
          • add_callout()
          • add_callout_array()
          • add_interrupt()
          • add_interrupt_array()
          • add_ram()
          • add_string()
          • add_typed_string()
          • alloc_qtime()
          • alloc_ram()
          • armv_cache
          • armv_chip
          • armv_chip_detect()
          • armv_pte
          • armv_setup_v7()
          • as_add()
          • as_add_containing()
          • as_default()
          • as_find()
          • as_find_containing()
          • as_info2off()
          • as_off2info()
          • as_set_checker()
          • as_set_priority()
          • avoid_ram()
          • calc_time_t()
          • calloc_ram()
          • callout_io_map(), callout_io_map_indirect()
          • callout_memory_map(),callout_memory_map_indirect()
          • callout_register_data()
          • chip_access()
          • chip_done()
          • chip_read*()
          • chip_write*()
          • copy_memory()
          • del_typed_string()
          • find_startup_info()
          • find_typed_string()
          • handle_common_option()
          • hwi_add_device()
          • hwi_add_inputclk()
          • hwi_add_irq()
          • hwi_add_location()
          • hwi_add_nicaddr()
          • hwi_add_rtc()
          • hwi_alloc_item()
          • hwi_alloc_tag()
          • hwi_find_as()
          • init_asinfo()
          • init_cacheattr()
          • init_cpuinfo()
          • init_hwinfo()
          • init_intrinfo()
          • init_mmu()
          • init_nanospin()
          • init_qtime()
          • init_raminfo()
          • init_smp()
          • init_syspage_memory() (deprecated)
          • init_system_private()
          • jtag_reserve_memory()
          • kprintf()
          • pcnet_reset()
          • print_syspage()
          • rtc_time()
          • startup_io_map()
          • startup_io_unmap()
          • startup_memory_map()
          • startup_memory_unmap()
          • timer_diff()
          • timer_ns2tick()
          • timer_start()
          • timer_tick2ns()
          • tulip_reset()
          • uncompress()
          • x86_64_cpuid_string()
          • x86_64_cputype()
          • x86_64_fputype()
          • x86_scanmem()
        • Debugging QNX Embedded Systems
          • Generating IPL debug symbols
          • Generating startup debug symbols
        • Sample Buildfiles
          • Shared libraries
          • Using multiple consoles
          • Creating a temporary directory (/tmp)
          • Minimal configuration
          • Flash filesystem
          • Disk filesystem
          • TCP/IP with network filesystem
        • Glossary
      • Core Networking Stack User's Guide
        • Overview
          • Architecture of io-pkt
          • Threading model
          • Threading priorities
          • Components of core networking
          • Process manager abilities
        • Packet Filtering
          • Packet Filter interface
            • Packet Filter (pf) module: firewalls and NAT
          • Berkeley Packet Filter
        • IP Security and Hardware Encryption
          • Setting up an IPsec connection: examples
            • Between two boxes manually
            • With authentication using the preshared-key method
          • IPsec tools
          • Hardware-accelerated crypto
        • Wi-Fi Configuration
          • Using Wi-Fi with io-pkt
          • Connecting to a Wi-Fi network (Station mode)
            • Using no encryption
            • Using WEP (Wired Equivalent Privacy) for authentication and encryption
            • Using WPA/WPA2/WPA3 for authentication and encryption
              • Connecting with WPA/WPA2/WPA3
              • Personal-level authentication and Enterprise-level authentication
          • Using a Wireless Access Point (WAP)
            • Creating a WAP
              • Acting as a gateway
              • Acting as a bridge
            • WEP access point
            • WPA access point
          • WPA utilities
            • Using wpa_supplicant to manage your Wi-Fi network connections
          • TCP/IP configuration in a Wi-Fi network
            • Client in infrastructure or ad hoc mode
            • DHCP server on WAP acting as a gateway
            • Launching the DHCP server on your gateway
            • Configuring an access point as a router
        • Transparent Distributed Processing
          • Using TDP over IP
        • Network Drivers
          • Loading and unloading a driver
          • Troubleshooting a driver
          • Problems with shared interrupts
          • Writing a new driver
          • Debugging a driver using gdb
          • Dumping 802.11 debugging information
          • Jumbo packets and hardware checksumming
          • Padding Ethernet packets
          • Transmit Segmentation Offload (TSO)
        • Utilities, Managers, and Configuration Files
        • Writing Network Drivers for io-pkt
        • A Hardware-Independent Sample Driver: sam.c
        • Additional information
        • Glossary
      • Customizing a BSP
        • Prerequisites
        • The development process
        • OS Image Buildfiles
        • Startup
        • Graphics
        • I2C
          • I2C (Inter-Integrated Circuit) Framework
          • Hardware interface
            • Function table
              • version_info function
              • init function
              • fini function
              • send function
              • recv function
              • abort function
              • set_slave_addr function
              • set_bus_speed function
              • driver_info function
              • ctl function
              • bus_reset function
            • Access function
            • Sample calls
          • Application interfaces
            • Shared-library interface
            • Resource manager interface
              • Supporting data types
              • DCMD_I2C_BUS_RESET
              • DCMD_I2C_DRIVER_INFO
              • DCMD_I2C_MASTER_RECV (deprecated)
              • DCMD_I2C_MASTER_SEND (deprecated)
              • DCMD_I2C_RECV
              • DCMD_I2C_SEND
              • DCMD_I2C_SENDRECV
              • DCMD_I2C_SET_BUS_SPEED
              • DCMD_I2C_SET_SLAVE_ADDR (deprecated)
              • DCMD_I2C_STATUS
          • Resource manager design
        • USB
        • Networking
        • Serial port
        • SPI
      • Device Publishers Developer's Guide
        • Device Publishers
          • Running a device publisher
          • Role of device drivers
          • PPS object types
          • Plugins
            • Plugin ratings
        • The USB Launcher Service
          • Command line for USB launcher service (usblauncher_otg)
          • Device control object
          • Device information object
          • Driver object
          • Mount object
          • Mounting USB filesystems
          • Configuration files
          • USB hubs
          • Supported third-party applications and protocols
        • The mmcsdpub Publisher
          • Command line for mmcsdpub
          • Device information object
          • Driver object
          • Mount object
        • The cdpub Publisher
          • Command line for cdpub
          • Device control object
          • Device information object
          • Driver object
          • Mount object
      • High Availability Framework Developer's Guide
        • Introduction
          • Where's the problem?
          • A software foundation for HA
        • What's in the High Availability Framework?
        • The QNX Neutrino Approach to HA
          • The reset “solution”
            • Traditional RTOS architecture
          • Modularity means granularity
            • Intrinsic HA
        • Using the High Availability Manager
          • HAM hierarchy
            • Entities
            • Conditions
            • Actions
            • Action Fail actions
            • Multistaged recovery
          • State of the HAM
            • Example of the view shown in /proc/ham
          • HAM API
            • Connect/disconnect functions
            • Attach/detach functions
              • For self-attached entities
              • Code snippet using self-attach/detach calls
              • For attaching/detaching all other entities
              • Code snippet using attach/detach calls
            • Entity functions
            • Condition functions
              • Condition types
              • Condition flags
            • Action functions
            • Action fail functions
              • Example to monitor inetd
              • Example to monitor fs-nfs3
            • Functions to operate on handles
          • A client example
          • Starting and stopping a HAM
            • Stopping a HAM
            • Control functions
            • Verbosity control
            • Publishing autonomously detected conditions
            • Publish state transitions
            • Publish other conditions
            • Subscribing to autonomously published conditions
            • Trigger based on state transitions
            • Trigger based on specific published condition
        • Using the Client Recovery Library
          • MsgSend*() functions
          • Other covers and convenience functions
            • HA-awareness functions
            • I/O covers
            • Convenience functions
          • A simple example
          • State-reconstruction example
        • HAM API Reference
          • ham_action_control()
          • ham_action_execute()
          • ham_action_fail_execute()
          • ham_action_fail_log()
          • ham_action_fail_notify_pulse(), ham_action_fail_notify_pulse_node()
          • ham_action_fail_notify_signal(), ham_action_fail_notify_signal_node()
          • ham_action_fail_waitfor()
          • ham_action_handle(), ham_action_handle_node()
          • ham_action_handle_free()
          • ham_action_heartbeat_healthy()
          • ham_action_log()
          • ham_action_notify_pulse(), ham_action_notify_pulse_node()
          • ham_action_notify_signal(), ham_action_notify_signal_node()
          • ham_action_remove()
          • ham_action_restart()
          • ham_action_waitfor()
          • ham_attach(), ham_attach_node()
          • ham_attach_self()
          • ham_condition()
          • ham_condition_control()
          • ham_condition_handle(), ham_condition_handle_node()
          • ham_condition_handle_free()
          • ham_condition_raise()
          • ham_condition_remove()
          • ham_condition_state()
          • ham_connect(), ham_connect_nd(), ham_connect_node()
          • ham_detach()
          • ham_detach_name(), ham_detach_name_node()
          • ham_detach_self()
          • ham_disconnect(), ham_disconnect_nd(), ham_disconnect_node()
          • ham_entity(), ham_entity_node()
          • ham_entity_condition_raise()
          • ham_entity_condition_state()
          • ham_entity_control()
          • ham_entity_handle(), ham_entity_handle_node()
          • ham_entity_handle_free()
          • ham_heartbeat()
          • ham_stop(), ham_stop_nd(), ham_stop_node()
          • ham_verbose()
        • Client Recovery Library Reference
          • ha_attach()
          • ha_close()
          • ha_connection_ctrl()
          • ha_ConnectAttach(), ha_ConnectAttach_r()
          • ha_ConnectDetach(), ha_ConnectDetach_r()
          • ha_creat(), ha_creat64()
          • ha_detach()
          • ha_dup()
          • ha_fclose()
          • ha_fopen()
          • ha_open(), ha_open64()
          • ha_ReConnectAttach()
          • ha_reopen()
        • Examples
          • Simple restart
          • Compound restart
          • Death/condition notification
          • Heartbeating clients (liveness detection)
            • The process is made to heartbeat
          • Process starvation
            • Thread 2 is made to heartbeat
        • Glossary
      • High-Performance Networking Stack (io-sock)
        • Overview
          • Architecture of io-sock
          • Threading model and priorities
          • Socket API
          • WiFi capability
        • Privilege Control
        • Packet Filtering
        • Starting io-sock and Driver Management
        • Running io-sock with diagnostic features
        • Migrating an Application to the io-sock Networking Stack and Manager
        • Modifying a BSP to Support io-sock
        • Socket API
          • clearsockprefix()
          • in6addr_*
          • setsockprefix()
        • Utilities and Driver Reference
          • Networking utilities and services
          • devctl
          • devs-axe.so
          • devs-axge.so
          • devs-cdce.so
          • devs-dwc.so
          • devs-dwceqos.so
          • devs-em.so
          • devs-ffec.so
          • devs-genet.so
          • devs-iwm.so
          • devs-ixgbe.so
          • devs-libfdt.so
          • devs-libpci.so
          • devs-libusbdci.so
          • devs-phy.so
          • devs-re.so
          • devs-smsc.so
          • devs-urndis.so
          • devs-vmx.so
          • ifconfig (io-sock)
          • inetd (io-sock)
          • io-sock
          • ptpd2
          • sysctl (io-sock)
          • vmstat
        • Writing Network Drivers for io-sock
        • A Hardware-Independent Sample Driver: sample.c
        • Adding PTP into io-sock Network Drivers
        • devs-qwdi_dhd_pcie-version.so
      • Instant Device Activation
        • Using Minidrivers for Instant Device Activation
          • The minidriver basics
          • The minidriver architecture
          • How does the minidriver work?
            • Seamless transition
            • Running multiple handler functions
        • Writing a Minidriver
          • Timing requirements
          • Data storage
          • Handler function
            • Hardware access
            • Debugging from within the minidriver
          • Customizing the startup program to include your minidriver
          • Making the transition to a full driver
          • Making a boot image that includes your minidriver
        • Sample Minidriver
          • The minidriver handler function
          • Adding your minidriver to the system
          • Test application: mini-peeker.c
          • Transition from minidriver to full driver
        • APIs and Datatypes
          • mdriver_add()
          • mdriver_entry
          • mdriver_max
        • Hardware Interaction Within the Minidriver
      • Migrating to QNX SDP 7.1
        • Planning Your Migration
        • Migration Guidelines
          • Board Support Packages
          • Buildfiles
          • Kernel and process manager
          • Graphics
          • Audio
          • Resource Managers
          • QNX Momentics IDE
      • PCI Server User's Guide
        • PCI Server Overview
          • Environment variables
          • Configuration files
        • Design Details
          • Module loading
          • Configuration space access
          • The PCI server
          • Hardware-dependent modules
          • Capability modules
          • The “Strings” module
        • API Reference
          • pci_bdf()
          • pci_bdf_t
          • pci_chassis_slot_bridge()
          • pci_chassis_slot_device()
          • pci_device_attach()
          • pci_device_cfg_cap_disable(), pci_device_cfg_cap_enable()
          • pci_device_cfg_cap_isenabled()
          • pci_device_cfg_rd*()
          • pci_device_cfg_wr*()
          • pci_device_chassis_slot()
          • pci_device_detach()
          • pci_device_find()
          • pci_device_find_capid()
          • pci_device_is_multi_func()
          • pci_device_map_as()
          • pci_device_read_*()
          • pci_device_read_ba()
          • pci_device_read_cap()
          • pci_device_read_capid()
          • pci_device_read_irq()
          • pci_device_reset()
          • pci_device_rom_disable(), pci_device_rom_enable()
          • pci_device_write_cmd(), pci_device_write_status()
          • pci_strerror()
        • Capability Modules and APIs
          • Capability ID 0x10 (PCI Express)
          • Capability ID 0x5 (MSI)
          • Capability ID 0x11 (MSI-X)
        • Example
      • Persistent Publish/Subscribe Developer's Guide
        • QNX Neutrino PPS Service
          • Running PPS
        • Objects and Their Attributes
          • Object files
            • Special objects
            • Object and directory sizes
          • Change notification
          • Object syntax
          • Attribute syntax
        • Persistence
          • Persistent storage
          • Saving objects
          • Loading objects
        • Publishing
          • Creating, modifying, and deleting objects and attributes
          • Multiple publishers
        • Subscribing
          • Waiting for data on a file descriptor
          • Subscription modes
            • Full mode
            • Delta mode
          • Subscribing to multiple objects
            • Subscribe to all objects in a directory
            • Notification groups
              • Creating notification groups
              • Using notification groups
        • Options and Qualifiers
          • Pathname open options
            • The critical option
            • Filtering notifications
          • Object and attribute qualifiers
            • Nonpersistence qualifier
            • Item qualifier
          • Reading and writing from the command line
          • Access Control List configuration file
            • ACL configuration file format
        • Server Objects
          • Working with server objects
            • Sending messages through PPS server objects
              • Sending a message
              • Replying to a message
              • Supporting cancellation of requests
        • PPS Encoding and Decoding API
          • Encoding PPS data
          • Decoding PPS data
            • Handling unknown data
            • Dealing with errors
          • Other features of PPS
        • PPS API reference
          • pps_attrib_flags_t
          • pps_attrib_t
          • pps_decoder_cleanup()
          • pps_decoder_dump_tree()
          • pps_decoder_error_t
          • pps_decoder_flags()
          • pps_decoder_get_bool()
          • pps_decoder_get_double()
          • pps_decoder_get_int()
          • pps_decoder_get_int64()
          • pps_decoder_get_state()
          • pps_decoder_get_string()
          • pps_decoder_goto_index()
          • pps_decoder_initialize()
          • pps_decoder_is_integer()
          • pps_decoder_length()
          • pps_decoder_name()
          • pps_decoder_next()
          • pps_decoder_parse_json_str()
          • pps_decoder_parse_pps_str()
          • pps_decoder_pop()
          • pps_decoder_push()
          • pps_decoder_push_array()
          • pps_decoder_push_object()
          • pps_decoder_reset()
          • pps_decoder_set_position()
          • pps_decoder_set_state()
          • pps_decoder_state_t
          • pps_decoder_status()
          • pps_decoder_t
          • pps_decoder_type()
          • pps_encoder_add_bool()
          • pps_encoder_add_double()
          • pps_encoder_add_from_decoder()
          • pps_encoder_add_int()
          • pps_encoder_add_int64()
          • pps_encoder_add_json()
          • pps_encoder_add_null()
          • pps_encoder_add_string()
          • pps_encoder_buffer()
          • pps_encoder_cleanup()
          • pps_encoder_clear_option()
          • pps_encoder_delete_attribute()
          • pps_encoder_end_array()
          • pps_encoder_end_object()
          • pps_encoder_error_t
          • pps_encoder_initialize()
          • pps_encoder_length()
          • pps_encoder_reset()
          • pps_encoder_set_option()
          • pps_encoder_start_array()
          • pps_encoder_start_object()
          • pps_encoder_t
          • pps_node_type_t
          • pps_options_t
          • pps_status_t
          • ppsparse()
        • Examples
          • Publishers
          • Subscribers
      • Platform-independent Publish/Subscribe Developer's Guide
        • PiPS Overview
          • Integration with publish-subscribe middleware
          • Key concepts
        • PiPS Configuration
        • Writing PiPS applications
          • Accessing providers through PiPS
          • Enumerating a provider's root namespace
        • Writing an RTPS type plugin
          • Writing a type plugin from an existing IDL file
            • Generating the Fast RTPS type definition
            • Defining the classes for the PiPS type implementation
            • Writing the required instance class methods
            • Writing the required type implementation methods
            • Writing encoder and decoder routines
          • Writing a type plugin from a C structure
          • Linking and loading the type plugin
        • PiPS Client API
          • Definitions and constants in PiPS Client API
          • pips_data_t
          • pips_enable_debug()
          • pips_enable_trace()
          • pips_encoding_e
          • pips_entity_t
            • pips_entity
            • pips_entity_attach()
            • pips_entity_get_data()
            • pips_entity_get_provider()
            • pips_entity_parent()
            • pips_entity_path()
          • pips_event_handler_t
            • pips_event_type_e
            • pips_event_deleted_publisher_handler_t
            • pips_event_deleted_subscriber_handler_t
            • pips_event_new_data_handler_t
            • pips_event_new_publisher_handler_t
            • pips_event_new_subscriber_handler_t
            • pips_event_new_topic_handler_t
            • pips_event_register_handler()
            • pips_event_remove_all_handlers()
            • pips_event_remove_handler()
          • pips_group_t
            • pips_create_group()
            • pips_group_add_member()
            • pips_group_get_member_name()
            • pips_group_narrow()
            • pips_group_next_member()
            • pips_topic_is_group()
          • pips_group_member_t
            • pips_delete_group_member()
            • pips_group_member_get_data()
            • pips_group_member_set_data()
          • pips_guid_t
            • pips_guid_cmp()
            • pips_guid_copy()
            • pips_guid_format()
            • pips_guid_from_str()
            • pips_guid_is_defined()
            • pips_guid_tostring()
          • pips_guid_str_t
          • pips_multimap_t
            • pips_multimap_add_blob()
            • pips_multimap_add_boolean()
            • pips_multimap_add_json()
            • pips_multimap_add_number()
            • pips_multimap_add_string()
            • pips_multimap_clear()
            • pips_multimap_dup_string()
            • pips_multimap_get_item()
            • pips_multimap_item_t
            • pips_multimap_set_value()
            • pips_multimap_type_e
            • pips_multimap_value_t
          • pips_namespace_t
            • pips_namespace
            • pips_namespace_create_namespace()
            • pips_namespace_create_publication()
            • pips_namespace_create_topic()
            • pips_namespace_find_entity()
            • pips_namespace_find_topic()
            • pips_namespace_group_topics()
            • pips_namespace_narrow()
            • pips_namespace_next_child()
          • pips_provider_t
            • pips_get_provider()
            • pips_get_registered_providers()
            • pips_init_provider()
            • pips_load_provider()
            • pips_provider_find_entity()
            • pips_provider_find_namespace()
            • pips_provider_find_topic()
            • pips_provider_get_participant_name()
            • pips_provider_create_publication()
            • pips_provider_create_topic()
            • pips_provider_root()
            • pips_set_default_provider()
          • pips_publication_t
            • pips_delete_publication()
            • pips_publication
            • pips_publication_assert_flags()
            • pips_publication_attach_data()
            • pips_publication_get_data()
            • pips_publication_get_topic()
            • pips_publication_new_data_handler_t
            • pips_publication_read()
            • pips_publication_write()
          • pips_set_verbosity()
          • pips_topic_t
            • pips_create_topic()
            • pips_delete_topic()
            • pips_topic
            • pips_topic_create_publication()
            • pips_topic_dup_pps_name()
            • pips_topic_get_provider()
            • pips_topic_get_type()
            • pips_topic_narrow()
      • QDB Developer's Guide
        • Getting Started with QDB
          • Starting the QDB server
          • Loading QDB databases
          • Unloading QDB databases
          • PPS configuration path
          • Database configuration objects
          • Database storage files
          • Schema files
          • Summary of database files
        • QDB Command Line
          • Temporary storage filesystem
          • Database integrity testing
          • Sharing connections between clients
          • Shared caching
          • Database recovery
          • Busy timeout
          • Handling corrupt databases
        • QDB Client
          • Backing up and restoring databases
        • QDB Application Example
          • Connecting to a database
            • Using asynchronous mode
          • Executing an SQL statement
          • Getting the result of a query
          • Using a result
          • Disconnecting from the database
          • Sample program
        • Datatypes in QDB
          • Storage classes
          • Column affinity
            • How column affinity is determined
            • Column affinity example
          • Comparison expressions
            • Comparison example
          • Operators: Column affinities
          • Sorting, grouping and compound SELECT statements
          • Other affinity modes
          • Collation sequences: Use in comparison operations
            • Assigning collation sequences from SQL
            • Collation sequences: Examples
        • QDB Virtual Machine Opcodes
          • Instruction format and execution
          • Virtual machine features
          • Viewing programs generated by QDB
          • The opcodes
        • Writing User-Defined Functions
          • Scalar and aggregate functions
          • Collation routines
          • Loading user-defined functions
          • SQLite C/C++ API
            • sqlite3_result_*
            • sqlite3_value_*
            • sqlite3_user_data
        • QDB API Reference
          • qdb_backup()
          • qdb_binding_t
          • qdb_bkcancel()
          • qdb_cell()
          • qdb_cell_length()
          • qdb_cell_type()
          • qdb_collation()
          • qdb_collation_ext()
          • qdb_column_decltype()
          • qdb_column_index()
          • qdb_column_name()
          • qdb_columns()
          • qdb_connect()
          • qdb_data_source()
          • qdb_disconnect()
          • qdb_freeresult()
          • qdb_getdbsize()
          • qdb_getdbsize_bytes()
          • qdb_geterrcode()
          • qdb_geterrmsg()
          • qdb_getoption()
          • qdb_getresult()
          • qdb_getresultoption()
          • qdb_gettransstate()
          • qdb_interrupt()
          • qdb_last_insert_rowid()
          • qdb_logmemstats()
          • qdb_mprintf()
          • qdb_parameters()
          • qdb_printmsg()
          • qdb_query()
          • qdb_rowchanges()
          • qdb_rows()
          • qdb_setbusytimeout()
          • qdb_setoption()
          • qdb_snprintf()
          • qdb_statement()
          • qdb_stmt_decltypes()
          • qdb_stmt_exec()
          • qdb_stmt_free()
          • qdb_stmt_init()
          • qdb_vacuum()
          • qdb_vmprintf()
        • QDB SQL Reference
          • Row ID and Autoincrement
          • Comments
          • Expressions
          • Keywords
          • Statements
            • ALTER TABLE
            • ANALYZE
            • ATTACH DATABASE
            • CREATE INDEX
            • CREATE TABLE
            • CREATE TRIGGER
            • CREATE VIEW
            • DELETE
            • DETACH DATABASE
            • DROP INDEX
            • DROP TABLE
            • DROP TRIGGER
            • DROP VIEW
            • EXPLAIN
            • INSERT
            • ON CONFLICT
            • PRAGMA
            • REINDEX
            • REPLACE
            • SELECT
            • TRANSACTION
            • UPDATE
            • VACUUM
        • fileset Reference
      • QNX Helpers Developer's Guide
        • attr.h
          • GCC attribute macros
        • endian.h
          • Endian macros for headers and static initialization
          • Endian conversion convenience macros
        • error.h
          • Macros
            • QH_ABORT()
            • QH_ABORT_ON_ERRNO()
            • QH_RET_ERRNO()
            • QH_SET_ERRNO()
            • QH_RET_ERRNO_WEOK()
            • QH_RET_ON_ERRNO()
          • qh_abort_on_errno()
          • qh_sticky_error()
          • qh_sticky_error_last()
          • qh_strerror()
        • io.h
          • qh_close()
        • log.h
          • Setting up QNX helpers logging
          • Controlling QNX helpers logging
          • Macros
            • qh_log()
            • QH_LOG_CHECK()
            • QH_LOG_DEFAULT_CONTEXT_INIT()
            • qh_log_linetrace()
            • qh_log_loc()
            • qh_log_noloc()
          • Macro variables
            • All or no log destinations
            • Blocked destinations
            • Flags for converting destinations
            • Log message output
            • Log to stderr based on log level
            • Message destinations
            • Message with severity
            • QH_LOG_USER_CONTEXT_VAR
            • Severity level masks
            • User-reserved area
            • Verbosity levels
            • Version numbers
          • qh_log_check()
          • qh_log_context_create()
          • qh_log_context_destroy()
          • qh_log_context_normalize_name()
          • qh_log_context_t
          • qh_log_ex()
          • qh_log_get_destinations()
          • qh_log_get_destinations_by_name()
          • qh_log_get_verbosity()
          • qh_log_get_verbosity_by_name()
          • qh_log_info_t
          • qh_log_set_cl_mode()
          • qh_log_update_config()
          • qh_vlog_ex()
        • misc.h
          • QH_ARRAY_LENGTH
          • QH_UNUSED
        • qh.h
          • Using qh.h
          • Definitions in qh.h
        • size.h
          • Macros for printed number sizes
          • Macros
            • qh_sizeof_member()
            • qh_sizeof_utai_member()
        • string.h
          • Macros
            • QH_STR_EXPANDED_STRINGIFY
            • QH_STR_STRINGIFY
          • qh_malloc_sprintf()
          • qh_memclear()
          • qh_str()
          • qh_str_groupname_to_gid()
          • qh_str_to_bytes()
          • qh_str_to_int8()
          • qh_str_to_int16()
          • qh_str_to_int32()
          • qh_str_to_int64()
          • qh_str_to_mode()
          • qh_str_to_signal()
          • qh_str_to_uint8()
          • qh_str_to_uint16()
          • qh_str_to_uint32()
          • qh_str_to_uint64()
          • qh_str_username_to_uid()
          • qh_strcmp()
          • qh_strdup()
        • time.h
          • Sleep time and absolute time
          • Unit conversion definitions
          • qh_get_nstime()
          • qh_nssleep()
          • qh_poll_check_cb_ft
          • qh_poll_until()
      • SMMUMAN User's Guide
        • SMMUMAN Architecture
          • Isolation of DMA devices
          • SMMUMAN components
          • SMMUMAN in a QNX Hypervisor guest
        • smmuman
          • Installation
          • Starting and stopping smmuman
          • Configuring smmuman
            • Global options
            • Options for ARM SMMUs
            • Options for Renesas R-Car IPMMUs
            • Options for x86 IOMMUs (VT-ds)
          • Mapping DMA devices and memory regions through the API
          • Startup mappings
          • SMMUMAN in a QNX Hypervisor system
        • SMMUMAN Client API Reference
          • smmu_* data structures
          • Enumerated values and constants
          • smmu_device_add_generic()
          • smmu_device_add_mmio()
          • smmu_device_add_pci()
          • smmu_device_report_reserved()
          • smmu_fini()
          • smmu_init()
          • smmu_mapping_add()
          • smmu_obj_create()
          • smmu_obj_destroy()
          • smmu_safety()
          • smmu_xfer_notify()
          • smmu_xfer_status()
        • Example program
        • Terminology
      • System Analysis Toolkit (SAT) User's Guide
        • Introduction
          • What can the SAT do for you?
          • Components of the SAT
        • Events and the Kernel
          • Generating events: a typical scenario
            • Multithreaded example
            • Thread context-switch time
            • Restarting threads
          • Simple and combine events
          • Fast and wide modes
          • Classes and events
            • Communication class: _NTO_TRACE_COMM
            • Control class: _NTO_TRACE_CONTROL
            • Interrupt classes: _NTO_TRACE_INTENTER, _NTO_TRACE_INTEXIT,_NTO_TRACE_INT_HANDLER_ENTER, and _NTO_TRACE_INT_HANDLER_EXIT
            • Kernel-call classes: _NTO_TRACE_KERCALLENTER, _NTO_TRACE_KERCALLEXIT, and _NTO_TRACE_KERCALLINT
            • Process class: _NTO_TRACE_PROCESS
            • Security class: _NTO_TRACE_SEC
            • System class: _NTO_TRACE_SYSTEM
            • Thread class: _NTO_TRACE_THREAD
            • User class: _NTO_TRACE_USER
            • Virtual thread class: _NTO_TRACE_VTHREAD
        • Kernel Buffer Management
          • Ring buffer size
          • Full buffers and the high-water mark
          • Buffer overruns
        • Capturing Trace Data
          • Using tracelogger to control tracing
            • Managing trace buffers
            • tracelogger's modes of operation
            • Choosing between wide and fast modes
            • Filtering events
            • Specifying where to send the output
          • Using TraceEvent() to control tracing
            • Managing trace buffers
            • Modes of operation
            • Filtering events
            • Choosing between wide and fast modes
            • Inserting trace events
        • Filtering
          • The static rules filter
          • The dynamic rules filter
            • Setting up a dynamic rules filter
            • Event handler
            • Removing event handlers
          • The post-processing facility
        • Interpreting Trace Data
          • Using traceprinter and interpreting the output
          • Building your own parser
            • The traceparser library
            • Simple and combine events, event buffer slots, and the traceevent_t structure
            • Event interlacing
            • Timestamps
        • Tutorials: Controlling event tracing
          • The instrex.h header file
          • Gathering all events from all classes
          • Gathering all events from one class
          • Gathering five events from four classes
          • Gathering kernel calls
          • Event handling - simple
          • Inserting a user simple event
        • Sample Programs
          • Data-capture program
          • Parser
        • Current Trace Events and Data
          • Interpreting the table
          • Table of events
      • System Architecture
        • The Philosophy of the QNX Neutrino RTOS
          • An embeddable POSIX OS?
          • Product scaling
          • Why POSIX for embedded systems?
          • Why QNX Neutrino for embedded systems?
          • Microkernel architecture
            • The OS as a team of processes
            • A true kernel
            • System processes
          • Interprocess communication
            • QNX Neutrino as a message-passing operating system
          • Network distribution of kernels
            • Single-computer model
            • Flexible networking
        • The QNX Neutrino Microkernel
          • The implementation of the QNX Neutrino RTOS
            • POSIX realtime and thread extensions
          • System services
          • Threads and processes
            • Thread attributes
            • Thread life cycle
          • Thread scheduling
            • Scheduling priority
            • Scheduling policies
              • FIFO scheduling
              • Round-robin scheduling
              • Sporadic scheduling
              • Manipulating priority and scheduling policies
            • IPC issues
            • Thread complexity issues
          • Synchronization services
            • Mutexes: mutual exclusion locks
            • Condvars: condition variables
            • Barriers
            • Sleepon locks
            • Reader/writer locks
            • Safely sharing mutexes, barriers, and reader/writer locks between processes
            • Semaphores
            • Synchronization via scheduling policy
            • Synchronization via message passing
            • Synchronization via atomic operations
            • Synchronization services implementation
          • Clock and timer services
            • Tracking time
            • Timers
          • Interrupt handling
            • Interrupt latency
            • Scheduling latency
            • Nested interrupts
            • Interrupt calls
        • Interprocess Communication (IPC)
          • Synchronous message passing
          • Message copying
          • Simple messages
          • Channels and connections
          • Pulses
          • Priority inheritance and messages
            • Server boost
          • Message-passing API
          • Robust implementations with Send/Receive/Reply
          • Events
            • I/O notification
          • Signals
            • Special signals
            • Summary of signals
          • POSIX message queues
          • Shared memory
            • Shared memory with message passing
            • Creating a shared memory object
            • mmap()
          • Typed memory
          • Pipes and FIFOs
        • The Instrumented Microkernel
          • Instrumentation at a glance
          • Event control
            • Modes of emission
            • Ring buffer
          • Data interpretation
            • System analysis with the IDE
          • Proactive tracing
        • Multicore Processing
          • Asymmetric multiprocessing (AMP)
          • Symmetric multiprocessing (SMP)
            • Booting an x86 SMP system
            • How the SMP microkernel works
            • Critical sections
          • Bound multiprocessing (BMP)
            • A viable migration strategy
          • Choosing between AMP, SMP, and BMP
        • Process Manager
          • Process management
            • Process primitives
              • posix_spawn()
              • spawn()
              • fork()
              • exec*()
            • Process loading
          • Memory management
            • Locking memory
          • Pathname management
            • Resolving pathnames
            • Symbolic prefixes
              • Creating special device names
              • Relative pathnames
              • Network root
            • File descriptor namespace
              • Open control blocks
        • Dynamic Linking
          • How shared objects are used
            • Memory layout for a typical process
            • Runtime linker
            • Loading a shared library at runtime
            • Symbol name resolution
        • Resource Managers
          • How do client programs talk to resource managers?
            • Why write a resource manager?
            • The types of resource managers
              • Device resource managers
              • Filesystem resource managers
            • Communication via native IPC
          • Resource manager architecture
            • Message types
            • The resource manager shared library
              • Automatic default message handling
              • open(), dup(), and close()
              • Multiple thread handling
              • Dispatch functions
              • Combine messages
              • Second-level default message handling
          • Summary
        • Filesystems
          • Filesystems and pathname resolution
          • Filesystem classes
            • Filesystems as shared libraries
            • io-blk
              • Builtin RAM disk
              • Partitions
              • Buffer cache
            • Filesystem limitations
          • Image filesystem
          • RAM “filesystem”
          • Embedded transaction filesystem (ETFS)
          • Power-Safe filesystem
            • Problems with existing disk filesystems
            • Copy-on-write filesystem
            • Performance
            • Encryption
          • DOS Filesystem
          • FFS3 filesystem
          • NFS filesystem
          • CIFS filesystem
          • Linux Ext2 filesystem
          • Universal Disk Format (UDF) filesystem
          • Apple Macintosh HFS and HFS Plus
          • Windows NT filesystem
          • Inflator pass-through filesystem
          • QNX Trusted Disk
          • Filesystem events
        • PPS
          • Persistence
          • PPS objects
          • Publishing
          • Subscribing
        • Character I/O
          • Driver/io-char communication
          • Device control
          • Input modes
            • Raw input mode
            • Edited input mode
          • Device subsystem performance
          • Console devices
          • Serial devices
          • Pseudo terminal devices (ptys)
        • Networking Architecture
          • Network manager (io-pkt*)
          • Threading model
          • Protocol module
          • Driver module
        • Native Networking (Qnet)
          • QNX Neutrino distributed
          • Name resolution and lookup
            • File descriptor (connection ID)
            • Behind a simple open()
            • Global Name Service (GNS)
            • Network naming
              • Resolvers
          • Redundant Qnet: Quality of Service (QoS) and multiple paths
            • QoS policies
            • Specifying QoS policies
            • Symbolic links
          • Examples
        • TCP/IP Networking
          • Structure of the TCP/IP manager
          • Socket API
            • Database routines
          • Multiple stacks
          • IP filtering and NAT
          • NTP
          • Dynamic host configuration
            • AutoIP
          • PPP over Ethernet
          • /etc/autoconnect
        • High Availability
          • An OS for HA
            • Inherent HA
            • HA-specific modules
          • Custom hardware support
          • Client library
            • Recovery example
          • High Availability Manager
            • HAM and the Guardian
            • HAM hierarchy
              • Entities
              • Conditions
              • Actions
            • Publishing autonomously detected conditions
              • State transitions
              • Other conditions
            • Subscribing to autonomously published conditions
            • HAM as a “filesystem”
            • Multistage recovery
            • HAM API
        • Adaptive Partitioning
          • Why adaptive?
          • Benefits of adaptive partitioning
            • Engineering product performance
            • Dealing with design complexity
            • Providing security
            • Debugging
          • Adaptive partitioning thread scheduler
        • What is Real Time and Why Do I Need It?
        • Glossary
      • Technotes
        • Compiling OpenVPN for QNX Neutrino
        • IP Tunneling (Generic Routing Encapsulation)
        • PPPOE and Path MTU Discovery
        • Making Multiple Images
        • POSIX Message Queues: Two Implementations
        • Choosing the Correct MTD Routine for the Flash Filesystem
        • Reading a Shutdown Message
        • SPI (Serial Peripheral Interface) Framework
          • Hardware interface
            • Function table
            • Low-level module handle structure
            • init function
            • fini function
            • drvinfo function
            • devinfo function
            • setcfg function
            • xfer function
            • dma_xfer function
          • API library
            • spi_open()
            • spi_close()
            • spi_setcfg()
            • spi_getdevinfo()
            • spi_getdrvinfo()
            • spi_read()
            • spi_write()
            • spi_xchange()
            • spi_cmdread()
            • spi_dma_xchange()
            • spi_dma_xfer()
        • Fine-tuning your network drivers
        • Backtraces
          • API
          • Examples
            • Obtaining and printing a memory map
            • Backtracing a thread in another process
            • Backtracing another thread within the same process
            • Backtracing the current thread
            • Doing a BT_SELF backtrace in a signal handler
            • Backtracing a collection of threads
        • Reloadable Image Filesystems
          • Command-line options
          • Examples
          • Minidriver support
          • Performance measurements
          • Manually mounting an IFS
          • Sample script to combine IPL with boot image for the EDOSK7780
          • Commands to burn a new IPL/Boot image for the EDOSK7780
        • Customizing language sort orders for libqdb_cldr.so
          • Standard language sort order files
          • Sort order algorithm
            • Contractions and expansions
            • Locale data files
          • Adding a new sort order locale
          • Tailoring a sort order algorithm
      • User's Guide
        • Getting to Know the OS
          • QNX Neutrino compared with Unix
          • QNX Neutrino compared with Microsoft Windows
          • How QNX Neutrino is unique
            • Resource managers
        • Logging In, Logging Out, and Shutting Down
          • root or non-root?
          • Logging in
          • Once you've logged in
          • Logging out
          • Shutting down and rebooting
        • Managing User Accounts
          • What does a user account do?
            • User accounts vs user IDs: login, lookup, and permissions
            • What happens when you log in?
          • Account database
            • /etc/passwd
            • /etc/group
            • /etc/shadow
            • /etc/.pwlock
          • Managing your own account
            • Changing your password
            • Forgot your password?
          • Managing other accounts
            • Adding users
            • Removing accounts
            • Defining groups
              • Creating a new group
              • Modifying an existing group
          • Troubleshooting
        • Using the Command Line
          • Processing a command
          • Character-device drivers
            • Input modes
            • Terminal support
            • Telnet
            • The keyboard at a glance
            • Physical and virtual consoles
          • Shell
            • Editing the command line
            • Command and filename completion
            • Reserved words
            • Entering multiple commands
            • Aliases
            • Substitutions
            • Redirecting input and output
            • Pipes
            • Quoting special characters
            • History: recalling commands
            • Shell scripts
          • Utilities
            • Understanding command syntax
            • Displaying online usage messages
            • Executing commands on another node or tty
            • Priorities
          • Basic commands
          • Troubleshooting
        • Working with Files
          • Types of files
          • Filenames and pathnames
            • Absolute and relative pathnames
            • Dot and dot-dot directories
            • No drive letters
            • Pathnames that begin with a dot
            • Extensions
            • Pathname-space mapping
            • Filename rules
          • Where everything is stored
          • File ownership and permissions
            • Setuid and setgid
            • Sticky bit
            • Default file permissions
            • Access Control Lists (ACLs)
          • Filename extensions
          • Troubleshooting
        • Using Editors
          • Supported editors
          • Specifying the default editor
        • Configuring Your Environment
          • What happens when you log in?
          • Customizing your home
          • Configuring your shell
            • /etc/profile
            • $HOME/.profile
            • ksh's startup file
          • Environment variables
            • Setting PATH and LD_LIBRARY_PATH
          • Configuration strings
          • Setting the time zone
            • Examples
            • Programming with time zones
          • Terminal types
          • Troubleshooting
        • Writing Shell Scripts
          • Available shells
          • Running a shell script
          • The first line
            • Arguments to a ksh script
            • Arguments to a gawk script
            • Arguments to a perl script
          • Example of a Korn shell script
          • Efficiency
          • Caveat scriptor
        • Working with Filesystems
          • Setting up, starting, and stopping a block filesystem
          • Mounting and unmounting filesystems
          • Image filesystem
          • /dev/shmem RAM “filesystem”
          • Power-Safe filesystem
            • Links and inodes
            • Booting
            • Snapshots
          • DOS filesystem
          • Linux Ext2 filesystem
          • Flash filesystems
          • CIFS filesystem
          • NFS filesystem
          • Universal Disk Format (UDF) filesystem
          • Apple Macintosh HFS and HFS Plus
          • Windows NT filesystem
          • Inflator filesystem
          • Troubleshooting
        • Using Qnet for Transparent Distributed Processing
          • When should you use Qnet?
          • Conventions for naming nodes
          • Software components for Qnet networking
          • Starting Qnet
          • Checking out the neighborhood
            • Populating /net
          • Troubleshooting
            • Is Qnet running?
            • Are io-pkt* and the drivers running?
            • Is the network card functional?
            • How do I get diagnostic information?
            • Is the hostname unique?
            • Are the nodes in the same domain?
        • TCP/IP Networking
          • Overview of TCP/IP
          • Software components for TCP/IP networking
          • Running the Internet daemons
          • Running multiple instances of the TCP/IP stack
          • Dynamically assigned TCP/IP parameters
            • Using PPPoE
            • Using DHCP
            • Using AutoIP
          • Troubleshooting
            • Are io-pkt* and the drivers running?
            • What is the name server information?
            • How do I map hostnames to IP addresses?
            • How do I get the network status?
            • How do I make sure I'm connected to other hosts?
            • How do I display information about an interface controller?
        • Backing Up Data
          • Backup strategies
            • Choosing backup storage media and location
            • Choosing a backup format
            • Controlling your backup
        • Securing Your System
          • General OS security
            • Remote and local attacks
              • Remote exploits
              • Local exploits
            • Effects of attacks
            • Viruses
            • QNX Neutrino security in general
          • QNX Neutrino-specific security issues
            • Message passing
            • pdebug
            • qconn
            • Qnet
            • IPSec
          • Setting up a firewall
        • Fine-Tuning Your System
          • Getting the system's status
          • Improving performance
          • Fine-tuning USB storage devices
        • Understanding System Limits
          • Configurable limits
          • Filesystem limits
            • Querying filesystem limits
            • Power-Safe (fs-qnx6.so) filesystem
            • Linux Ext2 filesystem
            • DOS FAT12/16/32 filesystem
            • NFS3 filesystem
            • CIFS filesystem
            • Embedded (flash) filesystem
            • Embedded Transaction filesystem (ETFS)
            • UDF filesystem
            • Apple Macintosh HFS and HFS Plus
            • Windows NT filesystem
          • Other system limits
            • File descriptors
            • Synchronization primitives
            • TCP/IP limits
            • Shared memory
            • Message queues
            • Platform-specific limits
        • Technical Support
        • Glossary
        • Examples
          • Buildfile for an NFS-mounting target
          • Sample buildfile
          • .profile
          • .kshrc
          • PPP with CHAP authentication between two QNX Neutrino boxes
    • Audio & Graphics API
      • Audio Developer's Guide
        • Audio Architecture
          • QNX Sound Architecture
          • QSA with QNX Acoustics Management Platform
          • Cards and devices
          • Control device
            • Control events
          • Mixer devices
          • Pulse Code Modulation (PCM) devices
            • Data formats
            • PCM state machine
            • PCM software mixer
            • PCM input splitter
            • PCM plugin converters
            • PCM events
            • PCM thread priorities
        • Playing and Capturing Audio Data
          • Handling PCM devices
            • Opening your PCM device
            • Configuring the PCM device
            • Controlling voice conversion
            • Preparing the PCM subchannel
            • Closing the PCM subchannel
          • Playing audio data
            • Playback states
            • Sending data to the PCM subchannel
            • If the PCM subchannel stops during playback
            • Stopping the playback
            • Synchronizing with the PCM subchannel
          • Capturing audio data
            • Selecting what to capture
            • Capture states
            • Receiving data from the PCM subchannel
            • If the PCM subchannel stops during capture
            • Stopping the capture
            • Synchronizing with the PCM subchannel
        • Mixer Architecture
          • Opening the mixer device
          • Controlling a mixer group
          • The best mixer group with respect to your PCM subchannel
          • Finding all mixer groups
          • Mixer event notification
          • Closing the mixer device
        • Audio Concurrency Management
          • Understanding audio ducking
            • Understanding the mix policy when using multiple audio types with the same priority
            • Understanding how multiple ducking levels cumulate
          • Understanding volume ramping
            • Volume ramping example
          • Understanding preemption
          • Understanding audio type volume controls
          • Syntax of the audio policy configuration file
        • Optimizing Audio
        • Audio Library
          • snd_afm_close()
          • snd_afm_file_descriptor()
          • snd_afm_get_ap_data()
          • snd_afm_get_audio_mode()
          • snd_afm_get_param()
          • snd_afm_get_vin_list()
          • snd_afm_get_vin_list_count()
          • snd_afm_info()
          • snd_afm_info_t
          • snd_afm_load_ap_dataset()
          • snd_afm_open()
          • snd_afm_open_name()
          • snd_afm_set_ap_data()
          • snd_afm_set_audio_mode()
          • snd_afm_set_param()
          • snd_afm_set_vin_stream()
          • snd_afm_start()
          • snd_afm_status()
          • snd_afm_status_t
          • snd_afm_stop()
          • snd_card_get_longname()
          • snd_card_get_name()
          • snd_card_name()
          • snd_cards()
          • snd_cards_list()
          • snd_ctl_callbacks_t
          • snd_ctl_close()
          • snd_ctl_file_descriptor()
          • snd_ctl_ducking_read()
          • snd_ctl_ducking_status_read()
          • snd_ctl_get_filter()
          • snd_ctl_hw_info()
          • snd_ctl_hw_info_t
          • snd_ctl_mixer_switch_list()
          • snd_ctl_mixer_switch_read()
          • snd_ctl_mixer_switch_write()
          • snd_ctl_open()
          • snd_ctl_pcm_channel_info()
          • snd_ctl_pcm_info()
          • snd_ctl_read()
          • snd_ctl_set_filter()
          • snd_ducking_status_t
          • snd_ducking_type_status_t
          • snd_mixer_callbacks_t
          • snd_mixer_close()
          • snd_mixer_eid_t
          • snd_mixer_element_info()
          • snd_mixer_element_info_build()
          • snd_mixer_element_info_free()
          • snd_mixer_element_info_t
          • snd_mixer_element_read()
          • snd_mixer_element_t
          • snd_mixer_element_write()
          • snd_mixer_elements()
          • snd_mixer_elements_t
          • snd_mixer_element_volume1_range_t
          • snd_mixer_file_descriptor()
          • snd_mixer_filter_t
          • snd_mixer_get_bit()
          • snd_mixer_get_filter()
          • snd_mixer_gid_t
          • snd_mixer_group_read()
          • snd_mixer_group_t
          • snd_mixer_group_write()
          • snd_mixer_groups()
          • snd_mixer_groups_t
          • snd_mixer_info()
          • snd_mixer_info_t
          • snd_mixer_open()
          • snd_mixer_open_name()
          • snd_mixer_read()
          • snd_mixer_routes()
          • snd_mixer_routes_t
          • snd_mixer_set_bit()
          • snd_mixer_set_filter()
          • snd_mixer_sort_eid_table()
          • snd_mixer_sort_gid_table()
          • snd_mixer_weight_entry_t
          • snd_pcm_build_linear_format()
          • snd_pcm_capture_go()
          • snd_pcm_capture_pause()
          • snd_pcm_capture_prepare()
          • snd_pcm_capture_resume()
          • snd_pcm_channel_audio_ducking()
          • snd_pcm_channel_drain()
          • snd_pcm_channel_drop()
          • snd_pcm_channel_go()
          • snd_pcm_channel_info()
          • snd_pcm_channel_info_t
          • snd_pcm_channel_params()
          • snd_pcm_channel_params_t
          • snd_pcm_channel_pause()
          • snd_pcm_channel_prepare()
          • snd_pcm_channel_read_event()
          • snd_pcm_channel_resume()
          • snd_pcm_channel_setup()
          • snd_pcm_channel_setup_t
          • snd_pcm_channel_status()
          • snd_pcm_channel_status_t
          • snd_pcm_chmap_query_t
          • snd_pcm_chmap_t
          • snd_pcm_close()
          • snd_pcm_event_t
          • snd_pcm_file_descriptor()
          • snd_pcm_filter_t
          • snd_pcm_find()
          • snd_pcm_format_big_endian()
          • snd_pcm_format_linear()
          • snd_pcm_format_little_endian()
          • snd_pcm_format_signed()
          • snd_pcm_format_size()
          • snd_pcm_format_t
          • snd_pcm_format_unsigned()
          • snd_pcm_format_width()
          • snd_pcm_free_chmaps()
          • snd_pcm_get_apx_data()
          • snd_pcm_get_chmap()
          • snd_pcm_get_filter()
          • snd_pcm_get_format_name()
          • snd_pcm_info()
          • snd_pcm_info_t
          • snd_pcm_link()
          • snd_pcm_link_mode()
          • snd_pcm_link_transition ()
          • snd_pcm_load_apx_dataset()
          • snd_pcm_mute_event_t
          • snd_pcm_nonblock_mode()
          • snd_pcm_open()
          • snd_pcm_open_name()
          • snd_pcm_open_preferred()
          • snd_pcm_outputclass_event_t
          • snd_pcm_playback_go()
          • snd_pcm_playback_pause()
          • snd_pcm_playback_prepare()
          • snd_pcm_playback_resume()
          • snd_pcm_plugin_drain()
          • snd_pcm_plugin_drop()
          • snd_pcm_plugin_get_voice_conversion()
          • snd_pcm_plugin_info()
          • snd_pcm_plugin_params()
          • snd_pcm_plugin_prepare()
          • snd_pcm_plugin_reset_voice_conversion()
          • snd_pcm_plugin_read()
          • snd_pcm_plugin_set_disable()
          • snd_pcm_plugin_set_enable()
          • snd_pcm_plugin_set_src_method()
          • snd_pcm_plugin_set_src_mode()
          • snd_pcm_plugin_set_voice_conversion()
          • snd_pcm_plugin_setup()
          • snd_pcm_plugin_status()
          • snd_pcm_plugin_update_src()
          • snd_pcm_plugin_write()
          • snd_pcm_query_channel_map()
          • snd_pcm_query_chmaps()
          • snd_pcm_read()
          • snd_pcm_set_apx_data()
          • snd_pcm_set_apx_external_volume()
          • snd_pcm_set_apx_user_volume()
          • snd_pcm_set_chmap()
          • snd_pcm_set_filter()
          • snd_pcm_set_output_class()
          • snd_pcm_status_event_t
          • snd_pcm_t
          • snd_pcm_unlink()
          • snd_pcm_voice_conversion_t
          • snd_pcm_write()
          • snd_strerror()
          • snd_switch_t
        • afm_ctl.c example
        • apx_ctl.c example
        • wave.c example
        • waverec.c example
        • mix_ctl.c example
        • audiomgmt_monitor.c example
        • ALSA and libasound.so
        • Glossary
      • Gestures Library Reference
        • Gestures Library Overview
        • Gesture Recognition
        • User defined gestures
        • Gesture Tutorials
          • Tutorial: Create a gesture-handling application
            • Example: Code snippets of a gesture-handling application
          • Tutorial: Create a custom gesture
            • Example: Code snippets of a defining a custom gesture
        • Gestures Library Reference
          • Gesture Buckets (bucket.h)
            • Definitions in bucket.h
            • gestures_bucket_add()
            • gestures_bucket_clear()
            • gestures_bucket_count()
            • gestures_bucket_del()
            • gestures_bucket_get()
            • gestures_bucket_init()
            • gestures_bucket_t
          • Global Settings (defaults.h)
            • Definitions in defaults.h
          • Double Tap (double_tap.h)
            • double_tap_gesture_alloc()
            • double_tap_gesture_default_params()
            • double_tap_params_t
            • double_tap_state_e
            • gesture_double_tap_t
          • Event Lists (event_list.h)
            • event_list_add()
            • event_list_alloc()
            • event_list_alloc_copy()
            • event_list_clear()
            • event_list_copy()
            • event_list_free()
            • event_list_get_first()
            • event_list_item
            • event_list_item_t
          • Long Press (long_press.h)
            • gesture_long_press_t
            • long_press_gesture_alloc()
            • long_press_gesture_default_params()
            • long_press_params_t
          • Pinch Gestures (pinch.h)
            • gesture_pinch_t
            • pinch_gesture_alloc()
            • pinch_gesture_default_params()
            • pinch_params_t
          • Press and Tap (press_and_tap.h)
            • gesture_pt_t
            • pt_gesture_alloc()
            • pt_gesture_default_params()
            • pt_params_t
          • Rotate Gesture (rotate.h)
            • gesture_rotate_t
            • rotate_gesture_alloc()
            • rotate_gesture_default_params()
            • rotate_params_t
          • Gesture Sets (set.h)
            • gestures_set_add()
            • gestures_set_alloc()
            • gestures_set_fail_f
            • gestures_set_free()
            • gestures_set_process_event()
            • gestures_set_process_event_list()
            • gestures_set_register_fail_cb()
          • Swipe Gesture (swipe.h)
            • gesture_swipe_t
            • swipe_gesture_default_params()
            • swipe_params_t
          • Tap Gesture (tap.h)
            • gesture_tap_t
            • tap_gesture_alloc()
            • tap_gesture_default_params()
            • tap_params_t
          • Gesture Timers (timer.h)
            • gesture_timer_callback_t
            • gesture_timer_clear()
            • gesture_timer_create()
            • gesture_timer_destroy()
            • gesture_timer_query()
            • gesture_timer_set_event()
            • gesture_timer_set_ms()
            • gesture_timer_set_now()
          • Triple Tap (triple_tap.h)
            • gesture_triple_tap_t
            • triple_tap_gesture_alloc()
            • triple_tap_gesture_default_params()
            • triple_tap_params_t
            • triple_tap_state_e
          • Two Finger Pan (two_finger_pan.h)
            • gesture_tfpan_t
            • tfpan_gesture_alloc()
            • tfpan_gesture_default_params()
            • tfpan_params_t
          • Two Finger Tap (two_finger_tap.h)
            • gesture_tft_t
            • tft_gesture_alloc()
            • tft_gesture_default_params()
            • tft_params_t
          • Two Finger Double Tap (two_finger_double_tap.h)
            • gesture_two_finger_double_tap_t
            • two_finger_double_tap_gesture_alloc()
            • two_finger_double_tap_gesture_default_params()
            • two_finger_double_tap_params_t
            • two_finger_double_tap_state_e
          • Data Types and Helper Functions (types.h)
            • Definitions in types.h
            • diff_time_ms()
            • gesture_add_mustfail()
            • gesture_base
            • gesture_base_init()
            • gesture_base_t
            • gesture_callback_f
            • gesture_coords_t
            • gesture_e
            • gesture_funcs_t
            • gesture_state_e
            • map_contact_id()
            • max_displacement_abs()
            • save_coords()
      • Image Library Reference
        • Working with Images
          • Attaching to the image library
          • Load an image
          • Clean up resources
        • Image API
          • img_cfg_read()
          • img_codec_get_criteria()
          • img_codec_list()
          • img_codec_list_byext()
          • img_codec_list_bymime()
          • img_convert_data()
          • img_convert_getfunc()
          • img_crop()
          • img_decode_begin()
          • img_decode_callouts_t
          • img_decode_finish()
          • img_decode_frame()
          • img_decode_validate()
          • img_dtransform()
          • img_dtransform_apply()
          • img_dtransform_create()
          • img_dtransform_free()
          • img_encode_begin()
          • img_encode_callouts_t
          • img_encode_finish()
          • img_encode_frame()
          • img_expand_getfunc()
          • IMG_FMT_BPL()
          • IMG_FMT_BPP()
          • img_format_t
          • img_lib_attach()
          • img_lib_detach()
          • img_load()
          • img_load_file()
          • img_load_resize()
          • img_load_resize_file()
          • img_resize_fs()
          • img_rotate_ortho()
          • img_write()
          • img_write_file()
          • img_t
          • io_close()
          • io_open()
      • Input Events Library Reference
        • Writing a Touch Driver
          • Provide the callback functions
          • Connect to the Input Events library
          • Provide initialization and cleanup callback functions
          • Communicate with the hardware
          • Disconnect from the Input Events library
        • Input Events Library Overview
          • Event types (event_types.h)
            • contact_type_e
            • input_class_e
            • input_event_e
            • mtouch_event
            • mtouch_event_t
          • Driver (mtouch_driver.h)
            • Definitions in mtouch_driver.h
            • Driver test result types
            • mtouch_driver_attach()
            • mtouch_driver_detach()
            • mtouch_driver_funcs_t
            • mtouch_driver_process_packet()
            • mtouch_test_bist()
            • mtouch_test_fini()
            • mtouch_test_init()
            • mtouch_test_read_firmware_version()
            • mtouch_test_read_product_id()
            • mtouch_test_read_serial_id()
            • mtouch_test_read_supplier_id()
          • Log (mtouch_log.h)
            • Definitions in mtouch_log.h
            • mtouch_log()
          • Parameters (mtouch_params.h)
            • Definitions in mtouch_params.h
            • mtouch_client_params
            • mtouch_client_params_t
            • mtouch_driver_params
            • mtouch_driver_params_t
            • mtouch_filter_config
            • mtouch_filter_config_t
          • Parse options (parseopts.h)
            • input_parseopts()
            • input_parse_bool()
            • input_parse_double()
            • input_parse_signed()
            • input_parse_string()
            • input_parse_unsigned()
          • Screen helpers (screen_helpers.h)
            • screen_get_mtouch_event()
      • OpenWF Configuration Developer's Guide
        • Before you begin
        • Introduction to the Wfdcfg library
        • Getting the source code
        • Setting timing parameters
        • Updating Wfdcfg source (adding extensions)
        • Building the Wfdcfg library
        • Updating your target
        • Configuring Screen for your display
        • OpenWF Display Configuration Library Reference
          • Definitions in wfdcfg.h
          • WFDCFG_FNPTR()
          • wfdcfg_device
          • wfdcfg_device_create()
          • wfdcfg_device_destroy()
          • wfdcfg_device_get_extension()
          • wfdcfg_ext_fn_port_init1_t
          • wfdcfg_ext_fn_port_set_mode2_t
          • wfdcfg_ext_fn_port_uninit1_t
          • wfdcfg_ext_fn_set_power_mode_t
          • wfdcfg_flags
          • wfdcfg_keyval
          • wfdcfg_mode_get_extension()
          • wfdcfg_mode_list
          • wfdcfg_mode_list_create()
          • wfdcfg_mode_list_destroy()
          • wfdcfg_mode_list_get_next()
          • wfdcfg_port
          • wfdcfg_port_create()
          • wfdcfg_port_destroy()
          • wfdcfg_port_get_extension()
          • wfdcfg_power_mode
          • wfdcfg_timing
      • Screen Graphics Subsystem Developer's Guide
        • Application Development
          • Getting started
          • Function execution types
            • Apply execution
            • Delayed execution
            • Flushing execution
            • Immediate execution
        • Buffers
        • Rendering
          • Render Targets
          • Software Rendering
          • Hardware Rendering
            • OpenGL ES rendering APIs
            • Vulkan rendering APIs
            • Blitting
          • Hybrid Rendering
          • Font Rendering
        • Windowing
          • Window Groups
          • Window Geometry
            • Window types
            • Window properties
            • Window rotation
          • Window Management
          • Tutorials
            • Create a window
            • Create a child window
            • Zooming with windows
              • Displaying in fullscreen mode
              • Zooming in (from the window's parent)
              • Zooming in (from the owner of a window)
              • Zooming out (from a window's parent)
              • Zooming out (from the owner of a window)
              • Using a source clip rectangle
        • Resource Sharing
          • Cloning
            • Windows
            • Streams
            • Displays
            • Tutorial: Screenshots
              • Using screen_read_window()
              • Using screen_read_display()
          • Using Streams
            • Producer
            • Consumer
            • Multiple Consumers and Producers
            • External Composition
        • Displaying the contents of windows
          • Targeting your displays
          • Display Geometry
            • Display rotation
          • Composition
        • Input
          • Input Events
          • Windows
          • Sessions
            • Session properties
            • Keyboard sessions
            • Multitouch (touch) sessions
            • Pointer sessions
            • Joystick, gamepad, and jog sessions
        • Event Handling
        • Asynchronous Notifications
          • Tutorial: Using screen_notify()
        • Permissions and Privileges
        • Security policies
        • Utilities and binaries
          • calib-touch
          • drm-intel
          • drm-probe-displays
          • drm-vmwgfx
          • egl-configs
          • events
          • gles1-gears
          • gles1-vsync
          • gles2-gears
          • gles2-maze
          • gles2-teapot
          • gles3-gears
          • gltracelogger
          • gltraceprinter
          • mtouch
            • Calibrating touch
            • Scaling configuration file
            • Touch configuration file
            • Touch filters
          • screen-gles2-tools
          • screen
          • screencmd
          • screeninfo
          • screenshot
          • sharewin
          • sw-vsync
          • vcapture-demo
          • vg-tiger
          • vncserv
          • Vulkan utilities and binaries
            • vkcube
            • vk-fsray
            • vk-gears
            • vk-maze
            • vk-teapot
            • vulkaninfo
          • win-vsync
        • Debugging
          • At initialization
          • At runtime
        • Screen library reference
          • Function safety
          • Function types
          • General (screen.h)
            • Definitions in screen.h
            • Screen CBABC mode types
            • Screen alpha mode types
            • Screen color space types
            • Screen cursor shapes
            • Screen flushing types
            • Screen gesture types
            • Screen idle mode types
            • Screen mirror types
            • Screen mouse button types
            • Screen object types
            • Screen pixel format types
            • Screen power mode types
            • Screen property types
            • Screen rotation types
            • Screen scaling quality types
            • Screen scale types
            • Screen sensitivity masks
            • Screen sensitivity types
            • Screen status types
            • Screen touch types
            • Screen transparency types
            • Screen usage flag types
          • Platform-specific APIs (screen_ext.h)
            • Qualcomm Screen Pixel Format
          • Blits (screen.h)
            • Screen blit types
            • screen_blit()
            • screen_fill()
            • screen_flush_blits()
          • Buffers (screen.h)
            • Screen acquire buffer flags
            • screen_acquire_buffer()
            • screen_release_buffer()
            • screen_buffer_t
            • screen_create_buffer()
            • screen_destroy_buffer()
            • screen_get_buffer_property_cv()
            • screen_get_buffer_property_iv()
            • screen_get_buffer_property_llv()
            • screen_get_buffer_property_pv()
            • screen_set_buffer_property_cv()
            • screen_set_buffer_property_iv()
            • screen_set_buffer_property_llv()
            • screen_set_buffer_property_pv()
          • Contexts (screen.h)
            • screen_context_t
            • Screen context types
            • Screen notification types
            • screen_create_context()
            • screen_destroy_context()
            • screen_flush_context()
            • screen_get_context_property_cv()
            • screen_get_context_property_iv()
            • screen_get_context_property_llv()
            • screen_get_context_property_pv()
            • screen_notify()
            • screen_register_event()
            • screen_register_window_manager()
            • screen_set_context_property_cv()
            • screen_set_context_property_iv()
            • screen_set_context_property_llv()
            • screen_set_context_property_pv()
            • screen_unregister_event()
            • screen_unregister_window_manager()
          • Debugging (screen.h)
            • Screen debug graph types
          • Devices (screen.h)
            • Screen device metric counts
            • Screen device types
            • Screen game button types
            • Screen input mode types
            • screen_device_t
            • screen_create_device_type()
            • screen_destroy_device()
            • screen_get_device_property_cv()
            • screen_get_device_property_iv()
            • screen_get_device_property_llv()
            • screen_get_device_property_pv()
            • screen_set_device_property_cv()
            • screen_set_device_property_iv()
            • screen_set_device_property_llv()
            • screen_set_device_property_pv()
          • Displays (screen.h)
            • Screen display metric counts
            • Screen display mode types
            • Screen display technology types
            • Screen display types
            • screen_display_mode_t
            • screen_display_t
            • screen_get_display_modes()
            • screen_get_display_property_cv()
            • screen_get_display_property_iv()
            • screen_get_display_property_llv()
            • screen_get_display_property_pv()
            • screen_read_display()
            • screen_set_display_property_cv()
            • screen_set_display_property_iv()
            • screen_set_display_property_llv()
            • screen_set_display_property_pv()
            • screen_wait_vsync()
          • Events (screen.h)
            • Screen event flags
            • Screen event types
            • Screen input control events
            • screen_create_event()
            • screen_destroy_event()
            • screen_event_t
            • screen_get_event()
            • screen_get_event_property_cv()
            • screen_get_event_property_iv()
            • screen_get_event_property_llv()
            • screen_get_event_property_pv()
            • screen_inject_event()
            • screen_send_event()
            • screen_set_event_property_cv()
            • screen_set_event_property_iv()
            • screen_set_event_property_llv()
            • screen_set_event_property_pv()
          • Groups (screen.h)
            • screen_create_group()
            • screen_destroy_group()
            • screen_get_group_property_cv()
            • screen_get_group_property_iv()
            • screen_get_group_property_llv()
            • screen_get_group_property_pv()
            • screen_group_t
            • screen_set_group_property_cv()
            • screen_set_group_property_iv()
            • screen_set_group_property_llv()
            • screen_set_group_property_pv()
          • Pixmaps (screen.h)
            • Screen pixmap metric counts
            • screen_attach_pixmap_buffer()
            • screen_create_pixmap()
            • screen_create_pixmap_buffer()
            • screen_destroy_pixmap()
            • screen_destroy_pixmap_buffer()
            • screen_get_pixmap_property_cv()
            • screen_get_pixmap_property_iv()
            • screen_get_pixmap_property_llv()
            • screen_get_pixmap_property_pv()
            • screen_join_pixmap_group()
            • screen_leave_pixmap_group()
            • screen_pixmap_t
            • screen_ref_pixmap()
            • screen_set_pixmap_property_cv()
            • screen_set_pixmap_property_iv()
            • screen_set_pixmap_property_llv()
            • screen_set_pixmap_property_pv()
            • screen_unref_pixmap()
          • Sessions (screen.h)
            • Screen session metric counts
            • Screen input mode types
            • Screen session types
            • screen_create_session_type()
            • screen_destroy_session()
            • screen_get_session_property_cv()
            • screen_get_session_property_iv()
            • screen_get_session_property_llv()
            • screen_get_session_property_pv()
            • screen_session_t
            • screen_set_session_property_cv()
            • screen_set_session_property_iv()
            • screen_set_session_property_llv()
            • screen_set_session_property_pv()
          • Streams (screen.h)
            • Screen stream metric counts
            • Screen stream mode types
            • screen_attach_stream_buffers()
            • screen_consume_stream_buffers()
            • screen_create_stream()
            • screen_create_stream_buffers()
            • screen_dequeue_stream_render_buffer()
            • screen_destroy_stream()
            • screen_destroy_stream_buffers()
            • screen_get_stream_property_cv()
            • screen_get_stream_property_iv()
            • screen_get_stream_property_llv()
            • screen_get_stream_property_pv()
            • screen_post_stream()
            • screen_ref_stream()
            • screen_stream_t
            • screen_set_stream_property_cv()
            • screen_set_stream_property_iv()
            • screen_set_stream_property_llv()
            • screen_set_stream_property_pv()
            • screen_share_stream_buffers()
            • screen_unref_stream()
          • Windows (screen.h)
            • Screen window metric counts
            • Screen permission masks
            • Screen window types
            • screen_window_t
            • screen_attach_window_buffers()
            • screen_create_window()
            • screen_create_window_buffers()
            • screen_create_window_from_class()
            • screen_create_window_group()
            • screen_create_window_type()
            • screen_dequeue_window_render_buffer()
            • screen_destroy_window()
            • screen_destroy_window_buffers()
            • screen_discard_window_regions()
            • screen_get_window_property_cv()
            • screen_get_window_property_iv()
            • screen_get_window_property_llv()
            • screen_get_window_property_pv()
            • screen_join_window_group()
            • screen_leave_window_group()
            • screen_manage_window()
            • screen_post_window()
            • screen_read_window()
            • screen_ref_window()
            • screen_set_window_property_cv()
            • screen_set_window_property_iv()
            • screen_set_window_property_llv()
            • screen_set_window_property_pv()
            • screen_share_display_buffers()
            • screen_share_stream_buffers()
            • screen_share_window_buffers()
            • screen_unref_window()
            • screen_wait_post()
        • Configuring Screen
          • Configure khronos section
            • Configure egl display subsection
            • Configure wfd device subsection
          • Configure winmgr section
            • Configure globals subsection
            • Configure display subsection
            • Configure class subsection
          • Apply your Screen configuration
        • Glossary
      • Video Capture Developer's Guide
        • Using Video Capture
          • Header files and libraries
          • Implementing video capture
          • Sample video capture program
          • Properties applied to arrays
          • Contexts
          • Buffers
          • Platform-specific considerations
        • Video Capture API (capture.h)
          • Properties
            • Data bus, data lane, and clock
            • Debugging
            • Deinterlacing
              • Capture deinterlacing mode types
              • Definitions
            • Destination buffer
            • Driver and device
              • Capture no signal mode types
              • Definitions
            • External source
            • Interface, threads, and offsets
              • Capture interface type
              • Definitions
            • I2C decoder path and slave address
            • Polarity
            • Source
              • capture_color_space
              • Definitions
            • Video capture behavior
            • Video standards
            • Video frame
          • capture_context_t
          • capture_create_buffers()
          • capture_create_context()
          • capture_destroy_context()
          • capture_get_frame()
          • capture_get_free_buffer()
          • capture_get_property_i()
          • capture_get_property_p()
          • capture_is_property()
          • capture_put_buffer()
          • capture_release_frame()
          • capture_set_property_i()
          • capture_set_property_p()
          • capture_update()
          • Helper macros
    • Multimedia
      • Adding Multimedia to Target Images
        • Modifying Buildfiles to Generate Images with Multimedia
          • Script for launching multimedia services
          • OS image contents
        • Location of Multimedia Support Files on Target
          • Playback
          • Encoding and casting
      • Multimedia Renderer
        • Multimedia Renderer: Capabilities and Architecture
          • Playback model
          • Abstraction layers
        • Configuring and Starting mm-renderer
          • Configuration file for mm-renderer
          • Command line for mm-renderer
        • Playing and Recording Media Content
          • Using the service from client applications
          • Working with contexts
            • Closing context handles
          • Playing audio content
          • Playing video content
            • Managing video windows
            • Playing video with subtitles
          • Playing playlists
          • Playing autolists
          • Switching tracks within an input file
          • Recording audio content
          • Defining parameters
        • Multimedia Renderer API
          • Connection management
            • mmr_connect()
            • mmr_connection_t
            • mmr_disconnect()
            • mmr_plugin_info()
          • Context management
            • mmr_command_send()
            • mmr_context_close()
            • mmr_context_create()
            • mmr_context_destroy()
            • mmr_context_open()
            • mmr_context_parameters()
            • mmr_context_t
          • Error information
            • mm_error_code_t
            • mmr_error_info()
            • mmr_error_info_t
          • Events
            • mmr_event_arm()
            • mmr_event_data_set()
            • mmr_event_get()
            • mmr_event_t
              • data
              • details
            • mmr_event_type_t
            • mmr_event_wait()
            • mmr_metadata_split()
            • mmr_state_t
          • Input configuration
            • mmr_input_attach()
            • mmr_input_detach()
            • mmr_input_parameters()
            • mmr_track_parameters()
          • Output configuration
            • mmr_output_attach()
            • mmr_output_detach()
            • mmr_output_parameters()
          • Playback control
            • mmr_list_change()
            • mmr_play()
            • mmr_seek()
            • mmr_speed_set()
            • mmr_stop()
        • Dictionary Object API
          • strm_dict_t
          • strm_dict_clone()
          • strm_dict_compare()
          • strm_dict_destroy()
          • strm_dict_find_index()
          • strm_dict_find_rstr()
          • strm_dict_find_value()
          • strm_dict_index_delete()
          • strm_dict_key_delete()
          • strm_dict_key_get()
          • strm_dict_key_rstr()
          • strm_dict_new()
          • strm_dict_set()
          • strm_dict_set_index()
          • strm_dict_set_index_rstr()
          • strm_dict_set_rstr()
          • strm_dict_size()
          • strm_dict_subtract()
          • strm_dict_value_get()
          • strm_dict_value_rstr()
          • strm_string_t
          • strm_string_alloc()
          • strm_string_clone()
          • strm_string_destroy()
          • strm_string_get()
          • strm_string_make()
          • strm_string_modify()
      • Multimedia Streaming Server
        • Multimedia Streaming Server: Overview
          • Integration with other media services
          • Starting the mm-stream server
          • mm-stream-client utility
        • Configuring the mm-stream server
          • Configuration file examples
          • Configuration syntax
        • Multimedia Streaming Server API
          • mm-stream error codes
          • mmstream_connect()
          • mmstream_disable()
          • mmstream_disconnect()
          • mmstream_enable()
          • mmstream_get_configuration()
          • mmstream_get_status_information()
          • mmstream_instance_t
          • mmstream_set_configuration()
      • Multimedia Test Utilities
        • Role of the Multimedia Test Utilities
          • Using the test utilities
        • mmcli
          • Using mmcli instead of other components
          • mmcli command line
          • mmcli language
            • mmcli test scripts
            • mmcli interactive sessions
          • Using mmcli to play media files
        • mmrplay
          • Using mmrplay instead of mm-renderer
          • mmrplay command line
          • Playback examples
      • OpenMAX AL Additions
        • QNX OpenMAX-Compliant Media Engine
        • Decoding audio to a QNX buffer queue
        • QNX OpenMAX AL API
          • Buffer data types
            • Buffer constants
            • XADataLocator_QNXBufferQueue
            • XAQNXBuffer
            • XAQNXBufferInfo
            • XAQNXBufferItem
          • XAQNXBufferQueueSourceItf
            • XAQNXBufferQueueSourceItf constants
            • XAQNXBufferQueueSourceItf
              • Clear()
              • Enqueue()
              • GetCallbackEventsMask()
              • RegisterCallback()
              • SetBufferInfo()
              • SetCallbackEventsMask()
            • xaQNXBufferQueueSourceCallback
          • XAQNXVideoBufferQueueSourceItf
            • XAQNXVideoBufferQueueSourceItf constants
            • XAQNXVideoBufferQueueSourceItf
              • Clear()
              • Enqueue()
              • GetCallbackEventsMask()
              • RegisterCallback()
              • SetBufferInfo()
              • SetCallbackEventsMask()
            • xaQNXVideoBufferQueueSourceCallback
          • XAQNXBufferQueueSinkItf
            • XAQNXBufferQueueSinkItf constants
            • XADataFormat_QNXEncoded
              • XAAudioStreamInformation_QNX
              • XAVideoStreamInformation_QNX
            • XADataLocator_QNXScreenBufferQueue
            • XAQNXBufferQueueSinkItf
              • Done()
              • Get()
              • GetAndWait()
              • GetFormat()
          • Logging function controls
            • openmaxal_logger_cb
            • openmaxal_set_logger()
          • QNX configuration extensions
            • Audio decoding parameters
            • Audio encoding parameters
            • Network parameters
            • Screen-writer parameters
            • Subtitle parameters
            • Thread priority parameters
            • Video decoding parameters
            • Video encoding parameters
              • XAQ_VideoEncoderCropping
    • Networking Middleware
      • Networking Middleware Architecture Guide
        • Architecture
        • Deployment Model
      • Networking Middleware C API Reference
        • QNX SDP Networking Middleware C API
          • qwf_interface.h
            • qwf_Cleanup()
            • qwf_CleanupServices()
            • qwf_Context_t
            • qwf_Init()
            • qwf_InitializeCore()
            • qwf_InitializeServices()
            • qwf_ProcessEvents()
            • qwf_QueryActiveService()
            • qwf_ReturnStatus_e
            • qwf_Service_e
          • qwf_net.h
            • Network Manager service constants
            • qwf_net_Connect()
            • qwf_net_ConnectData_t
            • qwf_net_Disconnect()
            • qwf_net_Event_t
            • qwf_net_EventClientCallback_t
            • qwf_net_EventCode_e
            • qwf_net_GetAvailableInterfaces()
            • qwf_net_GetDefaultInterface()
            • qwf_net_GetInterfaceData()
            • qwf_net_GetPriorityList()
            • qwf_net_IfaceList_t
            • qwf_net_IfName_t
            • qwf_net_IfType_e
            • qwf_net_InterfaceData_t
            • qwf_net_IpAddrStr_t
            • qwf_net_IpConfigMethod_e
            • qwf_net_RegisterCallback()
            • qwf_net_Results_e
          • qwf_wifi.h
            • Wi-Fi Manager service constants
            • qwf_wifi_AccessPointModeState_e
            • qwf_wifi_ApClientData_t
            • qwf_wifi_ApModeStatusData_t
            • qwf_wifi_ApProfileData_t
            • qwf_wifi_BgScanInfo_t
            • qwf_wifi_BgScanMode_e
            • qwf_wifi_ConnectionStatus_e
            • qwf_wifi_ConnectSavedNetwork()
            • qwf_wifi_ConnectToAccessPoint()
            • qwf_wifi_CreateSavedNetwork()
            • qwf_wifi_DeleteSavedNetwork()
            • qwf_wifi_DisableSavedNetwork()
            • qwf_wifi_DisableWlanInterface()
            • qwf_wifi_Disconnect()
            • qwf_wifi_EapMethod_e
            • qwf_wifi_EnableSavedNetwork()
            • qwf_wifi_EnableWlanInterface()
            • qwf_wifi_Event_t
            • qwf_wifi_EventClientCallback_t
            • qwf_wifi_EventCode_e
            • qwf_wifi_FrequencyBand_e
            • qwf_wifi_GetAccessPointProfile()
            • qwf_wifi_GetApClients()
            • qwf_wifi_GetApStatus()
            • qwf_wifi_GetClientStatus()
            • qwf_wifi_GetConnectedSavedNetworkId()
            • qwf_wifi_GetConnectedSSID()
            • qwf_wifi_GetSavedNetworks()
            • qwf_wifi_GetScanResults()
            • qwf_wifi_InterfaceSetting_e
            • qwf_wifi_IpAddrStr_t
            • qwf_wifi_RegisterCallback()
            • qwf_wifi_Results_e
            • qwf_wifi_ResumeAccessPoint()
            • qwf_wifi_SavedNetwork_t
            • qwf_wifi_ScanResult_t
            • qwf_wifi_SecurityProtocol_e
            • qwf_wifi_SetBgScanMode()
            • qwf_wifi_SetEnterpriseCredentials()
            • qwf_wifi_SetHostapdOptions()
            • qwf_wifi_SetPassphrase()
            • qwf_wifi_SetWepKey()
            • qwf_wifi_Ssid_t
            • qwf_wifi_Standard_e
            • qwf_wifi_StartAccessPoint()
            • qwf_wifi_StartScan()
            • qwf_wifi_StationModeStatusData_t
            • qwf_wifi_StopAccessPoint()
            • qwf_wifi_UpdateAccessPoint()
            • qwf_wifi_UpdateSavedNetwork()
            • qwf_wifi_VhtOperChanWidth_e
            • qwf_wifi_WifiRole_e
        • Code Examples
          • Network Manager service
          • Wi-Fi Manager service
      • Networking Middleware Services Reference
        • Network Manager (net_pps)
        • Packet Filter Control
        • Tether Manager (tetherman)
        • Wi-Fi Configuration (wpa_pps)
        • Wi-Fi Protected Access (WPA) Supplicant
    • Programming
      • Getting Started with QNX Neutrino
        • Processes and Threads
          • Process and thread fundamentals
            • A process as a house
            • The occupants as threads
            • Back to processes and threads
            • Mutual exclusion
            • Priorities
            • Semaphores
            • A semaphore as a mutex
          • The kernel's role
            • Single CPU
            • Multiple CPU (SMP)
            • The kernel as arbiter
              • Prioritization
              • Scheduling policies
              • FIFO
              • Round Robin (RR)
              • The rules
            • Kernel states
              • Kernel states, the complete list
          • Threads and processes
            • Why processes?
            • Starting a process
              • Starting a process from the command line
              • Starting a process from within a program
                • Starting a process with the system() call
                • Starting a process with the exec() and spawn() calls
                • Starting a process with the fork() call
                • Using fork() in a multithreaded process
                • Starting a process with the posix_spawn() call
                • So what should you use?
            • Starting a thread
              • The thread attributes structure
                • Thread attribute administration
                • The “flags” thread attribute
                • The “stack” thread attributes
                • The “scheduling” thread attributes
              • A few examples
              • Where a thread is a good idea
              • Threads in mathematical operations
                • Coding for SMP or single processor
                • Synchronizing to the termination of a thread
                • Joining
                • Using a barrier
                • Multiple threads on a single CPU
                • Things to watch out for when using SMP
              • Threads in independent situations
                • Multiple processes
                • Multiple processes with shared memory
                • Multiple threads
                • Comparisons
          • More on synchronization
            • Readers/writer locks
            • Sleepon locks
            • Condition variables
              • Signal versus broadcast
              • Sleepons versus condition variables (condvars)
            • Additional OS services
            • Pools of threads
              • Controlling the number of threads
              • The thread pool functions
              • Error handling
              • Tuning a thread pool
            • An example of synchronization
          • Scheduling and the real world
            • Rescheduling: hardware interrupts
            • Rescheduling: kernel calls
            • Rescheduling: exceptions
            • Summary
        • Message Passing
          • A small microkernel and message passing
          • Message passing and client/server
          • Network-distributed message passing
          • What it means for you
          • Multiple threads
            • Server/subserver
            • Some examples
          • Using message passing
            • Architecture & structure
            • The client
              • Establishing a connection
              • Sending messages
            • The server
              • Creating the channel
              • Message handling
              • Server framework
            • Identifying messages
            • The send-hierarchy
            • Receive IDs, channels, and other parameters
              • More about channels
              • Who sent the message?
              • The receive ID (a.k.a. the client cookie)
              • Replying to the client
              • Not replying to the client
              • Replying with no data, or an errno
              • Finding the server's ND/PID/CHID
              • What about priorities?
              • Reading and writing data
            • Multipart messages
              • What about the other versions?
              • Implementation
          • Pulses
            • Receiving a pulse message
              • What's in a pulse?
              • The MsgReceivePulse() function
            • The MsgDeliverEvent() function
            • Channel flags
              • _NTO_CHF_UNBLOCK
                • Synchronization problem
                • Using the _NTO_MI_UNBLOCK_REQ
          • Message passing over a network
            • Networked message passing differences
            • Some notes on NDs
          • Priority inheritance
            • So what's the trick?
            • Summary
        • Clocks, Timers, and Getting a Kick Every So Often
          • Clocks and timers
            • Operating periodically
            • Clock interrupt sources
            • Base timing resolution
            • Timing jitter
            • Types of timers
            • Notification schemes
              • How to fill in the struct sigevent structure
              • Pulse notification
              • Signal notification
          • Using timers
            • Creating a timer
            • Signal, pulse, or thread?
            • What kind of timer?
            • A server with periodic pulses
              • Server-maintained timeouts
                • Declarations
                • main()
                • setupPulseAndTimer()
                • gotAPulse()
                • gotAMessage()
              • Notes
              • Periodic server maintenance cycles
            • Timers delivering signals
            • Timers creating threads
            • Getting and setting the realtime clock and more
          • Advanced topics
            • Other clock sources
              • CLOCK_MONOTONIC
              • So what does CLOCK_SOFTTIME do?
              • Using different clock sources
            • Kernel timeouts
              • Kernel timeouts with pthread_join()
              • Kernel timeouts with message passing
            • Summary
        • Interrupts
          • QNX Neutrino and interrupts
            • Interrupt service routine (ISR)
              • Clearing the interrupt source
              • Telling a thread to do something
            • Level-sensitivity versus edge-sensitivity
          • Writing interrupt handlers
            • Attaching an interrupt handler
            • Now that you've attached an interrupt
            • Detaching an interrupt handler
            • The flags parameter
            • The interrupt service routine
              • Using InterruptAttach()
              • Using InterruptAttachEvent()
              • InterruptAttach() versus InterruptAttachEvent()
              • The tradeoffs
            • ISR functions
          • Summary
        • Resource Managers
          • What is a resource manager?
            • Examples of resource managers
            • Characteristics of resource managers
          • The client's view
            • Finding the server
            • Finding the process manager
            • Handling directories
            • Unioned filesystems
            • Client summary
          • The resource manager's view
            • Registering a pathname
            • Handling messages
              • Connect messages
              • I/O messages
              • Three groups, really
          • The resource manager library
            • The library really does what we just talked about
            • Behind the scenes at the library
              • The base layer
              • The POSIX layer
          • Writing a resource manager
            • Data structures
              • resmgr_attr_t control structure
                • The other_func message handler
                • The data structure sizing parameters
                • The flags parameter
              • resmgr_connect_funcs_t connect table
              • resmgr_io_funcs_t I/O table
              • The resmgr_context_t internal context block
            • Resource manager structure
              • The resmgr_attach() function and its parameters
              • Putting in your own functions
              • The general flow of a resource manager
              • Messages that should be connect messages but aren't
              • Combine messages
            • POSIX-layer data structures
              • The iofunc_ocb_t OCB structure
              • The iofunc_attr_t attributes structure
              • The iofunc_mount_t mount structure
                • Of device numbers, inodes, and our friend rdev
          • Handler routines
            • General notes
              • Locking, unlocking, and combine message handling
            • Connect functions notes
              • Internal use part
              • End-user parameter part
          • Alphabetical listing of connect and I/O functions
            • Access control list I/O function handler
            • Change file mode I/O function handler
            • Change ownership I/O function handler
            • Change timestamps I/O function handler
            • Close duplicate OCB I/O function handler
            • Close OCB I/O function handler
            • Create file link connect function handler
            • Device control I/O function handler
            • Duplicate a file descriptor I/O function handler
            • File descriptor information I/O function handler
            • File locking I/O function handler
            • Flush data I/O function handler
            • Lock OCB I/O function handler
            • Make filesystem node connect function handler
            • Map memory I/O function handler
            • Mount connect function handler
            • Open connect function handler
            • Open file descriptor I/O function handler
            • pathconf I/O function handler
            • Power I/O function handler
            • Read I/O function handler
            • Read link connect function handler
            • Rename connect function handler
            • Register for notification I/O function handler
            • Resize file I/O function handler
            • Set file position I/O function handler
            • Shutdown I/O function handler
            • stat I/O function handler
            • Unblock connect function handler
            • Unblock I/O function handler
            • Unlink connect function handler
            • Unlock OCB I/O function handler
            • User-defined message I/O function handler
            • Write I/O function handler
          • Examples
            • The basic skeleton of a resource manager
            • A simple read I/O function handler example
              • The code
              • Effective use of other messaging functions
            • A simple write I/O function handler example
            • A simple device control I/O function handler example
          • Advanced topics
            • Extending the OCB
            • Locking in the resource manager
            • Extending the attributes structure
            • Blocking within the resource manager
            • Returning directory entries
              • Generally speaking...
              • The struct dirent structure and friends
                • Offsets
                • Contents
              • Example
                • main() and declarations
                • my_open()
                • my_read()
                • my_read_dir()
                • my_read_file()
                • dirent_size()
                • dirent_fill()
          • Summary
        • Sample Programs
          • atoz.c
          • time1.c
          • tp1.c
          • tt1.c
        • Glossary
      • Programmer's Guide
        • Compiling and Debugging
          • Choosing the version of the OS
          • Making your code more portable
            • Conforming to standards
            • Including OS-specific code
          • Cross-development
            • Cross-development with network filesystem
            • Cross-development with debugger
            • Cross-development, deeply embedded
          • Using libraries
          • Linking your modules
            • Creating shared objects
              • Specifying an internal name
          • Optimizing the runtime linker
            • Lazy binding
            • RTLD_LAZY
            • Lazy loading
            • Diagnostics and debugging
            • Environment variables
          • Debugging in a cross-development environment
            • The GNU debugger (gdb)
            • The process-level debug agent
              • Serial connection
              • TCP/IP connection
          • Auditing builds
          • A simple debug session
        • Programming Overview
          • An application as a set of processes
          • Some definitions
          • Priorities and scheduling
            • Priority range
            • BLOCKED and READY states
            • The ready queue
            • Rescheduling a running thread
          • Scheduling policies
            • FIFO scheduling
            • Round-robin scheduling
            • Sporadic scheduling
          • Why threads?
          • Talking to hardware
          • Summary
        • Processes
          • Starting processes: two methods
          • Process creation
            • Concurrency
            • Inheriting file descriptors
          • Process termination
          • Detecting process termination
            • Using the High Availability Framework
            • Detecting termination from a starter process
            • Sample parent process using wait()
            • Sample parent process using sigwaitinfo()
            • Detecting dumped processes
            • Detecting the termination of daemons or of all processes
            • Detecting client termination
          • Stack allocation
          • Process privileges
            • Privilege separation
              • Thread I/O privileges
            • Procmgr abilities
              • Ability domains
              • Ability ranges
              • Locking an ability
              • Dropping an ability
              • Ability inheritance
              • Creating abilities
            • An example of privilege separation
            • Resource constraint thresholds
          • Controlling processes via the /proc filesystem
            • Reading and writing the process's address space
            • Manipulating a process or thread
            • Thread information
            • DCMD_PROC_BREAK
            • DCMD_PROC_CHANNELS
            • DCMD_PROC_CLEAR_FLAG
            • DCMD_PROC_CURTHREAD
            • DCMD_PROC_EVENT
            • DCMD_PROC_GETALTREG
            • DCMD_PROC_GETFPREG
            • DCMD_PROC_GETGREG
            • DCMD_PROC_GETREGSET
            • DCMD_PROC_GET_BREAKLIST
            • DCMD_PROC_INFO
            • DCMD_PROC_IRQS
            • DCMD_PROC_MAPDEBUG
            • DCMD_PROC_MAPDEBUG_BASE
            • DCMD_PROC_MAPINFO
            • DCMD_PROC_PAGEDATA
            • DCMD_PROC_PTINFO
            • DCMD_PROC_RUN
            • DCMD_PROC_SETALTREG
            • DCMD_PROC_SETFPREG
            • DCMD_PROC_SETGREG
            • DCMD_PROC_SETREGSET
            • DCMD_PROC_SET_FLAG
            • DCMD_PROC_SIGNAL
            • DCMD_PROC_STATUS
            • DCMD_PROC_STOP
            • DCMD_PROC_SYSINFO
            • DCMD_PROC_THREADCTL
            • DCMD_PROC_TIDSTATUS
            • DCMD_PROC_TIMERS
            • DCMD_PROC_WAITSTOP
        • Multicore Processing
          • The impact of multicore
            • Thread affinity
            • Multicore and...
          • Designing with multiprocessing in mind
        • Working with Access Control Lists (ACLs)
          • ACL formats
          • ACL storage management
          • Manipulating ACL entries in working storage
          • Manipulating permissions in an ACL entry
          • Manipulating the tag type and qualifier in an ACL entry
          • Manipulating ACLs on a file or directory
          • Example
        • Understanding the Microkernel's Concept of Time
          • Short delays
          • Oversleeping: errors in delays
          • Another hiccup with hardware timers
          • What time is it?
          • Reducing the power consumption of clocks and timers
          • Tolerant and high-resolution timers
          • Monitoring execution times
        • Transparent Distributed Processing Using Qnet
          • Benefits of Qnet
          • How does it work?
          • Locating services using GNS
          • Quality of Service (QoS) and multiple paths
          • Designing a system using Qnet
          • Autodiscovery vs static
          • When should you use Qnet, TCP/IP, or NFS?
          • Drivers for Qnet
          • Low-level discussion of Qnet principles
          • Details of Qnet data communication
          • Node descriptors
          • Forcing retransmission
        • Writing an Interrupt Handler
          • Interrupts on multicore systems
            • Example of modifying the interrupt controller in a BSP when using InterruptAttach()
            • Example of using InterruptAttachEvent() to handle sigevents on a specific CPU
          • Attaching and detaching interrupts
          • Interrupt Service Routine (ISR)
            • Determining the source of the interrupt
            • Servicing the hardware
              • Safe functions
            • Updating common data structures
            • Notifying the application code
              • Using InterruptAttach()
              • Using InterruptAttachEvent()
          • Running out of interrupt events
          • Problems with shared interrupts
          • Advanced topics
            • Interrupt environment
            • Ordering of shared interrupts
            • Interrupt latency
            • Atomic operations
        • 32- and 64-Bit Architectures
          • Sizes of data types
          • Kernel calls and macros for sigvals
          • Large file support
          • sigevents
          • TimerInfo()
          • struct stat
          • Communicating with processes of different architectures
          • I/O messages
          • iofunc support for ns-resolution timestamps
          • DCMD_PROC_* and the /proc filesystem
          • Trace events
          • Other tips for programming
        • Working with Memory
          • Memory objects
          • Memory management in QNX Neutrino
          • Dynamic memory management
          • Typed memory
            • Using mmap() to allocate from typed memory objects
            • Direct allocation from typed memory
            • Interaction with other POSIX APIs
            • Practical examples
          • Shared Memory
            • Sharing memory through the direct mapping of physical addresses
            • Secure buffer management
            • Anonymous shared objects
            • Shared memory handles
            • Sealing a shared memory object
            • Revoking access to a shared memory object
            • Putting it all together: using handles with anonymous, revocable, and sealed shared memory objects
            • Getting information about the layout of a shared memory object
          • Heap analysis
            • Heap corruption
            • Detecting and reporting errors
              • Using the librcheck library
              • Configuring librcheck for Memory Analysis
              • Controlling the level of checking
              • Forcing verification
              • Specifying an error handler
              • Caveats
            • Manual checking (bounds checking)
            • Memory leaks
            • C++ issues
        • Power Management
        • Freedom from Hardware and Platform Dependencies
          • Common problems
            • I/O space vs memory-mapped
            • Big-endian vs little-endian
            • Alignment and structure packing
            • Atomic operations
          • Solutions
            • Determining endianness
            • Swapping data if required
            • Accessing unaligned data
            • Examples
              • Mixed-endian accesses
              • Accessing hardware with dual-ported memory
            • Accessing I/O ports
        • Conventions for Recursive Makefiles and Directories
          • Structure of a multiplatform source tree
            • Makefile structure
            • The recurse.mk file
            • Macros
              • The EARLY_DIRS and LATE_DIRS macros
              • The LIST macro
              • The MAKEFILE macro
              • The CHECKFORCE macro
            • Directory levels
              • Project level
              • Section level (optional)
              • OS level
              • CPU level
              • Variant level
          • Specifying options
            • The common.mk file
            • The variant-level makefile
            • Recognized variant names
          • Using the standard macros and include files
            • The qconfig.mk include file
              • Preset macros
              • Postset macros
              • qconfig.mk macros
            • The qrules.mk include file
            • The qtargets.mk include file
          • Advanced topics
            • Collapsing unnecessary directory levels
            • Performing partial builds
            • Performing parallel builds
            • More uses for LIST
            • GNU configure
              • hook_preconfigure()
              • hook_postconfigure()
              • hook_premake()
              • hook_postmake()
              • hook_pinfo()
          • Examples of creating Makefiles
            • A single application
            • A library and an application
        • Glossary
      • The QNX Neutrino Cookbook: Recipes for Programmers
        • The Basics
          • In the beginning...
            • The main() function
            • Command-line processing — optproc()
            • Common globals
            • Usage messages
          • Threaded resource managers
        • High Availability
          • Terminology
          • Lies, damn lies, and statistics
          • Increasing availability
            • Increasing the MTBF
            • Decreasing the MTTR
            • Parallel versus serial
              • Series calculations
              • Parallel calculations
              • Aggregate calculations
          • Failure modes and recovery models
            • Cascade failures
              • System startup and HA
            • Overlords, or Big Brother is watching you
            • Cold, warm, and hot standby
              • Achieving cold standby
              • Achieving warm standby
              • Achieving hot standby
              • Problems
            • Detecting failure
              • Obituaries
            • Graceful fail-over
            • Using shadows
            • In-service upgrades
            • Policies
          • Implementing HA
          • RK drones on about his home systems again
          • Other HA systems
        • Design Philosophy
          • Decoupling design in a message-passing environment
            • Door-lock actuators
            • At this point...
          • Managing message flow
            • Swipe-card readers
              • Control program sends to the swipe-card reader
              • Swipe-card reader sends to control program
              • Using a keypad challenge — control program sends to the swipe-card reader
              • Using a keypad challenge — swipe-card reader sends to control program
          • Scalability
            • Distributed processing
          • Summary
        • Web Counter Resource Manager
          • Requirements
            • Using the web counter resource manager
          • Design
            • Generating the graphical image
          • The code — phase 1
            • Operation
              • Generating the graphical image
            • Step-by-step code walkthrough
              • Include files and data structures
              • Source files
              • The code
                • The execute_resmgr() function
                • The io_open() function
                • The io_read() function
                • The io_close_ocb() function
                • The render_7segment() function
                • The encode_image() function
          • The code — phase 2
            • Persistent count file
            • Font selection
            • Plain text rendering
            • Writing to the resource
              • Adding the io_write() handler
              • The io_write() function
              • The io_close_ocb() function
          • The code — phase 3
            • Filename processing tricks
            • Changes
              • Globals
              • The new-and-improved execute_resmgr()
              • Option processing
              • Handling io_read()
                • Operating on a file
                • Operating on a directory
                • The persistent counter file
          • Enhancements
          • References
        • ADIOS — Analog/Digital I/O Server
          • Requirements
          • Design
            • Driver Design
              • DIO-144
              • ISO-813
              • PCL-711
            • Shared Memory Design
            • Tags database design
          • The Driver Code
            • Theory of operation
            • Code walkthrough
              • main() and friends
              • The resource manager modules
              • The card interface modules
                • Card configuration
                • Analog input
                • Analog output
                • Digital input
                • Digital output
          • The ADIOS server code
            • The usual stuff
            • The shared memory region
              • Calculating the sizes of data structures
              • Open and check the shared memory
              • Truncate and map shared memory
            • Acquiring data
          • The showsamp and tag utilities
            • The showsamp utility
            • The tag utility
          • References
        • RAM-disk Filesystem
          • Requirements
            • Connect functions
            • I/O functions
            • Missing functions
          • Design
          • The code
            • The extended attributes structure
            • The io_read() function
            • The io_write() function
            • The c_open() function
              • Finding the target
                • The pathwalk() function
                • The connect_msg_to_attr() function
              • Fun with symlinks
              • Analyze the mode flag
              • Bind the OCB and attributes structure
              • Finally, the c_open() code walkthrough
              • Walkthrough
              • The redirect_symlink() function
            • The c_readlink() function
            • The c_link() function
            • The c_rename() function
            • The c_mknod() function
            • The c_unlink() function
            • The io_close_ocb() function
            • The io_devctl() function
              • Mounting options
              • Filesystem statistics
            • The c_mount() function
          • References
        • TAR Filesystem
          • Requirements
          • Design
            • Creating a .tar file
          • The code
            • The structures
            • The functions
              • The c_mount() function
              • The analyze_tar_file() function
              • The add_tar_entry() function
              • The io_read() function and related utilities
            • The mount helper program
          • Variations on a theme
            • Virtual filesystem for USENET news (VFNews)
              • How does USENET news work?
              • So why is this a problem?
              • How can this possibly be made better?
              • Operation
            • Strange and unusual filesystems
              • Indexed filesystem
              • Executing commands
            • Secure filesystem
            • Line-based filesystem
          • References
        • Filesystems
          • What is a filesystem?
            • Hierarchical arrangement
            • Data elements
            • The mount point and the root
          • What does a filesystem do?
          • Filesystems and QNX Neutrino
          • How does a filesystem work?
            • Mount point management
              • Unnamed mount registration
              • Special device registration
              • Mount point registration
            • Pathname resolution
            • Directory management
            • Data element content management
          • References
        • The /proc Filesystem
          • The /proc/boot directory
          • The /proc/mount directory
          • The /proc by-process-ID directories
            • Operations on the as entry
              • Discontiguous address space
              • Someone else's virtual address space
            • Finding a particular process
              • Iterating through the list of processes
            • Finding out information about the process
            • DCMD_PROC_INFO
              • Process information
              • Memory information
              • Signal information
              • CPU usage information
              • Miscellaneous
            • DCMD_PROC_MAPINFO and DCMD_PROC_PAGEDATA
            • DCMD_PROC_TIMERS
            • DCMD_PROC_IRQS
            • Finding out information about the threads
              • The DCMD_PROC_TIDSTATUS command
              • Blocked thread information
              • The DCMD_PROC_GETGREG and DCMD_PROC_GETFPREG commands
          • References
        • Sample Programs
          • Web-Counter resource manager
          • ADIOS — Analog / Digital I/O Server
          • RAM-disk and tar filesystem managers
          • The /proc filesystem
        • Glossary
      • Writing a Resource Manager
        • What Is a Resource Manager?
          • Why write a resource manager?
          • The types of resource managers
          • Communication via native IPC
          • Examples of resource managers
            • Transparent Distributed Processing (Qnet) statistics
            • Robot arm
            • GPS devices
            • Database example
            • I2C (Inter-Integrated Circuit) driver
          • When not to use a resource manager
        • The Bones of a Resource Manager
          • Under the covers
            • Under the client's covers
            • Under the resource manager's covers
          • Layers in a resource manager
          • Simple examples of device resource managers
            • Single-threaded device resource manager
              • Initialize the dispatch interface
              • Initialize the resource manager attributes
              • Initialize functions used to handle messages
              • Initialize the attribute structure used by the device
              • Put a name into the namespace
              • Allocate the context structure
              • Start the resource manager message loop
            • Multithreaded device resource manager
              • Define THREAD_POOL_PARAM_T
              • Initialize thread pool attributes
              • Allocate a thread pool handle
              • Start the threads
        • Fleshing Out the Skeleton
          • Message types
            • Connect messages
            • I/O messages
            • Default message handling
            • open(), dup(), and close()
          • Setting resource manager attributes
          • Ways of adding functionality to the resource manager
            • Using the default functions
            • Using the helper functions
            • Writing the entire function yourself
          • Security
        • POSIX-Layer Data Structures
          • Extending the OCB and attribute structures
          • Extending the mount structure
        • Handling Read and Write Messages
          • Handling the _IO_READ message
            • Sample code for handling _IO_READ messages
          • Handling the _IO_WRITE message
            • Sample code for handling _IO_WRITE messages
          • Methods of returning and replying
          • Handling other read/write details
            • Handling the xtype member
              • If you aren't expecting extended types (xtype)
            • Handling pread*() and pwrite*()
              • Sample code for handling _IO_READ messages in pread*()
              • Sample code for handling _IO_WRITE messages in pwrite*()
            • Handling readcond()
          • Updating the time for reads and writes
        • Resource Managers that Handle Multiple Devices
        • Combine Messages
          • Where combine messages are used
          • The library's combine-message handling
            • Component responses
            • Component data access
            • Locking and unlocking the attribute structure
            • Connect message types
        • Using the Receive Buffer as a Reply Buffer
        • Handling Other Messages
          • Custom messages
          • Handling devctl() messages
            • Sample code for handling _IO_DEVCTL messages
          • Handling ionotify(), poll(), and select()
            • Sample code for handling _IO_NOTIFY messages
          • Handling out-of-band (_IO_MSG) messages
          • Handling private messages and pulses
          • Handling open(), dup(), and close() messages
          • Handling mount()
            • mount() function call
            • Mount in the resource manager
            • mount utility
          • Handling stat()
          • Handling lseek()
          • Handling mmap() messages
        • Unblocking Clients and Handling Interrupts
          • Handling client unblocking due to signals or timeouts
          • Unblocking if someone closes a file descriptor
          • Handling interrupts
            • Sample code for handling interrupts
        • Multithreaded Resource Managers
          • Multithreaded resource manager example
          • Thread pool attributes
          • Thread pool functions
        • Filesystem Resource Managers
          • Considerations for filesystem resource managers
          • The _IO_OPEN message for filesystems
          • Returning directory entries from _IO_READ
            • Returning information associated with a directory structure
        • Glossary
    • Sensor Framework
      • Architecture
        • Sensor Framework Architecture
        • Supported Platforms
        • Applications
      • Getting Started
        • Getting Started with the Sensor Framework for QNX SDP
          • Packaging in this release
          • Feature availability by hardware platform
        • Understanding Reference Images
          • Working with reference images
            • Mounting additional filesystems on a target system
          • Reference images available
          • Reference image sensor support
          • Reference image vision-processing support
        • Getting Started with the NXP iMX8QM-MEK Image
          • About the Sensor Framework for QNX SDP
            • Supported hardware configurations
            • Supported vision algorithms
          • Install and Boot the Reference Image
            • Get the reference image
            • Prepare an SD card with an image
            • Configure the hardware and boot the reference image
          • Use the Reference Image
            • Connect to the reference image
            • Run sample applications
              • ADAS example
              • Camera example
              • Camera MUX
              • Sensor example
            • Connect cameras and sensors
            • Configure cameras and sensors on the reference image
            • Modify the system to run a custom application
          • Troubleshoot Common Issues
        • Getting Started with the Renesas R-Car V3H Videobox miniPLUS Image
          • About the Sensor Framework for QNX SDP
            • Supported hardware configurations
          • Install and Boot a Reference Image
            • Get a reference image
            • Configure the hardware and boot a reference image
          • Use the Reference Image
            • Connect to the reference image
            • Run sample applications
              • ADAS example
              • Camera example
              • Camera MUX
              • Sensor example
            • Connect cameras and sensors
            • Configure cameras and sensors on the reference image
            • Modify the system to run a custom application
          • Troubleshoot Common Issues
        • Getting Started with the VMware Image
          • About the Sensor Framework for QNX SDP
            • Supported hardware configurations
          • Install and Boot the Reference Image
            • Get the reference image
            • Configure the software and boot the reference image
          • Use the Reference Image
            • Connect to the reference image
            • Run sample applications
              • ADAS example
              • Camera example
              • Camera MUX
              • Sensor example
            • Connect cameras and sensors
            • Configure cameras and sensors on the reference image
          • Troubleshoot Common Issues
      • Sensor Framework Libraries
        • ADAS Library Developer's Guide
          • ADAS Library Overview
          • Configuring the ADAS Library
            • Algorithms
            • Camera Layout
            • Display
            • Inputs
            • Overlay Layout
            • Viewer
            • Viewer Sequence
          • Using Custom Algorithms
          • Using Viewer Plugins
          • ADAS Library Reference
            • adas_api.h
              • adas_algorithm_t
              • adas_configure_viewer()
              • adas_destroy()
              • adas_error_t
              • adas_get_num_viewers()
              • adas_get_supported_views()
              • adas_get_viewer_configuration()
              • adas_get_viewer_info()
              • adas_initialize()
              • adas_record_start()
              • adas_record_stop()
              • adas_set_viewer_visibility()
              • adas_start_viewer_sequence()
              • adas_stop_viewer_sequence()
              • adas_view_t
              • adas_viewer_info_t
              • adas_viewer_type_t
            • adas_defs.h
              • adas_chained_rotations_3d_t
              • adas_coordinates_range_t
              • adas_cube_t
              • adas_dimensions_3d_t
              • adas_dimensions_t
              • adas_pixel_buffer
              • adas_pixel_buffer_handle_t
              • adas_pixel_buffer_type_internal_t
              • adas_pixel_format_t
              • adas_position_3d_t
              • adas_position_t
              • adas_rect_t
              • adas_rgba_color_t
              • adas_space_t
              • adas_vertex_coords_t
            • adas_external_algo.h
              • adas_algo_scaling_factor()
              • adas_ext_algorithm_t
              • adas_fusion_create_buffer_from_tracking()
              • adas_profile_init()
              • adas_profile_print()
            • adas_fusion_defs.h
              • Definitions in adas_fusion_defs.h
              • adas_fusion_algo_close_t
              • adas_fusion_algo_handle_t
              • adas_fusion_algo_open_t
              • adas_fusion_algo_preferences_t
              • adas_fusion_algo_probe_t
              • adas_fusion_algo_process_sensor_buffer_t
              • adas_fusion_buffer_t
              • adas_fusion_buffer_type_t
              • adas_fusion_distance_flag_t
              • adas_fusion_metrics_flag_t
              • adas_fusion_object_data_t
              • adas_fusion_object_type_t
            • adas_log.h
              • ADAS_ERROR()
              • adas_log_print()
              • ADAS_PRINT()
              • adas_strerror()
            • adas_opencv.h
              • adas_opencv_create_mat_from_pixel_buffer()
              • adas_opencv_generate_fusion_tracks_from_rect()
              • adas_opencv_generate_rect_from_fusion_tracks()
              • adas_opencv_get_conversion_format()
            • adas_sensor_defs.h
              • adas_focal_properties_t
              • adas_fov_properties_t
              • adas_sensor_buffer_t
              • adas_sensor_buffer_type_t
              • adas_sensor_orientation_t
              • adas_sensor_properties_t
              • adas_sensor_source_t
              • adas_sensor_type_t
            • adas_viewer_plugin.h
              • adas_viewer_plugin_deinit_t
              • adas_viewer_plugin_init_t
              • adas_viewer_plugin_process_t
              • adas_viewer_plugin_program_t
              • adas_viewer_plugin_t
              • adas_viewer_plugin_view_type_t
        • Camera Developer's Guide
          • Camera Library Overview
          • Viewfinder Mode
          • Settings on the Camera
          • Image Buffer Access
            • Using callback mode
            • Using event mode
            • Using stream mode
          • Resource Management
          • External Camera Drivers
          • Show a Video Stream from a Camera
            • Connect to the camera
            • Set the viewfinder mode for the camera
            • Connect Screen with the Camera API
            • Start the viewfinder and configure camera settings
            • Use Screen to show the viewfinder window
            • Stop the viewfinder
            • Record video
              • Understanding the camera roll
              • Synchronized recording of video from multiple cameras
            • Use streams
            • Encode video from a camera
          • Camera Library Reference
            • camera_api.h
              • Definitions in camera_api.h
              • Camera access mode flags
              • camera_analog_video_standard_t
              • camera_audiocodec_t
              • camera_add_video_group_entry()
              • camera_bayerformat_t
              • camera_bayerjustify_t
              • camera_buffer_t
              • camera_can_feature()
              • camera_close()
              • camera_create_video_group()
              • camera_deregister_resource()
              • camera_destroy_video_group()
              • camera_devstatus_t
              • camera_disable_event()
              • camera_enable_status_event()
              • camera_enable_video_event()
              • camera_enable_viewfinder_event()
              • camera_error_t
              • camera_eventkey_t
              • camera_eventmode_t
              • camera_exposuremode_t
              • camera_feature_t
              • camera_find_capable()
              • camera_focusmode_t
              • camera_force_video_keyframe()
              • camera_framedesc_t
              • camera_frametype_t
              • camera_frame_bayer_t
              • camera_frame_cbycry_t
              • camera_frame_crycby_t
              • camera_frame_compressedaudio_t
              • camera_frame_compressedvideo_t
              • camera_frame_gray8_t
              • camera_frame_meta_t
              • camera_frame_nv12_t
              • camera_frame_rgb565_t
              • camera_frame_rgb888_t
              • camera_frame_rgb8888_t
              • camera_frame_roi_t
              • camera_frame_unspecified_t
              • camera_frame_ycbcr420p_t
              • camera_frame_ycbycr_t
              • camera_frame_ycrycb_t
              • camera_get_analog_video_standard()
              • camera_get_api_version()
              • camera_get_brightness()
              • camera_get_capture_property()
              • camera_get_contrast()
              • camera_get_filename()
              • camera_get_hue()
              • camera_get_location_property()
              • camera_get_physical_property()
              • camera_get_saturation()
              • camera_get_screen_buffer()
              • camera_get_sharpness()
              • camera_get_specified_vf_framerates()
              • camera_get_specified_vf_resolutions()
              • camera_get_status_details()
              • camera_get_supported_brightness()
              • camera_get_supported_cameras()
              • camera_get_supported_contrast()
              • camera_get_supported_hue()
              • camera_get_supported_saturation()
              • camera_get_supported_sharpness()
              • camera_get_supported_vf_frame_types()
              • camera_get_supported_vf_framerates()
              • camera_get_supported_vf_modes()
              • camera_get_supported_vf_resolutions()
              • camera_get_supported_vf_rotations()
              • camera_get_vf_mode()
              • camera_get_vf_property()
              • camera_get_video_buffers()
              • camera_get_video_frame_types()
              • camera_get_video_output_resolutions()
              • camera_get_video_property()
              • camera_get_video_rotations()
              • camera_get_viewfinder_buffers()
              • camera_get_zoom_limits()
              • camera_get_zoom_ratio_from_zoom_level()
              • camera_handle_t
              • camera_has_feature()
              • camera_imgprop_t
              • camera_init_video_encoder()
              • camera_is_audiocodec_supported()
              • camera_is_create_window_supported()
              • camera_is_roll_format_supported()
              • camera_is_videocodec_supported()
              • camera_location_prop_t
              • camera_open()
              • camera_physprop_t
              • camera_powerdownreason_t
              • camera_region_t
              • camera_register_resource()
              • camera_remove_video_group_entry()
              • camera_res_t
              • camera_return_buffer()
              • camera_roll_available_video()
              • camera_roll_close_video()
              • camera_roll_get_path()
              • camera_roll_open_video()
              • camera_roll_set_path()
              • camera_roll_set_filename_suffix()
              • camera_roll_video_fmt_t
              • camera_set_analog_video_standard()
              • camera_set_brightness()
              • camera_set_capture_property()
              • camera_set_contrast()
              • camera_set_filename()
              • camera_set_hue()
              • camera_set_saturation()
              • camera_set_sharpness()
              • camera_set_vf_mode()
              • camera_set_vf_property()
              • camera_set_video_filesize_limit()
              • camera_set_video_filesize_warning()
              • camera_set_video_property()
              • camera_start_encode()
              • camera_start_video()
              • camera_start_video_group()
              • camera_start_viewfinder()
              • camera_stop_encode()
              • camera_stop_video()
              • camera_stop_video_group()
              • camera_stop_viewfinder()
              • camera_unit_t
              • camera_vfmode_t
              • camera_videocodec_t
              • camera_video_group_id_t
            • camera_encoder.h
              • camera_get_supported_videoencoder_parameter_values()
              • camera_get_videoencoder_parameter()
              • camera_set_videoencoder_parameter()
            • camera_h264avc.h
              • camera_h264avc_entropycoding_t
              • camera_h264avc_level_t
              • camera_h264avc_parameters_t
              • camera_h264avc_profile_t
              • camera_h264avc_ratecontrol_t
              • camera_h264avc_slicetype_t
            • camera_3a.h
              • camera_3a_t
              • camera_exposuremode_t
              • camera_focusmode_t
              • camera_focusstate_t
              • camera_get_3a_lock_modes()
              • camera_get_ev_offset()
              • camera_get_exposure_mode()
              • camera_get_exposure_modes()
              • camera_get_exposure_regions()
              • camera_get_focus_mode()
              • camera_get_focus_modes()
              • camera_get_focus_regions()
              • camera_get_focus_state()
              • camera_get_manual_aperture()
              • camera_get_manual_focus_step()
              • camera_get_manual_iso()
              • camera_get_manual_shutter_speed()
              • camera_get_manual_white_balance()
              • camera_get_manual_white_balance_rb_gain()
              • camera_get_supported_ev_offsets()
              • camera_get_supported_manual_aperture_values()
              • camera_get_supported_manual_iso_values()
              • camera_get_supported_manual_shutter_speeds()
              • camera_get_supported_manual_white_balance_rb_gain()
              • camera_get_supported_manual_white_balance_values()
              • camera_get_whitebalance_mode()
              • camera_get_whitebalance_modes()
              • camera_get_whitebalance_regions()
              • camera_set_3a_lock()
              • camera_set_ev_offset()
              • camera_set_exposure_mode()
              • camera_set_exposure_regions()
              • camera_set_manual_aperture()
              • camera_set_manual_focus_step()
              • camera_set_manual_iso()
              • camera_set_manual_shutter_speed()
              • camera_set_manual_white_balance()
              • camera_set_manual_white_balance_rb_gain()
              • camera_set_whitebalance_mode()
              • camera_set_whitebalance_regions()
              • camera_whitebalancemode_t
            • external_camera_api.h
              • allocate_preview_buffer_func_t
              • camera_buffer_list_t
              • camera_external_camera_t
              • camera_isp_config_type_t
              • camera_preview_frame_flags_t
              • camera_preview_params_t
              • camera_vf_framerate_min_max_index_t
              • close_external_camera_func_t
              • configure_preview_func_t
              • deinit_camera_func_t
              • free_preview_buffer_func_t
              • get_default_image_attributes_func_t
              • get_default_ISO_value_func_t
              • get_default_shutter_speed_func_t
              • get_default_wb_mode_func_t
              • get_ev_offset_func_t
              • get_framerate_func_t
              • get_manual_ISO_value_func_t
              • get_manual_shutter_speed_func_t
              • get_manual_wb_rb_gain_func_t
              • get_preview_buffer_size_func_t
              • get_preview_frame_func_t
              • get_preview_num_buffers_func_t
              • get_supported_brightness_func_t
              • get_supported_contrast_func_t
              • get_supported_ev_offsets_func_t
              • get_supported_hue_func_t
              • get_supported_ISO_values_func_t
              • get_supported_saturation_func_t
              • get_supported_sharpness_func_t
              • get_supported_shutter_speeds_func_t
              • get_supported_vf_framerates_func_t
              • get_supported_vf_frametypes_func_t
              • get_supported_vf_resolutions_func_t
              • get_supported_wb_rb_gain_func_t
              • get_supported_whitebalance_func_t
              • get_time_func_t
              • get_whitebalance_func_t
              • init_camera_func_t
              • is_exposure_mode_valid_func_t
              • is_feature_capable_func_t
              • is_whitebalance_mode_valid_func_t
              • open_external_camera_func_t
              • parse_config_func_t
              • register_status_callback_func_t
              • restart_preview_func_t
              • set_brightness_func_t
              • set_contrast_func_t
              • set_ev_offset_func_t
              • set_exposure_mode_func_t
              • set_framerate_func_t
              • set_hue_func_t
              • set_isp_config_func_t
              • set_manual_ISO_value_func_t
              • set_manual_shutter_speed_func_t
              • set_manual_wb_rb_gain_func_t
              • set_saturation_func_t
              • set_sharpness_func_t
              • set_standby_mode_func_t
              • set_whitebalance_func_t
              • set_whitebalance_mode_func_t
              • start_preview_func_t
              • status_callback
              • stop_preview_func_t
        • Sensor Developer's Guide
          • Sensor Library Overview
          • Opening and closing a connection to a sensor unit
          • Starting and stopping a sensor unit
          • Opening and closing a connection to an interim data unit
          • Starting an interim data unit
          • Accessing sensor data and status
            • Using callback mode
            • Using event mode
          • Publishing interim data
          • Subscribing to interim data
          • Recording data from a sensor
          • Querying sensor information
          • Using external clocks
          • Using external sensor drivers
          • Sensor Library Reference
            • sensor_api.h
              • Definitions in sensor_api.h
              • sensor_access_mode_t
              • sensor_bayerformat_t
              • sensor_bayerjustify_t
              • sensor_buffer_t
              • sensor_close()
              • sensor_coord_system_t
              • sensor_data_callback_t
              • sensor_devstatus_t
              • sensor_disable_data_callback()
              • sensor_disable_event()
              • sensor_disable_status_callback()
              • sensor_enable_event()
              • sensor_error_t
              • sensor_event_t
              • sensor_eventkey_t
              • sensor_eventmode_t
              • sensor_feed_input_metadata()
              • sensor_format_t
              • sensor_format_data_t
              • sensor_format_info_t
              • sensor_format_unspecified_t
              • sensor_format_user_data_t
              • sensor_format_video_bayer_t
              • sensor_format_video_cbycry_t
              • sensor_format_video_compressed_t
              • sensor_format_video_packed_t
              • sensor_format_video_planar_t
              • sensor_format_video_roi_t
              • sensor_format_video_semiplanar_t
              • sensor_get_buffer()
              • sensor_get_location_property()
              • sensor_get_metadata_limits()
              • sensor_get_physical_property()
              • sensor_get_screen_buffer()
              • sensor_get_status_details()
              • sensor_get_streaming_property()
              • sensor_get_supported_sensors()
              • sensor_get_unit()
              • sensor_handle_t
              • sensor_input_metadata_t
              • sensor_location_prop_t
              • sensor_metadata_limits_t
              • sensor_metadata_type_t
              • sensor_open()
              • sensor_physprop_t
              • sensor_playback_group_t
              • sensor_register_data_callback()
              • sensor_register_status_callback()
              • sensor_return_buffer()
              • sensor_roll_close_file()
              • sensor_roll_format_t
              • sensor_roll_get_path()
              • sensor_roll_open_file()
              • sensor_roll_set_filename_suffix()
              • sensor_roll_set_path()
              • sensor_speed_metadata_t
              • sensor_speed_metadata_limits_t
              • sensor_speed_yaw_metadata_t
              • sensor_speed_yaw_metadata_limits_t
              • sensor_start()
              • sensor_start_recording()
              • sensor_status_callback_t
              • sensor_stop()
              • sensor_stop_recording()
              • sensor_streamprop_t
              • sensor_type_t
              • sensor_unit_t
              • sensor_vehicle_direction_t
              • sensor_videocodec_t
              • supported_sensor_info_t
            • sensor_gps_imu.h
              • sensor_flag_gps_format_t
              • sensor_flag_imu_format_t
              • sensor_gps_fix_t
              • sensor_gps_format_t
              • sensor_imu_format_t
              • sensor_utc_status_t
              • sensor_utc_time_t
            • sensor_interim_data.h
              • sensor_get_supported_interim_data()
              • sensor_interim_data_alloc()
              • sensor_interim_data_close()
              • sensor_interim_data_info_t
              • sensor_interim_data_open()
              • sensor_interim_data_publish()
              • sensor_interim_data_start()
              • sensor_interim_data_unit_t
            • sensor_lidar.h
              • sensor_flag_lidar_point_cloud_t
              • sensor_flag_lidar_polar_t
              • sensor_flag_lidar_spherical_t
              • sensor_lidar_flag_t
              • sensor_lidar_point_cloud_t
              • sensor_lidar_polar_t
              • sensor_lidar_spherical_t
            • sensor_radar.h
              • sensor_flag_radar_track_polar_t
              • sensor_flag_radar_track_spherical_t
              • sensor_radar_object_class_t
              • sensor_radar_track_flags_t
              • sensor_radar_track_polar_t
              • sensor_radar_track_spherical_t
            • external_sensor_api.h
              • close_external_sensor_func_t
              • deinit_sensor_func_t
              • fill_format_info_func_t
              • get_buffer_requirements_func_t
              • get_metadata_limits_func_t
              • get_packet_func_t
              • get_time_func_t
              • init_sensor_func_t
              • parse_config_func_t
              • open_external_sensor_func_t
              • sensor_ext_reference_clock_t
              • sensor_external_sensor_t
              • sensor_flags_t
              • sensor_streaming_params_t
              • set_sensor_metadata_func_t
              • start_streaming_func_t
              • stop_streaming_func_t
          • Glossary
      • Sensor Framework Services
        • Synchronizing Sensor Timestamps
        • Sensor (sensor)
          • Sensor configuration file
            • Example: Sensor configuration file for USB camera
            • Example: Sensor configuration file for two USB cameras
            • Example: Sensor configuration file for GigE network camera
            • Example: Sensor configuration file for file camera
            • Example: Sensor configuration file for file data
            • Example: Sensor configuration file for radar
            • Example: Sensor configuration file for lidar
            • Example: Sensor configuration file for lidar (Leddartech)
            • Example: Sensor configuration file for GPS (XSens)
            • Example: Sensor configuration file for ONVIF camera
            • Example: Sensor configuration file for OV5640 camera
            • Example: Sensor configuration file for OV10635 camera
            • Example: Sensor configuration file for four OV10635 cameras
            • Example: Sensor configuration file for four AMI MINICube RDACM24 cameras
            • Example: Sensor configuration file for NovAtel GPS and IMU sensors
          • Interim data configuration file
            • Example: Interim data configuration file for an interim data unit
          • Debugging
          • Security considerations
        • System Launch and Monitor (slm)
    • System Security Guide
      • Security Matrix
      • Security Features Overview
      • Security Features for Developers
        • Security policies
        • Stack protection
        • RELRO
        • Compiler defenses
        • Address space layout randomization (ASLR)
        • Fortified system functions
        • Cryptography for developers
        • random
        • Writing a resource manager
          • Resource managers and vulnerabilities
          • Initialization
          • Message checking
          • Permission checking
      • Security Features for System Integrators
        • Privilege control
          • User IDs for system services
          • Process manager abilities
          • Abilities
          • Security policies
        • Systems without passwords
        • Secure boot
        • Cryptography for system integrators
        • Address space layout randomization (ASLR)
        • Fortified system functions
        • Access control
        • Filesystem security
        • Adaptive partitioning
        • random
        • Virtualization security features
        • The /proc filesystem
        • Application groups
      • Security Policies
        • Using security policies
        • Security policy language
        • Tutorial: Build a system that uses a security policy
          • Setting up a system to use security types
          • Booting the system for the first time
          • The generated security policy
          • Compiling the security policy
          • Booting securely
          • Developing systems with a security policy
          • The error file
          • System monitoring using secpolgenerate
          • Security policy maintenance
          • Reviewing for unnecessary rules
          • procmgr_ability() calls and the security policy
          • Event and state files
          • Troubleshooting and frequently asked questions
        • The libsecpol API (secpol.h)
          • Specifying the security policy file handle
          • Checking custom permissions when no policy is used
          • Customizing permissions using a security policy
          • Definitions in secpol.h
          • secpol_check_permission()
          • secpol_close()
          • secpol_file_t
          • secpol_flags_e
          • secpol_get_permission()
          • secpol_get_permission_flags_e
          • secpol_get_policy_id()
          • secpol_get_type_id()
          • secpol_get_type_name()
          • secpol_open()
          • secpol_open_flags_e
          • secpol_permission_t
          • secpol_posix_spawnattr_settypeid()
          • secpol_resolve_name()
          • secpol_transition_type()
          • secpol_type_id()
      • Fortified System Functions
      • QNX Cryptography Library
        • Configuration file
        • Adding cryptographic primitives
          • Certicom plugin
          • TomCrypt plugin
          • OpenSSL plugin
        • Supported primitives
          • Key generation and usage
          • Digests
          • Symmetric cryptography (ciphers)
          • Message authentication code (MAC)
          • Key Derivation Function (KDF)
          • Random number generator (RNG)
          • Digital signing and verification
          • Padding
        • QNX cryptography library reference
          • qcrypto.h
            • qcrypto_cipher_aad()
            • qcrypto_cipher_action_t
            • qcrypto_cipher_args_t
            • qcrypto_cipher_blocksize()
            • qcrypto_cipher_decrypt()
            • qcrypto_cipher_encrypt()
            • qcrypto_cipher_final()
            • qcrypto_cipher_get_tag()
            • qcrypto_cipher_init()
            • qcrypto_cipher_ivsize()
            • qcrypto_cipher_keysize()
            • qcrypto_cipher_padding_t
            • qcrypto_cipher_request()
            • qcrypto_cipher_supported()
            • qcrypto_cipher_tagsize()
            • qcrypto_ctx_t
            • qcrypto_digest()
            • qcrypto_digest_copy()
            • qcrypto_digest_final()
            • qcrypto_digest_init()
            • qcrypto_digest_request()
            • qcrypto_digest_supported()
            • qcrypto_digest_update()
            • qcrypto_digestsize()
            • qcrypto_kdf_args_t
            • qcrypto_kdf_generate()
            • qcrypto_kdf_request()
            • qcrypto_kdf_supported()
            • qcrypto_key_t
            • qcrypto_init()
            • qcrypto_mac_final()
            • qcrypto_mac_init()
            • qcrypto_mac_keysize()
            • qcrypto_mac_request()
            • qcrypto_mac_supported()
            • qcrypto_mac_tagsize()
            • qcrypto_mac_update()
            • qcrypto_memclear()
            • qcrypto_memcmp()
            • qcrypto_padding_iso7816_pad()
            • qcrypto_padding_iso7816_size()
            • qcrypto_padding_iso7816_unpad()
            • qcrypto_padding_pkcs7_pad()
            • qcrypto_padding_pkcs7_size()
            • qcrypto_padding_pkcs7_unpad()
            • qcrypto_plugin_name()
            • qcrypto_print_info()
            • qcrypto_release_ctx()
            • qcrypto_rng_args_t
            • qcrypto_rng_bytes()
            • qcrypto_rng_init()
            • qcrypto_rng_request()
            • qcrypto_rng_seed()
            • qcrypto_rng_supported()
            • qcrypto_rsa_pad_mode_t
            • qcrypto_set_config_path()
            • qcrypto_signature_args_t
            • qcrypto_signature_init()
            • qcrypto_signature_mode_t
            • qcrypto_signature_request()
            • qcrypto_signature_sign()
            • qcrypto_signature_sign_nodgst()
            • qcrypto_signature_sign_oneshot()
            • qcrypto_signature_sigsize()
            • qcrypto_signature_supported()
            • qcrypto_signature_update()
            • qcrypto_signature_verify()
            • qcrypto_signature_verify_nodgst()
            • qcrypto_signature_verify_oneshot()
            • qcrypto_uninit()
          • qcrypto_dyn.h
            • qcrypto_load()
            • qcrypto_unload()
          • qcrypto_error.h
            • QNX cryptography library error codes
            • qcrypto_strerror()
          • qcrypto_keys.h
            • qcrypto_ec_curve_t
            • qcrypto_ec_key_type_t
            • qcrypto_key_args_t
            • qcrypto_key_format_t
            • qcrypto_key_from_file()
            • qcrypto_key_from_mem()
            • qcrypto_key_generate()
            • qcrypto_key_is_private()
            • qcrypto_key_is_public()
            • qcrypto_key_is_symmetric()
            • qcrypto_key_to_file()
            • qcrypto_key_to_mem()
            • qcrypto_keygen_request()
            • qcrypto_keygen_supported()
            • qcrypto_keypair_generate()
            • qcrypto_keypair_init()
            • qcrypto_keypair_init_from_file()
            • qcrypto_keypair_init_from_mem()
            • qcrypto_privkey_from_file()
            • qcrypto_privkey_from_mem()
            • qcrypto_privkey_to_file()
            • qcrypto_privkey_to_mem()
            • qcrypto_pubkey_from_file()
            • qcrypto_pubkey_from_mem()
            • qcrypto_pubkey_from_privkey()
            • qcrypto_pubkey_to_file()
            • qcrypto_pubkey_to_mem()
            • qcrypto_release_key()
          • qcrypto_plugin.h
            • qcrypto_algorithm_op_init
            • qcrypto_algorithm_op_uninit
            • qcrypto_algorithm_t
            • qcrypto_algorithm_type_t
            • qcrypto_cipher_op_aad
            • qcrypto_cipher_op_encrypt_decrypt
            • qcrypto_cipher_op_final
            • qcrypto_cipher_op_get_tag
            • qcrypto_cipher_op_init
            • qcrypto_cipher_ops_t
            • qcrypto_cipher_params_t
            • qcrypto_cipher_t
            • qcrypto_digest_op_copy
            • qcrypto_digest_op_final
            • qcrypto_digest_op_init
            • qcrypto_digest_op_update
            • qcrypto_digest_ops_t
            • qcrypto_digest_params_t
            • qcrypto_digest_t
            • qcrypto_kdf_op_gen
            • qcrypto_kdf_ops_t
            • qcrypto_kdf_t
            • qcrypto_key_alg_type_t
            • qcrypto_key_ctx_free()
            • qcrypto_key_ctx_t
            • qcrypto_key_type_t
            • qcrypto_keygen_op_export_raw
            • qcrypto_keygen_op_get_pubkey
            • qcrypto_keygen_op_import_raw
            • qcrypto_keygen_op_key_gen
            • qcrypto_keygen_op_keypair_gen
            • qcrypto_keygen_op_keypair_init
            • qcrypto_keygen_op_keypair_init_params
            • qcrypto_keygen_op_release
            • qcrypto_keygen_ops_t
            • qcrypto_keygen_params_t
            • qcrypto_keygen_t
            • qcrypto_mac_op_final
            • qcrypto_mac_op_init
            • qcrypto_mac_op_update
            • qcrypto_mac_ops_t
            • qcrypto_mac_params_t
            • qcrypto_mac_t
            • qcrypto_plugin_op_get_description
            • qcrypto_plugin_op_init
            • qcrypto_plugin_op_uninit
            • qcrypto_plugin_ops_t
            • qcrypto_rng_op_bytes
            • qcrypto_rng_op_init
            • qcrypto_rng_op_seed
            • qcrypto_rng_ops_t
            • qcrypto_rng_params_t
            • qcrypto_rng_t
            • qcrypto_signature_op_init
            • qcrypto_signature_op_sign
            • qcrypto_signature_op_sign_nodgst
            • qcrypto_signature_op_sign_oneshot
            • qcrypto_signature_op_sigsize
            • qcrypto_signature_op_update
            • qcrypto_signature_op_verify
            • qcrypto_signature_op_verify_nodgst
            • qcrypto_signature_op_verify_oneshot
            • qcrypto_signature_ops_t
            • qcrypto_signature_params_t
            • qcrypto_signature_t
            • qcrypto_state_ctx_t
            • register_algorithm()
      • The devcrypto service
        • The devcrypto plugin API (devcrypto_plugin.h)
          • Definitions in devcrypto_plugin.h
          • devcrypto_aead_cipher_op_decrypt
          • devcrypto_aead_cipher_op_encrypt
          • devcrypto_aead_cipher_op_init
          • devcrypto_aead_cipher_ops_t
          • devcrypto_aead_cipher_params_t
          • devcrypto_aead_cipher_t
          • devcrypto_algorithm_op_init
          • devcrypto_algorithm_op_uninit
          • devcrypto_algorithm_t
          • devcrypto_algorithm_type_t
          • devcrypto_cipher_op_decrypt
          • devcrypto_cipher_op_encrypt
          • devcrypto_cipher_op_init
          • devcrypto_cipher_ops_t
          • devcrypto_cipher_params_t
          • devcrypto_cipher_t
          • devcrypto_digest_op_copy
          • devcrypto_digest_op_final
          • devcrypto_digest_op_init
          • devcrypto_digest_op_update
          • devcrypto_digest_ops_t
          • devcrypto_digest_params_t
          • devcrypto_digest_t
          • devcrypto_mac_op_final
          • devcrypto_mac_op_init
          • devcrypto_mac_op_update
          • devcrypto_mac_ops_t
          • devcrypto_mac_params_t
          • devcrypto_mac_t
          • devcrypto_plugin_op_init
          • devcrypto_plugin_op_uninit
          • devcrypto_plugin_ops_t
          • devcrypto_plugin_register_algorithm()
          • devcrypto_state_ctx_t
        • Example devcrypto plugin: openssl_digest.c
        • The devcrypto I/O command API (cryptodev.h)
          • General definitions in cryptodev.h
          • Cryptography device algorithms
          • Cryptography device operations
          • Cryptography device CIOCCRYPT command flags
          • cphash_op_t
          • cryptodev_crypt_auth_op_t
          • cryptodev_crypt_op_t
          • cryptodev_session_op_t
      • Pathtrust
      • PAM
      • Using mkqnximage to Display Security Features
        • Secure procfs (/proc filesystem) option
        • Pathtrust option
        • QTD option
        • Secpol and policy options
    • Utilities & Libraries
      • Addon Interfaces Library Reference
        • Addon Interfaces Library: Overview
          • Writing addon interfaces: example
        • Using Addon Resources
          • Creating resources in an addon
          • Using addon resources in an application
        • Predefined Interfaces
          • Recognized interfaces
            • InitializeInterface
            • Name
            • Strings
          • AOConfigSettings
            • Settings
            • VerifyAll()
            • VerifyValue()
          • AODeConstructor
            • Create()
            • Destroy()
          • AODeInitializer
            • Cleanup()
            • Init()
          • AOExtInspector
            • RateExtension()
          • AOFormatInspector
            • RateFormat()
          • AOMimetypeInspector
            • RateMimetype()
          • AOStreamer
            • Close()
            • ContextOpen()
            • GetError()
            • Length()
            • Open()
            • Read()
            • Seek()
            • SideInfo()
            • Sniff()
            • Tell()
            • Write()
          • AOStreamerMimeInfo
            • GetInfo()
          • AOStreamInspector
            • RateStream()
          • AOResourceAccess
            • GetResources()
            • SetResource()
        • Defined Structures
          • AOAudioFormat_t
          • AODataFormat_t
            • AOIFOURCC* constants and functions
          • AOImageFormat_t
          • AOIStream_t
          • AOLoadedConfig_t
          • AOResource_t
          • AOVideoFormat_t
        • Core API Reference
          • Function safety
          • AOICtrl_t
          • AOError_t
            • AOErrNo_t
          • AOInterface_t
          • AOParam_t
          • AoAdd()
          • AoAddDirectory()
          • AoAddDll()
          • AoAddPrivate()
          • AoAddStatic()
          • AoAddUnloadSignal()
          • AoFindExt()
          • AoFindFormats()
          • AoFindMime()
          • AoFindName()
          • AoFindStreams()
          • AoFindString()
          • AoGetAOInterface()
          • AoGetInterface()
          • AoGetStrings()
          • AoHasInterface()
          • AoHold()
          • AoHoldAll()
          • AoIterate()
          • AoIterateHoldGet()
          • AoIterateName()
          • AoLoadConfig()
          • AoOpenFilespec()
          • AoOpenStream()
          • AoRelease()
          • AoReleaseAll()
          • AoRemove()
          • AoSearchString()
          • AoSetError()
          • AoStreamClose()
          • AoUngetStrings()
            • Handling changed addon strings
          • AoUnloadConfig()
      • C Library Reference
        • What's in a Function Description?
        • Manifests
        • Character Sets
        • A
          • abort()
          • abs()
          • accept()
          • access()
          • acl_add_perm()
          • acl_calc_mask()
          • acl_clear_perms()
          • acl_copy_entry()
          • acl_copy_ext()
          • acl_copy_int()
          • acl_create_entry()
          • acl_delete_entry()
          • acl_delete_perm()
          • acl_dup()
          • acl_free()
          • acl_from_text()
          • acl_get_entry()
          • acl_get_fd()
          • acl_get_file()
          • acl_get_perm_np()
          • acl_get_permset()
          • acl_get_qualifier()
          • acl_get_tag_type()
          • acl_init()
          • acl_set_fd()
          • acl_set_file()
          • acl_set_permset()
          • acl_set_qualifier()
          • acl_set_tag_type()
          • acl_size()
          • acl_to_text()
          • acl_valid()
          • acos(), acosf(), acosl()
          • acosh(), acoshf(), acoshl()
          • addrinfo
          • aio_cancel()
          • aio_error()
          • aio_fsync()
          • aio_read(), aio_read64()
          • aio_return()
          • aio_suspend()
          • aio_write(), aio_write64()
          • aiocb, aiocb64
          • alarm()
          • alignas, __alignas_is_defined
          • aligned_alloc()
          • alignof(), __alignof_is_defined
          • alloca()
          • alphasort()
          • _amblksiz
          • _argc
          • _argv
          • asctime(), asctime_r()
          • asin(), asinf(), asinl()
          • asinh(), asinhf(), asinhl()
          • asprintf()
          • assert()
          • at_quick_exit()
          • atan(), atanf(), atanl()
          • atan2(), atan2f(), atan2l()
          • atanh(), atanhf(), atanhl()
          • atexit()
          • atof()
          • atoi()
          • atol(), atoll()
          • ATOMIC_*_LOCK_FREE
          • atomic_*
          • atomic_add()
          • atomic_add_value()
          • atomic_clr()
          • atomic_clr_value()
          • atomic_compare_exchange_strong(), atomic_compare_exchange_strong_explicit(), atomic_compare_exchange_weak(), atomic_compare_exchange_weak_explicit()
          • atomic_exchange(), atomic_exchange_explicit()
          • atomic_fetch_add(), atomic_fetch_add_explicit()
          • atomic_fetch_and(), atomic_fetch_and_explicit()
          • atomic_fetch_or(), atomic_fetch_or_explicit()
          • atomic_fetch_sub(), atomic_fetch_sub_explicit()
          • atomic_fetch_xor(), atomic_fetch_xor_explicit()
          • atomic_flag_clear(), atomic_flag_clear_explicit()
          • atomic_flag_test_and_set(), atomic_flag_test_and_set_explicit()
          • atomic_init()
          • atomic_is_lock_free()
          • atomic_load(), atomic_load_explicit()
          • atomic_set()
          • atomic_set_value()
          • atomic_signal_fence()
          • atomic_store(), atomic_store_explicit()
          • atomic_sub()
          • atomic_sub_value()
          • atomic_thread_fence()
          • atomic_toggle()
          • atomic_toggle_value()
          • _auxv
        • B
          • basename()
          • bcmp()
          • bcopy()
          • bind()
          • bindresvport()
          • bsearch()
          • bt_get_backtrace()
          • bt_init_accessor()
          • bt_load_memmap()
          • bt_release_accessor()
          • bt_set_flags()
          • bt_sprn_memmap()
          • bt_sprnf_addrs()
          • bt_translate_addrs()
          • bt_unload_memmap()
          • _btext
          • btowc()
          • bzero()
        • C
          • c16rtomb(), c32rtomb()
          • _cred_info
          • cabs(), cabsf(), cabsl()
          • cache_fini()
          • CACHE_FLUSH()
          • cache_init()
          • CACHE_INVAL()
          • cacos(), cacosf(), cacosl()
          • cacosh(), cacoshf(), cacoshl()
          • call_once()
          • calloc()
          • carg(), cargf(), cargl()
          • casin(), casinf(), casinl()
          • casinh(), casinhf(), casinhl()
          • catan(), catanf(), catanl()
          • catanh(), catanhf(), catanhl()
          • cbrt(), cbrtf(), cbrtl()
          • ccos(), ccosf(), ccosl()
          • ccosh(), ccoshf(), ccoshl()
          • ceil(), ceilf(), ceill()
          • cexp(), cexpf(), cexpl()
          • cfgetispeed()
          • cfgetospeed()
          • cfgopen()
          • cfmakeraw()
          • cfree()
          • cfsetispeed()
          • cfsetospeed()
          • ChannelCreate(), ChannelCreate_r(), ChannelCreatePulsePool()
          • ChannelDestroy(), ChannelDestroy_r()
          • chdir()
          • chmod()
          • chown()
          • chroot()
          • cimag(), cimagf(), cimagl()
          • clearenv()
          • clearerr()
          • ClientInfoExtFree()
          • clock()
          • clock_getcpuclockid()
          • clock_getres()
          • clock_gettime()
          • clock_nanosleep()
          • clock_settime()
          • ClockAdjust(), ClockAdjust_r()
          • ClockCycles()
          • ClockId(), ClockId_r()
          • ClockPeriod(), ClockPeriod_r()
          • ClockTime(), ClockTime_r()
          • clog(), clogf(), clogl()
          • close()
          • closedir()
          • closelog()
          • _cmdname()
          • CMPLX(), CMPLXF(), CMPLXL()
          • cnd_broadcast()
          • cnd_destroy()
          • cnd_init()
          • cnd_signal()
          • cnd_timedwait()
          • cnd_wait()
          • confstr()
          • conj(), conjf(), conjl()
          • connect()
          • ConnectAttach(), ConnectAttach_r()
          • ConnectClientInfo(), ConnectClientInfo_r()
          • ConnectClientInfoAble()
          • ConnectClientInfoExt()
          • ConnectDetach(), ConnectDetach_r()
          • ConnectFlags(), ConnectFlags_r()
          • ConnectServerInfo(), ConnectServerInfo_r()
          • copysign(), copysignf(), copysignl()
          • cos(), cosf(), cosl()
          • cosh(), coshf(), coshl()
          • cpow(), cpowf(), cpowl()
          • cproj(), cprojf(), cprojl()
          • creal(), crealf(), creall()
          • creat(), creat64()
          • crypt()
          • csin(), csinf(), csinl()
          • csinh(), csinhf(), csinhl()
          • csqrt(), csqrtf(), csqrtl()
          • ctan(), ctanf(), ctanl()
          • ctanh(), ctanhf(), ctanhl()
          • ctermid()
          • ctime(), ctime_r()
        • D
          • daemon()
          • daylight
          • DebugBreak()
          • DebugKDBreak()
          • DebugKDOutput()
          • delay()
          • devctl(),devctlv()
          • dhcpctl*()
          • difftime()
          • dircntl()
          • dirent, dirent64
          • dirfd()
          • dirname()
          • dispatch_block()
          • dispatch_context_alloc()
          • dispatch_context_free()
          • dispatch_create()
          • dispatch_create_channel()
          • dispatch_destroy()
          • dispatch_handler()
          • dispatch_timeout()
          • dispatch_unblock()
          • div()
          • dl_iterate_phdr()
          • dladdr()
          • dlclose()
          • dlerror()
          • dlopen()
          • dlsym()
          • dn_comp()
          • dn_expand()
          • dprintf()
          • drand48()
          • dup()
          • dup2()
        • E
          • eaccess()
          • _edata
          • encrypt()
          • _end
          • endfsent()
          • endgrent()
          • endhostent()
          • ENDIAN_BE16()
          • ENDIAN_BE32()
          • ENDIAN_BE64()
          • ENDIAN_LE16()
          • ENDIAN_LE32()
          • ENDIAN_LE64()
          • ENDIAN_RET16()
          • ENDIAN_RET32()
          • ENDIAN_RET64()
          • ENDIAN_SWAP16()
          • ENDIAN_SWAP32()
          • ENDIAN_SWAP64()
          • endnetent()
          • endprotoent()
          • endpwent()
          • endservent()
          • endspent()
          • endutent()
          • environ
          • erand48()
          • erf(), erff(), erfl()
          • erfc(), erfcf(), erfcl()
          • err(), errx()
          • errno
          • _etext
          • execl()
          • execle()
          • execlp()
          • execlpe()
          • execv()
          • execve()
          • execvp()
          • execvpe()
          • _exit()
          • exit()
          • exp(), expf(), expl()
          • exp2(), exp2f(), exp2l()
          • expm1(), expm1f(), expm1l()
        • F
          • fabs(), fabsf(), fabsl()
          • faccessat()
          • fcfgopen()
          • fchdir()
          • fchecktrust()
          • fchmod()
          • fchmodat()
          • fchown()
          • fchownat()
          • fclose()
          • fcloseall()
          • fcntl()
          • fdatasync()
          • fdim(), fdimf(), fdiml()
          • fdistrusted()
          • fdopen()
          • fdopendir()
          • feclearexcept()
          • fedisableexcept()
          • feenableexcept()
          • fegetenv()
          • fegetexceptflag()
          • fegetprec()
          • fegetround()
          • feholdexcept()
          • feof()
          • feraiseexcept()
          • ferror()
          • fesetenv()
          • fesetexceptflag()
          • fesetprec()
          • fesetround()
          • fetestexcept()
          • feupdateenv()
          • fflush()
          • ffs(), ffsl(), ffsll()
          • fgetc()
          • fgetpos()
          • fgets()
          • fgetspent()
          • fgetwc()
          • fgetws()
          • fileno()
          • flink()
          • flock()
          • flockfile()
          • floor(), floorf(), floorl()
          • fls(), flsl(), flsll()
          • fma(), fmaf(), fmal()
          • fmax(), fmaxf(), fmaxl()
          • fmin(), fminf(), fminl()
          • fmod(), fmodf(), fmodl()
          • fnmatch(), _fnmatchv()
          • fopen(), fopen64()
          • fork()
          • forkpty()
          • forksafe_mutex_destroy()
          • forksafe_mutex_init()
          • forksafe_mutex_lock()
          • forksafe_mutex_trylock()
          • forksafe_mutex_unlock()
          • fpathconf()
          • fpclassify()
          • fprintf()
          • fputc()
          • fputs()
          • fputwc()
          • fputws()
          • fread()
          • free()
          • freeaddrinfo()
          • freeifaddrs()
          • freopen(), freopen64()
          • frexp(), frexpf(), frexpl()
          • fs_crypto_check()
          • fs_crypto_domain_add()
          • fs_crypto_domain_add_flags()
          • fs_crypto_domain_hard_lock()
          • fs_crypto_domain_key_change()
          • fs_crypto_domain_key_check()
          • fs_crypto_domain_key_size()
          • fs_crypto_domain_lock()
          • fs_crypto_domain_query()
          • fs_crypto_domain_remove()
          • fs_crypto_domain_unlock()
          • fs_crypto_domain_whitelist_configure()
          • fs_crypto_domain_whitelist_ctrl()
          • fs_crypto_domain_whitelist_ctrl_access_grant()
          • fs_crypto_domain_whitelist_ctrl_access_revoke()
          • fs_crypto_domain_whitelist_get_flags()
          • fs_crypto_domain_whitelist_set_flags()
          • fs_crypto_enable()
          • fs_crypto_enable_option()
          • fs_crypto_file_get_domain()
          • fs_crypto_file_set_domain()
          • fs_crypto_key_gen()
          • fs_crypto_migrate_control()
          • fs_crypto_migrate_path()
          • fs_crypto_migrate_status()
          • fs_crypto_migrate_tag()
          • fs_crypto_set_logging()
          • fscanf()
          • fsev_t, FSE*()
          • fseek(), fseeko(), fseeko64()
          • fsetpos()
          • fstat(), fstat64()
          • fstatat(), fstatat64()
          • fstatvfs(), fstatvfs64()
          • fsync()
          • ftell(), ftello(), ftello64()
          • ftime()
          • ftruncate(), ftruncate64()
          • ftrylockfile()
          • ftw(), ftw64()
          • funlockfile()
          • futime()
          • futimens()
          • fwide()
          • fwprintf()
          • fwrite()
          • fwscanf()
        • G
          • gai_strerror()
          • getaddrinfo()
          • getc()
          • getc_unlocked()
          • getchar()
          • getchar_unlocked()
          • getcwd()
          • getdelim(), getline()
          • getdomainname()
          • getdtablesize()
          • getegid()
          • getenv()
          • geteuid()
          • getfsent()
          • getfsfile()
          • getfsspec()
          • getgid()
          • getgrent()
          • getgrgid()
          • getgrgid_r()
          • getgrnam()
          • getgrnam_r()
          • getgrouplist()
          • getgroups()
          • gethostbyaddr()
          • gethostbyaddr_r()
          • gethostbyname(), gethostbyname2()
          • gethostbyname_r()
          • gethostent()
          • gethostent_r()
          • gethostname()
          • getifaddrs()
          • GETIOVBASE()
          • GETIOVLEN()
          • getitimer()
          • getlogin()
          • getlogin_r()
          • getnameinfo()
          • getnetbyaddr()
          • getnetbyname()
          • getnetent()
          • getopt()
          • getopt_long(), getopt_long_only()
          • getpagesize()
          • getpagesizes(), getpagesizes64()
          • getpass()
          • getpeereid()
          • getpeername()
          • getpgid()
          • getpgrp()
          • getpid()
          • getppid()
          • getprotobyname()
          • getprotobynumber()
          • getprotoent()
          • getpwent()
          • getpwent_r()
          • getpwnam()
          • getpwnam_r()
          • getpwuid()
          • getpwuid_r()
          • getrlimit(), getrlimit64()
          • getrusage()
          • gets()
          • getservbyname()
          • getservbyport()
          • getservent()
          • getsid()
          • getsockname()
          • getsockopt()
          • getspent(), getspent_r()
          • getspnam(), getspnam_r()
          • getsubopt()
          • gettid()
          • gettimeofday()
          • getuid()
          • getutent()
          • getutid()
          • getutline()
          • getw()
          • getwc()
          • getwchar()
          • getwd()
          • glob()
          • globfree()
          • gmtime()
          • gmtime_r()
          • grantpt()
        • H
          • h_errno
          • hcreate()
          • hdestroy()
          • herror()
          • hostent
          • hsearch()
          • hstrerror()
          • htonl()
          • htons()
          • hwi_find()
          • hwi_find_bus()
          • hwi_find_compatible()
          • hwi_find_device()
          • hwi_find_devicebus()
          • hwi_find_item()
          • hwi_find_num_units()
          • hwi_find_tag()
          • hwi_find_unit()
          • hwi_next_item()
          • hwi_next_tag()
          • hwi_off2tag()
          • hwi_tag2off()
          • hwi_tag_find()
          • hwiattr_get(), hwiattr_get_*()
          • hwitag_find_busattr()
          • hwitag_find_clkfreq()
          • hwitag_find_errata()
          • hwitag_find_ivec()
          • hwitag_find_nicaddr()
          • hwitag_find_phyaddr()
          • hypot(), hypotf(), hypotl()
        • I
          • ICMP
          • ICMP6
          • if_freenameindex()
          • if_indextoname()
          • if_nameindex()
          • if_nametoindex()
          • ifaddrs
          • ilogb(), ilogbf(), ilogbl()
          • in8()
          • in8s()
          • in16(), inbe16(), inle16()
          • in16s()
          • in32(), inbe32(), inle32()
          • in32s()
          • index()
          • inet_addr()
          • inet_aton()
          • inet_lnaof()
          • inet_makeaddr()
          • inet_net_ntop()
          • inet_netof()
          • inet_net_pton()
          • inet_network()
          • inet_ntoa()
          • inet_ntoa_r()
          • inet_ntop()
          • inet_pton()
          • INET6
          • inet6_option_alloc()
          • inet6_option_append()
          • inet6_option_find()
          • inet6_option_init()
          • inet6_option_next()
          • inet6_option_space()
          • inet6_rthdr_add()
          • inet6_rthdr_getaddr()
          • inet6_rthdr_getflags()
          • inet6_rthdr_init()
          • inet6_rthdr_lasthop()
          • inet6_rthdr_reverse()
          • inet6_rthdr_segments()
          • inet6_rthdr_space()
          • initgroups()
          • initstate()
          • inotify_add_watch()
          • inotify_event
          • inotify_init()
          • inotify_rm_watch()
          • inotify_qnx_ext()
          • insque()
          • InterruptAttach(), InterruptAttach_r()
          • InterruptAttachArray(), InterruptAttachArray_r()
          • InterruptAttachEvent(), InterruptAttachEvent_r()
          • InterruptDetach(), InterruptDetach_r()
          • InterruptDisable()
          • InterruptEnable()
          • InterruptHookIdle2()
          • InterruptHookTrace()
          • InterruptLock()
          • InterruptMask()
          • InterruptStatus()
          • InterruptUnlock()
          • InterruptUnmask()
          • InterruptWait(), InterruptWait_r()
          • _io_connect
          • _io_connect_ftype_reply
          • _io_connect_link_reply
          • ioctl(), vioctl()
          • iofdinfo()
          • iofunc_ability_check()
          • iofunc_acl()
          • iofunc_acl_default()
          • iofunc_attr_init(), iofunc_attr_init_sized()
          • iofunc_attr_lock()
          • iofunc_attr_t
          • iofunc_attr_trylock()
          • iofunc_attr_unlock()
          • iofunc_check_access()
          • iofunc_chmod()
          • iofunc_chmod_default()
          • iofunc_chown()
          • iofunc_chown_default()
          • iofunc_client_info_able()
          • iofunc_client_info_ext()
          • iofunc_client_info_ext_free()
          • iofunc_close_dup()
          • iofunc_close_dup_default()
          • iofunc_close_ocb()
          • iofunc_close_ocb_default()
          • iofunc_devctl()
          • iofunc_devctl_default()
          • iofunc_devctl_verify()
          • iofunc_fdinfo()
          • iofunc_fdinfo_default()
          • iofunc_func_init()
          • iofunc_link()
          • iofunc_lock()
          • iofunc_lock_calloc()
          • iofunc_lock_default()
          • iofunc_lock_free()
          • iofunc_lock_ocb_default()
          • iofunc_lseek()
          • iofunc_lseek_default()
          • iofunc_mknod()
          • iofunc_mmap()
          • iofunc_mmap_default(), iofunc_mmap_default_ext()
          • iofunc_mmap_ext()
          • iofunc_mount_fini()
          • iofunc_mount_init()
          • iofunc_mount_set_time()
          • iofunc_mount_t
          • iofunc_notify()
          • iofunc_notify_remove(), iofunc_notify_remove_strict()
          • iofunc_notify_trigger(), iofunc_notify_trigger_strict()
          • iofunc_ocb_attach()
          • iofunc_ocb_calloc()
          • iofunc_ocb_detach()
          • iofunc_ocb_free()
          • iofunc_ocb_t
          • iofunc_open()
          • iofunc_open_default()
          • iofunc_openfd()
          • iofunc_openfd_default()
          • iofunc_pathconf()
          • iofunc_pathconf_default()
          • iofunc_read_default()
          • iofunc_read_verify()
          • iofunc_readlink()
          • iofunc_rename()
          • iofunc_space_verify()
          • iofunc_stat(), iofunc_stat_format()
          • iofunc_stat_default()
          • iofunc_sync()
          • iofunc_sync_default()
          • iofunc_sync_verify()
          • iofunc_time_update()
          • iofunc_unblock()
          • iofunc_unblock_default()
          • iofunc_unlink()
          • iofunc_unlock_ocb_default()
          • iofunc_utime()
          • iofunc_utime_default()
          • iofunc_write_default()
          • iofunc_write_verify()
          • ionotify()
          • IP
          • IPsec
          • ipsec_dump_policy()
          • ipsec_get_policylen()
          • ipsec_set_policy()
          • ipsec_strerror()
          • IPv6
          • isalnum()
          • isalpha()
          • isascii()
          • isatty()
          • isblank()
          • iscntrl()
          • isdigit()
          • isfdtype()
          • isfinite()
          • isgraph()
          • isgreater()
          • isgreaterequal()
          • isinf()
          • isless()
          • islessequal()
          • islessgreater()
          • islower()
          • isnan()
          • isnormal()
          • isprint()
          • ispunct()
          • isspace()
          • isunordered()
          • isupper()
          • iswalnum()
          • iswalpha()
          • iswblank()
          • iswcntrl()
          • iswctype()
          • iswdigit()
          • iswgraph()
          • iswlower()
          • iswprint()
          • iswpunct()
          • iswspace()
          • iswupper()
          • iswxdigit()
          • isxdigit()
          • itoa()
        • J
          • j0(), j0f()
          • j1(), j1f()
          • jn(), jnf()
          • jrand48()
        • K
          • kill()
          • killpg()
        • L
          • labs()
          • lchown()
          • lcong48()
          • ldexp(), ldexpf(), ldexpl()
          • ldiv(), lldiv()
          • lfind()
          • lgamma(), lgamma_r(), lgammaf(), lgammaf_r(), lgammal(), lgammal_r()
          • link()
          • linkat()
          • lio_listio(), lio_listio64()
          • listen()
          • llabs()
          • llrint(), llrintf(), llrintl()
          • llround(), llroundf(), llroundl()
          • localeconv()
          • localtime()
          • localtime_r()
          • lockf(), lockf64()
          • log(), logf(), logl()
          • log10(), log10f(), log10l()
          • log1p(), log1pf(),