/*

* 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:

*

*/

/*-- Project Headers. --*/

#include "AudPanic.h"

#include "ProcTools.h"

#include "ProcMP3InFileHandler.h"

#include "mpheader.h"

#include "audconstants.h"

#include "ProcMP3FrameHandler.h"

// Debug print macro

#if defined _DEBUG 

#include <e32svr.h>

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

#else

#define PRINT(x)

#endif

/*

   Purpose:     Minimum buffer size for determining the payload size

                of a free format mp3 bitstream.

   Explanation: - */

#define MIN_MP3_FREE_FORMAT_BUF_SIZE (42)

/*

   Purpose:     Buffer size for searching the start of a mp3 frame.

   Explanation: - */

const int16 Kmp3BufSize = 8;

/*

   Purpose:     Buffer size for determining an avarage frame size of a mp3 stream.

   Explanation: - */

const int16 Kmp3BitrateRegions = 4;

/*

   Purpose:     # of frames processed from each region.

   Explanation: This is used when the avarage frame size is determined. */

const int16 Kmp3BitrateNumFrames = 125;

/*

   Purpose:     Buffer size for determining if a clip is valid mp3

   Explanation: - */

const TUint Kmp3TempBufferSize = 4096;

// ID3v2 header's tag offset

const TUint KSizeOfTagOffset = 6;

// The size of MP3 header, header must include bits for determining frame length

const TInt KRawMp3FrameHeaderSize = 5;

// Bit rates in bits/sec supported by MPEG2, MPEG1 and MPEG2.5 respectively

const TInt16 cBitRateTable[3][16] =

	{

		{-1,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0},

		{-1,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0},

		{-1,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0},

	};

// Sampling frequencies supported by MPEG2, MPEG1 and MPEG2.5 respectively

const TUint16 cSamplingFrequencyTable[3][4] =

	{

		{22050,24000,16000,0},

		{44100,48000,32000,0},

		{11025,12000,8000,0},

	};

const TInt KRawMp3MaxFrameSize = 1441;     // 320kbit/s @ 32kHz = int((144*320000/32000)+1)

CProcMP3InFileHandler* CProcMP3InFileHandler::NewL(const TDesC& aFileName, RFile* aFileHandle, CAudClip* aClip, 

                            TInt aReadBufferSize, TInt aTargetSampleRate, TChannelMode aChannelMode) 

{

  CProcMP3InFileHandler* self = NewLC(aFileName, aFileHandle, aClip, aReadBufferSize, 

                                          aTargetSampleRate, aChannelMode);

  CleanupStack::Pop(self);

  return self;

}

CProcMP3InFileHandler* 

CProcMP3InFileHandler::NewLC(const TDesC& aFileName, RFile* aFileHandle, CAudClip* aClip, 

                            TInt aReadBufferSize, TInt aTargetSampleRate, TChannelMode aChannelMode) 

{

  CProcMP3InFileHandler* self = new (ELeave) CProcMP3InFileHandler();

  CleanupStack::PushL(self);

  self->ConstructL(aFileName, aFileHandle, aClip, aReadBufferSize,

                      aTargetSampleRate, aChannelMode);

  return self;

}

CProcMP3InFileHandler::CProcMP3InFileHandler() : CProcInFileHandler(), mp3FileFormat(0),

                                                 isValidMP3(0), mp3HeaderBytes(0), 

                                                 mp3Log(0), isFreeFormatMP3(0), isVbrMP3(0) 

{

}

