// ------------------------------------------------------------------------------------------------

#include <IIEP_Def.H>

#include <CORE/SourceFilter_MP3.H>

// ------------------------------------------------------------------------------------------------

extern BYTE g_ucWaveHeader[WAVE_HEADER_LENGTH];

// ------------------------------------------------------------------------------------------------

// name: CMP3Stream()

// desc:

// ------------------------------------------------------------------------------------------------

static size_t read_sub(int fd, void *pBuf, size_t nSize)

{

  if (fd)

  {

    IIEP::CMP3Stream *pcoStream = (IIEP::CMP3Stream *) fd;

    return pcoStream -> ReadFile(pBuf, nSize);

  }

  return 0;

}

// ------------------------------------------------------------------------------------------------

// name: CMP3Stream()

// desc:

// ------------------------------------------------------------------------------------------------

static off_t seek_sub(int fd, off_t nOffset, int iOrigin)

{

  if (fd)

  {

    IIEP::CMP3Stream *pcoStream = (IIEP::CMP3Stream *) fd;

    return pcoStream -> SeekFile(nOffset, iOrigin);

  }

  return 0;

}

// ------------------------------------------------------------------------------------------------

// name: CMP3Stream()

// desc:

// ------------------------------------------------------------------------------------------------

IIEP::CMP3Stream::CMP3Stream(void)

{

  m_dwKBPerSec    = INFINITE;

  m_dwTimeStart   = 0;

  m_pcoMH         = 0;

  m_dwTotalBlocks = 0;

  m_dwAlignment   = 4;

  m_dwLength      = 0;

  m_dwPosition    = 0;

  memcpy(m_ucHeader, g_ucWaveHeader, WAVE_HEADER_LENGTH);

  m_dwDataBufPos  = 0;

  m_dwDataBufLen  = 0;

  m_bSeekFlag     = false;

}

// ------------------------------------------------------------------------------------------------

// name: ~CMP3Stream()

// desc:

// ------------------------------------------------------------------------------------------------

IIEP::CMP3Stream::~CMP3Stream(void)

{

  Close();

}

// ------------------------------------------------------------------------------------------------

// name: SetSeekFlag()

// desc: called by IIEP::CPlayer::SetMediaPosition(QWORD qwPosition)

// ------------------------------------------------------------------------------------------------

void IIEP::CMP3Stream::SetSeekFlag(void)

{

  m_bSeekFlag = true;

}

// ------------------------------------------------------------------------------------------------

// name: Open()

// desc:

// ------------------------------------------------------------------------------------------------

bool IIEP::CMP3Stream::Open(const WORD *pcwsFileName, CMediaType &coMT, DWORD dwKBPerSec)

