Литература_1 / sys_arch

Mediastore content management

The MME’s mediastore content-management capabilities include:

•media metadata extraction and storage — tags, third-party metadata, cover art, etc.

•media content browsing and searching

•playlist extraction and custom playlist creation

Media playback and recording

The MME’s media playback and recording capabilities include:

•media content recording, copying and ripping

•media stream processing:

-a flexible plugin architecture for filters that decrypt, parse, decode, encode and encrypt media data streams

-a transparent communication mechanism to external codecs for flexible HW/SW partitioning of filter functionality

•media stream rendering and deployment:

-route to output devices (displays, amplifiers, headphones, etc.)

-store registered and encoded media data to storage device (HDD)

The MME interface

The MME API includes a primary interface and a secondary interface. The primary interface (mme) offers the media management functionality required of a multimedia middleware platform, while the secondary interface (qdb) offers the required database functionality. Together the primary and secondary interfaces offer multimedia applications a consistent API that provides:

•media transport, rendering and control — control of playback, and of aspects of media rendering such as volume, brightness, and playback modes (mme)

•notification — receiving information about the status of media, devices and operations; and effecting changes to media library content (mme)

•navigation — browsing media devices that support internal navigation, such as a DVD menu system or an iPod (mme, qdb, or both)

•database capabilities — searching, sorting, organizing, and updating of media information and metadata (qdb)

Component-based architecture

The MME is comprised of several independent components. Each MME component executes independently as a Neutrino resource manager process. A resource manager is a user-level server process that accepts messages from other programs and, optionally, communicates with hardware.

The MME’s component-based architecture delivers:

•flexibility — developers using the MME to build multimedia products can easily configure the MME and its individual resource managers to meet their specific needs.

•easy deployment — multimedia applications build with the MME can be deployed on a single processor, or on a distributed network of processors with no changes to their application code.

•reliability — the MME’s resource managers all have their own failure and restart; a resource manager failure doesn’t mean a system failure.

•portability — all MME components offer standard interfaces, such as POSIX or SQL.

The MME resource managers

The MME resource managers can be placed into these groups:

•high-level resource managers that provide the interfaces to HMI client applications

•low-level resource managers that don’t normally interface with HMI client applications

The resource managers that provide the interfaces to multimedia client applications are:

•the qdb database engine

•the mme multimedia engine

Human-Machine

Interface

Content synchronization

Media devices

MME architecture showing mme and qdb resource managers.

Both the mme and the qdb resource managers support device-specific functionality within a POSIX framework. Together they make up the interface to HMI client applications, providing them with an API to control, browse, copy or rip, and play media, as well as the ability to monitor and manage multimedia processing. The mme controls the low-level resource managers that directly access and process media data.

Multimedia client applications don’t normally interface with the MME’s lower-level resource managers. You may nonetheless find it useful to know about these resource managers and understand what they do, especially if you are tuning your system configuration. The MME’s low-level resource managers include:

•the io-fs resource managers that provide access to media devices and mediastores

•the io-media resource managers that are responsible for media stream processing and rendering, for managing complex media streams, and for performing tasks that include CD and DVD playback, file playback, media copying, and media recording

Other low-level resource managers that are not specific to the MME, but which the

MME uses, include:

•the devb resource managers, such as devb-eide and devb-atapi, that provide access to data on block-oriented devices and filesystems

•the io-usb resource manager that provides access to media on USB stores

•io-audio, io-display, and other resource managers that provide an abstraction of media output devices

Glossary

♥ 2008, QNX Software Systems GmbH & Co. KG.

A20 gate

On x86-based systems, a hardware component that forces the A20 address line on the bus to zero, regardless of the actual setting of the A20 address line on the processor. This component is in place to support legacy systems, but the QNX Neutrino OS doesn’t require any such hardware. Note that some processors, such as the 386EX, have the A20 gate hardware built right into the processor itself — our IPL will disable the A20 gate as soon as possible after startup.

adaptive

Scheduling algorithm whereby a thread’s priority is decayed by 1. See also FIFO, round robin, and sporadic.

adaptive partitioning

A method of dividing, in a flexible manner, CPU time, memory, file resources, or kernel resources with some policy of minimum guaranteed usage.

asymmetric multiprocessing (AMP)

A multiprocessing system where a separate OS, or a separate instantiation of the same OS, runs on each CPU.

atomic

Of or relating to atoms. :-)

In operating systems, this refers to the requirement that an operation, or sequence of operations, be considered indivisible. For example, a thread may need to move a file position to a given location and read data. These operations must be performed in an atomic manner; otherwise, another thread could preempt the original thread and move the file position to a different location, thus causing the original thread to read data from the second thread’s position.

attributes structure

Structure containing information used on a per-resource basis (as opposed to the

OCB, which is used on a per-open basis).

This structure is also known as a handle. The structure definition is fixed (iofunc_attr_t), but may be extended. See also mount structure.

bank-switched

A term indicating that a certain memory component (usually the device holding an image) isn’t entirely addressable by the processor. In this case, a hardware component manifests a small portion (or “window”) of the device onto the processor’s address bus. Special commands have to be issued to the hardware to move the window to different locations in the device. See also linearly mapped.

