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

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

Windows CE

开发平台：

C/C++

ge2d.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: ge2d.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.  * Big thanks to Mobile Stream (http://www.mobile-stream.com)
  23.  * for reverse enginerring the GE2D interface
  24.  *
  25.  ****************************************************************************/
  27. #include "../common/common.h"
  29. #if defined(TARGET_PALMOS)
  31. #include "../common/palmos/pace.h"
  33. #if defined(_M_IX86)
  34. //#define GE2DEMU
  35. #endif
  37. #define GE2D_ID FOURCC('G','E','2','D')
  39. #define sonyGE2DLibType 'aexo'
  40. #define sonyGE2DLibCreator 'SeGE'
  42. enum {
  43. sonyGE2DFormatYCbCr422 = 1,
  44. sonyGE2DFormatYCbCr422Planar,
  45. sonyGE2DFormatYCbCr420Planar
  46. };
  48. #define sonyGE2DBlitPixelCoord 0x2
  50. typedef UInt32 GE2DInsnType;
  52. typedef struct GE2DBitmapType
  53. {
  54. UInt8 format; /* 0x00 */
  55. UInt8 zero; /* 0x01 */
  56. UInt16 pitch; /* 0x02 */
  57. UInt16 chromaPitch;/* 0x04 */
  58. UInt16 width; /* 0x06 */
  59. UInt16 height; /* 0x08 */
  60. UInt16 unused; /* 0x0a */
  61. void * plane1P; /* 0x0c: Y */
  62. void * plane2P; /* 0x10: Cb */
  63. void * plane3P; /* 0x14: Cr */
  65. } GE2DBitmapType;
  67. typedef struct GE2DLibAPIType
  68. {
  69. Err (*GE2DLibOpen)();
  70. Err (*GE2DLibClose)();
  71. Err (*GE2DProgramBlit)(GE2DInsnType *,
  72. void *, UInt16,
  73. const void *, UInt16,
  74. UInt16, UInt16, UInt8);
  75. Err (*GE2DBlitWithAlpha)(void *, UInt16,
  76. const void *, UInt16,
  77. UInt16, UInt16, UInt8);
  78. Err (*GE2DBlit)(void *dstBitsP, UInt16 dstPitch,
  79. const void *srcBitsP, UInt16 srcPitch,
  80. UInt16 srcWidth, UInt16 srcHeight, UInt8 ff);
  81. Err (*GE2DBlitWithMask)(void *dstBitsP, UInt16 dstPitch,
  82. const void *srcBitsP, UInt16 srcPitch,
  83. UInt16 srcWidth, UInt16 srcHeight,
  84. UInt8 ff, const void *maskBitsP);
  85. Err (*GE2DBlitBitmap)(void *dstP, Coord left, Coord top,
  86. UInt16 dstWidth, UInt16 dstHeight, GE2DBitmapType *);
  87. Err (*GE2DConvertBitmap)(GE2DBitmapType *, GE2DBitmapType *);
  88. Err (*GE2DProgramBlitBitmapWithMask)(GE2DInsnType *programP,
  89. void *dstP, Coord left, Coord top,
  90. UInt16 dstWidth, UInt16 dstHeight,
  91. GE2DBitmapType *bmpP, const void *p7);
  92. Err (*GE2DProgramBlitBitmap)(GE2DInsnType *programP,
  93. void *dstP, Coord left, Coord top,
  94. UInt16 dstWidth, UInt16 dstHeight, GE2DBitmapType *bmpP);
  95. Err (*GE2DScaleBitmap)(GE2DBitmapType *dstBmpP, GE2DBitmapType *srcBmpP);
  96. Err (*GE2DShowOverlay)(Coord left, Coord top, GE2DBitmapType *);
  97. Err (*GE2DHideOverlay)();
  98. Err (*GE2DRunProgram)(const GE2DInsnType *programP);
  99. Err (*GE2DRunProgram2)(const GE2DInsnType *programP);
  100. Err (*GE2D_60)(UInt16 x, UInt16 y);
  101. Err (*GE2D_64)();
  102. Err (*GE2D_68)(void *);
  103. Err (*GE2D_72)(RectangleType *);
  104. Err (*GE2D_76)(FormType *);
  105. Err (*GE2D_80)(Boolean);
  106. Err (*GE2D_84)();
  107. Err (*GE2DSetLock)(Boolean lock);
  109. } GE2DLibAPIType;
  111. typedef struct ge2d
  112. {
  113. overlay p;
  114. point Offset;
  115. GE2DBitmapType Buffer;
  116. GE2DBitmapType Scale;
  117. int BufferSize;
  118. int ScaleSize;
  119. rect OverlayRect;
  120. blitfx SoftFX;
  121. char* Bits;
  123. } ge2d;
  125. static UInt32 LibRef = 0;
  127. #if defined(GE2DEMU)
  128. #include "ge2demu.c"
  129. #else
  130. static GE2DLibAPIType API;
  131. #endif
  133. extern char* QueryScreen(video* Video,int* Offset,int* Mode);
  135. static void FreeBuffer(GE2DBitmapType* p,int* Allocated)
  136. {
  137. free(p->plane1P);
  138. free(p->plane2P);
  139. free(p->plane3P);
  140. memset(p,0,sizeof(GE2DBitmapType));
  141. *Allocated = 0;
  142. }
  144. static bool_t AllocBuffer(GE2DBitmapType* p,int w,int h,int* Allocated)
  145. {
  146. int size;
  147. w = (w+1) & ~1;
  148. h = (h+1) & ~1;
  149. size = w*h;
  151. p->format = sonyGE2DFormatYCbCr420Planar;
  152. p->zero = 0;
  153. p->pitch = (UInt16)w;
  154. p->chromaPitch = (UInt16)(w >> 1);
  155. p->width = (UInt16)w;
  156. p->height = (UInt16)h;
  157. p->unused = 0;
  159. if (*Allocated < size)
  160. {
  161. free(p->plane1P);
  162. free(p->plane2P);
  163. free(p->plane3P);
  164. p->plane1P = malloc(size);
  165. p->plane2P = malloc(size/4);
  166. p->plane3P = malloc(size/4);
  167. if (!p->plane1P || !p->plane2P || !p->plane3P)
  168. {
  169. FreeBuffer(p,Allocated);
  170. return 0;
  171. }
  172. *Allocated = size;
  173. }
  175. memset(p->plane1P,0,size);
  176. memset(p->plane2P,128,size/4);
  177. memset(p->plane2P,128,size/4);
  178. return 1;
  179. }
  181. static int GetMode(ge2d* p)
  182. {
  183. int Offset;
  184. p->Bits = QueryScreen(&p->p.Output.Format.Video,&Offset,NULL);
  186. if (!p->p.Output.Format.Video.Pitch || !p->p.Output.Format.Video.Pixel.BitCount)
  187. return ERR_INVALID_PARAM;
  189. p->Offset.x = (Offset % p->p.Output.Format.Video.Pitch) / (p->p.Output.Format.Video.Pixel.BitCount/8);
  190. p->Offset.y = Offset / p->p.Output.Format.Video.Pitch;
  192. return ERR_NONE;
  193. }
  195. static int Init(ge2d* p)
  196. {
  197. //p->p.SetFX = BLITFX_AVOIDTEARING;
  198. p->p.Overlay = 0;
  200. if (GetMode(p) != ERR_NONE)
  201. return ERR_INVALID_PARAM;
  203. if (!AllocBuffer(&p->Buffer,p->p.Input.Format.Video.Width,p->p.Input.Format.Video.Height,&p->BufferSize))
  204. return ERR_OUT_OF_MEMORY;
  206. return ERR_NONE;
  207. }
  209. static void Done(ge2d* p)
  210. {
  211. FreeBuffer(&p->Buffer,&p->BufferSize);
  212. FreeBuffer(&p->Scale,&p->ScaleSize);
  213. }
  215. static int UpdateOverlay(ge2d* p)
  216. {
  217. if (p->p.Overlay)
  218. {
  219. if (p->p.Show)
  220. {
  221. int x = p->p.DstAlignedRect.x;
  222. int y = p->p.DstAlignedRect.y;
  224. x += p->Offset.x;
  225. y += p->Offset.y;
  227. PALMCALL3(API.GE2DShowOverlay,(Coord)x,(Coord)y,p->Scale.format? &p->Scale : &p->Buffer);
  228. }
  229. else
  230. PALMCALL0(API.GE2DHideOverlay);
  231. }
  232. return ERR_NONE;
  233. }
  235. static int Update(ge2d* p)
  236. {
  237. blitfx OvlFX = p->p.FX;
  238. video Buffer;
  240. if (p->p.Overlay)
  241. PALMCALL0(API.GE2DHideOverlay);
  243. p->SoftFX = p->p.FX;
  244. p->SoftFX.ScaleX = SCALE_ONE; // scale handled by hardware
  245. p->SoftFX.ScaleY = SCALE_ONE;
  246. OvlFX.Direction = 0;
  248. //align to 100%
  249. if (OvlFX.ScaleX > SCALE_ONE-(SCALE_ONE/16) && OvlFX.ScaleX < SCALE_ONE+(SCALE_ONE/16) &&
  250. OvlFX.ScaleY > SCALE_ONE-(SCALE_ONE/16) && OvlFX.ScaleY < SCALE_ONE+(SCALE_ONE/16))
  251. {
  252. OvlFX.ScaleX = SCALE_ONE;
  253. OvlFX.ScaleY = SCALE_ONE;
  254. }
  256. if (p->SoftFX.Direction & DIR_SWAPXY)
  257. SwapInt(&OvlFX.ScaleX,&OvlFX.ScaleY);
  259. memset(&Buffer,0,sizeof(Buffer));
  260. Buffer.Pixel.Flags = PF_YUV420;
  261. Buffer.Width = p->p.Input.Format.Video.Width;
  262. Buffer.Height = p->p.Input.Format.Video.Height;
  263. Buffer.Direction = CombineDir(p->p.InputDirection,p->p.OrigFX.Direction,p->p.Output.Format.Video.Direction);
  264. if (Buffer.Direction & DIR_SWAPXY)
  265. SwapInt(&Buffer.Width,&Buffer.Height);
  266. Buffer.Pitch = Buffer.Width;
  268. for (;;)
  269. {
  270. VirtToPhy(&p->p.Viewport,&p->p.DstAlignedRect,&p->p.Output.Format.Video);
  271. VirtToPhy(NULL,&p->OverlayRect,&Buffer);
  273. AnyAlign(&p->p.DstAlignedRect, &p->OverlayRect, &OvlFX, 2, 1, SCALE_ONE/256, SCALE_ONE*256);
  275. if ((OvlFX.ScaleX != SCALE_ONE || OvlFX.ScaleY != SCALE_ONE) && 
  276. (p->p.DstAlignedRect.Width != p->OverlayRect.Width && p->p.DstAlignedRect.Height != p->OverlayRect.Height))
  277. {
  278. if (!AllocBuffer(&p->Scale,p->p.DstAlignedRect.Width,p->p.DstAlignedRect.Height,&p->ScaleSize))
  279. {
  280. // fallback to 100%
  281. OvlFX.ScaleX = SCALE_ONE;
  282. OvlFX.ScaleY = SCALE_ONE;
  283. continue;
  284. }
  285. }
  286. else
  287. FreeBuffer(&p->Scale,&p->ScaleSize);
  288. break;
  289. }
  291. VirtToPhy(NULL,&p->p.SrcAlignedRect,&p->p.Input.Format.Video);
  293. BlitRelease(p->p.Soft);
  294. p->p.Soft = BlitCreate(&Buffer,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  295. BlitAlign(p->p.Soft,&p->OverlayRect,&p->p.SrcAlignedRect);
  297. if (!AllocBuffer(&p->Buffer,p->OverlayRect.Width,p->OverlayRect.Height,&p->BufferSize))
  298. return ERR_OUT_OF_MEMORY;
  300. Buffer.Width = p->OverlayRect.Width;
  301. Buffer.Height = p->OverlayRect.Height;
  302. Buffer.Pitch = Buffer.Width;
  303. p->OverlayRect.x = 0;
  304. p->OverlayRect.y = 0;
  306. BlitRelease(p->p.Soft);
  307. p->p.Soft = BlitCreate(&Buffer,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  308. BlitAlign(p->p.Soft,&p->OverlayRect,&p->p.SrcAlignedRect);
  310. if (!p->Scale.format) // no scaling -> adjust dst rectangle with soft yuv blitting alignement
  311. {
  312. p->p.DstAlignedRect.x += (p->p.DstAlignedRect.Width - p->OverlayRect.Width) >> 1;
  313. p->p.DstAlignedRect.y += (p->p.DstAlignedRect.Height - p->OverlayRect.Height) >> 1;
  314. p->p.DstAlignedRect.Width = p->OverlayRect.Width;
  315. p->p.DstAlignedRect.Height = p->OverlayRect.Height;
  316. }
  317. PhyToVirt(&p->p.DstAlignedRect,&p->p.GUIAlignedRect,&p->p.Output.Format.Video);
  319. return UpdateOverlay(p);
  320. }
  322. static INLINE void FlushDCache(void *p, int n)
  323. {
  324. SonyCleanDCache(p,n);
  325. SonyInvalidateDCache(p,n);
  326. }
  328. static int Blit(ge2d* p, const constplanes Data, const constplanes DataLast )
  329. {
  330. int n;
  331. planes Planes;
  333. Planes[0] = p->Buffer.plane1P;
  334. Planes[1] = p->Buffer.plane3P;
  335. Planes[2] = p->Buffer.plane2P;
  336. BlitImage(p->p.Soft,Planes,Data,DataLast,-1,-1);
  338. n = p->Buffer.width * p->Buffer.height;
  339. FlushDCache(Planes[0],n);
  340. FlushDCache(Planes[1],n/4);
  341. FlushDCache(Planes[2],n/4);
  343. if (p->Scale.format)
  344. PALMCALL2(API.GE2DScaleBitmap,&p->Scale,&p->Buffer);
  346. if (!p->p.Overlay)
  347. {
  348. PALMCALL6(API.GE2DBlitBitmap,p->Bits,
  349. (Coord)(p->p.DstAlignedRect.x + p->Offset.x),
  350. (Coord)(p->p.DstAlignedRect.y + p->Offset.y),
  351. (Coord)(p->p.Output.Format.Video.Pitch>>1),(Coord)p->p.Output.Format.Video.Height,
  352. p->Scale.format? &p->Scale : &p->Buffer);
  353. }
  355. return ERR_NONE;
  356. }
  358. static int Reset(ge2d* p)
  359. {
  360. return GetMode(p);
  361. }
  363. static int Create(ge2d* p)
  364. {
  365. p->p.Init = (ovlfunc)Init;
  366. p->p.Done = (ovldone)Done;
  367. p->p.Reset = (ovlfunc)Reset;
  368. p->p.Blit = (ovlblit)Blit;
  369. p->p.Update = (ovlfunc)Update;
  370. p->p.UpdateShow = (ovlfunc)UpdateOverlay;
  372. QueryDesktop(&p->p.Output.Format.Video);
  373. return ERR_NONE;
  374. }
  376. static const nodedef GE2D = 
  377. {
  378. sizeof(ge2d)|CF_GLOBAL,
  379. GE2D_ID,
  380. OVERLAY_CLASS,
  381. PRI_DEFAULT+50,
  382. (nodecreate)Create,
  383. };
  385. void GE2D_Init() 
  386. {
  387. #if !defined(GE2DEMU)
  388. Err err;
  390. // UInt32 CompanyID;
  391. // FtrGet(sysFtrCreator, sysFtrNumOEMCompanyID, &CompanyID);
  392. // if (CompanyID != 'sony')
  393. // return;
  395. err = SysFindModule(sonyGE2DLibType, sonyGE2DLibCreator, 0, 0, &LibRef);
  396. if (err) 
  397. err = SysLoadModule(sonyGE2DLibType, sonyGE2DLibCreator, 0, 0, &LibRef);
  398. if (err)
  399. return;
  401. if (SysGetEntryAddresses(LibRef, 0, 22, (void **)(void *)&API) != errNone)
  402. return;
  404. #endif
  406. PALMCALL0(API.GE2DLibOpen);
  407. NodeRegisterClass(&GE2D);
  408. }
  410. void GE2D_Done() 
  411. {
  412. NodeUnRegisterClass(GE2D_ID);
  413. if (LibRef)
  414. {
  415. PALMCALL0(API.GE2DLibClose);
  416. //SysUnloadModule(LibRef);
  417. LibRef = 0;
  418. }
  419. }
  421. #else
  422. void GE2D_Init() {}
  423. void GE2D_Done() {}
  424. #endif