{

  Close();

  //

  if (MPG123_OK != mpg123_init())

  {

    goto OPEN_FAIL;

  }

  m_pcoMH = mpg123_new(NULL, NULL);

  if (0 == m_pcoMH)

  {

    goto OPEN_FAIL;

  }

  if (false == OpenFile(pcwsFileName))

  {

    goto OPEN_FAIL;

  }

  if (MPG123_OK != mpg123_replace_reader(m_pcoMH, read_sub, seek_sub))

  {

    goto OPEN_FAIL;

  }

  if (MPG123_OK != mpg123_open_fd(m_pcoMH, (int) this))

  {

    goto OPEN_FAIL;

  }

  long nRate;

  int  iChannels;

  int  iEncoding;

  if (MPG123_OK != mpg123_getformat(m_pcoMH, &nRate, &iChannels, &iEncoding))

  {

    goto OPEN_FAIL;

  }

  //  Ensure that this output format will not change (it could, when we allow it)

  mpg123_format_none(m_pcoMH);

	mpg123_format(m_pcoMH, nRate, iChannels, iEncoding);

  // scan & get total samples

  mpg123_scan(m_pcoMH);

  off_t nOff = mpg123_length(m_pcoMH); 

  if (nOff < 0)

  {

    goto OPEN_FAIL;

  }

  m_dwTotalBlocks = (DWORD) nOff;

  // set other format

  m_dwAlignment = iChannels * 2;

  if (0 == m_dwAlignment)

  {

    m_dwAlignment = 4;

  }

  m_dwLength = m_dwTotalBlocks * m_dwAlignment + WAVE_HEADER_LENGTH;

  WORD  wChannels        = (WORD ) iChannels;

  DWORD dwSamplesPerSec  = (DWORD) nRate;

  DWORD dwAvgBytesPerSec =         m_dwAlignment * dwSamplesPerSec;

  WORD  wBlockAlign      = (WORD ) m_dwAlignment;

  WORD  wBitsPerSample   =         16;

  PWORD  pwData;

  PDWORD pdwData;

  pdwData = (PDWORD) &m_ucHeader[0x04];

 *pdwData = m_dwTotalBlocks * m_dwAlignment + WAVE_HEADER_LENGTH - 8;

  pwData = (PWORD) &m_ucHeader[0x16];

 *pwData = wChannels;

  pdwData = (PDWORD) &m_ucHeader[0x18];

 *pdwData = dwSamplesPerSec;

  pdwData = (PDWORD) &m_ucHeader[0x1C];

 *pdwData = dwAvgBytesPerSec;

  pwData = (PWORD) &m_ucHeader[0x20];

 *pwData = wBlockAlign;

  pwData = (PWORD) &m_ucHeader[0x22];

 *pwData = wBitsPerSample;

  pdwData = (PDWORD) &m_ucHeader[0x28];

 *pdwData = m_dwTotalBlocks * m_dwAlignment;

  coMT.majortype = MEDIATYPE_Stream;

  coMT.subtype   = MEDIASUBTYPE_WAVE;

  SetPointer(0);

  m_dwTimeStart = ::timeGetTime();

  return true;

OPEN_FAIL:

  Close();

  return false;

}

// ------------------------------------------------------------------------------------------------

// name: Close()

// desc:

// ------------------------------------------------------------------------------------------------

void IIEP::CMP3Stream::Close(void)

{

  m_coFileIn.Close();

  if (m_pcoMH)

  {

	  mpg123_close (m_pcoMH);

	  mpg123_delete(m_pcoMH);

    m_pcoMH = 0;

  }

  mpg123_exit(); 

  m_dwTimeStart   = 0;

  m_dwTotalBlocks = 0;

  m_dwLength   = 0;

  m_dwPosition = 0;

  m_bSeekFlag = false;

  m_nDataBegin = 0;

  m_nDataTotal = 0;

}

// ------------------------------------------------------------------------------------------------

// name: SetPointer()

// desc:

// ------------------------------------------------------------------------------------------------

HRESULT IIEP::CMP3Stream::SetPointer(LONGLONG llPos)

{

  if (llPos < 0 || llPos > (LONGLONG) m_dwLength)

  {

    return S_FALSE;

  }

  m_dwPosition = (DWORD) llPos;

  if (llPos < WAVE_HEADER_LENGTH)

  {

    mpg123_seek(m_pcoMH, 0, SEEK_SET);

    m_dwDataBufLen = 0;

  }

  else

  {

    if (m_bSeekFlag && m_dwAlignment > 0)

    {

      m_bSeekFlag = false;

      mpg123_seek(m_pcoMH, (long) (m_dwPosition - WAVE_HEADER_LENGTH) / m_dwAlignment, SEEK_SET);

      m_dwDataBufLen = 0;

    }

  }

  return S_OK;

}

// ------------------------------------------------------------------------------------------------

// name: Read()

// desc:

// ------------------------------------------------------------------------------------------------

HRESULT IIEP::CMP3Stream::Read(PBYTE   pucBuffer,

                               DWORD   dwBytesToRead,

                               BOOL    bAlign,

                               LPDWORD pdwBytesRead)

