able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/ui/conf/vidview.cpp

1630 lines
33 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// File: videview.cpp
#include "precomp.h"
#include "vidview.h"
#include "resource.h"
#include "confman.h"
#include "rtoolbar.h"
#include "pfndrawd.h"
#include "NmManager.h"
#include "cmd.h"
#define DibHdrSize(lpbi) ((lpbi)->biSize + (int)(lpbi)->biClrUsed * sizeof(RGBQUAD))
#define DibDataSize(lpbi) ((lpbi)->biSizeImage)
#define DibSize(lpbi) (DibHdrSize(lpbi) + DibDataSize(lpbi))
typedef struct
{
DWORD *pdwCapDevIDs;
LPTSTR pszCapDevNames;
DWORD dwNumCapDev;
} ENUM_CAP_DEV;
CSimpleArray<CVideoWindow *> *CVideoWindow::g_pVideos;
BOOL CVideoWindow::g_fMirror = FALSE;
BOOL CVideoWindow::g_bLocalOneTimeInited = FALSE;
static const TCHAR REGVAL_VIDEO_QUALITY[] = TEXT("ImageQuality");
static const UINT VIDEO_ZOOM_MIN = 50;
static const UINT VIDEO_ZOOM_MAX = 400;
static const UINT QCIF_WIDTH = 176;
static const UINT QCIF_HEIGHT = 144;
CVideoWindow::CVideoWindow(VideoType eType, BOOL bEmbedded) :
m_dwFrameSize(NM_VIDEO_MEDIUM),
m_hdd(NULL),
#ifdef DISPLAYFPS
m_cFrame (0),
m_dwTick (GetTickCount()),
#endif // DISPLAYFPS
m_pActiveChannel(NULL),
m_dwCookie(0),
m_dwImageQuality(NM_VIDEO_MIN_QUALITY),
m_pNotify(NULL),
m_fLocal(REMOTE!=eType),
m_hBitmapMirror(NULL),
m_hDCMirror(NULL),
m_fZoomable(TRUE),
m_bEmbedded(bEmbedded),
m_hGDIObj(NULL)
{
if (NULL == g_pVideos)
{
g_pVideos = new CSimpleArray<CVideoWindow*>;
}
if (NULL != g_pVideos)
{
CVideoWindow* p = static_cast<CVideoWindow*>(this);
g_pVideos->Add(p);
}
m_sizeVideo.cx = 0;
m_sizeVideo.cy = 0;
RegEntry reAudio(AUDIO_KEY); // HKCU
RegEntry reVideo( IsLocal() ? VIDEO_LOCAL_KEY : VIDEO_REMOTE_KEY,
HKEY_CURRENT_USER );
DWORD dwFrameSizeDefault = FRAME_QCIF;
DWORD dwImageQualityDefault = NM_VIDEO_DEFAULT_QUALITY;
int nVideoWidthDefault = VIDEO_WIDTH_QCIF;
int nVideoHeightDefault = VIDEO_HEIGHT_QCIF;
UINT uBandWidth = reAudio.GetNumber(REGVAL_TYPICALBANDWIDTH, BW_DEFAULT);
if (uBandWidth == BW_144KBS)
{
dwImageQualityDefault = NM_VIDEO_MIN_QUALITY;
}
m_dwFrameSize = reVideo.GetNumber(
REGVAL_VIDEO_FRAME_SIZE, dwFrameSizeDefault );
if (!IsLocal())
{
m_dwImageQuality = reVideo.GetNumber(
REGVAL_VIDEO_QUALITY, dwImageQualityDefault );
}
m_nXferOnConnect =
IsLocal() ? VIDEO_SEND_CONNECT_DEFAULT :
VIDEO_RECEIVE_CONNECT_DEFAULT;
m_nXferOnConnect = reVideo.GetNumber(
REGVAL_VIDEO_XFER_CONNECT,
m_nXferOnConnect);
m_zoom = 100;
}
VOID CVideoWindow::OnNCDestroy()
{
// remote channel will get released upon the NM_CHANNEL_REMOVED
// notification. The preview channel needs to be released here,
// and not in the destructor because of a circular ref count
if (NULL != m_pActiveChannel)
{
NmUnadvise(m_pActiveChannel, IID_INmChannelVideoNotify, m_dwCookie);
m_dwCookie = 0;
m_pActiveChannel->Release();
m_pActiveChannel = NULL;
}
if (NULL != m_pNotify)
{
m_pNotify->Release();
m_pNotify = NULL;
}
}
CVideoWindow::~CVideoWindow()
{
CVideoWindow* p = static_cast<CVideoWindow*>(this);
g_pVideos->Remove(p);
if (0 == g_pVideos->GetSize())
{
delete g_pVideos;
g_pVideos = NULL;
}
if (NULL != m_hdd)
{
DRAWDIB::DrawDibClose(m_hdd);
}
// BUGBUG PhilF: Does DrawDibClose() nuke the selected palette?
// release resources related to mirror preview
UnInitMirroring();
}
BOOL CVideoWindow::Create(HWND hwndParent, HPALETTE hpal, IVideoChange *pNotify)
{
if (FAILED(DRAWDIB::Init()))
{
return(FALSE);
}
if (!CGenWindow::Create(
hwndParent,
0,
IsLocal() ? TEXT("NMLocalVideo") : TEXT("NMRemoteVideo"),
WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
WS_EX_CLIENTEDGE))
{
return(FALSE);
}
SetWindowPos(GetWindow(), NULL, 0, 0, m_sizeVideo.cx, m_sizeVideo.cy,
SWP_NOZORDER|SWP_NOACTIVATE);
// We do NOT own this palette
m_hPal = hpal;
m_hdd = DRAWDIB::DrawDibOpen();
if (NULL != m_hdd)
{
// Use the Indeo palette in 8 bit mode only if the decompressed
// video data is H.261 or H.263. We will create this palette as
// an identity palette.
// PhilF: If the user is utilizing an installable codec, do we still want to do this?
// Update the palette in the DrawDib surface
if (NULL != hpal)
{
DRAWDIB::DrawDibSetPalette(m_hdd, hpal);
}
}
if (NULL != pNotify)
{
m_pNotify = pNotify;
m_pNotify->AddRef();
}
if (IsLocal())
{
// need to get PreviewChannel;
INmManager2 *pManager = CConfMan::GetNmManager();
ASSERT (NULL != pManager);
pManager->GetPreviewChannel(&m_pActiveChannel);
pManager->Release();
if (m_pActiveChannel)
{
NmAdvise(m_pActiveChannel, static_cast<INmChannelVideoNotify*>(this),
IID_INmChannelVideoNotify, &m_dwCookie);
DWORD_PTR dwFrameSize = GetFrameSize();
if (g_bLocalOneTimeInited)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_IMAGE_PREFERRED_SIZE, &dwFrameSize);
}
else
{
DWORD dwSizes = GetFrameSizes();
// if frame size is not valid
if (!(m_dwFrameSize & dwSizes))
{
// find an alternate size
if (FRAME_QCIF & dwSizes)
{
dwFrameSize = FRAME_QCIF;
}
else if (FRAME_SQCIF & dwSizes)
{
dwFrameSize = FRAME_SQCIF;
}
else if (FRAME_CIF & dwSizes)
{
dwFrameSize = FRAME_CIF;
}
}
RegEntry reVideo( IsLocal() ? VIDEO_LOCAL_KEY : VIDEO_REMOTE_KEY,
HKEY_CURRENT_USER );
SetMirror(reVideo.GetNumber(REGVAL_VIDEO_MIRROR, TRUE));
g_bLocalOneTimeInited = TRUE;
}
SetFrameSize((DWORD)dwFrameSize);
}
}
ResizeWindowsToFrameSize();
return TRUE;
}
DWORD CVideoWindow::GetFrameSizes()
{
DWORD_PTR dwSizes = 0;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_IMAGE_SIZES, &dwSizes);
}
return (DWORD)dwSizes;
}
VOID CVideoWindow::SetFrameSize(DWORD dwSize)
{
DWORD dwPrevSize = m_dwFrameSize;
m_dwFrameSize = dwSize;
if (IsLocal())
{
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->SetProperty(NM_VIDPROP_IMAGE_PREFERRED_SIZE, dwSize);
}
}
if (dwPrevSize != dwSize)
{
if ((NULL == m_pActiveChannel) ||
(!IsLocal() && (S_OK != m_pActiveChannel->IsActive())) ||
(IsLocal() && IsPaused()))
{
ResizeWindowsToFrameSize();
}
}
}
VOID CVideoWindow::ResizeWindowsToFrameSize()
{
SIZE size;
switch(m_dwFrameSize)
{
case FRAME_SQCIF:
size.cx = VIDEO_WIDTH_SQCIF;
size.cy = VIDEO_HEIGHT_SQCIF;
break;
case FRAME_CIF:
if (IsLocal())
{
size.cx = VIDEO_WIDTH_CIF;
size.cy = VIDEO_HEIGHT_CIF;
break;
}
// else fall through to QCIF
case FRAME_QCIF:
default:
size.cx = VIDEO_WIDTH_QCIF;
size.cy = VIDEO_HEIGHT_QCIF;
break;
}
SetVideoSize(&size);
}
STDMETHODIMP CVideoWindow::QueryInterface(REFIID riid, PVOID *ppv)
{
HRESULT hr = S_OK;
if ((riid == IID_INmChannelVideoNotify) || (riid == IID_IUnknown))
{
*ppv = static_cast<INmChannelVideoNotify *>(this);
DbgMsgApi("CVideoWindow::QueryInterface()");
}
else
{
hr = E_NOINTERFACE;
*ppv = NULL;
DbgMsgApi("CVideoWindow::QueryInterface(): Called on unknown interface.");
}
if (S_OK == hr)
{
AddRef();
}
return hr;
}
STDMETHODIMP CVideoWindow::NmUI(CONFN uNotify)
{
return S_OK;
}
STDMETHODIMP CVideoWindow::MemberChanged(NM_MEMBER_NOTIFY uNotify, INmMember *pMember)
{
return S_OK;
}
STDMETHODIMP CVideoWindow::StateChanged(NM_VIDEO_STATE uState)
{
InvalidateRect(GetWindow(), NULL, TRUE);
if (NULL != m_pNotify)
{
m_pNotify->StateChange(this, uState);
}
CNmManagerObj::VideoChannelStateChanged(uState, !m_fLocal);
return S_OK;
}
STDMETHODIMP CVideoWindow::PropertyChanged(DWORD dwReserved)
{
if (NM_VIDPROP_FRAME == dwReserved)
{
OnFrameAvailable();
}
return S_OK;
}
HRESULT CVideoWindow::OnChannelChanged(NM_CHANNEL_NOTIFY uNotify, INmChannel *pChannel)
{
INmChannelVideo* pChannelVideo;
if (SUCCEEDED(pChannel->QueryInterface(IID_INmChannelVideo, (void**)&pChannelVideo)))
{
BOOL bIncoming = (S_OK == pChannelVideo->IsIncoming());
if ((bIncoming && !IsLocal()) || (!bIncoming && IsLocal()))
{
switch (uNotify)
{
case NM_CHANNEL_ADDED:
if (NULL == m_pActiveChannel)
{
pChannelVideo->AddRef();
m_pActiveChannel = pChannelVideo;
NmAdvise(m_pActiveChannel,static_cast<INmChannelVideoNotify*>(this),
IID_INmChannelVideoNotify, &m_dwCookie);
SetImageQuality(m_dwImageQuality);
}
if (!_Module.InitControlMode())
{
switch(m_nXferOnConnect)
{
case VIDEO_XFER_START:
if (IsPaused())
{
Pause(FALSE);
}
break;
case VIDEO_XFER_STOP:
Pause(TRUE);
break;
default:
if (!IsLocal())
{
Pause(TRUE);
}
break;
}
}
break;
case NM_CHANNEL_REMOVED:
if (!IsLocal() && (pChannel == m_pActiveChannel))
{
NmUnadvise(m_pActiveChannel, IID_INmChannelVideoNotify, m_dwCookie);
m_pActiveChannel->Release();
m_pActiveChannel = NULL;
m_dwCookie = 0;
ResizeWindowsToFrameSize();
}
}
// just in case we missed a notification
// (in final version this should not be the case)
// m_VideoWindow.OnStateChange();
}
pChannelVideo->Release();
}
return S_OK;
}
HRESULT CVideoWindow::SetImageQuality(DWORD dwQuality)
{
HRESULT hr = E_FAIL;
m_dwImageQuality = dwQuality;
if (NULL != m_pActiveChannel)
{
hr = m_pActiveChannel->SetProperty(NM_VIDPROP_IMAGE_QUALITY, dwQuality);
CNmManagerObj::VideoPropChanged(NM_VIDPROP_IMAGE_QUALITY, !IsLocal());
}
return hr;
}
HRESULT CVideoWindow::SetCameraDialog(ULONG ul)
{
if(IsLocal())
{
return m_pActiveChannel->SetProperty(NM_VIDPROP_CAMERA_DIALOG, ul);
CNmManagerObj::VideoPropChanged(NM_VIDPROP_CAMERA_DIALOG, IsLocal());
}
return E_FAIL;
}
HRESULT CVideoWindow::GetCameraDialog(ULONG* pul)
{
HRESULT hr;
DWORD_PTR dwPropVal;
if(IsLocal())
{
hr = m_pActiveChannel->GetProperty(NM_VIDPROP_CAMERA_DIALOG, &dwPropVal);
*pul = (ULONG)dwPropVal;
return hr;
}
return E_FAIL;
}
BOOL CVideoWindow::IsXferAllowed()
{
if (IsLocal())
{
return FIsSendVideoAllowed() && (NULL != m_pActiveChannel);
}
else
{
return FIsReceiveVideoAllowed();
}
}
BOOL CVideoWindow::IsAutoXferEnabled()
{
return(VIDEO_XFER_START == m_nXferOnConnect);
}
BOOL CVideoWindow::IsXferEnabled()
{
if (NULL != m_pActiveChannel)
{
NM_VIDEO_STATE state;
if (SUCCEEDED(m_pActiveChannel->GetState(&state)))
{
switch (state)
{
case NM_VIDEO_PREVIEWING:
case NM_VIDEO_TRANSFERRING:
case NM_VIDEO_REMOTE_PAUSED:
return TRUE;
case NM_VIDEO_IDLE:
case NM_VIDEO_LOCAL_PAUSED:
case NM_VIDEO_BOTH_PAUSED:
default:
return FALSE;
}
}
}
return FALSE;
}
HRESULT CVideoWindow::GetVideoState(NM_VIDEO_STATE* puState)
{
if(m_pActiveChannel)
{
return m_pActiveChannel->GetState(puState);
}
return E_FAIL;
}
VOID CVideoWindow::Pause(BOOL fPause)
{
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->SetProperty(NM_VIDPROP_PAUSE, (ULONG)fPause);
CNmManagerObj::VideoPropChanged(NM_VIDPROP_PAUSE, !IsLocal());
}
}
BOOL CVideoWindow::IsPaused()
{
if (NULL != m_pActiveChannel)
{
ULONG_PTR uPause;
if (SUCCEEDED(m_pActiveChannel->GetProperty(NM_VIDPROP_PAUSE, &uPause)))
{
return (BOOL)uPause;
}
}
return TRUE;
}
BOOL CVideoWindow::IsConnected()
{
if (NULL != m_pActiveChannel)
{
NM_VIDEO_STATE state;
if (SUCCEEDED(m_pActiveChannel->GetState(&state)))
{
switch (state)
{
case NM_VIDEO_LOCAL_PAUSED:
case NM_VIDEO_TRANSFERRING:
case NM_VIDEO_BOTH_PAUSED:
case NM_VIDEO_REMOTE_PAUSED:
return TRUE;
case NM_VIDEO_IDLE:
case NM_VIDEO_PREVIEWING:
default:
return FALSE;
}
}
}
return FALSE;
}
DWORD CVideoWindow::GetNumCapDev()
{
DWORD_PTR dwNumDevs = 0;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_NUM_CAPTURE_DEVS, &dwNumDevs);
}
return (DWORD)dwNumDevs;
}
DWORD CVideoWindow::GetMaxCapDevNameLen()
{
DWORD_PTR dwLen = 0;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_MAX_CAPTURE_NAME, &dwLen);
}
return (DWORD)dwLen;
}
DWORD CVideoWindow::GetCurrCapDevID()
{
DWORD_PTR dwID = 0;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_CAPTURE_DEV_ID, &dwID);
}
return (DWORD)dwID;
}
VOID CVideoWindow::SetCurrCapDevID(DWORD dwID)
{
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->SetProperty(NM_VIDPROP_CAPTURE_DEV_ID, dwID);
InvalidateRect(GetWindow(), NULL, TRUE);
}
}
VOID CVideoWindow::EnableAutoXfer(BOOL fEnable)
{
m_nXferOnConnect = fEnable ? VIDEO_XFER_START : VIDEO_XFER_NOP;
RegEntry reXfer( IsLocal() ? VIDEO_LOCAL_KEY : VIDEO_REMOTE_KEY,
HKEY_CURRENT_USER );
reXfer.SetValue ( REGVAL_VIDEO_XFER_CONNECT, m_nXferOnConnect);
}
VOID CVideoWindow::EnumCapDev(DWORD *pdwCapDevIDs, LPTSTR pszCapDevNames, DWORD dwNumCapDev)
{
ENUM_CAP_DEV enumCapDev;
enumCapDev.pdwCapDevIDs = pdwCapDevIDs;
enumCapDev.pszCapDevNames = pszCapDevNames;
enumCapDev.dwNumCapDev = dwNumCapDev;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_CAPTURE_LIST, (DWORD_PTR *)&enumCapDev);
}
}
VOID CVideoWindow::GetDesiredSize(SIZE *ppt)
{
ppt->cx = m_sizeVideo.cx*m_zoom/100;
ppt->cy = m_sizeVideo.cy*m_zoom/100;
if (m_bEmbedded)
{
ppt->cx = min(ppt->cx, QCIF_WIDTH);
ppt->cy = min(ppt->cy, QCIF_HEIGHT);
}
SIZE sGen;
CGenWindow::GetDesiredSize(&sGen);
ppt->cx += sGen.cx;
ppt->cy += sGen.cy;
}
VOID CVideoWindow::SetVideoSize(LPSIZE lpsize)
{
m_sizeVideo = *lpsize;
OnDesiredSizeChanged();
}
#ifdef DEBUG
DWORD g_fDisplayFPS = FALSE;
#ifdef DISPLAYFPS
VOID CVideoWindow::UpdateFps(void)
{
DWORD dwTick = GetTickCount();
m_cFrame++;
// Update display every 4 seconds
if ((dwTick - m_dwTick) < 4000)
return;
TCHAR sz[32];
wsprintf(sz, "%d FPS", m_cFrame / 4);
SetWindowText(m_hwndParent, sz);
m_cFrame = 0;
m_dwTick = dwTick;
}
#endif /* DISPLAYFPS */
#endif // DEBUG
VOID CVideoWindow::OnFrameAvailable(void)
{
::InvalidateRect(GetWindow(), NULL, FALSE);
#ifdef DISPLAYFPS
if (g_fDisplayFPS)
{
UpdateFps();
}
#endif // DISPLAYFPS
}
VOID CVideoWindow::PaintDib(HDC hdc, FRAMECONTEXT *pFrame)
{
RECT rcVideo;
GetClientRect(GetWindow(), &rcVideo);
HPALETTE hpOld = NULL;
if (NULL != m_hPal)
{
hpOld = SelectPalette(hdc, m_hPal, FALSE);
RealizePalette(hdc);
}
// create the bitmap object, only if it doesn't exist
// and if the mirror bitmap object isn't the right size
if (!ShouldMirror() || !InitMirroring(rcVideo))
{
// ISSUE: (ChrisPi 2-19-97) should we use DDF_SAME_HDC?
DRAWDIB::DrawDibDraw(m_hdd,hdc,
rcVideo.left,
rcVideo.top,
RectWidth(rcVideo),
RectHeight(rcVideo),
&pFrame->lpbmi->bmiHeader,
pFrame->lpData,
pFrame->lpClipRect->left,
pFrame->lpClipRect->top,
RectWidth(pFrame->lpClipRect),
RectHeight(pFrame->lpClipRect),
0);
}
else
{
if (NULL != m_hPal)
{
SelectPalette(m_hDCMirror, m_hPal, FALSE);
RealizePalette(m_hDCMirror);
}
DRAWDIB::DrawDibDraw(m_hdd,
m_hDCMirror,
0,
0,
RectWidth(rcVideo),
RectHeight(rcVideo),
&pFrame->lpbmi->bmiHeader,
pFrame->lpData,
pFrame->lpClipRect->left,
pFrame->lpClipRect->top,
RectWidth(pFrame->lpClipRect),
RectHeight(pFrame->lpClipRect),
0);
::StretchBlt(hdc,
rcVideo.right,
rcVideo.top,
-RectWidth(rcVideo),
RectHeight(rcVideo),
m_hDCMirror,
0,
0,
RectWidth(rcVideo),
RectHeight(rcVideo),
SRCCOPY);
// HACKHACK georgep; don't worry about deselecting the palette in
// the temp DC
}
if (NULL != hpOld)
{
SelectPalette(hdc, hpOld, FALSE);
}
}
/* P A I N T L O G O */
/*-------------------------------------------------------------------------
%%Function: PaintLogo
Display the 256 color NetMeeting logo in the video window.
-------------------------------------------------------------------------*/
VOID CVideoWindow::PaintLogo(HDC hdc, UINT idbLargeLogo, UINT idbSmallLogo)
{
RECT rcVideo;
GetClientRect(GetWindow(), &rcVideo);
::FillRect(hdc, &rcVideo, (HBRUSH)::GetStockObject(WHITE_BRUSH));
// Create the memory DC
HDC hdcMem = ::CreateCompatibleDC(hdc);
if (NULL == hdcMem)
{
ERROR_OUT(("PaintLogo: Unable to CreateCompatibleDC"));
return;
}
// Load the bitmap (LoadBitmap doesn't work for 256 color images)
HANDLE hBitmap = LoadImage(::GetInstanceHandle(),
MAKEINTRESOURCE(idbLargeLogo), IMAGE_BITMAP, 0, 0,
LR_CREATEDIBSECTION);
if (NULL != hBitmap)
{
BITMAP bitmap;
::GetObject(hBitmap, sizeof(bitmap), &bitmap);
int cx = bitmap.bmWidth;
int cy = bitmap.bmHeight;
if (RectWidth(rcVideo) < cx || RectHeight(rcVideo) < cy)
{
HANDLE hNew = LoadImage(::GetInstanceHandle(),
MAKEINTRESOURCE(idbSmallLogo), IMAGE_BITMAP, 0, 0,
LR_CREATEDIBSECTION);
if (NULL != hNew)
{
DeleteObject(hBitmap);
hBitmap = hNew;
::GetObject(hBitmap, sizeof(bitmap), &bitmap);
cx = bitmap.bmWidth;
cy = bitmap.bmHeight;
}
}
HBITMAP hBmpTmp = (HBITMAP)::SelectObject(hdcMem, hBitmap);
// Select and realize the palette
HPALETTE hPalette = m_hPal;
if (NULL != hPalette)
{
SelectPalette(hdcMem, hPalette, FALSE);
RealizePalette(hdcMem);
SelectPalette(hdc, hPalette, FALSE);
RealizePalette(hdc);
}
int x = rcVideo.left + (RectWidth(rcVideo) - cx) / 2;
int y = rcVideo.top + (RectHeight(rcVideo) - cy) / 2;
::BitBlt(hdc, x, y, cx, cy, hdcMem, 0, 0, SRCCOPY);
::SelectObject(hdcMem, hBmpTmp);
::DeleteObject(hBitmap);
}
::DeleteDC(hdcMem);
}
VOID CVideoWindow::OnPaint()
{
PAINTSTRUCT ps;
HDC hdc;
hdc = ::BeginPaint(GetWindow(), &ps);
if( hdc )
{
if( RectWidth(ps.rcPaint) && RectHeight(ps.rcPaint) )
{
// This means that we have a non-zero surface area ( there may be something to paint )
DBGENTRY(CVideoWindow::ProcessPaint);
// paint the video rect
FRAMECONTEXT fc;
if ((S_OK == GetFrame(&fc)))
{
if (!IsPaused())
{
SIZE vidSize =
{
RectWidth(fc.lpClipRect),
RectHeight(fc.lpClipRect)
} ;
if ((vidSize.cx != m_sizeVideo.cx) || (vidSize.cy != m_sizeVideo.cy))
{
// save the new image size
SetVideoSize(&vidSize);
}
}
PaintDib(hdc, &fc);
ReleaseFrame(&fc);
}
else
{
PaintLogo(hdc, IDB_VIDEO_LOGO, IDB_VIDEO_LOGO_SMALL);
}
// check to see if needs painting outside the video rect
#if FALSE
// Currently just stretching the video to the window size
if (ps.rcPaint.left < m_rcVideo.left ||
ps.rcPaint.top < m_rcVideo.top ||
ps.rcPaint.right > m_rcVideo.right ||
ps.rcPaint.bottom > m_rcVideo.bottom)
{
HFONT hfOld;
int nBkModeOld;
RECT rc, rcClient;
::GetClientRect(GetWindow(), &rcClient);
// erase the background if requested
if (ps.fErase)
{
::ExcludeClipRect(hdc,
m_rcVideo.left,
m_rcVideo.top,
m_rcVideo.right,
m_rcVideo.bottom);
::FillRect(hdc, &rcClient, ::GetSysColorBrush(COLOR_BTNFACE));
}
nBkModeOld = ::SetBkMode(hdc, TRANSPARENT);
hfOld = (HFONT)::SelectObject(hdc, g_hfontDlg);
// paint the status text
// first erase the old text if not already done
if (!ps.fErase)
{
::FillRect(hdc, &m_rcStatusText, ::GetSysColorBrush(COLOR_BTNFACE));
}
TCHAR szState[MAX_PATH];
if (GetState(szState, CCHMAX(szState)))
{
COLORREF crOld;
crOld = ::SetTextColor(hdc, ::GetSysColor(COLOR_BTNTEXT));
rc = m_rcStatusText;
rc.left += STATUS_MARGIN;
::DrawText(hdc,
szState,
-1,
&rc,
DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
::SetTextColor(hdc, crOld);
}
// paint border around video
rc = m_rcVideo;
::InflateRect(&rc,
::GetSystemMetrics(SM_CXEDGE),
::GetSystemMetrics(SM_CYEDGE));
::DrawEdge(hdc, &rc, EDGE_SUNKEN , BF_RECT);
// restore DC stuff
::SelectObject(hdc, hfOld);
::SetBkMode(hdc, nBkModeOld);
}
#endif // FALSE
DBGEXIT(CVideoWindow::ProcessPaint);
}
::EndPaint(GetWindow(), &ps);
}
}
VOID CVideoWindow::SetZoom(UINT zoom)
{
if (m_zoom == zoom)
{
return;
}
m_zoom = zoom;
OnDesiredSizeChanged();
}
void CVideoWindow::OnCommand(int idCmd)
{
switch (idCmd)
{
case IDM_VIDEO_GETACAMERA:
CmdLaunchWebPage(idCmd);
break;
case IDM_VIDEO_COPY:
CopyToClipboard();
break;
case IDM_VIDEO_FREEZE:
Pause(!IsPaused());
break;
case IDM_VIDEO_UNDOCK:
CMainUI::NewVideoWindow(GetConfRoom());
break;
case IDM_VIDEO_ZOOM1:
SetZoom(100);
break;
case IDM_VIDEO_ZOOM2:
SetZoom(200);
break;
case IDM_VIDEO_ZOOM3:
SetZoom(300);
break;
case IDM_VIDEO_ZOOM4:
SetZoom(400);
break;
case IDM_VIDEO_PROPERTIES:
LaunchConfCpl(GetWindow(), OPTIONS_VIDEO_PAGE);
break;
}
}
void CVideoWindow::UpdateVideoMenu(HMENU hMenu)
{
EnableMenuItem(hMenu, IDM_VIDEO_COPY, MF_BYCOMMAND|(CanCopy() ? MF_ENABLED : MF_GRAYED|MF_DISABLED));
EnableMenuItem(hMenu, IDM_VIDEO_UNDOCK, MF_BYCOMMAND|(IsLocal() ? MF_ENABLED : MF_GRAYED|MF_DISABLED));
if (!FIsSendVideoAllowed() && !FIsReceiveVideoAllowed())
{
EnableMenuItem(hMenu, IDM_VIDEO_FREEZE, MF_BYCOMMAND | MF_GRAYED | MF_DISABLED);
EnableMenuItem(hMenu, IDM_VIDEO_PROPERTIES, MF_BYCOMMAND | MF_GRAYED | MF_DISABLED);
EnableMenuItem(hMenu, IDM_VIDEO_GETACAMERA, MF_BYCOMMAND | MF_GRAYED | MF_DISABLED);
}
else
{
CheckMenuItem(hMenu, IDM_VIDEO_FREEZE, MF_BYCOMMAND|(IsPaused() ? MF_CHECKED : MF_UNCHECKED));
UINT uEnable = ::CanShellExecHttp() ? MF_ENABLED : MF_GRAYED;
::EnableMenuItem(hMenu, IDM_VIDEO_GETACAMERA, uEnable);
}
int nZoom = GetZoom();
int idZoom;
if (350 < nZoom) idZoom = IDM_VIDEO_ZOOM4;
else if (250 < nZoom) idZoom = IDM_VIDEO_ZOOM3;
else if (150 < nZoom) idZoom = IDM_VIDEO_ZOOM2;
else idZoom = IDM_VIDEO_ZOOM1;
UINT uFlags = IsZoomable() && !m_bEmbedded
? MF_ENABLED : MF_GRAYED|MF_DISABLED;
for (int id=IDM_VIDEO_ZOOM1; id<=IDM_VIDEO_ZOOM4; ++id)
{
EnableMenuItem(hMenu, id, MF_BYCOMMAND|uFlags);
CheckMenuItem(hMenu, id, MF_BYCOMMAND|MF_UNCHECKED);
}
CheckMenuItem(hMenu, idZoom, MF_BYCOMMAND|MF_CHECKED);
uFlags = CanLaunchConfCpl()
? MF_ENABLED : MF_GRAYED|MF_DISABLED;
EnableMenuItem(hMenu, IDM_VIDEO_PROPERTIES, MF_BYCOMMAND|uFlags);
}
void CVideoWindow::OnContextMenu(HWND hwnd, HWND hwndContext, UINT xPos, UINT yPos)
{
HMENU hmLoad = LoadMenu(_Module.GetModuleInstance(), MAKEINTRESOURCE(IDR_VIDEO_POPUP));
if (NULL != hmLoad)
{
HMENU hmPopup = GetSubMenu(hmLoad, 0);
ASSERT(NULL != hmPopup);
UpdateVideoMenu(hmPopup);
int idCmd = TrackPopupMenu(hmPopup, TPM_RETURNCMD|TPM_RIGHTBUTTON,
xPos, yPos, 0, hwnd, NULL);
if (0 != idCmd)
{
OnCommand(idCmd);
}
DestroyMenu(hmLoad);
}
}
LRESULT CVideoWindow::ProcessMessage(HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
switch (message)
{
HANDLE_MSG(hwnd, WM_CONTEXTMENU, OnContextMenu);
case WM_ERASEBKGND:
return 0;
case WM_PAINT:
OnPaint();
return 0;
case WM_NCDESTROY:
OnNCDestroy();
return 0;
case WM_SIZE:
// Need to redraw the whole window
InvalidateRect(GetWindow(), NULL, FALSE);
break;
default:
break;
}
return CGenWindow::ProcessMessage(hwnd, message, wParam, lParam) ;
}
#if FALSE
int CVideoWindow::GetState(LPTSTR lpszState, int nStateMax)
{
int uStringID;
NM_VIDEO_STATE state = NM_VIDEO_IDLE;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetState(&state);
}
if (IsLocal())
{
switch (state)
{
case NM_VIDEO_PREVIEWING:
uStringID = IDS_VIDEO_STATE_PREVIEWING;
break;
case NM_VIDEO_TRANSFERRING:
uStringID = IDS_VIDEO_STATE_SENDING;
break;
case NM_VIDEO_REMOTE_PAUSED:
uStringID = IDS_VIDEO_STATE_REMOTEPAUSED;
break;
case NM_VIDEO_LOCAL_PAUSED:
case NM_VIDEO_BOTH_PAUSED:
uStringID = IDS_VIDEO_STATE_PAUSED;
break;
case NM_VIDEO_IDLE:
default:
uStringID = IDS_VIDEO_STATE_NOTSENDING;
break;
}
}
else
{
switch (state)
{
case NM_VIDEO_TRANSFERRING:
uStringID = IDS_VIDEO_STATE_RECEIVING;
break;
case NM_VIDEO_REMOTE_PAUSED:
uStringID = IDS_VIDEO_STATE_REMOTEPAUSED;
break;
case NM_VIDEO_LOCAL_PAUSED:
case NM_VIDEO_BOTH_PAUSED:
uStringID = IDS_VIDEO_STATE_PAUSED;
break;
case NM_VIDEO_IDLE:
case NM_VIDEO_PREVIEWING:
default:
uStringID = IDS_VIDEO_STATE_NOTRECEIVING;
break;
}
}
return ::LoadString(
::GetInstanceHandle(),
uStringID,
lpszState,
nStateMax);
}
#endif // FALSE
// Return value will be TRUE if Windows can handle the format
static BOOL IsKnownDIBFormat(BITMAPINFOHEADER *pbmih)
{
if (sizeof(BITMAPINFOHEADER) != pbmih->biSize)
{
return(FALSE);
}
if (1 != pbmih->biPlanes)
{
return(FALSE);
}
int bits = pbmih->biBitCount;
int comp = pbmih->biCompression;
switch (bits)
{
case 1:
if (BI_RGB == comp)
{
return(TRUE);
}
break;
case 4:
if (BI_RGB == comp || BI_RLE4 == comp)
{
return(TRUE);
}
break;
case 8:
if (BI_RGB == comp || BI_RLE8 == comp)
{
return(TRUE);
}
break;
case 16:
if (BI_RGB == comp || BI_BITFIELDS == comp)
{
return(TRUE);
}
break;
case 24:
case 32:
if (BI_RGB == comp)
{
return(TRUE);
}
break;
default:
break;
}
return(FALSE);
}
#ifdef TryPaintDIB
BOOL CVideoWindow::CopyToClipboard()
{
FRAMECONTEXT fc;
BOOL fSuccess = FALSE;
// Get the current frame and open the clipboard
if (S_OK == GetFrame(&fc))
{
HWND hwnd = GetWindow();
if (OpenClipboard(hwnd))
{
// Allocate memory that we will be giving to the clipboard
BITMAPINFOHEADER *pbmih = &fc.lpbmi->bmiHeader;
BOOL bCopy = IsKnownDIBFormat(pbmih);
// BUGBUG georgep; I think this doesn't work for 15 or 16 bit DIBs
int nColors = pbmih->biClrUsed;
if (0 == nColors && pbmih->biBitCount <= 8)
{
nColors = 1 << pbmih->biBitCount;
}
// Special case for 16-bit bitfield bitmaps
if (16 == pbmih->biBitCount && BI_BITFIELDS == pbmih->biCompression)
{
nColors = 3;
}
int nHdrSize = pbmih->biSize + nColors * sizeof(RGBQUAD);
int bitsPer = pbmih->biBitCount;
if (!bCopy)
{
bitsPer *= pbmih->biPlanes;
if (bitsPer > 24)
{
bitsPer = 32;
}
// LAZYLAZY georgep: Skipping 16-bit format
else if (bitsPer > 8)
{
bitsPer = 24;
}
else if (bitsPer > 4)
{
bitsPer = 8;
}
else if (bitsPer > 1)
{
bitsPer = 4;
}
else
{
bitsPer = 1;
}
}
int nDataSize = bCopy ? pbmih->biSizeImage : 0;
if (0 == nDataSize)
{
// Make an uncompressed DIB
int nByteWidth = (pbmih->biWidth*bitsPer+7) / 8;
nDataSize = ((nByteWidth + 3)&~3) * pbmih->biHeight;
}
// Allocate the total memory for the DIB
HGLOBAL hCopy = GlobalAlloc(GHND, nHdrSize + nDataSize);
if (NULL != hCopy)
{
BITMAPINFO *lpvCopy = reinterpret_cast<BITMAPINFO*>(GlobalLock(hCopy));
CopyMemory(lpvCopy, pbmih, nHdrSize);
// Create a temporary DC for drawing into
HDC hdc = GetDC(hwnd);
if (NULL != hdc)
{
HDC hdcTemp = CreateCompatibleDC(hdc);
ReleaseDC(hwnd, hdc);
hdc = hdcTemp;
}
if (NULL != hdc)
{
if (bCopy)
{
if (ShouldMirror())
{
// Create a DIB section for drawing into
LPVOID pData;
HBITMAP hDIB = CreateDIBSection(hdc, lpvCopy, DIB_RGB_COLORS, &pData, NULL, 0);
if (NULL != hDIB)
{
// Draw into the DIB, and then copy the bits
HGDIOBJ hOld = SelectObject(hdc, hDIB);
RECT rc = { 0, 0, pbmih->biWidth, pbmih->biHeight };
StretchDIBits(hdc, 0, 0, pbmih->biWidth, pbmih->biHeight,
pbmih->biWidth, 0, -pbmih->biWidth, pbmih->biHeight,
fc.lpData, lpvCopy, DIB_RGB_COLORS, SRCCOPY);
CopyMemory(&lpvCopy->bmiColors[nColors], pData, nDataSize);
// Start cleaning up
SelectObject(hdc, hOld);
DeleteObject(hDIB);
}
}
else
{
CopyMemory(&lpvCopy->bmiColors[nColors], fc.lpData, nDataSize);
}
fSuccess = TRUE;
}
else
{
lpvCopy->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
lpvCopy->bmiHeader.biPlanes = 1;
lpvCopy->bmiHeader.biBitCount = bitsPer;
lpvCopy->bmiHeader.biCompression = BI_RGB;
lpvCopy->bmiHeader.biSizeImage = nDataSize;
// Create a DIB section for drawing into
LPVOID pData;
HBITMAP hDIB = CreateDIBSection(hdc, lpvCopy, DIB_RGB_COLORS, &pData, NULL, 0);
if (NULL != hDIB)
{
// Draw into the DIB, and then copy the bits
HGDIOBJ hOld = SelectObject(hdc, hDIB);
RECT rc = { 0, 0, pbmih->biWidth, pbmih->biHeight };
PaintDib(hdc, &fc, &rc);
CopyMemory(&lpvCopy->bmiColors[nColors], pData, nDataSize);
// Start cleaning up
SelectObject(hdc, hOld);
DeleteObject(hDIB);
fSuccess = TRUE;
}
}
DeleteDC(hdc);
}
GlobalUnlock(hCopy);
if (fSuccess)
{
// Set the DIB into the clipboard
EmptyClipboard();
fSuccess = (NULL != SetClipboardData(CF_DIB, (HANDLE)hCopy));
}
if (!fSuccess)
{
GlobalFree(hCopy);
}
}
CloseClipboard();
}
ReleaseFrame(&fc);
}
return fSuccess;
}
#else // TryPaintDIB
BOOL CVideoWindow::CopyToClipboard()
{
FRAMECONTEXT fc;
BOOL fSuccess = FALSE;
if (S_OK == GetFrame(&fc))
{
if (OpenClipboard(GetWindow()))
{
EmptyClipboard();
{
HGLOBAL hCopy;
BITMAPINFOHEADER *pbmih;
pbmih = &fc.lpbmi->bmiHeader;
hCopy = GlobalAlloc(GHND, DibSize(pbmih));
if (NULL != hCopy)
{
LPVOID lpvCopy = GlobalLock(hCopy);
int nHdrSize = DibHdrSize(pbmih);
CopyMemory(lpvCopy, pbmih, nHdrSize);
CopyMemory((LPBYTE)lpvCopy + nHdrSize, fc.lpData, DibDataSize(pbmih));
GlobalUnlock(hCopy);
fSuccess = (NULL != SetClipboardData(CF_DIB, (HANDLE)hCopy));
if (!fSuccess)
{
GlobalFree(hCopy);
}
}
}
CloseClipboard();
}
ReleaseFrame(&fc);
}
return fSuccess;
}
#endif // TryPaintDIB
HRESULT CVideoWindow::GetFrame(FRAMECONTEXT *pFrameContext)
{
HRESULT hr = E_FAIL;
if (NULL != m_pActiveChannel)
{
hr = m_pActiveChannel->GetProperty(NM_VIDPROP_FRAME, (DWORD_PTR *)pFrameContext);
}
return hr;
}
HRESULT CVideoWindow::ReleaseFrame(FRAMECONTEXT *pFrameContext)
{
HRESULT hr = E_FAIL;
if (NULL != m_pActiveChannel)
{
hr = m_pActiveChannel->SetProperty(NM_VIDPROP_FRAME, (DWORD_PTR)pFrameContext);
}
return hr;
}
void CVideoWindow::SaveSettings()
{
RegEntry re( IsLocal() ? VIDEO_LOCAL_KEY : VIDEO_REMOTE_KEY,
HKEY_CURRENT_USER );
re.SetValue(REGVAL_VIDEO_FRAME_SIZE, m_dwFrameSize);
if (!IsLocal())
{
re.SetValue(REGVAL_VIDEO_QUALITY, m_dwImageQuality);
}
else
{
re.SetValue(REGVAL_VIDEO_MIRROR, GetMirror());
}
}
VOID CVideoWindow::ForwardSysChangeMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_PALETTECHANGED:
OnPaletteChanged();
break;
}
}
VOID CVideoWindow::OnPaletteChanged(void)
{
::RedrawWindow(GetWindow(), NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
}
BOOL CVideoWindow::HasDialog(DWORD dwDialog)
{
DWORD_PTR dwDialogs = 0;
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->GetProperty(NM_VIDPROP_CAMERA_DIALOG, &dwDialogs);
}
return (BOOL)(dwDialogs & dwDialog);
}
VOID CVideoWindow::ShowDialog(DWORD dwDialog)
{
if (NULL != m_pActiveChannel)
{
m_pActiveChannel->SetProperty(NM_VIDPROP_CAMERA_DIALOG, dwDialog);
}
}
BOOL CVideoWindow::InitMirroring(RECT &rcVideo)
{
HDC hdcWindow;
if ((m_hBitmapMirror != NULL) &&
(RectWidth(rcVideo) == m_sizeBitmapMirror.cx) &&
(RectHeight(rcVideo) == m_sizeBitmapMirror.cy))
{
return TRUE;
}
hdcWindow = ::GetDC(NULL);
UnInitMirroring();
m_hBitmapMirror = ::CreateCompatibleBitmap(hdcWindow, RectWidth(rcVideo), RectHeight(rcVideo));
if (m_hBitmapMirror == NULL)
{
ReleaseDC(NULL, hdcWindow);
return FALSE;
}
m_hDCMirror = ::CreateCompatibleDC(hdcWindow);
if (m_hDCMirror == NULL)
{
UnInitMirroring();
ReleaseDC(NULL, hdcWindow);
return FALSE;
}
// preserve the handle of the object being replaced
m_hGDIObj = ::SelectObject(m_hDCMirror, m_hBitmapMirror);
::SetMapMode(m_hDCMirror, GetMapMode(hdcWindow));
m_sizeBitmapMirror.cx = RectWidth(rcVideo);
m_sizeBitmapMirror.cy = RectHeight(rcVideo);
ReleaseDC(NULL, hdcWindow);
return TRUE;
}
VOID CVideoWindow::UnInitMirroring()
{
if (m_hBitmapMirror)
{
if (m_hDCMirror)
{
::SelectObject(m_hDCMirror, m_hGDIObj);
}
::DeleteObject(m_hBitmapMirror);
m_hBitmapMirror = NULL;
}
if (m_hDCMirror)
{
::DeleteObject(m_hDCMirror);
m_hDCMirror = NULL;
}
}
VOID CVideoWindow::InvalidateAll()
{
for(int i = g_pVideos->GetSize()-1; i >= 0 ; --i)
{
CVideoWindow *pVideo = (*g_pVideos)[i];
HWND hwnd = pVideo->GetWindow();
if (NULL != hwnd)
{
InvalidateRect(hwnd, NULL, FALSE);
}
}
}
VOID CVideoWindow::SetMirror(BOOL bMirror)
{
bMirror = bMirror != FALSE;
if (g_fMirror != bMirror)
{
g_fMirror = bMirror;
InvalidateAll();
}
}
BOOL CVideoWindow::CanCopy()
{
BOOL bCopy = (IsXferEnabled() && IsLocal()) || IsConnected();
if (bCopy)
{
bCopy = FALSE;
FRAMECONTEXT fc;
if (S_OK == GetFrame(&fc))
{
BITMAPINFOHEADER *pbmih = &fc.lpbmi->bmiHeader;
bCopy = IsKnownDIBFormat(pbmih);
ReleaseFrame(&fc);
}
}
return(bCopy);
}
BOOL CVideoWindow::FDidNotDisplayIntelLogo()
{
return FALSE;
}
VOID CVideoWindow::DisplayIntelLogo( BOOL bDisplay )
{
}
Reference in a new issue Copy permalink