You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
635 lines
18 KiB
635 lines
18 KiB
#include "stdafx.h"
|
|
#include "mswebdvd.h"
|
|
#include "msdvd.h"
|
|
#include "ddrawobj.h"
|
|
//
|
|
// CDDrawDVD constructor
|
|
//
|
|
CDDrawDVD::CDDrawDVD(CMSWebDVD *pDVD)
|
|
{
|
|
m_pDVD = pDVD;
|
|
|
|
// Default colors to be used for filling
|
|
m_VideoKeyColor = RGB(255, 0, 255) ;
|
|
|
|
m_pOverlayCallback = new CComObject<COverlayCallback> ;
|
|
|
|
CComVariant vData;
|
|
vData.vt = VT_VOID;
|
|
vData.byref = this;
|
|
if(m_pOverlayCallback){
|
|
m_pOverlayCallback->SetDDrawDVD(vData);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// CDDrawDVD destructor
|
|
//
|
|
CDDrawDVD::~CDDrawDVD(void)
|
|
{
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetupDDraw */
|
|
/* Description: Creates DDrawObject and Surface */
|
|
/*************************************************************************/
|
|
HRESULT CDDrawDVD::SetupDDraw(const AMDDRAWGUID* lpDDGUID, HWND hwnd){
|
|
|
|
// DO NOT CALL TWICE !!!
|
|
// WILL CRASH OV MIXER DJ
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
if(!::IsWindow(hwnd)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_pDDObject.Release();
|
|
hr = ::DirectDrawCreate(lpDDGUID->lpGUID, &m_pDDObject, NULL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = m_pDDObject->SetCooperativeLevel(hwnd, DDSCL_NORMAL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
m_pDDObject.Release();
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
DDSURFACEDESC ddsd;
|
|
::ZeroMemory(&ddsd, sizeof(ddsd));
|
|
ddsd.dwSize = sizeof(ddsd);
|
|
|
|
ddsd.dwFlags = DDSD_CAPS;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
|
|
|
|
m_pPrimary.Release();
|
|
hr = m_pDDObject->CreateSurface(&ddsd, &m_pPrimary, NULL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
m_pDDObject.Release();
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IDirectDrawClipper> pClipper;
|
|
|
|
hr = m_pDDObject->CreateClipper(0, &pClipper, NULL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
m_pPrimary.Release();
|
|
m_pDDObject.Release();
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pClipper->SetHWnd(0, hwnd);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
m_pPrimary.Release();
|
|
m_pDDObject.Release();
|
|
pClipper.Release();
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
|
|
hr = m_pPrimary->SetClipper(pClipper);
|
|
|
|
if (FAILED(hr)){
|
|
|
|
m_pPrimary.Release();
|
|
m_pDDObject.Release();
|
|
pClipper.Release();
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
/*
|
|
* We release the clipper interface after attaching it to the surface
|
|
* as we don't need to use it again and the surface holds a reference
|
|
* to the clipper when its been attached. The clipper will therefore
|
|
* be released when the surface is released.
|
|
*/
|
|
pClipper.Release();
|
|
|
|
return(hr);
|
|
}/* end of function SetupDDraw */
|
|
|
|
/*************************************************************/
|
|
/* Name:
|
|
/* Description:
|
|
/*************************************************************/
|
|
HRESULT CDDrawDVD::SetColorKey(COLORREF colorKey)
|
|
{
|
|
m_VideoKeyColor = colorKey;
|
|
|
|
// if 256 color mode, force to set back to magenta
|
|
HWND hwnd = ::GetDesktopWindow();
|
|
HDC hdc = ::GetWindowDC(hwnd);
|
|
|
|
if(NULL == hdc){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ((::GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) == RC_PALETTE)
|
|
{
|
|
if (m_VideoKeyColor != MAGENTA_COLOR_KEY) {
|
|
hr = m_pDVD->put_ColorKey(MAGENTA_COLOR_KEY);
|
|
if (SUCCEEDED(hr))
|
|
m_VideoKeyColor = MAGENTA_COLOR_KEY;
|
|
}
|
|
}
|
|
|
|
::ReleaseDC(hwnd, hdc);
|
|
return hr ;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name:
|
|
/* Description:
|
|
/*************************************************************/
|
|
COLORREF CDDrawDVD::GetColorKey()
|
|
{
|
|
// if 256 color mode, force to set back to magenta
|
|
HWND hwnd = ::GetDesktopWindow();
|
|
HDC hdc = ::GetWindowDC(hwnd);
|
|
|
|
if(NULL == hdc){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
if ((::GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) == RC_PALETTE)
|
|
{
|
|
if (m_VideoKeyColor != MAGENTA_COLOR_KEY) {
|
|
|
|
if (SUCCEEDED(m_pDVD->put_ColorKey(MAGENTA_COLOR_KEY)))
|
|
m_VideoKeyColor = MAGENTA_COLOR_KEY;
|
|
}
|
|
}
|
|
|
|
::ReleaseDC(hwnd, hdc);
|
|
return m_VideoKeyColor;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* Function: HasOverlay */
|
|
/* Description: Tells us if the video card support overlay. */
|
|
/*************************************************************************/
|
|
HRESULT CDDrawDVD::HasOverlay(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(!m_pDDObject){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
DDCAPS caps;
|
|
|
|
::ZeroMemory(&caps, sizeof(DDCAPS));
|
|
|
|
caps.dwSize = sizeof(DDCAPS);
|
|
|
|
hr = m_pDDObject->GetCaps(&caps, NULL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(caps.dwMaxVisibleOverlays > 0){
|
|
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
|
|
hr = S_FALSE;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function HasOverlay */
|
|
|
|
/*************************************************************************/
|
|
/* Function: HasAvailableOverlay */
|
|
/* Description: Tells us if the overlay is used. */
|
|
/*************************************************************************/
|
|
HRESULT CDDrawDVD::HasAvailableOverlay(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(!m_pDDObject){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
DDCAPS caps;
|
|
|
|
::ZeroMemory(&caps, sizeof(DDCAPS));
|
|
|
|
caps.dwSize = sizeof(DDCAPS);
|
|
|
|
hr = m_pDDObject->GetCaps(&caps, NULL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if((caps.dwMaxVisibleOverlays > 0) && (caps.dwMaxVisibleOverlays > caps.dwCurrVisibleOverlays)){
|
|
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
|
|
hr = S_FALSE;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function HasAvailableOverlay */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetOverlayMaxStretch */
|
|
/* Description: Tells us the maximum stretch factors of overlay. */
|
|
/*************************************************************************/
|
|
HRESULT CDDrawDVD::GetOverlayMaxStretch(DWORD *pdwMaxStretch){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(!m_pDDObject){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
DDCAPS caps;
|
|
|
|
::ZeroMemory(&caps, sizeof(DDCAPS));
|
|
|
|
caps.dwSize = sizeof(DDCAPS);
|
|
|
|
hr = m_pDDObject->GetCaps(&caps, NULL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if (caps.dwCaps & DDCAPS_OVERLAYSTRETCH && caps.dwMaxOverlayStretch!=0) {
|
|
*pdwMaxStretch = caps.dwMaxOverlayStretch/2;
|
|
}
|
|
|
|
else {
|
|
#ifdef _DEBUG
|
|
::MessageBox(::GetFocus(), TEXT("Overlay can't stretch"), TEXT("Error"), MB_OK) ;
|
|
#endif
|
|
}
|
|
|
|
|
|
return(hr);
|
|
}/* end of function GetOverlayMaxStretch */
|
|
|
|
// convert a RGB color to a pysical color.
|
|
// we do this by leting GDI SetPixel() do the color matching
|
|
// then we lock the memory and see what it got mapped to.
|
|
HRESULT CDDrawDVD::DDColorMatchOffscreen(COLORREF rgb, DWORD* dwColor)
|
|
{
|
|
HDC hdc;
|
|
*dwColor = CLR_INVALID;
|
|
DDSURFACEDESC ddsd;
|
|
IDirectDrawSurface* pdds;
|
|
|
|
LPDIRECTDRAW pdd = GetDDrawObj();
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
ZeroMemory(&ddsd, sizeof(ddsd)) ;
|
|
ddsd.dwSize = sizeof(ddsd) ;
|
|
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
|
|
ddsd.dwWidth = 8;
|
|
ddsd.dwHeight = 8;
|
|
hr = pdd->CreateSurface(&ddsd, &pdds, NULL);
|
|
if (hr != DD_OK) {
|
|
return 0;
|
|
}
|
|
|
|
// use GDI SetPixel to color match for us
|
|
if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
|
|
{
|
|
// set our value
|
|
SetPixel(hdc, 0, 0, rgb);
|
|
pdds->ReleaseDC(hdc);
|
|
}
|
|
|
|
// now lock the surface so we can read back the converted color
|
|
ZeroMemory(&ddsd, sizeof(ddsd)) ;
|
|
ddsd.dwSize = sizeof(ddsd) ;
|
|
while ((hr = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
|
|
;
|
|
|
|
if (hr == DD_OK)
|
|
{
|
|
// get DWORD
|
|
DWORD temp = *(DWORD *)ddsd.lpSurface;
|
|
|
|
// mask it to bpp
|
|
if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
|
|
temp &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount)-1;
|
|
|
|
pdds->Unlock(NULL);
|
|
|
|
*dwColor = temp;
|
|
hr = S_OK;
|
|
}
|
|
|
|
pdds->Release();
|
|
return hr;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: CreateDIBBrush
|
|
/* Description:
|
|
/*************************************************************/
|
|
HRESULT CDDrawDVD::CreateDIBBrush(COLORREF rgb, HBRUSH *phBrush)
|
|
{
|
|
#if 1
|
|
|
|
HDC hdc;
|
|
DDSURFACEDESC ddsd;
|
|
IDirectDrawSurface* pdds;
|
|
|
|
LPDIRECTDRAW pdd = GetDDrawObj();
|
|
HRESULT hr = S_OK;
|
|
|
|
ZeroMemory(&ddsd, sizeof(ddsd)) ;
|
|
ddsd.dwSize = sizeof(ddsd) ;
|
|
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
|
|
ddsd.dwWidth = 8;
|
|
ddsd.dwHeight = 8;
|
|
hr = pdd->CreateSurface(&ddsd, &pdds, NULL);
|
|
if (hr != DD_OK) {
|
|
return 0;
|
|
}
|
|
|
|
// use GDI SetPixel to color match for us
|
|
if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
|
|
{
|
|
// set our value
|
|
SetPixel(hdc, 0, 0, rgb);
|
|
pdds->ReleaseDC(hdc);
|
|
}
|
|
|
|
// now lock the surface so we can read back the converted color
|
|
ZeroMemory(&ddsd, sizeof(ddsd)) ;
|
|
ddsd.dwSize = sizeof(ddsd) ;
|
|
while ((hr = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
|
|
;
|
|
|
|
DWORD temp = CLR_INVALID;
|
|
if (hr == DD_OK)
|
|
{
|
|
// get DWORD
|
|
temp = *((DWORD *)ddsd.lpSurface);
|
|
|
|
// mask it to bpp
|
|
if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
|
|
temp &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount)-1;
|
|
|
|
pdds->Unlock(NULL);
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
::ZeroMemory(&ddsd, sizeof(ddsd)) ;
|
|
ddsd.dwSize = sizeof(ddsd) ;
|
|
hr = pdds->GetSurfaceDesc(&ddsd) ;
|
|
if (! (SUCCEEDED(hr) && (ddsd.dwFlags & DDSD_WIDTH) && (ddsd.dwFlags & DDSD_HEIGHT)) ) {
|
|
return hr;
|
|
}
|
|
|
|
if (hr == DD_OK && temp != CLR_INVALID) {
|
|
DDBLTFX ddBltFx;
|
|
::ZeroMemory(&ddBltFx, sizeof(ddBltFx)) ;
|
|
ddBltFx.dwSize = sizeof(DDBLTFX);
|
|
ddBltFx.dwFillColor = temp;
|
|
|
|
RECT rc;
|
|
::SetRect(&rc, 0, 0, ddsd.dwWidth, ddsd.dwHeight);
|
|
|
|
hr = pdds->Blt(&rc, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &ddBltFx);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
DWORD dwBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount;
|
|
DWORD dwWidth = WIDTHBYTES(ddsd.dwWidth*dwBitCount);
|
|
DWORD dwSizeImage = ddsd.dwHeight*dwWidth;
|
|
|
|
BYTE *packedDIB = new BYTE[sizeof(BITMAPINFOHEADER) + dwSizeImage + 1024];
|
|
BITMAPINFOHEADER *lpbmi = (BITMAPINFOHEADER*) packedDIB;
|
|
|
|
::ZeroMemory(lpbmi, sizeof(BITMAPINFOHEADER));
|
|
lpbmi->biSize = sizeof(BITMAPINFOHEADER);
|
|
lpbmi->biBitCount = (WORD)dwBitCount;
|
|
lpbmi->biWidth = ddsd.dwWidth;
|
|
lpbmi->biHeight = ddsd.dwHeight;
|
|
lpbmi->biPlanes = 1;
|
|
|
|
LPDWORD pdw = (LPDWORD)DibColors(lpbmi);
|
|
|
|
switch (dwBitCount) {
|
|
case 8: {
|
|
lpbmi->biCompression = BI_RGB;
|
|
lpbmi->biClrUsed = 256;
|
|
for (int i=0; i<(int)lpbmi->biClrUsed/16; i++)
|
|
{
|
|
*pdw++ = 0x00000000; // 0000 black
|
|
*pdw++ = 0x00800000; // 0001 dark red
|
|
*pdw++ = 0x00008000; // 0010 dark green
|
|
*pdw++ = 0x00808000; // 0011 mustard
|
|
*pdw++ = 0x00000080; // 0100 dark blue
|
|
*pdw++ = 0x00800080; // 0101 purple
|
|
*pdw++ = 0x00008080; // 0110 dark turquoise
|
|
*pdw++ = 0x00C0C0C0; // 1000 gray
|
|
*pdw++ = 0x00808080; // 0111 dark gray
|
|
*pdw++ = 0x00FF0000; // 1001 red
|
|
*pdw++ = 0x0000FF00; // 1010 green
|
|
*pdw++ = 0x00FFFF00; // 1011 yellow
|
|
*pdw++ = 0x000000FF; // 1100 blue
|
|
*pdw++ = 0x00FF00FF; // 1101 pink (magenta)
|
|
*pdw++ = 0x0000FFFF; // 1110 cyan
|
|
*pdw++ = 0x00FFFFFF; // 1111 white
|
|
}
|
|
break;
|
|
}
|
|
case 16:
|
|
lpbmi->biCompression = BI_BITFIELDS;
|
|
lpbmi->biClrUsed = 3;
|
|
pdw[0] = ddsd.ddpfPixelFormat.dwRBitMask ;
|
|
pdw[1] = ddsd.ddpfPixelFormat.dwGBitMask ;
|
|
pdw[2] = ddsd.ddpfPixelFormat.dwBBitMask ;
|
|
break;
|
|
case 24:
|
|
case 32:
|
|
lpbmi->biCompression = BI_RGB;
|
|
lpbmi->biClrUsed = 0;
|
|
break;
|
|
}
|
|
|
|
ZeroMemory(&ddsd, sizeof(ddsd)) ;
|
|
ddsd.dwSize = sizeof(ddsd) ;
|
|
while ((hr = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
|
|
;
|
|
|
|
if (hr != DD_OK)
|
|
return hr;
|
|
|
|
BYTE *lpTempSurf = (BYTE *)ddsd.lpSurface;
|
|
for (DWORD i=0; i<ddsd.dwHeight; i++) {
|
|
::memcpy((BYTE*) DibPtr(lpbmi)+i*dwWidth,
|
|
lpTempSurf+i*ddsd.lPitch, dwWidth);
|
|
}
|
|
pdds->Unlock(NULL);
|
|
|
|
*phBrush = ::CreateDIBPatternBrushPt((LPVOID) packedDIB, DIB_RGB_COLORS);
|
|
}
|
|
|
|
pdds->Release();
|
|
#else
|
|
|
|
HRESULT hr = S_OK;
|
|
typedef struct {
|
|
BYTE rgb[3];
|
|
} RGB;
|
|
|
|
typedef struct {
|
|
BITMAPINFOHEADER bmiHeader;
|
|
RGB pBits[8][8];
|
|
} PackedDIB;
|
|
|
|
PackedDIB packedDIB;
|
|
|
|
::ZeroMemory(&packedDIB, sizeof(PackedDIB));
|
|
packedDIB.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
|
|
packedDIB.bmiHeader.biCompression = BI_RGB;
|
|
packedDIB.bmiHeader.biBitCount = 24;
|
|
packedDIB.bmiHeader.biHeight = 8;
|
|
packedDIB.bmiHeader.biWidth = 8;
|
|
packedDIB.bmiHeader.biPlanes = 1;
|
|
|
|
for (int i=0; i<8; i++) {
|
|
for (int j=0; j<8; j++)
|
|
packedDIB.pBits[i][j] = *((RGB*)&rgb);
|
|
}
|
|
|
|
*phBrush = ::CreateDIBPatternBrushPt((LPVOID)&packedDIB, DIB_RGB_COLORS);
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* COverlayCallback */
|
|
/*************************************************************/
|
|
/* Name: OnUpdateOverlay
|
|
/* Description:
|
|
/*************************************************************/
|
|
HRESULT STDMETHODCALLTYPE COverlayCallback::OnUpdateOverlay(BOOL bBefore,
|
|
DWORD dwFlags,
|
|
BOOL bOldVisible,
|
|
const RECT *prcSrcOld,
|
|
const RECT *prcDestOld,
|
|
BOOL bNewVisible,
|
|
const RECT *prcSrcNew,
|
|
const RECT *prcDestNew)
|
|
{
|
|
if (bBefore)
|
|
return S_OK;
|
|
|
|
if(!prcSrcOld || !prcDestOld || !prcSrcNew || !prcDestNew){
|
|
return E_POINTER;
|
|
}
|
|
CMSWebDVD *pDVD = m_pDDrawDVD->GetDVD();
|
|
ATLASSERT(pDVD);
|
|
|
|
if (m_dwWidth != (DWORD)RECTWIDTH(prcDestNew) ||
|
|
m_dwHeight != (DWORD)RECTHEIGHT(prcDestNew) ||
|
|
m_dwARWidth != (DWORD)RECTWIDTH(prcDestNew) ||
|
|
m_dwARHeight != (DWORD)RECTHEIGHT(prcDestNew)) {
|
|
|
|
m_dwWidth = (DWORD)RECTWIDTH(prcDestNew);
|
|
m_dwHeight = (DWORD)RECTHEIGHT(prcDestNew);
|
|
m_dwARWidth = (DWORD)RECTWIDTH(prcDestNew);
|
|
m_dwARHeight = (DWORD)RECTHEIGHT(prcDestNew);
|
|
|
|
return pDVD->UpdateOverlay();
|
|
} /* end of if statement */
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*************************************************************/
|
|
/* Name: OnUpdateColorKey
|
|
/* Description:
|
|
/*************************************************************/
|
|
HRESULT STDMETHODCALLTYPE COverlayCallback::OnUpdateColorKey(COLORKEY const *pKey, DWORD dwColor)
|
|
{
|
|
m_pDDrawDVD->SetColorKey(pKey->HighColorValue);
|
|
return S_OK ;
|
|
}
|
|
|
|
|
|
/*************************************************************/
|
|
/* Name: OnUpdateSize
|
|
/* Description:
|
|
/*************************************************************/
|
|
HRESULT STDMETHODCALLTYPE COverlayCallback::OnUpdateSize(DWORD dwWidth, DWORD dwHeight,
|
|
DWORD dwARWidth, DWORD dwARHeight)
|
|
{
|
|
CMSWebDVD *pDVD = m_pDDrawDVD->GetDVD();
|
|
ATLASSERT(pDVD);
|
|
|
|
if (m_dwWidth != dwWidth ||
|
|
m_dwHeight != dwHeight ||
|
|
m_dwARWidth != dwARWidth ||
|
|
m_dwARHeight != dwARHeight) {
|
|
|
|
m_dwWidth = dwWidth;
|
|
m_dwHeight = dwHeight;
|
|
m_dwARWidth = dwARWidth;
|
|
m_dwARHeight = dwARHeight;
|
|
|
|
return pDVD->UpdateOverlay();
|
|
} /* end of if statement */
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: SetDDrawDVD
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP COverlayCallback::SetDDrawDVD(VARIANT pDDrawDVD)
|
|
{
|
|
switch(pDDrawDVD.vt){
|
|
|
|
case VT_VOID: {
|
|
m_pDDrawDVD = static_cast<CDDrawDVD*> (pDDrawDVD.byref);
|
|
break;
|
|
}
|
|
|
|
} /* end of switch statement */
|
|
|
|
return S_OK;
|
|
}
|
|
|