/*

* 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 input class for handling audio data and giving it to CCMRActiveOutput

*

*/

// INCLUDES

#include "CCMRAudioInput.h"

#include "CCMRAudioInputSW.h"

#include "CCMRAudioInputHW.h"

#include "CCMRActiveOutput.h"

#include "CCMRAudioCodecData.h"

#include "CCMRFifo.h"

#include "CCMRVideoHWParams.h"

#include "CCMRConfigManager.h"

#include <mmf/server/mmfaudioinput.h>

#include <AudioInput.h>

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

#include <mmf/common/mmfaudio.h>            // For KMMFEventCategoryAudioLoadingComplete

// CONSTANTS

// Initial number of buffers allocated

const TInt KCMRNumAudioBuffers = 10;

// MACROS

#define AIASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CCMRAUDIOINPUT"), EInternalAssertionFailure))

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CCMRAudioInputTraces.h"

#endif

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

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

// CCMRAudioInput::~CCMRAudioInput

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

//

CCMRAudioInput::~CCMRAudioInput()

    {

    OstTrace0( CAMERASRV_PERFORMANCE, CCMRAUDIOINPUT_CCMRAUDIOINPUT, "e_CCMRAudioInput::~CCMRAudioInput 1" );

    if ( iInputEmpty )

        {

        delete iInputEmpty;

        iInputEmpty = NULL;

        }

    if ( iInputFilled )

        {

        delete iInputFilled;

        iInputFilled = NULL;

        }

    if ( iOutputFilled )

        {

        delete iOutputFilled;

        iOutputFilled = NULL;

        }

    if ( iOutputEmptied )

        {

        delete iOutputEmptied;

        iOutputEmptied = NULL;

        }

    if ( (!iSrcBufRef) && iDevSoundBuffer )

        {

        delete iDevSoundBuffer;

        iDevSoundBuffer = NULL;

        }

    if ( iProcessingBuffer )

        {

        // we happen to have the last buffer still in process, must delete it now

        delete iProcessingBuffer;

        iProcessingBuffer = NULL;

        }

    if ( iDecConfigInfo )

        {

        delete iDecConfigInfo;

        iDecConfigInfo = NULL;

        // iOutputVideoBuffer is not used with decspecinfo

        }

    if ( iMediaSinkBuffer )

        {

        delete iMediaSinkBuffer;

        iMediaSinkBuffer = NULL;

        }

    iOutputThreadHandle.Close();

    if ( iMutexCreated )

        {

        iMutexObj.Close();

        }

    OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCMRAUDIOINPUT_CCMRAUDIOINPUT, "e_CCMRAudioInput::~CCMRAudioInput 0" );

    }

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

// CCMRAudioInput::ConstructL

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

//

void CCMRAudioInput::ConstructL(CCMRActiveOutput* aOutput, TUint aThreadId, CCMRConfigManager* aConfig )

    {

    PRINT((_L("CCMRAudioInput::ConstructL() in") ));

    iConfig = aConfig; // doesn't own

    iPrioritySettings.iPriority = KAudioPriorityVideoRecording;

    iPrioritySettings.iPref =  TMdaPriorityPreference( KAudioPrefVideoRecording );

    // Create input fifos

    // this fifo is for buffers that are available for storing data from MMFAudioInput/DevSound

    iInputEmpty = CCMRFifo::NewL(KCMRNumAudioBuffers);

    // this fifo is for buffers that are storing data from MMFAudioInput/DevSound

    iInputFilled = CCMRFifo::NewL(KCMRNumAudioBuffers);

    // this fifo is for buffers that contain encoded data and are waiting for sink to retrieve

    iOutputFilled = CCMRFifo::NewL(KCMRNumAudioBuffers);

    // this fifo is for buffers that sink has read and are available for reuse in iOutputFilled

    iOutputEmptied = CCMRFifo::NewL(KCMRNumAudioBuffers);

    iFirstTime = ETrue;

    iFirstBufferRequested = EFalse;

    iTimeStampWhenPaused = TTimeIntervalMicroSeconds(0);

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

    User::LeaveIfError(iMutexObj.CreateLocal());

    iMutexCreated = ETrue;

    iMediaSinkBuffer = new (ELeave) CCMRMediaBuffer();

    iConsumer = aOutput;

    iConsumer->RegisterSourceL( this );

    PRINT((_L("CCMRAudioInput::ConstructL() out") ));

    }

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

// CCMRAudioInput::SetCodecL

//

// Set codec

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

//

