// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// @file hostisochronoustransfers.cpp

// @internalComponent

// 

//

#include "hosttransfers.h"

#include <e32debug.h>

#include <e32test.h>

extern RTest gtest;

namespace NUnitTesting_USBDI

	{

CIsochTransfer::CIsochTransfer(RUsbPipe& aPipe,RUsbInterface& aInterface,TUint16 aMaxPacketSize,

							   TInt aMaxNumPackets,MTransferObserver& aObserver,TInt aTransferId)

:	CBaseTransfer(aPipe,aInterface,aObserver,aTransferId),

	iTransferDescriptor(aMaxPacketSize,aMaxNumPackets),

	iMaxPacketSize(aMaxPacketSize)

	{

	RDebug::Printf("aMaxPacketSize = %d, aMaxNumPackets = %d",aMaxPacketSize, aMaxNumPackets);

	}

CIsochTransfer::~CIsochTransfer()

	{

	LOG_FUNC

	// Cancel the transfer

	Cancel();

	}	

TBool CIsochTransfer::DataPolled(TUint aPacketsToBeRead, RBuf8& aDataPolled) 

	{

	LOG_FUNC

	TInt numOfPacketsReturned = 0;	

	TInt firstPacketIndex = 0;

	TInt totalPacketsRead = 0;

	TInt packetsToBeRead = aPacketsToBeRead;

	TUint dataPolledBufSize = iMaxPacketSize*aPacketsToBeRead;

	aDataPolled.CreateL(dataPolledBufSize);

	do {						

		TPtrC8 ptrRet = iTransferDescriptor.Packets(firstPacketIndex, packetsToBeRead, numOfPacketsReturned); 

		RDebug::Printf("numOfPacketsReturned = %d", numOfPacketsReturned);

		RDebug::Printf("ptrRet.Length() = %d", ptrRet.Length());

		firstPacketIndex = numOfPacketsReturned;

		totalPacketsRead += numOfPacketsReturned;

		packetsToBeRead = packetsToBeRead - numOfPacketsReturned;

		RDebug::Printf("totalPacketsRead = %d", totalPacketsRead);	

		RDebug::Printf("packetsToBeRead = %d", packetsToBeRead);	

		aDataPolled.Append(ptrRet);		

		}	while(totalPacketsRead != aPacketsToBeRead); 	

	return ETrue; 

	}

TInt CIsochTransfer::TransferInL(TInt aPacketsExpected)

	{

	LOG_FUNC

	// Activate the asynchronous transfer 	

	RDebug::Printf("Activating isoch. in transfer");

	iTransferDescriptor.Reset();

	TPacketLengths fullLengths = iTransferDescriptor.Lengths();

	for(TInt packet = 0; packet < fullLengths.MaxNumPackets(); packet++)

		{

		fullLengths[packet] = iMaxPacketSize;

		}	

	RDebug::Printf("fullLengths.MaxNumPackets() == %d",fullLengths.MaxNumPackets());

	iTransferDescriptor.ReceivePackets(aPacketsExpected);

	Pipe().Transfer(iTransferDescriptor,iStatus);

	SetActive();

	return KErrNone;																

	}

TInt CIsochTransfer::RegisterTransferDescriptor()

	{

	LOG_FUNC

	// Register the transfer descriptor with the interface	

	TInt err(Interface().RegisterTransferDescriptor(iTransferDescriptor));

	if(err != KErrNone)

		{

		RDebug::Printf("<Error %d> Unable to register transfer descriptor",err);

		}

	return err;	

	}

TInt CIsochTransfer::PrepareTransfer(const TDesC8& aIsochData)

	{

	LOG_FUNC

	//	

	iTransferDescriptor.Reset();

	TPacketLengths fullLengths = iTransferDescriptor.Lengths();

	RDebug::Printf("fullLengths.MaxNumPackets() == %d",fullLengths.MaxNumPackets());

	//	

	TInt bytesRemaining(aIsochData.Size());

	TInt maxAvailablePacketSlots;

	TInt startOffset(0);

	TInt startPacket(0); 

	RDebug::Printf("Audio data is %d bytes",bytesRemaining);

	// Keep saving the isoch data to transfer in each packet buffer supplied 

	// by the transfer descriptor

	while(bytesRemaining)

		{

		// Request a modifiable buffer to write the isoch data to

		TPtr8 packetBuffer = iTransferDescriptor.WritablePackets(bytesRemaining/iMaxPacketSize,maxAvailablePacketSlots);

		TInt dataToWrite = Min(bytesRemaining,packetBuffer.MaxSize());		

		if(dataToWrite == 0)

			{

			RDebug::Printf("<Warning> dropping the rest of the isoch data");

			break;

			}

		// Validate entire buffer as it is going to be filled

		packetBuffer.SetMax();

		// Calculate the number of packets to write in this buffer		

		TInt maxPacket = dataToWrite / iMaxPacketSize;

		for(TInt packet = 0; packet < maxPacket; packet++)

			{

			fullLengths[startPacket + packet] = iMaxPacketSize;

			}

		packetBuffer.Copy(aIsochData.Mid(startOffset, maxPacket * iMaxPacketSize));

		iTransferDescriptor.SaveMultiple(maxPacket);

		bytesRemaining -= maxPacket * iMaxPacketSize;

		startOffset += maxPacket * iMaxPacketSize;

		startPacket += maxPacket;

		}	

	return KErrNone;

	}

TInt CIsochTransfer::TransferOut()

	{	

	// Transfer the iscohronous data	

	RDebug::Printf("Activating isochronous out transfer");

	Pipe().Transfer(iTransferDescriptor,iStatus);

	SetActive();

	return KErrNone;

	}

	}