static GLint getInternalFormat(void) { switch (glctx.type) { #ifdef CONFIG_GL_WIN32 case GLTYPE_W32: { PIXELFORMATDESCRIPTOR pfd; HDC vo_hdc = vo_w32_get_dc(vo_w32_window); int pf = GetPixelFormat(vo_hdc); if (!DescribePixelFormat(vo_hdc, pf, sizeof pfd, &pfd)) { r_sz = g_sz = b_sz = a_sz = 0; } else { r_sz = pfd.cRedBits; g_sz = pfd.cGreenBits; b_sz = pfd.cBlueBits; a_sz = pfd.cAlphaBits; } vo_w32_release_dc(vo_w32_window, vo_hdc); } break; #endif #ifdef CONFIG_GL_X11 case GLTYPE_X11: if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_RED_SIZE, &r_sz) != 0) r_sz = 0; if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_GREEN_SIZE, &g_sz) != 0) g_sz = 0; if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_BLUE_SIZE, &b_sz) != 0) b_sz = 0; if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_ALPHA_SIZE, &a_sz) != 0) a_sz = 0; break; #endif } rgb_sz=r_sz+g_sz+b_sz; if(rgb_sz<=0) rgb_sz=24; #ifdef TEXTUREFORMAT_ALWAYS return TEXTUREFORMAT_ALWAYS; #else if(r_sz==3 && g_sz==3 && b_sz==2 && a_sz==0) return GL_R3_G3_B2; if(r_sz==4 && g_sz==4 && b_sz==4 && a_sz==0) return GL_RGB4; if(r_sz==5 && g_sz==5 && b_sz==5 && a_sz==0) return GL_RGB5; if(r_sz==8 && g_sz==8 && b_sz==8 && a_sz==0) return GL_RGB8; if(r_sz==10 && g_sz==10 && b_sz==10 && a_sz==0) return GL_RGB10; if(r_sz==2 && g_sz==2 && b_sz==2 && a_sz==2) return GL_RGBA2; if(r_sz==4 && g_sz==4 && b_sz==4 && a_sz==4) return GL_RGBA4; if(r_sz==5 && g_sz==5 && b_sz==5 && a_sz==1) return GL_RGB5_A1; if(r_sz==8 && g_sz==8 && b_sz==8 && a_sz==8) return GL_RGBA8; if(r_sz==10 && g_sz==10 && b_sz==10 && a_sz==2) return GL_RGB10_A2; #endif return GL_RGB; }
/** * \brief Configure and show window on the screen. * * This function should be called in libvo's "config" callback. * It configures a window and shows it on the screen. * * Global libvo variables changed: * vo_fs * vo_vm * * \return 1 - Success, 0 - Failure */ int vo_w32_config(uint32_t width, uint32_t height, uint32_t flags) { PIXELFORMATDESCRIPTOR pfd; int pf; HDC vo_hdc = vo_w32_get_dc(vo_window); memset(&pfd, 0, sizeof pfd); pfd.nSize = sizeof pfd; pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; if (flags & VOFLAG_STEREO) pfd.dwFlags |= PFD_STEREO; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 24; pfd.iLayerType = PFD_MAIN_PLANE; pf = ChoosePixelFormat(vo_hdc, &pfd); if (!pf) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to select a valid pixel format!\n"); vo_w32_release_dc(vo_window, vo_hdc); return 0; } SetPixelFormat(vo_hdc, pf, &pfd); vo_w32_release_dc(vo_window, vo_hdc); // we already have a fully initialized window, so nothing needs to be done if (flags & VOFLAG_HIDDEN) return 1; // store original size for videomode switching o_dwidth = width; o_dheight = height; if (WinID < 0) { // the desired size is ignored in wid mode, it always matches the window size. prev_width = vo_dwidth = width; prev_height = vo_dheight = height; prev_x = vo_dx; prev_y = vo_dy; } vo_fs = flags & VOFLAG_FULLSCREEN; vo_vm = flags & VOFLAG_MODESWITCHING; return createRenderingContext(); }
/** * \brief Configure and show window on the screen. * * This function should be called in libvo's "config" callback. * It configures a window and shows it on the screen. * * \return 1 - Success, 0 - Failure */ int vo_w32_config(struct vo *vo, uint32_t width, uint32_t height, uint32_t flags) { struct vo_w32_state *w32 = vo->w32; PIXELFORMATDESCRIPTOR pfd; int pf; HDC vo_hdc = vo_w32_get_dc(vo, w32->window); memset(&pfd, 0, sizeof pfd); pfd.nSize = sizeof pfd; pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; if (flags & VOFLAG_STEREO) pfd.dwFlags |= PFD_STEREO; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 24; pfd.iLayerType = PFD_MAIN_PLANE; pf = ChoosePixelFormat(vo_hdc, &pfd); if (!pf) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to select a valid pixel format!\n"); vo_w32_release_dc(vo, w32->window, vo_hdc); return 0; } SetPixelFormat(vo_hdc, pf, &pfd); vo_w32_release_dc(vo, w32->window, vo_hdc); // we already have a fully initialized window, so nothing needs to be done if (flags & VOFLAG_HIDDEN) return 1; bool reset_size = !(w32->o_dwidth == width && w32->o_dheight == height); w32->o_dwidth = width; w32->o_dheight = height; // the desired size is ignored in wid mode, it always matches the window size. if (WinID < 0) { if (w32->window_bounds_initialized) { // restore vo_dwidth/vo_dheight, which are reset against our will // in vo_config() RECT r; GetClientRect(w32->window, &r); vo->dwidth = r.right; vo->dheight = r.bottom; } else { // first vo_config call; vo_config() will always set vo_dx/dy so // that the window is centered on the screen, and this is the only // time we actually want to use vo_dy/dy (this is not sane, and // video_out.h should provide a function to query the initial // window position instead) w32->window_bounds_initialized = true; reset_size = true; w32->window_x = w32->prev_x = vo->dx; w32->window_y = w32->prev_y = vo->dy; } if (reset_size) { w32->prev_width = vo->dwidth = width; w32->prev_height = vo->dheight = height; } } vo_fs = flags & VOFLAG_FULLSCREEN; w32->vm = flags & VOFLAG_MODESWITCHING; return reinit_window_state(vo); }
/** * \brief Initialize w32_common framework. * * The first function that should be called from the w32_common framework. * It handles window creation on the screen with proper title and attributes. * It also initializes the framework's internal variables. The function should * be called after your own preinit initialization and you shouldn't do any * window management on your own. * * Global libvo variables changed: * vo_w32_window * vo_screenwidth * vo_screenheight * * \return 1 = Success, 0 = Failure */ int vo_w32_init(void) { PIXELFORMATDESCRIPTOR pfd; HDC vo_hdc; int pf; char exedir[MAX_PATH]; HINSTANCE user32; HICON mplayerIcon = NULL; HICON mplayerSmallIcon = NULL; char *dev; if (vo_window) return 1; hInstance = GetModuleHandle(NULL); mplayerIcon = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_SHARED); mplayerSmallIcon = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, LR_SHARED); { WNDCLASSEX wcex = { sizeof wcex, CS_OWNDC | CS_DBLCLKS, WndProc, 0, 0, hInstance, mplayerIcon, LoadCursor(0, IDC_ARROW), NULL, 0, classname, mplayerSmallIcon }; if (!RegisterClassEx(&wcex)) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to register window class!\n"); return 0; } } if (WinID >= 0) { RECT r; GetClientRect(WinID, &r); vo_dwidth = r.right; vo_dheight = r.bottom; vo_window = CreateWindowEx(WS_EX_NOPARENTNOTIFY, classname, classname, WS_CHILD | WS_VISIBLE, 0, 0, vo_dwidth, vo_dheight, WinID, 0, hInstance, 0); EnableWindow(vo_window, 0); } else vo_window = CreateWindowEx(0, classname, classname, vo_border ? (WS_OVERLAPPEDWINDOW | WS_SIZEBOX) : WS_POPUP, CW_USEDEFAULT, 0, 100, 100, 0, 0, hInstance, 0); if (!vo_window) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to create window!\n"); return 0; } myMonitorFromWindow = NULL; myGetMonitorInfo = NULL; myEnumDisplayMonitors = NULL; user32 = GetModuleHandle("user32.dll"); if (user32) { myMonitorFromWindow = (void *)GetProcAddress(user32, "MonitorFromWindow"); myGetMonitorInfo = GetProcAddress(user32, "GetMonitorInfoA"); myEnumDisplayMonitors = GetProcAddress(user32, "EnumDisplayMonitors"); } dev_hdc = 0; dev = get_display_name(); if (dev) dev_hdc = CreateDC(dev, NULL, NULL, NULL); updateScreenProperties(); vo_hdc = vo_w32_get_dc(vo_window); memset(&pfd, 0, sizeof pfd); pfd.nSize = sizeof pfd; pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 24; pfd.iLayerType = PFD_MAIN_PLANE; pf = ChoosePixelFormat(vo_hdc, &pfd); if (!pf) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to select a valid pixel format!\n"); vo_w32_release_dc(vo_window, vo_hdc); return 0; } SetPixelFormat(vo_hdc, pf, &pfd); vo_w32_release_dc(vo_window, vo_hdc); mp_msg(MSGT_VO, MSGL_V, "vo: win32: running at %dx%d with depth %d\n", vo_screenwidth, vo_screenheight, depthonscreen); return 1; }