/*

* Copyright (c) 2005-2009 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 CBTSACStreamerController class. This class constructs and

*				 communicates with 'BT Audio Streamer' component to do RTP streaming.

*

*/

// INCLUDE FILES

#include "btsacStreamerController.h"

#include "debug.h"

// Subband codec-specific values

// in bluetoothAV.h

using namespace SymbianSBC;      

// CONSTANTS

_LIT(KBTAADLL, "btaudioadaptation.dll");

const TInt KRetryTimerDelay = 2000000;		// 2 seconds. If something fails, how soon should we retry. 

const TInt KStabilizationDelay = 2000000;	// 2 seconds. Wait this long after bitpool change then start mononitor packet drops again

const TInt KDataCollectDelay = 600000; 		// Time (600ms) to collect packet drop data

// All tables below have to formed such a way that highest max bitpool value has to be in position 0 and etc.

const TInt KMaxBitpoolValues[] = {59, 48, 40, 34}; // Max bitpool values

const TInt KDeviationValues[] = {1000, 100000, 300000, 300000}; // maximum time (ys) between first and last packet dropped event

const TInt KNumOfBitpoolValues = sizeof(KMaxBitpoolValues)/sizeof(TInt);

#define MAXBITPOOLVALUEMAX KMaxBitpoolValues[0]

#define MAXBITPOOLVALUEMIN KMaxBitpoolValues[KNumOfBitpoolValues-1]

const float KReconfigureLimitFactor = 0.02; // 2% of during KDataCollectDelay transferred data

const float KLimitCheckInterval = ((float)KDataCollectDelay/1000000.0); // Time (seconds) to collect packet drop data

// MODULE DATA STRUCTURES

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

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

// CBTSACStreamerController::NewL

// Two-phased constructor.

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

//

