path: root/Src/Winamp/video.cpp

#include <windowsx.h>

#include "main.h"
#include <ddraw.h>
#include <multimon.h>
#include "api.h"
#include "vid_overlay.h"
#include "vid_ddraw.h"
#include "vid_subs.h"
#include "vid_none.h"
#include "VideoOutput.h"

#include "Browser.h"
#include "video.h"
#include "../nu/AutoWide.h"
#include "WinampAttributes.h"
#include "resource.h"

#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_CREATE WM_USER+0x900

#define VIDEO_GENFF_SIZEREQUEST (WM_USER+2048)
#undef GetSystemMetrics

#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))

VideoOutput *m_videooutput = NULL;

static int VW_OnLButtonUp(HWND hwnd, int x, int y, UINT flags);
static int VW_OnRButtonUp(HWND hwnd, int x, int y, UINT flags);
static int VW_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
static int VW_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags);
static int VW_OnLButtonDblClk(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
static BOOL VW_OnNCActivate(HWND hwnd, BOOL fActive, HWND hwndActDeact, BOOL fMinimized);
extern "C" int g_video_numaudiotracks;
extern "C" int is_fullscreen_video = 0;
extern "C" int no_notify_play;
extern "C" int last_no_notify_play;
#undef GetSystemMetrics

bool sizeOnOpen = false;
int widthOnOpen, heightOnOpen;
#define VideoClassicWidth() 19
#define VideoClassicHeight() 58
static void VideoClose();

/* Resizes the windows (parent and children) based on what the size of the video should be */
static void SetVideoSize(int width, int height)
{
	if (m_videooutput && m_videooutput->is_fullscreen()) // fullscreen
	{
		m_videooutput->SetVideoPosition(0, 0, config_video_width, config_video_height);
	}
	else 	// not fullscreen
	{
		// send out ideal video size message (in case anyone wants it)
		PostMessageW(hMainWindow, WM_WA_IPC, (((width) & 0xFFFF) << 16) | ((height) & 0xFFFF), IPC_SETIDEALVIDEOSIZE);
		if (GetParent(hVideoWindow)) // if gen_ff owns the window, then signal it about the video size
			PostMessageW(GetParent(hVideoWindow), VIDEO_GENFF_SIZEREQUEST, width, height);
		else // classic skin
			SetWindowPos(hVideoWindow, 0, 0, 0, width + VideoClassicWidth(), height + VideoClassicHeight(), SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
	}
}

/*	Resizes the windows (parent and children) based on what the size of the parent should be 	*/
void SetExteriorSize(int width, int height)
{
	// calculate interior size
	width -= VideoClassicWidth();
	height -= VideoClassicHeight();

	// pass our calculated value onto the size routine
	SetVideoSize(width, height);
}

/* lays out children (video and ad) based on a given parent window size */
static void LayoutChildren(int width, int height)
{
	if (m_videooutput && m_videooutput->is_fullscreen()) // fullscreen
	{
		m_videooutput->SetVideoPosition(0, 0, config_video_width, config_video_height);
	}
	else // not fullscreen
	{
		// calculate interior size
		width -= VideoClassicWidth();
		height -= VideoClassicHeight();

		// size the video
		if (m_videooutput)
		{
			m_videooutput->SetVideoPosition(11, 20, width, height);
			InvalidateRect(m_videooutput->getHwnd(), 0, TRUE); // force repaint of video
		}
		InvalidateRect(hVideoWindow, 0, TRUE); // force repaint of parent window
	}
}

/* Resizes the windows (parent and children) based on what the size of the parent should be
Sets the position of the parent window */
static void SetExteriorSizeAndPosition(int x, int y, int width, int height)
{
	config_video_wx = x;
	config_video_wy = y;
	SetExteriorSize(width, height);
}

void updateTrackSubmenu()
{
	HMENU menu = GetSubMenu(GetSubMenu(top_menu, 3), 13);
	HMENU audiomenu = GetSubMenu(menu, 6);
	HMENU videomenu = GetSubMenu(menu, 7);
	static int audioadded = 0;
	static int videoadded = 0;
	static int first = 1;
	if (first)
	{
		RemoveMenu(audiomenu, ID_VID_AUDIO0, MF_BYCOMMAND);
		RemoveMenu(videomenu, ID_VID_VIDEO0, MF_BYCOMMAND);
		first = 1;
	}

	if (audioadded)
	{
		for (int i = 0;i < 16;i++)
		{
			RemoveMenu(audiomenu, ID_VID_AUDIO0 + i, MF_BYCOMMAND);
		}
		audioadded = 0;
	}
	if (videoadded)
	{
		for (int i = 0;i < 16;i++)
		{
			RemoveMenu(videomenu, ID_VID_VIDEO0 + i, MF_BYCOMMAND);
		}
		videoadded = 0;
	}

	VideoOutput *out = (VideoOutput *)video_getIVideoOutput();
	if (!out || !out->getTrackSelector())
	{
		EnableMenuItem(menu, 8, MF_GRAYED | MF_BYPOSITION);
		EnableMenuItem(menu, 9, MF_GRAYED | MF_BYPOSITION);
		return ;
	}

	ITrackSelector *sel = out->getTrackSelector();

	int numaudiotracks = sel->getNumAudioTracks();
	if (numaudiotracks < 2)
	{
		EnableMenuItem(menu, 8, MF_GRAYED | MF_BYPOSITION);
	}
	else
	{
		audioadded = 1;
		int curtrack = sel->getCurAudioTrack();
		for (int i = 0;i < numaudiotracks;i++)
		{
			char t[256] = {0};
			sel->enumAudioTrackName(i, t, 255);
			InsertMenuA(audiomenu, i, MF_BYPOSITION, ID_VID_AUDIO0 + i, t);
			CheckMenuItem(audiomenu, ID_VID_AUDIO0 + i, ((i == curtrack) ? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
		}
		EnableMenuItem(menu, 8, MF_ENABLED | MF_BYPOSITION);
	}

	int numvideotracks = sel->getNumVideoTracks();
	if (numvideotracks < 2)
	{
		EnableMenuItem(menu, 9, MF_GRAYED | MF_BYPOSITION);
	}
	else
	{
		videoadded = 1;
		int curtrack = sel->getCurVideoTrack();
		for (int i = 0;i < numvideotracks;i++)
		{
			char t[256] = {0};
			sel->enumVideoTrackName(i, t, 255);
			InsertMenuA(videomenu, i, MF_BYPOSITION, ID_VID_VIDEO0 + i, t);
			CheckMenuItem(videomenu, ID_VID_VIDEO0 + i, ((i == curtrack) ? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
		}
		EnableMenuItem(menu, 9, MF_ENABLED | MF_BYPOSITION);
	}
}

int ShowVideoWindow(int init_state)
{
	sizeOnOpen = false;

	if (config_video_open // if we're already open
	    || !hVideoWindow // or we havn't made the video window yet
	    || !g_has_video_plugin // or we're configured to not have video
	    || !Ipc_WindowToggle(IPC_CB_WND_VIDEO, 1))  // or some plugin doesn't want us to open the video window
		return 0; // then bail out

	CheckMenuItem(main_menu, WINAMP_OPTIONS_VIDEO, MF_CHECKED);
	if(!init_state && !config_minimized) ShowWindow(hVideoWindow, SW_SHOWNA);
	//ad->show(true);
	config_video_open = 1;
	set_aot(1);
	return 1;
}

void HideVideoWindow(int autoStop)
{
	sizeOnOpen = false;

	if (!config_video_open // if we're not even open
	    || !hVideoWindow // or we havn't made the video window yet
	    //	|| !g_has_video_plugin // or we're configured to not have video
	    || !Ipc_WindowToggle(IPC_CB_WND_VIDEO, !config_video_open)) // or some plugin doesn't want us to close the video window
		return ; // then bail out

	if (GetForegroundWindow() == hVideoWindow || IsChild(hVideoWindow, GetForegroundWindow()))
	{
		SendMessageW(hMainWindow, WM_COMMAND, WINAMP_NEXT_WINDOW, 0);
	}
	CheckMenuItem(main_menu, WINAMP_OPTIONS_VIDEO, MF_UNCHECKED);
	ShowWindow(hVideoWindow, SW_HIDE);

	config_video_open = 0;

	if (autoStop && config_video_stopclose && !(GetAsyncKeyState(VK_SHIFT)&0x8000) && video_isVideoPlaying())
	{
		PostMessageW(hMainWindow, WM_COMMAND, WINAMP_BUTTON4, 0);
	}
}

HMENU BuildPopupMenu();

void Vid_Cmd(windowCommand *wc)
{
	switch (wc->cmd)
	{
	case VIDCMD_FULLSCREEN:
		videoGoFullscreen();
		break;
	case VIDCMD_1X:
		SendMessageW(videoGetHwnd(), WM_COMMAND, ID_VIDEOWND_ZOOM100, 0);
		break;
	case VIDCMD_2X:
		SendMessageW(videoGetHwnd(), WM_COMMAND, ID_VIDEOWND_ZOOM200, 0);
		break;
	case VIDCMD_LIB:
		SendMessageW(videoGetHwnd(), WM_COMMAND, WINAMP_VIDEO_TVBUTTON, 0);
		break;
	case VIDPOPUP_MISC:
		DoTrackPopup(BuildPopupMenu(), wc->align, wc->x, wc->y, videoGetHwnd());
		break;
	case VIDCMD_EXIT_FS:
		videoForceFullscreenOff();
		break;
	}
}

static int VW_OnRButtonUp(HWND hwnd, int x, int y, UINT flags)
{
	POINT p;
	extern HMENU top_menu;
	GetCursorPos(&p);
	DoTrackPopup(main_menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, p.x, p.y, hMainWindow);
	return 1;
}

static int VW_OnLButtonUp(HWND hwnd, int x, int y, UINT flags)
{
	ReleaseCapture();
	videoui_handlemouseevent(x, y, -1, flags);
	return 1;
}

static int VW_OnLButtonDown( HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags )
{
	SetCapture( hwnd );
	videoui_handlemouseevent( x, y, 1, keyFlags );
	SetFocus( hwnd );

	return 1;
}

static int VW_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags)
{
	videoui_handlemouseevent(x, y, 0, keyFlags);

	return 1;
}

static BOOL VW_OnNCActivate( HWND hwnd, BOOL fActive, HWND hwndActDeact, BOOL fMinimized )
{
	if ( !m_videooutput || ( m_videooutput && !m_videooutput->is_fullscreen() ) )
	{
		if ( fActive == FALSE )
			draw_vw_tbar( config_hilite ? 0 : 1 );
		else
			draw_vw_tbar( 1 );
	}

	return TRUE;
}

static int VW_OnLButtonDblClk(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
	return 1;
}

/*Turns off and on the screensaver*/
VOID CALLBACK ResetScreenSaver(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
	// benski> this seems less hackish.  only win2k and up
	if (config_video_noss && video_isVideoPlaying())
		SetThreadExecutionState(ES_DISPLAY_REQUIRED);
	// TODO: maybe we should do the same thing with ES_SYSTEM_REQUIRED to keep the system from snoozing

	// benski> old code was here
	/*
	BOOL b;
	if (config_video_noss && video_isVideoPlaying() && SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &b, 0) && b)
	{
		SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 0, 0, 0); // turn off
		SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 1, 0, 0); // turn back on
		// this is just a hack
		// basically by toggling off and on we reset the timeout count
	}
*/
}

static void VideoOpen(HWND hwnd, int width, int height)
{
	sizeOnOpen=false;

	// check if we appear to be doing a resume from a tag edit
	// and if so then we need to ignore the show window option
	if (config_video_autoopen &&
		((no_notify_play != last_no_notify_play && !last_no_notify_play) || (no_notify_play == last_no_notify_play)))
		ShowVideoWindow(0);
	last_no_notify_play = no_notify_play;

	HWND skinVidWindow = GetParent(hwnd) ? GetParent(hwnd) : hwnd;

	if (m_videooutput->is_fullscreen() || config_video_auto_fs) // go fullscreen
	{
		videoGoFullscreen();
		InvalidateRect(m_videooutput->getHwnd(), 0, TRUE);
	}
	else // not fullscreen
	{
		if (config_video_updsize)
		{
			widthOnOpen = width;
			heightOnOpen = height;
			sizeOnOpen = true;
			SetVideoSize(width, height);
		}
		LayoutChildren(config_video_width, config_video_height);

		if (!IsIconic(skinVidWindow))
			BringWindowToTop(skinVidWindow);
		InvalidateRect(hwnd, 0, TRUE);
	}
}

LRESULT CALLBACK video_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (uMsg == g_scrollMsg) { wParam <<= 16; uMsg = WM_MOUSEWHEEL; }

	if (uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDOWN || uMsg == WM_RBUTTONUP || uMsg == WM_MOUSEMOVE)
		if (!m_videooutput || !m_videooutput->is_fullscreen())
		{
			switch (uMsg)
			{
				HANDLE_MSG(hwnd, WM_LBUTTONUP,   VW_OnLButtonUp);
				HANDLE_MSG(hwnd, WM_LBUTTONDOWN, VW_OnLButtonDown);
				HANDLE_MSG(hwnd, WM_MOUSEMOVE,   VW_OnMouseMove);
				HANDLE_MSG(hwnd, WM_RBUTTONUP,   VW_OnRButtonUp);
			}
		}

	switch (uMsg)
	{
	case WM_USER + 1:
		if (m_videooutput)
			SendMessageW(m_videooutput->getHwnd(), uMsg, wParam, lParam);
		break;

	case WM_USER + 2:
		if (sizeOnOpen)
		{
			//				sizeOnOpen=false;
			PostMessageW(hwnd, WM_VIDEO_RESIZE, widthOnOpen, heightOnOpen);
		}
		if (m_videooutput)
			SendMessageW(m_videooutput->getHwnd(), uMsg, wParam, lParam);
		break;

	case WM_USER + 0x100:
		if (wParam == 1 && lParam)
		{
			config_video_wx = ((POINT *)lParam)->x;
			config_video_wy = ((POINT *)lParam)->y;
			if ((!!config_snap) ^ (!!(GetKeyState(VK_SHIFT) & 0x8000)))
			{
				RECT outrc;
				EstVidWindowRect(&outrc);
				SnapWindowToAllWindows(&outrc, hVideoWindow);
				SetVidWindowRect(&outrc);
			}
			SetWindowPos(hVideoWindow, 0, config_video_wx, config_video_wy, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
		}
		return 0;
	case WM_TIMER:
		switch (wParam)
		{
			case 12345:                    // signal from elsewhere
				if (m_videooutput)
					SendMessageW(m_videooutput->getHwnd(), WM_TIMER, 0, 0);
			break;
		}
		return 0;
	case WM_WINDOWPOSCHANGING:
	case WM_WINDOWPOSCHANGED:         // we trap both windowposchanging and windowposchanged incase someone uses SetWindowPos(..., SWP_NOSENDCHANGING)
		{
			LPWINDOWPOS windowPos = (LPWINDOWPOS) lParam;
			if (windowPos->flags & SWP_NOSIZE)
			{
				break;
			}

			if (uMsg == WM_WINDOWPOSCHANGED)
			{
				config_video_width = windowPos->cx;
				config_video_height = windowPos->cy;
				LayoutChildren(config_video_width, config_video_height);
				// update the position of the tooltips on window resize
				set_vid_wnd_tooltip();
			}
		}
		break;

	case WM_NOTIFY:
		{
			LPTOOLTIPTEXT tt = (LPTOOLTIPTEXT)lParam;
			if(tt->hdr.hwndFrom = hVideoTooltipWindow)
			{
				switch (tt->hdr.code)
				{
					case TTN_SHOW:
						SetWindowPos(tt->hdr.hwndFrom,HWND_TOPMOST,0,0,0,0,SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE);
						break;
				}
			}
		}
		break;

	case WM_GETMINMAXINFO:
		{
			MINMAXINFO *p = (MINMAXINFO *)lParam;
			p->ptMaxTrackSize.x = 16384;
			p->ptMaxTrackSize.y = 16384;
		}
		return 0;

	case WM_VIDEO_RESIZE:
		//ReplyMessage(0); // if IVideoOutput::open() was called on a different thread, this will unblock it.
		{
			int width = wParam;
			int height = lParam;
			//			idealWidth = wParam;
			SetVideoSize(width, height);
			LayoutChildren(config_video_width, config_video_height);
		}
		return 0;

	case WM_DESTROY:
		if (NULL != WASABI_API_APP) WASABI_API_APP->app_unregisterGlobalWindow(hwnd);
		if (vw_init)
			draw_vw_kill();
		break;

	case WM_DISPLAYCHANGE:
		InvalidateRect(hwnd, NULL, TRUE);
		break;

	case WM_VIDEO_OPEN:
		VideoOpen(hwnd, wParam, lParam);
		//		set_aot(1);
		return 0;
		break;

	case WM_VIDEO_CREATE:
		m_videooutput->mainthread_Create();
		break;

	case WM_VIDEO_CLOSE:
		VideoClose();
		InvalidateRect(hwnd, NULL, TRUE); //repaint
		return 0;

	case WM_VIDEO_UPDATE_STATUS_TEXT:
		if (m_videooutput && !m_videooutput->is_fullscreen()) 
			draw_vw_info((wchar_t*)wParam, 1);
		videoTextFeed->UpdateText((const wchar_t*)wParam, 1024);
		return 0;

	case WM_MOUSEWHEEL:
		return SendMessageW(hMainWindow, uMsg, wParam, lParam);

	HANDLE_MSG(hwnd, WM_QUERYNEWPALETTE, Main_OnQueryNewPalette);
	HANDLE_MSG(hwnd, WM_PALETTECHANGED, Main_OnPaletteChanged);
	HANDLE_MSG(hwnd, WM_NCACTIVATE, VW_OnNCActivate);
	HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK, VW_OnLButtonDblClk);

	case WM_CONTEXTMENU:
		{
			if (lParam == MAKELONG(-1, -1))
			{
				extern HMENU top_menu;
				RECT r;
				GetWindowRect(videoGetHwnd(), &r);
				DoTrackPopup(BuildPopupMenu(), TPM_LEFTALIGN | TPM_RIGHTBUTTON, r.left, r.top, videoGetHwnd());
			}
		}
		return 0;

	case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP:
		if ((GetAsyncKeyState(VK_CONTROL)&0x8000) && wParam == VK_F4)
		{
			if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN)
				SendMessageW(hMainWindow, WM_COMMAND, WINAMP_OPTIONS_VIDEO, 0);
		}
		/*      else if(uMsg==WM_SYSKEYDOWN && (LPARAM&(1<<29)) && wParam == VK_RETURN)
		      {
		        if (m_videooutput)
		        {
		          if(!m_videooutput->is_fullscreen()) m_videooutput->fullscreen();
		          else m_videooutput->remove_fullscreen();
		        }
		      }*/
		else
		{
			if (SendMessageW(m_videooutput->getHwnd(), uMsg, wParam, lParam)) return 0;
			if (wParam != VK_RETURN && m_videooutput->is_fullscreen() && ((GetAsyncKeyState(VK_CONTROL) | GetAsyncKeyState(VK_MENU))&0x8000)) return 0;
			{
				MSG winmsg;
				winmsg.message = uMsg;
				winmsg.hwnd = hMainWindow;
				winmsg.wParam = wParam;
				winmsg.lParam = lParam;
				if (WASABI_API_APP->app_translateAccelerators(&winmsg)) return 0;
				//if (transAccel(hwnd,uMsg,wParam,lParam)) return 0;
				//transAccelStruct tas = {hwnd, uMsg, wParam, lParam};
				//if (SendMessageW(hMainWindow, WM_WA_IPC, (WPARAM)&tas, IPC_TRANSLATEACCELERATOR)) return 0;
			}
		}
		break;

	case WM_DROPFILES:
		return SendMessageW(hMainWindow, uMsg, wParam, lParam);

	case WM_SHOWWINDOW:
		if (wParam == TRUE) // showing
		{
			if (sizeOnOpen)
			{
				//sizeOnOpen=false;
				PostMessageW(hwnd, WM_VIDEO_RESIZE, widthOnOpen, heightOnOpen);
			}

			if (!IsIconic(hwnd))
				BringWindowToTop(hwnd);
			LayoutChildren(config_video_width, config_video_height);
		}

		RefreshIconicThumbnail();

		/*
		{
		      // if extra_data[EMBED_STATE_EXTRA_REPARENTING] is set, we are being reparented by the freeform lib, so we should
		      // just ignore this message because our visibility will not change once the freeform
		      // takeover/restoration is complete
		      embedWindowState *ws = (embedWindowState *)GetWindowLongW(hwnd, GWL_USERDATA);
		      if (ws != NULL && ws->extra_data[EMBED_STATE_EXTRA_REPARENTING]) 
			  {
			  }
		    }
		*/
		break;

	case WM_CLOSE:
		if (!m_videooutput || !m_videooutput->is_fullscreen())
			WASABI_API_APP->main_shutdown();
		else
			m_videooutput->remove_fullscreen();
		return 0;

	case WM_PAINT:
		if (!m_videooutput || !m_videooutput->is_fullscreen())
		{
			draw_paint_vw(hwnd);
			return 0;
		}
		break;

	case WM_CREATE:
		hVideoWindow = hwnd;
		SetTimer(hwnd, 32, 15000, ResetScreenSaver);
		SetWindowLongPtrW(hwnd, GWLP_USERDATA, (config_keeponscreen&2) ? 0x49474541 : 0);
		SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE)&~(WS_CAPTION));
		SetWindowPos(hVideoWindow, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
		//ad->CreateHWND(hwnd);
		m_videooutput = new VideoOutput(hwnd);
		if (!config_minimized)
			ShowWindow(m_videooutput->getHwnd(), SW_SHOWNA);
		SetExteriorSizeAndPosition(config_video_wx, config_video_wy, config_video_width, config_video_height);
		LayoutChildren(config_video_width, config_video_height);
		
		if (NULL != WASABI_API_APP) WASABI_API_APP->app_registerGlobalWindow(hwnd);
		
		return 0;

	case WM_COMMAND:
		return SendMessageW(hMainWindow, uMsg, wParam, lParam);

	case WM_MOVE:
		if (m_videooutput)
			SendMessageW(m_videooutput->getHwnd(), WM_MOVE, 0, 0);
		return 0;

	case WM_SETCURSOR:
		if (config_usecursors && !disable_skin_cursors)
		{
#define inreg(x,y,x2,y2) \
	((mouse_x <= ( x2 ) && mouse_x >= ( x ) &&  \
	  mouse_y <= ( y2 ) && mouse_y >= ( y )))

			if (((HWND)wParam == hVideoWindow || IsChild(hVideoWindow, (HWND)wParam)) && HIWORD(lParam) == WM_MOUSEMOVE)
			{
				int mouse_x, mouse_y;
				POINT p;
				static RECT b[] =
				    {
				        { -(275 - 264), 3, -(275 - 272), 12},                               //close
				        {0, 0, -1, 13},                               // titelbar
				        { -20, -20, -1, -1},
				    };

				int iconoffs[] = {15 + 1, 15 + 2, 15 + 4, 15 + 5};
				int b_len = 3;
				int x;
				GetCursorPos(&p);
				ScreenToClient(hVideoWindow, &p);
				mouse_x = p.x;
				mouse_y = p.y;

				for (x = 0; x < b_len; x ++)
				{
					int l, r, t, bo;
					l = b[x].left;r = b[x].right;t = b[x].top;bo = b[x].bottom;
					if (l < 0) l += config_video_width;
					if (r < 0) r += config_video_width;
					if (t < 0) t += config_video_height;
					if (bo < 0) bo += config_video_height;
					if (inreg(l, t, r, bo)) break;
				}

				if (Skin_Cursors[iconoffs[x]]) SetCursor(Skin_Cursors[iconoffs[x]]);
				else SetCursor(LoadCursorW(NULL, IDC_ARROW));
			}
			return TRUE;
		}
		else SetCursor(LoadCursorW(NULL, IDC_ARROW));
		return TRUE;

	case 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 (FALSE != IsDirectMouseWheelMessage(uMsg))
	{
		SendMessageW(hwnd, WM_MOUSEWHEEL, wParam, lParam);
		return TRUE;
	}

	return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}

static void VideoClose()
{
	sizeOnOpen=false;
	if (!g_has_video_plugin)
		return ;

	if (m_videooutput && m_videooutput->is_fullscreen() && config_video_remove_fs_on_stop)
		videoForceFullscreenOff();

	if ((!m_videooutput && (bool)config_video_autoclose)
	    || (m_videooutput && !m_videooutput->is_fullscreen() && (bool)config_video_autoclose))
		HideVideoWindow(false);
}

extern "C"
{
	void videoAdSizeChanged()
	{
		LayoutChildren(config_video_width, config_video_height);
	}

	void *video_getIVideoOutput()
	{
		return (void *)m_videooutput;
	}

	int video_isVideoPlaying()
	{
		if (!m_videooutput) return 0;
		return m_videooutput->isVideoPlaying();
	}

	void videoGoFullscreen()
	{
		if (m_videooutput)
		{
			m_videooutput->fullscreen();
		}
	}

	int videoIsFullscreen()
	{
		if (m_videooutput) return !!m_videooutput->is_fullscreen();
		return 0;
	}

	void videoReinit()
	{
		if (m_videooutput)
			PostMessageW(m_videooutput->getHwnd(), WM_USER + 0x1, 0, 0);
	}

	void videoForceFullscreenOff()
	{
		if (m_videooutput)
		{
			m_videooutput->remove_fullscreen();
			LayoutChildren(config_video_width, config_video_height);
		}
	}

	void videoToggleFullscreen()
	{
		if (m_videooutput)
		{
			if (!m_videooutput->is_fullscreen())
				videoGoFullscreen();
			else
				videoForceFullscreenOff();
		}
	}

	void videoSetFlip(int on)
	{
		if (m_videooutput)
		{
			m_videooutput->extended(VIDUSER_SET_VFLIP, on, 0);
		}
		// for consistency we need to update the state on the prefs page
		if(prefs_last_page == 24 && IsWindow(prefs_hwnd))
		{
			SendMessageW(prefs_hwnd, WM_USER + 33, IDC_PREFS_VIDEO_FLIPRGB, on);
		}
		CheckMenuItem(GetSubMenu(GetSubMenu(top_menu, 3), 13), ID_VIDEOWND_VERTICALLYFLIP, (on ? MF_CHECKED: MF_UNCHECKED));
	}

	DWORD videoGetWidthHeightDWORD()
	{
		if (!m_videooutput) return 0;
		return m_videooutput->GetWidthHeightDWORD();
	}

	HWND videoGetHwnd()
	{
		if (m_videooutput) return m_videooutput->getHwnd();
		return NULL;
	}

	int video_getNumAudioTracks()
	{
		VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
		if (!vid) return 1;
		ITrackSelector *sel = vid->getTrackSelector();
		if (!sel) return 1;
		return sel->getNumAudioTracks();
	}

	int video_getNumVideoTracks()
	{
		VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
		if (!vid) return 1;
		ITrackSelector *sel = vid->getTrackSelector();
		if (!sel) return 1;
		return sel->getNumVideoTracks();
	}

	int video_getCurAudioTrack()
	{
		VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
		if (!vid) return 0;
		ITrackSelector *sel = vid->getTrackSelector();
		if (!sel) return 0;
		return sel->getCurAudioTrack();
	}

	int video_getCurVideoTrack()
	{
		VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
		if (!vid) return 0;
		ITrackSelector *sel = vid->getTrackSelector();
		if (!sel) return 0;
		return sel->getCurVideoTrack();
	}

	int video_setCurAudioTrack(int track)
	{
		VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
		if (!vid) return 0;
		ITrackSelector *sel = vid->getTrackSelector();
		if (!sel) return 0;
		sel->setAudioTrack(track);
		return sel->getCurAudioTrack();
	}

	int video_setCurVideoTrack(int track)
	{
		VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
		if (!vid) return 0;
		ITrackSelector *sel = vid->getTrackSelector();
		if (!sel) return 0;
		sel->setVideoTrack(track);
		return sel->getCurVideoTrack();
	}

	HWND video_Create()
	{
		return CreateWindowExW(WS_EX_ACCEPTFILES, L"Winamp Video", getStringW(IDS_VIDEOCAPTION, NULL, 0), (WS_OVERLAPPED | WS_CLIPCHILDREN)&(~WS_CAPTION),
		                      config_video_wx, config_video_wy, config_video_width, config_video_height,
		                      hMainWindow, NULL, GetModuleHandle(NULL), NULL);
	}
}