vo_directx.c

DawnLightPlayer,一个新的基于ffmpeg的全功能播放器

	while ( i < NUM_FORMATS )
	{
		if (g_ddpf[i].g_ddpfOverlay.dwRGBBitCount == ddpf.dwRGBBitCount)
		{
			if (g_ddpf[i].g_ddpfOverlay.dwRBitMask == ddpf.dwRBitMask)
			{
				av_log(NULL, AV_LOG_ERROR,"vo_directx: %i %s supported\n",i,g_ddpf[i].img_format_name);
				formatcount++;
				primary_image_format = g_ddpf[i].img_format;
			}
		}
		i++;
	}
	//get the colorkey for overlay mode
	destcolorkey = CLR_INVALID;
	if (windowcolor != CLR_INVALID && g_lpddsPrimary->lpVtbl->GetDC(g_lpddsPrimary,&hdc) == DD_OK)
	{
		rgbT = GetPixel(hdc, 0, 0);
		SetPixel(hdc, 0, 0, windowcolor);
		g_lpddsPrimary->lpVtbl->ReleaseDC(g_lpddsPrimary,hdc);
	}
	// read back the converted color
	ddsd.dwSize = sizeof(ddsd);
	while ((hres = g_lpddsPrimary->lpVtbl->Lock(g_lpddsPrimary,NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
		;
	if (hres == DD_OK)
	{
		destcolorkey = *(DWORD *) ddsd.lpSurface;
		if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
			destcolorkey &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;
		g_lpddsPrimary->lpVtbl->Unlock(g_lpddsPrimary,NULL);
	}
	if (windowcolor != CLR_INVALID && g_lpddsPrimary->lpVtbl->GetDC(g_lpddsPrimary,&hdc) == DD_OK)
	{
		SetPixel(hdc, 0, 0, rgbT);
		g_lpddsPrimary->lpVtbl->ReleaseDC(g_lpddsPrimary,hdc);
	}
	//release primary
	g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
	g_lpddsPrimary = NULL;
	if (formatcount==0)
	{
		av_log(NULL, AV_LOG_ERROR,"vo_directx: Unknown Pixelformat\n");
		return -1;
	}
	return 0;
}

static void dlp_parse_key(int k)
{
	printf("key: %u\n", k);
}

//function handles input
static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_MOUSEACTIVATE:
			return MA_ACTIVATEANDEAT;
		case WM_NCACTIVATE:
			{
				if (adapter_count > 2) //only disable if more than one adapter.
					return 0;
				break;
			}
		case WM_DESTROY:
			{
				PostQuitMessage(0);
				return 0;
			}
		case WM_CLOSE:
			{
				//dlp_parse_key(KEY_CLOSE_WIN);
				return 0;
			}
		case WM_WINDOWPOSCHANGED:
			{
				if (g_lpddsBack != NULL)
				{
					Directx_ManageDisplay();
				}
				break;
			}
		case WM_SYSCOMMAND:
			{
				switch (wParam)
				{
					//kill screensaver etc.
					//note: works only when the window is active
					//you can workaround this by disabling the allow screensaver option in
					//the link to the app
					case SC_MAXIMIZE:
						//if (!vo_fs) control(VOCTRL_FULLSCREEN, NULL);
						return 0;
				}
				break;
			}
		case WM_KEYDOWN:
			{
				switch (wParam)
				{
					case VK_LEFT:
						{
							//dlp_parse_key(KEY_LEFT);
							break;
						}
					case VK_UP:
						{
							//dlp_parse_key(KEY_UP);
							break;
						}
					case VK_RIGHT:
						{
							//dlp_parse_key(KEY_RIGHT);
							break;
						}
					case VK_DOWN:
						{
							//dlp_parse_key(KEY_DOWN);
							break;
						}
					case VK_TAB:
						{
							//dlp_parse_key(KEY_TAB);
							break;
						}
					case VK_BACK:
						{
							//dlp_parse_key(KEY_BS);
							break;
						}
					case VK_DELETE:
						{
							//dlp_parse_key(KEY_DELETE);
							break;
						}
					case VK_INSERT:
						{
							//dlp_parse_key(KEY_INSERT);
							break;
						}
					case VK_HOME:
						{
							//dlp_parse_key(KEY_HOME);
							break;
						}
					case VK_END:
						{
							//dlp_parse_key(KEY_END);
							break;
						}
					case VK_PRIOR:
						{
							//dlp_parse_key(KEY_PAGE_UP);
							break;
						}
					case VK_NEXT:
						{
							//dlp_parse_key(KEY_PAGE_DOWN);
							break;
						}
					case VK_ESCAPE:
						{
							//dlp_parse_key(KEY_ESC);
							break;
						}
				}
				break;
			}
		case WM_CHAR:
			{
				dlp_parse_key(wParam);
				break;
			}
	}
	return DefWindowProc(hWnd, message, wParam, lParam);
}