void CCMRAudioInput::SetCodecL( CCMRAudioCodecData* aCodecData )

    {

    PRINT((_L("CCMRAudioInput::SetCodecL() in")));

    iCodecData = aCodecData;

    PRINT((_L("CCMRAudioInput::SetCodecL() out")));

    }

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

// CCMRAudioInput::SourcePrimeL

// Primes the source

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

//

void CCMRAudioInput::SourcePrimeL()

    {

    PRINT((_L("CCMRAudioInput::SourcePrimeL()")));

    iDevSoundBuffer = NULL;

    iSendBufCount = 0;

    iFirstTime = ETrue;

    }

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

// CCMRAudioInput::SourceRecordL

// Start recording

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

//

void CCMRAudioInput::SourceRecordL()

    {

    PRINT((_L("CCMRAudioInput::SourceRecordL() in")));

    ConfigDevSoundL();

    iState = EStateRecording;

    iSamplesUpdatedAfterStart = EFalse;

    iFirstBufferRequested = EFalse;

    PRINT((_L("CCMRAudioInput::SourceRecordL() out")));

    }

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

// CCMRAudioInput::SourcePauseL

// Pause recording

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

//

void CCMRAudioInput::SourcePauseL()

    {

    PRINT((_L("CCMRAudioInput::SourcePauseL(), calling iDataSource->SourceStopL")));

    iState = EStateStopping;

    // store the latest timestamp - must do it already here, since sending event may reset it and we should not touch it after reset

  	MMMFAudioInput* audioInput = static_cast<MMMFAudioInput*>(iMMFDataSource);

    CMMFDevSound* devSound = &audioInput->SoundDevice();

    TInt sampleRate = iCodecData->GetSampleRate();

	TBool firstPause = EFalse;

	if (iTimeStampWhenPaused == 0)

		{

		firstPause = ETrue;

		}

    if ( sampleRate )

        {

        TTimeIntervalMicroSeconds currentTimeStamp;

        currentTimeStamp = devSound->SamplesRecorded();

        currentTimeStamp = currentTimeStamp.Int64() * 1000000;

        currentTimeStamp = currentTimeStamp.Int64() / sampleRate;

        iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + currentTimeStamp.Int64();

        }

    else

        {

        iTimeStampWhenPaused = 0;

        }

   	TInt initialDelay = 0;

    // Add A/V sync constant to paused timestamp

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

		{

		PRINT((_L("CCMRAudioInput::SourcePauseL(), using ICM setting value for AVsync delay")));

		iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + (iConfig->VideoQualitySettings().iAVSyncResumeDelay*1000);

		initialDelay = iConfig->VideoQualitySettings().iAVSyncStartDelay;

		}

	else

		{

		initialDelay = KCMRInitialVideoAudioTimeSyncDC;

		if ( sampleRate <= KCMRPauseVideoAudioTimeSyncDC_LowSampleRateValue )

		    {

		    PRINT((_L("CCMRAudioInput::SourcePauseL(), using LowSampleRateValue")));

		    iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + (KCMRPauseVideoAudioTimeSyncDC_LowSampleRate*1000);

		    }

		else if ( sampleRate <= KCMRPauseVideoAudioTimeSyncDC_MidSampleRateValue )

			{

		    PRINT((_L("CCMRAudioInput::SourcePauseL(), using MidSampleRateValue")));

		    iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + (KCMRPauseVideoAudioTimeSyncDC_MidSampleRate*1000);

			}

		else

		    {

		    iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + (KCMRPauseVideoAudioTimeSyncDC*1000);

		    }

		}

    // Add startdelay if first pause.

    if ( firstPause )

	    {

	    // only add start delay if we haven't been paused. Only add delay after first audio available

		if ( initialDelay < 0 )

			{

			if ( iTimeStampWhenPaused > -(initialDelay*1000) )

				{

				iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + (initialDelay*1000);

				}

			else

				{

				iTimeStampWhenPaused = 0;

				}

			}

		else

			{

			iTimeStampWhenPaused = iTimeStampWhenPaused.Int64() + (initialDelay*1000);

			}

	    }

    // Stop audio.

    PRINT((_L("CCMRAudioInput::SourceStopL() DevSound SourceStopL()")));

    devSound->Stop();

    if ( iOutputFilled->IsEmpty() )

        {

        PRINT((_L("CCMRAudioInput::SourcePauseL(), no data buffers queued so no chance to signal end of data; sending an event instead")));

        TMMFEvent event (KMMFEventCategoryPlaybackComplete, KErrNone);

    	iEventHandler.SendEventToClient(event);

        }

    PRINT((_L("CCMRAudioInput::SourcePauseL() out")));

    }

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

