/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation for video recorder

*

*/

// INCLUDE FILES

#include "mmf/common/mmfbase.h"

#include "CCMRRecorderBase.h"

#include "CCMRVideoSettings.h"      // default video settings

#include "CCMRSupportedCodecs.h"

#include "CCMRVideoHWParams.h"

#include "CCMRVideoRecorder.h"

#include "CCMRMediaRecorder.h"      // for bitrate control mode

#include "CCMRVideoThreadProxy.h"

#include "CCMRFifo.h"

#include "CCMRActiveOutput.h"

#include "CCMRVideoCodecDataH263.h"

#include "CCMRVideoCodecDataMPEG4.h"

#include "CCMRVideoCodecDataH264AVC.h"

#include <mmf/common/mmfvideo.h>

/*

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CCMRMDFVideoRecorderTraces.h"

#endif

*/

// MACROS

// Assertion macro wrapper for code cleanup

#define VRASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CCMRMDFVIDEORECORDER"), EInternalAssertionFailure))

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x;

#else

#define PRINT(x)

#endif

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// convertFrameRateToInterval Converts framerate to frame time interval

// (time between 2 consecutive frames).

// Returns: TInt time between 2 consecutive frames

// -----------------------------------------------------------------------------

//

static TInt convertFrameRateToInterval(TReal32 aFrameRate)

    {

    return (TInt(1E6/aFrameRate + 0.5));

    }

// -----------------------------------------------------------------------------

// convertFrameRateToInterval Converts framerate to frame time interval

// (time between 2 consecutive frames).

// Returns: TInt time between 2 consecutive frames

// -----------------------------------------------------------------------------

//

static TInt TLinearOrderFuncVideoSizeRate(const TPictureRateAndSize& aPictureRateAndSize1,

										  const TPictureRateAndSize& aPictureRateAndSize2 )

	{

	if ( (aPictureRateAndSize1.iPictureSize.iWidth == aPictureRateAndSize2.iPictureSize.iWidth) &&

		 (aPictureRateAndSize1.iPictureSize.iHeight == aPictureRateAndSize2.iPictureSize.iHeight) &&

		 (aPictureRateAndSize1.iPictureRate == aPictureRateAndSize2.iPictureRate) )

		{

		return 0;

		}

	if ( (aPictureRateAndSize1.iPictureSize.iWidth < aPictureRateAndSize2.iPictureSize.iWidth) ||

		 (aPictureRateAndSize1.iPictureSize.iHeight < aPictureRateAndSize2.iPictureSize.iHeight) ||

		 (aPictureRateAndSize1.iPictureRate < aPictureRateAndSize2.iPictureRate))

		{

		return -1;

		}

	else

		{

		return 1;

		}

	}

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------

// CCMRVideoRecorder::NewL

// Two-phased constructor.

// ---------------------------------------------------------

//

