QtMobility Reference Documentation

Multimedia

Multimedia provides a set of APIs that allow the developer to play, record and manage a collection of media content. It is dependent on the QtMultimediaKit module. QtMultimediaKit is the recommended API to build multimedia applications using Qt. The Phonon API is no longer recommended.

No Special Namespace

Unlike the other APIs in QtMobility, the Multimedia API is not in the QtMobility namespace.

Overview

This API delivers an easy to use interface to multimedia functions. The developer can use the API to display an image, or a video, record sound or play a multimedia stream.

There are several benefits this API brings to Qt. Firstly, the developer can now implement fundamental multimedia functions with minimal code, mostly because they are already implemented. Also there is a great deal of flexibility with the media source or the generated multimedia. The source file does not need to be local to the device, it could be streamed from a remote location and identified by a URL. Finally, many different codecs are supported 'out of the box'.

The supplied examples give a good idea at the ease of use of the API. When the supporting user interface code is ignored we can see that functionality is immediately available with minimal effort.

Audio

The Audio Recorder example is a good introduction to the basic use of the API. We will use snippets from this example to illustrate how to use the API to quickly build functionality.

The first step is to demonstrate recording audio to a file. When recording from an audio source there are a number of things we may want to control beyond the essential user interface. We may want a particular encoding of the file, MP3 or Ogg Vorbis for instance, or select a different input source. The user may modify the bitrate, number of channels, quality and sample rate. Here the example will only modify the codec and the source device, since they are essential.

To begin, the developer sets up a source and a recorder object. A QAudioCaptureSource object is created and used to initialize a QMediaRecorder object. The output file name is then set for the QMediaRecorder object.

 audiosource = new QAudioCaptureSource;
 capture = new QMediaRecorder(audiosource);

 capture->setOutputLocation(QUrl("test.raw"));

A list of devices is needed so that an input can be selected in the user interface

 for(int i = 0; i < audiosource->deviceCount(); i++)
     deviceBox->addItem(audiosource->name(i));

and a list of the supported codecs for the user to select a codec,

 QStringList codecs = capture->supportedAudioCodecs();
 for(int i = 0; i < codecs.count(); i++)
     codecsBox->addItem(codecs.at(i));

To set the selected device or codec just use the index of the device or codec by calling the setter in audiosource or capture as appropriate, for example,

 audiosource->setSelectedDevice(i);
 ...
 capture->setAudioCodec(codecIdx);

Now start recording by using the record() function from the new QMediaRecorder object

 capture->record();

And stop recording by calling the matching function stop() in QMediaRecorder.

 capture->stop();

How then would this audio file be played? The QMediaPlayer class will be used as a generic player. Since the player can play both video and audio files the interface will be more complex, but for now the example will concentrate on the audio aspect.

Playing the file is simple: create a player object, pass in the filename, set the volume or other parameters, then play. Not forgetting that the code will need to be hooked up to the user interface.

 QMediaPlayer *player = new QMediaPlayer;
 ...
 player->setMedia(QUrl::fromLocalFile("test.raw"));
 player->setVolume(50);
 player->play();

The filename does not have to be a local file. It could be a URL to a remote resource. Also by using the QMediaPlaylist class from this API we can play a list of local or remote files. The QMediaPlaylist class supports constructing, managing and playing playlists.

 player = new QMediaPlayer;

 playlist = new QMediaPlaylist(player);
 playlist->addMedia(QUrl("http://example.com/myfile1.mp3"));
 playlist->addMedia(QUrl("http://example.com/myfile2.mp3"));
 ...
 playlist->setCurrentPosition(1);
 player->play();

To manipulate the playlist there are the usual management functions (which are in fact slots): previous, next, setCurrentPosition and shuffle. Playlists can be built, saved and loaded using the API.

Video

Continuing with the example discussed for an Audio recorder/player, we can use this to show how to play video files with little change to the code.

Moving from audio to video requires few changes in the sample code. To play a video playlist the code can be changed to include another new QtMobility Project class: QVideoWidget. This class enables control of a video resource with signals and slots for the control of brightness, contrast, hue, saturation and full screen mode.

 player = new QMediaPlayer;

 playlist = new QMediaPlaylist(player);
 playlist->addMedia(QUrl("http://example.com/myclip1.mp4"));
 playlist->addMedia(QUrl("http://example.com/myclip2.mp4"));
 ...
 widget = new QVideoWidget(player);
 widget->show();

 playlist->setCurrentPosition(1);
 player->play();

The Player example does things a bit differently to our sample code. Instead of using a QVideoWidget object directly, the Player example has a VideoWidget class that inherits from QVideoWidget. This means that functions can be added to provide functions such as full screen display, either on a double click or on a particular keypress.

     videoWidget = new VideoWidget(this);
     player->setVideoOutput(videoWidget);

     playlistModel = new PlaylistModel(this);
     playlistModel->setPlaylist(playlist);

Radio

