#include "devvideorecord.h"
class CMMFDevVideoRecord : public CBase |
CMMFDevVideoRecord is the main client class of DevVideoRecord.
IMPORT_C void | CancelSupplementalInfo | ( | ) |
IMPORT_C HBufC8 * | CodingStandardSpecificInitOutputLC | ( | ) |
Returns coding-standard specific initialization output from the encoder. The information can contain, for example, the MPEG-4 VOL header. This method can be called after Initialize() has been called.
Returns: "Coding-standard specific initialization output. The data format is coding-standard specific and defined separately. The buffer is pushed to the cleanup stack, and the caller is responsible for deallocating it."
IMPORT_C HBufC8 * | CodingStandardSpecificSettingsOutputLC | ( | ) |
Returns coding-standard specific settings output from the encoder. The information can contain, for example, some bitstream headers that can change based on settings modified while encoding is in progress.
Returns: "Coding-standard specific output. The data format is coding-standard specific and defined separately. The buffer is pushed to the cleanup stack, and the caller is responsible for deallocating it."
IMPORT_C void | CommitL | ( | ) |
Commit all configuration changes since the last CommitL(), Revert() or Initialize(). This only applies to methods that can be called both before AND after DevVideoRecord has been initialized. See the following methods for details.
See also: SetOutputRectL SetPreProcessTypesL SetRotateOptionsL SetScaleOptionsL SetInputCropOptionsL SetOutputCropOptionsL SetOutputPadOptionsL SetColorEnhancementOptionsL SetFrameStabilisationOptionsL SetCustomPreProcessOptionsL SetCodingStandardSpecificOptionsL SetImplementationSpecificEncoderOptionsL
IMPORT_C TAny * | CustomInterface | ( | THwDeviceId | aHwDevice, |
TUid | aInterface | |||
) |
Retrieves a custom interface to the specified hardware device.
Parameter | Description |
---|---|
aHwDevice | "The hardware device from which the custom interface shall be requested. The value is returned from SelectDecoderL() or SelectPostProcessorL() when the device is selected." @param "aInterface" "Interface UID, defined with the custom interface." @return "Pointer to the interface implementation, or NULL if the device does not implement the interface requested. The return value must be cast to the correct type by the user." |
IMPORT_C void | FindEncodersL | ( | const TDesC8 & | aMimeType, |
TUint32 | aPreProcType, | |||
RArray< TUid > & | aEncoders, | |||
TBool | aExactMatch = ETrue | |||
) |
Finds all available encoders for a given video type with support for certain pre-processing operations. The video type is specified using its MIME type, which may include parameters specifying the supported level, version, and other information. Encoder hardware devices can use wildcards when listing the supported video types in the ECom registration information, so it is possible that all the encoders returned do not support the specified submode, e.g. profile and level, unless aExactMatch is set.
The encoder capabilities can be checked with VideoEncoderInfoLC().
Parameter | Description |
---|---|
aMimeType | "The video type that will be encoded." |
aPreProcType | "The pre-processing types that the encoder has to support, a binary OR of TPrePostProcessType values. If no pre-processing support is needed, set this value to zero." @param "aEncoders" "An array for the result encoder UIDs. The array must be created and destroyed by the caller." @param "aExactMatch" "True if exact matching should be used. In this case only encoders that support exactly the MIME-type given will be returned. Since verifying this may require loading the encoders into memory, this can be a fairly expensive operation, and if the user needs to verify their capabilities further in any case this parameter should be set to EFalse." |
Finds all available pre-processors for a given set of pre-processing operations.
Parameter | Description |
---|---|
aPreProcType | "The pre-processing types that the device has to support, a binary OR of TPrePostProcessType values." |
aPreProcessors | "An array for the result pre-processor UIDs. The array must be created and destroyed by the caller." |
IMPORT_C void | Freeze | ( | ) |
Freezes the input picture. Freezing is similar to a pause, except that timestamps are incremented normally during a freeze. Normal encoding can be continued using ReleaseFreeze().
Parameter | Description |
---|---|
aEncoders | "An array for the result encoder UIDs. The array must be created and destroyed by the caller." |
IMPORT_C void | GetFrameStabilisationOutput | ( | THwDeviceId | aHwDevice, |
TRect & | aRect | |||
) |
Reads the frame stabilisation output picture position. This information can be used for positioning the viewfinder. The position returned is the stabilisation result for the most recent input picture.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to query. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aRect | "The position of the stabilisation output picture inside the input picture. If frame stabilisation is not used, the rectangle is set to cover the entire input picture." @pre "This method can only be called after the API has been initialized with Initialize()." |
Gets the current output buffer status. The information includes the number of free output buffers and the total size of free buffers in bytes.
Parameter | Description |
---|---|
aNumFreeBuffers | "Target for the number of free output buffers." |
aTotalFreeBytes | "Target for the total free buffer size in bytes." |
IMPORT_C void | GetPictureCounters | ( | TPictureCounters & | aCounters | ) |
Reads various counters related to processed video pictures. See the definition of TPictureCounters for a description of the counters. The counters are reset when Initialize() or this method is called, and thus they only include pictures processed since the last call.
Parameter | Description |
---|---|
aCounters | "The counter structure to fill." |
Parameter | Description |
---|---|
aPreProcessors | "An array for the result pre-processor UIDs. The array must be created and destroyed by the caller." |
IMPORT_C HBufC8 * | ImplementationSpecificInitOutputLC | ( | ) |
Returns implementation-specific initialization output from the encoder. This method can be called after Initialize() has been called.
Returns: "Implementation-specific initialization output. The data format is specific to the encoder implementation, and defined by the encoder supplier. The buffer is pushed to the cleanup stack, and the caller is responsible for deallocating it."
IMPORT_C HBufC8 * | ImplementationSpecificSettingsOutputLC | ( | ) |
Returns implementation-specific settings output from the encoder. The information can contain, for example, some bitstream headers that can change based on settings modified while encoding is in progress.
Returns: "Implementation-specific initialization output. The data format is implementation-specific and defined separately by the encoder supplier. The buffer is pushed to the cleanup stack, and the caller is responsible for deallocating it."
IMPORT_C void | Initialize | ( | ) |
Initializes the video devices, and reserves hardware resources. This method is asynchronous, DevVideoRecord will call MMMFDevVideoRecordObserver::MdvroInitializeComplete() after initialization has completed. If direct capture is used, this method also prepares the camera API for capture by calling PrepareVideoCaptureL(). No DevVideoRecord method may be called while initialization is in progress, the initialization process can only be cancelled by destroying the DevVideoRecord object.
After initialization has successfully been completed, video capturing and encoding can be started with Start() with a relatively low delay since the hardware has already been set up.
If Initialize() fails, the DevVideoRecord object must be destroyed, and set up from scratch.
KErrHardwareNotAvailable - Not enough free video processing hardware resources
KErrNotSupported - The current configuration is not supported.
IMPORT_C void | InputEnd | ( | ) |
Notifies the system that the end of input data has been reached. No more input data can be written through the API. The encoder and pre-processor can use this signal to ensure that the remaining data gets processed, without waiting for new data. After the remaining data has been processed, the client gets notified by the MdvroStreamEnd() callback.
IMPORT_C CMMFDevVideoRecord * | NewL | ( | MMMFDevVideoRecordObserver & | aObserver | ) | [static] |
KErrHardwareNotAvailable - Not enough free video processing hardware resources
KErrNoMemory - Not enough free memory available"
Parameter | Description |
---|---|
aObserver | "The observer object to use. The observer callbacks are used to return input buffers back to the client." |
Returns: "A new CMMFDevVideoRecord object.
IMPORT_C TVideoOutputBuffer * | NextBufferL | ( | ) |
Retrieves the next output buffer, in coding order. The buffer must be returned using ReturnBuffer() when it is no longer used. The maximum amount of buffers that the caller can keep in its use is controlled by the iMinNumOutputBuffers and iMinTotalOutputBufferSize fields in the TEncoderBufferOptions settings.
Returns: "The next output buffer, in coding order. If no new buffers are available, the return value is NULL."
IMPORT_C TUint | NumComplexityLevels | ( | THwDeviceId | aHwDevice | ) |
Retrieves the number of complexity control levels available for a hardware device. Devices can support processing the same input data with different computational complexity levels. The complexity level can affect, for example, the motion vector search range used in an encoder.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
Returns: "The number of complexity control levels available, one if multiple levels are not supported."
IMPORT_C TUint | NumDataBuffers | ( | ) |
Returns the number of output buffers currently containing valid output data.
Returns: "The number of output buffers with valid output data."
IMPORT_C void | Pause | ( | ) |
Pauses video recording. Recording can be resumed using Resume().
While video is paused, new pictures are not captured, and input pictures written using WritePictureL() are discarded. Timestamps are not incremented - the encoder assumes that the clock source is paused as well, and input picture timestamps are adjusted accordingly. Pause is typically used in video recording applications to pause recording, conversational applications should use Freeze() instead.
IMPORT_C void | PictureLoss | ( | ) |
IMPORT_C void | PictureLoss | ( | const TArray< TPictureId > & | aPictures | ) |
Indicates to the encoder the pictures that have been lost. The encoder can react to this by transmitting an intra-picture.
Parameter | Description |
---|---|
aPictures | "Picture identifiers for the lost pictures. See [6] for a definition of TPictureId." |
IMPORT_C CPreProcessorInfo * | PreProcessorInfoLC | ( | TUid | aPreProcessor | ) |
Parameter | Description |
---|---|
aPreProcessor | "The device to query." |
Returns: "Pre-processor information as a CPreProcessorInfo object. The object is pushed to the cleanupstack, and must be deallocated by the caller."
IMPORT_C TTimeIntervalMicroSeconds | RecordingPosition | ( | ) |
Returns the current recording position. The position is the capture timestamp from the latest input picture, or the capture timestamp for the latest picture captured from the camera when direct capture is used.
Returns: "The current recording position."
IMPORT_C void | ReferencePictureSelection | ( | const TDesC8 & | aSelectionData | ) |
Sends a reference picture selection request to the encoder. The request is delivered as a coding-standard specific binary message. Reference picture selection can be used to select a previous correctly transmitted picture to use as a reference in case later pictures have been lost.
Parameter | Description |
---|---|
aSelectionData | "The reference picture selection request message. The message format is coding-standard specific, and defined separately." |
IMPORT_C void | ReleaseFreeze | ( | ) |
IMPORT_C void | Resume | ( | ) |
IMPORT_C void | ReturnBuffer | ( | TVideoOutputBuffer * | aBuffer | ) |
Returns a used output buffer back to the encoder. The buffer can no longer be used by the client.
Parameter | Description |
---|---|
aBuffer | "The buffer to return." |
IMPORT_C void | Revert | ( | ) |
Revert any configuration changes that have not yet been committed using CommitL(). This only applies to methods that can be called both before AND after DevVideoRecord has been initialized. See the following methods for details.
See also: SetOutputRectL SetPreProcessTypesL SetRotateOptionsL SetScaleOptionsL SetInputCropOptionsL SetOutputCropOptionsL SetOutputPadOptionsL SetColorEnhancementOptionsL SetFrameStabilisationOptionsL SetCustomPreProcessOptionsL SetCodingStandardSpecificOptionsL SetImplementationSpecificEncoderOptionsL
IMPORT_C THwDeviceId | SelectEncoderL | ( | TUid | aEncoder | ) |
Selects the video encoder to be used. This method must be called before any other video encoder related methods are used. The encoder can be changed by calling this method again before the system has been initialized with Initialize().
All video encoder settings are reset to their default values. By default no pre-processing is performed.
Parameter | Description |
---|---|
aEncoder | "The video encoder to use." |
Returns: "Hardware device ID, used in other methods for configuring the encoder."
IMPORT_C THwDeviceId | SelectPreProcessorL | ( | TUid | aPreProcessor | ) |
Selects the video pre-processor to be used. This method must be called before any other pre-processor related methods are used. The pre-processor to use can be changed by calling this method again before the API has been initialized with Initialize().
All pre-processor settings are reset to their default values. By default no pre-processing is performed.
Parameter | Description |
---|---|
aPreProcessor | "The pre-processor to use." |
Returns: "Hardware device ID, used in other methods for configuring the pre-processor."
IMPORT_C void | SendSupplementalInfoL | ( | const TDesC8 & | aData | ) |
Requests the encoder to sends supplemental information in the bitstream. The information data format is coding-standard dependent. Only one supplemental information send request can be active at a time. This variant encodes the information to the next possible picture.
Parameter | Description |
---|---|
aData | "Supplemental information data to send. The buffer can be reused immediately after the method returns." |
IMPORT_C void | SendSupplementalInfoL | ( | const TDesC8 & | aData, |
const TTimeIntervalMicroSeconds & | aTimestamp | |||
) |
Requests the encoder to send supplemental information in the bitstream. The information data format is coding-standard dependent. Only one supplemental information send request can be active at a time. This variant encodes the information to the picture whose presentation timestamp is equal to or greater than and closest to the value of aTimestamp.
Parameter | Description |
---|---|
aData | "Supplemental information data to send. The buffer can be reused immediately after the method returns." |
aTimestamp | "Timestamp for the picture in which the supplemental information should be included. If the timestamp is in the past, the supplemental information will not be sent." |
IMPORT_C void | SetBufferOptionsL | ( | const TEncoderBufferOptions & | aOptions | ) |
Sets encoder buffering options.
Parameter | Description |
---|---|
aOptions | "The buffering options." |
Sets the expected or prevailing channel conditions for an unequal error protection level, in terms of expected bit error rate. The video encoder can use this information to optimize the generated bitstream.
Parameter | Description |
---|---|
aLevel | "Error protection level number. This argument is ignored if unequal error protection is not in use." |
aErrorRate | "Expected bit error rate, as a fraction of the total bits transmitted. Set to 0.0 if bit errors are not expected." |
aStdDeviation | "Expected bit error rate standard deviation." |
IMPORT_C void | SetChannelPacketLossRate | ( | TUint | aLevel, |
TReal | aLossRate, | |||
TTimeIntervalMicroSeconds32 | aLossBurstLength | |||
) |
Sets the expected or prevailing channel conditions for an unequal error protection level, in terms of expected packet loss rate. The video encoder can use this information to optimize the generated bitstream.
Parameter | Description |
---|---|
aLevel | "Error protection level number. This argument is ignored if unequal error protection is not in use." |
aLossRate | "Packet loss rate, in number of packets lost per second. Set to 0.0 if packet losses are not expected." |
aLossBurstLength | "Expected average packet loss burst length. Set to zero if the information is not available." |
IMPORT_C void | SetClockSource | ( | MMMFClockSource * | aClock | ) |
Sets the clock source to use for video timing. When video recording is synchronized with audio, the clock source is implemented by the audio playback subsystem, otherwise the clock source should get the time from the system clock. This method can be called after all hardware devices have been selected, but before calling Initialize().
If no clock source is set, video recording will not be synchronized, but will proceed as fast as possible, depending on input data and output buffer availability. If direct capturing is used without a clock source, the timestamps in the output data may not be valid. All encoders must support synchronization with an external clock source, as well as unsynchronized non-realtime operation.
Parameter | Description |
---|---|
aClock | "The clock source to use." |
IMPORT_C void | SetCodingStandardSpecificOptionsL | ( | const TDesC8 & | aOptions | ) |
Sets coding-standard specific encoder options.
Parameter | Description |
---|---|
aOptions | "The options to use. The data format for the options is coding-standard specific, and defined seperately." |
IMPORT_C void | SetColorEnhancementOptionsL | ( | THwDeviceId | aHwDevice, |
const TColorEnhancementOptions & | aOptions | |||
) |
Sets color enhancement pre-processing options.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aOptions | "Color enchancement options." |
IMPORT_C void | SetComplexityLevel | ( | THwDeviceId | aHwDevice, |
TUint | aLevel | |||
) |
Sets the complexity level to use for video processing in a hardware device. The level can be changed at any time.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aLevel | "The computational complexity level to use. Level zero (0) is the most complex one, with the highest quality. Higher level numbers require less processing and may have lower quality." @pre "This method can only be called after the API has been initialized with Initialize()." |
IMPORT_C void | SetCustomPreProcessOptionsL | ( | THwDeviceId | aHwDevice, |
const TDesC8 & | aOptions | |||
) |
Sets custom implementation-specific pre-processing options.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aOptions | "Post-processing options. The data format is implementation-specific." |
Sets up an unequal error protection level. If unequal error protection is not used, this method can be used to control settings for the whole encoded bitstream.
Parameter | Description |
---|---|
aLevel | "Error protection level number. This argument is ignored if unequal error protection is not in use." |
aBitrate | "Target bit-rate for this error protection level." |
aStrength | "Forward error control strength for this error protection level. The strength can be specified using values from TErrorControlStrength (EFecStrengthNone, EFecStrengthLow, EFecStrengthNormal, EFecStrengthHigh), or with intermediate values between those constants." |
Sets the number of unequal error protection levels. By default unequal error protection is not used.
Parameter | Description |
---|---|
aNumLevels | "The number of unequal error protection levels. To disable unequal error protection, set this value to one. When unequal error protection is used, the encoder should code pictures so that they can be divided into number of unequal error protection levels having an ascending order of importance in the quality of decoded pictures, with level zero indicating the least important level. The encoder should map the requested bit-rate scalability layers and in-layer bit-rate scalability steps to the unequal error protection levels. In addition, the encoder may use coded sub-pictures to divide coded pictures to different regions of interest or data partitions to divide coded segments into pieces of different importance." @param "aSeparateBuffers" "True if each unequal error protection level of a coded data unit shall be encapsulated in its own output buffer. Ignored if unequal error protection is not used. If each unequal error protection level (e.g. a data partition) of coded data unit is encapsulated in its own output buffer, the caller can transmit the output buffers in different logical channels or can apply a different amount of application-level forward error coding for different output buffers. If all unequal error protection levels (e.g. data partitions) of coded data unit are encapsulated in the same output buffer, the caller can apply a forward error control mechanism that protects the beginning of the output buffer better than the remaining of the output buffer." |
Sets whether bit errors or packets losses can be expected in the video transmission channel. The video encoder can use this information to optimize the bitstream.
Parameter | Description |
---|---|
aBitErrors | "True if bit errors can be expected." |
aPacketLosses | "True if packet losses can be expected." |
IMPORT_C void | SetFrameStabilisationOptionsL | ( | THwDeviceId | aHwDevice, |
const TSize & | aOutputSize, | |||
TBool | aFrameStabilisation | |||
) |
Sets frame stabilisation options.
Frame stabilisation is performed as the first pre-processing operation in the hardware device. The stabilisation process gets the complete hardware device input picture as its input, and it produces a smaller stabilised output picture. The rest of the processing in the hardware device is done using the stabilisation output picture.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aOutputSize | "Output picture size. The output picture must size must be smaller than or equal to the hardware device input picture size." |
aFrameStabilisation | "True if frame stabilisation should be used. By default stabilisation is not used." |
Sets the reference picture options to be used for all scalability layers. The settings can be overridden for an individual scalability layer by using SetLayerReferenceOptions().
Parameter | Description |
---|---|
aMaxReferencePictures | "The maximum number of reference pictures to be used. More than one reference frame can be used in the H.264 | MPEG-4 AVC and in some advanced profiles of MPEG-4 Part 2 and H.263. The minimum value is one." @param "aMaxPictureOrderDelay" "The maximum picture order delay, in number of pictures. This specifies the maximum number of pictures that precede any picture in the sequence in decoding order and follow the picture in presentation order. Pictures may be coded/decoded in different order from their capture/display order. Thus, decoded pictures have to be buffered to order them in correct display order. For example, if one conventional B picture is coded between P pictures, a one-picture display ordering delay has to be applied in the decoder. The minimum value is zero, which indicates that pictures must be coded in capture/display order." @pre "This method can only be called before the API has been initialized with Initialize()." |
IMPORT_C void | SetImplementationSpecificEncoderOptionsL | ( | const TDesC8 & | aOptions | ) |
Sets implementation-specific encoder options.
Parameter | Description |
---|---|
aOptions | "The options to use. The data format for the options is specific to the encoder implementation, and defined separately by the encoder implementor." |
IMPORT_C void | SetInLayerScalabilityL | ( | TUint | aLayer, |
TUint | aNumSteps, | |||
TInLayerScalabilityType | aScalabilityType, | |||
const TArray< TUint > & | aBitrateShare, | |||
const TArray< TUint > & | aPictureShare | |||
) |
Sets in-layer scalability options for a layer. In-layer bit-rate scalability refers to techniques where a specific part of a single-layer coded stream can be decoded correctly without decoding the leftover part. For example, B-pictures can be used for this. By default in-layer scalability is not used.
KErrNotSupported - In-layer scalability is not supported.
KErrArgument - Some of the arguments are out of range. For example, it is not possible to use the specified in-layer scalability setup due to other constraints (such as the maximum picture order delay)." @pre "This method can only be called after the API has been initialized with Initialize()."
Parameter | Description |
---|---|
aLayer | "Layer number. Layers are numbered [0 n-1], where n is the number of layers available. Use zero if layered bit-rate scalability is not used." |
aNumSteps | "The number of in-layer scalability steps to use. Set to one to disable in-layer scalability." |
aScalabilityType | "The scalability type to use. See the definition of TInLayerScalabilityType for more information." |
aBitrateShare | "Bit-rate share for each scalability step. The bit-rate shares are defined as fractions of total layer bit-rate, with the share for one layer being aBitrateShare[i]/sum(aBitrateShare). For example, to use 2/3 of the total bitrate for the first layer and the remaining 1/3 for the second, the array contents would be {2,1}." @param "aPictureShare" "Picture rate share for each scalability step. The picture rate shares are defined similarly to the bit-rate shares. For example, a client wishing to use two B-pictures between each pair of reference pictures should set the array contents to {1,2}." |
IMPORT_C void | SetInputCropOptionsL | ( | THwDeviceId | aHwDevice, |
const TRect & | aRect | |||
) |
Sets pre-processing options for input cropping. Input cropping is typically used for digital zooming.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aRect | "The input cropping rectangle specifying the area of the picture to use. The rectangle must fit completely inside the input picture." |
IMPORT_C void | SetInputFormatL | ( | THwDeviceId | aHwDevice, |
const TUncompressedVideoFormat & | aFormat, | |||
const TSize & | aPictureSize | |||
) |
Sets the input format for a hardware device. If both a pre-processor and an encoder are used, the pre-processor output format and the encoder input format must be the same. The input format for the first device in the system is the input format for video input data.
The method has to be called for both direct capture as well as memory buffer input. The camera API must be initialized by the device using it for capture, since there is no way to query the current format from the camera API.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aFormat | "The input format to use." |
aPictureSize | "The input picture size in pixels." |
Sets the period for layer promotions points for a scalability layer. A layer promotion point is a picture where it is possible to start encoding this enhancement layer if only the lower layers were encoded earlier.
Parameter | Description |
---|---|
aLayer | "Layer number." |
aPeriod | "Layer promotion point period. A value of one signals that each picture should be a layer promotion point, value two that there is one picture between each promotion point etc." @pre "This method can only be called after the API has been initialized with Initialize()." |
IMPORT_C void | SetLayerReferenceOptions | ( | TUint | aLayer, |
TUint | aMaxReferencePictures, | |||
TUint | aMaxPictureOrderDelay | |||
) |
Sets the reference picture options to be used for a single scalability layer. These settings override those set with SetGlobalReferenceOptions().
Parameter | Description |
---|---|
aLayer | "Layer number." |
aMaxReferencePictures | "The maximum number of reference pictures to be used." |
aMaxPictureOrderDelay | "The maximum picture order delay, in number of pictures." |
IMPORT_C void | SetMinRandomAccessRate | ( | TReal | aRate | ) |
Sets the minimum frequency (in time) for instantaneous random access points in the bitstream. An instantaneous random access point is such where the encoder can achieve a full output picture immediately by encoding data starting from the random access point. The random access point frequency may be higher than signalled, if the sequence contains scene cuts which typically cause a coding of a random access point.
Parameter | Description |
---|---|
aRate | "Random access point rate, in pictures per second. For example, to request a random access point every ten seconds, set the value to 0.1." |
IMPORT_C void | SetNumBitrateLayersL | ( | TUint | aNumLayers | ) |
Sets the number of bit-rate scalability layers to use. Set to 1 to disable layered scalability.
Bit-rate scalability refers to the ability of a coded stream to be decoded at different bit-rates. Scalable video is typically ordered into hierarchical layers of data. A base layer contains an individual representation of a video stream and enhancement layers contain refinement data in addition to the base layer. The quality of the encoded video stream progressively improves as enhancement layers are added to the base layer.
Parameter | Description |
---|---|
aNumLayers | "The number of bit-rate scalability layers to use, set to 1 to disable scalability." |
IMPORT_C void | SetOutputCropOptionsL | ( | THwDeviceId | aHwDevice, |
const TRect & | aRect | |||
) |
Sets pre-processing options for output cropping. Output cropping is performed after other pre-processing operations but before output padding. Output cropping and padding can be used in combination to prepare the picture size to suit the encoder, typically video encoders only support picture sizes that are multiples of 16 pixels.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aRect | "The output cropping rectangle specifying the area of the picture to use. The rectangle must fit completely inside the picture." |
IMPORT_C void | SetOutputFormatL | ( | THwDeviceId | aHwDevice, |
const CCompressedVideoFormat & | aFormat, | |||
TVideoDataUnitType | aDataUnitType, | |||
TVideoDataUnitEncapsulation | aDataEncapsulation, | |||
TBool | aSegmentationAllowed = EFalse | |||
) |
Sets the output format for a hardware device to a compressed video format. Only applicable for encoder devices. The picture size depends on the input data format and possible scaling performed.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL()when the device is selected." |
aFormat | "The video format to use." |
aDataUnitType | "The type of output coded data units." |
aDataEncapsulation | "Data encapsulation type for output encoded data units." |
aSegmentationAllowed | "True if a coded data unit can be segmented into multiple output buffers if a single buffer is not large enough." |
IMPORT_C void | SetOutputFormatL | ( | THwDeviceId | aHwDevice, |
const TUncompressedVideoFormat & | aFormat | |||
) |
Sets the output format for a hardware device to an uncompressed video format. Only applicable for pre-processor devices. The picture size depends on the input data format and possible scaling performed.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectPreProcessorL() when the device is selected." |
aFormat | "The video format to use." |
IMPORT_C void | SetOutputPadOptionsL | ( | THwDeviceId | aHwDevice, |
const TSize & | aOutputSize, | |||
const TPoint & | aPicturePos | |||
) |
Sets pre-processing options for output padding. Output padding is performed as the last pre-processing operation, and typically used to prepare the picture size to suit the encoder. The image is padded with black pixels.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aOutputSize | "The padded output picture size. The output size must be large enough for the picture in its new position." |
aPicturePos | "The position for the original picture in the new padded picture. The original picture in its new position must fit completely inside the new picture." |
IMPORT_C void | SetOutputRectL | ( | THwDeviceId | aHwDevice, |
const TRect & | aRect | |||
) |
Sets the encoder output rectangle for encoded video output. This rectangle specifies the part of the input and output pictures which is displayed after encoding. Many video codecs process data in 16x16 pixel units but enable specifying and coding the decoder output rectangle for image sizes that are not multiple of 16 pixels (e.g 160x120).
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() when the device is selected." |
aRect | "The encoder output rectangle." |
IMPORT_C void | SetPreProcessTypesL | ( | THwDeviceId | aHwDevice, |
TUint32 | aPreProcessTypes | |||
) |
Sets the pre-processing types to be used in a hardware device. [1 #191] If separate encoder and pre-processor devices are used, both can be configured to perform different pre-processing operations.
Pre-processing operations are carried out in the following order:
1. Frame stabilisation 2. Input cropping 3. Mirroring 4. Rotating 5. Scaling 6. Output cropping 7. Output padding
Color space conversion and color enhancement can be performed at any point in the pre-processing flow.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aPreProcessTypes | "The pre-processing steps to perform, a bitwise OR of values from TPrePostProcessType." |
IMPORT_C void | SetRateControlOptions | ( | TUint | aLayer, |
const TRateControlOptions & | aOptions | |||
) |
Sets the bit-rate control options for a layer. If layered bit-rate scalability is not used, the options are set for the whole bitstream.
Parameter | Description |
---|---|
aLayer | "Layer number. Layers are numbered [0 n-1], where n is the number of layers available. Use zero if layered bit-rate scalability is not used." |
aOptions | "Bit-rate control options." |
IMPORT_C void | SetRgbToYuvOptionsL | ( | THwDeviceId | aHwDevice, |
TRgbRange | aRgbRange, | |||
const TYuvFormat & | aOutputFormat | |||
) |
Sets pre-processing options for RGB to YUV color space conversion. By default, input RGB data is assumed to use the full value range ([0 255]), and the output YUV format is the hardware device output format, so typically calling this method is not necessary.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aRgbRange | "Input RGB data range" |
aOutputFormat | "Conversion output YUV format." |
IMPORT_C void | SetRotateOptionsL | ( | THwDeviceId | aHwDevice, |
TRotationType | aRotationType | |||
) |
Sets pre-processing options for rotation.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aRotationType | "The rotation to perform." |
IMPORT_C void | SetScalabilityLayerTypeL | ( | TUint | aLayer, |
TScalabilityType | aScalabilityType | |||
) |
Sets the scalability type for a bit-rate scalability layer.
Parameter | Description |
---|---|
aLayer | "Layer number. Layers are numbered [0 n-1], where n is the number of layers available. The first layer is the base layer, it can be decoded independently from the other layers, and it has the lowest total bitrate." @param "aScalabilityType" "Layer scalability type." |
IMPORT_C void | SetScaleOptionsL | ( | THwDeviceId | aHwDevice, |
const TSize & | aTargetSize, | |||
TBool | aAntiAliasFiltering | |||
) |
Sets pre-processing options for scaling.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aTargetSize | "Target picture size. If a fixed scale factor size is used, the new dimensions must be set to: width=floor(factor*width), height=floor(factor*height). For example, scaling a QCIF (176x144) picture up by a factor of 4/3 yields a size of 234x192." @param "aAntiAliasFiltering" "True if anti-aliasing filtering should be used. If the pre-processor does not support anti-aliased scaling, or supports anti-aliased scaling only, this argument is ignored." |
Sets the target size of each coded video segment. The segment target size can be specified in terms of number of bytes per segment, number of macroblocks per segment, or both.
Parameter | Description |
---|---|
aLayer | "Layer number. Layers are numbered [0 n-1], where n is the number of layers available. Use zero if layered bit-rate scalability is not used." |
aSizeBytes | "Segment target size in bytes. Set to zero to use unlimited segment size. The segment size in bytes should include all data that is typically stored or transmitted for each segment in the format currently in use. This includes all related headers." @param "aSizeMacroblocks" "Segment target size in number of macroblocks per segment. Set to zero to use unlimited segment size." @pre "This method can only be called after the API has been initialized with Initialize()." |
Sets the data source to be a camera, and sets the system to use direct capture for input. The first hardware device (pre-processor if both encoder and pre-processor are used, encoder otherwise) must support direct capture.
KErrNotSupported - Direct capture is not supported or the picture rate specified is not supported." @pre "This method can only be called before the API has been initialized with Initialize()."
Parameter | Description |
---|---|
aCameraHandle | "A camera handle for the camera to use. The handle is passed to CCamera::NewDuplicateL() in the camera API." |
aPictureRate | "Video capture picture rate." |
IMPORT_C void | SetSourceMemoryL | ( | TReal | aMaxPictureRate, |
TBool | aConstantPictureRate, | |||
TBool | aProcessRealtime | |||
) |
Sets the data source to be memory buffers.
Parameter | Description |
---|---|
aMaxPictureRate | "The maximum picture rate for input pictures." |
aConstantPictureRate | "True if the input picture rate is constant. In that case, aMaxPictureRate specifies the picture rate. If pictures may be skipped in the input data due to performance reasons, this flag cannot be set." @param "aProcessRealtime" "True if real-time processing is needed, false if not. Real-time processing is typically needed for video recording applications, while video conversion and off-line processing applications do not require it." |
IMPORT_C void | SetYuvToYuvOptionsL | ( | THwDeviceId | aHwDevice, |
const TYuvFormat & | aInputFormat, | |||
const TYuvFormat & | aOutputFormat | |||
) |
Sets pre-processing options for YUV to YUV data format conversion. By default, the hardware device input and output data formats are used. For encoder devices, the device input format and the closest matching format supported by the encoding process are used. Typically calling this method is not necessary.
Parameter | Description |
---|---|
aHwDevice | "The hardware device to configure. The value is returned from SelectEncoderL() or SelectPreProcessorL() when the device is selected." |
aInputFormat | "Conversion input format." |
aOutputFormat | "Conversion output format." |
IMPORT_C void | SliceLoss | ( | TUint | aFirstMacroblock, |
TUint | aNumMacroblocks, | |||
const TPictureId & | aPicture | |||
) |
Indicates a loss of consecutive macroblocks in raster scan order to the encoder.
Parameter | Description |
---|---|
aFirstMacroblock | "The first lost macroblock. The macroblocks are numbered such that the macroblock in the upper left corner of the picture is considered macroblock number 1 and the number for each macroblock increases from left to right and then from top to bottom in raster-scan order." @param "aNumMacroblocks" "The number of lost macroblocks that are consecutive in raster scan order." @param "aPicture" "The picture number for the picture where the macroblocks were lost. If the picture is not known, aPicture.iIdType is set to ENone." @pre "This method can only be called after the API has been initialized with Initialize()." |
IMPORT_C void | Start | ( | ) |
IMPORT_C void | Stop | ( | ) |
IMPORT_C CVideoEncoderInfo * | VideoEncoderInfoLC | ( | TUid | aVideoEncoder | ) |
Parameter | Description |
---|---|
aVideoEncoder | "The video encoder device to query." |
Returns: "Encoder information as a CVideoEncoderInfo object. The object is pushed to the cleanup stack, and must be deallocated by the caller."
IMPORT_C void | WritePictureL | ( | TVideoPicture * | aPicture | ) |
Writes an uncompressed input picture. The picture must remain valid and unmodified until it is returned with the MdvroReturnPicture() callback. This method must not be called if direct capture is used.
Parameter | Description |
---|---|
aPicture | "The picture to write." |