/*

* Copyright (c) 2009 Aricent and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Aricent - initial contribution.

*

* Contributors:

*

* Description:

* Declares plugin class for Mpeg4SP/H263 encoder HwDevice. This class inherits 

* from CMMFVideoEncodeHwDevice and implements the pure virtual functions.The 

* class also contains implementation specific private methods.

*

*/

#ifndef ARIMP4SPENCHWDEVICEIMPL_H

#define ARIMP4SPENCHWDEVICEIMPL_H

//System Includes

#include <Implementationproxy.h>

#include <f32file.h>

#include <e32const.h>

#include <e32base.h>

#include <Videorecordhwdevice.h>

//User Includes

#include "arivideoenccommon.h"

#include "aristatemachine.h"

#include "aribaseengine.h"

#include "arimp4spencwrapper.h"

//#include "arimp4spenchwdevice.h"

#include "arimp4spenchwdeviceuids.hrh"

#include "ariprint.h"

// Forward declarations

/**

 * This class is part of Aricent's Mpeg4-sp/H263 encoder HwDevice plugin used

 * for encoding yuv420 input to Mpeg4-sp/H263 content.

 * Provides implementation for standard MDF HwDevice plugin APIs as well as

 * private functions used internal to this class for .This class also

 * implements callback APIs from MProcessEngineObserver which are called

 * from CBaseEngine.

 */

class CAriMp4spencHwDeviceImpl: public CMMFVideoEncodeHwDevice,

							    public MProcessEngineObserver