♥ 2008, QNX Software Systems GmbH & Co. KG.

base layer calls

Convenient set of library calls for writing resource managers. These calls all start with resmgr_*(). Note that while some base layer calls are unavoidable (e.g. resmgr_pathname_attach()), we recommend that you use the POSIX layer calls where possible.

BIOS/ROM Monitor extension signature

A certain sequence of bytes indicating to the BIOS or ROM Monitor that the device is to be considered an “extension” to the BIOS or ROM Monitor — control is to be transferred to the device by the BIOS or ROM Monitor, with the expectation that the device will perform additional initializations.

On the x86 architecture, the two bytes 0x55 and 0xAA must be present (in that order) as the first two bytes in the device, with control being transferred to offset 0x0003.

block-integral

The requirement that data be transferred such that individual structure components are transferred in their entirety — no partial structure component transfers are allowed.

In a resource manager, directory data must be returned to a client as block-integral data. This means that only complete struct dirent structures can be returned — it’s inappropriate to return partial structures, assuming that the next _IO_READ request will “pick up” where the previous one left off.

bootable

An image can be either bootable or nonbootable. A bootable image is one that contains the startup code that the IPL can transfer control to.

bootfile

The part of an OS image that runs the startup code and the Neutrino microkernel.

bound multiprocessing (BMP)

A multiprocessing system where a single instantiation of an OS manages all CPUs simultaneously, but you can lock individual applications or threads to a specific CPU.

budget

In sporadic scheduling, the amount of time a thread is permitted to execute at its normal priority before being dropped to its low priority.

buildfile

A text file containing instructions for mkifs specifying the contents and other details of an image, or for mkefs specifying the contents and other details of an embedded filesystem image.

♥ 2008, QNX Software Systems GmbH & Co. KG.

canonical mode

Also called edited mode or “cooked” mode. In this mode the character device library performs line-editing operations on each received character. Only when a line is “completely entered” — typically when a carriage return (CR) is received — will the line of data be made available to application processes. Contrast raw mode.

channel

A kernel object used with message passing.

In QNX Neutrino, message passing is directed towards a connection (made to a channel); threads can receive messages from channels. A thread that wishes to receive messages creates a channel (using ChannelCreate()), and then receives messages from that channel (using MsgReceive()). Another thread that wishes to send a message to the first thread must make a connection to that channel by “attaching” to the channel (using ConnectAttach()) and then sending data (using MsgSend()).

CIFS

Common Internet File System (aka SMB) — a protocol that allows a client workstation to perform transparent file access over a network to a Windows 95/98/NT server. Client file access calls are converted to CIFS protocol requests and are sent to the server over the network. The server receives the request, performs the actual filesystem operation, and sends a response back to the client.

CIS

Card Information Structure — a data block that maintains information about flash configuration. The CIS description includes the types of memory devices in the regions, the physical geometry of these devices, and the partitions located on the flash.

combine message

A resource manager message that consists of two or more messages. The messages are constructed as combine messages by the client’s C library (e.g. stat(), readblock()), and then handled as individual messages by the resource manager.

The purpose of combine messages is to conserve network bandwidth and/or to provide support for atomic operations. See also connect message and I/O message.

connect message

In a resource manager, a message issued by the client to perform an operation based on a pathname (e.g. an io_open message). Depending on the type of connect message sent, a context block (see OCB) may be associated with the request and will be passed to subsequent I/O messages. See also combine message and I/O message.

connection

A kernel object used with message passing.

♥ 2008, QNX Software Systems GmbH & Co. KG.

Connections are created by client threads to “connect” to the channels made available by servers. Once connections are established, clients can MsgSendv() messages over them. If a number of threads in a process all attach to the same channel, then the one connection is shared among all the threads. Channels and connections are identified within a process by a small integer.

The key thing to note is that connections and file descriptors (FD) are one and the same object. See also channel and FD.

context

Information retained between invocations of functionality.

When using a resource manager, the client sets up an association or context within the resource manager by issuing an open() call and getting back a file descriptor. The resource manager is responsible for storing the information required by the context (see OCB). When the client issues further file-descriptor based messages, the resource manager uses the OCB to determine the context for interpretation of the client’s messages.

cooked mode

See canonical mode.

core dump

A file describing the state of a process that terminated abnormally.

critical section

A code passage that must be executed “serially” (i.e. by only one thread at a time).

The simplest from of critical section enforcement is via a mutex.

deadlock

A condition in which one or more threads are unable to continue due to resource contention. A common form of deadlock can occur when one thread sends a message to another, while the other thread sends a message to the first. Both threads are now waiting for each other to reply to the message. Deadlock can be avoided by good design practices or massive kludges — we recommend the good design approach.

device driver

A process that allows the OS and application programs to make use of the underlying hardware in a generic way (e.g. a disk drive, a network interface). Unlike OSs that require device drivers to be tightly bound into the OS itself, device drivers for QNX Neutrino are standard processes that can be started and stopped dynamically. As a result, adding device drivers doesn’t affect any other part of the OS — drivers can be developed and debugged like any other application. Also, device drivers are in their own protected address space, so a bug in a device driver won’t cause the entire OS to shut down.