//========= Copyright Valve Corporation, All rights reserved. ============//
//-----------------------------------------------------------------------------
// File: XMVHelper.h
//
// Desc: Definition of XMV playback helper class for playing XMVs in a number
// of different ways.
//
// Hist: 2.7.03 - Created, based on work by Jeff Sullivan
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#ifndef _XMVHELPER_H_
#define _XMVHELPER_H_
#include <xtl.h>
#include <xmv.h>
// Number of textures to allocate for decoding. A larger number may help to
// smooth out any frame rate variations if you are decoding to a texture.
// When decoding to overlays two textures are always used.
const DWORD XMVPLAYER_NUMTEXTURES = 2;
//-----------------------------------------------------------------------------
// Name: LOAD_CONTEXT
// Desc: This structure is used to hold information used by the packet callbacks.
//-----------------------------------------------------------------------------
struct LOAD_CONTEXT
{
// Memory available for loading packets - maximum packet size.
DWORD dwPacketSize;
// Packet that XMV was decoding out of, and might still be, that
// we want to load into as soon as we can.
BYTE* pPendingReleasePacket;
// Packet that XMV is decoding out of.
BYTE* pDecodingPacket;
// Packet we are currently loading into.
BYTE* pLoadingPacket;
// Information for when reading packets out of a file.
// Handle to the file we are reading from.
HANDLE hFile;
// Overlapped structure to control asynchronous reading.
OVERLAPPED Overlapped;
// Information for when copying packets out of a memory buffer.
// The size and location of the buffer we are reading from if we are
// playing a movie from memory.
BYTE* pInputBuffer;
DWORD inputSize;
// The offset in the memory buffer that we are currently reading from.
DWORD readOffset;
// The size of the packet that we have 'queued up' for reading. This
// is a packet that we have warned about via ReleasePreviousMemoryPacket
// but have not yet been asked to load.
DWORD currentPacketSize;
};
class CXMVPlayer
{
public:
CXMVPlayer();
~CXMVPlayer();
// Open a .wmv file and prepare it for playing.
// The format parameter specifies what type of texture it should be unpacked into ( if allocateTextures
// is TRUE ). Only YUY2, LIN_X8R8G8B8 and LIN_A8R8G8B8 are supported as formats.
// If you plan to play the movie with Play() or otherwise use overlays then format must be D3DFMT_YUY2
// pDevice is needed in order to create textures.
// allocateTextures should be TRUE if you plan to play the movie manually with AdvanceFrame.
// It should be FALSE if you plan to play the movie with Play().
// IsPlaying() will return TRUE if the movie opened successfully.
HRESULT OpenFile( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures );
// Open a file using the packet interface. This method of opening a .wmv file can be easily
// customized to read the data from game specific file formats. The GetNextPacket and
// ReleasePreviousPacket functions from XMVHelper.cpp are used to read the packets. See above for
// information about the other parameters.
HRESULT OpenFileForPackets( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures );
// Open a block of memory for playing using the packet interface. This method of opening a .wmv file can be easily
// customized to read the data from game specific file formats, or to retain the block of data in memory.
// The GetNextMemoryPacket and ReleasePreviousMemoryPacket functions from XMVHelper.cpp are used to read
// the packets. See above for information about the other parameters.
HRESULT OpenMovieFromMemory( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures );
// Destroy frees up all the movie resources. IsPlaying() will return FALSE afterwards. Destroy()
// can be called during movie playback, but is not thread safe.
HRESULT Destroy();
// The AdvanceFrame functions move to the next frame if it is time for that. Call this
// function frequently - typically 30-60 times per second.
// AdvanceFrameForTexturing returns the most recent frame decoded, for texturing.
// It will return zero if the first frame has not been decoded, but otherwise
// will always return a texture.
LPDIRECT3DTEXTURE8 AdvanceFrameForTexturing( LPDIRECT3DDEVICE8 pDevice );
// AdvanceFrameForOverlays returns newly decoded frames, for use as an overlays.
// You MUST call UpdateOverlay() with the texture's surface.
// It will return zero if there is not a *new* frame available.
LPDIRECT3DTEXTURE8 AdvanceFrameForOverlays( LPDIRECT3DDEVICE8 pDevice );
// Get information about the movie playing.
DWORD GetWidth() const { return m_VideoDesc.Width; }
DWORD GetHeight() const { return m_VideoDesc.Height; }
DWORD GetCurrentFrame() const { return m_dwCurrentFrame; }
DWORD GetElapsedTime() const { return m_bPlaying ? GetTickCount() - m_dwStartTime : 0; }
// IsPlaying returns TRUE if a movie has been opened but has not ended or been destroyed.
BOOL IsPlaying() const { return m_bPlaying; }
BOOL IsFailed() const { return m_bError; }
// Call TerminatePlayback on the decoder. It may take a few hundred ms before the movie stops.
// This function is thread safe, as long as you ensure that you don't call Destroy() in another
// thread simultaneously.
void TerminatePlayback();
HRESULT Play( DWORD Flags, RECT* pRect );
// Call this to enable overlays if you will be playing the movie in an overlay using
// AdvanceFrame. The overlays will be disabled when Destroy() is called.
void EnableOverlays( LPDIRECT3DDEVICE8 pDevice );
private:
XMVDecoder* m_pXMVDecoder; // Pointer to the XMV decoder object.
XMVVIDEO_DESC m_VideoDesc; // Description of the .xmv files video data.
XMVAUDIO_DESC m_AudioDesc; // Description of the .xmv files audio data.
LPDIRECT3DTEXTURE8 m_pTextures[XMVPLAYER_NUMTEXTURES]; // Textures to cycle through.
DWORD m_nDecodeTextureIndex; // Index of the current texture to decode to.
// These texture pointers are copies of the values in m_pTextures. They are used to track
// the decode/display/pending status.
// When displaying using textures pShowingTexture points to the texture to display,
// pDecodingTexture points to the texture to decode into, and pSubmittedTexture is always
// zero.
// When displaying using overlays pShowingTexture points to the texture that the hardware
// is currently displaying, pDecodingTexture points to the texture to decode into, and
// pSubmittedTexture is a surface that has been submitted to the overlay system, but not
// necessarily displayed yet. At any given time one of these is always zero. When
// pDecodingTexture is zero that means that pShowingTexture might be being displayed, or
// the hardware might have switched to pSubmittedTexture, we don't know yet.
LPDIRECT3DTEXTURE8 pShowingTexture;
LPDIRECT3DTEXTURE8 pDecodingTexture;
LPDIRECT3DTEXTURE8 pSubmittedTexture;
int m_dwCurrentFrame; // Current frame number - minus one if not yet started.
DWORD m_dwStartTime;
BOOL m_bPlaying; // Is a movie currently playing?
BOOL m_bOverlaysEnabled; // Are overlays enabled? For disabling them on destroy.
LPDIRECT3DDEVICE8 m_pDevice; // For use by Destroy to disable overlays.
BOOL m_bError;
LOAD_CONTEXT m_loadContext; // Data for communicating with packet callback functions.
BYTE* m_physicalBuffer; // Pointer to block of physical memory used for loading packets.
// Helper function for opening files.
HRESULT FinishOpeningFile( D3DFORMAT Format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures );
// Copy constructor and assignment operator are private and unimplemented
// to prevent unintentional, unsupported, and disastrous copying.
CXMVPlayer( const CXMVPlayer& source );
CXMVPlayer& operator=( const CXMVPlayer& source );
};
#endif //#ifndef _XMVPLAYER_H_