static int preinit(const char *arg)
{
	HINSTANCE hInstance = GetModuleHandle(NULL);
	char exedir[MAX_PATH];
	WNDCLASS   wc;

	if (arg)
	{
		if (strstr(arg,"noaccel"))
		{
			nooverlay = 1;
		}
	}
	/*load icon from the main app*/
	if (GetModuleFileName(NULL,exedir,MAX_PATH))
	{
		mplayericon = ExtractIcon( hInstance, exedir, 0 );
	}
	monitor_rect.right = GetSystemMetrics( SM_CXSCREEN );
	monitor_rect.bottom = GetSystemMetrics( SM_CYSCREEN );

	//windowcolor = vo_colorkey;
	colorbrush = CreateSolidBrush(windowcolor);
	blackbrush = (HBRUSH)GetStockObject(BLACK_BRUSH);
	wc.style         =  CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
	wc.lpfnWndProc   =  WndProc;
	wc.cbClsExtra    =  0;
	wc.cbWndExtra    =  0;
	wc.hInstance     =  hInstance;
	wc.hCursor       =  mplayercursor;
	wc.hIcon         =  mplayericon;
	wc.hbrBackground =  colorbrush;
	wc.lpszClassName =  WNDCLASSNAME_WINDOWED;
	wc.lpszMenuName  =  NULL;
	RegisterClass(&wc);
	hWnd = CreateWindowEx(0,
			WNDCLASSNAME_WINDOWED,"",WS_POPUP,
			CW_USEDEFAULT, CW_USEDEFAULT, 100, 100,NULL,NULL,hInstance,NULL);
	wc.hbrBackground = blackbrush;
	wc.lpszClassName = WNDCLASSNAME_FULLSCREEN;
	RegisterClass(&wc);

	if ( Directx_InitDirectDraw() != 0 )
		return -1;

	hWndFS = CreateWindow(WNDCLASSNAME_FULLSCREEN,"Fullscreen",WS_POPUP,monitor_rect.left,monitor_rect.top,monitor_rect.right-monitor_rect.left,monitor_rect.bottom-monitor_rect.top,hWnd,NULL,hInstance,NULL);

	if (Directx_CheckPrimaryPixelformat()!=0)return 1;
	if (!nooverlay && Directx_CheckOverlayPixelformats() == 0)        //check for supported hardware
	{
		av_log(NULL, AV_LOG_INFO ,"<vo_directx><INFO>hardware supports overlay\n");
		nooverlay = 0;
	}
	else   //if we can't have overlay we create a backpuffer with the same imageformat as the primary surface
	{
		av_log(NULL, AV_LOG_INFO ,"<vo_directx><INFO>using backpuffer\n");
		nooverlay = 1;
	}

	return 0;
}

static int directx_display(AVPicture *pic)
{
	memcpy( image, pic->data[0], pic->linesize[0] * d_image_height );
	return 0;
}

