/*
* Copyright (c) 2006 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:  The functions in this module implements the common behavior
*                for the audio decoder base class.
*
*/


// INCLUDE FILES
#include "AdvancedAudioDecoder.h"
#include "DebugMacros.h"
#include <mmfdatabuffer.h>
//#include <Mmfcodec.h>

EXPORT_C TCodecProcessResult CAdvancedAudioDecoder::ProcessHwL(CMMFBuffer& aSrc, CMMFBuffer& aDst)
	{
    DP0(_L ("CAdvancedAudioDecoder::ProcessAccelL ---start"));
	
	TMMFPtr8 codecSrc;
	TMMFPtr8 codecDst;

	TCodecProcessResult result;
	result.iStatus = TCodecProcessResult::EProcessIncomplete;

	//convert from generic CMMFBuffer to CMMFDataBuffer
	iSrc = static_cast<const CMMFDataBuffer*>(&aSrc);
	iDst = static_cast<CMMFDataBuffer*>(&aDst);

	const TUint srcLen = iSrc->Data().Length();
	const TUint dstAvail = iDst->Data().MaxLength() - iDst->Position();

	if (!dstAvail)
		User::Leave(KErrArgument);

	TUint dstAdded = 0;
	TUint srcUsed = 0;

	TInt srcPos = iSrc->Position();
	TInt dstPos = iDst->Position();

//  DP4(_L ("CAdvancedAudioDecoder::ProcessAccelL: srcLen[%d], srcPos[%d] dstPos[%d], dstAvailLen[%d]"), srcLen, srcPos, dstPos, dstAvailLen);

	while ((dstAdded < dstAvail) && (srcPos + srcUsed < srcLen))
        {
        codecSrc.Set(iSrc->Data());
        codecDst.Set(iDst->Data());
        codecDst.SetLength(codecDst.MaxLength());
		codecSrc.Shift(srcPos + srcUsed);
		codecDst.Shift(dstPos + dstAdded);

//		DP2(_L ("CAdvancedAudioDecoder::ProcessAccelL: before ProcessDecodeL offsetting srcptr to srcPos[%d]+srcUsed[%d]"), srcPos, srcUsed);

		ProcessParseL(&codecSrc, &codecDst);
		if (!iEnabled)
			{ // output buffer is invalid when stopped - don't use it
	    	DP0(_L ("CAdvancedAudioDecoder::ProcessAccelL --- end - disabled - returning"));
	    	result.iStatus = TCodecProcessResult::EProcessComplete;
			return result;
			}

        dstAdded += codecDst.Length();
        srcUsed += codecSrc.Length();

        if (iMarkPlayEnd)
        	{ // don't parse any more data
            DP0(_L ("CAdvancedAudioDecoder::ProcessAccelL --- mark play end breaking"));
			break;        	
        	}
        }

	result.iSrcBytesProcessed = srcUsed;
	result.iDstBytesAdded     = dstAdded;

	if (result.iDstBytesAdded && (result.iSrcBytesProcessed + srcPos >= srcLen))
		result.iStatus = TCodecProcessResult::EProcessComplete;
	else if (result.iDstBytesAdded < dstAvail)
		result.iStatus = TCodecProcessResult::EDstNotFilled;
	
    iDst->Data().SetLength(iDst->Position()+result.iDstBytesAdded);

    DP0(_L ("CAdvancedAudioDecoder::ProcessAccelL ---end"));
    return result;
	}