CCMRVideoRecorder* CCMRVideoRecorder::NewL(MAsyncEventHandler& aEventHandler, CCMRConfigManager* aConfig )

    {

    PRINT((_L("CCMRVideoRecorder::NewL(), In: MDF")))

    CCMRVideoRecorder* self = new (ELeave) CCMRVideoRecorder(aEventHandler);

    CleanupStack::PushL( self );

    self->ConstructL(aConfig);

    CleanupStack::Pop();

    PRINT((_L("CCMRVideoRecorder::NewL(), Out: MDF")))

    return self;

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::ConstructL()

// Symbian 2nd phase constructor can leave.

// ---------------------------------------------------------

//

void CCMRVideoRecorder::ConstructL(CCMRConfigManager* aConfig)

    {

    PRINT((_L("CCMRVideoRecorder::ConstructL(), In")))

    SetState(EStateNone);

    iConfig = aConfig;

    iNumCameraBuffers = iConfig->PluginSettings().iCMRNumCameraBuffers;

    // Create input fifo

    iSourceFifo = CCMRFifo::NewL(iNumCameraBuffers);

    iCodingFifo = CCMRFifo::NewL(iNumCameraBuffers);

    iOutputSinkBuffer = new (ELeave) CCMRMediaBuffer;

    iSizeIndex = -1;

    iSizeIndex420 = -1;

    iSizeIndex422 = -1;

    iSizeIndexDCEncoder = -1;

    iRateIndex = -1;

    iRateIndex420 = -1;

    iRateIndex422 = -1;

    iRateIndexDCEncoder = -1;

    iDevVideoRec = NULL;

    iEncoderHWDeviceId = 0;

    iPreProcessorHWDeviceId = 0;

    iOutputVideoBuffer = NULL;

    iVideoBufferType = CCMRMediaBuffer::EVideoH263;

    iClockSource = NULL;

    iDecSpecInfoLength = 0;

    iPreferredEncoderUID = KNullUid;

    iPreferredEncapsulationSet = EFalse;

    iFrameSize.SetSize( KCMRFrameWidth, KCMRFrameHeight );

    iSourceFrameRate = KCMRFrameRate;

    iSourceFrameInterval = convertFrameRateToInterval(iSourceFrameRate);

    iEncodingFrameRate = KCMRFrameRate;

    iMaxFrameRate4GivenSize = KCMRFrameRate;

    iRequestedFrameRate = KCMRFrameRate;

    CCMRRecorderBase::SetTargetBitRateL( KCMRTargetBitRate );

    iMinRandomAccessPeriodInSeconds = KCMRMinRandomAccessPeriod;

    iMimeType = KCMRMimeTypeH263BaselineProfile;    //copy

    iMimeType += _L8( "; level=10" );    // append

    iVideoCodecData = new (ELeave) CCMRVideoCodecDataH263(10);    // default is H.263 level 10

    iBitRateMode = EBitRateConstant;

    iTimeWhenPaused = 0;

    iTotalPausedTime = 0;

    iErrorCode = KErrNone;

    iEncoderInputQueueLength = 0;

    iNumberOfCapturedFrames = 0;

    iNumberOfEncodedFrames = 0;

    iMutexObj.CreateLocal();

    iMutexCreated = ETrue;

    iBufferReturnAO = CCMRReturnAO::NewL(this);

    iFatalError = EFalse;

    iInputEnd = EFalse;

    iStreamEnd = EFalse;

    // Direct capture

    iDirectCapture = EFalse;

    iCameraHandle = 0;

    iSkipBuffers = EFalse;

    iDriftFrameSkipCount = 0;

    iAddedFrameDurationCount = 0;

    iPreviousCameraFrameIndex = 0;

#ifdef _DEBUG

    iLastCapture = 0;

    iCumulativeEncodingTime = iCumulativeCaptureTime = 0;

    iAverageEncodingTime = iAverageCaptureTime = 0;

#endif

	iDevVideoRec = CMMFDevVideoRecord::NewL( *this );

	iAvailableVideoEncoders.Reset();

	iAvailableVideoFrameSizesRates.Reset();

	PRINT((_L("CCMRVideoRecorder::ConstructL() looking for defaul video codec encoder(s)")));

	iDevVideoRec->FindEncodersL(iMimeType, 0 /* aPreProc */, iAvailableVideoEncoders, EFalse );

	PRINT((_L("CCMRVideoRecorder::ConstructL() search found %d encoder(s)"), iAvailableVideoEncoders.Count() ));

	if ( iConfig )

		{

		iConfig->SetVideoCodec(iMimeType);

		iConfig->SetVideoPixelAspectRatio(KCMRAspectRatioNum, KCMRAspectRatioDenom);

		// fill out defaults for Rate Control from ICM.

	    iRateControlOptions.iPictureQuality = iConfig->PluginSettings().iCMRPictureQuality;

	    iRateControlOptions.iLatencyQualityTradeoff = iConfig->PluginSettings().iCMRLatencyQualityTradeoff; // latency vs. quality

	    iRateControlOptions.iQualityTemporalTradeoff = iConfig->PluginSettings().iCMRQualityTemporalTradeoff; // spatial vs. temporal quality

		}

    UpdateSupportedVideoFrameSizesRates();

    PRINT((_L("CCMRVideoRecorder::ConstructL(), Out")))

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::~CCMRVideoRecorder()

// Destructor

// ---------------------------------------------------------

//

CCMRVideoRecorder::~CCMRVideoRecorder()

    {

    PRINT((_L("CCMRVideoRecorder::~CCMRVideoRecorder(), In")));

    // This is the counterpart to NewL & OpenL, e.g. Close & Delete

    // free all memory allocated and uninitalize & delete objects created, e.g. DevVideoRecord

#if defined VIDEO_FILE_OUTPUT || defined VIDEO_BS_FILE_OUTPUT

    iOutputFile.Close();

    iFs.Close();

#endif

    // to make PC Lint happy

    iOutputVideoBuffer = NULL;

    iOutput = NULL;

    iClockSource = NULL;

    // delete DevVideoRecord instance

    delete iDevVideoRec;

    PRINT((_L("CCMRVideoRecorder::~CCMRVideoRecorder() devvideorec deleted")));

    iAvailableVideoFrameSizesRates.Close();

    iAvailableVideoEncoders.Close();

    delete iOutputSinkBuffer;

    iOutputSinkBuffer = NULL;

    delete iVideoCodecData;

    iVideoCodecData = NULL;

    // empty the source fifo, just in case once more; this should be done a) by encoder and b) by MdvroStreamEnd()

    MFrameBuffer* cbuffer;

    if ( iSourceFifo )

        {

        while ( !iSourceFifo->IsEmpty() )

            {

            cbuffer = reinterpret_cast<MFrameBuffer*>(iSourceFifo->Get());

            // Release camera API buffer

            cbuffer->Release();

            }

        delete iSourceFifo;

        iSourceFifo = NULL;

        }

    TVideoPicture* picture;

    if ( iCodingFifo )

        {

        // delete the empty devvr picture-holders stored in the fifo

        while ( !iCodingFifo->IsEmpty() )

            {

            picture = reinterpret_cast<TVideoPicture*>(iCodingFifo->Get());

            PRINT((_L("CCMRVideoRecorder::~CCMRVideoRecorder() deleting %x"),picture));

            delete picture;

            }

        delete iCodingFifo;

        iCodingFifo = NULL;

        }

    PRINT((_L("CCMRVideoRecorder::~CCMRVideoRecorder() fifos deleted")));

    if ( iDecSpecInfo )

        {

        // We still have MPEG-4 decoder configuration info stored

        delete iDecSpecInfo;

        iDecSpecInfo = NULL;

        }

    // delete camera

    delete iSource;

    iSource = NULL;

    PRINT((_L("CCMRVideoRecorder::~CCMRVideoRecorder() camera deleted")));

    if ( iBufferReturnAO )

        {

        iBufferReturnAO->Cancel();

        delete iBufferReturnAO;

        }

    if ( iThreadHandleOpened )

        {

        iOutputThreadHandle.Close();

        iThreadHandleOpened = EFalse;

        }

    if ( iMutexCreated )

        {

        iMutexObj.Close();

        }

    SetState(EStateNone);

    PRINT((_L("CCMRVideoRecorder::~CCMRVideoRecorder(), Out")));

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::SetOutputL

// Sets output active object

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CCMRVideoRecorder::SetOutputL(CCMRActiveOutput* aOutput)

    {

    iOutput = aOutput;

    iOutput->RegisterSourceL( this );

    if ( iSource && iThreadHandleOpened )

        {

        SetState( EStateOpen );

        }

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::SetClockSourceL

// Set clock source

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CCMRVideoRecorder::SetClockSource(MMMFClockSource* aClockSource)

    {

    iClockSource = aClockSource;

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::SetOutputThreadIdL

// Sets id of the output thread

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CCMRVideoRecorder::SetOutputThreadIdL(TUint aThreadId)

    {

    User::LeaveIfError( iOutputThreadHandle.Open(aThreadId) );

    iThreadHandleOpened = ETrue;

    if ( iOutput && iSource )

        {

        SetState( EStateOpen );

        }

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::SetCameraHandleL

// Sets camera handle and creates camera instance

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CCMRVideoRecorder::SetCameraHandleL(TInt aCameraHandle)

    {

    PRINT((_L("CCMRVideoRecorder::SetCameraHandleL(), In")))

    // Create video source

#ifdef VIDEO_FILE_INPUT

    iSource = CCMRVideoFileSource::NewL(this);

#else

    iSource = CCMRVideoCameraSource::NewL(this, aCameraHandle);

#endif

    // Store a camera handle for future use

    iCameraHandle = aCameraHandle;

    // get camera info

    iSource->CameraInfo(iCameraInfo);

#if defined VIDEO_FILE_OUTPUT || defined VIDEO_BS_FILE_OUTPUT

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iOutputFile.Replace(iFs, _L("videorec_out.bin"), EFileWrite | EFileShareExclusive));

#endif

    if ( iOutput && iThreadHandleOpened )

        {

        SetState( EStateOpen );

        }

    PRINT((_L("CCMRVideoRecorder::SetCameraHandleL(), Out")))

    }

// ---------------------------------------------------------

// CCMRVideoRecorder::SetupEncoderL

// Private helper method to select & setup the encoder

// plugin devvr must use

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CCMRVideoRecorder::SetupEncoderL()

    {

#ifdef _DEBUG

    TBuf<256> mime;

    mime.Copy(iMimeType);

    PRINT((_L("CCMRVideoRecorder::SetupEncoderL() in, video mime-type: %S "), &mime ));

#endif

    if ( iPreferredEncoderUID != KNullUid )

        {// We have preferred encoder UID from client - override encoder search and use it instead.

        PRINT((_L("CCMRVideoRecorder::SetVideoCodecL() skipping encoder search. Using API user encoder: %d "), iPreferredEncoderUID.iUid));

        iAvailableVideoEncoders.Reset();

        iAvailableVideoEncoders.AppendL(iPreferredEncoderUID);

        }

    else if ( iConfig &&

            ( iConfig->IsICMConfigDataAvailable() ) &&

            ( iConfig->VideoQualitySettings().iVideoEncoderUID != KNullUid ) )

        {// Video quality set has set UID value - override encoder search and use it instead.

        PRINT((_L("CCMRVideoRecorder::SetVideoCodecL() skipping encoder search. Using ICM config encoder: %d "), iPreferredEncoderUID.iUid));

        iAvailableVideoEncoders.Reset();

        iAvailableVideoEncoders.AppendL(iPreferredEncoderUID);

        }

    // uncompressed format structures for YUV420 planar

    TBool cameraSupports420 = ETrue;

    if ( (iSizeIndex420 < 0) || (iRateIndex420 < 0) )

        {

        cameraSupports420 = EFalse;

        }

    else

        {

        cameraSupports420 = ETrue;

        PRINT((_L("CCMRVideoRecorder::SetupEncoderL() camera supports YUV420 planar") ));

        }

    // uncompressed format structures for YUV422

    TBool cameraSupports422 = ETrue;

    if ( (iSizeIndex422 < 0) || (iRateIndex422 < 0) )

        {

        cameraSupports422 = EFalse;

        }

    else

        {

        cameraSupports422 = ETrue;

        PRINT((_L("CCMRVideoRecorder::SetupEncoderL() camera supports YUV422 interleaved") ));

        }

    // Output format

    CCompressedVideoFormat *comprFormat = CCompressedVideoFormat::NewL( iMimeType );

    CleanupStack::PushL( comprFormat );

    // index for encoder candidate. Have to go through the list to find an accerated encoder

    TInt encoderIndex = -1;

    TUncompressedVideoFormat encoderUncompFormat;

    // encoder info for retrieving capabilities

    CVideoEncoderInfo* encoderInfo = NULL;

    // this is needed if init of HW accelerated codec failed and we retry => forces to select ARM codec

    TBool alreadyFailedWithHWAccelerated = iVideoCodecHWAccelerated;

    iVideoCodecHWAccelerated = EFalse;

    TInt infoError = KErrNone;

    TBool encoderSupports422 = EFalse;

    TBool encoderSupports420 = EFalse;

    TYuvCoefficients preproInputYuvCoefficient;

    TYuvCoefficients preproOutputYuvCoefficient;

    TYuvCoefficients encoderInputYuvCoefficient;

    TUint aspectRatioNum = 0;

    TUint aspectRatioDenom = 0;

    TVideoDataUnitEncapsulation outputFormatEncapsulation = EDuElementaryStream;

    if( KCMRMimeTypeH263() == iMimeType.Left( KCMRMimeTypeH263().Length() ))

        {// H.263

        PRINT((_L("CCMRVideoRecorder::SetupEncoderL() - setting H.263 YUVs") ));

        preproInputYuvCoefficient = EYuvBt601Range1;

        preproOutputYuvCoefficient = EYuvBt601Range0;

        encoderInputYuvCoefficient = EYuvBt601Range0;

        iVideoBufferType = CCMRMediaBuffer::EVideoH263;

        // pixel aspect ratios

        if ( iConfig && iConfig->IsICMConfigDataAvailable() )

	        {

	        aspectRatioNum = iConfig->VideoQualitySettings().iVideoPixelAspectRatioNum;

	        aspectRatioDenom = iConfig->VideoQualitySettings().iVideoPixelAspectRatioDenom;

	        }

        else

	        {

	        aspectRatioNum = KCMRAspectRatioNum;

	        aspectRatioDenom = KCMRAspectRatioDenom;

	        }

        }

    else if ( KCMRMimeTypeMPEG4V() == iMimeType.Left( KCMRMimeTypeMPEG4V().Length() ))

        {// MPEG-4

        PRINT((_L("CCMRVideoRecorder::SetupEncoderL() - setting MPEG4 YUVs") ));

        preproInputYuvCoefficient = EYuvBt709Range1;

        preproOutputYuvCoefficient = EYuvBt709Range1;

        encoderInputYuvCoefficient = EYuvBt709Range1;

        // pixel aspect ratios

        if ( iConfig && iConfig->IsICMConfigDataAvailable() )

	        {

	        aspectRatioNum = iConfig->VideoQualitySettings().iVideoPixelAspectRatioNum;

	        aspectRatioDenom = iConfig->VideoQualitySettings().iVideoPixelAspectRatioDenom;

	        }

        else

	        {

	        aspectRatioNum = KCMRMPEG4AspectRatioNum;

	        aspectRatioDenom = KCMRMPEG4AspectRatioDenom;

	        }

        iVideoBufferType = CCMRMediaBuffer::EVideoMPEG4;

        }

    else

        {// H.264 AVC

        PRINT((_L("CCMRVideoRecorder::SetupEncoderL() - setting H.264 AVC YUVs") ));

        preproInputYuvCoefficient = EYuvBt709Range1;

        preproOutputYuvCoefficient = EYuvBt709Range1;

        encoderInputYuvCoefficient = EYuvBt709Range1;

        // pixel aspect ratios 1:1

        if ( iConfig && iConfig->IsICMConfigDataAvailable() )

	        {