{

  if (0 == m_pcoMH) return S_FALSE;

  CAutoLock lck(&m_csLock);

  DWORD dwReadLength;

  // wait until the bytes are here

  DWORD dwTime = ::timeGetTime();

  if (m_dwPosition + dwBytesToRead > m_dwLength)

  {

    dwReadLength = m_dwLength - m_dwPosition;

  }

  else

  {

    dwReadLength = dwBytesToRead;

  }

  DWORD dwTimeToArrive = (m_dwPosition + dwReadLength) / m_dwKBPerSec;

  if (dwTime - m_dwTimeStart < dwTimeToArrive)

  {

    ::Sleep(dwTimeToArrive - dwTime + m_dwTimeStart);

  }

  // read data

  DWORD dwRead = 0;

  if (m_dwPosition < WAVE_HEADER_LENGTH)

  {

    DWORD dwPatchLen = WAVE_HEADER_LENGTH - m_dwPosition;

    if (dwReadLength < dwPatchLen)

    {

      dwPatchLen = dwReadLength;

    }

    memcpy(pucBuffer, m_ucHeader + m_dwPosition, dwPatchLen);

    m_dwPosition += dwPatchLen;

    dwReadLength -= dwPatchLen;

    pucBuffer += dwPatchLen;

    dwRead    += dwPatchLen;

  }

  if (dwReadLength > 0)

  {

    while (m_dwDataBufLen < dwReadLength)

    {

      if (m_dwDataBufLen > 0)

      {

        memcpy(pucBuffer, m_ucDataBuffer + m_dwDataBufPos, m_dwDataBufLen);

        dwRead         += m_dwDataBufLen;

        dwReadLength   -= m_dwDataBufLen;

        pucBuffer      += m_dwDataBufLen;

        m_dwDataBufPos += m_dwDataBufLen;

        m_dwDataBufLen =  0;

      }

      if (DecodeFrame() == false) break;

    }

    if (dwReadLength > 0)

    {

      if (m_dwDataBufLen >= dwReadLength)

      {

        memcpy(pucBuffer, m_ucDataBuffer + m_dwDataBufPos, dwReadLength);

        dwRead         += dwReadLength;

        m_dwDataBufPos += dwReadLength;

        m_dwDataBufLen -= dwReadLength;

      }

    }

  }

  m_dwPosition += dwRead;

  *pdwBytesRead = dwRead;

  return S_OK;

}

// ------------------------------------------------------------------------------------------------

// name: Size()

// desc:

// ------------------------------------------------------------------------------------------------

LONGLONG IIEP::CMP3Stream::Size(LONGLONG *pSizeAvailable)

{

//  LONGLONG llCurrentAvailable = Int32x32To64((::timeGetTime() - m_dwTimeStart), m_dwKBPerSec);

  LONGLONG llLength = (LONGLONG) m_dwTotalBlocks * m_dwAlignment + WAVE_HEADER_LENGTH;

  if (pSizeAvailable)

  {

//  *pSizeAvailable = min(llLength, llCurrentAvailable);

    *pSizeAvailable = llLength;

  }

  return llLength;

}

// ------------------------------------------------------------------------------------------------

// name: Alignment()

// desc:

// ------------------------------------------------------------------------------------------------

DWORD IIEP::CMP3Stream::Alignment(void)

{

  return m_dwAlignment;

}

// ------------------------------------------------------------------------------------------------

// name: Lock()

// desc:

// ------------------------------------------------------------------------------------------------

void IIEP::CMP3Stream::Lock(void)

{

  m_csLock.Lock();

}

// ------------------------------------------------------------------------------------------------

// name: Unlock()

// desc:

// ------------------------------------------------------------------------------------------------

void IIEP::CMP3Stream::Unlock(void)

{

  m_csLock.Unlock();

}

// ------------------------------------------------------------------------------------------------

// name: DecodeFrame()

// desc:

// ------------------------------------------------------------------------------------------------

bool IIEP::CMP3Stream::DecodeFrame(void)

{

  if (0 == m_dwDataBufLen)

  {

    m_dwDataBufPos = 0;

  }

  if (m_dwDataBufPos + m_dwDataBufLen + MP3_DECODE_LEN > MP3_DECODE_BUF_LEN)

  {

    return true;

  }

  size_t nBytesRead = 0;

  mpg123_read(m_pcoMH, m_ucDataBuffer + m_dwDataBufPos + m_dwDataBufLen, MP3_DECODE_LEN, &nBytesRead);

  m_dwDataBufLen += (DWORD) nBytesRead;

  return (m_dwDataBufLen > 0);

}