// -----------------------------------------------------------------------------
// CAdvancedAudioDecoder::ProcessParseL
// ProcessParseL method that shall be called from the ProcessL method to perform
// the parsing of the encoded data
// -----------------------------------------------------------------------------
EXPORT_C void CAdvancedAudioDecoder::ProcessParseL(TMMFPtr8* aSrc, TMMFPtr8* aDst)
    {
    DP0(_L ("CAdvancedAudioDecoder::ProcessParseL ---start"));
    TUint8* srcPtr  = NULL;
    TUint8* dstPtr  = NULL;
    TInt    srcLen  = aSrc->Length();
    TInt    dstAvail= aDst->Length();
    TInt    srcUsed = 0;
    TInt    dstUsed = 0;

    //**************************************************
    //* Get Input Data:  Only want to process more input
    //* data if the output buffer is empty.
    //**************************************************

    if(iOutBufferCount == 0)
        {
        srcPtr = (TUint8*) aSrc->Ptr();

        //*************************************************
        //* If the input buffer is empty, and there is
        //* enough data in the input stream, then use the
        //* data from the input stream.  Else must append
        //* available input data to the input buffer.
        //*************************************************

        srcPtr = PrepareInFrame(srcPtr, srcLen, srcUsed);

        if (iInBufferCount > 0)
            {
            srcLen = iInBufferCount;
            }
        }

    //*************************************************
    //* If there is enough input data, then determine
    //* where the output should go (output stream or
    //* output buffer if output stream doesn't have
    //* enough room).  Then parse the data.
    //*************************************************

    if(srcPtr)
        {
        // Determine where to put output data
        dstPtr = (TUint8*) aDst->Ptr();
        dstUsed = iOutFrameLength;
		TInt inLen, outLen;

		outLen = dstAvail;
		
        if(dstAvail < iOutFrameLength)
            {
//	        DP2(_L ("CAdvancedAudioDecoder::ProcessParseL: dstAvail[%d], iOutFrameLength[%d]"), dstAvail, iOutFrameLength);

            dstPtr = iOutBuffer;
			outLen = iOutFrameLength; // Set the dst length to the new length
            }

        // Parse one frame
        inLen = srcLen;
        
        ParseL(srcPtr, inLen, dstPtr, outLen);
		if (!iEnabled)
			{ // aDst and dstPtr invalid when stopped - don't use
	    	DP0(_L ("CAdvancedAudioDecoder::ProcessParseL --- end - disabled - returning"));
			return;
			}

        // adjust in counters
        if (iInBufferCount > 0)
            {
            // if parse from the temp buf, adjust indexes
//	    	DP3(_L ("CAdvancedAudioDecoder::ProcessParseL adjusting tempbuf after parse count[%d] indx[%d] used[%d]"),
//	    			iInBufferCount, iInBufferIndx, inLen);
            iInBufferCount -= inLen;
            iInBufferIndx += inLen;
            }
        else
            {
            srcUsed = inLen;
            }
        
		if ((inLen == 0) && (iSrc->LastBuffer()))
			{
			srcUsed = srcLen;
			dstUsed = 0;
			}

        // adjust out counters
        dstUsed = outLen;
        
        if (dstAvail < iOutFrameLength)
            iOutBufferCount = outLen;
        }

    //*************************************************
    //* If any data is stored in the output buffer,
    //* then output as much of it as well fit in the
    //* output stream.
    //*************************************************

    if(iOutBufferCount > 0)
        {
        dstUsed = Min (iOutBufferCount, dstAvail);
        TPtrC8 outPtr (iOutBufferPtr, dstUsed);

        aDst->SetLength(0);
        aDst->Append (outPtr);

        iOutBufferCount -= dstUsed;
        iOutBufferPtr   += dstUsed;

        if(iOutBufferCount == 0)
            {
            iOutBufferPtr = iOutBuffer;
            }
        }


    //*************************************************
    //* Modify the length attributes of the source and
    //* destination data streams to inform the caller
    //* of how much data was used in each buffer.
    //*************************************************


//    DP2(_L ("CAdvancedAudioDecoder::ProcessParseL maxlen[%d] used[%d]"), aSrc->MaxLength(), srcUsed);
    aSrc->SetLength(srcUsed);
    aDst->SetLength(dstUsed);
    DP0(_L ("CAdvancedAudioDecoder::ProcessParseL ---end"));
    }

