Initial community commit

1 files changed, 1040 insertions, 0 deletions

diff --git a/Src/Winamp/VideoOutput.cpp b/Src/Winamp/VideoOutput.cpp
new file mode 100644
index 00000000..9dac1c52
--- /dev/null
+++ b/Src/Winamp/VideoOutput.cpp
@@ -0,0 +1,1040 @@
+#include <windowsx.h>
+
+#include "main.h"
+#include "VideoOutput.h"
+#include "VideoOutputChild.h"
+#include "vid_none.h"
+#include "vid_ddraw.h"
+#include "vid_overlay.h"
+#include "vid_d3d.h"
+#include <cassert>
+#include "directdraw.h"
+#include "video.h"
+#include "api.h"
+#include "WinampAttributes.h"
+#include "resource.h"
+#include "../nu/AutoWide.h"
+#include "stats.h"
+#include "IVideoD3DOSD.h"
+
+extern "C" int is_fullscreen_video;
+#define WM_VIDEO_UPDATE_STATUS_TEXT WM_USER+0x874
+#define WM_VIDEO_OPEN WM_USER+0x875
+#define WM_VIDEO_CLOSE WM_USER+0x876
+#define WM_VIDEO_RESIZE WM_USER+0x877
+#define WM_VIDEO_OSDCHANGE WM_USER+0x888
+#define WM_VIDEO_CREATE WM_USER+0x900
+int g_bitmap_id = IDB_VIDEOLOGO;
+int VideoOutput::class_refcnt = 0;
+wchar_t vidoutbuf_save[1024] = {0};
+
+static bool input_plugin_thread_safe = false;
+
+//#define USE_GDIPLUS_VIDEO_RENDERER
+
+IVideoOSD *posd = new IVideoD3DOSD;
+
+HRESULT(WINAPI *_DirectDrawCreate)(GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter) = 0;
+
+void OpenDirectDraw()
+{
+	static int a = 0;
+	if (!_DirectDrawCreate && !a)
+	{
+		a++;
+		HINSTANCE h = LoadLibraryW(L"ddraw.dll");
+		if (h)
+		{
+			*(void**)&_DirectDrawCreate = (void*)GetProcAddress(h, "DirectDrawCreate");
+		}
+	}
+}
+
+HMENU BuildPopupMenu()
+{
+	HMENU menu = GetSubMenu(GetSubMenu(top_menu, 3), 13);
+	{
+		static int menuset = 0;
+		if (!menuset)
+		{
+			InsertMenu(menu, (UINT)-1, MF_BYPOSITION | MF_SEPARATOR, 0, 0);
+			InsertMenuA(menu, (UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)GetSubMenu(top_menu, 0), "Winamp");
+			menuset = 1;
+		}
+	}
+	updateTrackSubmenu();
+	return menu;
+}
+
+void VideoOutput::mainthread_Create()
+{
+	if (!video_created)
+	{
+		m_video_output = new Direct3DVideoOutput(video_hwnd, this);
+		video_created=true;
+	}
+}
+
+VideoOutput::VideoOutput(HWND parent_hwnd, int initxpos, int initypos)
+		: m_logo(0),
+		m_logo_w(0),
+		m_logo_h(0),
+		userVideo(false)
+{
+	video_palette = 0;
+	video_created = false;
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::VideoOutput"));
+	WNDCLASSW wc = {0, };
+
+	wc.style = CS_DBLCLKS;
+	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+	wc.lpfnWndProc = WndProc;
+	wc.hInstance = GetModuleHandle(NULL);
+	wc.lpszClassName = L"WinampVideoChild";
+	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+	if (!class_refcnt) RegisterClassW(&wc);
+	class_refcnt++;
+
+	m_tracksel = NULL;
+	fs_reparented_rgn = 0;
+	fs_reparented = 0;
+	m_ignore_change = false;
+	fs_has_resized = false;
+	m_opened = 0;
+
+	last_fullscreen_exit_time = 0;
+
+	curSubtitle = NULL;
+	m_statusmsg = 0;
+	m_bufferstate = -1;
+	m_msgcallback = 0;
+	m_msgcallback_tok = 0;
+	video_hwnd = 0;
+
+	aspect = 1.0;
+	m_need_change = false;
+
+	is_fs = 0;
+	memset(&oldfsrect, 0, sizeof(oldfsrect));
+	memset(&lastfsrect, 0, sizeof(lastfsrect));
+
+	m_video_output = NULL;
+	resetSubtitle();
+	m_lastbufinvalid = NULL;
+
+	CreateWindowExW(0, wc.lpszClassName, L"WinampVideoChildWindow",
+					parent_hwnd ? WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS :
+								  (WS_OVERLAPPEDWINDOW & (~WS_MAXIMIZEBOX)),
+	               0, 0, 1, 1,
+	               parent_hwnd, NULL, wc.hInstance, (void*)this);
+	posd->SetParent(video_hwnd);
+}
+
+VideoOutput::~VideoOutput()
+{
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::~VideoOutput"));
+	free(m_statusmsg);
+	posd->Hide();
+	if (m_video_output) m_video_output->close();
+	m_video_output = 0;
+	DestroyWindow(video_hwnd);
+	if (m_logo)
+		DeleteObject(m_logo);
+	m_logo = 0;
+	if (posd)
+	{
+		delete posd;
+		posd = NULL;
+	}
+}
+
+void VideoOutput::LoadLogo()
+{
+	static wchar_t logo_tmp[MAX_PATH];
+	if(!logo_tmp[0]) StringCchPrintfW(logo_tmp,MAX_PATH,L"%s\\videologo.bmp",CONFIGDIR);
+	if(PathFileExistsW(logo_tmp)) m_logo = (HBITMAP)LoadImageW(0,logo_tmp,IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
+
+	if(!m_logo) m_logo = (HBITMAP)LoadImage(hMainInstance, MAKEINTRESOURCE(g_bitmap_id), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
+	BITMAP bm;
+	GetObject(m_logo, sizeof(BITMAP), &bm);
+	m_logo_w = bm.bmWidth;
+	m_logo_h = bm.bmHeight;
+	if (m_logo_h < 0)
+		m_logo_h = -m_logo_h;
+}
+
+void VideoOutput::UpdateText(const wchar_t *videoInfo)
+{
+	{
+		//AutoLock lock(textGuard);
+		StringCchCopyW(vidoutbuf_save, 1023, (wchar_t*)videoInfo); // 1023 so that we can guarantee that this will be null terminated even in the middle of a strcpy
+	}
+	PostMessageW(hVideoWindow, WM_VIDEO_UPDATE_STATUS_TEXT, (WPARAM)vidoutbuf_save, 0);
+	PostMessageW(hMainWindow, WM_WA_IPC, IPC_CB_MISC_VIDEOINFO, IPC_CB_MISC);
+}
+
+INT_PTR VideoOutput::extended(INT_PTR param1, INT_PTR param2, INT_PTR param3)
+{
+	switch (param1) // nonlocking commands
+	{
+		case VIDUSER_GET_VIDEOHWND:
+			return (INT_PTR)video_hwnd;
+
+		case VIDUSER_SET_INFOSTRING:
+			if (param2)
+				UpdateText(AutoWide((const char *)param2));
+			return 0;
+
+		case VIDUSER_SET_INFOSTRINGW:
+			if (param2)
+				UpdateText((const wchar_t *)param2);
+			return 0;
+	}
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::extended"));
+	switch (param1)
+	{
+		case VIDUSER_SET_PALETTE:
+		{
+			RGBQUAD *palette = (RGBQUAD *)param2;
+			if (m_video_output) 
+				m_video_output->setPalette(palette);
+			else
+				video_palette = palette;
+			return 0;
+		}
+
+		case VIDUSER_SET_VFLIP:
+		{
+			if (m_video_output)
+				m_video_output->setVFlip(param2);
+			return 0;
+		}
+
+		case VIDUSER_SET_TRACKSELINTERFACE:
+			m_tracksel = (ITrackSelector *)param2;
+			return 0;
+
+		case VIDUSER_OPENVIDEORENDERER:
+		{/*
+			userVideo = true;
+			m_video_output = (VideoRenderer *)param2;
+			VideoOpenStruct *openStruct = (VideoOpenStruct *)param3;
+			int x = openUser(openStruct->w, openStruct->h, openStruct->vflip, openStruct->aspectratio, openStruct->fmt);
+			if (x)
+			{
+				m_video_output = 0;
+				userVideo = false;
+				return 0;
+			}
+			else*/
+				return 1;
+		}
+		case VIDUSER_CLOSEVIDEORENDERER:
+			close();
+			userVideo = false;
+			return 1;
+
+		case VIDUSER_GETPOPUPMENU:
+			return (INT_PTR)BuildPopupMenu();
+
+		case VIDUSER_SET_THREAD_SAFE:
+			input_plugin_thread_safe = !!param2;
+			break;
+	}
+	return 0;
+}
+
+int VideoOutput::get_latency()
+{
+	return config_video_vsync2 ? 15 : 0;
+}
+
+void VideoOutput::adjustAspect(RECT &rd)
+{
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::adjustAspect"));
+
+	if (posd->Showing() /*&& config_video_osd*/)
+	{
+		rd.top += posd->GetBarHeight();
+		rd.bottom -= posd->GetBarHeight();
+	}
+
+	if (config_video_aspectadj)
+	{
+		int outh = rd.bottom - rd.top;
+		int outw = rd.right - rd.left;
+
+		double outputaspect = aspect;
+
+		if (config_video_useratio && config_video_ratio1 && config_video_ratio2)
+		{
+			RECT r;
+			getViewport(&r, hVideoWindow, 1, NULL);
+			int screenx = r.right - r.left;
+			int screeny = r.bottom - r.top;
+
+			if (screenx && screeny)
+			{
+				outputaspect *= config_video_ratio1 * screeny / ((double)screenx * (double)config_video_ratio2);
+			}
+		}
+
+		int newh = (int)((outputaspect * height * outw) / (double)width);
+		int neww = (int)((width * outh) / (height * outputaspect));
+
+		if (outh > newh) // black bars on top and bottom
+		{
+			int d = outh - newh;
+			rd.top += d / 2;
+			rd.bottom -= d - d / 2;
+		}
+		else if (outw > neww) // black bars on left and right
+		{
+			int d = outw - neww;
+			rd.left += d / 2;
+			rd.right -= d - d / 2;
+		}
+	}
+}
+
+LRESULT CALLBACK VideoOutput::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+
+	if (uMsg == g_scrollMsg) // can't check against variables in case statements
+	{
+		wParam <<= 16;
+		uMsg = WM_MOUSEWHEEL;
+	}
+
+	if (FALSE != IsDirectMouseWheelMessage(uMsg))
+	{
+		SendMessageW(hwnd, WM_MOUSEWHEEL, wParam, lParam);
+		return TRUE;
+	}
+
+	switch (uMsg)
+	{
+		case WM_MOUSEWHEEL:
+			return SendMessageW(hMainWindow, uMsg, wParam, lParam);
+
+		case WM_CREATE:
+		{
+			VideoOutput *vid = (VideoOutput *)((CREATESTRUCT *)lParam)->lpCreateParams;
+			vid->video_hwnd = hwnd;
+			SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)vid);
+		}
+		return 0;
+		default:                                          /// pass it on to the other window procedure
+			VideoOutput *_This = (VideoOutput*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+			if (_This)
+				return _This->WindowProc(hwnd, uMsg, wParam, lParam);
+			else
+				return DefWindowProc(hwnd, uMsg, wParam, lParam);
+	}
+}
+
+void VideoOutput::notifyBufferState(int bufferstate) /* 0-255*/
+{	
+	m_bufferstate = bufferstate;
+	if (bufferstate == -1 || bufferstate == 255 || (GetTickCount() - m_lastbufinvalid > 500)) // don't want to do this too often
+	{
+		AutoLock autoLock(guard LOCKNAME("VideoOutput::notifyBufferState"));
+		if (!m_video_output || !m_video_output->onPaint(video_hwnd))
+			InvalidateRect(video_hwnd, 0, TRUE);
+		m_lastbufinvalid = GetTickCount();
+	}
+}
+
+void VideoOutput::DrawLogo(HDC out, RECT *canvas_size)
+{
+	int bufferState = m_bufferstate;
+	if (m_logo && config_video_logo)
+	{
+		HDC dc = CreateCompatibleDC(NULL);
+		SelectObject(dc, m_logo);
+		int xp = (canvas_size->right - canvas_size->left - m_logo_w) / 2;
+		int yp = (canvas_size->bottom - canvas_size->top - m_logo_h) / 2;
+		BitBlt(out, xp, yp, m_logo_w, m_logo_h, dc, 0, 0, SRCCOPY);
+
+		if (bufferState != -1)
+		{
+			if (bufferState < 16) bufferState = 16;
+
+			HGDIOBJ oldobj1 = SelectObject(out, CreateSolidBrush(RGB(0, 0, 0)));
+			HGDIOBJ oldobj2 = SelectObject(out, CreatePen(PS_SOLID, 0, RGB(0, 0, 0)));
+			Rectangle(out, canvas_size->left, canvas_size->top, canvas_size->right, yp);
+			if (m_statusmsg)
+				Rectangle(out, canvas_size->left, yp + m_logo_h, canvas_size->right, canvas_size->bottom);
+			else
+			{
+				Rectangle(out, canvas_size->left, yp + m_logo_h + 2 + 9, canvas_size->right, canvas_size->bottom);
+				Rectangle(out, xp + ((bufferState *(m_logo_w + 2)) >> 8), yp + m_logo_h + 2, canvas_size->right, yp + 9 + m_logo_h + 2);
+			}
+			Rectangle(out, canvas_size->left, yp, xp - 1, yp + m_logo_h + 9 + 2);
+			Rectangle(out, xp + m_logo_w + 1, yp, canvas_size->right, yp + m_logo_h + 2);
+			DeleteObject(SelectObject(out, oldobj2));
+			DeleteObject(SelectObject(out, oldobj1));
+		}
+
+		if (m_statusmsg)
+		{
+			RECT subr = {0, yp + m_logo_h + 2, canvas_size->right, canvas_size->bottom};
+			SetTextColor(out, RGB(255, 255, 255));
+			SetBkMode(out, TRANSPARENT);
+			DrawTextA(out, m_statusmsg, -1, &subr, DT_TOP | DT_CENTER | DT_NOCLIP | DT_NOPREFIX);
+		}
+		else
+		{
+			yp += m_logo_h + 2;
+			if (bufferState)
+			{
+				HGDIOBJ oldobj1 = SelectObject(out, CreateSolidBrush(RGB(128, 128, 128)));
+				HGDIOBJ oldobj2 = SelectObject(out, CreatePen(PS_SOLID, 0, RGB(255, 255, 255)));
+				Rectangle(out, xp - 1, yp, xp + ((bufferState *(m_logo_w + 2)) >> 8), yp + 9);
+				DeleteObject(SelectObject(out, oldobj2));
+				DeleteObject(SelectObject(out, oldobj1));
+			}
+		}
+		DeleteDC(dc);
+	}
+}
+
+void VideoOutput::PaintLogo(int bufferState)
+{
+	// TODO: ask renderer to draw this shiz
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::PaintLogo"));
+
+	PAINTSTRUCT p;
+	BeginPaint(video_hwnd, &p);
+	RECT r;
+	GetClientRect(video_hwnd, &r);
+	HDC out = p.hdc;
+
+	HRGN hrgn = CreateRectRgnIndirect(&r);
+	HBRUSH b = (HBRUSH)GetStockObject(BLACK_BRUSH);
+	FillRgn(out, hrgn, b);
+	DeleteObject(b);
+	DeleteObject(hrgn);
+
+	DrawLogo(out, &r);
+
+	EndPaint(video_hwnd, &p);
+}
+
+// the big window procedure
+LRESULT VideoOutput::WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	// the follow messages are handled w/o a lock
+	switch (uMsg)
+	{
+		case WM_USER + 0x1:
+			m_need_change = true;
+			break;
+
+		case WM_USER + 0x2:
+			m_ignore_change = !!lParam;
+			break;
+
+		case WM_ERASEBKGND:
+			return 1;
+
+		case WM_COMMAND:
+			switch (LOWORD(wParam))
+			{
+				case ID_VIDEOWND_VIDEOOPTIONS:
+					prefs_last_page = 24;
+					prefs_dialog(1);
+					break;
+
+				case ID_VID_AUDIO0:
+				case ID_VID_AUDIO1:
+				case ID_VID_AUDIO2:
+				case ID_VID_AUDIO3:
+				case ID_VID_AUDIO4:
+				case ID_VID_AUDIO5:
+				case ID_VID_AUDIO6:
+				case ID_VID_AUDIO7:
+				case ID_VID_AUDIO8:
+				case ID_VID_AUDIO9:
+				case ID_VID_AUDIO10:
+				case ID_VID_AUDIO11:
+				case ID_VID_AUDIO12:
+				case ID_VID_AUDIO13:
+				case ID_VID_AUDIO14:
+				case ID_VID_AUDIO15:
+				{
+					VideoOutput *out = (VideoOutput *)video_getIVideoOutput();
+					if (!out)
+						break;
+					
+					out->getTrackSelector()->setAudioTrack(LOWORD(wParam) - ID_VID_AUDIO0);
+					break;
+				}
+				case ID_VID_VIDEO0:
+				case ID_VID_VIDEO1:
+				case ID_VID_VIDEO2:
+				case ID_VID_VIDEO3:
+				case ID_VID_VIDEO4:
+				case ID_VID_VIDEO5:
+				case ID_VID_VIDEO6:
+				case ID_VID_VIDEO7:
+				case ID_VID_VIDEO8:
+				case ID_VID_VIDEO9:
+				case ID_VID_VIDEO10:
+				case ID_VID_VIDEO11:
+				case ID_VID_VIDEO12:
+				case ID_VID_VIDEO13:
+				case ID_VID_VIDEO14:
+				case ID_VID_VIDEO15:
+				{
+					VideoOutput *out = (VideoOutput *)video_getIVideoOutput();
+					if (!out) break;
+					out->getTrackSelector()->setVideoTrack(LOWORD(wParam) - ID_VID_VIDEO0);
+					break;
+				}
+			}
+			break;
+		case WM_RBUTTONUP:
+			if (!is_fs)
+			{
+				POINT p;
+				GetCursorPos(&p);
+				DoTrackPopup(BuildPopupMenu(), TPM_RIGHTBUTTON | TPM_LEFTBUTTON, p.x, p.y, hwnd);
+			}
+			break;
+		case WM_LBUTTONDOWN:   // putting this here prevents a deadlock, but allows a race condition over video drawing =(
+		{
+			int x = GET_X_LPARAM(lParam);
+			int y = GET_Y_LPARAM(lParam);
+
+			if (is_fs && config_video_osd)
+			{
+				if (((IVideoD3DOSD *)posd)->isOSDReadyToDraw())
+				{
+					if (posd->MouseDown(x, y, wParam))
+						videoToggleFullscreen();
+				}
+			}
+			else
+			{
+				SetCapture(video_hwnd);
+				clickx = x;
+				clicky = y;
+				SetFocus(video_hwnd);
+			}
+		}
+		break;
+		case WM_MOUSEMOVE:
+		{
+			int x = GET_X_LPARAM(lParam);
+			int y = GET_Y_LPARAM(lParam);
+			if (is_fs && config_video_osd)
+			{
+				if (((IVideoD3DOSD *)posd)->isOSDReadyToDraw())
+				{
+					posd->MouseMove(x, y, wParam);
+				}
+			}
+			else if (GetCapture() == video_hwnd && config_easymove)
+			{
+				POINT p = { x, y};
+				ClientToScreen(hVideoWindow, &p);
+				p.x -= clickx;
+				p.y -= clicky;
+				SendMessageW(hVideoWindow, WM_USER + 0x100, 1, (LPARAM)&p);
+			}
+		}
+		break;
+		case WM_LBUTTONUP:
+		{
+			int x = GET_X_LPARAM(lParam);
+			int y = GET_Y_LPARAM(lParam);
+			if (GetCapture() == video_hwnd)
+				ReleaseCapture();
+			if (is_fs && config_video_osd)
+			{
+				if (((IVideoD3DOSD *)posd)->isOSDReadyToDraw())
+					if (posd->MouseUp(x, y, wParam))
+							videoToggleFullscreen();
+			}
+			SetFocus(hVideoWindow);
+		}
+		break;
+	}
+
+	switch (uMsg)
+	{
+		case WM_VIDEO_OSDCHANGE:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_VIDEO_OSDCHANGE"));
+			if (m_video_output)
+			{
+				m_video_output->Refresh();
+				m_video_output->timerCallback();
+			}
+		}
+		break;
+		case WM_SHOWWINDOW:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_SHOWWINDOW"));
+			if (wParam == TRUE  // being shown
+			    && !m_logo) // logo hasn't been loaded yet
+				LoadLogo();
+		}
+		break;
+		case WM_INITMENUPOPUP:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_INITMENUPOPUP"));
+			return SendMessageW(hMainWindow, uMsg, wParam, lParam); // for popup menus
+		}
+
+		case WM_WINDOWPOSCHANGED:
+		case WM_SIZE:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_SIZE"));
+			if (m_video_output)
+			{
+				m_video_output->OnWindowSize();
+				if (is_fs)
+					if ( ((IVideoD3DOSD *)posd)->isOSDInited() )
+						((IVideoD3DOSD *)posd)->UpdateOSD(hwnd, this);
+			}
+		}
+		break;
+
+		case WM_TIMER:
+		case WM_WINDOWPOSCHANGING:
+		case WM_MOVE:
+		case WM_MOVING:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_TIMER, etc"));
+			if (m_video_output && !m_ignore_change)
+				m_video_output->timerCallback();
+
+			if (uMsg == WM_TIMER)
+				return 0;
+		}
+		break;
+
+		case WM_LBUTTONDBLCLK:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_LBUTTONDBLCLK"));
+			videoToggleFullscreen();
+		}
+		break;
+
+		case WM_PAINT:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_PAINT"));
+			if (m_video_output && m_video_output->onPaint(hwnd))
+				return 0;
+			PaintLogo(m_bufferstate);
+		}
+
+		return 0;
+		break;
+
+		case WM_PRINTCLIENT:
+		{
+			//AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_PAINT"));
+			//if (m_video_output && m_video_output->onPaint(hwnd))
+			//	return 0;
+			RECT r;
+			GetClientRect(video_hwnd, &r);
+			DrawLogo((HDC)wParam, &r);
+		}
+
+		return 0;
+		break;
+
+		case WM_KEYDOWN:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_KEYDOWN"));
+			if (wParam == VK_ESCAPE && is_fs)
+			{
+				videoToggleFullscreen();
+				//remove_fullscreen();
+				return 1;
+			}
+			if (!is_fs)
+			{
+				if (wParam == '3' || LOWORD(wParam) == 192 /* ` */)
+				{
+					SendMessageW(hwnd, WM_COMMAND, ID_VIDEOWND_ZOOM50, 0); return 0;
+				}
+				if (wParam == '1')
+				{
+					SendMessageW(hwnd, WM_COMMAND, ID_VIDEOWND_ZOOM100, 0); return 0;
+				}
+				if (wParam == '2')
+				{
+					SendMessageW(hwnd, WM_COMMAND, ID_VIDEOWND_ZOOM200, 0); return 0;
+				}
+			}
+			if (wParam == ' ')
+			{
+				SendMessageW(hMainWindow, WM_COMMAND, WINAMP_BUTTON3, 0); return 0;
+			}
+			if(wParam == 'F' && (GetAsyncKeyState(VK_SHIFT)&0x8000) && !(GetAsyncKeyState(VK_CONTROL)&0x8000))
+			{
+				SendMessageW(hwnd, WM_COMMAND, ID_VIDEOWND_VERTICALLYFLIP, 0); return 0;
+			}
+		}
+		break;
+
+		case WM_COMMAND:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_COMMAND"));
+			switch (LOWORD(wParam))
+			{
+				case ID_VIDEOWND_VERTICALLYFLIP:
+				{
+					int new_fliprgb = !config_video_fliprgb;//IsDlgButtonChecked(hwndDlg,IDC_PREFS_VIDEO_FLIPRGB)?1:0;
+					config_video_fliprgb = 0;
+					videoSetFlip(new_fliprgb);
+					config_video_fliprgb = new_fliprgb;
+					break;
+				}
+
+				case ID_VIDEOWND_ZOOMFULLSCREEN:
+					videoGoFullscreen();
+					break;
+
+				case ID_VIDEOWND_ZOOM200:
+				case ID_VIDEOWND_ZOOM100:
+				case ID_VIDEOWND_ZOOM50:
+					if (m_video_output)
+						UpdateVideoSize(width, height, aspect, LOWORD(wParam));
+					else
+						UpdateVideoSize(320, 240, 1.0, LOWORD(wParam));
+					break;
+
+				default:
+					SendMessageW(hMainWindow, WM_COMMAND, wParam, lParam);
+					break;
+			}
+		}
+		break;
+
+		case WM_SETCURSOR:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_SETCURSOR"));
+			if (is_fs)
+			{
+				SetCursor(posd->Showing() ? LoadCursor(NULL, IDC_ARROW) : NULL);
+				return TRUE;
+			}
+			else
+				SetCursor(LoadCursor(NULL, IDC_ARROW));
+		}
+		break;
+
+		case WM_SYSCOMMAND:
+		{
+			AutoLock autoLock(guard LOCKNAME("VideoOutput::WM_SYSCOMMAND"));
+			// eat screen saver message when fullscreen
+			if (((wParam & 0xfff0) == SC_SCREENSAVE || (wParam & 0xfff0) == SC_MONITORPOWER) && config_video_noss &&
+			    video_isVideoPlaying())
+			{
+				return -1;
+			}
+		}
+		break;
+	}
+
+	if (m_msgcallback)
+	{
+		return m_msgcallback(m_msgcallback_tok, hwnd, uMsg, wParam, lParam);
+	}
+
+	return (DefWindowProc(hwnd, uMsg, wParam, lParam));
+}
+
+void VideoOutput::fullscreen()
+{
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::fullscreen"));
+	if (!m_video_output || !m_opened)
+		return ;
+
+	if (is_fs)
+		return ;
+
+	// TODO: let the video renderer handle fullscreen itself, if it can.
+
+	/*if (last_fullscreen_exit_time + 250 > GetTickCount()) // gay hack
+	return ; // dont let you go back and forth too quickly	
+	*/
+
+	GetWindowRect(hVideoWindow, &oldfsrect); // save the old coordinates
+	getViewport(&lastfsrect, video_hwnd, 1, NULL);
+	if (GetParent(hVideoWindow))
+	{
+		fs_reparented_rgn = CreateRectRgn(0, 0, 0, 0);
+		GetWindowRgn(hVideoWindow, fs_reparented_rgn);
+
+		fs_reparented = SetParent(hVideoWindow, NULL);
+		SetWindowRgn(hVideoWindow, NULL, FALSE);
+
+		ScreenToClient(fs_reparented, (LPPOINT)&oldfsrect);
+		ScreenToClient(fs_reparented, ((LPPOINT)&oldfsrect) + 1);
+	}
+
+	is_fullscreen_video = true;
+	is_fs = true;
+	//m_video_output->Fullscreen(true);
+	SetWindowPos(hVideoWindow, HWND_TOPMOST, lastfsrect.left, lastfsrect.top, lastfsrect.right - lastfsrect.left, lastfsrect.bottom - lastfsrect.top, SWP_DRAWFRAME | SWP_NOACTIVATE);
+	SetFocus(hVideoWindow);
+
+	resetSubtitle();
+}
+
+extern "C" HWND hExternalVisWindow;
+
+int VideoOutput::openUser(int w, int h, int vflip, double aspectratio, unsigned int fmt)
+{
+// TODO
+	return 1;
+}
+
+int VideoOutput::open(int w, int h, int vflip, double aspectratio, unsigned int fmt)
+{
+	if (!video_created)
+		SendMessageW(hVideoWindow, WM_VIDEO_CREATE, 0, 0);
+
+	if (!h || !w || !fmt) // check this after creating the video window.  some plugins use this call to open the video output early
+		return 0;
+
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::open"));
+	
+	if (!m_need_change)
+		stats.IncrementStat(Stats::VIDEOS_PLAYED);
+
+	if (hExternalVisWindow)
+		PostMessageW(hExternalVisWindow, WM_USER + 1666, 1, 15);
+
+	m_opened = false;
+	userVideo = false;
+	width = w;
+	height = h;
+
+	type = fmt;
+	aspect = aspectratio;
+	if (m_video_output)
+	{
+		if (type == VIDEO_MAKETYPE('N','O','N','E'))
+		{
+			m_opened = true;
+			PostMessageW(hMainWindow, WM_WA_IPC, IPC_CB_MISC_INFO, IPC_CB_MISC);
+			OpenVideoSize(width, height, aspect);
+			fs_has_resized = is_fs;
+			return 0;
+		}
+		else if (m_video_output->OpenVideo(w, h, type, vflip, aspect))
+		{
+			if (video_palette)
+				m_video_output->setPalette(video_palette);
+			video_palette = 0;
+			DoTheVistaVideoDance();
+			InvalidateRect(video_hwnd, NULL, TRUE);
+			m_opened = true;
+			PostMessageW(hMainWindow, WM_WA_IPC, IPC_CB_MISC_INFO, IPC_CB_MISC);
+			if (!m_need_change) //don't update size when renegotiating video output
+			{
+				OpenVideoSize(width, height, aspect);
+				fs_has_resized = is_fs;
+			}
+			return 0;
+		}
+	}
+	return 1;
+}
+
+void VideoOutput::draw(void *frame)
+{
+	if (!frame)
+		return ;
+	AutoLock autoLock(guard LOCKNAME("VideoOutput::draw"));
+
+	if (m_video_output)
+	{
+		m_video_output->displayFrame((const char *)frame, 0, 0);
+	}
+}
+
+extern wchar_t draw_vw_info_lastb[512];
+
+void VideoOutput::close()
+{
+	UpdateText(L"");
+	AutoLock autoLock(guard);
+	if (!m_opened)
+		return ;
+	m_opened = false;
+	if (m_video_output)
+	{
+		m_video_output->drawSubtitle(0);
+		m_video_output->close();
+	}
+	m_bufferstate = -1;
+
+	draw_vw_info_lastb[0] = 0;
+	input_plugin_thread_safe = false; // reset this
+	InvalidateRect(video_hwnd, NULL, true);
+	PostMessageW(hVideoWindow, WM_VIDEO_CLOSE, 0, 0);
+}
+
+int VideoOutput::is_fullscreen()
+{
+	return is_fs;
+}
+
+void VideoOutput::showStatusMsg(const char *text)
+{
+	AutoLock autoLock(guard);
+	m_statusmsg = _strdup(text);
+	PaintLogo(m_bufferstate);
+	//InvalidateRect(video_hwnd, NULL, TRUE);
+}
+
+void VideoOutput::drawSubtitle(SubsItem *item)
+{
+	AutoLock autoLock(guard);
+	if (item == curSubtitle)
+		return ;
+	curSubtitle = item;
+
+	if (m_video_output)
+		m_video_output->drawSubtitle(item);
+}
+
+void VideoOutput::resetSubtitle()
+{
+	AutoLock autoLock(guard);
+	curSubtitle = NULL;
+	if (m_video_output)
+		m_video_output->resetSubtitle();
+	//	InvalidateRect(this->getHwnd(), 0, TRUE);
+}
+
+void VideoOutput::remove_fullscreen()
+{
+	AutoLock autoLock(guard);
+	if (!is_fs)
+	{
+		is_fullscreen_video = false;
+		return ;
+	}
+
+	posd->Hide();
+	posd->ctrlrects_ready = 0; //tofix
+
+	if (m_video_output)
+	{
+		//	m_video_output->Fullscreen(false);
+	}
+
+	resetSubtitle();
+
+	is_fs = 0;
+
+	if (fs_reparented)
+	{
+		SetParent(hVideoWindow, fs_reparented);
+		SetWindowRgn(hVideoWindow, fs_reparented_rgn, FALSE);
+		fs_reparented = 0;
+		SetWindowPos(hVideoWindow, HWND_TOPMOST, oldfsrect.left, oldfsrect.top, oldfsrect.right - oldfsrect.left, oldfsrect.bottom - oldfsrect.top, SWP_NOACTIVATE | SWP_NOZORDER);
+	}
+	else
+		SetWindowPos(hVideoWindow, config_aot ? HWND_TOPMOST : HWND_NOTOPMOST, oldfsrect.left, oldfsrect.top, oldfsrect.right - oldfsrect.left, oldfsrect.bottom - oldfsrect.top, SWP_NOACTIVATE);
+
+	last_fullscreen_exit_time = GetTickCount();
+
+	posd->Hide();
+
+	if (!m_opened && m_video_output)
+	{
+		m_video_output->close();
+	}
+
+	is_fullscreen_video = false;
+
+	if (fs_has_resized)
+	{
+		fs_has_resized = false;
+		if (config_video_updsize)
+			UpdateVideoSize(width, height, aspect);
+	}
+}
+
+void VideoOutput::UpdateVideoSize(int newWidth, int newHeight, double newAspect, int zoom)
+{
+    if (!m_opened)
+        return;
+
+	// fill in default values if we have 0s
+	if (!newWidth)
+		newWidth = 320;
+	if (!newHeight)
+		newHeight = 240;
+
+	switch (zoom)
+	{
+		case ID_VIDEOWND_ZOOM200:
+			newWidth *= 2;
+			newHeight *= 2;
+			break;
+		case ID_VIDEOWND_ZOOM50:
+			newWidth /= 2;
+			newHeight /= 2;
+			break;
+	}
+
+	// establish a minimum window size
+	if (newWidth < 256)
+		newWidth = 256;
+	if (newHeight < 64)
+		newHeight = 64;
+
+	if (newAspect > 0.001) // floating point can be weird about checking == 0
+	{
+		if (newAspect < 1.0)
+			newWidth = (int)((double)newWidth / newAspect);
+		else
+			newHeight = (int)((double)newHeight * newAspect);
+	}
+
+	//SendNotifyMessage(hVideoWindow, WM_VIDEO_RESIZE, newWidth, newHeight);
+	PostMessageW(hVideoWindow, WM_VIDEO_RESIZE, newWidth, newHeight);
+}
+
+void VideoOutput::OpenVideoSize(int newWidth, int newHeight, double newAspect)
+{
+	// fill in default values if we have 0s
+	if (!newWidth)
+		newWidth = 320;
+	if (!newHeight)
+		newHeight = 240;
+
+	// establish a minimum window size
+	if (newWidth < 256)
+		newWidth = 256;
+	if (newHeight < 64)
+		newHeight = 64;
+
+	if (newAspect > 0.001) // floating point can be weird about checking == 0
+	{
+		if (newAspect < 1.0)
+			newWidth = (int)((double)newWidth / newAspect);
+		else
+			newHeight = (int)((double)newHeight * newAspect);
+	}
+
+	PostMessageW(hVideoWindow, WM_VIDEO_OPEN, newWidth, newHeight);
+}
+
+void VideoOutput::SetVideoPosition(int x, int y, int width, int height)
+{
+	AutoLock autoLock(guard);
+
+	SetWindowPos(getHwnd(), 0, x, y, width, height, SWP_NOZORDER | SWP_NOACTIVATE);
+}
\ No newline at end of file