TBool CProcMP3InFileHandler::GetEncAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime)

    {

    TBool rValue = EFalse;

  if(!iFileOpen) 

  {

    TAudPanic::Panic(TAudPanic::EInternal);

  }

  aSize = 0;

  aTime = 0;

  aFrame = NULL;

  if(isValidMP3)

  {

    TMpFrameState frState;

    int16 frameFound;

    TInt bufSize;

    TPtr8 mp3DataBuf(mp3HeaderBytes, Kmp3BufSize);

    /*-- Search start of next frame. --*/

    bufSize = BufferedFileRead((TDes8&) mp3DataBuf);

    if(bufSize < Kmp3BufSize)

      ZERO_MEMORY(mp3HeaderBytes + bufSize, Kmp3BufSize - bufSize);

    frameFound = GetMP3Frame(mp3HeaderBytes, Kmp3BufSize, &frState, 0);

    /*-- Frame found. --*/

    if(frameFound == 0)

    {

      TInt fLen;

      fLen = frState.frameBytes + frState.headerBytes;

      fLen -= Kmp3BufSize - (frState.readBytes - frState.headerBytes);

      if(fLen > 0)

      {

        TInt offset;

        uint8 *audFrameOffsetPtr;

        HBufC8 *audioFrame = HBufC8::NewL(frState.frameBytes + frState.headerBytes);

        offset = frState.readBytes - frState.headerBytes;

        mp3DataBuf.Set(mp3HeaderBytes + offset, Kmp3BufSize - offset, Kmp3BufSize - offset);

        audioFrame->Des().Copy(((const TDesC8 &) mp3DataBuf));

        audFrameOffsetPtr = (uint8 *) audioFrame->Des().Ptr();

        TPtr8 audTmpPtr(audFrameOffsetPtr + Kmp3BufSize - offset, fLen, fLen);

        bufSize = BufferedFileRead(audTmpPtr, fLen);

        fLen = frState.frameBytes + frState.headerBytes;

        audioFrame->Des().SetLength(fLen);

        aFrame = audioFrame;

        aSize = fLen;

        aTime = iMp3Edit->GetFrameTime(mp3FileFormat);

        iCurrentTimeMilliseconds += aTime;

        TRAPD(err, ManipulateGainL(aFrame));

        if (err != KErrNone)

            {

            // something went wrong with the gain manipulation

            // continue by returning the original frame

            }

        rValue = ETrue;

      }

    }

  }

  return (rValue);

    }

CProcMP3InFileHandler::~CProcMP3InFileHandler() 

{

//  if(iFileOpen)

  CloseFile();

  if (iMp3Edit != 0)

    {

      delete iMp3Edit;

      iMp3Edit = 0;

    }

  if (iFileName != 0)

    {

      delete iFileName;

      iFileName = 0;

    }

  if (iReadBuffer != 0)

    {

      delete iReadBuffer;

      iReadBuffer = 0;

    }

  if (mp3FileFormat != 0)

    {

      delete mp3FileFormat;

      mp3FileFormat = 0;

    }

  if (mp3HeaderBytes != 0)

    {

      delete mp3HeaderBytes;

      mp3HeaderBytes = 0;

    }

  if (iDecoder != 0)

    {

      delete iDecoder;

      iDecoder = 0;

    }

  if (iFrameHandler != 0)

    {

      delete iFrameHandler;

      iFrameHandler = 0;

    }

  if (iSilentFrame != 0)

    {

      delete iSilentFrame;

      iSilentFrame = 0;

    }

}

int16 CProcMP3InFileHandler::

GetMP3Frame(uint8 *dataBytes, int16 bufSize, TMpFrameState *frState, uint8 syncStatus)

