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

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

Windows CE

开发平台：

C/C++

overlay_console.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_ddraw.c 276 2005-08-23 14:47:32Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #if defined(TARGET_WIN32)
  28. #define WIN32_LEAN_AND_MEAN
  29. #ifndef STRICT
  30. #define STRICT
  31. #endif
  32. #include <windows.h>
  34. #if defined(TARGET_WINCE)
  35. #define TWIN(a) L ## a
  36. #else
  37. #define TWIN(a) a
  38. #endif
  40. typedef struct palitem
  41. {
  42. char ch;
  43. uint8_t col;
  44. uint8_t y[4];
  45. uint8_t u;
  46. uint8_t v;
  47. uint8_t rgb[4][3];
  49. } palitem;
  51. #define MAPCOUNT 29
  52. //#define MAPCOUNT 14
  54. typedef struct console
  55. {
  56. overlay Overlay;
  57. planes Planes;
  58. planes Dither;
  59. HANDLE Handle;
  60. HANDLE Buffer;
  61. HMODULE Kernel;
  62. CHAR_INFO *Char;
  63. int16_t Width,Height;
  64. bool_t Own;
  65. HWND (WINAPI* GetConsoleWindow)();
  66. BOOL (WINAPI* SetConsoleOutputCP)(UINT);
  67. palitem** Map;
  68. palitem Pal[256*MAPCOUNT];
  70. } console;
  72. #define SAT(Value) (Value < 0 ? 0: (Value > 255 ? 255: Value))
  73. #define SATY(Value) (Value < 16 ? 16: (Value > 255 ? 255: Value))
  75. static const uint8_t Pal[16*4] = 
  76. {
  77. 0,0,0,0,
  78. 0,0,128,0,
  79. 0,128,0,0,
  80. 0,128,128,0,
  81. 128,0,0,0,
  82. 128,0,128,0,
  83. 128,128,0,0,
  84. 192,192,192,0,
  85. 128,128,128,0,
  86. 0,0,255,0,
  87. 0,255,0,0,
  88. 0,255,255,0,
  89. 255,0,0,0,
  90. 255,0,255,0,
  91. 255,255,0,0,
  92. 255,255,255,0,
  93. };
  95. static const char Map[MAPCOUNT*5] = 
  96. {
  97. ' ',0,0,0,0,
  98. '.',0,0,3,3,
  99. ',',0,0,4,4,
  100. ':',3,3,3,3,
  101. ';',3,3,4,4,
  102. '=',5,5,5,5,
  103. '~',5,5,0,0,
  104. '/',0,10,10,0,
  105. '\',10,0,0,10,
  106. ')',6,2,6,2,
  107. '(',2,6,2,6,
  108. '#',12,12,12,12,
  109. '262',15,15,15,15,
  110. '261',9,9,9,9,
  111. '260',2,2,2,2,
  112. 't',5,5,3,5,
  113. 'f',5,3,5,5,
  114. '%',4,6,4,6,
  115. '$',8,8,8,8,
  116. '&',8,8,8,10,
  117. 'K',11,9,11,9,
  118. 'S',10,10,10,10,
  119. 'Z',8,10,10,8,
  120. 'W',8,8,10,10,
  121. 'M',10,10,8,8,
  122. 'X',11,11,11,11,
  123. 'Y',11,11,6,6,
  124. 'G',10,10,10,12,
  125. '8',11,11,11,11,
  126. };
  128. static INLINE void ToRGB(uint8_t* p,int y,int u,int v)
  129. {
  130. int r,g,b;
  131. y -= 16;
  132. u -= 128;
  133. v -= 128;
  134. r = (y*0x2568             + 0x3343*v) /0x2000;
  135. g = (y*0x2568 - 0x0c92*u  - 0x1a1e*v) /0x2000;
  136. b = (y*0x2568 + 0x40cf*u)             /0x2000;
  137. p[0] = (uint8_t)(SAT(r));
  138. p[1] = (uint8_t)(SAT(g));
  139. p[2] = (uint8_t)(SAT(b));
  140. }
  142. static palitem* GetMap(console* p,int y0,int y1,int y2,int y3,int u,int v)
  143. {
  144. palitem** q;
  145. q = &p->Map[(y0>>5)*8*8*8*16*16+
  146.      (y1>>5)*8*8*16*16+
  147.      (y2>>5)*8*16*16+
  148.      (y3>>5)*16*16+
  149.      (u>>4)*16+(v>>4)];
  151. if (*q==NULL)
  152. {
  153. //find best
  154. palitem* Best = NULL;
  155. int BestDiff = MAX_INT;
  156. palitem* Pal = p->Pal;
  157. uint8_t RGB[4][3];
  158. int i;
  160. y0 &= ~31;
  161. y1 &= ~31;
  162. y2 &= ~31;
  163. y3 &= ~31;
  164. u &= ~15;
  165. v &= ~15;
  167. ToRGB(RGB[0],y0,u,v);
  168. ToRGB(RGB[1],y1,u,v);
  169. ToRGB(RGB[2],y2,u,v);
  170. ToRGB(RGB[3],y3,u,v);
  172. for (i=0;i<MAPCOUNT*256;++i,++Pal)
  173. {
  174. int Diff;
  175. #if defined(_MSC_VER) && defined(_M_IX86)
  176. uint16_t Diff2[2];
  177. __asm
  178. {
  179. mov eax,Pal
  180. pxor mm0,mm0
  182. movq mm2,[RGB]
  183. movd mm4,[RGB+8]
  184. movq mm3,mm2
  185. punpcklbw mm2,mm0
  186. punpckhbw mm3,mm0
  187. punpcklbw mm4,mm0
  189. movq mm5,[eax+8]
  190. movd mm7,[eax+8+8]
  191. movq mm6,mm5
  192. punpcklbw mm5,mm0
  193. punpckhbw mm6,mm0
  194. punpcklbw mm7,mm0
  196. psubw mm2,mm5
  197. psubw mm3,mm6
  198. psubw mm4,mm7
  199. pxor mm5,mm5
  200. pxor mm6,mm6
  201. pxor mm7,mm7
  202. pcmpgtw mm5,mm2
  203. pcmpgtw mm6,mm3
  204. pcmpgtw mm7,mm4
  205. pxor mm2,mm5
  206. pxor mm3,mm6
  207. pxor mm4,mm7
  208. paddw mm2,mm5
  209. paddw mm3,mm6
  210. paddw mm4,mm7
  212. paddw mm2,mm3
  213. paddw mm2,mm4
  214. movq mm0,mm2
  215. psrl mm0,32
  216. paddw mm0,mm2
  217. movd Diff2,mm0
  218. };
  219. Diff = Diff2[0] + Diff2[1];
  220. #else
  221. Diff = 
  222. abs(RGB[0][0] - Pal->rgb[0][0]) + 
  223. abs(RGB[0][1] - Pal->rgb[0][1]) + 
  224. abs(RGB[0][2] - Pal->rgb[0][2]);
  226. if (Diff >= BestDiff) continue;
  227. Diff +=
  228. abs(RGB[1][0] - Pal->rgb[1][0]) + 
  229. abs(RGB[1][1] - Pal->rgb[1][1]) + 
  230. abs(RGB[1][2] - Pal->rgb[1][2]);
  232. if (Diff >= BestDiff) continue;
  233. Diff +=
  234. abs(RGB[2][0] - Pal->rgb[2][0]) + 
  235. abs(RGB[2][1] - Pal->rgb[2][1]) + 
  236. abs(RGB[2][2] - Pal->rgb[2][2]);
  238. if (Diff >= BestDiff) continue;
  239. Diff +=
  240. abs(RGB[3][0] - Pal->rgb[3][0]) + 
  241. abs(RGB[3][1] - Pal->rgb[3][1]) + 
  242. abs(RGB[3][2] - Pal->rgb[3][1]);
  243. #endif
  245. if (Diff < BestDiff)
  246. {
  247. BestDiff = Diff;
  248. Best = Pal;
  249. }
  250. }
  252. #if defined(_MSC_VER) && defined(_M_IX86)
  253. __asm { emms };
  254. #endif
  255. *q = Best;
  256. }
  257. return *q;
  258. }
  260. static int Init(console* p)
  261. {
  262. int i,j,k,l;
  263. palitem* w;
  265. if (!p->Map)
  266. {
  267. p->Map = (palitem**) malloc(8*8*8*8*16*16*sizeof(palitem*));
  268. if (!p->Map)
  269. return ERR_OUT_OF_MEMORY;
  270. memset(p->Map,0,8*8*8*8*16*16*sizeof(palitem*));
  271. }
  273. if (SurfaceAlloc(p->Planes,&p->Overlay.Output.Format.Video)!=ERR_NONE)
  274. return ERR_OUT_OF_MEMORY;
  276. if (SurfaceAlloc(p->Dither,&p->Overlay.Output.Format.Video)!=ERR_NONE)
  277. return ERR_OUT_OF_MEMORY;
  279. memset(p->Planes[0],0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height);
  280. memset(p->Planes[1],128,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height/4);
  281. memset(p->Planes[2],128,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height/4);
  283. memset(p->Dither[0],0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height);
  284. memset(p->Dither[1],0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height/4);
  285. memset(p->Dither[2],0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height/4);
  287. p->Kernel = LoadLibrary(T("kernel32.dll"));
  288. *(FARPROC*)&p->GetConsoleWindow = GetProcAddress(p->Kernel,TWIN("GetConsoleWindow"));
  289. *(FARPROC*)&p->SetConsoleOutputCP = GetProcAddress(p->Kernel,TWIN("SetConsoleOutputCP"));
  291. p->Handle = INVALID_HANDLE_VALUE;
  292. p->Width = (int16_t)(p->Overlay.Output.Format.Video.Width/2);
  293. p->Height = (int16_t)(p->Overlay.Output.Format.Video.Height/2);
  294. p->Char = malloc(sizeof(CHAR_INFO)*p->Width*p->Height);
  295. if (!p->Char)
  296. return ERR_OUT_OF_MEMORY;
  298. w = p->Pal;
  299. for (i=0;i<16;++i)
  300. for (j=0;j<16;++j)
  301. for (k=0;k<MAPCOUNT;++k,++w)
  302. {
  303. int r,g,b,t;
  304. const char* ch = &Map[k*5];
  306. w->ch = ch[0];
  307. w->col = (uint8_t)(i*16+j);
  309. ++ch;
  310. for (l=0;l<4;++l,++ch)
  311. {
  312. w->rgb[l][0] = (uint8_t)((Pal[i*4+0]*(32-ch[0])+Pal[j*4+0]*ch[0])>>5);
  313. w->rgb[l][1] = (uint8_t)((Pal[i*4+1]*(32-ch[0])+Pal[j*4+1]*ch[0])>>5);
  314. w->rgb[l][2] = (uint8_t)((Pal[i*4+2]*(32-ch[0])+Pal[j*4+2]*ch[0])>>5);
  315. }
  317. r = (w->rgb[0][0]+w->rgb[1][0]+w->rgb[2][0]+w->rgb[3][0])/4;
  318. g = (w->rgb[0][1]+w->rgb[1][1]+w->rgb[2][1]+w->rgb[3][1])/4;
  319. b = (w->rgb[0][2]+w->rgb[1][2]+w->rgb[2][2]+w->rgb[3][2])/4;
  321. t = (-(1212 * r) - (2384 * g) + (3596 * b))/0x2000 + 128;
  322. w->u = (uint8_t)(SAT(t));
  324. t = ((3596 * r) - (3015 * g) - (582 * b))/0x2000 + 128;
  325. w->v = (uint8_t)(SAT(t));
  327. t = ((2105 * w->rgb[0][0]) + (4128 * w->rgb[0][1]) + (802 * w->rgb[0][2]))/0x2000 + 16;
  328. w->y[0] = (uint8_t)(SATY(t));
  330. t = ((2105 * w->rgb[1][0]) + (4128 * w->rgb[1][1]) + (802 * w->rgb[1][2]))/0x2000 + 16;
  331. w->y[1] = (uint8_t)(SATY(t));
  333. t = ((2105 * w->rgb[2][0]) + (4128 * w->rgb[2][1]) + (802 * w->rgb[2][2]))/0x2000 + 16;
  334. w->y[2] = (uint8_t)(SATY(t));
  336. t = ((2105 * w->rgb[3][0]) + (4128 * w->rgb[3][1]) + (802 * w->rgb[3][2]))/0x2000 + 16;
  337. w->y[3] = (uint8_t)(SATY(t));
  338. }
  340. p->Overlay.ClearFX = BLITFX_ONLYDIFF;
  341. return ERR_NONE;
  342. }
  344. static void Done(console* p)
  345. {
  346. SurfaceFree(p->Planes); 
  347. SurfaceFree(p->Dither);
  348. FreeLibrary(p->Kernel);
  349. free(p->Char);
  350. p->Char = NULL;
  351. }
  353. static void Delete(console* p)
  354. {
  355. free(p->Map);
  356. p->Map = NULL;
  357. }
  359. static int UpdateShow(console* p)
  360. {
  361. CONSOLE_CURSOR_INFO Info;
  363. if (p->Overlay.Show)
  364. {
  365. COORD Size;
  366. p->Own = AllocConsole() != FALSE;
  368.         p->Handle = CreateFile(T("CONOUT$"), GENERIC_READ | GENERIC_WRITE,
  369.                                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
  370.                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  371. if (p->Handle == INVALID_HANDLE_VALUE)
  372. return ERR_NOT_SUPPORTED;
  374. p->Buffer = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,0,NULL,CONSOLE_TEXTMODE_BUFFER,NULL);
  375. if (p->Buffer == INVALID_HANDLE_VALUE)
  376. return ERR_NOT_SUPPORTED;
  378. Size.X = p->Width;
  379. Size.Y = p->Height;
  380. SetConsoleScreenBufferSize(p->Buffer,Size);
  382. GetConsoleCursorInfo(p->Buffer, &Info);
  383. Info.bVisible = FALSE;
  384. SetConsoleCursorInfo(p->Buffer, &Info);
  386. SetConsoleMode(p->Buffer, 0);
  387. SetConsoleActiveScreenBuffer(p->Buffer);
  389. if (p->SetConsoleOutputCP)
  390. p->SetConsoleOutputCP(850);
  392. if (p->GetConsoleWindow)
  393. SetWindowPos(p->GetConsoleWindow(),HWND_TOP,0,0,1024,1024,SWP_NOMOVE|SWP_SHOWWINDOW);
  394. }
  395. else
  396. {
  397. if (p->Handle != INVALID_HANDLE_VALUE)
  398. {
  399. SetConsoleActiveScreenBuffer(p->Handle);
  401. CloseHandle(p->Buffer);
  402. CloseHandle(p->Handle);
  404. if (p->Own)
  405. FreeConsole();
  406. }
  407. }
  408. return ERR_NONE;
  409. }
  411. static int Lock(console* p, planes Planes, bool_t OnlyAligned )
  412. {
  413. Planes[0] = p->Planes[0];
  414. return ERR_NONE;
  415. }
  417. static int Unlock(console* p )
  418. {
  419. return ERR_NONE;
  420. }
  422. static int Blit(console* p, const constplanes Data, const constplanes DataLast )
  423. {
  424. if (p->Handle != INVALID_HANDLE_VALUE)
  425. {
  426. COORD Pos,Size;
  427. SMALL_RECT Rect;
  428. int n,Row;
  429. CHAR_INFO *Char;
  430. uint8_t *y,*u,*v;
  431. int8_t *y2,*u2,*v2;
  432. int dy[4],du,dv,PalY;
  434. BlitImage(p->Overlay.Soft,p->Planes,Data,DataLast,-1,-1);
  436. y = p->Planes[0];
  437. u = p->Planes[1];
  438. v = p->Planes[2];
  440. y2 = p->Dither[0];
  441. u2 = p->Dither[1];
  442. v2 = p->Dither[2];
  444. if (p->Overlay.Dirty)
  445. {
  446. memset(y2,0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height);
  447. memset(u2,0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height/4);
  448. memset(v2,0,p->Overlay.Output.Format.Video.Pitch*p->Overlay.Output.Format.Video.Height/4);
  449. }
  451. Char = p->Char;
  452. Row = 0;
  453. dy[0] = dy[1] = dy[2] = dy[3] = du = dv = 0;
  455. for (n = p->Width*p->Height;--n>=0;++Char)
  456. {
  457. int Pitch = p->Overlay.Output.Format.Video.Pitch;
  458. palitem* Pal;
  460. dy[0] += y[0] + y2[0];
  461. dy[1] += y[1] + y2[1];
  462. dy[2] += y[Pitch+0] + y2[Pitch+0];
  463. dy[3] += y[Pitch+1] + y2[Pitch+1];
  464. du += u[0] + u2[0];
  465. dv += v[0] + v2[0];
  467. dy[0] = SATY(dy[0]);
  468. dy[1] = SATY(dy[1]);
  469. dy[2] = SATY(dy[2]);
  470. dy[3] = SATY(dy[3]);
  471. du = SAT(du);
  472. dv = SAT(dv);
  474. Pal = GetMap(p,dy[0],dy[1],dy[2],dy[3],du,dv);
  476. y2[0] = (int8_t)((dy[0]-Pal->y[0])>>1);
  477. y2[1] = (int8_t)((dy[1]-Pal->y[1])>>1);
  478. y2[Pitch+0] = (int8_t)((dy[2]-Pal->y[2])>>1);
  479. y2[Pitch+1] = (int8_t)((dy[3]-Pal->y[3])>>1);
  481. PalY = Pal->y[0]+Pal->y[1]+Pal->y[2]+Pal->y[3];
  482. dy[0] = dy[1] = dy[2] = dy[3] = (dy[0]+dy[1]+dy[2]+dy[3]-PalY)/8;
  483. du = (du - Pal->u) >> 1;
  484. dv = (dv - Pal->v) >> 1;
  485. if (PalY < 48*4)
  486. {
  487. du /= 2;
  488. dv /= 2;
  490. if (PalY < 32*4)
  491. {
  492. du /= 4;
  493. dv /= 4;
  494. }
  495. }
  497. u2[0] = (int8_t)du;
  498. v2[0] = (int8_t)dv;
  500. Char->Attributes = Pal->col;
  501. Char->Char.AsciiChar = Pal->ch;
  503. y += 2;
  504. ++u;
  505. ++v;
  507. y2 += 2;
  508. ++u2;
  509. ++v2;
  511. if (++Row == p->Width)
  512. {
  513. Row = 0;
  514. y += p->Overlay.Output.Format.Video.Pitch;
  515. y2 += p->Overlay.Output.Format.Video.Pitch;
  516. }
  517. }
  519. Size.X = p->Width;
  520. Size.Y = p->Height;
  521. Pos.X = 0;
  522. Pos.Y = 0;
  523. Rect.Left = 0;
  524. Rect.Top = 0;
  525. Rect.Right = (int16_t)(p->Width-1);
  526. Rect.Bottom = (int16_t)(p->Height-1);
  527. WriteConsoleOutput(p->Buffer, p->Char, Size, Pos, &Rect);
  528. }
  529. return ERR_NONE;
  530. }
  532. static int Create(console* p)
  533. {
  534. p->Overlay.Primary = 0;
  535. p->Overlay.Output.Format.Video.Width = 80*2;
  536. p->Overlay.Output.Format.Video.Height = 50*2;
  537. p->Overlay.Output.Format.Video.Direction = 0;
  538. p->Overlay.Output.Format.Video.Aspect = ASPECT_ONE;
  539. p->Overlay.Output.Format.Video.Pitch = p->Overlay.Output.Format.Video.Width;
  540. p->Overlay.Output.Format.Video.Pixel.Flags = PF_YUV420|PF_16ALIGNED;
  541. FillInfo(&p->Overlay.Output.Format.Video.Pixel);
  542. p->Overlay.Init = Init;
  543. p->Overlay.Done = Done;
  544. p->Overlay.Blit = Blit;
  545. p->Overlay.UpdateShow = UpdateShow;
  546. p->Overlay.Lock = Lock;
  547. p->Overlay.Unlock = Unlock;
  548. return ERR_NONE;
  549. }
  551. static const nodedef Console = 
  552. {
  553. sizeof(console)|CF_GLOBAL,
  554. CONSOLE_ID,
  555. OVERLAY_CLASS,
  556. PRI_DEFAULT-15,
  557. (nodecreate)Create,
  558. (nodedelete)Delete,
  559. };
  561. void OverlayConsole_Init() 
  562. { 
  563. NodeRegisterClass(&Console);
  564. }
  566. void OverlayConsole_Done()
  567. {
  568. NodeUnRegisterClass(CONSOLE_ID);
  569. }
  571. #endif