开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
overlay_gapi.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：13k
源码类别：

Windows CE

开发平台：

C/C++

overlay_gapi.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: overlay_gapi.c 543 2006-01-07 22:06:24Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #ifdef TARGET_WINCE
  28. #define WIN32_LEAN_AND_MEAN
  29. #ifndef STRICT
  30. #define STRICT
  31. #endif
  32. #include <windows.h>
  34. typedef struct GXDisplayProperties 
  35. {
  36. int cxWidth;
  37. int cyHeight;
  38. int cbxPitch;
  39. int cbyPitch;
  40. int cBPP;
  41. int ffFormat;
  42. } GXDisplayProperties;
  44. #define SHFS_SHOWTASKBAR            0x0001
  45. #define SHFS_HIDETASKBAR            0x0002
  46. #define SHFS_SHOWSIPBUTTON          0x0004
  47. #define SHFS_HIDESIPBUTTON          0x0008
  48. #define SHFS_SHOWSTARTICON          0x0010
  49. #define SHFS_HIDESTARTICON          0x0020
  51. #define GX_FULLSCREEN 0x01
  52. #define kfLandscape 0x08
  53. #define kfPalette 0x10
  54. #define kfDirect 0x20
  55. #define kfDirect555 0x40
  56. #define kfDirect565 0x80
  57. #define kfDirect888 0x100
  58. #define kfDirect444 0x200
  59. #define kfDirectInverted 0x400
  61. typedef struct gapi
  62. {
  63. overlay Overlay;
  65. bool_t Windows;
  66. bool_t Opened;
  67. bool_t DRAM;
  68. void* Wnd;
  69. int AdjustPtr;
  70. uint8_t* DirectPtr;
  71. uint8_t* Pointer;
  72. HMODULE GX;
  73. HMODULE AygShell;
  74. GXDisplayProperties Info;
  76. int (*GXOpenDisplay)(HWND hWnd, DWORD dwFlags);
  77. int (*GXCloseDisplay)();
  78. void* (*GXBeginDraw)();
  79. int (*GXEndDraw)();
  80. GXDisplayProperties (*GXGetDisplayProperties)();
  81. int (*GXSetViewport)(DWORD dwTop, DWORD dwHeight, DWORD, DWORD);
  82. BOOL (*GXIsDisplayDRAMBuffer)();
  83. BOOL (WINAPI* SHFullScreen)(HWND, DWORD);
  85. } gapi;
  87. static const datatable Params[] = 
  88. {
  89. { GAPI_WIDTH, TYPE_INT, DF_SETUP | DF_RDONLY | DF_HIDDEN },
  90. { GAPI_HEIGHT, TYPE_INT, DF_SETUP | DF_RDONLY | DF_HIDDEN },
  91. { GAPI_PITCHX, TYPE_INT, DF_SETUP | DF_RDONLY | DF_HIDDEN },
  92. { GAPI_PITCHY, TYPE_INT, DF_SETUP | DF_RDONLY | DF_HIDDEN },
  93. { GAPI_BPP, TYPE_INT, DF_SETUP | DF_RDONLY | DF_HIDDEN },
  94. { GAPI_FORMAT, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX | DF_HIDDEN },
  95. { GAPI_DRAM, TYPE_BOOL, DF_SETUP | DF_RDONLY | DF_HIDDEN },
  96. { GAPI_POINTER, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX | DF_HIDDEN },
  98. DATATABLE_END(GAPI_ID)
  99. };
  101. static int Enum(gapi* p, int* No, datadef* Param)
  102. {
  103. if (OverlayEnum(&p->Overlay,No,Param)==ERR_NONE)
  104. return ERR_NONE;
  105. return NodeEnumTable(No,Param,Params);
  106. }
  108. static int Get(gapi* p,int No,void* Data,int Size)
  109. {
  110. int Result = OverlayGet(&p->Overlay,No,Data,Size);
  111. switch (No)
  112. {
  113. case GAPI_WIDTH: GETVALUE(p->Info.cxWidth,int); break;
  114. case GAPI_HEIGHT: GETVALUE(p->Info.cyHeight,int); break;
  115. case GAPI_PITCHX: GETVALUE(p->Info.cbxPitch,int); break;
  116. case GAPI_PITCHY: GETVALUE(p->Info.cbyPitch,int); break;
  117. case GAPI_BPP: GETVALUE(p->Info.cBPP,int); break;
  118. case GAPI_FORMAT: GETVALUE(p->Info.ffFormat,int); break;
  119. case GAPI_DRAM: GETVALUE(p->DRAM,bool_t); break;
  120. case GAPI_POINTER: GETVALUE((int)p->Pointer,int); break;
  121. }
  122. return Result;
  123. }
  125. static bool_t LoadDriver(gapi* p)
  126. {
  127. HMODULE GX;
  128. tchar_t Path[MAXPATH];
  130. if (p->Windows)
  131. GetSystemPath(Path,TSIZEOF(Path),T("gx.dll"));
  132. else
  133. tcscpy_s(Path,TSIZEOF(Path),T("gx.dll"));
  135. if ((GX = LoadLibrary(Path))==NULL)
  136. {
  137. if (!p->Windows)
  138. {
  139. p->Windows = 1;
  140. return LoadDriver(p);
  141. }
  142. return 0;
  143. }
  145. if (p->GX)
  146. FreeLibrary(p->GX);
  147. p->GX = GX;
  149. GetProc(&p->GX,&p->GXOpenDisplay,T("?GXOpenDisplay@@YAHPAUHWND__@@K@Z"),0);
  150. GetProc(&p->GX,&p->GXCloseDisplay,T("?GXCloseDisplay@@YAHXZ"),0);
  151. GetProc(&p->GX,&p->GXBeginDraw,T("?GXBeginDraw@@YAPAXXZ"),0);
  152. GetProc(&p->GX,&p->GXEndDraw,T("?GXEndDraw@@YAHXZ"),0);
  153. GetProc(&p->GX,&p->GXGetDisplayProperties,T("?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ"),0);
  154. GetProc(&p->GX,&p->GXSetViewport,T("?GXSetViewport@@YAHKKKK@Z"),1);
  155. GetProc(&p->GX,&p->GXIsDisplayDRAMBuffer,T("?GXIsDisplayDRAMBuffer@@YAHXZ"),1);
  157. return p->GX!=NULL;
  158. }
  160. static int Init(gapi* p)
  161. {
  162. GXDisplayProperties Info;
  163. video GDI;
  164. int Caps = QueryPlatform(PLATFORM_CAPS);
  166. if (!p->Opened)
  167. {
  168. ShowError(p->Overlay.Node.Class,GAPI_ID,GAPI_OPEN_ERROR);
  169. return ERR_NOT_SUPPORTED; // don't show device error
  170. }
  172. Info = p->Info;
  174. if (Info.cxWidth == GetSystemMetrics(SM_CXSCREEN) &&
  175. Info.cyHeight < GetSystemMetrics(SM_CYSCREEN))
  176. {
  177. // HPC devices we need the taskbar counted in the height too
  178. RECT WorkArea;
  179. SystemParametersInfo(SPI_GETWORKAREA,0,&WorkArea,0);
  180. if (WorkArea.top == 0 && WorkArea.bottom == Info.cyHeight)
  181. Info.cyHeight = GetSystemMetrics(SM_CYSCREEN);
  182. }
  184. p->Overlay.Output.Format.Video.Direction = 0;
  185. p->Overlay.Output.Format.Video.Aspect = ASPECT_ONE;
  187. if (Info.ffFormat & kfPalette)
  188. {
  189. QueryDesktop(&GDI);
  190. p->Overlay.Output.Format.Video.Pixel.Flags = PF_PALETTE;
  191. p->Overlay.Output.Format.Video.Pixel.BitCount = Info.cBPP;
  192. p->Overlay.Output.Format.Video.Pixel.Palette = GDI.Pixel.Palette;
  193. }
  194. else
  195. if (Info.ffFormat & kfDirect444)
  196. DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,Info.cBPP,4,4,4,0,0,0);
  197. else
  198. if (Info.ffFormat & kfDirect565)
  199. {
  200. if (Caps & CAPS_ONLY12BITRGB)
  201. DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,Info.cBPP,4,4,4,1,2,1);
  202. else
  203. DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,Info.cBPP,5,6,5,0,0,0);
  204. }
  205. else
  206. if (Info.ffFormat & kfDirect555)
  207. DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,Info.cBPP,5,5,5,0,0,0);
  208. else
  209. if (Info.ffFormat & kfDirect888)
  210. DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,Info.cBPP,8,8,8,0,0,0);
  212. if (Info.ffFormat & kfDirectInverted)
  213. p->Overlay.Output.Format.Video.Pixel.Flags |= PF_INVERTED;
  215. // get signed x/y pitches in bits
  216. Info.cbxPitch <<= 3;
  217. Info.cbyPitch <<= 3;
  219. // one pitch is probably zero when BPP<8
  220. if (!Info.cbxPitch) 
  221. if (Info.cbyPitch < 0)
  222. Info.cbxPitch = -Info.cBPP;
  223. else
  224. Info.cbxPitch = Info.cBPP;
  225. else
  226. if (!Info.cbyPitch)
  227. if (Info.cbxPitch < 0)
  228. Info.cbyPitch = Info.cBPP;
  229. else
  230. Info.cbyPitch = -Info.cBPP;
  232. // one of the pitches absolute value must be BPP
  233. if (abs(Info.cbyPitch) < abs(Info.cbxPitch))
  234. {
  235. if (abs(Info.cbxPitch) < Info.cyHeight*Info.cBPP &&
  236. abs(Info.cbxPitch) >= Info.cxWidth*Info.cBPP) //swapped gapi resolution
  237. SwapInt(&Info.cxWidth,&Info.cyHeight);
  239. Info.ffFormat |= kfLandscape;
  240. Info.cbyPitch = Info.cbyPitch<0 ? -Info.cBPP : Info.cBPP;
  241. }
  242. else
  243. {
  244. if (abs(Info.cbyPitch) < Info.cxWidth*Info.cBPP &&
  245. abs(Info.cbyPitch) >= Info.cyHeight*Info.cBPP) //swapped gapi resolution
  246. SwapInt(&Info.cxWidth,&Info.cyHeight);
  248. Info.ffFormat &= ~kfLandscape;
  249. Info.cbxPitch = Info.cbxPitch<0 ? -Info.cBPP : Info.cBPP;
  250. }
  252. p->Overlay.Output.Format.Video.Width = Info.cxWidth;
  253. p->Overlay.Output.Format.Video.Height = Info.cyHeight;
  255. // we need the physical start of the framebuffer
  256. p->AdjustPtr = 0;
  257. if (Info.cbxPitch<0) 
  258. p->AdjustPtr += (Info.cbxPitch * (Info.cxWidth-1)) >> 3;
  259. if (Info.cbyPitch<0) 
  260. p->AdjustPtr += (Info.cbyPitch * (Info.cyHeight-1)) >> 3;
  262. if (Info.ffFormat & kfLandscape)
  263. {
  264. p->Overlay.Output.Format.Video.Direction |= DIR_SWAPXY;
  265. p->Overlay.Output.Format.Video.Pitch = abs(Info.cbxPitch) >> 3;
  266. SwapInt(&p->Overlay.Output.Format.Video.Width,&p->Overlay.Output.Format.Video.Height);
  268. if (Info.cbxPitch<0) 
  269. p->Overlay.Output.Format.Video.Direction |= DIR_MIRRORUPDOWN;
  270. if (Info.cbyPitch<0) 
  271. p->Overlay.Output.Format.Video.Direction |= DIR_MIRRORLEFTRIGHT;
  272. }
  273. else
  274. {
  275. p->Overlay.Output.Format.Video.Pitch = abs(Info.cbyPitch) >> 3;
  277. if (Info.cbxPitch<0) 
  278. p->Overlay.Output.Format.Video.Direction |= DIR_MIRRORLEFTRIGHT;
  279. if (Info.cbyPitch<0) 
  280. p->Overlay.Output.Format.Video.Direction |= DIR_MIRRORUPDOWN;
  281. }
  283. if (!p->DRAM)
  284. {
  285. p->Overlay.SetFX = BLITFX_AVOIDTEARING;
  287. if ((Info.cxWidth > Info.cyHeight) && (Caps & CAPS_PORTRAIT))
  288. p->Overlay.SetFX |= BLITFX_VMEMROTATED;
  290. if ((Info.cyHeight > Info.cxWidth) && (Caps & CAPS_LANDSCAPE))
  291. p->Overlay.SetFX |= BLITFX_VMEMROTATED;
  292. }
  293. else
  294. p->Overlay.ClearFX = BLITFX_ONLYDIFF;
  296. // wm2003se gapi emulation?
  297. if (QueryPlatform(PLATFORM_VER) >= 421)
  298. {
  299. if (p->Overlay.Output.Format.Video.Width == 240 && p->Overlay.Output.Format.Video.Height == 320 && p->Overlay.Output.Format.Video.Pitch == 640)
  300. p->Overlay.Output.Format.Video.Pitch = 480;
  301. }
  303. if (Info.cxWidth == 240 && Info.cyHeight == 320)
  304. AdjustOrientation(&p->Overlay.Output.Format.Video,0);
  306. return ERR_NONE;
  307. }
  309. static void Done(gapi* p)
  310. {
  311. }
  313. static int Reset(gapi* p)
  314. {
  315. Done(p);
  316. Init(p);
  317. return ERR_NONE;
  318. }
  320. static int Lock(gapi* p, planes Planes, bool_t OnlyAligned)
  321. {
  322. if (!p->Opened)
  323. return ERR_INVALID_PARAM;
  325. if (p->DirectPtr)
  326. p->Pointer = p->DirectPtr + p->AdjustPtr;
  327. else
  328. {
  329. if (p->DRAM && p->GXSetViewport)
  330. {
  331. int Top,Height;
  332. if (OnlyAligned)
  333. {
  334. Top = p->Overlay.GUIAlignedRect.y;
  335. Height = p->Overlay.GUIAlignedRect.Height;
  336. }
  337. else
  338. {
  339. Top = p->Overlay.Viewport.y;
  340. Height = p->Overlay.Viewport.Height;
  341. }
  343. if (p->Overlay.Output.Format.Video.Pixel.Flags & PF_PIXELDOUBLE)
  344. {
  345. Top >>= 1;
  346. Height >>= 1;
  347. }
  349. p->GXSetViewport(Top,Height,0,0); // coords in windows space
  350. }
  352. p->Pointer = (uint8_t*)p->GXBeginDraw();
  353. if (!p->Pointer)
  354. return ERR_NOT_SUPPORTED;
  356. p->Pointer += p->AdjustPtr;
  357. }
  359. Planes[0] = p->Pointer;
  360. return ERR_NONE;
  361. }
  363. static int Unlock(gapi* p)
  364. {
  365. if (!p->DirectPtr)
  366. p->GXEndDraw();
  367. return ERR_NONE;
  368. }
  370. static int UpdateWnd(gapi* p)
  371. {
  372. void* Wnd = Context()->Wnd;
  373. if (p->Wnd != Wnd)
  374. {
  375. p->Wnd = Wnd;
  376. if (p->Wnd && !p->Opened)
  377. {
  378. HWND WndTask;
  380. while (!p->GX || !p->GXOpenDisplay(p->Wnd,GX_FULLSCREEN))
  381. {
  382. if (!p->Windows)
  383. {
  384. p->Windows = 1; // try gx.dll in windows directory (HPC with .NET)
  385. if (LoadDriver(p))
  386. continue;
  387. }
  388. return ERR_NOT_SUPPORTED;
  389. }
  391. // just in case GXOpenDisplay hides these things
  392. if (p->SHFullScreen)
  393. {
  394. p->SHFullScreen(p->Wnd,SHFS_SHOWSTARTICON);
  395. p->SHFullScreen(p->Wnd,SHFS_SHOWTASKBAR);
  396. }
  398. WndTask = FindWindow(T("HHTaskbar"),NULL);
  399. if (WndTask)
  400. ShowWindow(WndTask,SW_SHOWNA);
  402. p->Info = p->GXGetDisplayProperties();
  403. if (!p->Info.cxWidth || !p->Info.cyHeight) // this shouldn't happen
  404. {
  405. p->GXCloseDisplay();
  406. return ERR_DEVICE_ERROR;
  407. }
  409. p->DirectPtr = NULL;
  410. p->Opened = 1;
  411. p->DRAM = 0;
  413. if (p->GXIsDisplayDRAMBuffer)
  414. p->DRAM = p->GXIsDisplayDRAMBuffer() != 0;
  416. // detect fake DRAM
  417. if (p->DRAM && !(p->Info.ffFormat & kfLandscape) && QueryPlatform(PLATFORM_MODEL)==MODEL_SPV_C500_ORIGROM)
  418. {
  419. p->GXSetViewport(0,0,0,0);
  420. p->DirectPtr = p->GXBeginDraw();
  421. }
  423. if (QueryPlatform(PLATFORM_VER) >= 421)
  424. IsOrientationChanged(); // force requery of orientation (GXOpenDisplay changes to portrait)
  426. Init(p); // we need the output format
  427. }
  428. else
  429. if (p->Opened && !p->Wnd && !p->DirectPtr)
  430. {
  431. p->GXCloseDisplay();
  432. p->Opened = 0;
  433. }
  434. }
  435. return ERR_NONE;
  436. }
  438. static int Set(gapi* p,int No,const void* Data,int Size)
  439. {
  440. int Result = OverlaySet(&p->Overlay,No,Data,Size);
  441. switch (No)
  442. {
  443. case NODE_SETTINGSCHANGED: 
  444. Result = UpdateWnd(p);
  445. break;
  446. }
  447. return Result;
  448. }
  450. static int Create(gapi* p)
  451. {
  452. if (NodeEnumObject(NULL,RAW_ID))
  453. return ERR_NOT_SUPPORTED;
  455. p->Overlay.Node.Enum = Enum;
  456. p->Overlay.Node.Get = Get;
  457. p->Overlay.Node.Set = Set;
  458. p->Overlay.Lock = Lock;
  459. p->Overlay.Unlock = Unlock;
  460. p->Overlay.Init = Init;
  461. p->Overlay.Done = Done;
  462. p->Overlay.Reset = Reset;
  463. p->Overlay.Node.Get = Get;
  464. p->Overlay.Node.Enum = Enum;
  466. if (!LoadDriver(p))
  467. return ERR_NOT_SUPPORTED;
  469. p->AygShell = LoadLibrary(T("aygshell.dll"));
  470. GetProc(&p->AygShell,&p->SHFullScreen,T("SHFullScreen"),1);
  471. return ERR_NONE;
  472. }
  474. static void Delete(gapi* p)
  475. {
  476. if (p->GX)
  477. FreeLibrary(p->GX);
  478. if (p->AygShell)
  479. FreeLibrary(p->AygShell);
  480. }
  482. static const nodedef GAPI =
  483. {
  484. sizeof(gapi)|CF_GLOBAL,
  485. GAPI_ID,
  486. OVERLAY_CLASS,
  487. PRI_DEFAULT+50,
  488. (nodecreate)Create,
  489. (nodedelete)Delete,
  490. };
  492. void OverlayGAPI_Init() 
  493. { 
  494. NodeRegisterClass(&GAPI);
  495. }
  497. void OverlayGAPI_Done()
  498. {
  499. NodeUnRegisterClass(GAPI_ID);
  500. }
  502. #endif