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

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

Windows CE

开发平台：

C/C++

helper_video.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: helper_video.c 548 2006-01-08 22:41:57Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  26. bool_t EqSubtitle(const subtitle* a, const subtitle* b)
  27. {
  28. return a->FourCC == b->FourCC;
  29. }
  31. bool_t EqAudio(const audio* a, const audio* b)
  32. {
  33. return a->Bits == b->Bits &&
  34.    a->Channels == b->Channels &&
  35.    a->SampleRate == b->SampleRate &&
  36.    a->FracBits == b->FracBits &&
  37.    a->Flags == b->Flags &&
  38.    a->Format == b->Format;
  39. }
  41. bool_t EqFrac(const fraction* a, const fraction* b)
  42. {
  43. if (a->Den == b->Den && a->Num == b->Num) 
  44. return 1;
  45. if (!a->Den) return b->Den==0;
  46. if (!b->Den) return 0;
  47. return (int64_t)b->Den * a->Num == (int64_t)a->Den * b->Num;
  48. }
  50. int BitMaskSize(uint32_t Mask)
  51. {
  52. int i;
  53. for (i=0;Mask;++i)
  54. Mask &= Mask - 1;
  55. return i;
  56. }
  58. int BitMaskPos(uint32_t Mask)
  59. {
  60. int i;
  61. for (i=0;Mask && !(Mask&1);++i) 
  62. Mask >>= 1;
  63. return i;
  64. }
  66. int ScaleRound(int v,int Num,int Den)
  67. {
  68. int64_t i;
  69. if (!Den) 
  70. return 0;
  71. i = (int64_t)v * Num;
  72. if (i<0)
  73. i-=Den/2;
  74. else
  75. i+=Den/2;
  76. i/=Den;
  77. return (int)i;
  78. }
  80. void FillColor(uint8_t* Dst,int DstPitch,int x,int y,int Width,int Height,int BPP,int Value)
  81. {
  82. if (Width>0 && Height>0)
  83. {
  84. uint16_t *p16,*p16e;
  85. uint32_t *p32,*p32e;
  86. uint8_t* End;
  88. Dst += y*DstPitch + (x*BPP)/8;
  89. End = Dst + Height * DstPitch;
  90. do
  91. {
  92. switch (BPP)
  93. {
  94. case 1:
  95. Value &= 1;
  96. memset(Dst,Value * 0xFF,Width >> 3);
  97. break;
  98. case 2:
  99. Value &= 3;
  100. memset(Dst,Value * 0x55,Width >> 2);
  101. break;
  102. case 4:
  103. Value &= 15;
  104. memset(Dst,Value * 0x11,Width >> 1);
  105. break;
  106. case 8:
  107. memset(Dst,Value,Width);
  108. break;
  109. case 16:
  110. p16 = (uint16_t*)Dst;
  111. p16e = p16+Width;
  112. for (;p16!=p16e;++p16)
  113. *p16 = (uint16_t)Value;
  114. break;
  115. case 32:
  116. p32 = (uint32_t*)Dst;
  117. p32e = p32+Width;
  118. for (;p32!=p32e;++p32)
  119. *p32 = Value;
  120. break;
  121. }
  122. Dst += DstPitch;
  123. }
  124. while (Dst != End);
  125. }
  126. }
  128. bool_t EqBlitFX(const blitfx* a, const blitfx* b)
  129. {
  130. return a->Flags == b->Flags &&
  131.    a->Contrast == b->Contrast &&
  132.    a->Saturation == b->Saturation &&
  133.    a->Brightness == b->Brightness &&
  134.    a->Direction == b->Direction &&
  135.    a->RGBAdjust[0] == b->RGBAdjust[0] &&
  136.    a->RGBAdjust[1] == b->RGBAdjust[1] &&
  137.    a->RGBAdjust[2] == b->RGBAdjust[2] &&
  138.    a->ScaleX == b->ScaleX &&
  139.    a->ScaleY == b->ScaleY;
  140. }
  142. int CombineDir(int Src, int Blit, int Dst)
  143. {
  144. //order of transformations 
  145. //  SrcMirror
  146. //  SrcSwap
  147. //  BlitSwap
  148. //  BlitMirror
  149. //  DstSwap
  150. //  DstMirror
  152. //should be combined to a single
  153. //  Swap
  154. //  Mirror
  156. if (Dst & DIR_SWAPXY)
  157. {
  158. if (Blit & DIR_MIRRORLEFTRIGHT)
  159. Dst ^= DIR_MIRRORUPDOWN;
  160. if (Blit & DIR_MIRRORUPDOWN)
  161. Dst ^= DIR_MIRRORLEFTRIGHT;
  162. }
  163. else
  164. Dst ^= Blit & (DIR_MIRRORUPDOWN|DIR_MIRRORLEFTRIGHT);
  165. Dst ^= Blit & DIR_SWAPXY;
  166. Dst ^= Src & DIR_SWAPXY;
  167. if (Dst & DIR_SWAPXY)
  168. {
  169. if (Src & DIR_MIRRORLEFTRIGHT)
  170. Dst ^= DIR_MIRRORUPDOWN;
  171. if (Src & DIR_MIRRORUPDOWN)
  172. Dst ^= DIR_MIRRORLEFTRIGHT;
  173. }
  174. else
  175. Dst ^= Src & (DIR_MIRRORUPDOWN|DIR_MIRRORLEFTRIGHT);
  177. return Dst;
  178. }
  180. int SurfaceRotate(const video* SrcFormat, const video* DstFormat, 
  181.   const planes Src, planes Dst, int Dir)
  182. {
  183. blitfx FX;
  184. memset(&FX,0,sizeof(FX));
  185. FX.ScaleX = SCALE_ONE;
  186. FX.ScaleY = SCALE_ONE;
  187. FX.Direction = Dir;
  188. return SurfaceCopy(SrcFormat,DstFormat,Src,Dst,&FX);
  189. }
  192. int SurfaceCopy(const video* SrcFormat, const video* DstFormat, 
  193. const planes Src, planes Dst, const blitfx* FX)
  194. {
  195. void* Blit;
  196. rect SrcRect;
  197. rect DstRect;
  199. VirtToPhy(NULL,&SrcRect,SrcFormat);
  200. VirtToPhy(NULL,&DstRect,DstFormat);
  202. Blit = BlitCreate(DstFormat,SrcFormat,FX,NULL);
  203. if (!Blit)
  204. return ERR_NOT_SUPPORTED;
  206. BlitAlign(Blit,&DstRect,&SrcRect);
  207. BlitImage(Blit,Dst,*(const constplanes*)Src,NULL,-1,-1);
  208. BlitRelease(Blit);
  210. return ERR_NONE;
  211. }
  213. int SurfaceAlloc(planes Ptr, const video* p)
  214. {
  215. int i;
  216. for (i=0;i<MAXPLANES;++i)
  217. Ptr[i] = NULL;
  219. if (p->Pixel.Flags & (PF_YUV420|PF_YUV422|PF_YUV444|PF_YUV410))
  220. {
  221. int x,y,s;
  222. PlanarYUV(&p->Pixel,&x,&y,&s);
  223. Ptr[0] = Alloc16(p->Height * p->Pitch);
  224. Ptr[1] = Alloc16((p->Height>>y) * (p->Pitch>>s));
  225. Ptr[2] = Alloc16((p->Height>>y) * (p->Pitch>>s));
  226. if (!Ptr[0] || !Ptr[1] || !Ptr[2])
  227. {
  228. SurfaceFree(Ptr);
  229. return ERR_OUT_OF_MEMORY;
  230. }
  231. return ERR_NONE;
  232. }
  233. Ptr[0] = Alloc16(GetImageSize(p));
  234. return Ptr[0] ? ERR_NONE : ERR_OUT_OF_MEMORY;
  235. }
  237. void SurfaceFree(planes p)
  238. {
  239. int i;
  240. for (i=0;i<MAXPLANES;++i)
  241. {
  242. Free16(p[i]);
  243. p[i] = NULL;
  244. }
  245. }
  247. int DefaultAspect(int Width,int Height)
  248. {
  249. return ASPECT_ONE; //todo?
  250. }
  252. void DefaultPitch(video* p)
  253. {
  254. p->Pitch = p->Width*GetBPP(&p->Pixel);
  255. if (p->Pixel.Flags & PF_RGB) 
  256. p->Pitch = ((p->Pitch+31)>>5)*4; // dword align
  257. else 
  258. p->Pitch = (p->Pitch+7)>>3; // byte align
  259. }
  261. void DefaultRGB(pixel* p, int BitCount, 
  262.          int RBits, int GBits, int BBits,
  263.  int RGaps, int GGaps, int BGaps)
  264. {
  265. p->Flags = PF_RGB;
  266. p->BitCount = BitCount;
  267. p->BitMask[0] = ((1<<RBits)-1) << (RGaps+GBits+GGaps+BBits+BGaps);
  268. p->BitMask[1] = ((1<<GBits)-1) << (GGaps+BBits+BGaps);
  269. p->BitMask[2] = ((1<<BBits)-1) << (BGaps);
  270. }
  272. bool_t Compressed(const pixel* Fmt)
  273. {
  274. return (Fmt->Flags & PF_FOURCC) && !AnyYUV(Fmt);
  275. }
  277. bool_t PlanarYUV(const pixel* Fmt, int* x, int* y,int *s)
  278. {
  279. if (PlanarYUV420(Fmt))
  280. {
  281. if (x) *x = 1;
  282. if (y) *y = 1;
  283. if (s)
  284. {
  285. if (Fmt->Flags & PF_FOURCC &&
  286. ((Fmt->FourCC == FOURCC_IMC2) || (Fmt->FourCC == FOURCC_IMC4)))
  287. *s = 0; // interleaved uv scanlines
  288. else
  289. *s = 1;
  290. }
  291. return 1;
  293. }
  294. if (PlanarYUV422(Fmt))
  295. {
  296. if (x) *x = 1;
  297. if (s) *s = 1;
  298. if (y) *y = 0;
  299. return 1;
  301. }
  302. if (PlanarYUV444(Fmt))
  303. {
  304. if (x) *x = 0;
  305. if (y) *y = 0;
  306. if (s) *s = 0;
  307. return 1;
  308. }
  309. if (PlanarYUV410(Fmt))
  310. {
  311. if (x) *x = 2;
  312. if (s) *s = 2;
  313. if (y) *y = 2;
  314. return 1;
  316. }
  318. if (x) *x = 0;
  319. if (y) *y = 0;
  320. if (s) *s = 0;
  321. return 0;
  322. }
  324. typedef struct rgbfourcc
  325. {
  326. uint32_t FourCC;
  327. int BitCount;
  328. uint32_t BitMask[3];
  330. } rgbfourcc;
  332. static const rgbfourcc RGBFourCC[] =
  333. {
  334. { FOURCC_RGB32, 32, { 0xFF0000, 0xFF00, 0xFF }},
  335. { FOURCC_RGB24, 24, { 0xFF0000, 0xFF00, 0xFF }},
  336. { FOURCC_RGB16, 16, { 0xF800, 0x07E0, 0x001F }},
  337. { FOURCC_RGB15, 16, { 0x7C00, 0x03E0, 0x001F }},
  338. { FOURCC_BGR32, 32, { 0xFF, 0xFF00, 0xFF0000 }},
  339. { FOURCC_BGR24, 24, { 0xFF, 0xFF00, 0xFF0000 }},
  340. { FOURCC_BGR16, 16, { 0x001F, 0x07E0, 0xF800 }},
  341. { FOURCC_BGR15, 16, { 0x001F, 0x03E0, 0x7C00 }},
  342. {0},
  343. };
  345. uint32_t DefFourCC(const pixel* Fmt)
  346. {
  347. uint32_t FourCC=0;
  348. if (Fmt->Flags & PF_YUV420)
  349. return FOURCC_I420;
  350. if (Fmt->Flags & PF_YUV422)
  351. return FOURCC_YV16;
  352. if (Fmt->Flags & PF_YUV410)
  353. return FOURCC_YUV9;
  355. if (Fmt->Flags & PF_FOURCC)
  356. {
  357. FourCC = Fmt->FourCC;
  358. if (FourCC == FOURCC_YVU9)
  359. FourCC = FOURCC_YUV9;
  360. if (FourCC == FOURCC_IYUV || FourCC == FOURCC_YV12)
  361. FourCC = FOURCC_I420;
  362. if (FourCC == FOURCC_YUNV || FourCC == FOURCC_V422 || FourCC == FOURCC_YUYV)
  363. FourCC = FOURCC_YUY2;
  364. if (FourCC == FOURCC_Y422 || FourCC == FOURCC_UYNV)
  365. FourCC = FOURCC_UYVY;
  366. }
  367. else
  368. if (Fmt->Flags & PF_RGB)
  369. {
  370. const rgbfourcc *i;
  371. for (i=RGBFourCC;i->FourCC;++i)
  372. if (i->BitCount == Fmt->BitCount &&
  373. i->BitMask[0] == Fmt->BitMask[0] &&
  374. i->BitMask[1] == Fmt->BitMask[1] &&
  375. i->BitMask[2] == Fmt->BitMask[2])
  376. {
  377. FourCC = i->FourCC;
  378. break;
  379. }
  380. }
  381. return FourCC;
  382. }
  384. bool_t PlanarYUV420(const pixel* Fmt)
  385. {
  386. if (Fmt->Flags & PF_YUV420)
  387. return 1;
  389. return (Fmt->Flags & PF_FOURCC) && 
  390.      ((Fmt->FourCC == FOURCC_YV12) ||
  391.    (Fmt->FourCC == FOURCC_IYUV) ||
  392.    (Fmt->FourCC == FOURCC_I420) ||
  393.    (Fmt->FourCC == FOURCC_IMC2) ||
  394.    (Fmt->FourCC == FOURCC_IMC4));
  395. }
  397. bool_t PlanarYUV410(const pixel* Fmt)
  398. {
  399. if (Fmt->Flags & PF_YUV410)
  400. return 1;
  402. return (Fmt->Flags & PF_FOURCC) && 
  403.      ((Fmt->FourCC == FOURCC_YVU9) ||
  404.    (Fmt->FourCC == FOURCC_YUV9));
  405. }
  407. bool_t PlanarYUV422(const pixel* Fmt)
  408. {
  409. if (Fmt->Flags & PF_YUV422)
  410. return 1;
  412. return (Fmt->Flags & PF_FOURCC) && (Fmt->FourCC == FOURCC_YV16);
  413. }
  415. bool_t PlanarYUV444(const pixel* Fmt)
  416. {
  417. return (Fmt->Flags & PF_YUV444) != 0;
  418. }
  420. bool_t PackedYUV(const pixel* Fmt)
  421. {
  422. return (Fmt->Flags & PF_FOURCC) && 
  424.   ((Fmt->FourCC == FOURCC_YUY2) ||
  425.    (Fmt->FourCC == FOURCC_YUNV) ||
  426.    (Fmt->FourCC == FOURCC_V422) ||
  427.       (Fmt->FourCC == FOURCC_YUYV) ||
  428.    (Fmt->FourCC == FOURCC_VYUY) ||
  429.    (Fmt->FourCC == FOURCC_UYVY) ||
  430.    (Fmt->FourCC == FOURCC_Y422) ||
  431.    (Fmt->FourCC == FOURCC_YVYU) ||
  432.    (Fmt->FourCC == FOURCC_UYNV));
  433. }
  435. bool_t AnyYUV(const pixel* Fmt)
  436. {
  437. return PlanarYUV420(Fmt) || 
  438. PlanarYUV410(Fmt) || 
  439. PlanarYUV422(Fmt) || 
  440. PlanarYUV444(Fmt) || 
  441. PackedYUV(Fmt);
  442. }
  444. uint32_t RGBToFormat(rgbval_t RGB, const pixel* Fmt)
  445. {
  446. uint32_t v;
  447. int R,G,B;
  448. int Y,U,V;
  449. int Pos[3];
  451. R = (INT32LE(RGB) >> 0) & 255;
  452. G = (INT32LE(RGB) >> 8) & 255;
  453. B = (INT32LE(RGB) >> 16) & 255;
  455. if (AnyYUV(Fmt))
  456. {
  457. Y = ((2105 * R) + (4128 * G) + (802 * B))/0x2000 + 16;
  458. V = ((3596 * R) - (3015 * G) - (582 * B))/0x2000 + 128;
  459. U = (-(1212 * R) - (2384 * G) + (3596 * B))/0x2000 + 128;
  461. if (Fmt->Flags & PF_INVERTED)
  462. {
  463. Y ^= 255;
  464. U ^= 255;
  465. V ^= 255;
  466. }
  467. v =  (Fmt->BitMask[0] / 255) * Y;
  468. v += (Fmt->BitMask[1] / 255) * U;
  469. v += (Fmt->BitMask[2] / 255) * V;
  470. }
  471. else
  472. {
  473. if (Fmt->Flags & PF_INVERTED)
  474. {
  475. R ^= 255;
  476. G ^= 255;
  477. B ^= 255;
  478. }
  480. Pos[0] = BitMaskPos(Fmt->BitMask[0]) + BitMaskSize(Fmt->BitMask[0]);
  481. Pos[1] = BitMaskPos(Fmt->BitMask[1]) + BitMaskSize(Fmt->BitMask[1]);
  482. Pos[2] = BitMaskPos(Fmt->BitMask[2]) + BitMaskSize(Fmt->BitMask[2]);
  484. v = ((R << Pos[0]) & (Fmt->BitMask[0] << 8)) |
  485. ((G << Pos[1]) & (Fmt->BitMask[1] << 8)) |
  486. ((B << Pos[2]) & (Fmt->BitMask[2] << 8));
  487. v >>= 8;
  488. }
  490. return v;
  491. }
  493. void FillInfo(pixel* Fmt)
  494. {
  495. Fmt->BitCount = GetBPP(Fmt);
  496. if (PlanarYUV(Fmt,NULL,NULL,NULL))
  497. {
  498. if (Fmt->Flags & (PF_YUV420|PF_YUV422|PF_YUV444|PF_YUV410))
  499. {
  500. Fmt->BitMask[0] = 0x000000FF;
  501. Fmt->BitMask[1] = 0x0000FF00;
  502. Fmt->BitMask[2] = 0x00FF0000;
  503. }
  504. else
  505. switch (Fmt->FourCC)
  506. {
  507. case FOURCC_IMC4:
  508. case FOURCC_I420: 
  509. case FOURCC_IYUV:
  510. case FOURCC_YUV9:
  511. Fmt->BitMask[0] = 0x000000FF;
  512. Fmt->BitMask[1] = 0x0000FF00;
  513. Fmt->BitMask[2] = 0x00FF0000;
  514. break;
  515. case FOURCC_IMC2:
  516. case FOURCC_YV16:
  517. case FOURCC_YV12: 
  518. case FOURCC_YVU9:
  519. Fmt->BitMask[0] = 0x000000FF;
  520. Fmt->BitMask[1] = 0x00FF0000;
  521. Fmt->BitMask[2] = 0x0000FF00;
  522. break;
  523. }
  524. }
  525. else
  526. if (PackedYUV(Fmt))
  527. switch (Fmt->FourCC)
  528. {
  529. case FOURCC_YUY2:
  530. case FOURCC_YUNV:
  531. case FOURCC_V422:
  532. case FOURCC_YUYV:
  533. Fmt->BitMask[0] = 0x00FF00FF;
  534. Fmt->BitMask[1] = 0x0000FF00;
  535. Fmt->BitMask[2] = 0xFF000000;
  536. break;
  537. case FOURCC_YVYU:
  538. Fmt->BitMask[0] = 0x00FF00FF;
  539. Fmt->BitMask[1] = 0xFF000000;
  540. Fmt->BitMask[2] = 0x0000FF00;
  541. break;
  542. case FOURCC_UYVY:
  543. case FOURCC_Y422:
  544. case FOURCC_UYNV:
  545. Fmt->BitMask[0] = 0xFF00FF00;
  546. Fmt->BitMask[1] = 0x000000FF;
  547. Fmt->BitMask[2] = 0x00FF0000;
  548. break;
  549. }
  550. }
  552. int GetImageSize(const video* p)
  553. {
  554. int Size = p->Pitch * p->Height;
  555. if (PlanarYUV420(&p->Pixel))
  556. Size = (Size*3)/2; //1:0.25:0.25
  557. else
  558. if (PlanarYUV422(&p->Pixel))
  559. Size *= 2; //1:0.5:0.5
  560. else
  561. if (PlanarYUV444(&p->Pixel))
  562. Size *= 3; //1:1:1
  563. return Size;
  564. }
  566. int GetBPP(const pixel* Fmt)
  567. {
  568. if (Fmt->Flags & (PF_RGB | PF_PALETTE)) 
  569. return Fmt->BitCount;
  570. if (PlanarYUV(Fmt,NULL,NULL,NULL))
  571. return 8;
  572. if (PackedYUV(Fmt))
  573. return 16;
  574. return 0;
  575. }
  577. bool_t EqPoint(const point* a, const point* b)
  578. {
  579. return a->x==b->x && a->y==b->y;
  580. }
  582. bool_t EqRect(const rect* a, const rect* b)
  583. {
  584. return a->x==b->x && a->y==b->y && a->Width==b->Width && a->Height==b->Height;
  585. }
  587. bool_t EqPixel(const pixel* a, const pixel* b)
  588. {
  589. if (a->Flags != b->Flags) 
  590. return 0;
  592. if ((a->Flags & PF_PALETTE) &&
  593. a->BitCount != b->BitCount)
  594. return 0;
  596. if ((a->Flags & PF_RGB) &&
  597. (a->BitCount != b->BitCount ||
  598.  a->BitMask[0] != b->BitMask[0] ||
  599.  a->BitMask[1] != b->BitMask[1] ||
  600.  a->BitMask[2] != b->BitMask[2]))
  601. return 0;
  603. if ((a->Flags & PF_FOURCC) && a->FourCC != b->FourCC)
  604. return 0;
  606. return 1;
  607. }
  609. bool_t EqVideo(const video* a, const video* b)
  610. {
  611. // no direction check here!
  612. return a->Width == b->Width &&
  613.    a->Height == b->Height &&
  614.    a->Pitch == b->Pitch &&
  615.    EqPixel(&a->Pixel,&b->Pixel);
  616. }
  618. void ClipRectPhy(rect* Physical, const video* p)
  619. {
  620. if (Physical->x < 0)
  621. {
  622. Physical->Width += Physical->x;
  623. Physical->x = 0;
  624. }
  625. if (Physical->y < 0)
  626. {
  627. Physical->Height += Physical->y;
  628. Physical->y = 0;
  629. }
  630. if (Physical->x + Physical->Width > p->Width)
  631. {
  632. Physical->Width = p->Width - Physical->x;
  633. if (Physical->Width < 0)
  634. {
  635. Physical->Width = 0;
  636. Physical->x = 0;
  637. }
  638. }
  639. if (Physical->y + Physical->Height > p->Height)
  640. {
  641. Physical->Height = p->Height - Physical->y;
  642. if (Physical->Height < 0)
  643. {
  644. Physical->Height = 0;
  645. Physical->y = 0;
  646. }
  647. }
  648. }
  650. void VirtToPhy(const rect* Virtual, rect* Physical, const video* p)
  651. {
  652. if (Virtual)
  653. {
  654. *Physical = *Virtual;
  656. if (p->Pixel.Flags & PF_PIXELDOUBLE)
  657. {
  658. Physical->x >>= 1;
  659. Physical->y >>= 1;
  660. Physical->Width >>= 1;
  661. Physical->Height >>= 1;
  662. }
  664. if (p->Direction & DIR_SWAPXY)
  665. SwapRect(Physical);
  667. if (p->Direction & DIR_MIRRORLEFTRIGHT)
  668. Physical->x = p->Width - Physical->x - Physical->Width;
  670. if (p->Direction & DIR_MIRRORUPDOWN)
  671. Physical->y = p->Height - Physical->y - Physical->Height;
  673. ClipRectPhy(Physical,p);
  674. }
  675. else
  676. {
  677. Physical->x = 0;
  678. Physical->y = 0;
  679. Physical->Width = p->Width;
  680. Physical->Height = p->Height;
  681. }
  682. }
  684. void PhyToVirt(const rect* Physical, rect* Virtual, const video* p)
  685. {
  686. if (Physical)
  687. *Virtual = *Physical;
  688. else
  689. {
  690. Virtual->x = 0;
  691. Virtual->y = 0;
  692. Virtual->Width = p->Width;
  693. Virtual->Height = p->Height;
  694. }
  696. if (p->Direction & DIR_MIRRORLEFTRIGHT)
  697. Virtual->x = p->Width - Virtual->x - Virtual->Width;
  699. if (p->Direction & DIR_MIRRORUPDOWN)
  700. Virtual->y = p->Height - Virtual->y - Virtual->Height;
  702. if (p->Direction & DIR_SWAPXY)
  703. SwapRect(Virtual);
  705. if (p->Pixel.Flags & PF_PIXELDOUBLE)
  706. {
  707. Virtual->x <<= 1;
  708. Virtual->y <<= 1;
  709. Virtual->Width <<= 1;
  710. Virtual->Height <<= 1;
  711. }
  712. }