/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

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

* Ixonos Plc

*

* Description:  

*

*/

#include <f32file.h>

#include "AudPanic.h"

#include "ProcInFileHandler.h"

#include "AudClipInfo.h"

#include "ProcTools.h"

#include "audconstants.h"

// Debug print macro

#if defined _DEBUG 

#include <e32svr.h>

#define PRINT(x) RDebug::Print x;

#else

#define PRINT(x)

#endif

CProcInFileHandler::~CProcInFileHandler() 

    {

    if (iFileOpen && iOwnsFile)

        {

        iFile.Close();

        iFs.Close();

        }

    if (iProperties != 0)

        {

        delete iProperties;

        iProperties = 0;

        }

    delete iRawSilentFrame;

    delete iInputBuffer;

    delete iWavFrameHandler;

    }

TBool CProcInFileHandler::DecodingRequired()

    {

    return iDecodingRequired;

    }

TInt CProcInFileHandler::GetDecodedFrameSize()

    {

    if (iProperties == 0)

        {

        return 0;

        }

    else

        {

        // divided by 1000000/2 cause time is in 

        // microseconds and 16 bits are used for one sample

#ifdef EKA2

        TInt frameSize = (iProperties->iFrameDuration.Int64())*(iTargetSampleRate)/(1000000/2);

#else

        TInt frameSize = (iProperties->iFrameDuration.Int64().GetTInt())*(iTargetSampleRate)/(1000000/2);

#endif        

        if (iChannelMode == EAudStereo)

            {

            frameSize *= 2;

            }

        return frameSize;

        }

    }

void CProcInFileHandler::SetDecodingRequired(TBool aDecodingRequired)

    {

    iDecodingRequired = aDecodingRequired;

    }

TBool CProcInFileHandler::GetAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime, TBool& aRawFrame) 

    {

    if (iDecodingRequired)

        {

        aRawFrame = ETrue;

        return GetRawAudioFrameL(aFrame, aSize, aTime);

        }

    else

        {

        aRawFrame = EFalse;

        return GetEncAudioFrameL(aFrame, aSize, aTime);

        }

    }

TBool CProcInFileHandler::GetRawAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime)

    {

    while (iInputBuffer == 0 || iInputBuffer->Length() < iRawFrameLength)

        {

        TBool ret = GetOneRawAudioFrameL(aFrame, aSize, aTime);

        if (!ret)

            {

            return ret;

            }

        WriteDataToInputBufferL(*aFrame);

        delete aFrame;

        aFrame = 0;

        }

    if (iInputBuffer->Length() >= iRawFrameLength)

        {

        aFrame = HBufC8::NewL(iRawFrameLength);

        aFrame->Des().Append(iInputBuffer->Left(iRawFrameLength));

        TInt bytesInSecond = iTargetSampleRate*2;

        if (iChannelMode == EAudStereo)

            {

            bytesInSecond *= 2;

            }

        // Fix for synchronizing problem ---------------------------------->

        // If the accurate frame length cannot be represented in milliseconds

        // store the remainder and increase the output frame lenght by one ms 

        // when needed. Accuracy depends on sampling rate

        TReal accurateFrameLen = TReal(aFrame->Length()*1000)/bytesInSecond;

        aTime = TUint((aFrame->Length()*1000)/bytesInSecond);

        iFrameLenRemainderMilli += accurateFrameLen - aTime;

        if (iFrameLenRemainderMilli > 1)

            {

            aTime += 1;

            iFrameLenRemainderMilli -= 1;

            }

        // <---------------------------------- Fix for synchronizing problem

        iInputBuffer->Des().Delete(0, iRawFrameLength);

        }

    return ETrue;

    }