{

  int16 locateFrame;

  int16 seekSyncStatus = 0;

  TPtr8 mp3DataBuf(dataBytes, bufSize);

  /*-- Search  start of 1st frame. --*/

  locateFrame = 0;

  frState->totalReadBytes = 0;

  while(locateFrame == 0)

  {

    if(syncStatus == 3)

      seekSyncStatus = iMp3Edit->FreeMode(mp3FileFormat, dataBytes, bufSize, 

                                   &frState->readBytes, &frState->frameBytes, 

                                   &frState->headerBytes);

    else

      seekSyncStatus = iMp3Edit->SeekSync(mp3FileFormat, dataBytes, bufSize, 

                                   &frState->readBytes, &frState->frameBytes, 

                                   &frState->headerBytes, (uint8) syncStatus);

    /*-- Start of 1st frame found. --*/

    if(seekSyncStatus == 0 || seekSyncStatus == 3)

      locateFrame = 1;

    /*-- Update data buffer, start of 1st frame not found yet. --*/

    else if(seekSyncStatus == 2)

    {

      if(frState->readBytes)

      {

        TInt tmpBufLen, tmp2;

        /*-- New data bytes to be read into buffer. --*/

        tmpBufLen = (int16) (bufSize - frState->readBytes);

        /*-- Move data that is possibly left in the buffer. --*/

        if(tmpBufLen) COPY_MEMORY(dataBytes, dataBytes + frState->readBytes, tmpBufLen);

        /*-- Prepare to read. --*/

        mp3DataBuf.Set(dataBytes + tmpBufLen, frState->readBytes, frState->readBytes);

        /*-- Update buffer. --*/

        tmp2 = BufferedFileRead((TDes8&) mp3DataBuf);

        if(tmp2 < frState->readBytes) 

          ZERO_MEMORY(dataBytes + tmpBufLen + tmp2, frState->readBytes - tmp2);

        frState->totalReadBytes += frState->readBytes;

      }

    }

    /*-- Abort, start of 1st frame cannot be located. --*/

    else locateFrame = 1;

  }

  return (seekSyncStatus);

}

void CProcMP3InFileHandler::

ConstructL(const TDesC& aFileName, RFile* aFileHandle, CAudClip* aClip, TInt aReadBufferSize,

            TInt aTargetSampleRate, TChannelMode aChannelMode) 

