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

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

Windows CE

开发平台：

C/C++

blit_soft.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: blit_soft.c 607 2006-01-22 20:58:29Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  25. #include "../dyncode/dyncode.h"
  26. #include "../cpu/cpu.h"
  27. #include "blit_soft.h"
  29. //#define BLITTEST
  31. /*
  32. TV range:
  33. +16  (219)
  34. +128 (224)
  35. +128 (224)
  37. PC range:
  38. +0   (255)
  39. +128 (255)
  40. +128 (255)
  42. ranges:
  43. R,G,B,Y [0..1]
  44. Cb,Cr   [-0.5..0.5]
  46. Y' = Kr * R' + (1 - Kr - Kb) * G' + Kb * B'
  47. Cb = 0.5 * (B' - Y') / (1 - Kb)
  48. Cr = 0.5 * (R' - Y') / (1 - Kr)
  50. Kb = 0.114
  51. Kr = 0.299
  53. ITU-R BT 601
  54.     Y'= 0.299   *R' + 0.587   *G' + 0.114   *B'
  55.     Cb=-0.168736*R' - 0.331264*G' + 0.5     *B'
  56.     Cr= 0.5     *R' - 0.418688*G' - 0.081312*B'
  58.     R'= Y'            + 1.403*Cr
  59.     G'= Y' - 0.344*Cb - 0.714*Cr
  60.     B'= Y' + 1.773*Cb 
  62. Kb = 0.0722
  63. Kr = 0.2126
  65. ITU-R BT 709
  66.     Y'= 0.2215*R' + 0.7154*G' + 0.0721*B'
  67.     Cb=-0.1145*R' - 0.3855*G' + 0.5000*B'
  68.     Cr= 0.5016*R' - 0.4556*G' - 0.0459*B'
  70.     R'= Y'             + 1.5701*Cr
  71.     G'= Y' - 0.1870*Cb - 0.4664*Cr
  72.     B'= Y' - 1.8556*Cb 
  73. */
  75. #define CM(i) ((int16_t)((i)*8192))
  77. #if defined(_M_IX86) && !defined(TARGET_SYMBIAN)
  79. static const int16_t YUVToRGB[4][8] =
  80. {
  81. // TV range BT-601
  82. { CM(1.164),-16,CM(1.596),CM(-0.813),-128,CM(2.017),CM(-0.392),-128 },
  83. // TV range BT-709
  84. { CM(1.164),-16,CM(1.786),CM(-0.530),-128,CM(2.111),CM(-0.213),-128 },
  85. // PC range BT-601
  86. { CM(1),0,CM(1.402),CM(-0.71414),-128,CM(1.772),CM(-0.34414),-128 },
  87. // PC range BT-709
  88. { CM(1),0,CM(1.5701),CM(-0.4664),-128,CM(1.8556),CM(-0.1870),-128 },
  89. };
  91. static const int16_t* GetYUVToRGB(const pixel* Src)
  92. {
  93. int i = 0;
  94. if (Src->Flags & PF_YUV_BT709)
  95. i += 1;
  96. if (Src->Flags & PF_YUV_PC)
  97. i += 2;
  99. return YUVToRGB[i];
  100. }
  102. #endif
  104. #define SAT(Value) (Value < 0 ? 0: (Value > 255 ? 255: Value))
  106. static const rgbval_t Gray1[2] = { 
  107. CRGB(0,0,0),CRGB(255,255,255)
  108. };
  109. static const rgbval_t Gray2[4] = { 
  110. CRGB(0,0,0),CRGB(85,85,85),CRGB(170,170,170),CRGB(255,255,255) 
  111. };
  112. static const rgbval_t Gray4[16] = {
  113. CRGB(0,0,0),CRGB(17,17,17),CRGB(34,34,34),CRGB(51,51,51),
  114. CRGB(68,68,68),CRGB(85,85,85),CRGB(102,102,102),CRGB(119,119,119),
  115. CRGB(136,136,136),CRGB(153,153,153),CRGB(170,170,170),CRGB(187,187,187),
  116. CRGB(204,204,204),CRGB(221,221,221),CRGB(238,238,238),CRGB(255,255,255)
  117. };
  119. #if defined(_M_IX86) && !defined(TARGET_SYMBIAN)
  121. #define DECLARE_BLITMMX(name) 
  122. extern void STDCALL name##_mmx(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,int Width,int Height,uintptr_t Src2SrcLast); 
  123. extern void STDCALL name##_mmx2(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,int Width,int Height,uintptr_t Src2SrcLast); 
  124. extern void STDCALL name##_3dnow(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,int Width,int Height,uintptr_t Src2SrcLast);
  126. DECLARE_BLITMMX(blit_i420_i420)
  127. DECLARE_BLITMMX(blit_i420_yuy2)
  128. DECLARE_BLITMMX(blit_i420_rgb32)
  129. DECLARE_BLITMMX(blit_i420_rgb24)
  130. DECLARE_BLITMMX(blit_i420_bgr32)
  131. DECLARE_BLITMMX(blit_i420_bgr24)
  132. DECLARE_BLITMMX(blit_rgb32_rgb32)
  133. DECLARE_BLITMMX(blit_rgb24_rgb24)
  134. DECLARE_BLITMMX(blit_rgb16_rgb16)
  136. typedef struct blitmmx
  137. {
  138. uint32_t In;
  139. uint32_t Out;
  140. blitsoftentry Func[3];
  142. } blitmmx;
  144. static const blitmmx BlitMMX[] = 
  145. {
  146. { FOURCC_I420, FOURCC_I420, { blit_i420_i420_mmx, blit_i420_i420_mmx2, blit_i420_i420_3dnow }},
  147. { FOURCC_I420, FOURCC_YUY2, { blit_i420_yuy2_mmx, blit_i420_yuy2_mmx2, blit_i420_yuy2_3dnow }},
  148. { FOURCC_I420, FOURCC_RGB32,{ blit_i420_rgb32_mmx,blit_i420_rgb32_mmx2,blit_i420_rgb32_3dnow }},
  149. { FOURCC_I420, FOURCC_RGB24,{ blit_i420_rgb24_mmx,blit_i420_rgb24_mmx2,blit_i420_rgb24_3dnow }},
  150. { FOURCC_I420, FOURCC_BGR32,{ blit_i420_bgr32_mmx,blit_i420_bgr32_mmx2,blit_i420_bgr32_3dnow }},
  151. { FOURCC_I420, FOURCC_BGR24,{ blit_i420_bgr24_mmx,blit_i420_bgr24_mmx2,blit_i420_bgr24_3dnow }},
  152. { FOURCC_RGB32,FOURCC_RGB32,{ blit_rgb32_rgb32_mmx,blit_rgb32_rgb32_mmx2,blit_rgb32_rgb32_3dnow }},
  153. { FOURCC_RGB24,FOURCC_RGB24,{ blit_rgb24_rgb24_mmx,blit_rgb24_rgb24_mmx2,blit_rgb24_rgb24_3dnow }},
  154. { FOURCC_RGB16,FOURCC_RGB16,{ blit_rgb16_rgb16_mmx,blit_rgb16_rgb16_mmx2,blit_rgb16_rgb16_3dnow }},
  155. { FOURCC_RGB15,FOURCC_RGB15,{ blit_rgb16_rgb16_mmx,blit_rgb16_rgb16_mmx2,blit_rgb16_rgb16_3dnow }},
  156. { FOURCC_BGR32,FOURCC_BGR32,{ blit_rgb32_rgb32_mmx,blit_rgb32_rgb32_mmx2,blit_rgb32_rgb32_3dnow }},
  157. { FOURCC_BGR24,FOURCC_BGR24,{ blit_rgb24_rgb24_mmx,blit_rgb24_rgb24_mmx2,blit_rgb24_rgb24_3dnow }},
  158. { FOURCC_BGR16,FOURCC_BGR16,{ blit_rgb16_rgb16_mmx,blit_rgb16_rgb16_mmx2,blit_rgb16_rgb16_3dnow }},
  159. { FOURCC_BGR15,FOURCC_BGR15,{ blit_rgb16_rgb16_mmx,blit_rgb16_rgb16_mmx2,blit_rgb16_rgb16_3dnow }},
  160. {0},
  161. };
  163. #endif
  165. typedef struct blitpack
  166. {
  167. blitfx FX;
  168. video Dst;
  169. video Src;
  170. rect DstRect;
  171. rect SrcRect;
  172. blit_soft Code[2];
  173. bool_t SafeBorder;
  174. int RScaleX;
  175. int RScaleY;
  176. struct blitpack* Next;
  178. } blitpack;
  180. static NOINLINE void FreeBlit(blit_soft* p)
  181. {
  182. CodeDone(&p->Code);
  183. free(p->LookUp_Data);
  184. p->LookUp_Data = NULL;
  185. }
  187. static INLINE struct blitpack* _BlitAlloc()
  188. {
  189. blitpack* p = (blitpack*) malloc(sizeof(blitpack));
  190. if (!p) return NULL;
  192. memset(p,0,sizeof(blitpack));
  193. CodeInit(&p->Code[0].Code);
  194. CodeInit(&p->Code[1].Code);
  195. return p;
  196. }
  198. static INLINE void _BlitFree(struct blitpack* p)
  199. {
  200. FreeBlit(&p->Code[0]);
  201. FreeBlit(&p->Code[1]);
  202. free(p);
  203. }
  205. #ifdef CONFIG_CONTEXT
  207. void Blit_Init()
  208. {
  209. }
  211. void Blit_Done()
  212. {
  213. blitpack* p;
  214. while ((p = Context()->Blit)!=NULL)
  215. {
  216. Context()->Blit = p->Next;
  217. _BlitFree(p);
  218. }
  219. }
  221. static INLINE void BlitFree(struct blitpack* p)
  222. {
  223. p->Next = Context()->Blit;
  224. Context()->Blit = p;
  225. }
  227. static INLINE struct blitpack* BlitAlloc()
  228. {
  229. blitpack* p = Context()->Blit;
  230. if (p)
  231. Context()->Blit = p->Next;
  232. else
  233. p = _BlitAlloc();
  234. return p;
  235. }
  237. #else
  238. #define BlitAlloc _BlitAlloc
  239. #define BlitFree _BlitFree
  240. #endif
  242. static const rgb* DefaultPal(const pixel* Format)
  243. {
  244. if (Format->Flags & PF_PALETTE)
  245. {
  246. if (!Format->Palette)
  247. switch (Format->BitCount)
  248. {
  249. case 1: return (const rgb*)Gray1;
  250. case 2: return (const rgb*)Gray2;
  251. case 4: return (const rgb*)Gray4;
  252. }
  253. return Format->Palette;
  254. }
  255. return NULL;
  256. }
  258. static int CalcScale(int v, int Min, int Max)
  259. {
  260. if (v > Max) v = Max;
  261. if (v < Min) v = Min;
  262. return v;
  263. }
  265. static int CalcRScale(int v, int Gray)
  266. {
  267. if (v<=0) return 16;
  269. v = (16*1024 << 16) / v;
  271. if (Gray) // only 100% and 200% scale
  272. return v > 12288 ? 16:8;
  274. //align to 100%
  275. if (v > 16834-1024 && v < 16384+1024) 
  276. v = 16384;
  277. //align to 200%
  278. if (v > 8192-1024 && v < 8192+1024) 
  279. v = 8192;
  280. //align to 50%
  281. if (v > 32768-2048 && v < 32768+2048) 
  282. v = 32768;
  284. #if defined(SH3)
  285. if (v < 12288)
  286. return 8;
  287. return 16;
  288. // if (v<1024) v=1024;
  289. // return ((v+1024) >> 11) << 1;
  290. #else
  291. if (v<512) v=512;
  292. return (v+512) >> 10;
  293. #endif
  294. }
  296. static NOINLINE bool_t EnlargeIfNeeded(int* v,int Align,int Side,int Limit)
  297. {
  298. int Needed = Align - (*v & (Align-1));
  299. if (Needed < Align && Needed <= (Limit-Side))
  300. {
  301. *v += Needed;
  302. return 1;
  303. }
  304. return 0;
  305. }
  307. void BlitAlign(blitpack* p, rect* DstRect, rect* SrcRect)
  308. {
  309. int i;
  310. int ShrinkX,ShrinkY;
  311. int SrcRight;
  312. int SrcBottom;
  313. int SrcAdjWidth,SrcAdjHeight;
  314. int RScaleX,RScaleY;
  315. blit_soft* Code;
  317. if (!p) return;
  319. RScaleX = p->RScaleX;
  320. RScaleY = p->RScaleY;
  321. Code = &p->Code[0];
  323. p->SafeBorder = 0;
  325. if (Code->ArithStretch && (RScaleX != 16) && (RScaleX != 32))
  326. {
  327. //avoid bilinear scale overrun (shrink source)
  329. if ((p->Src.Pixel.Flags & PF_SAFEBORDER) && Code->DstAlignSize > 2)
  330. p->SafeBorder = 1; // build a one pixel border before blitting on right and bottom side
  331. else
  332. {
  333. //only horizontal bilinear filtering is supported (arm_stretch)
  334. if (SrcRect->Width>2) 
  335. SrcRect->Width -= 2;
  336. }
  337. }
  339. // convert source to destination space
  340. if (p->FX.Direction & DIR_SWAPXY)
  341. {
  342. SwapInt(&RScaleX,&RScaleY);
  343. SwapRect(SrcRect);
  344. }
  346. SrcRight = SrcRect->x + SrcRect->Width;
  347. SrcBottom = SrcRect->y + SrcRect->Height;
  349. SrcAdjWidth = SrcRect->Width * 16 / RScaleX;
  350. SrcAdjHeight = SrcRect->Height * 16 / RScaleY;
  352. if (p->FX.Flags & BLITFX_ENLARGEIFNEEDED)
  353. {
  354. SrcRight = p->Src.Width;
  355. SrcBottom = p->Src.Height;
  356. if (p->FX.Direction & DIR_SWAPXY)
  357. SwapInt(&SrcRight,&SrcBottom);
  359. if (p->Src.Pixel.Flags & PF_SAFEBORDER)
  360. {
  361. SrcRight += 16;
  362. SrcBottom += 16;
  363. }
  365. if (EnlargeIfNeeded(&SrcAdjWidth,Code->DstAlignSize,SrcRect->x+SrcRect->Width,SrcRight))
  366. SrcRect->Width = -1; // need calc
  367. if (EnlargeIfNeeded(&SrcAdjHeight,Code->DstAlignSize,SrcRect->y+SrcRect->Height,SrcBottom))
  368. SrcRect->Height = -1; // need calc
  369. }
  371. ShrinkX = DstRect->Width - SrcAdjWidth;
  372. if (ShrinkX>=0) //shrink destination?
  373. {
  374. ShrinkX >>= 1;
  375. DstRect->x += ShrinkX;
  376. DstRect->Width = SrcAdjWidth;
  377. }
  378. else //adjust source position
  379. {
  380. ShrinkX = 0;
  381. SrcRect->x += (SrcAdjWidth - DstRect->Width) * RScaleX >> 5;
  382. SrcRect->Width = -1; // need calc
  383. }
  385. ShrinkY = DstRect->Height - SrcAdjHeight;
  386. if (ShrinkY>=0) //shrink Dst?
  387. {
  388. ShrinkY >>= 1;
  389. DstRect->y += ShrinkY;
  390. DstRect->Height = SrcAdjHeight;
  391. }
  392. else //adjust source position
  393. {
  394. ShrinkY = 0;
  395. SrcRect->y += (SrcAdjHeight - DstRect->Height) * RScaleY >> 5;
  396. SrcRect->Height = -1; // need calc
  397. }
  399. i = DstRect->Width & (Code->DstAlignSize-1); 
  400. DstRect->Width -= i; 
  401. i >>= 1;
  402. ShrinkX += i;
  403. DstRect->x += i;
  405. i = DstRect->Height & (Code->DstAlignSize-1);
  406. DstRect->Height -= i;
  407. i >>= 1;
  408. ShrinkY += i;
  409. DstRect->y += i;
  411. i = DstRect->x & (Code->DstAlignPos-1);
  412. if (i && ShrinkX < i)
  413. {
  414. DstRect->Width -= Code->DstAlignPos - i;
  415. DstRect->Width &= ~(Code->DstAlignSize-1); 
  416. DstRect->x += Code->DstAlignPos - i;
  417. }
  418. else
  419. DstRect->x -= i;
  421. i = DstRect->y & (Code->DstAlignPos-1);
  422. if (i && ShrinkY < i)
  423. {
  424. DstRect->Height -= Code->DstAlignPos - i;
  425. DstRect->Height &= ~(Code->DstAlignSize-1);
  426. DstRect->y += Code->DstAlignPos - i;
  427. }
  428. else
  429. DstRect->y -= i;
  431. SrcRect->x &= ~(Code->SrcAlignPos-1);
  432. SrcRect->y &= ~(Code->SrcAlignPos-1);
  434. // convert source back to it's space (if needed)
  435. if (SrcRect->Width < 0)
  436. SrcRect->Width = (DstRect->Width * RScaleX / 16 + 1) & ~1;
  437. if (SrcRect->Height < 0)
  438. SrcRect->Height = (DstRect->Height * RScaleY / 16 + 1) & ~1;
  440. if (SrcRect->x + SrcRect->Width > SrcRight)
  441. SrcRect->Width = SrcRight - SrcRect->x;
  443. if (SrcRect->y + SrcRect->Height > SrcBottom)
  444. SrcRect->Height = SrcBottom - SrcRect->y;
  446. if (p->FX.Direction & DIR_SWAPXY)
  447. SwapRect(SrcRect);
  449. p->DstRect = *DstRect;
  450. p->SrcRect = *SrcRect;
  451. }
  453. static NOINLINE void CodeRelease(blit_soft* p)
  454. {
  455. //todo... better palette handling
  456. if (p->Dst.Palette)
  457. memset(&p->Dst,0,sizeof(p->Dst));
  458. if (p->Src.Palette)
  459. memset(&p->Src,0,sizeof(p->Src));
  460. }
  462. void BlitRelease(blitpack* p)
  463. {
  464. if (p)
  465. {
  466. CodeRelease(&p->Code[0]);
  467. CodeRelease(&p->Code[1]);
  468. BlitFree(p);
  469. }
  470. }
  472. int AnyAlign(rect* DstRect, rect* SrcRect, const blitfx* FX, 
  473.   int DstAlignSize, int DstAlignPos,
  474.   int MinScale, int MaxScale)
  475. {
  476. int i,ShrinkX,ShrinkY;
  477. int ScaleX,ScaleY;
  478. int SrcRight;
  479. int SrcBottom;
  480. int SrcAdjWidth,SrcAdjHeight;
  482. if (!DstRect || !SrcRect || !FX)
  483. return ERR_INVALID_PARAM;
  485. ScaleX = CalcScale(FX->ScaleX,MinScale,MaxScale);
  486. ScaleY = CalcScale(FX->ScaleY,MinScale,MaxScale);
  487. SrcRight = SrcRect->x + SrcRect->Width;
  488. SrcBottom = SrcRect->y + SrcRect->Height;
  490. // convert source to destination space
  491. if (FX->Direction & DIR_SWAPXY)
  492. {
  493. SwapInt(&ScaleX,&ScaleY);
  494. SwapRect(SrcRect);
  495. }
  497. SrcAdjWidth = (SrcRect->Width * ScaleX + 32768) >> 16;
  498. SrcAdjHeight = (SrcRect->Height * ScaleY + 32768) >> 16;
  500. ShrinkX = DstRect->Width - SrcAdjWidth;
  501. if (ShrinkX>0) //shrink destination?
  502. {
  503. ShrinkX >>= 1;
  504. DstRect->x += ShrinkX;
  505. DstRect->Width = SrcAdjWidth;
  506. }
  507. else //adjust source position
  508. {
  509. ShrinkX = 0;
  510. SrcRect->x += ((SrcAdjWidth - DstRect->Width) << 15) / ScaleX;
  511. SrcRect->Width = -1;
  512. }
  514. ShrinkY = DstRect->Height - SrcAdjHeight;
  515. if (ShrinkY>0) //shrink Dst?
  516. {
  517. ShrinkY >>= 1;
  518. DstRect->y += ShrinkY;
  519. DstRect->Height = SrcAdjHeight;
  520. }
  521. else //adjust source position
  522. {
  523. ShrinkY = 0;
  524. SrcRect->y += ((SrcAdjHeight - DstRect->Height) << 15) / ScaleY;
  525. SrcRect->Height = -1;
  526. }
  528. // final alignment
  530. i = DstRect->Width & (DstAlignSize-1); 
  531. DstRect->Width -= i; 
  532. i >>= 1;
  533. ShrinkX += i;
  534. DstRect->x += i;
  536. i = DstRect->Height & (DstAlignSize-1);
  537. DstRect->Height -= i;
  538. i >>= 1;
  539. ShrinkY += i;
  540. DstRect->y += i;
  542. i = DstRect->x & (DstAlignPos-1);
  543. if (i && ShrinkX < i)
  544. {
  545. DstRect->Width -= DstAlignPos - i;
  546. DstRect->Width &= ~(DstAlignSize-1); 
  547. DstRect->x += DstAlignPos - i;
  548. }
  549. else
  550. DstRect->x -= i;
  552. i = DstRect->y & (DstAlignPos-1);
  553. if (i && ShrinkY < i)
  554. {
  555. DstRect->Height -= DstAlignPos - i;
  556. DstRect->Height &= ~(DstAlignSize-1);
  557. DstRect->y += DstAlignPos - i;
  558. }
  559. else
  560. DstRect->y -= i;
  562. SrcRect->x &= ~1;
  563. SrcRect->y &= ~1;
  565. if (SrcRect->Width < 0)
  566. SrcRect->Width = ((DstRect->Width << 16) / ScaleX +1) & ~1;
  567. if (SrcRect->Height < 0)
  568. SrcRect->Height = ((DstRect->Height << 16) / ScaleY +1) & ~1;
  570. if (FX->Direction & DIR_SWAPXY)
  571. SwapRect(SrcRect);
  573. if (SrcRect->x + SrcRect->Width > SrcRight)
  574. SrcRect->Width = SrcRight - SrcRect->x;
  576. if (SrcRect->y + SrcRect->Height > SrcBottom)
  577. SrcRect->Height = SrcBottom - SrcRect->y;
  579. return ERR_NONE;
  580. }
  582. static INLINE void SurfacePtr(uint8_t** Ptr, const planes Planes, const video* Format, int BPP, int x, int y, int Pitch)
  583. {
  584. int Adj = (x & 1) << 1;
  585.     Ptr[0] = (uint8_t*)Planes[0] + ((x * BPP) >> 3) + y * Pitch;
  587. if (Format->Pixel.Flags & (PF_YUV420|PF_YUV422|PF_YUV444|PF_YUV410))
  588. {
  589. if (Format->Pixel.Flags & PF_YUV420)
  590. {
  591. Ptr[1] = (uint8_t*)Planes[1] + (x >> 1) + (y >> 1) * (Pitch >> 1);
  592. Ptr[2] = (uint8_t*)Planes[2] + (x >> 1) + (y >> 1) * (Pitch >> 1);
  593. }
  594. else
  595. if (Format->Pixel.Flags & PF_YUV422)
  596. {
  597. Ptr[1] = (uint8_t*)Planes[1] + (x >> 1) + y * (Pitch >> 1);
  598. Ptr[2] = (uint8_t*)Planes[2] + (x >> 1) + y * (Pitch >> 1);
  599. }
  600. else
  601. if (Format->Pixel.Flags & PF_YUV444)
  602. {
  603. Ptr[1] = (uint8_t*)Planes[1] + x + y * Pitch;
  604. Ptr[2] = (uint8_t*)Planes[2] + x + y * Pitch;
  605. }
  606. else
  607. if (Format->Pixel.Flags & PF_YUV410)
  608. {
  609. Ptr[1] = (uint8_t*)Planes[1] + (x >> 2) + (y >> 2) * (Pitch >> 2);
  610. Ptr[2] = (uint8_t*)Planes[2] + (x >> 2) + (y >> 2) * (Pitch >> 2);
  611. }
  612. }
  613. else
  614. if (Format->Pixel.Flags & PF_FOURCC)
  615. switch (Format->Pixel.FourCC)
  616. {
  617. case FOURCC_IMC2:
  618. Ptr[2] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 1) + (y >> 1) * Pitch;
  619. Ptr[1] = Ptr[1] + (Pitch >> 1);
  620. break;
  621. case FOURCC_IMC4:
  622. Ptr[1] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 1) + (y >> 1) * Pitch;
  623. Ptr[2] = Ptr[1] + (Pitch >> 1);
  624. break;
  625. case FOURCC_I420:
  626. case FOURCC_IYUV:
  627. Ptr[1] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 1) + (y >> 1) * (Pitch >> 1);
  628. Ptr[2] = Ptr[1] + ((Format->Height * Pitch) >> 2);
  629. break;
  630. case FOURCC_YV16: 
  631. Ptr[2] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 1) + y * (Pitch >> 1);
  632. Ptr[1] = Ptr[2] + ((Format->Height * Pitch) >> 1);
  633. break;
  634. case FOURCC_YVU9: 
  635. Ptr[2] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 2) + (y >> 2) * (Pitch >> 2);
  636. Ptr[1] = Ptr[2] + ((Format->Height * Pitch) >> 4);
  637. break;
  638. case FOURCC_YUV9: 
  639. Ptr[1] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 2) + (y >> 2) * (Pitch >> 2);
  640. Ptr[2] = Ptr[1] + ((Format->Height * Pitch) >> 4);
  641. break;
  642. case FOURCC_YV12: 
  643. Ptr[2] = (uint8_t*)Planes[0] + Format->Height * Pitch + (x >> 1) + (y >> 1) * (Pitch >> 1);
  644. Ptr[1] = Ptr[2] + ((Format->Height * Pitch) >> 2);
  645. break;
  646. case FOURCC_YUY2:
  647. case FOURCC_YUNV:
  648. case FOURCC_V422:
  649. case FOURCC_YUYV:
  650. Ptr[1] = Ptr[0]+1-Adj;
  651. Ptr[2] = Ptr[0]+3-Adj;
  652. break;
  653. case FOURCC_YVYU:
  654. Ptr[1] = Ptr[0]+3-Adj;
  655. Ptr[2] = Ptr[0]+1-Adj;
  656. break;
  657. case FOURCC_UYVY:
  658. case FOURCC_Y422:
  659. case FOURCC_UYNV:
  660. Ptr[1] = Ptr[0]-Adj;
  661. Ptr[2] = Ptr[0]+2-Adj;
  662. Ptr[0]++;
  663. break;
  664. case FOURCC_VYUY:
  665. Ptr[2] = Ptr[0]-Adj;
  666. Ptr[1] = Ptr[0]+2-Adj;
  667. Ptr[0]++;
  668. break;
  669. }
  670. }
  672. void BlitImage(blitpack* Pack, const planes Dst, const constplanes Src, const constplanes SrcLast, int DstPitch, int SrcPitch)
  673. {
  674. uint8_t* DstPtr[MAXPLANES];
  675. uint8_t* SrcPtr[MAXPLANES];
  676. bool_t OnlyDiff;
  677. int Width,Height;
  678. blit_soft* p;
  679. uintptr_t Src2SrcLast;
  680. int DstStepX;
  681. int DstStepY;
  682. int DstX;
  683. int DstY;
  684. int SrcY;
  686. // nothing to do?
  687. if (!Pack || Pack->DstRect.Width<=0 || Pack->DstRect.Height<=0)
  688. return;
  690. OnlyDiff = (Pack->FX.Flags & BLITFX_ONLYDIFF) && SrcLast && SrcLast[0] != NULL;
  692. p = &Pack->Code[OnlyDiff];
  694. // calculate the Src and Dst pointers
  695. //   Src: always upperleft corner
  696. //   Dst: according to swapxy and mirroring
  698. Width = Pack->DstRect.Width;
  699. Height = Pack->DstRect.Height;
  701. if (p->SwapXY)
  702. SwapInt(&Width,&Height);
  704. if (DstPitch < 0)
  705. DstPitch = Pack->Dst.Pitch;
  706. if (SrcPitch < 0)
  707. SrcPitch = Pack->Src.Pitch;
  709. SrcY = Pack->SrcRect.y;
  710. if (p->SrcUpDown)
  711. SrcY += Pack->SrcRect.Height-1;
  713. SurfacePtr(SrcPtr,*(const planes*)Src,&Pack->Src,p->SrcBPP,Pack->SrcRect.x,SrcY,SrcPitch);
  715. if (p->SrcUpDown)
  716. SrcPitch = -SrcPitch;
  718. Src2SrcLast = 0;
  719. if (OnlyDiff)
  720. Src2SrcLast = (uint8_t*)SrcLast[0] - (uint8_t*)Src[0];
  722. DstStepX = p->DstBPP;
  723. DstStepY = DstPitch*8;
  724. DstX = Pack->DstRect.x;
  725. DstY = Pack->DstRect.y;
  727. if (p->DstLeftRight)
  728. {
  729. DstX += Pack->DstRect.Width-1;
  730. DstStepX = -DstStepX;
  731. }
  733. if (p->DstUpDown)
  734. {
  735. DstY += Pack->DstRect.Height-1;
  736. DstStepY = -DstStepY;
  737. }
  739. if (p->SwapXY)
  740. SwapInt(&DstStepX,&DstStepY);
  742. SurfacePtr(DstPtr,Dst,&Pack->Dst,p->DstBPP,DstX,DstY,DstPitch);
  744. if (p->DstUpDown)
  745. DstPitch = -DstPitch;
  747. if (p->Slices)
  748. {
  749. const int DstBlock2 = 5;
  750. const int DstBlock = 32;
  752. int SrcBlock = (DstBlock * p->RScaleX) >> 4; //SrcBlock has to be even because of YUV
  753. int DstNext = (DstBlock * DstStepX) >> 3;
  754. int DstNextUV = DstNext >> (p->SwapXY ? p->DstUVPitch2+p->DstUVY2 : p->DstUVX2);
  755. int SrcNext = (SrcBlock * p->SrcBPP) >> 3;
  756. int SrcNextUV = SrcNext >> p->SrcUVX2;
  758. if (Width > DstBlock && p->SlicesReverse) // reverse order?
  759. {
  760. int Quot = Width >> DstBlock2;
  761. int Rem = Width & (DstBlock-1);
  763. DstPtr[0] += Quot*DstNext;
  764. DstPtr[1] += Quot*DstNextUV;
  765. DstPtr[2] += Quot*DstNextUV;
  767. SrcPtr[0] += Quot*SrcNext;
  768. SrcPtr[1] += Quot*SrcNextUV;
  769. SrcPtr[2] += Quot*SrcNextUV;
  771. if (Rem)
  772. {
  773. p->Entry(p,DstPtr,SrcPtr,DstPitch,SrcPitch,Rem,Height,Src2SrcLast);
  775. Width -= Rem;
  776. }
  778. DstNext = -DstNext;
  779. DstNextUV = -DstNextUV;
  780. SrcNext = -SrcNext;
  781. SrcNextUV = -SrcNextUV;
  783. DstPtr[0] += DstNext;
  784. DstPtr[1] += DstNextUV;
  785. DstPtr[2] += DstNextUV;
  787. SrcPtr[0] += SrcNext;
  788. SrcPtr[1] += SrcNextUV;
  789. SrcPtr[2] += SrcNextUV;
  790. }
  792. for (;Width > DstBlock;Width -= DstBlock)
  793. {
  794. p->Entry(p,DstPtr,SrcPtr,DstPitch,SrcPitch,DstBlock,Height,Src2SrcLast);
  796. DstPtr[0] += DstNext;
  797. DstPtr[1] += DstNextUV;
  798. DstPtr[2] += DstNextUV;
  800. SrcPtr[0] += SrcNext;
  801. SrcPtr[1] += SrcNextUV;
  802. SrcPtr[2] += SrcNextUV;
  803. }
  804. }
  806. p->Entry(p,DstPtr,SrcPtr,DstPitch,SrcPitch,Width,Height,Src2SrcLast); 
  807. }
  809. void BuildPalLookUp(blit_soft* p,bool_t YUV)
  810. {
  811. //create a palette lookup with 3x3 bits RGB input
  812. int a,b,c;
  813. int Size = 1 << p->Dst.BitCount;
  814. uint8_t* LookUp;
  816. p->LookUp_Data = malloc(16*16*16*4);
  817. if (p->LookUp_Data)
  818. {
  819. LookUp = (uint8_t*) p->LookUp_Data;
  821. for (a=16;a<512;a+=32)
  822. for (b=16;b<512;b+=32)
  823. for (c=16;c<512;c+=32)
  824. {
  825. const rgb* q = p->DstPalette;
  826. int BestMatch = 0;
  827. int BestDiff = 0x7FFFFFFF;
  828. int i,v[3];
  830. v[0] = a; 
  831. v[1] = b;
  832. v[2] = c;
  833. if (v[0] >= 384) v[0] -= 512;
  834. if (v[1] >= 384) v[1] -= 512;
  835. if (v[2] >= 384) v[2] -= 512;
  837. if (YUV)
  838. {
  839. int w[3];
  841. w[0] = (v[0]*p->_YMul +                  v[2]*p->_RVMul + p->_RAdd) >> 16;
  842. w[1] = (v[0]*p->_YMul + v[1]*p->_GUMul + v[2]*p->_GVMul + p->_GAdd) >> 16;
  843. w[2] = (v[0]*p->_YMul + v[1]*p->_BUMul +               p->_BAdd) >> 16;
  844. v[0]=w[0];
  845. v[1]=w[1];
  846. v[2]=w[2];
  847. }
  849. for (i=0;i<Size;++i,++q)
  850. {
  851. int Diff = (q->c.r-v[0])*(q->c.r-v[0])+
  852.    (q->c.g-v[1])*(q->c.g-v[1])+
  853.    (q->c.b-v[2])*(q->c.b-v[2]);
  855. if (Diff < BestDiff)
  856. {
  857. BestMatch = i;
  858. BestDiff = Diff;
  859. }
  860. }
  862. q = p->DstPalette + BestMatch;
  863. if (YUV)
  864. {
  865. v[0] = ((2105 * q->c.r) + (4128 * q->c.g) + (802 * q->c.b))/0x2000 + 16;
  866. v[1] = (-(1212 * q->c.r) - (2384 * q->c.g) + (3596 * q->c.b))/0x2000 + 128;
  867. v[2] = ((3596 * q->c.r) - (3015 * q->c.g) - (582 * q->c.b))/0x2000 + 128;
  869. v[0]=SAT(v[0]);
  870. v[1]=SAT(v[1]);
  871. v[2]=SAT(v[2]);
  872. }
  873. else
  874. {
  875. v[0] = q->c.r;
  876. v[1] = q->c.g;
  877. v[2] = q->c.b;
  878. }
  880. LookUp[0] = (uint8_t)BestMatch;
  881. #if defined(SH3)
  882. LookUp[3] = (uint8_t)(v[0] >> 1);
  883. LookUp[1] = (uint8_t)(v[1] >> 1);
  884. LookUp[2] = (uint8_t)(v[2] >> 1);
  885. #else
  886. LookUp[1] = (uint8_t)v[0];
  887. LookUp[2] = (uint8_t)v[1];
  888. LookUp[3] = (uint8_t)v[2];
  889. #endif
  890. LookUp += 4;
  891. }
  892. }
  893. }
  895. int UniversalType(const pixel* p, bool_t YUV)
  896. {
  897. if (PlanarYUV(p,NULL,NULL,NULL)) return YUV ? 12:10;
  898. if (PackedYUV(p)) return YUV ? 13:11;
  900. if (p->Flags & PF_PALETTE)
  901. {
  902. if (p->BitCount==1) return 1;
  903. if (p->BitCount==2) return 2;
  904. if (p->BitCount==4) return 3;
  905. if (p->BitCount==8) return YUV ? 14:4;
  906. }
  908. if (p->Flags & PF_RGB)
  909. {
  910. if (p->BitCount==8)  return 5;
  911. if (p->BitCount==16) return 6;
  912. if (p->BitCount==24) return 7;
  913. if (p->BitCount==32) return 8;
  914. }
  916. return -1;
  917. }
  919. // !SwapXY
  920. // !DstLeftRight
  921. // SrcType == 12
  922. // DstType == 12
  923. // RScaleX == 32/16/8
  924. // RScaleY == 32/16/8 
  925. // SrcUVX2 == DstUVX2
  926. // SrcUVY2 == DstUVY2
  928. static void Blit_PYUV_PYUV_2Plane(const uint8_t* Src,uint8_t* Dst,int Width,int Height,int SrcPitch,int DstPitch,int ScaleX,int ScaleY)
  929. {
  930. int y;
  931. for (y=0;y<Height;++y)
  932. {
  933. const uint8_t* s = Src;
  934. uint8_t* d = Dst;
  935. uint8_t* de = Dst + Width;
  937. switch (ScaleX)
  938. {
  939. case 4:
  940. while (d<de)
  941. {
  942. d[0] = d[1] = d[2] = d[3] = *s;
  943. ++s;
  944. d+=4;
  945. }
  946. break;
  947. case 8:
  948. while (d<de)
  949. {
  950. d[0] = *s;
  951. d[1] = *s;
  952. ++s;
  953. d+=2;
  954. }
  955. break;
  956. case 16:
  957. memcpy(d,s,Width);
  958. break;
  959. case 32:
  960. while (d<de)
  961. {
  962. *d = *s;
  963. ++d;
  964. s+=2;
  965. }
  966. break;
  967. case 64:
  968. while (d<de)
  969. {
  970. *d = *s;
  971. ++d;
  972. s+=4;
  973. }
  974. break;
  975. }
  977. Dst += DstPitch;
  979. switch (ScaleY)
  980. {
  981. case 4:
  982. if ((y&3)==3) Src += SrcPitch;
  983. break;
  984. case 8:
  985. if (y&1) Src += SrcPitch;
  986. break;
  987. case 16:
  988. Src += SrcPitch;
  989. break;
  990. case 32:
  991. Src += SrcPitch*2;
  992. break;
  993. case 64:
  994. Src += SrcPitch*4;
  995. break;
  996. }
  997. }
  998. }
  1000. // needed for half/quarter software idct mode changes
  1001. static void STDCALL Blit_PYUV_PYUV_2(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,
  1002.                   int Width,int Height,uintptr_t Src2SrcLast) 
  1003. {
  1004. Blit_PYUV_PYUV_2Plane(SrcPtr[0],DstPtr[0],Width,Height,SrcPitch,DstPitch,This->RScaleX,This->RScaleY);
  1006. Width >>= This->SrcUVX2;
  1007. Height >>= This->SrcUVY2;
  1008. SrcPitch >>= This->SrcUVPitch2;
  1009. DstPitch >>= This->DstUVPitch2;
  1011. Blit_PYUV_PYUV_2Plane(SrcPtr[1],DstPtr[1],Width,Height,SrcPitch,DstPitch,This->RScaleX,This->RScaleY);
  1012. Blit_PYUV_PYUV_2Plane(SrcPtr[2],DstPtr[2],Width,Height,SrcPitch,DstPitch,This->RScaleX,This->RScaleY);
  1013. }
  1015. #if defined(_M_IX86) || !defined(CONFIG_DYNCODE) || defined(BLITTEST)
  1017. // !SwapXY
  1018. // !DstLeftRight
  1019. // SrcType == 12
  1020. // DstType == 12
  1021. // RScaleX == 16 && RScaleY == 16
  1022. // SrcUVX2 == DstUVX2
  1024. static void STDCALL Blit_PYUV_PYUV(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,
  1025.                int Width,int Height,uintptr_t Src2SrcLast) 
  1026. {
  1027. uint8_t* Src[3];
  1028. uint8_t* Dst[3];
  1030. uint8_t* LookUp = This->LookUp_Data;
  1031. int UVY = 1 << This->DstUVY2;
  1032. int UVDup = 1;
  1033. int SrcPitchUV = SrcPitch >> This->SrcUVPitch2;
  1034. int DstPitchUV = DstPitch >> This->DstUVPitch2;
  1035. int WidthUV = Width >> This->SrcUVX2;
  1036. int YAdd = This->FX.Brightness;
  1037. int x,y,i;
  1039. for (i=0;i<3;++i)
  1040. {
  1041. Src[i] = SrcPtr[i];
  1042. Dst[i] = DstPtr[i];
  1043. }
  1045. // skip some UV lines?
  1046. if (This->DstUVY2 > This->SrcUVY2)
  1047. SrcPitchUV <<= This->DstUVY2 - This->SrcUVY2;
  1048. else
  1049. UVDup = 1 << (This->SrcUVY2 - This->DstUVY2);
  1051. Height >>= This->DstUVY2;
  1053. for (y=0;y<Height;++y)
  1054. {
  1055. for (i=0;i<UVY;++i)
  1056. {
  1057. if (LookUp)
  1058. {
  1059. uint8_t* s = Src[0];
  1060. uint8_t* d = Dst[0];
  1061. for (x=0;x<Width;++x,++s,++d)
  1062. *d = LookUp[*s];
  1063. }
  1064. else
  1065. if (YAdd)
  1066. {
  1067. uint8_t* s = Src[0];
  1068. uint8_t* d = Dst[0];
  1069. for (x=0;x<Width;++x,++s,++d)
  1070. {
  1071. int Y = *s + YAdd;
  1072. Y = SAT(Y);
  1073. *d = (uint8_t)Y;
  1074. }
  1075. }
  1076. else
  1077. memcpy(Dst[0],Src[0],Width);
  1079. Src[0] += SrcPitch;
  1080. Dst[0] += DstPitch;
  1081. }
  1083. for (i=0;i<UVDup;++i)
  1084. {
  1085. if (LookUp)
  1086. {
  1087. for (x=0;x<WidthUV;++x)
  1088. {
  1089. Dst[1][x] = LookUp[256+Src[1][x]];
  1090. Dst[2][x] = LookUp[512+Src[2][x]];
  1091. }
  1092. }
  1093. else
  1094. {
  1095. memcpy(Dst[1],Src[1],WidthUV);
  1096. memcpy(Dst[2],Src[2],WidthUV);
  1097. }
  1099. Dst[1] += DstPitchUV;
  1100. Dst[2] += DstPitchUV;
  1101. }
  1103. Src[1] += SrcPitchUV;
  1104. Src[2] += SrcPitchUV;
  1105. }
  1106. }
  1108. // !SwapXY
  1109. // !DstLeftRight
  1110. // SrcType == 10
  1111. // SrcUVX2 == 1
  1112. // DstType == 8 00000000rrrrrrrrggggggggbbbbbbbb
  1114. static void STDCALL Blit_PYUV_RGB32(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,
  1115.                  int Width,int Height,uintptr_t Src2SrcLast) 
  1116. {
  1117. int i,x,y;
  1118. uint8_t* Src[3];
  1119. uint8_t* Dst;
  1120. int SrcStepX[16];
  1121. int SrcStepY[16];
  1122. int SrcUVY2 = This->SrcUVY2;
  1123. int SrcUVPitch2 = This->SrcUVPitch2;
  1125. int YAdd = This->FX.Brightness;
  1126. int sy0;
  1127. int sy=0;
  1129. for (i=0;i<3;++i)
  1130. Src[i] = SrcPtr[i];
  1131. Dst = DstPtr[0];
  1133. for (i=0;i<16;++i)
  1134. {
  1135. SrcStepX[i] = ((This->RScaleX * (i+1)) >> 4) - ((This->RScaleX * i) >> 4);
  1136. SrcStepY[i] = ((This->RScaleY * (i+1)) >> 4) - ((This->RScaleY * i) >> 4);
  1137. }
  1139. for (y=0;y<Height;++y)
  1140. {
  1141. uint8_t* dx = Dst;
  1142. int sx = 0;
  1144. for (x=0;x<Width;++x)
  1145. {
  1146. int cR,cG,cB;
  1147. int sx2 = sx>>1;
  1149. cR = ((Src[0][sx]+YAdd-16)*0x2568       + 0x3343*(Src[2][sx2]-128)) /0x2000;
  1150. cG = ((Src[0][sx]+YAdd-16)*0x2568 - 0x0c92*(Src[1][sx2]-128)  - 0x1a1e*(Src[2][sx2]-128)) /0x2000;
  1151. cB = ((Src[0][sx]+YAdd-16)*0x2568 + 0x40cf*(Src[1][sx2]-128))                             /0x2000;
  1153. cR = SAT(cR);
  1154. cG = SAT(cG);
  1155. cB = SAT(cB);
  1157. do
  1158. {
  1159. dx[0]=(uint8_t)cB;
  1160. dx[1]=(uint8_t)cG;
  1161. dx[2]=(uint8_t)cR;
  1162. dx+=4;
  1163. } while (SrcStepX[x&15]==0 && ++x<Width);
  1165. sx += SrcStepX[x&15];
  1166. }
  1167. Dst += DstPitch;
  1169. while (SrcStepY[y&15]==0 && ++y<Height)
  1170. {
  1171. memcpy(Dst,Dst-DstPitch,4*Width);
  1172. Dst += DstPitch;
  1173. }
  1175. sy0 = sy;
  1176. sy += SrcStepY[y&15];
  1177. Src[0] += SrcPitch * (sy - sy0);
  1178. Src[1] += (SrcPitch >> SrcUVPitch2) * ((sy >> SrcUVY2) - (sy0 >> SrcUVY2));
  1179. Src[2] += (SrcPitch >> SrcUVPitch2) * ((sy >> SrcUVY2) - (sy0 >> SrcUVY2));
  1180. }
  1181. }
  1183. // !SwapXY
  1184. // !DstLeftRight
  1185. // SrcType == 10
  1186. // SrcUVX2 == 1
  1187. // DstType == 6 rrrrrggggggbbbbb
  1189. static void STDCALL Blit_PYUV_RGB16(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,
  1190.                  int Width,int Height,uintptr_t Src2SrcLast) 
  1191. {
  1192. int i,x,y;
  1193. uint8_t* Src[3];
  1194. uint8_t* Dst;
  1195. int SrcStepX[16];
  1196. int SrcStepY[16];
  1197. int SrcUVY2 = This->SrcUVY2;
  1198. int SrcUVPitch2 = This->SrcUVPitch2;
  1200. int YAdd = This->FX.Brightness;
  1201. int sy0;
  1202. int sy=0;
  1204. for (i=0;i<3;++i)
  1205. Src[i] = SrcPtr[i];
  1206. Dst = DstPtr[0];
  1208. for (i=0;i<16;++i)
  1209. {
  1210. SrcStepX[i] = ((This->RScaleX * (i+1)) >> 4) - ((This->RScaleX * i) >> 4);
  1211. SrcStepY[i] = ((This->RScaleY * (i+1)) >> 4) - ((This->RScaleY * i) >> 4);
  1212. }
  1214. for (y=0;y<Height;++y)
  1215. {
  1216. uint16_t* dx = (uint16_t*)Dst;
  1217. int sx = 0;
  1219. for (x=0;x<Width;++x)
  1220. {
  1221. int cR,cG,cB;
  1222. int sx2 = sx>>1;
  1224. cR = ((Src[0][sx]+YAdd-16)*0x2568       + 0x3343*(Src[2][sx2]-128)) /0x2000;
  1225. cG = ((Src[0][sx]+YAdd-16)*0x2568 - 0x0c92*(Src[1][sx2]-128)  - 0x1a1e*(Src[2][sx2]-128)) /0x2000;
  1226. cB = ((Src[0][sx]+YAdd-16)*0x2568 + 0x40cf*(Src[1][sx2]-128))                             /0x2000;
  1228. cR = SAT(cR);
  1229. cG = SAT(cG);
  1230. cB = SAT(cB);
  1232. do
  1233. {
  1234. *dx = (uint16_t)(((cR << 8)&0xF800)|((cG << 3)&0x07E0)|(cB >> 3));
  1235. ++dx;
  1236. } while (SrcStepX[x&15]==0 && ++x<Width);
  1238. sx += SrcStepX[x&15];
  1239. }
  1240. Dst += DstPitch;
  1242. while (SrcStepY[y&15]==0 && ++y<Height)
  1243. {
  1244. memcpy(Dst,Dst-DstPitch,2*Width);
  1245. Dst += DstPitch;
  1246. }
  1248. sy0 = sy;
  1249. sy += SrcStepY[y&15];
  1250. Src[0] += SrcPitch * (sy - sy0);
  1251. Src[1] += (SrcPitch >> SrcUVPitch2) * ((sy >> SrcUVY2) - (sy0 >> SrcUVY2));
  1252. Src[2] += (SrcPitch >> SrcUVPitch2) * ((sy >> SrcUVY2) - (sy0 >> SrcUVY2));
  1253. }
  1254. }
  1256. static void STDCALL BlitUniversal(blit_soft* This, uint8_t** DstPtr,uint8_t** SrcPtr,int DstPitch,int SrcPitch,
  1257.                int Width,int Height,uintptr_t Src2SrcLast) 
  1258. {
  1259. //this will be very-very slow, only for compability and testing
  1261. int i,j,x,y;
  1263. uint8_t* Src[3];
  1264. uint8_t* Dst[3];
  1266. int SrcType = This->SrcType;
  1267. int DstType = This->DstType;
  1269. int DstMask[3],DstPos[3];
  1270. int SrcMask[3],SrcPos[3];
  1271. int DitherMask[3];
  1273. uint8_t* PalLookUp = (uint8_t*)This->LookUp_Data;
  1274. uint8_t* wp;
  1275. int Flags = This->FX.Flags;
  1276. bool_t Dither = (Flags & BLITFX_DITHER) != 0 && !(This->Dst.Flags & PF_FOURCC);
  1277. bool_t PalDither = Dither && (This->Dst.Flags & PF_PALETTE);
  1279. const rgb* SrcPalette = This->SrcPalette;
  1281. int SrcStepX[16];
  1282. int SrcStepY[16];
  1283. int RScaleX = This->RScaleX;
  1284. int RScaleY = This->RScaleY;
  1286. int SrcUVPitch2 = This->SrcUVPitch2;
  1287. int SrcUVX2 = This->SrcUVX2;
  1288. int SrcUVY2 = This->SrcUVY2;
  1289. int DstUVX2 = This->DstUVX2;
  1290. int DstUVY2 = This->DstUVY2;
  1291. int DstStepX = This->DstBPP;
  1292. int DstStepX2 = This->DstBPP;
  1293. int DstStepY = DstPitch << 3;
  1294. int DstStepY2 = DstStepY >> This->DstUVPitch2;
  1295. int dy = 0;
  1296. int dy2 = 0;
  1298. int cR,cG,cB;
  1299. int Y,U,V;
  1300. int sy0;
  1301. int sy=0;
  1302. int YAdd = This->FX.Brightness;
  1304. uint32_t SrcInvert = 0;
  1305. uint32_t DstInvert = 0;
  1307. SrcMask[0] = This->Src.BitMask[0];
  1308. SrcMask[1] = This->Src.BitMask[1];
  1309. SrcMask[2] = This->Src.BitMask[2];
  1311. DstMask[0] = This->Dst.BitMask[0];
  1312. DstMask[1] = This->Dst.BitMask[1];
  1313. DstMask[2] = This->Dst.BitMask[2];
  1315. for (i=0;i<3;++i)
  1316. {
  1317. DitherMask[i] = Dither ? (1 << (8 - BitMaskSize(DstMask[i]))) - 1 : 0;
  1318. SrcPos[i] = BitMaskPos(SrcMask[i]) + BitMaskSize(SrcMask[i]);
  1319. DstPos[i] = BitMaskPos(DstMask[i]) + BitMaskSize(DstMask[i]);
  1320. SrcMask[i] <<= 8;
  1321. DstMask[i] <<= 8;
  1322. Src[i] = SrcPtr[i];
  1323. Dst[i] = DstPtr[i];
  1324. }
  1326. if (This->DstPalette)
  1327. {
  1328. DstPos[0] = 11;
  1329. DstPos[1] = 7;
  1330. DstPos[2] = 3; 
  1331. DstMask[0] = 0xF0000;
  1332. DstMask[1] = 0x0F000;
  1333. DstMask[2] = 0x00F00;
  1334. }
  1336. for (j=0;j<16;++j)
  1337. {
  1338. SrcStepX[j] = ((RScaleX * (j+1)) >> 4) - ((RScaleX * j) >> 4);
  1339. SrcStepY[j] = ((RScaleY * (j+1)) >> 4) - ((RScaleY * j) >> 4);
  1340. }
  1342. if (This->DstLeftRight)
  1343. {
  1344. DstStepX = -DstStepX;
  1345. DstStepX2 = -DstStepX2;
  1346. if (This->DstBPP < 8)
  1347. dy = 8 - This->DstBPP;
  1348. }
  1350. if (This->SwapXY)
  1351. {
  1352. SwapInt(&DstUVX2,&DstUVY2);
  1353. SwapInt(&DstStepX,&DstStepY);
  1354. SwapInt(&DstStepX2,&DstStepY2);
  1355. }
  1357. cR = (DitherMask[0] >> 1);
  1358. cG = (DitherMask[1] >> 1);
  1359. cB = (DitherMask[2] >> 1);
  1360. Y=U=V=0;
  1362. if (This->Src.Flags & PF_INVERTED)
  1363. SrcInvert = (This->Src.BitCount>=32?0:(1 << This->Src.BitCount))-1;
  1364. if (This->Dst.Flags & PF_INVERTED)
  1365. DstInvert = (This->Dst.BitCount>=32?0:(1 << This->Dst.BitCount))-1;
  1367. for (y=0;y<Height;++y)
  1368. {
  1369. int dx=dy;
  1370. int dx2=dy2;
  1371. int sx=0;
  1373. for (x=0;x<Width;sx+=SrcStepX[x&15],++x,dx+=DstStepX)
  1374. {
  1375. uint8_t* q;
  1376. const rgb* p;
  1377. uint32_t v,w;
  1379. switch (SrcType)
  1380. {
  1381. case 10: //Planar YUV->RGB
  1382. cR += ((Src[0][sx]+YAdd-16)*0x2568               + 0x3343*(Src[2][sx>>SrcUVX2]-128)) /0x2000;
  1383. cG += ((Src[0][sx]+YAdd-16)*0x2568 - 0x0c92*(Src[1][sx>>SrcUVX2]-128)  - 0x1a1e*(Src[2][sx>>SrcUVX2]-128)) /0x2000;
  1384. cB += ((Src[0][sx]+YAdd-16)*0x2568 + 0x40cf*(Src[1][sx>>SrcUVX2]-128))                                     /0x2000;
  1386. cR=SAT(cR);
  1387. cG=SAT(cG);
  1388. cB=SAT(cB);
  1389. break;
  1390. case 11: //Packed YUV->RGB
  1391. cR += ((Src[0][sx*2]+YAdd-16)*0x2568   + 0x3343*(Src[2][4*(sx>>1)]-128)) /0x2000;
  1392. cG += ((Src[0][sx*2]+YAdd-16)*0x2568 - 0x0c92*(Src[1][4*(sx>>1)]-128)  - 0x1a1e*(Src[2][4*(sx>>1)]-128)) /0x2000;
  1393. cB += ((Src[0][sx*2]+YAdd-16)*0x2568 + 0x40cf*(Src[1][4*(sx>>1)]-128))                                   /0x2000;
  1395. cR=SAT(cR);
  1396. cG=SAT(cG);
  1397. cB=SAT(cB);
  1398. break;
  1399. case 12: //Planar YUV->YUV
  1400. Y += Src[0][sx];
  1401. U += Src[1][sx>>SrcUVX2];
  1402. V += Src[2][sx>>SrcUVX2];
  1404. //Y=SAT(Y);
  1405. //U=SAT(U);
  1406. //V=SAT(V);
  1407. break;
  1408. case 13: //Packed YUV->YUV
  1409. Y += Src[0][sx*2];
  1410. U += Src[1][4*(sx>>1)];
  1411. V += Src[2][4*(sx>>1)];
  1413. //Y=SAT(Y);
  1414. //U=SAT(U);
  1415. //V=SAT(V);
  1416. break;
  1417. case 1: //Pal1->RGB
  1418. p = &SrcPalette[ ((Src[0][sx>>3] >> ((~sx)&7)) & 1) ^ SrcInvert];
  1419. cR += p->c.r; cG += p->c.g; cB += p->c.b;
  1421. cR=SAT(cR);
  1422. cG=SAT(cG);
  1423. cB=SAT(cB);
  1424. break;
  1425. case 2: //Pal2->RGB
  1426. p = &SrcPalette[ ((Src[0][sx>>2] >> (((~sx)&3)*2)) & 3) ^ SrcInvert];
  1427. cR += p->c.r; cG += p->c.g; cB += p->c.b;
  1429. cR=SAT(cR);
  1430. cG=SAT(cG);
  1431. cB=SAT(cB);
  1432. break;
  1433. case 3: //Pal4->RGB
  1434. p = &SrcPalette[ ((Src[0][sx>>1] >> (((~sx)&1)*4)) & 15) ^ SrcInvert];
  1435. cR += p->c.r; cG += p->c.g; cB += p->c.b;
  1437. cR=SAT(cR);
  1438. cG=SAT(cG);
  1439. cB=SAT(cB);
  1440. break;
  1441. case 4: //Pal8->RGB
  1442. p = &SrcPalette[Src[0][sx] ^ SrcInvert];
  1443. cR += p->c.r; cG += p->c.g; cB += p->c.b;
  1445. cR=SAT(cR);
  1446. cG=SAT(cG);
  1447. cB=SAT(cB);
  1448. break;
  1449. case 5: //RGB8->RGB
  1450. v = Src[0][sx];
  1451. v ^= SrcInvert;
  1452. v <<= 8;
  1453. cR += (v & SrcMask[0]) >> SrcPos[0];
  1454. cG += (v & SrcMask[1]) >> SrcPos[1];
  1455. cB += (v & SrcMask[2]) >> SrcPos[2];
  1457. cR=SAT(cR);
  1458. cG=SAT(cG);
  1459. cB=SAT(cB);
  1460. break;
  1461. case 6: //RGB16->RGB
  1462. v = ((uint16_t*)Src[0])[sx];
  1463. v ^= SrcInvert;
  1464. v <<= 8;
  1465. cR += (v & SrcMask[0]) >> SrcPos[0];
  1466. cG += (v & SrcMask[1]) >> SrcPos[1];
  1467. cB += (v & SrcMask[2]) >> SrcPos[2];
  1469. cR=SAT(cR);
  1470. cG=SAT(cG);
  1471. cB=SAT(cB);
  1472. break;
  1473. case 7: //RGB24->RGB
  1474. v = Src[0][sx*3] | (Src[0][sx*3+1] << 8) | (Src[0][sx*3+2] << 16);
  1475. v ^= SrcInvert;
  1476. v <<= 8;
  1477. cR += (v & SrcMask[0]) >> SrcPos[0];
  1478. cG += (v & SrcMask[1]) >> SrcPos[1];
  1479. cB += (v & SrcMask[2]) >> SrcPos[2];
  1481. cR=SAT(cR);
  1482. cG=SAT(cG);
  1483. cB=SAT(cB);
  1484. break;
  1485. default: //RGB32->RGB
  1486. v = ((uint32_t*)Src[0])[sx];
  1487. v ^= SrcInvert;
  1488. v <<= 8;
  1489. cR += (v & SrcMask[0]) >> SrcPos[0];
  1490. cG += (v & SrcMask[1]) >> SrcPos[1];
  1491. cB += (v & SrcMask[2]) >> SrcPos[2];
  1493. cR=SAT(cR);
  1494. cG=SAT(cG);
  1495. cB=SAT(cB);
  1496. break;
  1497. }
  1499. q = Dst[0]+(dx >> 3);
  1500. switch (DstType)
  1501. {
  1502. case 10: //RGB->Planar YUV
  1503. Y = ((2105 * cR) + (4128 * cG) + (802 * cB))/0x2000 + 16;
  1504. U = (-(1212 * cR) - (2384 * cG) + (3596 * cB))/0x2000 + 128;
  1505. V = ((3596 * cR) - (3015 * cG) - (582 * cB))/0x2000 + 128;
  1507. *q = (uint8_t)Y;
  1508. Dst[1][dx2 >> 3] = (uint8_t)U;
  1509. Dst[2][dx2 >> 3] = (uint8_t)V;
  1510. if ((x & 1) || DstUVX2==0)
  1511. dx2+=DstStepX2;
  1512. cR=cG=cB=0;
  1513. break;
  1514. case 11: //RGB->Packed YUV
  1515. Y = ((2105 * cR) + (4128 * cG) + (802 * cB))/0x2000 + 16;
  1516. U = (-(1212 * cR) - (2384 * cG) + (3596 * cB))/0x2000 + 128;
  1517. V = ((3596 * cR) - (3015 * cG) - (582 * cB))/0x2000 + 128;
  1518. Y=SAT(Y);
  1519. U=SAT(U);
  1520. V=SAT(V);
  1521. *q = (uint8_t)Y;
  1522. Dst[1][4*(dx >> 5)] = (uint8_t)U;
  1523. Dst[2][4*(dx >> 5)] = (uint8_t)V;
  1524. cR=cG=cB=0;
  1525. break;
  1526. case 12: //YUV->Planar YUV
  1527. Y += YAdd;
  1528. Y=SAT(Y);
  1529. *q = (uint8_t)Y;
  1530. Dst[1][dx2 >> 3] = (uint8_t)U;
  1531. Dst[2][dx2 >> 3] = (uint8_t)V;
  1532. if ((x & 1) || DstUVX2==0)
  1533. dx2+=DstStepX2;
  1534. Y=U=V=0;
  1535. break;
  1536. case 13: //YUV->Packed YUV
  1537. Y += YAdd;
  1538. Y=SAT(Y);
  1539. *q = (uint8_t)Y;
  1540. Dst[1][4*(dx >> 5)] = (uint8_t)U;
  1541. Dst[2][4*(dx >> 5)] = (uint8_t)V;
  1542. Y=U=V=0;
  1543. break;
  1544. case 1: //RGB->Pal1
  1545. w = ((cR << DstPos[0]) & DstMask[0]) |
  1546. ((cG << DstPos[1]) & DstMask[1]) |
  1547. ((cB << DstPos[2]) & DstMask[2]);
  1549. wp = PalLookUp + (w >> 8)*4;
  1550. w = wp[0];
  1551. w ^= DstInvert;
  1552. *q &= ~(1 << ((~dx)&7));
  1553. *q |=  (w << ((~dx)&7));
  1555. if (PalDither)
  1556. {
  1557. cR -= wp[1];
  1558. cG -= wp[2];
  1559. cB -= wp[3];
  1560. }
  1561. else
  1562. cR=cG=cB=0;
  1563. break;
  1564. case 2: //RGB->Pal2
  1565. w = ((cR << DstPos[0]) & DstMask[0]) |
  1566. ((cG << DstPos[1]) & DstMask[1]) |
  1567. ((cB << DstPos[2]) & DstMask[2]);
  1569. wp = PalLookUp + (w >> 8)*4;
  1570. w = wp[0];
  1571. w ^= DstInvert;
  1572. *q &= ~(3 << ((~dx)&6));
  1573. *q |=  (w << ((~dx)&6));
  1575. if (PalDither)
  1576. {
  1577. cR -= wp[1];
  1578. cG -= wp[2];
  1579. cB -= wp[3];
  1580. }
  1581. else
  1582. cR=cG=cB=0;
  1583. break;
  1584. case 3: //RGB->Pal4
  1585. w = ((cR << DstPos[0]) & DstMask[0]) |
  1586. ((cG << DstPos[1]) & DstMask[1]) |
  1587. ((cB << DstPos[2]) & DstMask[2]);
  1589. wp = PalLookUp + (w >> 8)*4;
  1590. w = wp[0];
  1591. w ^= DstInvert;
  1592. *q &= ~(15 << ((~dx)&4));
  1593. *q |=  (w  << ((~dx)&4));
  1595. if (PalDither)
  1596. {
  1597. cR -= wp[1];
  1598. cG -= wp[2];
  1599. cB -= wp[3];
  1600. }
  1601. else
  1602. cR=cG=cB=0;
  1603. break;
  1604. case 14: //YUV->Pal8
  1605. w = ((Y << DstPos[0]) & DstMask[0]) |
  1606. ((U << DstPos[1]) & DstMask[1]) |
  1607. ((V << DstPos[2]) & DstMask[2]);
  1609. wp = PalLookUp + (w >> 8)*4;
  1610. w = wp[0];
  1611. w ^= DstInvert;
  1612. *q = (uint8_t)w;
  1614. if (PalDither)
  1615. {
  1616. Y -= wp[1];
  1617. U -= wp[2];
  1618. V -= wp[3];
  1619. }
  1620. else
  1621. Y=U=V=0;
  1622. break;
  1624. case 4: //RGB->Pal8
  1625. w = ((cR << DstPos[0]) & DstMask[0]) |
  1626. ((cG << DstPos[1]) & DstMask[1]) |
  1627. ((cB << DstPos[2]) & DstMask[2]);
  1629. wp = PalLookUp + (w >> 8)*4;
  1630. w = wp[0];
  1631. w ^= DstInvert;
  1632. *q = (uint8_t)w;
  1633. if (PalDither)
  1634. {
  1635. cR -= wp[1];
  1636. cG -= wp[2];
  1637. cB -= wp[3];
  1638. }
  1639. else
  1640. cR=cG=cB=0;
  1641. break;
  1642. case 5: //RGB->RGB8
  1643. w = ((cR << DstPos[0]) & DstMask[0]) |
  1644. ((cG << DstPos[1]) & DstMask[1]) |
  1645. ((cB << DstPos[2]) & DstMask[2]);
  1646. *q = (uint8_t)((w >> 8) ^ DstInvert);
  1647. cR &= DitherMask[0];
  1648. cG &= DitherMask[1];
  1649. cB &= DitherMask[2];
  1650. break;
  1651. case 6: //RGB->RGB16
  1652. w = ((cR << DstPos[0]) & DstMask[0]) |
  1653. ((cG << DstPos[1]) & DstMask[1]) |
  1654. ((cB << DstPos[2]) & DstMask[2]);
  1655. *(uint16_t*)q = (uint16_t)((w >> 8) ^ DstInvert);
  1656. cR &= DitherMask[0];
  1657. cG &= DitherMask[1];
  1658. cB &= DitherMask[2];
  1659. break;
  1660. case 7: //RGB->RGB24
  1661. w = ((cR << DstPos[0]) & DstMask[0]) |
  1662. ((cG << DstPos[1]) & DstMask[1]) |
  1663. ((cB << DstPos[2]) & DstMask[2]);
  1664. w >>= 8;
  1665. w ^= DstInvert;
  1666. q[0] = (uint8_t)(w);
  1667. q[1] = (uint8_t)(w >> 8);
  1668. q[2] = (uint8_t)(w >> 16);
  1669. cR &= DitherMask[0];
  1670. cG &= DitherMask[1];
  1671. cB &= DitherMask[2];
  1672. break;
  1673. default: //RGB->RGB32
  1674. w = ((cR << DstPos[0]) & DstMask[0]) |
  1675. ((cG << DstPos[1]) & DstMask[1]) |
  1676. ((cB << DstPos[2]) & DstMask[2]);
  1677. *(uint32_t*)q = (w >> 8) ^ DstInvert;
  1678. cR &= DitherMask[0];
  1679. cG &= DitherMask[1];
  1680. cB &= DitherMask[2];
  1681. break;
  1682. }
  1683. }
  1685. dy += DstStepY;
  1686. if ((y & 1) || DstUVY2==0)
  1687. dy2 += DstStepY2;
  1689. sy0 = sy;
  1690. sy += SrcStepY[y&15];
  1691. Src[0] += SrcPitch * (sy - sy0);
  1692. Src[1] += (SrcPitch >> SrcUVPitch2) * ((sy >> SrcUVY2) - (sy0 >> SrcUVY2));
  1693. Src[2] += (SrcPitch >> SrcUVPitch2) * ((sy >> SrcUVY2) - (sy0 >> SrcUVY2));
  1694. }
  1695. }
  1697. #endif
  1699. static bool_t BlitCompile(blit_soft* p,
  1700.    const pixel* NewDst,const pixel* NewSrc,
  1701.       const blitfx* NewFX,bool_t NewOnlyDiff)
  1702. {
  1703. int i;
  1704. bool_t Gray,SrcPlanarYUV,DstPlanarYUV;
  1706. if (EqPixel(&p->Dst,NewDst) && 
  1707. EqPixel(&p->Src,NewSrc) && 
  1708. EqBlitFX(&p->FX,NewFX) &&
  1709. NewOnlyDiff == p->OnlyDiff)
  1710. return p->Entry != NULL;
  1712. CodeStart(&p->Code);
  1714. // defaults
  1715. p->Caps = VC_BRIGHTNESS|VC_DITHER|VC_SATURATION|VC_CONTRAST|VC_RGBADJUST;
  1716. p->SrcAlignPos = 2;
  1717. p->DstAlignPos = 2;
  1718. p->DstAlignSize = 2;
  1720. p->Dst = *NewDst;
  1721. p->Src = *NewSrc;
  1722. p->FX = *NewFX;
  1723. p->OnlyDiff = (boolmem_t)NewOnlyDiff;
  1724. p->SwapXY = (boolmem_t)((p->FX.Direction & DIR_SWAPXY) != 0);
  1725. p->DstLeftRight = (boolmem_t)((p->FX.Direction & DIR_MIRRORLEFTRIGHT) != 0);
  1726. p->DstUpDown = (boolmem_t)((p->FX.Direction & DIR_MIRRORUPDOWN) != 0);
  1727. p->SrcUpDown = (boolmem_t)((p->FX.Flags & BLITFX_AVOIDTEARING) && !p->SwapXY && p->DstUpDown != ((p->FX.Flags & BLITFX_VMEMUPDOWN) != 0));
  1728. if (p->SrcUpDown)
  1729. p->DstUpDown = (boolmem_t)!p->DstUpDown;
  1731. // it's faster using slices with rotation (not just with AVOIDTEARING)
  1732. // probably because of ram page trashing (during vertical writing)
  1733. p->Slices = (boolmem_t)(p->SwapXY != ((p->FX.Flags & BLITFX_VMEMROTATED) != 0));
  1734. p->SlicesReverse = (boolmem_t)((p->SwapXY ? p->DstUpDown : p->DstLeftRight) == ((p->FX.Flags & BLITFX_VMEMUPDOWN) != 0));
  1736. Gray = (p->Dst.Flags & PF_PALETTE) && (p->Dst.BitCount == 4 || p->Dst.BitCount == 2);
  1737. p->RScaleX = CalcRScale(p->FX.ScaleX,Gray);
  1738. p->RScaleY = CalcRScale(p->FX.ScaleY,Gray);
  1740. // important these integeres should be 1 or 0
  1741. p->DstHalfX = p->SrcHalfX = p->RScaleX == 32;
  1742. p->DstHalfY = p->SrcHalfY = p->RScaleY == 32;
  1743. p->DstDoubleX = p->SrcDoubleX = p->RScaleX == 8;
  1744. p->DstDoubleY = p->SrcDoubleY = p->RScaleY == 8;
  1745. if (p->SwapXY)
  1746. {
  1747. SwapInt(&p->DstHalfX,&p->DstHalfY);
  1748. SwapInt(&p->DstDoubleX,&p->DstDoubleY);
  1749. }
  1751. p->SrcBPP = GetBPP(&p->Src);
  1752. p->SrcBPP2 = -3;
  1753. for (i=p->SrcBPP;i>1;i>>=1)
  1754. ++p->SrcBPP2;
  1756. p->DstBPP = GetBPP(&p->Dst);
  1757. p->DstBPP2 = -3;
  1758. for (i=p->DstBPP;i>1;i>>=1)
  1759. ++p->DstBPP2;
  1761. p->SrcYUV = (boolmem_t)AnyYUV(&p->Src);
  1762. p->SrcPalette = DefaultPal(&p->Src);
  1763. p->DstPalette = DefaultPal(&p->Dst);
  1765. free(p->LookUp_Data);
  1766. p->LookUp_Data = NULL;
  1768. p->ColorLookup = (boolmem_t)((p->FX.Flags & BLITFX_COLOR_LOOKUP) != 0);
  1769. #ifdef ARM
  1770. p->ARM5 = (boolmem_t)((QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_5E)!=0);
  1771. p->WMMX = (boolmem_t)((QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX)!=0 && 
  1772.           !QueryAdvanced(ADVANCED_NOWMMX) && (p->Dst.Flags & PF_16ALIGNED) && (p->Src.Flags & PF_16ALIGNED));
  1773. p->QAdd = (boolmem_t)((QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_5E)!=0 && 
  1774.       !p->DstPalette && !p->WMMX && !(p->FX.Flags & BLITFX_DITHER) && !p->ColorLookup);
  1775. #endif
  1776. CalcColor(p);
  1777. if (p->DstPalette)
  1778. BuildPalLookUp(p,p->SrcYUV);
  1780. p->ArithStretch = (boolmem_t)((p->FX.Flags & BLITFX_ARITHSTRETCHALWAYS) != 0);
  1781. if ((p->FX.Flags & BLITFX_ARITHSTRETCH50) && p->RScaleX==32 && p->RScaleY==32)
  1782. p->ArithStretch = 1;
  1783. if (p->DstPalette)
  1784. p->ArithStretch = 0;
  1786. SrcPlanarYUV = PlanarYUV(&p->Src,&p->SrcUVX2,&p->SrcUVY2,&p->SrcUVPitch2);
  1787. DstPlanarYUV = PlanarYUV(&p->Dst,&p->DstUVX2,&p->DstUVY2,&p->DstUVPitch2);
  1789. p->DirX = p->DstLeftRight ? -1:1;
  1790. for (i=0;i<3;++i)
  1791. {
  1792. p->DstSize[i] = BitMaskSize(p->Dst.BitMask[i]);
  1793. p->DstPos[i] = BitMaskPos(p->Dst.BitMask[i]);
  1794. p->SrcSize[i] = BitMaskSize(p->Src.BitMask[i]);
  1795. p->SrcPos[i] = BitMaskPos(p->Src.BitMask[i]);
  1796. }
  1798. #if defined(ARM)
  1799. if ((p->Dst.Flags & PF_RGB) && p->Dst.BitCount==16 && !p->SrcYUV)
  1800. Any_RGB_RGB(p);
  1801. if (!p->SrcYUV && DstPlanarYUV && p->RScaleX==16 && p->RScaleY==16)
  1802. Fix_Any_YUV(p);
  1803. #endif
  1805. #if (defined(ARM) || defined(SH3) || defined(MIPS)) && defined(CONFIG_DYNCODE)
  1806. if (SrcPlanarYUV)
  1807. {
  1808. #if defined(ARM)
  1809. if (DstPlanarYUV && p->RScaleX==16 && p->RScaleY==16 && 
  1810. ((p->SrcUVX2==p->DstUVX2 && p->SrcUVY2==p->DstUVY2 && !(p->SwapXY && p->SrcUVX2 != p->SrcUVY2)) || 
  1811. (p->DstUVX2==1 && p->DstUVY2==1)))
  1812. Fix_Any_YUV(p);
  1814. if (PackedYUV(&p->Dst) && p->RScaleX==16 && p->RScaleY==16 && p->SrcUVY2<2 && p->SrcUVX2<2)
  1815. Fix_PackedYUV_YUV(p);
  1816. #endif
  1817. if ((p->Dst.Flags & (PF_RGB|PF_PALETTE)) && (p->Dst.BitCount == 8 || p->Dst.BitCount == 16 || p->Dst.BitCount == 32))
  1818. {
  1819. #if defined(ARM)
  1820. if (p->Dst.BitCount == 16 && p->WMMX && PlanarYUV420(&p->Src) && 
  1821. (p->RScaleX==16 || p->RScaleX==8 || p->RScaleX==32) && (p->RScaleY==16 || p->RScaleY==8 || p->RScaleY==32))
  1822. WMMXFix_RGB_UV(p);
  1823. else
  1824. if ((p->Dst.BitCount == 16 || p->Dst.BitCount==32) && p->SrcUVX2==1 && p->SrcUVY2==1 && p->RScaleX == 16 && p->RScaleY == 16)
  1825. Fix_RGB_UV(p);
  1826. else
  1827. if (p->Dst.BitCount == 16 && p->SrcUVX2==1 && p->SrcUVY2==1 &&
  1828. (p->RScaleX == 8 || p->RScaleX == 16) && 
  1829. (p->RScaleY == 8 || p->RScaleY == 16) && !p->ArithStretch)
  1830. Fix_RGB_UV(p);
  1831. else
  1832. if (p->Dst.BitCount == 16 && p->SrcUVX2==1 && p->SrcUVY2==1 && p->RScaleX == 32 && p->RScaleY == 32)
  1833. Half_RGB_UV(p);
  1834. else
  1835. Stretch_RGB_UV(p);
  1836. #else
  1837. #if !defined(MIPS)
  1838. if (p->SrcUVX2==1 && p->SrcUVY2==1 && 
  1839. (p->RScaleX == 8 || p->RScaleX == 16) &&
  1840. (p->RScaleY == 8 || p->RScaleY == 16))
  1841. #endif
  1842. Fix_RGB_UV(p);
  1843. #endif
  1844. }
  1845. else
  1846. if (Gray)
  1847. Fix_Gray_UV(p);
  1848. }
  1849. #endif
  1851. CodeBuild(&p->Code);
  1852. if (p->Code.Size)
  1853. p->Entry = (blitsoftentry)p->Code.Code;
  1854. else
  1855. p->Entry = NULL;
  1857. #if defined(_M_IX86) && !defined(TARGET_SYMBIAN)
  1859. if (p->FX.Direction==0 && p->RScaleX==16 && p->RScaleY==16)
  1860. {
  1861. uint32_t In = DefFourCC(&p->Src);
  1862. uint32_t Out = DefFourCC(&p->Dst);
  1863. #ifdef CONFIG_CONTEXT
  1864. int Caps = QueryPlatform(PLATFORM_CAPS);
  1865. #else
  1866. int Caps = CPUCaps();
  1867. #endif
  1868. const blitmmx* i;
  1869. for (i=BlitMMX;i->In;++i)
  1870. if (i->In==In && i->Out==Out)
  1871. {
  1872. p->Caps &= ~VC_DITHER;
  1873. if (AnyYUV(&p->Src))
  1874. CalcYUVMMX(p);
  1875. if (Caps & CAPS_X86_MMX2)
  1876. p->Entry = i->Func[1];
  1877. else if (Caps & CAPS_X86_3DNOW)
  1878. p->Entry = i->Func[2];
  1879. else
  1880. p->Entry = i->Func[0];
  1881. break;
  1882. }
  1883. }
  1885. #endif
  1887. if (!p->Entry)
  1888. {
  1889. // use YUV internal calulaction?
  1890. bool_t YUV = (AnyYUV(&p->Dst) || 
  1891. (p->Dst.BitCount==8 && p->Dst.Flags & PF_PALETTE)) && p->SrcYUV;
  1893. p->DstType = UniversalType(&p->Dst,YUV);
  1894. p->SrcType = UniversalType(&p->Src,YUV);
  1896. #if defined(_M_IX86) || !defined(CONFIG_DYNCODE) || defined(BLITTEST)
  1898. if (p->SrcType>=0 && p->DstType>=0)
  1899. {
  1900. // universal
  1901. if (AnyYUV(&p->Dst)) 
  1902. p->Caps &= ~VC_DITHER;
  1903. else
  1904. p->Caps = VC_BRIGHTNESS | VC_DITHER;
  1905. p->Entry = BlitUniversal; 
  1906. }
  1908. if (p->SrcUVX2 == 1 && !p->SwapXY && !p->DstLeftRight && p->SrcType == 10)
  1909. {
  1910. if (p->DstType == 8 && 
  1911. p->Dst.BitMask[0] == 0xFF0000 &&
  1912. p->Dst.BitMask[1] == 0x00FF00 &&
  1913. p->Dst.BitMask[2] == 0x0000FF)
  1914. {
  1915. p->Caps = VC_BRIGHTNESS;
  1916. p->Entry = Blit_PYUV_RGB32;
  1917. }
  1919. if (p->DstType == 6 && 
  1920. p->Dst.BitMask[0] == 0xF800 &&
  1921. p->Dst.BitMask[1] == 0x07E0 &&
  1922. p->Dst.BitMask[2] == 0x001F)
  1923. {
  1924. p->Caps = VC_BRIGHTNESS;
  1925. p->Entry = Blit_PYUV_RGB16;
  1926. }
  1927. }
  1929. if (p->SrcUVX2 == p->DstUVX2 && !p->SwapXY && !p->DstLeftRight &&
  1930. p->RScaleX == 16 && p->RScaleY==16 &&
  1931. p->SrcType == 12 && p->DstType == 12)
  1932. {
  1933. CalcYUVLookUp(p);
  1934. p->Caps &= ~VC_DITHER;
  1935. p->Entry = Blit_PYUV_PYUV;
  1936. }
  1937. #endif
  1938. if (p->SrcUVX2 == p->DstUVX2 &&
  1939. p->SrcUVY2 == p->DstUVY2 && !p->SwapXY && !p->DstLeftRight &&
  1940. (p->RScaleX != 16 || p->RScaleY != 16) &&
  1941. (p->RScaleX == 16 || p->RScaleX == 8 || p->RScaleX == 32 || p->RScaleX == 4 || p->RScaleX == 64) && 
  1942. (p->RScaleY == 16 || p->RScaleY == 8 || p->RScaleY == 32 || p->RScaleX == 4 || p->RScaleX == 64) && 
  1943. p->SrcType == 12 && p->DstType == 12 &&
  1944. !p->FX.Saturation && !p->FX.Contrast && !p->FX.RGBAdjust[0] && 
  1945. !p->FX.RGBAdjust[1] && !p->FX.RGBAdjust[2] && !p->FX.Brightness)
  1946. {
  1947. p->Caps = 0;
  1948. p->Entry = Blit_PYUV_PYUV_2;
  1949. }
  1950. }
  1952. return p->Entry != NULL;
  1953. }
  1955. blitpack* BlitCreate(const video* Dst, 
  1956.          const video* Src, const blitfx* FX, int* OutCaps)
  1957. {
  1958. blitfx CopyFX;
  1959. bool_t Gray;
  1961. blitpack* p = BlitAlloc();
  1962. if (!p) return NULL;
  1964. if (!FX)
  1965. {
  1966. memset(&CopyFX,0,sizeof(CopyFX));
  1967. CopyFX.ScaleX = SCALE_ONE;
  1968. CopyFX.ScaleY = SCALE_ONE;
  1969. FX = &CopyFX;
  1970. }
  1972. if (!BlitCompile(&p->Code[0],&Dst->Pixel,&Src->Pixel,FX,0) ||
  1973. ((FX->Flags & BLITFX_ONLYDIFF) && !BlitCompile(&p->Code[1],&Dst->Pixel,&Src->Pixel,FX,1)))
  1974. {
  1975. BlitRelease(p);
  1976. return NULL;
  1977. }
  1979. p->FX = *FX;
  1980. p->Dst = *Dst;
  1981. p->Src = *Src;
  1983. Gray = (Dst->Pixel.Flags & PF_PALETTE) && 
  1984.    (Dst->Pixel.BitCount == 4 || Dst->Pixel.BitCount == 2);
  1986. p->RScaleX = CalcRScale(FX->ScaleX,Gray);
  1987. p->RScaleY = CalcRScale(FX->ScaleY,Gray);
  1989. if (OutCaps)
  1990. *OutCaps = p->Code[0].Caps;
  1992. return p;
  1993. }
  1995. static NOINLINE int CMul(blit_soft* p, int64_t* r, int64_t v, bool_t UV)
  1996. {
  1997. int m;
  1999. if (UV)
  2000. {
  2001. m = p->FX.Saturation;
  2002. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2003. m = 4*m+256;
  2004. v *= m;
  2005. if (v<0) 
  2006. v -= 128; 
  2007. else 
  2008. v += 128;
  2009. v >>= 8;
  2010. }
  2012. m = p->FX.Contrast;
  2013. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2014. m = 4*m + 256;
  2015. v *= m;
  2016. if (v<0) 
  2017. v -= 128; 
  2018. else 
  2019. v += 128;
  2020. v >>= 8;
  2022. if (r) *r = v;
  2023. return (int)v;
  2024. }
  2026. static NOINLINE int CAdd(blit_soft* p, int64_t* r, int64_t v, int v0, int vUV)
  2027. {
  2028. int m;
  2030. m = p->FX.Saturation;
  2031. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2032. m = 4*m+256;
  2033. v += ((256 - m) * vUV) >> 1;
  2035. m = p->FX.Contrast;
  2036. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2037. m = 4*m + 256;
  2038. v += ((256 - m)*(v0 - v)) >> 8;
  2040. if (r) *r = v;
  2041. return (int)v;
  2042. }
  2044. static INLINE bool_t InRange32(int64_t v)
  2045. {
  2046. return v >= -MAX_INT && v <= MAX_INT;
  2047. }
  2049. static INLINE uint8_t RotateRight8(int v,int Bits)
  2050. {
  2051. Bits &= 7;
  2052. return (uint8_t)(((v >> Bits) & ((1 << (8-Bits))-1)) | (v << (8-Bits)));
  2053. }
  2055. void CalcPalYUVLookUp(blit_soft* p)
  2056. {
  2057. p->LookUp_Size = 256+4+256+256;
  2058. p->LookUp_Data = malloc(p->LookUp_Size);
  2059. if (p->LookUp_Data)
  2060. {
  2061. int v,i,n = 1<<p->Src.BitCount;
  2062. rgb* Pal = p->Src.Palette;
  2063. uint8_t* LookUp = p->LookUp_Data;
  2064. for (i=0;i<n;++i)
  2065. {
  2066. v = (2105*Pal[i].c.r + 4128*Pal[i].c.g + 802*Pal[i].c.b)/0x2000 + 16 + p->FX.Brightness;
  2067. LookUp[i] = (uint8_t)SAT(v);
  2068. v = (-1212*Pal[i].c.r -2384*Pal[i].c.g + 3596*Pal[i].c.b)/0x2000 + 128;
  2069. LookUp[i+256+4] = (uint8_t)SAT(v);
  2070. v = (3596*Pal[i].c.r -3015*Pal[i].c.g -582*Pal[i].c.b)/0x2000 + 128;
  2071. LookUp[i+256+4+256] = (uint8_t)SAT(v);
  2072. }
  2073. }
  2074. }
  2076. void CalcPalRGBLookUp(blit_soft* p)
  2077. {
  2078. int i,n = 1<<p->Src.BitCount;
  2079. int w = p->Dst.BitCount>>3;
  2080. if (w<2 || w>4) return;
  2081. if (w==3) w=4;
  2083. p->LookUp_Size = w*n;
  2084. p->LookUp_Data = malloc(p->LookUp_Size);
  2085. if (p->LookUp_Data)
  2086. {
  2087. uint16_t* Pal = p->LookUp_Data;
  2088. for (i=0;i<n;++i)
  2089. {
  2090. uint32_t c = RGBToFormat(p->Src.Palette[i].v,&p->Dst);
  2091. if (w==2)
  2092. *(Pal++) = (uint16_t)c;
  2093. else
  2094. {
  2095. *(uint32_t*)Pal = c;
  2096. Pal += 2;
  2097. }
  2098. }
  2099. }
  2100. }
  2102. void CalcYUVLookUp(blit_soft* p)
  2103. {
  2104. if (p->FX.Saturation || p->FX.Contrast || (p->FX.Flags & BLITFX_DITHER) ||
  2105. p->FX.RGBAdjust[0] || p->FX.RGBAdjust[1] || p->FX.RGBAdjust[2])
  2106. {
  2107. p->LookUp_Size = 3*256+4;
  2108. p->LookUp_Data = malloc(p->LookUp_Size);
  2110. if (p->LookUp_Data)
  2111. {
  2112. int Ofs = (p->FX.Flags & BLITFX_DITHER)?-2:0;
  2113. int n;
  2114. uint8_t* i=p->LookUp_Data;
  2115. for (n=0;n<256+4;++n,++i)
  2116. {
  2117. int y = CMul(p,NULL,n+Ofs+p->FX.Brightness+p->FX.RGBAdjust[1]-128,0)+128;
  2118. *i = (uint8_t)SAT(y);
  2119. }
  2120. for (n=0;n<256;++n,++i)
  2121. {
  2122. int u = CMul(p,NULL,n-128-p->FX.RGBAdjust[1]+p->FX.RGBAdjust[2],1)+128;
  2123. *i = (uint8_t)SAT(u);
  2124. }
  2125. for (n=0;n<256;++n,++i)
  2126. {
  2127. int v = CMul(p,NULL,n-128-p->FX.RGBAdjust[1]+p->FX.RGBAdjust[0],1)+128;
  2128. *i = (uint8_t)SAT(v);
  2129. }
  2130. }
  2131. }
  2132. }
  2134. void CalcLookUp(blit_soft* p, bool_t Dither)
  2135. {
  2136. #if defined(ARM)
  2137. const int Safe = 512;
  2139. // 4*256:Y + (256+Safe*2)*n:SAT + 4*256:U + 4*256:V 
  2141. int SatOfsR = 4*256+Safe;
  2142. int SatOfsG = 4*256+Safe;
  2143. int SatOfsB = 4*256+Safe;
  2145. p->LookUp_Size = 4*256*3 + (256+Safe*2);
  2146. if (Dither)
  2147. {
  2148. if (p->DstSize[1] == p->DstSize[0])
  2149. SatOfsG = SatOfsR;
  2150. else
  2151. {
  2152. p->LookUp_Size += (256+Safe*2);
  2153. SatOfsG = SatOfsR + (256+Safe*2);
  2154. }
  2156. if (p->DstSize[2] == p->DstSize[0])
  2157. SatOfsB = SatOfsR;
  2158. else
  2159. if (p->DstSize[2] == p->DstSize[1])
  2160. SatOfsB = SatOfsG;
  2161. else
  2162. {
  2163. p->LookUp_Size += (256+Safe*2);
  2164. SatOfsB = SatOfsG + (256+Safe*2);
  2165. }
  2166. }
  2167. p->LookUp_U = (p->LookUp_Size - 4*256*2) >> 2;
  2168. p->LookUp_V = (p->LookUp_Size - 4*256) >> 2;
  2169. p->LookUp_Data = malloc(p->LookUp_Size);
  2171. if (p->LookUp_Data)
  2172. {
  2173. int v;
  2174. int32_t* YMul = (int32_t*)p->LookUp_Data;
  2175. int32_t* UMul = (int32_t*)p->LookUp_Data + p->LookUp_U;
  2176. int32_t* VMul = (int32_t*)p->LookUp_Data + p->LookUp_V;
  2177. uint8_t* SatR = (uint8_t*)p->LookUp_Data + SatOfsR;
  2178. uint8_t* SatG = (uint8_t*)p->LookUp_Data + SatOfsG;
  2179. uint8_t* SatB = (uint8_t*)p->LookUp_Data + SatOfsB;
  2181. memset(p->LookUp_Data,0,p->LookUp_Size);
  2183. for (v=0;v<256;++v)
  2184. {
  2185. *YMul = (p->_YMul * v) << LOOKUP_FIX;
  2186. *UMul = (((p->_BUMul * v + p->_BAdd + (SatOfsB << 16)) << LOOKUP_FIX) & 0xFFFF0000) |
  2187. (((p->_GUMul * v) >> (16-LOOKUP_FIX)) & 0xFFFF); //BUMul | GUMul
  2188. *VMul = (((p->_RVMul * v + p->_RAdd + (SatOfsR << 16)) << LOOKUP_FIX) & 0xFFFF0000) |
  2189. (((p->_GVMul * v + p->_GAdd + (SatOfsG << 16)) >> (16-LOOKUP_FIX)) & 0xFFFF); //BUMul | GUMul
  2191. ++YMul;
  2192. ++UMul;
  2193. ++VMul;
  2194. }
  2196. if (Dither)
  2197. {
  2198. for (v=-Safe;v<256+Safe;++v)
  2199. {
  2200. SatR[v] = RotateRight8(SAT(v),8-p->DstSize[0]);
  2201. SatG[v] = RotateRight8(SAT(v),8-p->DstSize[1]);
  2202. SatB[v] = RotateRight8(SAT(v),8-p->DstSize[2]);
  2203. }
  2204. }
  2205. else
  2206. {
  2207. for (v=-Safe;v<256+Safe;++v)
  2208. SatR[v] = (uint8_t)SAT(v);
  2209. }
  2210. }
  2211. #elif defined(MIPS)
  2212. const int Safe = 256;
  2214. // 256:Y + (128+Safe*2)*n:SAT + 8*256:U + 8*256:V 
  2216. int SatOfsR = 256+Safe;
  2217. int SatOfsG = 256+Safe;
  2218. int SatOfsB = 256+Safe;
  2220. p->LookUp_Size = 256+8*256*2 + (128+Safe*2);
  2221. if (p->DstSize[1] == p->DstSize[0])
  2222. SatOfsG = SatOfsR;
  2223. else
  2224. {
  2225. p->LookUp_Size += (128+Safe*2);
  2226. SatOfsG = SatOfsR + (128+Safe*2);
  2227. }
  2229. if (p->DstSize[2] == p->DstSize[0])
  2230. SatOfsB = SatOfsR;
  2231. else
  2232. if (p->DstSize[2] == p->DstSize[1])
  2233. SatOfsB = SatOfsG;
  2234. else
  2235. {
  2236. p->LookUp_Size += (128+Safe*2);
  2237. SatOfsB = SatOfsG + (128+Safe*2);
  2238. }
  2239. p->LookUp_U = p->LookUp_Size - 8*256*2;
  2240. p->LookUp_V = p->LookUp_Size - 8*256;
  2241. p->LookUp_Data = malloc(p->LookUp_Size);
  2243. if (p->LookUp_Data)
  2244. {
  2245. int v;
  2246. uint8_t* YMul = (uint8_t*)p->LookUp_Data;
  2247. uint8_t** UMul = (uint8_t**)((uint8_t*)p->LookUp_Data + p->LookUp_U);
  2248. uint8_t** VMul = (uint8_t**)((uint8_t*)p->LookUp_Data + p->LookUp_V);
  2250. uint8_t* SatR = (uint8_t*)p->LookUp_Data + SatOfsR;
  2251. uint8_t* SatG = (uint8_t*)p->LookUp_Data + SatOfsG;
  2252. uint8_t* SatB = (uint8_t*)p->LookUp_Data + SatOfsB;
  2254. memset(p->LookUp_Data,0,p->LookUp_Size);
  2256. for (v=0;v<256;++v)
  2257. {
  2258. *YMul = (uint8_t)((p->_YMul * v) >> 17);
  2260. UMul[0] = SatB + ((p->_BUMul * v + p->_BAdd) >> 17);
  2261. *(int*)&UMul[1] = (p->_GUMul * v) >> 17;
  2263. VMul[0] = SatR + ((p->_RVMul * v + p->_RAdd) >> 17);
  2264. VMul[1] = SatG + ((p->_GVMul * v + p->_GAdd) >> 17);
  2266. ++YMul;
  2267. UMul+=2;
  2268. VMul+=2;
  2269. }
  2271. for (v=-Safe;v<128+Safe;++v)
  2272. {
  2273. SatR[v] = (uint8_t)(SAT(v*2) >> (8-p->DstSize[0]));
  2274. SatG[v] = (uint8_t)(SAT(v*2) >> (8-p->DstSize[1]));
  2275. SatB[v] = (uint8_t)(SAT(v*2) >> (8-p->DstSize[2]));
  2276. }
  2277. }
  2278. #elif defined(SH3)
  2279. const int Safe = 256;
  2281. //LookUp_Data:
  2282. // [128..255|0..127]Y + 384 empty + 4*[128..255|0..127]U + 4*[128..255|0..127]V + (128+Safe*2)*n:SAT 
  2284. int SatOfsR = 256+384+4*256*2+Safe;
  2285. int SatOfsG = 256+384+4*256*2+Safe;
  2286. int SatOfsB = 256+384+4*256*2+Safe;
  2288. p->LookUp_Size = 256+384+4*256*2 + (128+Safe*2);
  2289. if (p->DstSize[1] == p->DstSize[0])
  2290. SatOfsG = SatOfsR;
  2291. else
  2292. {
  2293. p->LookUp_Size += (128+Safe*2);
  2294. SatOfsG = SatOfsR + (128+Safe*2);
  2295. }
  2297. if (p->DstSize[2] == p->DstSize[0])
  2298. SatOfsB = SatOfsR;
  2299. else
  2300. if (p->DstSize[2] == p->DstSize[1])
  2301. SatOfsB = SatOfsG;
  2302. else
  2303. {
  2304. p->LookUp_Size += (128+Safe*2);
  2305. SatOfsB = SatOfsG + (128+Safe*2);
  2306. }
  2307. p->LookUp_U = 128 + 384 + 4*128;
  2308. p->LookUp_V = 128 + 384 + 4*256 + 4*128;
  2309. p->LookUp_Data = malloc(p->LookUp_Size + Safe*2); //additional safe
  2310. if (p->LookUp_Data)
  2311. {
  2312. int v;
  2313. int8_t* YMul = (int8_t*)p->LookUp_Data;
  2314. int16_t* UMul = (int16_t*)((uint8_t*)p->LookUp_Data + 256 + 384);
  2315. int16_t* VMul = (int16_t*)((uint8_t*)p->LookUp_Data + 256 + 384 + 4*256);
  2317. int8_t* SatR = (int8_t*)p->LookUp_Data + SatOfsR;
  2318. int8_t* SatG = (int8_t*)p->LookUp_Data + SatOfsG;
  2319. int8_t* SatB = (int8_t*)p->LookUp_Data + SatOfsB;
  2321. memset(p->LookUp_Data,0,p->LookUp_Size + Safe*2);
  2323. for (v=0;v<256;++v)
  2324. {
  2325. *YMul = (int8_t)(((p->_YMul * ((v+128)&255)) >> 17)-128);
  2327. UMul[0] = (int16_t)(SatOfsB + ((p->_BUMul * ((v+128)&255) + p->_BAdd) >> 17));
  2328. UMul[1] = (int16_t)((p->_GUMul * ((v+128)&255)) >> 17);
  2330. VMul[0] = (int16_t)(SatOfsR + ((p->_RVMul * ((v+128)&255) + p->_RAdd) >> 17));
  2331. VMul[1] = (int16_t)(SatOfsG + ((p->_GVMul * ((v+128)&255) + p->_GAdd) >> 17));
  2333. ++YMul;
  2334. UMul+=2;
  2335. VMul+=2;
  2336. }
  2338. for (v=-Safe;v<128+Safe;++v)
  2339. {
  2340. SatR[v] = (int8_t)(SAT(v*2) >> (8-p->DstSize[0]));
  2341. SatG[v] = (int8_t)(SAT(v*2) >> (8-p->DstSize[1]));
  2342. SatB[v] = (int8_t)(SAT(v*2) >> (8-p->DstSize[2]));
  2343. }
  2344. }
  2345. #endif
  2346. }
  2348. void CalcColor(blit_soft* p)
  2349. {
  2350. #ifdef ARM
  2351. if (p->QAdd)
  2352. {
  2353. //saturation: signed 32bit / 3 (qdadd will triple)
  2354. int64_t YMul;
  2355. int64_t RVMul;
  2356. int64_t RAdd;
  2357. int64_t GUMul;
  2358. int64_t GVMul;
  2359. int64_t GAdd;
  2360. int64_t BUMul;
  2361. int64_t BAdd;
  2363. CMul(p,&YMul,0x63C000,0);
  2364. CMul(p,&RVMul,0x88B2AA,1);
  2365. CAdd(p,&RAdd,(p->FX.Brightness+p->FX.RGBAdjust[0])*0x63C000 - (int64_t)0x75400000,0x2AAAAAAA,0x88B2AA);
  2366. CMul(p,&GUMul,-0x218555,1);
  2367. CMul(p,&GVMul,-0x45A555,1);
  2368. CAdd(p,&GAdd,(p->FX.Brightness+p->FX.RGBAdjust[1])*0x63C000 + (int64_t)0x02AEAAAA,0x2AAAAAAA,-0x218555-0x45A555);
  2369. CMul(p,&BUMul,0xACD2AA,1);
  2370. CAdd(p,&BAdd,(p->FX.Brightness+p->FX.RGBAdjust[2])*0x63C000 - (int64_t)0x87500000,0x2AAAAAAA,0xACD2AA);
  2372. if (InRange32(YMul*0xF0) && 
  2373. InRange32(RVMul*0x10+RAdd) &&
  2374. InRange32(RVMul*0xF0+RAdd) &&
  2375. InRange32((GVMul+GUMul)*0x10+GAdd) &&
  2376. InRange32((GVMul+GUMul)*0xF0+GAdd) &&
  2377. InRange32(BUMul*0x10+BAdd) &&
  2378. InRange32(BUMul*0xF0+BAdd))
  2379. {
  2380. p->_YMul = (int)YMul;
  2381. p->_RVMul = (int)RVMul;
  2382. p->_RAdd = (int)RAdd;
  2383. p->_GUMul = (int)GUMul;
  2384. p->_GVMul = (int)GVMul;
  2385. p->_GAdd = (int)GAdd;
  2386. p->_BUMul = (int)BUMul;
  2387. p->_BAdd = (int)BAdd;
  2388. }
  2389. else
  2390. p->QAdd = 0;
  2391. }
  2392. if (!p->QAdd)
  2393. #endif
  2394. {
  2395. //saturation: unsigned 24bit
  2396. p->_YMul = CMul(p,NULL,0x12B40,0);
  2397. p->_RVMul = CMul(p,NULL,0x19A18,1);
  2398. p->_RAdd = CAdd(p,NULL,(p->FX.Brightness+p->FX.RGBAdjust[0])*0x12B40 - 0x0DFC000,0x800000,0x19A18);
  2399. p->_GUMul = CMul(p,NULL,-0x06490,1);
  2400. p->_GVMul = CMul(p,NULL,-0x0D0F0,1);
  2401. p->_GAdd = CAdd(p,NULL,(p->FX.Brightness+p->FX.RGBAdjust[1])*0x12B40 + 0x0880C00,0x800000,-0x06490-0x0D0F0);
  2402. p->_BUMul = CMul(p,NULL,0x20678,1);
  2403. p->_BAdd = CAdd(p,NULL,(p->FX.Brightness+p->FX.RGBAdjust[2])*0x12B40 - 0x115F000,0x800000,0x20678);
  2404. }
  2405. }
  2408. #if defined(_M_IX86) && !defined(TARGET_SYMBIAN)
  2410. static void ColMMX(blit_soft* p, int i, int ofs)
  2411. {
  2412. int mul = 2048;
  2413. int m;
  2414. int o = 128;
  2416. if (i>0)
  2417. {
  2418. m = p->FX.Saturation;
  2419. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2420. m = 4*m+256;
  2422. mul = (mul*m+128) >> 8;
  2423. ofs += 128 - (m>>1);
  2424. o = (o*m+128)>>8;
  2425. }
  2427. m = p->FX.Contrast;
  2428. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2429. m = 4*m + 256;
  2431. mul = (mul*m+128)>>8;
  2432. ofs += o - ((m*o)>>8);
  2434. if ((p->Src.Flags & PF_YUV_PC) && !(p->Dst.Flags & PF_YUV_PC))
  2435. {
  2436. if (i==0) //y [0..255]->[16..235]
  2437. {
  2438. mul = (mul*219+127)/255;
  2439. ofs = (ofs*219+127)/255+16;
  2440. }
  2441. else //uv [0..255]->[16..240]
  2442. { 
  2443. mul = (mul*224+127)/255;
  2444. ofs = (ofs*224+127)/255+16;
  2445. }
  2446. }
  2447. else
  2448. if (!(p->Src.Flags & PF_YUV_PC) && (p->Dst.Flags & PF_YUV_PC))
  2449. {
  2450. if (i==0) //y [16..235]->[0..255]
  2451. {
  2452. mul = (mul*255+109)/219;
  2453. ofs = ((ofs-16)*255+109)/219;
  2454. }
  2455. else //uv [16..240]->[0..255]
  2456. { 
  2457. mul = (mul*255+112)/224;
  2458. ofs = ((ofs-16)*255+112)/224;
  2459. }
  2460. }
  2462. if (mul<-32768) mul=32768;
  2463. if (mul>32767) mul=32767;
  2465. p->Col[i][0][3] = p->Col[i][0][2] = p->Col[i][0][1] = p->Col[i][0][0] = (int16_t)mul;
  2466. p->Col[i][1][3] = p->Col[i][1][2] = p->Col[i][1][1] = p->Col[i][1][0] = (int16_t)ofs;
  2467. }
  2469. static int16_t MulMMX(blit_soft* p, int i, int mul)
  2470. {
  2471. int m;
  2472. if (i>0)
  2473. {
  2474. m = p->FX.Saturation;
  2475. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2476. m = 4*m+256;
  2478. mul = (mul*m+128) >> 8;
  2479. }
  2481. m = p->FX.Contrast;
  2482. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  2483. m = 4*m + 256;
  2485. mul = (mul*m+128)>>8;
  2487. if (mul<-32768) mul=32768;
  2488. if (mul>32767) mul=32767;
  2489. return (int16_t)mul;
  2490. }
  2492. void CalcYUVMMX(blit_soft* p)
  2493. {
  2494. if (AnyYUV(&p->Dst))
  2495. {
  2496. ColMMX(p,0,p->FX.Brightness+p->FX.RGBAdjust[1]);
  2497. ColMMX(p,1,p->FX.RGBAdjust[2]-p->FX.RGBAdjust[1]);
  2498. ColMMX(p,2,p->FX.RGBAdjust[0]-p->FX.RGBAdjust[1]);
  2499. }
  2500. else
  2501. {
  2502. const int16_t* m = GetYUVToRGB(&p->Src);
  2503. p->Col[0][0][3] = p->Col[0][0][2] = p->Col[0][0][1] = p->Col[0][0][0] = MulMMX(p,0,m[0]);
  2504. p->Col[0][1][3] = p->Col[0][1][2] = p->Col[0][1][1] = p->Col[0][1][0] = (int16_t)(m[1]+p->FX.Brightness+p->FX.RGBAdjust[1]);
  2505. p->Col[1][0][1] = p->Col[1][0][0] = MulMMX(p,1,m[2]); //u_b
  2506. p->Col[1][0][3] = p->Col[1][0][2] = MulMMX(p,1,m[3]); //u_g
  2507. p->Col[1][1][3] = p->Col[1][1][2] = p->Col[1][1][1] = p->Col[1][1][0] = (int16_t)(m[4]+p->FX.RGBAdjust[2]-p->FX.RGBAdjust[1]);
  2508. p->Col[2][0][1] = p->Col[2][0][0] = MulMMX(p,2,m[5]); //v_r
  2509. p->Col[2][0][3] = p->Col[2][0][2] = MulMMX(p,2,m[6]); //v_g
  2510. p->Col[2][1][3] = p->Col[2][1][2] = p->Col[2][1][1] = p->Col[2][1][0] = (int16_t)(m[7]+p->FX.RGBAdjust[0]-p->FX.RGBAdjust[1]);
  2511. }
  2512. }
  2514. #endif