axmol/CocosDenshion/uphone/SoundPlayer.cpp

#include "SoundPlayer.h"
#include "TCOM_MediaPlayer_IIDs.h"
#include "TCOM_Generic_DataType_IIDs.h"

#define BREAK_IF(cond)      if (cond) break;

SoundPlayer::SoundPlayer()
: m_pPlayer(NULL)
, m_pMediaFile(NULL)
, m_MethodEmun(NULL)
{
    TCoInitialize(NULL);           
    if(m_MethodEmun.EnumMethod(TIID_DataType_SysFile, 0,  TIID_MediaPlayer_Method_Play )>0)
    {
        if(m_MethodEmun.GetDataTypeInterface(0,TCOM_CLSCTX_INPROC_SERVER,(LPVOID *)&m_pMediaFile)>= 0) 
        {
            HRESULT hr = m_pMediaFile->QueryInterface( TIID_MediaPlayer_Method_Play ,(LPVOID*)&m_pPlayer);
            if(TCOM_S_FAIL(hr))
            {
            }
            else
            {
                m_pPlayer->SetVolume(100);
            }
        }
    }

    MemSet(m_fileName, 0, sizeof(TUChar) * MAX_PATH);
}

SoundPlayer::~SoundPlayer()
{
    Release();
}

Boolean SoundPlayer::OpenAudioFile(const char* pszFilePath)
{
    Boolean bRet = FALSE;

    do 
    {
        BREAK_IF(!m_pMediaFile);

        TUString::StrGBToUnicode(m_fileName, (const Char*)pszFilePath);
        BREAK_IF(!EOS_IsFileExist(m_fileName));

        m_pMediaFile->SetName(m_fileName);
        BREAK_IF(! m_pPlayer || ! m_pPlayer->Open());

        bRet = TRUE;
    } while (0);

    return bRet;
}

void SoundPlayer::PlaySoundFile(const char* pFileName, Int32 nTimes)
{
    if (OpenAudioFile(pFileName))
    {
        m_pPlayer->Start();
        m_pPlayer->SetLoopTimes(nTimes);
    }
}

void SoundPlayer::PlaySoundFromMem(UInt8* pData, Int32 nSize, const char* FileName, Int32 nTimes)
{
    if (m_pMediaFile)
    {
        Int32 nRet = m_pMediaFile->SetContent(pData, nSize);

        if (! strlen(FileName))
        {
            const TUChar ExtendName[] = {'.', 'w', 'a', 'v', 0};
            const TUChar format[]     = { '%', 'd', 0};
            TUString::StrPrintF(m_fileName, format, nSize);
            TUString::StrCat(m_fileName, ExtendName);
        }
        else
        {
            TUString::StrGBToUnicode(m_fileName, (const Char*)(FileName));
        }

        m_pMediaFile->SetName(m_fileName);
        m_pMediaFile->SetMode(SYS_FILE_MEMORY_FILE_TYPE);

        if (m_pPlayer->Open())
        {
            m_pPlayer->Start();
            m_pPlayer->SetLoopTimes(nTimes);
        }
    }
}

void SoundPlayer::SetVolumeValue(Int32 nValue)
{
    if (m_pPlayer)
    {
        m_pPlayer->SetVolume(nValue);
    }
}

void SoundPlayer::Release()
{
    if (m_pPlayer)
    {
        m_pPlayer->Release();
        m_pPlayer = NULL;
    }
    if (m_pMediaFile)
    {
        m_pMediaFile->Release();
        m_pMediaFile = NULL;
    }

    TCoUninitialize();
}

void SoundPlayer::Pause()
{
    if (m_pPlayer)
    {
        m_pPlayer->Pause();
    }
}

void SoundPlayer::Resume()
{
    if (m_pPlayer)
    {
        m_pPlayer->Pause();
    }
}

void SoundPlayer::Stop()
{
    if (m_pPlayer)
    {
        m_pPlayer->Stop();
    }
}

void SoundPlayer::Rewind()
{
    if (m_pPlayer && m_pPlayer->HasAudio())
    {
        m_pPlayer->Stop();
        m_pPlayer->Start();
    }
}

void SoundPlayer::Mute(bool bMute)
{
    if (m_pPlayer)
    {
        m_pPlayer->Mute(bMute);
    }
}

bool SoundPlayer::IsPlaying()
{
    TMediaPlayerStatus status = m_pPlayer->GetCurrentStatus();

    return (status == PLAYER_STATUS_PLAYING);
}

Int32 SoundPlayer::GetFileBufferSize(const char* pszFilePath)
{
    Int32 nRet = -1;

    if (OpenAudioFile(pszFilePath))
    {
        nRet = m_pPlayer->GetDecodedAudioSize();
        m_pPlayer->Close();
    }

    return nRet;
}

Int32 SoundPlayer::DecodeFile(void* buffer, Int32 bufferLen, const char* pszFilePath)
{
    Int32 nRet = -1;

    UInt8* pBuffer = (UInt8*) buffer;

    if (OpenAudioFile(pszFilePath))
    {
        nRet = m_pPlayer->DecodeAudioToBuffer(pBuffer, bufferLen, TMM_AUDIO_FILE_WAV);

        m_pPlayer->Close();
    }

    return nRet;
}