/*

* Copyright (c) 2002-2006 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 "CCMRVideoRecorderClient.h"

#include "CCMRMediaRecorderImp.h"

#include "CCMRPerfMonitor.h"

#include "CCMRVideoHWParams.h"

#include "CCMRVideoCodecs.h"

#include "CCMRSupportedCodecs.h"

#include "CCMRConfigManager.h"

#include <mmf/common/mmfvideo.h>

// MACROS

// Assertion macro wrapper for code cleanup

#define MRASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CCMRMEDIARECORDER"), EInternalAssertionFailure))

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

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

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

// CCMRMediaRecorderImp::CCMRMediaRecorderImp

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCMRMediaRecorderImp::CCMRMediaRecorderImp()

    {

    iObserver = NULL;

    iSink = NULL;

    iVideoRecorder = NULL;

    iAudioRecorder = NULL;

    iVideoRecorderPreparing = EFalse;

    iAudioRecorderPreparing = EFalse;

    iAudioEnabled = ETrue;

    iState = EStateNone;

    iErrorCode = KErrNone;

    iMaxTargetBitRate = KMMFVariableVideoBitRate; //here this means: not set (=> won't be checked when setting A/V bitrates)

    }

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

// CCMRMediaRecorderImp::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMRMediaRecorder* CCMRMediaRecorder::NewL()

    {

    CCMRMediaRecorderImp* self = new (ELeave) CCMRMediaRecorderImp();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCMRMediaRecorderImp::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCMRMediaRecorderImp::ConstructL()

    {

    iState = EStateNone;

    // create video recorder

    iVideoRecorder = CCMRVideoRecorderClient::NewL();

    // create audio recorder

    iAudioRecorder = CCMRAudioRecorder::NewL();

    }

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

// CCMRMediaRecorderImp::~CCMRMediaRecorderImp

// Destructor.

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

//

CCMRMediaRecorderImp::~CCMRMediaRecorderImp()

    {

    PRINT((_L("CCMRMediaRecorderImp::~CCMRMediaRecorderImp() in")));

    // note, adding "this->" below disabled a PC Lint warning since it makes State explicitly to refer to this class

    if ( (this->State() == EStateRecording) || (this->State() == EStatePaused) )

        {

        // recorder must be stopped first

        PRINT((_L("CCMRMediaRecorderImp::~CCMRMediaRecorderImp() must stop first")));

        TRAPD(err, this->StopL());

        if ( err ) {}

        // we are destructing, ignore the error; error can't be KErrNotReady since our state is not stopping

        }

    // we can't enter here when in stopping-state since stop is blocking controller thread to wait

    // for audio & video threads to complete stop

    // Note that pausing & destructing can't happen at the same time since neither of them can be executed internally,

    // so we don't need to check pausing state here

    // zeroed to make PC Lint happy

    iObserver = NULL;

    iSink = NULL;

    iAudioSource = NULL;

    delete iAudioRecorder;

    PRINT((_L("CCMRMediaRecorderImp::~CCMRMediaRecorderImp() iAudioRecorder deleted")));

    delete iPerfMonitor;

    delete iConfig;

    delete iVideoRecorder;

    PRINT((_L("CCMRMediaRecorderImp::~CCMRMediaRecorderImp() iVideoRecorder deleted")));

    delete iAudioOutput;

    delete iVideoOutput;

    if ( iErrorReporter )

        {

        iErrorReporter->Cancel();

        delete iErrorReporter;

        }

    PRINT((_L("CCMRMediaRecorderImp::~CCMRMediaRecorderImp() out")));

    //#pragma attol insert _ATCPQ_DUMP(0);

    }

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

// CCMRMediaRecorderImp::OpenL

// Opens media recorder

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

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

//

void CCMRMediaRecorderImp::OpenL(MCMRMediaRecorderObserver *aObserver,

                                 MDataSource *aAudioSource,

                                 MCMRMediaSink *aSink, TInt aCameraHandle,

                                 const TDesC8& aVideoMimeType,

                                 TFourCC aAudioType)

    {

    PRINT((_L("CCMRMediaRecorderImp::OpenL() in, thread id %x"),TInt(RThread().Id())));

    if ( State() != EStateNone )

        {

        PRINT((_L("CCMRMediaRecorderImp::OpenL() already exists")));

        User::Leave( KErrAlreadyExists );

        }

    MRASSERT(aObserver);

    iObserver = aObserver;

    MRASSERT(aSink);

    iSink = aSink;

    if ( aAudioSource == NULL )

        {

        iAudioEnabled = EFalse;

        }

    iAudioSource = aAudioSource;

    // create active output objects; must be created here so that they all are in the same thread

    iAudioOutput = CCMRActiveOutput::NewL( iSink, this );

    iVideoOutput = CCMRActiveOutput::NewL( iSink, this );

    iPerfMonitor = CCMRPerfMonitor::NewL( iAudioOutput, iVideoOutput, iVideoRecorder, this );

    iConfig = CCMRConfigManager::NewL();

    // open video recorder

    TRAPD( err, iVideoRecorder->OpenL(this, iVideoOutput, aCameraHandle, aVideoMimeType, iPerfMonitor, iConfig) );

    if ( err != KErrNone )

        {

        PRINT((_L("CCMRMediaRecorderImp::OpenL() video open failed")));

        User::Leave( err );

        }

    // Inform sink about average bit-rate

    TInt br = 0;

    TRAP( err, iVideoRecorder->TargetBitRateL(br));

    if ( err == KErrNone )

        {

        TReal videoBitrateScaler = 0;

        if ( iConfig )

        	{

             videoBitrateScaler = iConfig->PluginSettings().iCMRAvgVideoBitRateScaler;

         	}

         // make sure we never get scaler value 0 (ends up Div0 error)

        if ( videoBitrateScaler == 0 )

         	{

         	videoBitrateScaler = KCMRAvgVideoBitRateScaler;

         	}

         //inform the estimated average bitrate to sink; use a HW-specific scaler to estimate the average

        br = static_cast<TInt>( br*videoBitrateScaler );

        iSink->SetAverageVideoBitRate( br );

        // open audio recorder

        TRAP( err, iAudioRecorder->OpenL(this, iAudioSource, iAudioOutput, aAudioType, iConfig) );

        }

    if ( err != KErrNone )

        {

        PRINT((_L("CCMRMediaRecorderImp::OpenL() audio open failed")));

        User::Leave( err );

        }

    TRAP( err, iAudioRecorder->TargetBitRateL(br));

    if ( err == KErrNone )

        {

        // Inform sink about the default average bit-rate

        iSink->SetAverageAudioBitRate( br );

        }

    else

        {

        PRINT((_L("CCMRMediaRecorderImp::OpenL() audio bitrate check failed")));

        User::Leave( err );

        }

    iErrorReporter = new (ELeave) CCMRErrorReporter(aObserver);

    iState = EStateOpen;

    PRINT((_L("CCMRMediaRecorderImp::OpenL() out")));

    }

// Settings

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

// CCMRMediaRecorderImp::SetVideoCodecL

// Sets video codec (overrides the codec given in OpenL).

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

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

//

void CCMRMediaRecorderImp::SetVideoCodecL( const TDesC8& aVideoMimeType )

    {

    PRINT((_L("CCMRMediaRecorderImp::SetVideoCodecL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::SetVideoCodecL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iVideoRecorder->SetVideoCodecL( aVideoMimeType );

    }

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

// CCMRMediaRecorderImp::GetVideoCodecL

// Gets the currently used video codec

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

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

//

void CCMRMediaRecorderImp::GetVideoCodecL( TDes8& aVideoMimeType )

    {

    PRINT((_L("CCMRMediaRecorderImp::GetVideoCodecL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::GetVideoCodecL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iVideoRecorder->GetVideoCodecL( aVideoMimeType );

    }

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

// CCMRMediaRecorderImp::GetSupportedVideoCodecsL

// Gets the supported & installed video codecs. This can be called also before opened

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

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

//

void CCMRMediaRecorderImp::GetSupportedVideoCodecsL( CDesC8Array& aVideoMimeTypes )

    {

    PRINT((_L("CCMRMediaRecorderImp::GetSupportedVideoCodecsL()")));

    iVideoRecorder->GetSupportedVideoCodecsL( aVideoMimeTypes );

    }

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

// CCMRMediaRecorderImp::SetAudioCodecL

// Sets audio codec (overrides the codec given in OpenL).

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

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

//

void CCMRMediaRecorderImp::SetAudioCodecL( const TFourCC& aAudioType )

    {

    PRINT((_L("CCMRMediaRecorderImp::SetAudioCodecL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::SetAudioCodecL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iAudioRecorder->SetAudioCodecL( aAudioType );

    }

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

// CCMRMediaRecorderImp::GetAudioCodecL

// Gets the currently used audio codec

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

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

//

void CCMRMediaRecorderImp::GetAudioCodecL( TFourCC& aAudioType )

    {

    PRINT((_L("CCMRMediaRecorderImp::GetAudioCodecL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::GetAudioCodecL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iAudioRecorder->GetAudioCodecL( aAudioType );

    }

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

// CCMRMediaRecorderImp::GetSupportedAudioCodecsL

// Gets the supported & installed audio codecs. This can be called also before opened

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

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

//

void CCMRMediaRecorderImp::GetSupportedAudioCodecsL( RArray<TFourCC>& aAudioTypes )

    {

    PRINT((_L("CCMRMediaRecorderImp::GetSupportedAudioCodecsL()")));

    iAudioRecorder->GetSupportedAudioCodecsL( aAudioTypes );

    }

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

// CCMRMediaRecorderImp::SetVideoFrameRateL

// Sets video frame rate (capture rate & encoding target rate.

// This can be changed also while recording, but then affects only to encoding frame rate

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

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

//

void CCMRMediaRecorderImp::SetVideoFrameRateL(TReal32 aFrameRate)

    {

    PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameRateL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameRateL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iVideoRecorder->SetFrameRateL(aFrameRate);

    }

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

// CCMRMediaRecorderImp::VideoFrameRateL

// Gets video (encoding) frame rate (capture rate is the same or higher).

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

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

//

TReal32 CCMRMediaRecorderImp::VideoFrameRateL()

    {

    PRINT((_L("CCMRMediaRecorderImp::VideoFrameRateL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::VideoFrameRateL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iVideoRecorder->FrameRateL(iFrameRate);

    return iFrameRate;

    }

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

// CCMRMediaRecorderImp::SetVideoFrameSizeL

// Sets video frame size.

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

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

//

void CCMRMediaRecorderImp::SetVideoFrameSizeL(const TSize& aSize)

    {

    PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameSizeL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameSizeL() wrong state")));

        User::Leave( KErrNotReady );

        }

    // this can't be changed while recording; video recorder is supposed to notice if in wrong state

    // state is changed based on mvroStateChange()

    iVideoRecorder->SetFrameSizeL(aSize);

    // Change audio samplerate based on framesize

    TSize framesize;

    TInt samplerate = 0;

    TInt channelmode = 0;

    iVideoRecorder->FrameSizeL(framesize);

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

		{

		samplerate = iConfig->VideoQualitySettings().iAudioSamplingRate;

		channelmode = iConfig->VideoQualitySettings().iAudioChannels;

		PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameSizeL() setting audio settings using ICM samplerate: %d, channels: %d"), samplerate, channelmode));

		}

	else

		{

	    if ( (framesize.iHeight >= KCMRVGAHeight) && (framesize.iWidth >= KCMRVGAWidth) )

	        {

	        samplerate = KCMRAACAudioSampleRateWithVGA;

	        channelmode = KCMRAACAudioChannelModeWithVGA;

	        PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameSizeL() >=VGA Default audio to samplerate:%d channels:%d"), samplerate, channelmode));

	        }

	    else if ( (framesize.iHeight >= KCMRCIFHeight) && (framesize.iWidth >= KCMRCIFWidth) )

	        {

	        samplerate = KCMRAACAudioSampleRateWithCIF;

	        channelmode = KCMRAACAudioChannelModeWithCIF;

	        PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameSizeL() CIF Default audio to samplerate:%d channels:%d"), samplerate, channelmode));

	        }

	    else if ( (framesize.iHeight >= KCMRQVGAHeight) && (framesize.iWidth >= KCMRQVGAWidth) )

	        {

	        samplerate = KCMRAACAudioSampleRateWithQVGA;

	        channelmode = KCMRAACAudioChannelModeWithQVGA;

	        PRINT((_L("CCMRMediaRecorderImp::SetVideoFrameSizeL() QVGA Default audio to samplerate:%d channels:%d"), samplerate, channelmode));

	        }

	     else

	        {

	        // AAC is not used for lower resolutions.

	        }

		}

    TFourCC currentAudioCodec;

    iAudioRecorder->GetAudioCodecL(currentAudioCodec);

    if ( currentAudioCodec == KCMRFourCCIdMPEG4AAC )

	    {

    	if ( samplerate )

        	{

        	iAudioRecorder->SetTargetSampleRateL( samplerate );

        	}

	    if ( channelmode )

	        {

	        iAudioRecorder->SetChannelModeL( channelmode );

	        }

	    }

    }

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

// CCMRMediaRecorderImp::GetVideoFrameSizeL

// Gets video frame size.

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

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

//

void CCMRMediaRecorderImp::GetVideoFrameSizeL(TSize& aSize) const

    {

    PRINT((_L("CCMRMediaRecorderImp::GetVideoFrameSizeL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::GetVideoFrameSizeL() wrong state")));

        User::Leave( KErrNotReady );

        }

    iVideoRecorder->FrameSizeL(aSize);

    }

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

// CCMRMediaRecorderImp::SetVideoBitRateL

// Sets video bitrate (or KMMFVariableVideoBitRate)

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

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

//

void CCMRMediaRecorderImp::SetVideoBitRateL(TInt aBitRate)

    {

    PRINT((_L("CCMRMediaRecorderImp::SetVideoBitRateL()")));

    if ( iState == EStateNone )

        {

        // not opened yet

        PRINT((_L("CCMRMediaRecorderImp::SetVideoBitRateL() wrong state")));

        User::Leave( KErrNotReady );

        }

    if ( ( iMaxTargetBitRate != KMMFVariableVideoBitRate ) && ( aBitRate != KMMFVariableVideoBitRate ) )

        {

        TInt abr;

        // check that the total bit-rate (audio+video) does not exceed a given limit

            {

            }

        }

    // this can be changed also while recording

    iVideoRecorder->SetTargetBitRateL(aBitRate);

    }

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

// CCMRMediaRecorderImp::VideoBitRateL

// Gets video bitrate.

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

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

//

TInt CCMRMediaRecorderImp::VideoBitRateL()

    {

    PRINT((_L("CCMRMediaRecorderImp::VideoBitRateL()")));

    if ( iState == EStateNone )

        {

        // not opened yet