// 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;

 	}

 	}