Subversion Repositories spk

#include "Movies.h"
#include <dshow.h>
#include <windows.h>
#include <mmsystem.h>
#include <atlbase.h>

//#define NO_AUDIO_RENDERER

LPDIRECT3DTEXTURE9 m_pTexture = NULL; // our texture

CComPtr<IGraphBuilder>  g_pGB;          // GraphBuilder
CComPtr<IMediaControl>  g_pMC;          // Media Control
CComPtr<IMediaPosition> g_pMP;          // Media Position
CComPtr<IMediaEvent>    g_pME;          // Media Event
CComPtr<IBaseFilter>    g_pRenderer;    // our custom renderer

D3DFORMAT               g_TextureFormat; // Texture format


LPDIRECT3DDEVICE9 gD3dDevice2;

//////////
// Construction/Destruction
//

CMovies::CMovies()
{
        Clean();
}

LPDIRECT3DTEXTURE9 CMovies::GetTexture () { return m_pTexture; }

CMovies::~CMovies()
{
        CoUninitialize();
}

bool CMovies::Initialise( LPDIRECT3DDEVICE9 device, const char *szVideoFilename, LPDIRECT3DTEXTURE9 texture )
{
        if ( m_cVideoFilename == szVideoFilename )
        {
                Stop();
                return true;
        }

        Clean();

        m_cVideoFilename = (char*)szVideoFilename; 

        gD3dDevice2 = device;

        //CoInitialize(NULL);

        HRESULT hr = S_OK;
        CComPtr<IBaseFilter>    pFSrc;                  // Source Filter
        CComPtr<IPin>           pFSrcPinOut;    // Source Filter Output Pin   
        CTextureRenderer        *pCTR = 0;              // DirectShow Texture renderer
    
//      Create the filter graph
        if ( FAILED( g_pGB.CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC) ) )
                return false;

//      Create the Texture Renderer object
        pCTR = new CTextureRenderer(NULL, &hr);

    if ( FAILED(hr) || !pCTR )
                return false;

        g_pRenderer = pCTR;
//      pFTR = pCTR;

        if ( FAILED( g_pGB->AddFilter(g_pRenderer, L"TEXTURERENDERER") ) )
                return false;

        TCHAR strFileName[MAX_PATH];
        WCHAR wFileName[MAX_PATH];

        lstrcpyn( strFileName, szVideoFilename, MAX_PATH - 1 );

    strFileName[MAX_PATH-1] = 0;
    wFileName[MAX_PATH-1] = 0;

        USES_CONVERSION;
        wcsncpy(wFileName, T2W(strFileName), NUMELMS(wFileName));

        hr = g_pGB->AddSourceFilter (wFileName, L"SOURCE", &pFSrc);
    
//      If the media file was not found, inform the user.
        if ( hr == VFW_E_NOT_FOUND )
        {
//              Msg(TEXT("Could not add source filter to graph!  (hr==VFW_E_NOT_FOUND)\r\n\r\n")
//                      TEXT("This sample reads a media file from the DirectX SDK's media path.\r\n")
//                      TEXT("Please install the DirectX 9 SDK on this machine."));
                return false;
        }
        else if ( FAILED( hr ) )
        {
//              Msg(TEXT("Could not add source filter to graph!  hr=0x%x"), hr);
                return false;
        }

        if ( FAILED( pFSrc->FindPin(L"Output", &pFSrcPinOut) ) )
        {
//              Msg(TEXT("Could not find output pin!  hr=0x%x"), hr);
                return false;
        }

#ifdef NO_AUDIO_RENDERER

        CComPtr<IPin> pFTRPinIn;      // Texture Renderer Input Pin

//      Find the source's output pin and the renderer's input pin
        if ( FAILED( g_pRenderer->FindPin(L"In", &pFTRPinIn) ) )
        {
//              Msg(TEXT("Could not find input pin!  hr=0x%x"), hr);
                return false;
        }