// CCMRAudioInput::SourceStopL

// Stop playing (recording)

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

//

void CCMRAudioInput::SourceStopL()

    {

    PRINT((_L("CCMRAudioInput::SourceStopL() in")));

    if ( iState != EStateStopping )

        {

        // we came here without pause => there was an error, must stop source

        PRINT((_L("CCMRAudioInput::SourceStopL() DevSound SourceStopL()")));

        MMMFAudioInput* audioInput = static_cast<MMMFAudioInput*>(iMMFDataSource);

        CMMFDevSound* devSound = &audioInput->SoundDevice();

        devSound->Stop();

        iFirstBufferRequested = EFalse;

        }

    // else data source was already stopped in pause

    iState = EStateStopped;

    PRINT((_L("CCMRAudioInput::SourceStopL() out")));

    }

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

// CCMRAudioInput::SetSourcePrioritySettings

// Set priority settings to source

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

//

void CCMRAudioInput::SetSourcePrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

    {

    iPrioritySettings = aPrioritySettings;

    MMMFAudioInput* audioInput = static_cast<MMMFAudioInput*>(iMMFDataSource);

    CMMFDevSound* devSound = &audioInput->SoundDevice();

    devSound->SetPrioritySettings(aPrioritySettings);

    }

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

// CCMRAudioInput::SoundDevice

// Get reference to DevSound from MMFAudioInput

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

//

CMMFDevSound& CCMRAudioInput::SoundDevice()

    {

	MMMFAudioInput* audioInput = static_cast<MMMFAudioInput*>(iMMFDataSource);

    return audioInput->SoundDevice();

    }

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

// CCMRAudioInput::ResetTimeStamp

//

// Resets audio timestamp before new recording; can't be reset automatically

// in stop/play since they are used also in pause/resume when the stamp should

// not reset

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

//

void CCMRAudioInput::ResetTimeStamp()

    {

    iTimeStampWhenPaused = TTimeIntervalMicroSeconds(0);

    iNumFramesReceived = 0;

    iDecConfigInfoChecked = EFalse;

    iSamplesUpdatedAfterStart = EFalse;

    iLatestTimeStamp = 0;

    }

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

// CCMRAudioInput::SendEventToClient

// Stop & send event (error) to client

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

//

void CCMRAudioInput::SendEventToClient(const TMMFEvent& aEvent)

	{

    PRINT((_L("CCMRAudioInput::SendEventToClient() in, event & error, %x & %d"), aEvent.iEventType, aEvent.iErrorCode));

    TRAPD(error,SourceStopL()); // errors can be ignored, we are already reporting an error here

    if (error != KErrNone)

        {

        PRINT((_L("CCMRAudioInput::SendEventToClient() stop error: %d"), error));

        }

	iEventHandler.SendEventToClient(aEvent);

    PRINT((_L("CCMRAudioInput::SendEventToClient() out")));

	}

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

// CCMRAudioInput::NewBufferL

// Inform sink about new coded buffer, and store it in iOutputCoded unless there

// aren't any older buffer under processing

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

//

void CCMRAudioInput::NewBufferL(CMMFBuffer* aBuffer)

    {

    // enter restricted area

    iMutexObj.Wait();

    CMMFBuffer* storeBuffer = NULL;

    storeBuffer = aBuffer;

    TInt bufLength = storeBuffer->BufferSize();

    TInt frameLength = 1;   // set to 1 since nonzero needed as the initial value in the while-loop below

    TUint8* data = const_cast<TUint8*>((static_cast<CMMFDataBuffer*>(storeBuffer))->Data().Ptr());

    while ( (bufLength > 0) && (frameLength > 0) )

        {

        frameLength = iCodecData->FrameLength( data, bufLength );

        bufLength -= frameLength;

        data += frameLength;

        iNumFramesReceived++;

        iNumFramesWaiting++;

        }

    TInt error = KErrNone;

    if ( iProcessingBuffer )

        {

        // there is one under processing, store this one to fifo

        TRAP(error, iOutputFilled->PutL( reinterpret_cast<TAny*>(storeBuffer) ));

        PRINT((_L("CCMRAudioInput::NewBufferL() added %x to fifo. Fifo size %d"), storeBuffer, iOutputFilled->NumberOfItems() ));

        }

    else

        {

        // take it into use immediately

        iProcessingBuffer = static_cast<CMMFDataBuffer*>(storeBuffer);

        iProcessingIndex = 0;

        iSrcNumUnreadBytes = storeBuffer->BufferSize();

        PRINT((_L("CCMRAudioInput::NewBufferL() taken buffer into iProcessingBuffer %x, size %d"), storeBuffer, iSrcNumUnreadBytes ));

        }

    // signal to sink

    if ( ( error == KErrNone ) && iSinkRequestStatus  )

        {

        PRINT((_L("CCMRAudioInput::EmptyBufferL() RequestComplete")));

        iOutputThreadHandle.RequestComplete( iSinkRequestStatus, KErrNone );

        }

    else

        {

        // else a new request has not been issued yet; this buffer will be handled jointly with previous ones

        PRINT((_L("CCMRAudioInput::NewBufferL() skipping RequestComplete")));

        }

    // leave restricted area

    iMutexObj.Signal();

    if ( error != KErrNone )

        {

        // leave postponed here to get out of mutex

        PRINT((_L("CCMRAudioInput::NewBufferL() leave with error code %d"), error));

        User::Leave( error );

        }

    }

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