QRadioTunerControl is a pure virtual base class that will be the basis for any platform specific radio device control. When the functions are implemented the developer will be able to quickly produce an application that supports the typical uses of an FM radio including tuning, volume, start, stop and various other controls.

Extending the API for Symbian and Maemo

For the developer who wishes to extend the functionality of the Multimedia classes there are several classes of particular importance. The default classes are QMediaService, QMediaServiceProvider and QMediaControl.

Basically, the idea is that to use the Multimedia API you would use these three classes or classes derived from them as follows

  • QMediaServiceProvider is used by the top level client class to request a service. The top level class knowing what kind of service it needs.
  • QMediaService provides a service and when asked by the top level object, say a component, will return a QMediaControl object.
  • QMediaControl allows the control of the service using a known interface.

Consider a developer creating, for example, a media player class called MyPlayer. It may have special requirements beyond ordinary media players and so may need a custom service and a custom control. We can subclass QMediaServiceProvider to create our MyServiceProvider class. Also we will create a MyMediaService, and the MyMediaControl to manipulate the media service.

The MyPlayer object calls MyServiceProvider::requestService() to get an instance of MyMediaService. Then the MyPlayer object calls this service object it has just received and calling requestControl() it will receive the control object derived from QMediaControl. Now we have all the parts necessary for our media application. We have the service provider, the service it provides and the control used to manipulate the service. Since our MyPlayer object has instances of the service and its control then it would be possible for these to be used by associated classes that could do additional actions, perhaps with their own control since the parameter to requestControl() is a c-type string, const char *, for the interface.

Adding a Media Service Provider

The base class for creating new service providers is QMediaServiceProvider. The user must implement the requestService() function

 QMediaService* requestService(const QByteArray &type, const QMediaServiceProviderHint &hint);

The details of implementation will depend on the provider. Looking at the class QMediaServiceProvider for the default implementation. Notice that requestService() uses the QMediaServiceProviderHint to look for the appropriate plugin and then to insert it into the plugin map. However, for a specific service provider there is probably no need for this approach, it will simply depend on what the developer wants to implement.

Other methods that may be overloaded

 void releaseService(QMediaService *service);

 QtMediaServices::SupportEstimate hasSupport(const QByteArray &serviceType,
                                     const QString &mimeType,
                                     const QStringList& codecs,
                                     int flags) const;

 QStringList supportedMimeTypes(const QByteArray &serviceType, int flags) const;

 QList<QByteArray> devices(const QByteArray &serviceType) const;

 QString deviceDescription(const QByteArray &serviceType, const QByteArray &device);

The choice of what needs to be done depends on what the developer wishes to do with the service.

Camera Support

Creating still images and video.

Still Images

In order to capture an image we need to create a QCamera object and use it to initialize a QVideoWidget, so we can see where the camera is pointing - a viewfinder. The camera object is also used to initialize a new QCameraImageCapture object, imageCapture. All that is then needed is to start the camera, lock it so that the settings are not changed while the image capture occurs, capture the image, and finally unlock the camera ready for the next photo.

         camera = new QCamera;
         viewFinder = new QCameraViewfinder();
         viewFinder->show();

         camera->setViewfinder(viewFinder);

         imageCapture = new QCameraImageCapture(camera);

         camera->setCaptureMode(QCamera::CaptureStillImage);
         camera->start();

         //on half pressed shutter button
         camera->searchAndLock();

         ...

         //on shutter button pressed
         imageCapture->capture();

         //on shutter button released
         camera->unlock();

Note: Alternatively, we could have used a QGraphicsVideoItem as a viewfinder.

Video Clips

Previously we saw code that allowed the capture of a still image. Recording video requires the use of a QMediaRecorder object and a QAudioCaptureSource for sound.

To record video we need a camera object, as before, a media recorder and a viewfinder object. The media recorder object will need to be initialized.

 camera = new QCamera;
 mediaRecorder = new QMediaRecorder(camera);

 camera->setCaptureMode(QCamera::CaptureVideo);
 camera->start();

 //on shutter button pressed
 mediaRecorder->record();

Signals from the mediaRecorder can be connected to slots to react to changes in the state of the recorder or error events. Recording itself starts with the record() function of mediaRecorder being called, this causes the signal stateChanged() to be emitted. The recording process can be changed with the record(), pause(), stop() and setMuted() slots in QMediaRecorder.

When the camera is in video mode, as decided by the application, then as the shutter button is pressed the camera is locked as before but instead the record() function in QMediaRecorder is used.

Focus

Focusing is managed by the classes QCameraFocus and QCameraFocusControl. QCameraFocus allows the developer to set the general policy by means of the enums for the FocusMode and the FocusPointMode. FocusMode deals with settings such as AutoFocus, ContinuousFocus and InfinityFocus, whereas FocusPointMode deals with the various focus zones within the view. FocusPointMode has support for face recognition, center focus and a custom focus where the focus point can be specified.

Canceling Asynchronous Operations

Various operations such as image capture and auto focusing occur asynchrously. These operations can often be cancelled by the start of a new operation as long as this is supported by the backend. For image capture, the operation can be cancelled by calling cancelCapture(). For auto-focus, auto-exposure or white balance cancellation can be done by calling unlock(QCamera::LockFocus).