static int directx_init(void)
{
	RECT rd;
	vo_fs = 0;
	image_format = PIX_FMT_BGR32;
	d_image_width = image_width = dlpctxp->pwidth;
	d_image_height = image_height = dlpctxp->pheight;

	if ( image_format != primary_image_format )
		nooverlay = 0;
	window_aspect= (float)d_image_width / (float)d_image_height;

	/*release all directx objects*/
	if (g_cc != NULL)
		g_cc->lpVtbl->Release(g_cc);
	g_cc=NULL;
	if (g_lpddclipper)
		g_lpddclipper->lpVtbl->Release(g_lpddclipper);
	g_lpddclipper=NULL;
	if (g_lpddsBack != NULL)
		g_lpddsBack->lpVtbl->Release(g_lpddsBack);
	g_lpddsBack = NULL;
	if (vo_doublebuffering)
		if (g_lpddsOverlay != NULL)
			g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
	g_lpddsOverlay = NULL;
	if (g_lpddsPrimary != NULL)
		g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
	g_lpddsPrimary = NULL;

	GetWindowRect(hWnd,&rd);
	vo_dx=rd.left;
	vo_dy=rd.top;

	vo_dx += monitor_rect.left; /* move position to global window space */
	vo_dy += monitor_rect.top;
	rd.left = vo_dx;
	rd.top = vo_dy;
	rd.right = rd.left + d_image_width;
	rd.bottom = rd.top + d_image_height;
	SetWindowPos(hWnd,NULL, vo_dx, vo_dy,rd.right-rd.left,rd.bottom-rd.top,SWP_SHOWWINDOW|SWP_NOOWNERZORDER);

	if (vo_fs )
		ShowWindow(hWndFS,SW_SHOW);

	SetWindowText( hWnd, vo_title );

	/*create the surfaces*/
	if ( Directx_CreatePrimarySurface() )
		return -1;

	//create palette for 256 color mode
	if ( image_format == PIX_FMT_BGR8 )
	{
		LPDIRECTDRAWPALETTE ddpalette=NULL;
		char* palette=malloc(4*256);
		int i;
		for (i=0; i<256; i++)
		{
			palette[4*i+0] = ((i >> 5) & 0x07) * 255 / 7;
			palette[4*i+1] = ((i >> 2) & 0x07) * 255 / 7;
			palette[4*i+2] = ((i >> 0) & 0x03) * 255 / 3;
			palette[4*i+3] = PC_NOCOLLAPSE;
		}
		g_lpdd->lpVtbl->CreatePalette(g_lpdd,DDPCAPS_8BIT|DDPCAPS_INITIALIZE,palette,&ddpalette,NULL);
		g_lpddsPrimary->lpVtbl->SetPalette(g_lpddsPrimary,ddpalette);
		free(palette);
		ddpalette->lpVtbl->Release(ddpalette);
	}

	if (!nooverlay && Directx_CreateOverlay(image_format))
	{
		if (image_format == primary_image_format)
			nooverlay = 1; /*overlay creation failed*/
		else
		{
			return -1;
		}
	}
	if (nooverlay)
	{
		if (Directx_CreateBackpuffer())
		{
			return -1;
		}
		vo_doublebuffering = 0;
		/*create clipper for nonoverlay mode*/
		if (g_lpdd->lpVtbl->CreateClipper(g_lpdd, 0, &g_lpddclipper,NULL)!= DD_OK)
		{
			return -1;
		}
		if (g_lpddclipper->lpVtbl->SetHWnd (g_lpddclipper, 0, hWnd)!= DD_OK)
		{
			return -1;
		}
		if (g_lpddsPrimary->lpVtbl->SetClipper (g_lpddsPrimary,g_lpddclipper)!=DD_OK)
		{
			return -1;
		}
	}
	else
	{
		if (DD_OK != g_lpddsOverlay->lpVtbl->QueryInterface(g_lpddsOverlay,&IID_IDirectDrawColorControl,(void**)&g_cc))
			av_log(NULL, AV_LOG_INFO,"<vo_directx><WARN>unable to get DirectDraw ColorControl interface\n");
	}
	Directx_ManageDisplay();
	memset(&ddsdsf, 0,sizeof(DDSURFACEDESC2));
	ddsdsf.dwSize = sizeof (DDSURFACEDESC2);
	if (g_lpddsBack->lpVtbl->Lock(g_lpddsBack,NULL,&ddsdsf, DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL) == DD_OK)
	{
		dstride = ddsdsf.lPitch;
		image = ddsdsf.lpSurface;
		return 0;
	}
	av_log(NULL, AV_LOG_INFO, "vo_directx: Initial Lock on the Surface failed.\n");
	return -1;
}

vo_t vo_directx =
{
	.id = VO_ID_DIRECTX,
	.name = "directx",
	.vo_init = directx_init,
	.vo_uninit = directx_uninit,
	.vo_display = directx_display,
	.vo_event_loop = NULL,
};

#endif /* ENABLE_VO_DIRECTX */