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 = ;
         m_nBIKHeight = ;
         m_nFrameRate = ;
         m_nFrameCount = ;

         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 * ; // RGB(A)

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

     CreateProceduralTexture();

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

         BINKTRACK *track = (BINKTRACK *)m_hTrack;

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

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

     for (int i = ; 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, , );
         }

         return false;
     }

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

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

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

         memset(m_pWaveData, , m_nWaveSize);

         if (track->Channels ==  && track->Bits == )
         {
             for (i = , n = ; i < m_nSampleSize && n < m_nWaveSize; )
             {
                 m_pWaveData[n] = (float)m_pSampleData[i] / 128.0f;
                 ++i;
                 ++n;
             }
         }
         else if (track->Channels ==  && track->Bits == )
         {
             for (i = , n = ; 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 ==  && track->Bits == )
         {
             for (i = , n = ; i < m_nSampleSize && n < m_nWaveSize; )
             {
                 m_pWaveData[n] = (float)( (m_pSampleData[i + ] << ) +
                     m_pSampleData[i]) / 32767.0f;

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

                 i += ;

                 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 + ;

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

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

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

     glBindTexture(GL_TEXTURE_2D, m_Texture);
     glTexImage2D(GL_TEXTURE_2D, , GL_RGB, m_nBIKWidth, m_nBIKHeight, , 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(, (GLuint *)&m_Texture);
 }