// -----------------------------------------------------------------------------
// CAdvancedAudioDecoder::PrepareInFrame
// -----------------------------------------------------------------------------
EXPORT_C TUint8* CAdvancedAudioDecoder::PrepareInFrame(TUint8* aSrc, TInt aSrcLen, TInt& aSrcUsed)
	{
//    DP0(_L ("CAdvancedAudioDecoder::PrepareInFrame ---start"));
    // note: aSrcUsed returns how much data is used from source buffer.
    // when it reaches the value of aSrcLen, we will be provided the next input buffer.
    // while we are decoding from the temp buf, we set it to 0 because we have not decoded any from
    // the current src buffer.
    TUint8* dataPtr = NULL;
	aSrcUsed = 0;

    if (iInBufferCount == 0)
        {
        // decoding from src buffer
//        DP2(_L("CAdvancedAudioDecoder::PrepareInFrame, aSrc[0x%x] aSrcLen[%d]"), aSrc, aSrcLen);

        iInBufferFilled = EFalse;
        iInBufferIndx = 0;
        
		if (aSrcLen >= iMaxFrameSize)
			{ // if enough data in input buffer, just use input buffer
//			DP2(_L ("CAdvancedAudioDecoder::PrepareInFrame using input buffer[0x%x][0x%x]"), aSrc, aSrc[0]);
			dataPtr = aSrc;
			}
		else if (iSrc->LastBuffer())
			{ // if input buffer is last buffer, then use it
//			DP2(_L ("CAdvancedAudioDecoder::PrepareInFrame using last input buffer[0x%x][0x%x]"), aSrc, aSrc[0]);
			dataPtr = aSrc;
			}
		else
			{
			// save input data
			// When not enough data in input buffer, move it to temp buffer
//			DP5(_L ("CAdvancedAudioDecoder::PrepareInFrame moving to temp buffer[0x%x] src[0x%x]d0[0x%x]srclen[%d]dend[0x%x]"),
//						iInBuffer, aSrc, aSrc[0], aSrcLen, aSrc[aSrcLen-1]);
			Mem::Copy(iInBuffer, aSrc, aSrcLen);
			iInBufferCount = aSrcLen;
			aSrcUsed = aSrcLen;     // inform that we used input buffer so we will get a new input buffer
			iInBufferIndx = 0;      // index will move with amount of data decoded
			dataPtr = NULL;         // NULL prevents decoder from decoding. We need to fill rest of temp buffer
			iUsedInBuffer = iInBufferCount;
	        iSavedBytesCopiedFromSrc = 0;
			}
        }
    else
        {
        // decoding from temp buffer
        dataPtr = iInBuffer+iInBufferIndx;  // index is adjusted after decode and ptr is data to decode
//		DP4(_L ("CAdvancedAudioDecoder::PrepareInFrame using temp buffer dataPtr[0x%x] iInBufferIndx[%d] iInBufferCount[%d] iInBufferFilled[%d]"),
//					dataPtr, iInBufferIndx, iInBufferCount, iInBufferFilled);
		
		if (!iInBufferFilled)
            {
            // need to fill rest of temp buffer
            TInt bytesToCopy = iSizeOfInBuffer-iUsedInBuffer;
            TInt bytesAvailable = aSrcLen;
            
            if (bytesAvailable < bytesToCopy)
                {
                bytesToCopy = bytesAvailable;
                }
                
            if (bytesToCopy)
                {
                // only do this once - partial input buffer means last buffer
//				DP5(_L ("CAdvancedAudioDecoder::PrepareInFrame putting more to temp buffer dstptr[0x%x] srcptr[0x%x]d0[0x%x]cnt[%d]dend[0x%x]"),
//							dataPtr+iUsedInBuffer, aSrc, aSrc[0], bytesToCopy, iInBuffer[KSizeOfInBuffer-1]);
       			Mem::Copy(dataPtr+iUsedInBuffer, aSrc, bytesToCopy);
        		iSavedBytesCopiedFromSrc = bytesToCopy; // save byte count used from this src buffer
	        	iInBufferCount += bytesToCopy;
	        	iUsedInBuffer += bytesToCopy;
	        	iInBufferFilled = ETrue;
                }
            }
        else
           	{
           	// temp buffer is filled and we are decoding from it
       	    TInt decodeOffsetIntoInputBuf = iSavedBytesCopiedFromSrc - iInBufferCount;
//			DP1(_L ("CAdvancedAudioDecoder::PrepareInFrame using temp buf aSrcUsed[%d]"), decodeOffsetIntoInputBuf);

       	    if (decodeOffsetIntoInputBuf >= 0)
       	    	{
       	    	// within the temp buffer, we have decoded all of the prior src buffer's data
       	    	// we are decoding into the data copied from the current input buffer
       	    	// so we can set the pointer to start using input buffer again
    	        dataPtr = NULL; // NULL prevents decoder from decoding. Need to let src get updated by aSrcUsed
				iInBufferCount = 0;
				aSrcUsed = decodeOffsetIntoInputBuf;
//				DP1(_L ("CAdvancedAudioDecoder::PrepareInFrame using inbuffer again, aSrcUsed[%d]"), aSrcUsed);
       	    	}
       	    else
       	    	{
       	    	aSrcUsed = 0; // here references current src buffer that we are not decoding from yet.
//				DP1(_L ("CAdvancedAudioDecoder::PrepareInFrame using inbuffer again, aSrcUsed[%d] b"), aSrcUsed);
       	    	}	
        	}
        }

    return dataPtr;
	}