Camera Controls

Control NameDescription
cameraThe interface for system camera devices
exposureIncludes: flash mode; flash power; metering mode; aperture; shutter speed, iso setting
focusIncludes: optical zoom; digital zoom; focus point; focus zones
image processingWhite balance; contrast; saturation; sharpen; denoise
locksHandles the locking and unlocking of camera devices

Classes

QCamera

Interface for system camera devices

QCameraCaptureBufferFormatControl

Control for setting the capture buffer format

QCameraCaptureDestinationControl

Control for setting capture destination

QCameraControl

Abstract base class for classes that control still cameras or video cameras

QCameraExposure

Interface for exposure related camera settings

QCameraExposureControl

Supplies control for exposure related camera parameters

QCameraFlashControl

Supplies a camera flash control

QCameraFocus

Interface for focus and zoom related camera settings

QCameraFocusControl

Supplies control for focusing related camera parameters

QCameraImageCaptureControl

Control interface for image capture services

QCameraImageProcessing

Interface for focus and zoom related camera settings

QCameraLocksControl

Abstract base class for classes that control still cameras or video cameras

QCameraViewfinder

Camera viewfinder widget

Examples

Record a Sound Source

AudioRecorder is a demonstration of the discovery of the supported devices and codecs and the use of recording functions in the QMediaRecorder class.

Play a Media File

The Player example is a simple multimedia player. Select a video file to play, stop, pause, show in fullscreen or manipulate various image attributes using the Color Options button.

Slide Show

The Slide Show shows the use of the QMediaImageViewer and QVideoWidget classes.

Camera Example

The Camera Example shows how use the QtMultimediaKit API to quickly write a camera application in C++.

QML Camera Example

The QML Camera Example demonstrates still image capture and controls using the QML plugin. Video recording is not currently available.

Reference documentation

Main classes

QAudio

Contains enums used by the audio classes

QAudioCaptureSource

Interface to query and select an audio input endpoint

QAudioDeviceInfo

Interface to query audio devices and their functionality

QAudioEncoderControl

Access to the settings of a media service that performs audio encoding

QAudioEncoderSettings

Set of audio encoder settings

QAudioEndpointSelector

Audio endpoint selector media control

QAudioFormat

Stores audio parameter information

QAudioInput

Interface for receiving audio data from an audio input device

QAudioOutput

Interface for sending audio data to an audio output device

QCameraImageCapture

Used for the recording of media content

QGraphicsVideoItem

Graphics item which display video produced by a QMediaObject

QImageEncoderControl

Access to the settings of a media service that performs image encoding

QMediaBindableInterface

The base class for objects extending media objects functionality

QMediaContainerControl

Access to the output container format of a QMediaService

QMediaContent

Access to the resources relating to a media content

QMediaControl

Base interface for media service controls

QMediaImageViewer

Means of viewing image media

QMediaNetworkAccessControl

Allows the setting of the Network Access Point for media related activities

QMediaObject

Common base for multimedia objects

QMediaPlayer

Allows the playing of a media source

QMediaPlayerControl

Access to the media playing functionality of a QMediaService

QMediaPlaylist

List of media content to play

QMediaPlaylistControl

Access to the playlist functionality of a QMediaService

QMediaPlaylistNavigator

Navigation for a media playlist

QMediaPlaylistSourceControl

Access to the playlist playback functionality of a QMediaService

QMediaRecorder

Used for the recording of media content

QMediaRecorderControl

Access to the recording functionality of a QMediaService

QMediaResource

Description of a media resource

QMediaService

Common base class for media service implementations

QMediaServiceProviderHint

Describes what is required of a QMediaService

QMediaStreamsControl

Media stream selection control

QMediaTimeInterval

Represents a time interval with integer precision

QMediaTimeRange

Represents a set of zero or more disjoint time intervals

QMetaDataWriterControl

Write access to the meta-data of a QMediaService's media

QRadioTuner

Interface to the systems analog radio device

QRadioTunerControl

Access to the radio tuning functionality of a QMediaService

QVideoDeviceControl

Video device selector media control

QVideoEncoderControl

Access to the settings of a media service that performs video encoding

QVideoRendererControl

Control for rendering to a video surface

QVideoWidget

Widget which presents video produced by a media object

QVideoWidgetControl

Media control which implements a video widget

QVideoWindowControl

Media control for rendering video to a window

QtMultimediaKit

Contains miscellaneous identifiers used throughout the Qt Media services library

Classes for service implementers.

QCameraImageProcessingControl

Abstract class for controlling image processing parameters, like white balance, contrast, saturation, sharpening and denoising

QMetaDataReaderControl

Read access to the meta-data of a QMediaService's media

QML Elements

X

Thank you for giving your feedback.

Make sure it is related to this specific page. For more general bugs and requests, please use the Qt Bug Tracker.

[0]; s.parentNode.insertBefore(ga, s); })();