CBTSACStreamerController* CBTSACStreamerController::NewL(MBTAudioAdaptationObserver& aObserver )

    {

    CBTSACStreamerController* self = new (ELeave) CBTSACStreamerController (aObserver);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CBTSACStreamerController::~CBTSACStreamerController()

    {

    TRACE_FUNC

    Cancel();

    if(iAudioInput)

	    {

	    iAudioInput->Stop();

	    iAudioInput->Disconnect();

	    }

    delete iPacketDropIoctl;

    delete iEncoderCI;

    delete iBTStreamer;

    delete iAudioInput;

    iLib.Close();

	iTimer.Close(); 

	iBitpoolData.Close();

    TRACE_INFO((_L("CBTSACStreamerController::~CBTSACStreamerController() completed")))

    }

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

// CBTSACStreamerController::CBTSACStreamerController

// C++ default constructor.

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

//

CBTSACStreamerController::CBTSACStreamerController(MBTAudioAdaptationObserver& aObserver)

    : CActive( EPriorityNormal ), iObserver(aObserver)

    {

	CActiveScheduler::Add(this);

    }

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

// CBTSACStreamerController::ConstructL

// Symbian 2nd phase constructor.

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

//

void CBTSACStreamerController::ConstructL( )

    {

    TRACE_FUNC

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

	iThread = RThread();

	iBTStreamer = CBTAudioStreamer::NewL();

    LEAVE_IF_ERROR( iLib.Load( KBTAADLL ) );

    typedef TInt (*TOurLibraryFunction2)(MBTAudioStreamObserver&, MBTAudioErrorObserver&);

    TOurLibraryFunction2 newL2 = reinterpret_cast<TOurLibraryFunction2>(iLib.Lookup(1));

    iAudioInput = (CBTAudioStreamInputBase*)newL2(*iBTStreamer, *this);       

	TInt ret;

	ret = iAudioInput->Connect();

	if (ret) 

		{

		TRACE_INFO((_L("CBTSACStreamerController::ConstructL() Audio Input Connect Error %d"), ret))

		User::Leave(ret); 

		}

	ret = iAudioInput->SetFormat(KMMFFourCCCodeSBC);	

	if (ret)

   		{

 		TRACE_INFO((_L("CBTSACStreamerController::ConstructL() Audio Input SetFormat Error %d"), ret))

  		User::Leave(ret);

 		}

    iEncoderCI = reinterpret_cast<CSbcEncoderIntfc *> (iAudioInput->EncoderInterface(KUidSbcEncoderIntfc));

	User::LeaveIfNull(iEncoderCI);

	InitializeBitpoolDataL();

    iState = EStateIdle;

    TRACE_INFO((_L("CBTSACStreamerController::ConstructL() completed")))

    }

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

// CBTSACStreamerController::StartStream

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

//

TInt CBTSACStreamerController::StartStream(RSocket& aSocket, TInt aFrameLength )

	{

	TRACE_FUNC

	if (!(iBTStreamer) || !(iAudioInput) )    

		{

		return KErrNotFound;	

		}

    if (iState == EStateError)

    	{

    	iState = EStateIdle;

    	TInt err = iAudioInput->Connect();

		if (!err) 

			{

			err = iAudioInput->SetFormat(KMMFFourCCCodeSBC);

			}    	

		if (err)

	   		{

	   		TRACE_INFO((_L("CBTSACStreamerController::StartStream() Audio Input initialization Error %d"), err))

	  		return err;

	 		}

    	}

    if (iState == EStateIdle)    

    	{

	    TInt err = KErrNone;

	    TRAP( err, iBTStreamer->StartL(aSocket, aFrameLength, iAudioInput, iCurrentBitrate));

	    if ( err == KErrNone )

	    	{

	    	err = iAudioInput->Start(); 	

	    	}

		if ( err == KErrNone )

			{			

			TRACE_INFO((_L("CBTSACStreamerController::StartStream() Sending packet drop IOCTL")))

    		TRAP( err, iPacketDropIoctl = CActivePacketDropIoctl::NewL(*this, aSocket));

    		if( err == KErrNone )

    			{

    			iPacketDropDeviation = 0;

				iTotalNbrOfDroppedPackets = 0;

    			iState = EStateStreaming;

				if(iCurrentBitpoolData->iMaxBitpoolValue < iMatchCap.MaxBitpoolValue())

					{

					TRACE_INFO((_L("CBTSACStreamerController::StartStream(), upgrade bitrate.")))

					// Streaming was stopped when the bitrate was lower than maximum, so upgrade it for starters.

					// iPacketDropIoctl->Start will be called after self completion.

					// Update current bitpool data to be highest possible. Highest possible bitpool value can be found from position 

					iCurrentBitpoolData = GetBitpoolData(0);

					if(iCurrentBitpoolData)

						{

						DoSelfComplete(EUpgradeBitrate, KErrNone);

						}

					else

						{

						err = KErrArgument;

						}

					}

				else if(iMatchCap.MaxBitpoolValue() > iBitpoolData[iBitpoolData.Count() - 1].iMaxBitpoolValue)

					{

					// Don't start receive packet drop events if max bitpool value is not bigger than min

					// bitpool value (we can't downgrade bitpool, we already have lowest possible value).

					DoSelfComplete(EStartStabilizingTimer, KErrNone);

					}

				TRACE_INFO((_L("CBTSACStreamerController::StartStream() completed")))

    			}

	    	}

	    if( err )

	    	{

	    	// In case someting went wrong stop both audio adaptation and streamer

	    	TRACE_INFO((_L("CBTSACStreamerController::StartStream() *Error: %d"), err))

	    	iAudioInput->Stop();

	    	iAudioInput->Disconnect();

	    	iBTStreamer->Stop();

	    	//make sure iAudioInput->Connect() & SetFormat() get called in StartStream()

	    	iState = EStateError;

	    	}

	    return err;

    	}

    else

    	{

    	return KErrAlreadyExists;

    	}

	}

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

// CBTSACStreamerController::StopStream

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

//

TInt CBTSACStreamerController::StopStream()

	{

	TRACE_FUNC

    Cancel();

   	if (!(iBTStreamer) || !(iAudioInput))    

		{

		return KErrNotFound;	

		}

    else if (iState != EStateIdle )

    	{

      	iAudioInput->Stop();

      	iBTStreamer->Stop();

	   	delete iPacketDropIoctl; 

	   	iPacketDropIoctl = NULL; 

	   	iState = EStateIdle;    

	 	return KErrNone;	

    	}

    else

    	{

    	return KErrAlreadyExists; 

    	}

	}

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

// CBTSACStreamerController::ResetAudioInput

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

//

void CBTSACStreamerController::ResetAudioInput()

	{

	TRACE_FUNC

	iAudioInput->Stop();

	iAudioInput->Disconnect();

    TInt err = iAudioInput->Connect();

	if (!err) 

		{

		err = iAudioInput->SetFormat(KMMFFourCCCodeSBC);

		}    	

	if (err)

		{

		TRACE_INFO((_L("CBTSACStreamerController::ResetAudioInput() Audio Input initialization Error %d"), err))

		}	

	}

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

// CBTSACStreamerController::FillCapabilities

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

//	

TInt CBTSACStreamerController::FillCapabilities( TSBCCodecCapabilities& aSbc )

	{

	TRACE_FUNC

	TUint8 itemp = 0x00; 

    // Sampling Frequency

    TInt ret;

	RArray<TUint> SupportedSamplingFrequencies; 

	ret = iEncoderCI->GetSupportedSamplingFrequencies(SupportedSamplingFrequencies); 

	if ( !ret)

		{

		 itemp = 0x00; 

		 for (TInt i=0; i<SupportedSamplingFrequencies.Count(); i++ )

		 	{

			 if ( SupportedSamplingFrequencies[i] == TUint(16000) )

			 	{

				itemp = E16kHz;	// 	E16kHz		= 0x8 

				continue; 

			 	}

			 if ( SupportedSamplingFrequencies[i] == TUint(32000) )

			 	{

			 	itemp |= E32kHz; //	E32kHz		= 0x4

			 	continue; 

			 	}

			 if ( SupportedSamplingFrequencies[i] == TUint(44100) )

			 	{

			 	itemp |= E44100Hz;	// E44100Hz	= 0x2

			 	continue; 

				}

			 if ( SupportedSamplingFrequencies[i] == TUint(48000) )

			 	{

			 	itemp |= E48kHz;	// E48kHz	= 0x1

			 	continue; 

			 	}

		 	}

		 aSbc.SetSamplingFrequencies(itemp);

		 TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder Sampling Frequencies: %d"), itemp))

		}

	else

		{

		return ret; 

		}

	// Channel mode

    RArray<CSbcEncoderIntfc::TSbcChannelMode> SupportedChannelModes; 

    ret = iEncoderCI->GetSupportedChannelModes(SupportedChannelModes);

	if ( !ret )

		{

		 itemp = 0x00; 

		 for (TInt i=0; i<SupportedChannelModes.Count(); i++ )

		 	{

			 if ( SupportedChannelModes[i] ==  CSbcEncoderIntfc::ESbcChannelMono)

			 	{

				itemp = EMono;	// 	EMono			= 0x8	 		 		

				continue;		 		

			 	}

			 if ( SupportedChannelModes[i] == CSbcEncoderIntfc::ESbcChannelDual )

			 	{

		 		itemp |= EDualChannel;	// 	EDualChannel	= 0x4

			 	continue;

			 	}

			 if ( SupportedChannelModes[i] == CSbcEncoderIntfc::ESbcChannelStereo )

			 	{

				itemp |= EStereo;	// 	EStereo			= 0x2	 		

			 	continue;

				}

			 if ( SupportedChannelModes[i] == CSbcEncoderIntfc::ESbcChannelJointStereo )

			 	{

		 		itemp |= EJointStereo;	//	EJointStereo	= 0x1

			 	continue;

			 	}

		 	}

		 aSbc.SetChannelModes(itemp);

		 TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder Channel modes: %d"), itemp))

		}

	else

		{

		return ret; 

		}

    // Blocks

    RArray<TUint> SupportedNumOfBlocks; 

    ret = iEncoderCI->GetSupportedNumOfBlocks(SupportedNumOfBlocks); 

	if ( !ret )

		{

		 itemp = 0x00; 

		 for (TInt i=0; i<SupportedNumOfBlocks.Count(); i++ )

		 	{

			 if ( SupportedNumOfBlocks[i] ==  TUint(4))

			 	{

				itemp = EBlockLenFour;	//	 EBlockLenFour 		= 0x8		 		

				continue;		 		

			 	}

			 if ( SupportedNumOfBlocks[i] == TUint(8) )

			 	{

			 	itemp |= EBlockLenEight;	// 	EBlockLenEight 		= 0x4

			 	continue;

			 	}

			 if ( SupportedNumOfBlocks[i] == TUint(12) )

			 	{

			 	itemp |= EBlockLenTwelve;	// 	EBlockLenTwelve		= 0x2

			 	continue;

				}

			 if ( SupportedNumOfBlocks[i] == TUint(16) )

			 	{

			 	itemp |= EBlockLenSixteen;	// 	EBlockLenSixteen	= 0x1

			 	continue;

			 	}

		 	}

		 aSbc.SetBlockLengths(itemp);

		 TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder Blocks: %d"), itemp))

		}

	else

		{

		return ret; 

		}

	// Subbands

	RArray<TUint> SupportedNumOfSubbands; 

	ret = iEncoderCI->GetSupportedNumOfSubbands(SupportedNumOfSubbands);

	if ( !ret )

		{

	    itemp = 0x0;

		for (TInt i=0; i<SupportedNumOfSubbands.Count(); i++ )

		 	{	

			 if ( SupportedNumOfSubbands[i] == TUint(4) )

			 	{

				itemp = EFourSubbands; // 	EFourSubbands  = 0x02

				continue; 

			 	}

			 if ( SupportedNumOfSubbands[i] == TUint(8) )

			 	{

			 	itemp |= EEightSubbands;	// 	EEightSubbands  = 0x01

			 	continue; 

			 	}

		 	}

		 aSbc.SetSubbands(itemp);

		 TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder SubBands: %d"), itemp))

		 }

	else

		{

		return ret; 

		}

    // allocation method bitmask 

    RArray<CSbcEncoderIntfc::TSbcAllocationMethod> SupportedAllocationMethods;

    ret = iEncoderCI->GetSupportedAllocationMethods(SupportedAllocationMethods); 

	if ( !ret )

		{

	    itemp = 0x0;

		for (TInt i=0; i<SupportedAllocationMethods.Count(); i++ )

		 	{	

			 if ( SupportedAllocationMethods[i] == CSbcEncoderIntfc::ESbcAllocationSNR )

			 	{

				itemp = ESNR; // 	ESNR  = 0x02

				continue; 

			 	}

			 if ( SupportedAllocationMethods[i] == CSbcEncoderIntfc::ESbcAllocationLoudness )

			 	{

			 	itemp |= ELoudness;	// 	ELoudness  = 0x01

			 	continue; 

			 	}

		 	}

		 aSbc.SetAllocationMethods(itemp);

		 TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder Alloc method: %d"), itemp))

		 }

	else

		{

		return ret; 

		}

	// bitpools

	TUint MinSupportedBitpoolSize; TUint MaxSupportedBitpoolSize; 

	ret = iEncoderCI->GetSupportedBitpoolRange(MinSupportedBitpoolSize, 

		                      				   MaxSupportedBitpoolSize);

	if ( !ret )

	 	{

		if (MaxSupportedBitpoolSize > MAXBITPOOLVALUEMAX)

	 	    {

	 	    MaxSupportedBitpoolSize = MAXBITPOOLVALUEMAX;

	 	    }

	 	// TUint8 to TInt

		aSbc.SetMaxBitpoolValue(MaxSupportedBitpoolSize);

		TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder Max bitpool: %d"), MaxSupportedBitpoolSize))

		aSbc.SetMinBitpoolValue(MinSupportedBitpoolSize);

		TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Encoder Min bitpool: %d"), MinSupportedBitpoolSize))

	 	}

	else

		{

		return ret; 

		}	 

    // save our local copy, 9 bytes on stack

    iLocalCap = aSbc;

	TRACE_INFO((_L("CBTSACStreamerController::FillCapabilities() Return: %d"), ret));	

	return ret;

	}

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

// CBTSACStreamerController::ConfigureSEP

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

//	

TInt CBTSACStreamerController::ConfigureSEP( TSBCCodecCapabilities& aDec )

	{

	TRACE_FUNC

	TInt err = KErrNone;

	TRAP(err, InitializeBitpoolDataL());

	if(err)

		return err;

	err = GetMatchingCaps(aDec);

	if(!err)

		{

		CheckAndAdjustBitpool(aDec);

		// Save the matching Caps

		iMatchCap = aDec;

		ReorganizeBitpoolTable(iMatchCap.MaxBitpoolValue());

		err = SetCurrentBitpoolData(iMatchCap.MaxBitpoolValue());

		if(!err)

			{

			iEncoderCI->SetBitpoolSize(iMatchCap.MaxBitpoolValue());

	  		// configure encoder

			err = iEncoderCI->ApplyConfig();

			}

		}

	TRACE_INFO((_L("CBTSACStreamerController::ConfigureSEP() return: %d"), err))

	return err;

	}

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

// CBTSACStreamerController::ConfigureSEPBitpool

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

//	

TInt CBTSACStreamerController::ConfigureSEPBitpool(EOngoingAction aAction)

	{

	TRACE_FUNC

    TInt err = KErrNone;