Bink Player

class CBIKMaterial
{
public:
    CBIKMaterial();
    ~CBIKMaterial();

    bool Init(const char *pFileName);
    void Shutdown(void);
    bool Update(void);
    int GetTexture(void);
    void GetFrameSize(int *pWidth, int *pHeight);
    int GetFrameRate(void);
    int GetFrameCount(void);
    void SetFrame(float flFrame);
    void SetLoop(bool state);

private:
    void CreateProceduralTexture(void);
    void DestroyProceduralTexture(void);

    int m_Texture;

    HBINK m_pHBINK;

    U8 *m_pBuffer;
    U32 m_nBufferSize;

    int m_nBIKWidth;
    int m_nBIKHeight;
    
    int m_nFrameRate;
    int m_nFrameCount;

    bool m_bLoop;

    HBINKTRACK m_hTrack;

    U8 *m_pSampleData;
    U32 m_nSampleSize;

public:
    float *m_pWaveData;
    U32 m_nWaveSize;
};

CBIKMaterial::CBIKMaterial()
{
    m_pHBINK = NULL;
}

CBIKMaterial::~CBIKMaterial()
{
}

bool CBIKMaterial::Init(const char *pFileName)
{
    m_pHBINK = BinkOpen(pFileName, BINKSNDTRACK);

    if (!m_pHBINK)
    {
        m_nBIKWidth = 64;
        m_nBIKHeight = 64;
        m_nFrameRate = 1;
        m_nFrameCount = 1;

        return false;
    }

    m_nBIKWidth = m_pHBINK->Width;
    m_nBIKHeight = m_pHBINK->Height;

    m_nFrameRate = (int)((float)m_pHBINK->FrameRate / (float)m_pHBINK->FrameRateDiv);
    m_nFrameCount = m_pHBINK->Frames;

    m_nBufferSize = m_nBIKWidth * m_nBIKHeight * 3; // RGB(A)

    m_pBuffer = new U8[m_nBufferSize];
    memset(m_pBuffer, 0, m_nBufferSize);

    CreateProceduralTexture();

    if (m_pHBINK->NumTracks)
    {
        m_hTrack = BinkOpenTrack(m_pHBINK, 0);

        BINKTRACK *track = (BINKTRACK *)m_hTrack;

        m_nSampleSize = track->MaxSize;
        m_pSampleData = new U8[m_nSampleSize];

        m_nWaveSize = 2048;
        m_pWaveData = new float[m_nWaveSize];
    }

    for (int i = 0; i < m_pHBINK->NumTracks; ++i)
    {
        BinkSetVolume(m_pHBINK, BinkGetTrackID(m_pHBINK, i), 0xFFFF);
    }

    return true;
}

void CBIKMaterial::Shutdown(void)
{
    DestroyProceduralTexture();

    if (m_pHBINK)
    {
        BinkClose(m_pHBINK);
        m_pHBINK = NULL;
    }

    if (m_pBuffer)
    {
        delete[] m_pBuffer;
        m_pBuffer = NULL;
    }
}

bool CBIKMaterial::Update(void)
{
    BinkDoFrame(m_pHBINK);

    if (BinkWait(m_pHBINK))
        return true;

    while (BinkShouldSkip(m_pHBINK))
    {
        BinkNextFrame(m_pHBINK);
        BinkDoFrame(m_pHBINK);
    }

    if (m_pHBINK->FrameNum == m_pHBINK->Frames)
    {
        if (m_bLoop)
        {
            BinkGoto(m_pHBINK, 0, 0);
        }

        return false;
    }

    BinkCopyToBuffer(m_pHBINK, m_pBuffer, m_nBIKWidth * 3, m_nBIKHeight, 0, 0, BINKSURFACE24R);
    glBindTexture(GL_TEXTURE_2D, m_Texture);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_nBIKWidth, m_nBIKHeight, GL_RGB, GL_UNSIGNED_BYTE, m_pBuffer);

    if (m_pHBINK->NumTracks && m_pSampleData)
    {
        memset(m_pSampleData, 0, m_nSampleSize);
        BinkGetTrackData(m_hTrack, m_pSampleData);

        BINKTRACK *track = (BINKTRACK *)m_hTrack;
        int i, n;

        memset(m_pWaveData, 0, m_nWaveSize);

        if (track->Channels == 1 && track->Bits == 8)
        {
            for (i = 0, n = 0; i < m_nSampleSize && n < m_nWaveSize; )
            {
                m_pWaveData[n] = (float)m_pSampleData[i] / 128.0f;
                ++i;
                ++n;
            }
        }
        else if (track->Channels == 2 && track->Bits == 8)
        {
            for (i = 0, n = 0; i < m_nSampleSize && n < m_nWaveSize; )
            {
                float l = (float)m_pSampleData[i] / 128.0f;
                ++i;
                float r = (float)m_pSampleData[i] / 128.0f;
                ++i;

                m_pWaveData[n] = (l + r) / 2.0f;
                ++n;
            }
        }
        else if (track->Channels == 1 && track->Bits == 16)
        {
            for (i = 0, n = 0; i < m_nSampleSize && n < m_nWaveSize; )
            {
                m_pWaveData[n] = (float)( (m_pSampleData[i + 1] << 8) + 
                    m_pSampleData[i]) / 32767.0f;

                i += 2;
                ++n;
            }
        }
        else if (track->Channels == 2 && track->Bits == 16)
        {
            for (i = 0, n = 0; i < m_nSampleSize && n < m_nWaveSize; )
            {
                float l = (float)( (m_pSampleData[i + 1] << 8) + 
                    m_pSampleData[i]) / 32767.0f;
                float r = (float)( (m_pSampleData[i + 3] << 8) + 
                    m_pSampleData[i + 2]) / 32767.0f;

                i += 4;

                m_pWaveData[n] = (l + r) / 2.0f;
                ++n;
            }
        }
    }

    BinkNextFrame(m_pHBINK);

    return true;
}

int CBIKMaterial::GetTexture(void)
{
    return m_Texture;
}

void CBIKMaterial::GetFrameSize(int *pWidth, int *pHeight)
{
    *pWidth = m_nBIKWidth;
    *pHeight = m_nBIKHeight;
}

int CBIKMaterial::GetFrameRate(void)
{
    return m_nFrameRate;
}

int CBIKMaterial::GetFrameCount(void)
{
    return m_nFrameCount;
}

void CBIKMaterial::SetFrame(float flFrame)
{
    U32 iFrame = (U32)flFrame + 1;

    if (m_pHBINK->LastFrameNum != iFrame)
    {
        BinkGoto(m_pHBINK, iFrame, 0);
    }
}

void CBIKMaterial::SetLoop(bool state)
{
    m_bLoop = state;
}

void CBIKMaterial::CreateProceduralTexture(void)
{
    glGenTextures(1, (GLuint *)&m_Texture);

    glBindTexture(GL_TEXTURE_2D, m_Texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_nBIKWidth, m_nBIKHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, m_pBuffer);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

void CBIKMaterial::DestroyProceduralTexture(void)
{
    glDeleteTextures(1, (GLuint *)&m_Texture);
}