TBool CProcInFileHandler::GetOneRawAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime)

    {

    TInt size = 0;

    TInt32 time = 0;

    HBufC8* frame = 0;

    TBool encFrameRead = GetEncAudioFrameL(frame, size, time);    

    if (encFrameRead) 

        {

        CleanupStack::PushL(frame);

        }

    aTime = time;

    if (!encFrameRead)

        {

        return EFalse;

        }

    TRAPD(err, iDecoder->FillDecBufferL(frame, aFrame));

    if (err == KErrNotFound)

        {

        // S60 audio decoders seem to leave with KErrNotFound if they find problems in input clips. 

        // However, sometimes the problem is only in one frame, e.g. the 1st frame may contain some metadata that can't be decoded,

        // but decoding can continue after that. But if there are many errors, the clip is most likely unusable.

	    PRINT((_L("CProcInFileHandler::GetOneRawAudioFrameL() iDecoder->FillDecBufferL leaved with %d"),err));

        if ( iDecoderErrors > 0 )

            {

            // several errors, leave, but change the error code to more readable

    	    PRINT((_L("CProcInFileHandler::GetOneRawAudioFrameL() leave with %d"),KErrCorrupt));

            User::Leave(KErrCorrupt);

            }

        iDecoderErrors++;

        }

    else if (err == KErrNone)

        {

        // keep filling the decoder buffer; the decoder seem to leave with KErrNone if it can't get enough data, ignore the leave

        }

    else

        {

        // some other error

	    PRINT((_L("CProcInFileHandler::GetOneRawAudioFrameL() iDecoder->FillDecBufferL leaved with %d, leaving"),err));

        User::Leave(err);

        }

    if (encFrameRead) 

        {

        CleanupStack::PopAndDestroy(frame);

        frame = 0;

        }

    while (aFrame == 0 || aFrame->Size() == 0)

        {

        encFrameRead = GetEncAudioFrameL(frame, size, time);

        if (encFrameRead) 

            {

            CleanupStack::PushL(frame);

            }

        else

            {

            return EFalse;

            }

        aTime += time;

        iDecoder->FillDecBufferL(frame, aFrame);

        if (encFrameRead) 

            {

            CleanupStack::PopAndDestroy(frame);

            frame = 0;

            }        

        }

    aSize = aFrame->Length();

    if (iProperties->iAudioTypeExtension != EAudExtensionTypeNoExtension) 

        {

        // AACPlus is always decoded, therefore the gain manipulation can be done

        // in time domain

        ManipulateGainL(aFrame);

        aSize = aFrame->Length();

        }

    return ETrue;

    }

TBool CProcInFileHandler::SetRawAudioFrameSize(TInt aSize)

    {

    const TInt KMaxRawFrameSize = 4096;

    if (aSize > 0 && aSize <= KMaxRawFrameSize)

        {

        iRawFrameLength = aSize;

        return ETrue;

        }

    return EFalse;

    }

TBool CProcInFileHandler::GetSilentAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime, TBool& aRawFrame)

    {

    if (iDecodingRequired)

        {

        aRawFrame = ETrue;

        return GetRawSilentAudioFrameL(aFrame, aSize, aTime);

        }

    else

        {

        aRawFrame = EFalse;

        return GetEncSilentAudioFrameL(aFrame, aSize, aTime);

        }

    }

TBool CProcInFileHandler::GetRawSilentAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aDuration)

    {

    aFrame = HBufC8::NewL(iRawFrameLength);    

    aFrame->Des().Fill(0, aFrame->Des().MaxLength());

    TInt bytesInSecond = iTargetSampleRate*2;

    if (iChannelMode == EAudStereo)

        {

        bytesInSecond *= 2;

        }

    aDuration = TUint((aFrame->Length()*1000)/bytesInSecond);

    aSize = aFrame->Length();

    // input buffer is created only if needed

    if (iInputBuffer)

        {

        iInputBuffer->Des().Delete(0, iInputBuffer->Size());

        }

    return ETrue;

    }

TBool CProcInFileHandler::GetEncSilentAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aDuration)

    {

    if (iSilentFrame == 0)

        {

        return EFalse;

        }

    aFrame = HBufC8::NewL(iSilentFrame->Size());    

    aFrame->Des().Append(iSilentFrame->Des());

    aDuration = iSilentFrameDuration;

    aSize = iSilentFrame->Size();

    return ETrue;

    }