// ------------------------------------------------------------------------------------------------

// name: OpenFile()

// desc:

// ------------------------------------------------------------------------------------------------

bool IIEP::CMP3Stream::OpenFile(const WORD *pcwsFileName)

{

  if (m_coFileIn.Open(pcwsFileName))

  {

    m_nDataBegin = 0;

    m_nDataTotal = m_coFileIn.GetFileSize();

    // check ID3 Tag V2.x

    BYTE ucBuffer[8];

    bool bFound;

TRY_ID3_AGAIN:

    bFound = false;

    if (6 == m_coFileIn.Read(ucBuffer, 6))

    {

      if (ucBuffer[0] == 'I' &&

          ucBuffer[1] == 'D' &&

          ucBuffer[2] == '3')

      {

        bFound = true;

        DWORD dwHeaderSize;

        if (m_coFileIn.ReadInverseDW(dwHeaderSize))

        {

          dwHeaderSize = ((dwHeaderSize & 0x7F000000) >> 3) +

                         ((dwHeaderSize & 0x007F0000) >> 2) +

                         ((dwHeaderSize & 0x00007F00) >> 1) +

                         ((dwHeaderSize & 0x0000007F)     );

          dwHeaderSize += 10;

          m_nDataBegin += dwHeaderSize;

          m_nDataTotal -= dwHeaderSize;

          if (ucBuffer[3] >= 0x03)  // ID3 Tag version >= 2.3

          {

            if (ucBuffer[5] & 0x40) // has extended header

            {

              if (m_coFileIn.ReadInverseDW(dwHeaderSize))

              {

                dwHeaderSize = ((dwHeaderSize & 0x7F000000) >> 3) +

                               ((dwHeaderSize & 0x007F0000) >> 2) +

                               ((dwHeaderSize & 0x00007F00) >> 1) +

                               ((dwHeaderSize & 0x0000007F)     );

                dwHeaderSize += 4;

                m_nDataBegin += dwHeaderSize;

                m_nDataTotal -= dwHeaderSize;

              }

            }

          }

        }

      }

    }

    SeekFile(0, SEEK_SET);

    if (bFound)

    {

      goto TRY_ID3_AGAIN;

    }

/*

    m_coFileIn.Read(ucBuffer, 2);

    if (ucBuffer[0] != 0xFF || ucBuffer[1] < 0xF0)

    {

      m_nDataBegin ++;

      m_nDataTotal --;

      SeekFile(0, SEEK_SET);

      goto TRY_ID3_AGAIN;

    }

    SeekFile(0, SEEK_SET);

*/

    return true;

  }

  return false;

}

// ------------------------------------------------------------------------------------------------

// name: ReadFile()

// desc:

// ------------------------------------------------------------------------------------------------

DWORD IIEP::CMP3Stream::ReadFile(PVOID pBuf, DWORD dwLen)

{

  return m_coFileIn.Read(pBuf, dwLen);

}

// ------------------------------------------------------------------------------------------------

// name: SeekFile()

// desc:

// ------------------------------------------------------------------------------------------------

long IIEP::CMP3Stream::SeekFile(long nOffset, int iOrigin)

{

  switch (iOrigin)

  {

  case SEEK_SET:

    if (nOffset < 0 || nOffset >= m_nDataTotal) return -1;

    break;

  case SEEK_CUR:

    nOffset += (m_coFileIn.GetReadPosition() - m_nDataBegin);

    if (nOffset < 0 || nOffset >= m_nDataTotal) return -1;

    break;

  case SEEK_END:

    nOffset = m_nDataTotal - 1 + nOffset;

    if (nOffset < 0 || nOffset >= m_nDataTotal) return -1;

    break;

  }

  if (m_coFileIn.Seek(nOffset + m_nDataBegin, SEEK_SET))

  {

    return nOffset;

  }

  return -1;

}

// ------------------------------------------------------------------------------------------------