// -----------------------------------------------------------------------------
// CAdvancedAudioDecoder::ParseL
// -----------------------------------------------------------------------------
EXPORT_C void CAdvancedAudioDecoder::ParseL(TUint8* aSrc, TInt& aSrcUsed, TUint8* aDst, TInt& aDstLen)
	{
    DP1(_L ("CAdvancedAudioDecoder::ParseL [0x%x]"), aSrc[0]);
	TInt savedLen = aSrcUsed;
	TInt err = KErrNone;
	TInt inLen = aSrcUsed;
//    TAudioFrameInfo frameInfo;
	TInt frameLen;

    // Parse one frame

	err = FrameLength(aSrc, inLen, frameLen);
	aSrcUsed = frameLen;
	if (aSrcUsed > savedLen)
		{ // in case util reports more bytes used than what is available at the end of the content
		aSrcUsed = savedLen;
		}

	if (!iRenderEnabled)
		{ // seeking
        aDstLen = 0;
		}	
	else
		{
		if (err == KErrNone)
			{
			Mem::Copy(aDst, aSrc, aSrcUsed);
			aDstLen = aSrcUsed;
			}
		}

	if (err != KErrNone)
		{
		aSrcUsed = 0;
        err = KErrCorrupt;
		}	
		
//	DP2(_L ("CAdvancedAudioDecoder::ParseL after decode aSrcUsed[%d] aDstLen[%d]"), aSrcUsed, aDstLen);

    DP1(_L ("CAdvancedAudioDecoder::ParseL err [%d]"),err);

	if (err == KErrNone)
		{
		if (iFrameTable)
			{
	   	    iFrameTable->SubmitTableEntry(iAccLen); // to add an entry for the frame actually decoded
			}
		}
		
	if (err == KErrCorrupt)
		{
		aDstLen = 0;
		// decode was not successful at this position, need to move forward because sync may still be found here.
		TInt syncPos = SeekSync(aSrc+1, savedLen-1); // decoder's seek returns 0 if not found, so we need to use our own seek function
		if (syncPos == savedLen-1)
			{ // search whole buffer - no sync found - so indicate the rest of the data has been used
			aSrcUsed = savedLen;
			}
		else 
			{
			aSrcUsed = syncPos+1;
			}	
		err = KErrNone;
		}

   	iAccLen += aSrcUsed;

    if(err != KErrNone)
        { // unrecoverable error
	    if (iSrc->LastBuffer())
			{ // don't have to error on last buffer, just indicate all the data was used
			aSrcUsed = savedLen;
			}
        else
            {
            User::Leave(err);
            }
        }
	}

// -----------------------------------------------------------------------------
// CAdvancedAudioDecoder::SeekSync
// -----------------------------------------------------------------------------
TInt CAdvancedAudioDecoder::SeekSync(TUint8* /*aBuf*/, TInt /*aBufLen*/)
    {
    return KErrNotSupported;
    }

TInt CAdvancedAudioDecoder::FrameLength(const TUint8* /*aBuf*/, TInt /*aBufLen*/, TInt& /*aFrameLength*/)
	{
    return KErrNotSupported;
	}


// End of file