{

public:

	/**

	 * Two-phased constructor.

	 * @return  pointer to an instance of CAriMp4spencHwDeviceImpl

	 * @leave	"The method will leave if an error occurs"

	 */

	static CAriMp4spencHwDeviceImpl* NewL();

	/**> Destructor */

	~CAriMp4spencHwDeviceImpl();

public:

	/**

	 * From CMMFVideoHwDevice

	 * The function retrieves a custom interface to the HwDevice.

	 * @param aInterface

	 *    UID of the interface to be retrieved. It is defined with the custom

	 *    interface

	 * @return returns pointer to the interface

     */

    TAny* CustomInterface( TUid aInterface );

public:

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function retrieves information about the video encoder

	 * @return "returns pointer to the object with encoder information"

	 * @leave  "The method will leave if an error occurs"

     */

	CVideoEncoderInfo* VideoEncoderInfoLC();

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the encoder output format.

	 * @param aFormat

	 *    UID of the interface to be retrieved. It is defined with the custom

	 *    interface

	 * @param aDataUnitType

	 *	  The type of output coded data units

	 * @param aDataEncapsulation

	 *	  Data encapsulation type for output encoded data units

	 * @param aSegmentationAllowed

	 *     Indicates if segmentation is allowed or not

	 * @leave	"The method will leave if an error occurs"

     */

	void SetOutputFormatL( const CCompressedVideoFormat& aFormat,

						TVideoDataUnitType aDataUnitType,

						TVideoDataUnitEncapsulation aDataEncapsulation,

						TBool aSegmentationAllowed=EFalse );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the pre-processor hwdevice that will write data to

	 * this encoder.

	 * @param aDevice

	 *      Pre-processor device that will write to this encoder

     */

	void SetInputDevice( CMMFVideoPreProcHwDevice* aDevice );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the number of bit-rate scalability layers to use.

	 * @param aNumLayers

	 *    The number of bit-rate scalability layers to use

	 * @leave "The method will leave if an error occurs"

     */

	void SetNumBitrateLayersL( TUint aNumLayers );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the scalability type for a bit-rate scalability layer

	 * @param aLayer

	 *    The layer number

	 * @param aScalabilityType

	 *    Layer scalability type

	 * @leave "The method will leave if an error occurs"

     */

	void SetScalabilityLayerTypeL( TUint aLayer,

									TScalabilityType aScalabilityType);

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the reference picture options to be used for all

	 * scalability layers

	 * @param aMaxReferencePictures

	 *    Maximum number of reference pictures to be used

	 * @param aMaxPictureOrderDelay

	 *    The maximum picture order delay, in number of pictures.

     */

	void SetGlobalReferenceOptions( TUint aMaxReferencePictures,

									TUint aMaxPictureOrderDelay );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the reference picture options to be used for a

	 * particular scalability layer

	 * @param aLayer

	 *    The layer number

	 * @param aMaxReferencePictures

	 *    Maximum number of reference pictures to be used for this layer

	 * @param aMaxPictureOrderDelay

	 *    The maximum picture order delay for this layer, in number of

	 *    pictures.

	 */

    void SetLayerReferenceOptions( TUint aLayer,TUint aMaxReferencePictures,

									TUint aMaxPictureOrderDelay );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the encoder buffering options

	 * @param aOptions

	 *    Buffering options to be used

	 * @leave "The method will leave if an error occurs"

     */

	void SetBufferOptionsL( const TEncoderBufferOptions& aOptions );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the encoder output rectangle

	 * @param aRect

	 *    Output rectangle to be used

	 * @leave "The method will leave if an error occurs"

	 */

    void SetOutputRectL( const TRect& aRect );

    /**

	 * From CMMFVideoEncodeHwDevice

	 * The function notifies the encoder whether bit errors or packets losses

	 * can be expected in the video transmission

	 * @param aBitErrors

	 *    Boolean to indicate if bit errors can be expected

	 * @param aPacketLosses

	 *    Boolean to indicate if packet losses can be expected

	 */

    void SetErrorsExpected( TBool aBitErrors, TBool aPacketLosses );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the minimum random access rate to be used

	 * @param aRate

	 *    The minimum random access rate

     */

	void SetMinRandomAccessRate( TReal aRate );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the coding standard specific options to be used.

	 * @param aOptions

	 *    Coding standard specific options to be used

	 * @leave "The method will leave if an error occurs"

	 */

    void SetCodingStandardSpecificOptionsL( const TDesC8& aOptions );

     /**

	  * From CMMFVideoEncodeHwDevice

	  * The function sets  the implementation specific options to be used

	  * @param aOptions

	  *    Implementation specific options to be used.

	  * @leave "The method will leave if an error occurs"

	  */

    void SetImplementationSpecificEncoderOptionsL( const TDesC8& aOptions );

    /**

	 * From CMMFVideoEncodeHwDevice

	 * The function returns coding-standard specific initialization output

	 * from the encoder

	 * @return Returns the pointer to buffer holding coding-standard specific

	 * initialization output

	 * @leave "The method will leave if an error occurs"

	 */

	HBufC8* CodingStandardSpecificInitOutputLC();

	/**

	* From CMMFVideoEncodeHwDevice

	* The function gets the implementation specific initialization output from

	* the encoder

	* @return Returns the pointer to buffer holding implementation specific

	* initialization output

	* @leave "The method will leave if an error occurs"

	*/

	HBufC8* ImplementationSpecificInitOutputLC();

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function the number of unequal error protection levels.

	 * @param aNumLevels

	 *    The number of unequal error protection levels to be used

	 * @param aSeparateBuffers

	 *    Boolean indicating whether each unequal error protection level of a

	 *    coded data unit shall be encapsulated in its own output buffer

	 * @leave "The method will leave if an error occurs"

     */

    void SetErrorProtectionLevelsL( TUint aNumLevels,

									TBool aSeparateBuffers );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function the number of unequal error protection levels.

	 * @param aNumLevels

	 *    The number of unequal error protection levels to be used

	 * @param aSeparateBuffers

	 *    Boolean indicating whether each unequal error protection level of a

	 *    coded data unit shall be encapsulated in its own output buffer

	 * @param aStrength

	 *    Forward error control strength for this error protection level

	 * @leave "The method will leave if an error occurs"

     */

    void SetErrorProtectionLevelL( TUint aLevel, TUint aBitrate,

												TUint aStrength );

	 /**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the expected or prevailing channel conditions for an

	 * unequal error protection

	 * level in terms of expected packet loss rate.

	 * @param aLevel

	 *    Error protection level number

	 * @param aLossRate

	 *    Packet loss rate, in number of packets lost per second.

	 * @param aLossBurstLength

	 *    Expected average packet loss burst length

     */

    void SetChannelPacketLossRate( TUint aLevel, TReal aLossRate,

							TTimeIntervalMicroSeconds32 aLossBurstLength );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the expected or prevailing channel conditions for an

	 * unequal error

	 * protection level, in terms of expected bit error rate

	 * @param aLevel

	 *    Error protection level number

	 * @param aErrorRate

	 *    Expected bit error rate

	 * @param aStdDeviation

	 *    Expected bit error rate standard deviation

     */

    void SetChannelBitErrorRate( TUint aLevel, TReal aErrorRate,

								TReal aStdDeviation );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the segment size. To be used only for packet mode

	 * @param aLayer

	 *    Layer number

	 * @param aSizeBytes

	 *    Segment size in bytes

	 * @param aSizeMacroblocks

	 *    Size of the macro blocks

     */

    void SetSegmentTargetSize( TUint aLayer, TUint aSizeBytes,

								TUint aSizeMacroblocks );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the bit-rate control options for a layer

	 * @param aLayer

	 *    Bit-rate scalability layer number

	 * @param aOptions

	 *    Bit-rate control options to be used

     */

	void SetRateControlOptions( TUint aLayer,

								const TRateControlOptions& aOptions );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the in-layer scalability options for a layer

	 * @param aLayer

	 *    Bit-rate scalability layer number

	 * @param aNumSteps

	 *    The number of in-layer scalability steps to use

	 * @param aScalabilityType

	 *    Bit-rate share for each scalability step

	 * @param aBitrateShare

	 *    Picture rate share for each scalability step

	 * @param aPictureShare

	 *    The scalability type to use

	 * @leave "The method will leave if an error occurs"

     */

    void SetInLayerScalabilityL( TUint aLayer,TUint aNumSteps,

								TInLayerScalabilityType aScalabilityType,

								const TArray<TUint>& aBitrateShare,

								const TArray<TUint>& aPictureShare );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function sets the segment size. To be used only for packet mode

	 * @param aLayer

	 *    Layer number

	 * @param aPeriod

	 *    The number of in-layer scalability steps to use

     */

    void SetLayerPromotionPointPeriod( TUint aLayer, TUint aPeriod );

	/**

	* From CMMFVideoEncodeHwDevice

	* The function gets the coding-standard specific settings output from the

	* encoder

	* @return Returns the pointer to buffer holding coding-standard specific

	* settings output

	* @leave "The method will leave if an error occurs"

	*/

    HBufC8* CodingStandardSpecificSettingsOutputLC();

    /**

	* From CMMFVideoEncodeHwDevice

	* The function gets the Implementation specific settings output from the

	* encoder

	* @return Returns the pointer to buffer holding Implementation specific

	* settings output

	* @leave "The method will leave if an error occurs"

	*/

    HBufC8* ImplementationSpecificSettingsOutputLC();

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function requests the encoder to send supplemental information in

	 * the bit stream

	 * @param aData

	 *    Supplemental information data to send

	 * @leave "The method will leave if an error occurs"

     */

	void SendSupplementalInfoL( const TDesC8& aData );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function requests the encoder to send supplemental information in

	 * the bit stream

	 * @param aData

	 *    Supplemental information data to send

	 * @param aTimestamp

	 *    Timestamp for the picture in which the supplemental information

	 *    should be included

	 * @leave "The method will leave if an error occurs"

     */

	void SendSupplementalInfoL( const TDesC8& aData,

								const TTimeIntervalMicroSeconds& aTimestamp );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function requests the encoder to cancel the current supplemental

	 * information send request

     */

	void CancelSupplementalInfo();

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function gets the current output buffer status

	 * @param aNumFreeBuffers

	 *    Target for the number of free output buffers

	 * @param aTotalFreeBytes

	 *    Target for the total free buffer size in bytes

     */

	void GetOutputBufferStatus( TUint& aNumFreeBuffers,

								TUint& aTotalFreeBytes );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function returns a used output buffer back to the encoder

	 * @param aBuffer

	 *    The buffer to be returned

     */

    void ReturnBuffer( TVideoOutputBuffer* aBuffer );

    /**

	 * From CMMFVideoEncodeHwDevice

	 * The function notifies the encoder that a picture loss has occurred

	 * without specifying the lost picture.

     */

    void PictureLoss();

    /**

	 * From CMMFVideoEncodeHwDevice

	 * The function notifies the encoder that a picture loss has occurred

	 * @param aPictures

	 *    Picture identifiers of lost pictures

     */

    void PictureLoss( const TArray<TPictureId>& aPictures );

	/**

	 * From CMMFVideoEncodeHwDevice

	 * The function notify the encoder that slice loss has occurred, giving

	 * the details of the macroblocks and the picture to which they belong

	 * @param aFirstMacroblock

	 *    The first lost macroblock.

	 * @param aNumMacroblocks

	 *    The number of macroblocks in the lost slice

	 * @param aPicture

	 *    The picture identified for the picture where the slice was lost

     */

    void SliceLoss( TUint aFirstMacroblock, TUint aNumMacroblocks,

					const TPictureId& aPicture );

    /**

	 * From CMMFVideoEncodeHwDevice

	 * The function requests the encoder to use reference picture selection

	 * @param aSelectionData

	 *    The reference picture selection request message

     */

    void ReferencePictureSelection( const TDesC8& aSelectionData );

public:

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function initializes the encoder HwDevice with the configuration

	 * settings and reserve

	 * the hardware resources required

     */

	void Initialize();

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function commits all changes since the last CommitL(), Revert() or

	 *  Initialize() to the hardware device

	 * @leave "The method will leave if an error occurs"

	 */

	void CommitL();

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function reverts all changes since the last CommitL(), Revert() or

	 * Initialize()

	 * back to their previous settings.

	 */

	void Revert();

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function writes an uncompressed input picture

	 * @param aPicture

	 *    The picture to write

	 * @leave "The method will leave if an error occurs"

     */

	void WritePictureL( TVideoPicture* aPicture );

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function notifies the hardware device that the end of input data

	 * has been reached.

     */

	void InputEnd();

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function starts recording video.

     */

	void Start();

	static TInt TimerCallBack( TAny* aPtr );

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function stops recording video

     */

	void Stop();

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function pauses video recording.

     */

	void Pause();

	/**

	 * From CMMFVideoRecordHwDevice

	 * The function resumes video recording after a pause.

     */

	void Resume();