//      Connect these two filters
        if ( FAILED( g_pGB->Connect(pFSrcPinOut, pFTRPinIn) ) )
        {
//              Msg(TEXT("Could not connect pins!  hr=0x%x"), hr);
                return false;
        }

#else

        // Render the source filter's output pin.  The Filter Graph Manager
        // will connect the video stream to the loaded CTextureRenderer
        // and will load and connect an audio renderer (if needed).

        if ( FAILED( g_pGB->Render(pFSrcPinOut) ) )
        {
//              Msg(TEXT("Could not render source output pin!  hr=0x%x"), hr);
                return false;
        }

#endif

//      Get the graph's media control, event & position interfaces
        g_pGB.QueryInterface(&g_pMC);
        g_pGB.QueryInterface(&g_pMP);
        g_pGB.QueryInterface(&g_pME);
    
        m_iVideoWidth = pCTR->m_lVidWidth;
        m_iVideoHeight = pCTR->m_lVidHeight;
        m_fRotation = 0.0f;

        return true;
}

void CMovies::Clean()
{
        g_pGB = NULL;
        g_pMP = NULL;
        g_pMC = NULL;
        g_pME = NULL;
        g_pRenderer = NULL;

        m_cVideoFilename = NULL;
        m_bPlaying = false;
        m_bPaused = true;
}

bool CMovies::Play()
{
        if ( FAILED( g_pMC->Run() ) )
                return false;

        m_bPlaying = true;
        m_bPaused = false;
        
        return true;
}

bool CMovies::Stop()
{
        if ( FAILED ( g_pMC->Stop() ) )
                return false;

        double temp;
        
        g_pMP->get_CurrentPosition( &temp );

        if ( FAILED ( g_pMP->put_CurrentPosition( 0 ) ) )
                return false;

//      temp += 0;

        m_bPlaying = false;
        m_bPaused = true;

        return true;
}

bool CMovies::Pause()
{
        if ( FAILED ( g_pMC->Pause() ) )
                return false;

        m_bPaused = true;
        
        return true;
}

bool CMovies::JumpTo( double PositionInSeconds )
{
        if ( FAILED ( g_pMP->put_CurrentPosition( PositionInSeconds ) ) )
                return false;

        return true;
}

bool CMovies::HasMovieEnded()
{
        long lEventCode, lParam1, lParam2;

//      Check for completion events
        HRESULT hr = g_pME->GetEvent(&lEventCode, (LONG_PTR *) &lParam1, (LONG_PTR *) &lParam2, 0);

        if (SUCCEEDED(hr))
        {
                if ( EC_COMPLETE == lEventCode ) 
                        return true;

//              Free any memory associated with this event
                hr = g_pME->FreeEventParams(lEventCode, lParam1, lParam2);
        }

        return false;
}

long CMovies::MovieLength()
{
        double length;

        g_pMP->get_Duration( &length );

        return (long)length * 1000;
}

//////////
//      Construction / Deconstruction
//
CTextureRenderer::CTextureRenderer( LPUNKNOWN pUnk, HRESULT *phr )
                                  : CBaseVideoRenderer(__uuidof(CLSID_TextureRenderer), 
                                    NAME("Texture Renderer"), pUnk, phr),
                                    m_bUseDynamicTextures(FALSE)
{
//      Store and AddRef the texture for our use.
        if (phr)
                *phr = S_OK;
}


CTextureRenderer::~CTextureRenderer()
{

}

HRESULT CTextureRenderer::CheckMediaType(const CMediaType *pmt)
{
        
    HRESULT   hr = E_FAIL;
    VIDEOINFO *pvi=0;
    
    CheckPointer(pmt,E_POINTER);

    // Reject the connection if this is not a video type
    if( *pmt->FormatType() != FORMAT_VideoInfo ) {
        return E_INVALIDARG;
    }
    
// Only accept RGB24 video
    pvi = (VIDEOINFO *)pmt->Format();

    if ( IsEqualGUID( *pmt->Type(),    MEDIATYPE_Video )  &&
                 IsEqualGUID( *pmt->Subtype(), MEDIASUBTYPE_RGB24 ) )
                hr = S_OK;
    return hr;
  }