// CCMRAudioInput::FillBufferL

// Ask new buffers from devsound.

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

//

void CCMRAudioInput::FillBufferL()

    {

    PRINT((_L("CCMRAudioInput::FillBufferL() in")));

    //this is a one-shot "prime" funtion for MMFDevSound as first buffer is uninitialised

    MMMFAudioInput* audioInput = static_cast<MMMFAudioInput*>(iMMFDataSource);

    CMMFDevSound* devSound = &audioInput->SoundDevice();

    if (!iFirstBufferRequested)

        {

        PRINT((_L("CCMRAudioInput::FillBufferL() DevSound RecordInitL")));

        devSound->RecordInitL();

        iFirstBufferRequested = ETrue;

        PRINT((_L("CCMRAudioInput::FillBufferL() out")));

        return;

        }

    PRINT((_L("CCMRAudioInput::FillBufferL() DevSound RecordData")));

    devSound->RecordData();

    PRINT((_L("CCMRAudioInput::FillBufferL() out")));

    }

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

// CCMRAudioInput::RequestNewData

// Output active object is ready to accept new data

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

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

//

void CCMRAudioInput::RequestNewData(TRequestStatus& aStatus)

    {

	PRINT((_L("CCMRAudioInput::RequestNewData() - START - aStatus: 0x%08x, iSinkRequestStatus: 0x%08x"), &aStatus, iSinkRequestStatus ));

    // enter restricted area

    iMutexObj.Wait();

    iSinkRequestStatus = &aStatus;

    aStatus = KRequestPending;

    // leave restricted area

    iMutexObj.Signal();

	PRINT((_L("CCMRAudioInput::RequestNewData() - END - aStatus: 0x%08x, iSinkRequestStatus: 0x%08x"), &aStatus, iSinkRequestStatus ));

    }

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

// CCMRAudioInput::RequestNewDataCancel

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

//

void CCMRAudioInput::RequestNewDataCancel(TRequestStatus& aStatus)

    {

	PRINT((_L("CCMRAudioInput::RequestNewDataCancel() - START - aStatus: 0x%08x, iSinkRequestStatus: 0x%08x"), &aStatus, iSinkRequestStatus ));

    // enter restricted area

    iMutexObj.Wait();

	if ( &aStatus == iSinkRequestStatus )

		{

		iOutputThreadHandle.RequestComplete( iSinkRequestStatus, KErrCancel );

		}

    // leave restricted area

    iMutexObj.Signal();

	PRINT((_L("CCMRAudioInput::RequestNewDataCancel() - END - aStatus: 0x%08x, iSinkRequestStatus: 0x%08x"), &aStatus, iSinkRequestStatus ));

    }

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

// CCMRAudioInput::GetNextBuffer

// Output active object takes the next output buffer

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

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

//

CCMRMediaBuffer* CCMRAudioInput::GetNextBuffer()

    {

    PRINT((_L("CCMRAudioInput::GetNextBuffer() in")));

    if ( (!iDecConfigInfoChecked) && (iState == EStateRecording)  )

        {

        // check if we have to provide decoder config info first

        iDecConfigInfoChecked = ETrue;

        TRAPD(err,

            {

            iDecConfigInfo = iCodecData->GetDecoderConfigInfoLC();

            if ( iDecConfigInfo != NULL )

                {