CProcInFileHandler::CProcInFileHandler() : iFileOpen(EFalse)

    {

    }

TInt32 CProcInFileHandler::GetCurrentTimeMilliseconds() 

    {

    return iCurrentTimeMilliseconds;

    }

// default implementation for files that do not have buffered bytes

TBool CProcInFileHandler::ReadAudioDecoderSpecificInfoL(HBufC8*& /*aBytes*/, TInt /*aBufferSize*/)

    {

    return EFalse;

    }

TBool CProcInFileHandler::OpenFileForReadingL() 

    {   

    if (iFileOpen)

        {

        User::Leave(KErrGeneral);

        }

    TInt err = iFs.Connect();

    if (err != KErrNone) 

        {

        iFileOpen = EFalse;

        User::Leave(err);

        }

    err=iFile.Open(iFs, iFileName->Des(), EFileShareReadersOnly);

    if (err != KErrNone) 

        {

        err=iFile.Open(iFs, iFileName->Des(), EFileShareAny);

        }

    if (err != KErrNone) 

        {

        iFileOpen = EFalse;

        iFs.Close();

        User::Leave(err);

        }

    else 

        {

        iFileOpen = ETrue;

        return ETrue;

        }

    return EFalse;

    }

TBool CProcInFileHandler::

SetPropertiesL(TAudFileProperties aProperties) 

{

  if(iProperties == 0)

    iProperties = new (ELeave) TAudFileProperties();

  iProperties->iAudioType = aProperties.iAudioType;

  iProperties->iBitrate = aProperties.iBitrate;

  iProperties->iBitrateMode = aProperties.iBitrateMode;

  iProperties->iChannelMode = aProperties.iChannelMode;

  iProperties->iDuration = 0;

  iProperties->iFileFormat = aProperties.iFileFormat;

  iProperties->iSamplingRate = aProperties.iSamplingRate;

  iProperties->iFrameLen = aProperties.iFrameLen;

  iProperties->iFrameDuration = aProperties.iFrameDuration;

  iProperties->iFrameCount = aProperties.iFrameCount;

  return (ETrue);

}

TBool CProcInFileHandler::SetPriority(TInt aPriority)

    {

    if (aPriority < 0) return EFalse;

    iPriority = aPriority;

    return ETrue;

    }

TInt CProcInFileHandler::Priority() const

    {

    return iPriority;

    }

TBool CProcInFileHandler::CloseFile() 

    {

    if (iOwnsFile)

    {        

        iFile.Close();

        iFs.Close();

        iFileOpen = EFalse;

    }

    return ETrue;

    }

TBool CProcInFileHandler::InitAndOpenFileL(const TDesC& aFileName, 

                                           RFile* aFileHandle,

                                           TInt aReadBufferSize) 

    {

    iBufferStartOffset = 0;

    iBufferEndOffset = 0;

    iCutInTime = 0;

    if (!aFileHandle)

    {        

        iFileName = HBufC::NewL(aFileName.Length());

        *iFileName = aFileName;

    }

    iReadBufferSize = aReadBufferSize;

    iReadBuffer = HBufC8::NewL(iReadBufferSize);

    const TInt KVedACSizeAMRBuffer = 320;

    // [JK]: Moved from OpenFileForReadingL

    // AMR buffer is the smallest possible

    // buffersize fill be increased if needed

    iRawFrameLength = KVedACSizeAMRBuffer;

    iInputBuffer = HBufC8::NewL(iRawFrameLength);

    if (aFileHandle)

    {

        iFile = *aFileHandle;

        iOwnsFile = EFalse;

        iFileOpen = ETrue;

        return 0;

    }

    TBool err = OpenFileForReadingL();

    if (!err) iFileOpen = ETrue;

    iOwnsFile = ETrue;

    return err;

    }

void CProcInFileHandler::ResetAndCloseFile()

    {

    if (iFileOpen) 

        {

        CloseFile();

        }

    if (iFileName != 0)

        delete iFileName;

    iFileName = 0;

    if (iReadBuffer != 0)

        delete iReadBuffer;

    iReadBuffer = 0;