HRESULT CTextureRenderer::SetMediaType(const CMediaType *pmt)
{
    HRESULT hr;

    UINT uintWidth = 2;
    UINT uintHeight = 2;

    // Retrive the size of this media type
    D3DCAPS9 caps;
    VIDEOINFO *pviBmp;                      // Bitmap info header
    pviBmp = (VIDEOINFO *)pmt->Format();

    m_lVidWidth  = pviBmp->bmiHeader.biWidth;
    m_lVidHeight = abs(pviBmp->bmiHeader.biHeight);
    m_lVidPitch  = (m_lVidWidth * 3 + 3) & ~(3); // We are forcing RGB24

    // here let's check if we can use dynamic textures
    ZeroMemory( &caps, sizeof(D3DCAPS9));

    hr = gD3dDevice2->GetDeviceCaps( &caps );
/*
    if ( caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES )
    {
        m_bUseDynamicTextures = true;
    }*/

    if( caps.TextureCaps & D3DPTEXTURECAPS_POW2 )
    {
        while( (LONG)uintWidth < m_lVidWidth )
            uintWidth = uintWidth << 1;

                while( (LONG)uintHeight < m_lVidHeight )
            uintHeight = uintHeight << 1;
    }
    else
    {
        uintWidth = m_lVidWidth;
        uintHeight = m_lVidHeight;
    }

        
//      Create the texture that maps to this media type
    hr = E_UNEXPECTED;

    if( m_bUseDynamicTextures )
    {
        hr = gD3dDevice2->CreateTexture( uintWidth, uintHeight, 1, D3DUSAGE_DYNAMIC, D3DFMT_X8R8G8B8,D3DPOOL_DEFAULT,
                                                                                &m_pTexture, NULL );
        if( FAILED(hr))
            m_bUseDynamicTextures = FALSE;
    }

    if( FALSE == m_bUseDynamicTextures )
        hr = gD3dDevice2->CreateTexture(uintWidth, uintHeight, 1, 0, 
                                         D3DFMT_X8R8G8B8,D3DPOOL_MANAGED,
                                         &m_pTexture, NULL);

        if ( FAILED(hr) )
                return false;

    // CreateTexture can silently change the parameters on us
    D3DSURFACE_DESC ddsd;
    ZeroMemory(&ddsd, sizeof(ddsd));

    if ( FAILED( m_pTexture->GetLevelDesc( 0, &ddsd ) ) ) 
        return false;

    CComPtr<IDirect3DSurface9> pSurf; 

    if ( SUCCEEDED( hr = m_pTexture->GetSurfaceLevel(0, &pSurf) ) )
        pSurf->GetDesc(&ddsd);

    // Save format info
    g_TextureFormat = ddsd.Format;

    if ( (g_TextureFormat != D3DFMT_X8R8G8B8) && (g_TextureFormat != D3DFMT_A1R5G5B5) )
        return VFW_E_TYPE_NOT_ACCEPTED;

    return S_OK;
}

