/*

* Copyright (c) 2004 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:  Audio recorder class. Client side for audio thread

*

*/

// INCLUDE FILES

#include    "CCMRAudioRecorder.h"

#include    "CCMRSupportedCodecs.h"

#include    "CCMRAudioCodecs.h"

#include    "CCMRAudioCodecData.h"

#include    "CCMRActiveOutput.h"

#include    "CCMRVideoHWParams.h"

#include    <mmf/server/mmfdatabuffer.h>

#include    <mmf/server/mmfaudioinput.h>

#include 	<AudioPreference.h>                // For MMF audio preference definitions.

// MACROS

// Assertion macro wrapper for code cleanup

#define ARASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CCMRAUDIORECORDER"), EInternalAssertionFailure)) 

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

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

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

// CCMRAudioRecorder::CCMRAudioRecorder

//

// Default constructor.

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

//

CCMRAudioRecorder::CCMRAudioRecorder()

    {

    iObserver = NULL;

    iDataSource = NULL;

    iThreadCreated = EFalse;

    }

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

// CCMRAudioRecorder::~CCMRAudioRecorder

//

// Destructor.

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

//

CCMRAudioRecorder::~CCMRAudioRecorder()

    {

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

    delete iThreadEventMonitor;

    iThreadEventMonitor = NULL;

    if ( iThreadCreated )

        {

        iThreadProxy.Close();

        }

    //audio thread already logs off audio source (=> deletes it)

    PRINT((_L("CCMRAudioRecorder::~CCMRAudioRecorder() thread closed")));

    iObserver = NULL;

    iDataSource = NULL;

    iOutputAO = NULL;

    delete iAudioCodecs;

    iAudioCodecs = NULL;

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

    }

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

// CCMRAudioRecorder::NewL

//

// Two-phased constructor.

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

//