{

  iTargetSampleRate = aTargetSampleRate;

  iChannelMode = aChannelMode;

  int16 locate1stFrame;

  TMpFrameState frState;

  isVbrMP3 = 0;

  isValidMP3 = 0;

  isFreeFormatMP3 = 0;

  //-- Initialize file format handle. --

  mp3FileFormat = (TMpTransportHandle *) new (ELeave) TMpTransportHandle[1];

  ZERO_MEMORY(mp3FileFormat, sizeof(TMpTransportHandle));

  //-- Buffer for header search. --

  mp3HeaderBytes = new (ELeave) uint8[Kmp3BufSize];

  ZERO_MEMORY(mp3HeaderBytes, Kmp3BufSize);

  // -- Buffer for validity check --

  HBufC8* vldBuffer = (HBufC8*) HBufC8::NewLC(Kmp3TempBufferSize);

  iMp3Edit = CMp3Edit::NewL();

   // Set the file format parameters to default values. Note that this function

   // should be called only once; when searching the start of 1st frame.

   //

  iMp3Edit->InitTransport(mp3FileFormat);

  iClip = aClip;

  //-- Open file. --//

  InitAndOpenFileL(aFileName, aFileHandle, aReadBufferSize);

  TPtr8 mp3DataBuf(mp3HeaderBytes, Kmp3BufSize);

  /*-- Read 1st bytes in. --*/

  BufferedFileSetFilePos(0);

  BufferedFileRead((TDes8&) mp3DataBuf);

  // ----------------------------------------->

  // Identify ID3v2 header:

  // more info in http://www.id3.org/

  TInt tagLen = 0;

  if (mp3DataBuf.Left(3).Compare(_L8("ID3")) == 0)

    {

    const TInt KLenOffset = 6;

    BufferedFileSetFilePos(KLenOffset);

    BufferedFileRead((TDes8&) mp3DataBuf);

    // ID3v2 tag found, calculate lenght:

    const TInt K2Pow7 = 128;

    const TInt K2Pow14 = 16384;

    const TInt K2Pow21 = 2097152;

    tagLen = K2Pow21 * mp3DataBuf[0] + 

             K2Pow14 * mp3DataBuf[1] +

             K2Pow7 * mp3DataBuf[2] +

             mp3DataBuf[3];

    tagLen += 10; // include ID3v2 header

    }

  // <-----------------------------------------

  BufferedFileSetFilePos(tagLen);

  TPtr8 vldDes( vldBuffer->Des() );

  TInt bytesRead = BufferedFileRead((TDes8&) vldDes);

  vldDes.SetLength(bytesRead);

  TBool result = Validate(vldDes);

  CleanupStack::PopAndDestroy(vldBuffer);

  if (!result)

  {

      User::Leave(KErrCorrupt);

  }

  BufferedFileSetFilePos(tagLen);

  bytesRead = BufferedFileRead((TDes8&) mp3DataBuf);

  /*-- Search start of 1st frame. --*/

  locate1stFrame = GetMP3Frame(mp3HeaderBytes, Kmp3BufSize, &frState, 1);

  /*-- If free format, we must determine the payload size of the frames. --*/

  if(locate1stFrame == 3)

  {

    int16 tmpBufLen;

    uint8 tmpBuf[MIN_MP3_FREE_FORMAT_BUF_SIZE];

    /*-- Switch to larger buffer. --*/

    tmpBufLen = (int16) (Kmp3BufSize - frState.readBytes);

    COPY_MEMORY(tmpBuf, mp3HeaderBytes + frState.readBytes, tmpBufLen);

    if(frState.readBytes)

    {

      int16 tmpBufLen2;

      tmpBufLen2 = (int16) (MIN_MP3_FREE_FORMAT_BUF_SIZE - tmpBufLen);

      mp3DataBuf.Set(tmpBuf + tmpBufLen, tmpBufLen2, tmpBufLen2);

      BufferedFileRead((TDes8&) mp3DataBuf);

    }

    /*-- Determine the payload size. --*/

    locate1stFrame = GetMP3Frame(tmpBuf, MIN_MP3_FREE_FORMAT_BUF_SIZE, &frState, 3);

    /*-- If payload size known, then go back to the start of 1st frame. --*/

    if(locate1stFrame == 0)

    {

      isFreeFormatMP3 = 1;

      BufferedFileSetFilePos(0);

      mp3DataBuf.Set(mp3HeaderBytes, Kmp3BufSize, Kmp3BufSize);

      BufferedFileRead((TDes8&) mp3DataBuf);

      locate1stFrame = GetMP3Frame(mp3HeaderBytes, Kmp3BufSize, &frState, 0);

    }

  }

  if(locate1stFrame == 0)

    isValidMP3 = 1;

  BufferedFileSetFilePos(0);

  TAudFileProperties prop;

  GetPropertiesL(&prop);

  if (iProperties != 0)

    {

      // generate a header -------------->

      TUint8 byte1 = 0xFF; // sync

      TUint8 byte2 = 0xFB; // sync + V1,L3 (mp3), no CRC

      TBuf8<8> byte3B;

      switch (iProperties->iBitrate)

      {

      case (32000):

          {

              byte3B.Append(_L8("0001"));

              break;

          }

      case (40000):

          {

              byte3B.Append(_L8("0010"));

              break;

          }

      case (48000):

          {

              byte3B.Append(_L8("0011"));

              break;

          }

      case (56000):

          {

              byte3B.Append(_L8("0100"));

              break;

          }

      case (64000):

          {

              byte3B.Append(_L8("0101"));

              break;

          }

      case (80000):

          {

              byte3B.Append(_L8("0110"));

              break;

          }

      case (96000):

          {

              byte3B.Append(_L8("0111"));

              break;

          }

      case (112000):

          {

              byte3B.Append(_L8("1000"));

              break;

          }

      case (128000):

          {

              byte3B.Append(_L8("1001"));

              break;

          }

      case (160000):

          {

              byte3B.Append(_L8("1010"));

              break;

          }

      case (192000):

          {

              byte3B.Append(_L8("1011"));

              break;

          }