HRESULT CTextureRenderer::DoRenderSample( IMediaSample * pSample )
{
        
    BYTE  *pBmpBuffer, *pTxtBuffer; // Bitmap buffer, texture buffer
    LONG  lTxtPitch;                // Pitch of bitmap, texture

    BYTE  * pbS = NULL;
    DWORD * pdwS = NULL;
    DWORD * pdwD = NULL;
    UINT row, col, dwordWidth, backwards;
    
    CheckPointer( pSample,E_POINTER );
    CheckPointer( m_pTexture,E_UNEXPECTED );

    // Get the video bitmap buffer
    pSample->GetPointer( &pBmpBuffer );

    // Lock the Texture
    D3DLOCKED_RECT d3dlr;
    if( m_bUseDynamicTextures )
    {
        if( FAILED(m_pTexture->LockRect(0, &d3dlr, 0, D3DLOCK_DISCARD)))
            return E_FAIL;
    }
    else
    {
        if (FAILED(m_pTexture->LockRect(0, &d3dlr, 0, 0)))
            return E_FAIL;
    }
    // Get the texture buffer & pitch
    pTxtBuffer = static_cast<byte *>(d3dlr.pBits);
    lTxtPitch = d3dlr.Pitch;

//      Copy the bits    
    if ( g_TextureFormat == D3DFMT_X8R8G8B8 )
    {
        // Instead of copying data bytewise, we use DWORD alignment here.
        // We also unroll loop by copying 4 pixels at once.
        //
        // original BYTE array is [b0][g0][r0][b1][g1][r1][b2][g2][r2][b3][g3][r3]
        //
        // aligned DWORD array is     [b1 r0 g0 b0][g2 b2 r1 g1][r3 g3 b3 r2]
        //
        // We want to transform it to [ff r0 g0 b0][ff r1 g1 b1][ff r2 g2 b2][ff r3 b3 g3]
        // below, bitwise operations do exactly this.

        dwordWidth = m_lVidWidth / 4; // aligned width of the row, in DWORDS
                                      // (pixel by 3 bytes over sizeof(DWORD))

                backwards = m_lVidWidth * m_lVidHeight * 4;

        for( row = 0; row< (UINT)m_lVidHeight; row++)
        {
            pdwS = ( DWORD* )pBmpBuffer;
            pdwD = ( DWORD* )pTxtBuffer;

                        for( col = 0; col < dwordWidth; col ++ )
                        {
                                pdwD[0] =  pdwS[0] | 0xFF000000;
                                pdwD[1] = ( ( pdwS[1] << 8)  | 0xFF000000) | ( pdwS[0] >> 24 );
                                pdwD[2] = ( ( pdwS[2] << 16) | 0xFF000000) | ( pdwS[1] >> 16 );
                                pdwD[3] = 0xFF000000 | ( pdwS[2] >> 8 );
                                pdwD += 4; 
                                pdwS += 3;
                        }


//                      We might have remaining (misaligned) bytes here
            pbS = (BYTE*) pdwS;
            for( col = 0; col < (UINT)m_lVidWidth % 4; col++)
            {
                *pdwD = 0xFF000000     |
                        (pbS[2] << 16) |
                        (pbS[1] <<  8) |
                        (pbS[0]);
                pdwD++;
                pbS += 3;           
            }

            pBmpBuffer  += m_lVidPitch;
            pTxtBuffer += lTxtPitch;
        }// for rows
    }

    if (g_TextureFormat == D3DFMT_A1R5G5B5) 
    {
        for(int y = 0; y < m_lVidHeight; y++ ) 
        {
            BYTE *pBmpBufferOld = pBmpBuffer;
            BYTE *pTxtBufferOld = pTxtBuffer;   

            for (int x = 0; x < m_lVidWidth; x++) 
            {
                *(WORD *)pTxtBuffer = (WORD)
                    (0x8000 +
                    ((pBmpBuffer[2] & 0xF8) << 7) +
                    ((pBmpBuffer[1] & 0xF8) << 2) +
                    (pBmpBuffer[0] >> 3));

                pTxtBuffer += 2;
                pBmpBuffer += 3;
            }

            pBmpBuffer = pBmpBufferOld + m_lVidPitch;
            pTxtBuffer = pTxtBufferOld + lTxtPitch;
        }
    }

    // Unlock the Texture
    if ( FAILED( m_pTexture->UnlockRect(0) ) )
        return E_FAIL;

    return S_OK;
}