CCMRAudioRecorder* CCMRAudioRecorder::NewL()

    {

    CCMRAudioRecorder* self = new (ELeave) CCMRAudioRecorder;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCMRAudioRecorder::ConstructL

//

// Symbian 2nd phase constructor.

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

//

void CCMRAudioRecorder::ConstructL()

    {

    SetState(EStateNone);

    iPrioritySettings.iPriority = KAudioPriorityVideoRecording;

    iPrioritySettings.iPref =  TMdaPriorityPreference( KAudioPrefVideoRecording );

    RArray<TFourCC> audioTypes;

    CleanupClosePushL( audioTypes );

    audioTypes.Reset();

    iAudioCodecs = CCMRAudioCodecs::NewL();

    iAudioCodecs->GetSupportedAudioCodecsL( audioTypes );

    // audioTypes have always >= 1 element now

    if ( audioTypes.Count() > 0 )

        {

        iAudioCodecFourCC = TFourCC(audioTypes[0]);

        iAudioCodecs->SetAudioCodecL( iAudioCodecFourCC );

        CCMRRecorderBase::SetTargetBitRateL( iAudioCodecs->GetCodecDataL()->GetBitRateL() );

        }

    else

        {

        // no audio codecs exist. Must anyway create audio recorder, since mediarecorder should work also video-only and codec support is checked later

        iAudioCodecFourCC = TFourCC(' ',' ',' ',' ');

        }

    CleanupStack::PopAndDestroy( &audioTypes ); // calls also audioTypes.Close()

    }

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

// CCMRAudioRecorder::OpenL

//

// Open recorder. This is like audio controller's AddSource

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

//

void CCMRAudioRecorder::OpenL(MCMRAudioRecorderObserver *aObserver, MDataSource *aSource, 

                              CCMRActiveOutput* aOutputAO, const TFourCC& aAudioType, CCMRConfigManager* aConfig )

    {

    PRINT((_L("CCMRAudioRecorder::OpenL() in")));

    if ( State() != EStateNone ) 

        {

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

        User::Leave( KErrAlreadyExists );

        }

    // save the references/pointers

    iObserver = aObserver;

    iConfig = aConfig;

    iConfig->SetAudioCodec( iAudioCodecFourCC );

    // check the source type

    if ( aSource && aSource->DataSourceType() != KUidMmfAudioInput)

        {

        PRINT((_L("CCMRAudioRecorder::OpenL() unsupported source")));

        User::Leave(KErrNotSupported);

        }

    iDataSource = aSource;

    iOutputAO = aOutputAO;

    // create thread for audio 

    User::LeaveIfError(iThreadProxy.CreateSubThread(iThreadCreated));

    User::LeaveIfError(iThreadProxy.SetOutput(iOutputAO));

    iThreadEventMonitor = CCMRSubThreadEventMonitor::NewL(*this, iThreadProxy); 

    iThreadEventMonitor->Start();

    // add data source => we will be connected also to DevSound and then we can use e.g. gain settings

    if (iDataSource)

        {

        User::LeaveIfError(iThreadProxy.AddDataSource(iDataSource));

        }

    // set config manager to thread

    User::LeaveIfError(iThreadProxy.SetConfigManager( aConfig ));

    // SetAudioCodec requires we are at least open

    SetState( EStateOpen );

    iObserver->MaroStateChange( State() );

    SetAudioCodecL( aAudioType );

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

    }

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

// CCMRAudioRecorder::SetAudioCodecL

//

// Set audio codec to be used (overrides the one given in OpenL)

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

//

void CCMRAudioRecorder::SetAudioCodecL( const TFourCC& aAudioType )

    {

    PRINT((_L("CCMRAudioRecorder::SetAudioCodecL() in")));    

    if ( ( State() != EStateOpen ) && ( State() != EStateReadyToRecord ) )

        {

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

        User::Leave(KErrNotReady);

        }

    if ( aAudioType != iAudioCodecFourCC )

        {

        iAudioCodecs->SetAudioCodecL( aAudioType );

        iAudioCodecFourCC = aAudioType;

        iConfig->SetAudioCodec(iAudioCodecFourCC);

        SetState( EStateOpen );

        iObserver->MaroStateChange( State() );

        }

    PRINT((_L("CCMRAudioRecorder::SetAudioCodecL() out")));        

    }

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

// CCMRAudioRecorder::GetAudioCodecL

// Get the used audio codec.

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

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

//

void CCMRAudioRecorder::GetAudioCodecL( TFourCC& aAudioType ) const

    {

    if ( (State() == EStateNone) || (iAudioCodecs->GetCodecDataL() == NULL) )

        {

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

        User::Leave(KErrNotReady);

        }

    aAudioType = iAudioCodecs->GetCodecDataL()->GetCodecFourCCL();

    }

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

// CCMRAudioRecorder::GetSupportedAudioCodecsL

// Get the supported & installed audio codecs.

// This can be called also when the recorder is not open

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

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

//

void CCMRAudioRecorder::GetSupportedAudioCodecsL( RArray<TFourCC>& aAudioTypes ) const

    {

    aAudioTypes.Reset();

    iAudioCodecs->GetSupportedAudioCodecsL( aAudioTypes );

    }

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

// CCMRAudioRecorder::SetPriorityL

//

// Set audio priority (for DevSound)

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

//

void CCMRAudioRecorder::SetPriorityL(const TMMFPrioritySettings& aPrioritySettings)

    {

    if ( State() == EStateNone || State() == EStateRecording || State() == EStatePaused )

        {

        PRINT((_L("CCMRAudioRecorder::SetPriorityL() wrong state")));

        User::Leave(KErrNotReady);

        }

    if ( aPrioritySettings.iPriority < EMdaPriorityMin || aPrioritySettings.iPriority > EMdaPriorityMax )

        {

        // outside allowed range

        PRINT((_L("CCMRAudioRecorder::SetPriorityL() unsupported priority")));

        User::Leave( KErrArgument );

        }

    iPrioritySettings = aPrioritySettings;

    SetState( EStateOpen );

    iObserver->MaroStateChange( State() );

    }

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

// CCMRAudioRecorder::SetTargetBitRateL

//

// Set audio bitrate. Note: checked only in PrepareL

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

//

void CCMRAudioRecorder::SetTargetBitRateL(TInt aBitRate)

    {

    PRINT((_L("CCMRAudioRecorder::SetTargetBitRateL() in")));

    if ( (( State() != EStateOpen ) && ( State() != EStateReadyToRecord )) || (iAudioCodecs->GetCodecDataL() == NULL) )

        {

        PRINT((_L("CCMRAudioRecorder::SetTargetBitRateL() wrong state")));

        User::Leave(KErrNotReady);

        }

    iAudioCodecs->GetCodecDataL()->SetBitRateL( aBitRate );

    // if we are here, the bitrate was ok, store it also here since the system assumes recorder class stores it

    CCMRRecorderBase::SetTargetBitRateL( aBitRate );

    SetState( EStateOpen );

    iObserver->MaroStateChange( State() );

    PRINT((_L("CCMRAudioRecorder::SetTargetBitRateL() out")));

    }

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

// CCMRAudioRecorder::SetTargetSampleRateL

//

// Set audio samplerate. AAC only.

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

//

void CCMRAudioRecorder::SetTargetSampleRateL(TInt aSampleRate)

    {

    PRINT((_L("CCMRAudioRecorder::SetTargetSampleRateL() in, samplerate=%d"),aSampleRate));

    if ( (( State() != EStateOpen ) && ( State() != EStateReadyToRecord )) || (iAudioCodecs->GetCodecDataL() == NULL) )

        {

        PRINT((_L("CCMRAudioRecorder::SetTargetSampleRateL() wrong state")));

        User::Leave(KErrNotReady);

        }

    iAudioCodecs->GetCodecDataL()->SetSampleRateL( aSampleRate );

    SetState( EStateOpen );

    iObserver->MaroStateChange( State() );

    PRINT((_L("CCMRAudioRecorder::SetTargetSampleRateL() out")));

    }    

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

// CCMRAudioRecorder::SetChannelModeL

//

// Set audio channel mode. AAC only.

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

//

void CCMRAudioRecorder::SetChannelModeL(TInt aChannelMode)

    {

    PRINT((_L("CCMRAudioRecorder::SetChannelModeL() in, channelmode=%d"), aChannelMode));

    if ( (( State() != EStateOpen ) && ( State() != EStateReadyToRecord )) || (iAudioCodecs->GetCodecDataL() == NULL) )

        {

        PRINT((_L("CCMRAudioRecorder::SetChannelModeL() wrong state")));

        User::Leave(KErrNotReady);

        }

    iAudioCodecs->GetCodecDataL()->SetChannelModeL( aChannelMode );

    SetState( EStateOpen );

    iObserver->MaroStateChange( State() );

    PRINT((_L("CCMRAudioRecorder::SetChannelModeL() out")));

    }

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

// CCMRAudioRecorder::MaxGainL

//

// Get maximum gain from audio input

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

//

TInt CCMRAudioRecorder::MaxGainL()

    {

    PRINT((_L("CCMRAudioRecorder::MaxGainL() in")));

    if ( State() == EStateNone )

        {

        PRINT((_L("CCMRAudioRecorder::MaxGainL() wrong state")));

        User::Leave( KErrNotReady );

        }

    // check max gain from sound device

    TInt gain;

    User::LeaveIfError( iThreadProxy.MaxGain( gain ));

    PRINT((_L("CCMRAudioRecorder::MaxGainL() almost out, max gain %d"),gain));

    return gain;

    }

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

// CCMRAudioRecorder::GainL

//

// Get current gain from audio input

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

//

TInt CCMRAudioRecorder::GainL()

    {

    PRINT((_L("CCMRAudioRecorder::GainL() in")));

    if ( State() == EStateNone )

        {

        PRINT((_L("CCMRAudioRecorder::GainL() wrong state")));

        User::Leave( KErrNotReady );

        }

    // check current gain from sound device

    TInt gain;

    User::LeaveIfError( iThreadProxy.GetGain( gain ));

    PRINT((_L("CCMRAudioRecorder::GainL() almost out, gain %d"),gain));

    return gain;

    }

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

// CCMRAudioRecorder::SetGainL

//

// Sets gain for audio input. Can be done before and during recording 

// and is effective immediately

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

//

void CCMRAudioRecorder::SetGainL(TInt aGain)

    {

    PRINT((_L("CCMRAudioRecorder::SetGainL() in")));

    if ( State() == EStateNone )

        {

        PRINT((_L("CCMRAudioRecorder::SetGainL() wrong state")));

        User::Leave( KErrNotReady );

        }

    if ( aGain >= 0 ) 

        {

        User::LeaveIfError( iThreadProxy.SetGain(aGain));

        PRINT((_L("CCMRAudioRecorder::SetGainL() out")));

        }

    else

        {

        PRINT((_L("CCMRAudioRecorder::SetGainL() out due to illegal argument: %d"),aGain));

        User::Leave( KErrArgument );

        }

    }

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

// CCMRAudioRecorder::GetThreadPriority

//

// Get audio thread priority

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

//

TThreadPriority CCMRAudioRecorder::GetThreadPriority() const

    {

    return iThreadProxy.GetThreadPriority();

    }

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

// CCMRAudioRecorder::PrepareL

//

// Prepare recorder for recording (freeze settings / implements PrimeL)

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

//

void CCMRAudioRecorder::PrepareL()

    {

    PRINT((_L("CCMRAudioRecorder::PrepareL() in    ")));

    if ( (State() != EStateOpen) && (State() != EStateReadyToRecord) )

        {

        PRINT((_L("CCMRAudioRecorder::PrepareL() wrong state")));

        User::Leave( KErrNotReady );

        }

    if ( !iThreadCreated )

        {

        PRINT((_L("CCMRAudioRecorder::PrepareL() no thread")));

        User::Leave( KErrNotReady );

        }

    // set priority settings

    User::LeaveIfError( iThreadProxy.SetPriority(iPrioritySettings));    

    // give handle to the audio codec

    User::LeaveIfError( iThreadProxy.SetAudioCodec( iAudioCodecs->GetCodecDataL() ) );

    // inform sink about average audio bitrate

    User::LeaveIfError( iOutputAO->SetAverageAudioBitRate(iAudioCodecs->GetCodecDataL()->GetBitRateL()) );

    // prime the audio thread

    User::LeaveIfError(iThreadProxy.Prime());

    PRINT((_L("CCMRAudioRecorder::PrepareL(), iThreadProxy.Prime() done") ));

    //no need to be in preparing state; prepare is synchronous

    SetState( EStateReadyToRecord );

    iObserver->MaroStateChange( State() );

    PRINT((_L("CCMRAudioRecorder::PrepareL() out    ")));

    }

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

// CCMRAudioRecorder::RecordL

//

// Start recording

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

//

void CCMRAudioRecorder::RecordL()

    {

    PRINT((_L("CCMRAudioRecorder::RecordL() in    ")));

    if ( (State() == EStateRecording) || (State() == EStatePaused) )

        {

        // ignore, already recording

        return;

        }

    if ( State() != EStateReadyToRecord )

        {

        PRINT((_L("CCMRAudioRecorder::RecordL() wrong state")));

        User::Leave(KErrNotReady);

        }

    if ( State() == EStateReadyToRecord )

        {

        User::LeaveIfError(iThreadProxy.Play());

        SetState( EStateRecording );

        iObserver->MaroStateChange( State() );

        }

    PRINT((_L("CCMRAudioRecorder::RecordL() out    ")));

    }

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

// CCMRAudioRecorder::StopL

//

// Stop recording

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

//

void CCMRAudioRecorder::StopL()

    {

    PRINT((_L("CCMRAudioRecorder::StopL() in    ")));

    if ( (State() == EStateRecording) || (State() == EStatePaused) )