draw.c

   1 /***************************************************************************
   2                           draw.c  -  description
   3                              -------------------
   4     begin                : Sun Oct 28 2001
   5     copyright            : (C) 2001 by Pete Bernert
   6     email                : BlackDove@addcom.de
   7  ***************************************************************************/
   8 /***************************************************************************
   9  *                                                                         *
  10  *   This program is free software; you can redistribute it and/or modify  *
  11  *   it under the terms of the GNU General Public License as published by  *
  12  *   the Free Software Foundation; either version 2 of the License, or     *
  13  *   (at your option) any later version. See also the license.txt file for *
  14  *   additional informations.                                              *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #define _IN_DRAW
  19
  20 #include <X11/Xlib.h>
  21 #include <X11/Xutil.h>
  22 #include <X11/cursorfont.h>
  23
  24 #include "gpu.h"
  25
  26 // misc globals
  27 int            iResX=640;
  28 int            iResY=480;
  29 long           lLowerpart;
  30 BOOL           bIsFirstFrame = TRUE;
  31 BOOL           bCheckMask = FALSE;
  32 unsigned short sSetMask = 0;
  33 unsigned long  lSetMask = 0;
  34 int            iDesktopCol = 16;
  35 int            iShowFPS = 0;
  36 int            iWinSize;
  37 int            iMaintainAspect = 0;
  38 int            iUseNoStretchBlt = 0;
  39 int            iFastFwd = 0;
  40 //int            iDebugMode = 0;
  41 int            iFVDisplay = 0;
  42 PSXPoint_t     ptCursorPoint[8];
  43 unsigned short usCursorActive = 0;
  44 unsigned long  ulKeybits;
  45
  46 int            iWindowMode=1;
  47 int            iColDepth=32;
  48 char           szDispBuf[64];
  49 char           szMenuBuf[36];
  50 char           szDebugText[512];
  51 void InitMenu(void) {}
  52 void CloseMenu(void) {}
  53
  54 //unsigned int   LUT16to32[65536];
  55 //unsigned int   RGBtoYUV[65536];
  56
  57 #include <sys/ipc.h>
  58 #include <sys/shm.h>
  59 #include <X11/extensions/Xv.h>
  60 #include <X11/extensions/Xvlib.h>
  61 #include <X11/extensions/XShm.h>
  62 int xv_port = -1;
  63 int xv_id = -1;
  64 int xv_depth = 0;
  65 int yuv_port = -1;
  66 int yuv_id = -1;
  67 int use_yuv = 0;
  68 int xv_vsync = 0;
  69
  70 XShmSegmentInfo shminfo;
  71 int finalw,finalh;
  72
  73 typedef struct {
  74 #define MWM_HINTS_DECORATIONS   2
  75   long flags;
  76   long functions;
  77   long decorations;
  78   long input_mode;
  79 } MotifWmHints;
  80
  81 extern XvImage  *XvShmCreateImage(Display*, XvPortID, int, char*, int, int, XShmSegmentInfo*);
  82
  83 #include <time.h>
  84
  85 // prototypes
  86 void hq2x_32( unsigned char * srcPtr, DWORD srcPitch, unsigned char * dstPtr, int width, int height);
  87 void hq3x_32( unsigned char * srcPtr,  DWORD srcPitch, unsigned char * dstPtr, int width, int height);
  88
  89 ////////////////////////////////////////////////////////////////////////
  90 // generic 2xSaI helpers
  91 ////////////////////////////////////////////////////////////////////////
  92
  93 void *         pSaISmallBuff=NULL;
  94 void *         pSaIBigBuff=NULL;
  95
  96 #define GET_RESULT(A, B, C, D) ((A != C || A != D) - (B != C || B != D))
  97
  98 static __inline int GetResult1(DWORD A, DWORD B, DWORD C, DWORD D, DWORD E)
  99 {
 100  int x = 0;
 101  int y = 0;
 102  int r = 0;
 103  if (A == C) x+=1; else if (B == C) y+=1;
 104  if (A == D) x+=1; else if (B == D) y+=1;
 105  if (x <= 1) r+=1;
 106  if (y <= 1) r-=1;
 107  return r;
 108 }
 109
 110 static __inline int GetResult2(DWORD A, DWORD B, DWORD C, DWORD D, DWORD E)
 111 {
 112  int x = 0;
 113  int y = 0;
 114  int r = 0;
 115  if (A == C) x+=1; else if (B == C) y+=1;
 116  if (A == D) x+=1; else if (B == D) y+=1;
 117  if (x <= 1) r-=1;
 118  if (y <= 1) r+=1;
 119  return r;
 120 }
 121
 122 #define colorMask8     0x00FEFEFE
 123 #define lowPixelMask8  0x00010101
 124 #define qcolorMask8    0x00FCFCFC
 125 #define qlowpixelMask8 0x00030303
 126
 127 #define INTERPOLATE8(A, B) ((((A & colorMask8) >> 1) + ((B & colorMask8) >> 1) + (A & B & lowPixelMask8)))
 128 #define Q_INTERPOLATE8(A, B, C, D) (((((A & qcolorMask8) >> 2) + ((B & qcolorMask8) >> 2) + ((C & qcolorMask8) >> 2) + ((D & qcolorMask8) >> 2) \
 129         + ((((A & qlowpixelMask8) + (B & qlowpixelMask8) + (C & qlowpixelMask8) + (D & qlowpixelMask8)) >> 2) & qlowpixelMask8))))
 130
 131
 132 void Super2xSaI_ex8(unsigned char *srcPtr, DWORD srcPitch,
 133                     unsigned char  *dstBitmap, int width, int height)
 134 {
 135  DWORD dstPitch        = srcPitch<<1;
 136  DWORD srcPitchHalf    = srcPitch>>1;
 137  int   finWidth        = srcPitch>>2;
 138  DWORD line;
 139  DWORD *dP;
 140  DWORD *bP;
 141  int iXA,iXB,iXC,iYA,iYB,iYC,finish;
 142  DWORD color4, color5, color6;
 143  DWORD color1, color2, color3;
 144  DWORD colorA0, colorA1, colorA2, colorA3,
 145        colorB0, colorB1, colorB2, colorB3,
 146        colorS1, colorS2;
 147  DWORD product1a, product1b,
 148        product2a, product2b;
 149
 150  finalw=width<<1;
 151  finalh=height<<1;
 152
 153  line = 0;
 154
 155   {
 156    for (; height; height-=1)
 157         {
 158      bP = (DWORD *)srcPtr;
 159          dP = (DWORD *)(dstBitmap + line*dstPitch);
 160      for (finish = width; finish; finish -= 1 )
 161       {
 162 //---------------------------------------    B1 B2
 163 //                                         4  5  6 S2
 164 //                                         1  2  3 S1
 165 //                                           A1 A2
 166        if(finish==finWidth) iXA=0;
 167        else                 iXA=1;
 168        if(finish>4) {iXB=1;iXC=2;}
 169        else
 170        if(finish>3) {iXB=1;iXC=1;}
 171        else         {iXB=0;iXC=0;}
 172        if(line==0)  {iYA=0;}
 173        else         {iYA=finWidth;}
 174        if(height>4) {iYB=finWidth;iYC=srcPitchHalf;}
 175        else
 176        if(height>3) {iYB=finWidth;iYC=finWidth;}
 177        else         {iYB=0;iYC=0;}
 178
 179        colorB0 = *(bP- iYA - iXA);
 180        colorB1 = *(bP- iYA);
 181        colorB2 = *(bP- iYA + iXB);
 182        colorB3 = *(bP- iYA + iXC);
 183
 184        color4 = *(bP  - iXA);
 185        color5 = *(bP);
 186        color6 = *(bP  + iXB);
 187        colorS2 = *(bP + iXC);
 188
 189        color1 = *(bP  + iYB  - iXA);
 190        color2 = *(bP  + iYB);
 191        color3 = *(bP  + iYB  + iXB);
 192        colorS1= *(bP  + iYB  + iXC);
 193
 194        colorA0 = *(bP + iYC - iXA);
 195        colorA1 = *(bP + iYC);
 196        colorA2 = *(bP + iYC + iXB);
 197        colorA3 = *(bP + iYC + iXC);
 198
 199        if (color2 == color6 && color5 != color3)
 200         {
 201          product2b = product1b = color2;
 202         }
 203        else
 204        if (color5 == color3 && color2 != color6)
 205         {
 206          product2b = product1b = color5;
 207         }
 208        else
 209        if (color5 == color3 && color2 == color6)
 210         {
 211          register int r = 0;
 212
 213          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color1&0x00ffffff),  (colorA1&0x00ffffff));
 214          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color4&0x00ffffff),  (colorB1&0x00ffffff));
 215          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorA2&0x00ffffff), (colorS1&0x00ffffff));
 216          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorB2&0x00ffffff), (colorS2&0x00ffffff));
 217
 218          if (r > 0)
 219           product2b = product1b = color6;
 220          else
 221          if (r < 0)
 222           product2b = product1b = color5;
 223          else
 224           {
 225            product2b = product1b = INTERPOLATE8(color5, color6);
 226           }
 227         }
 228        else
 229         {
 230          if (color6 == color3 && color3 == colorA1 && color2 != colorA2 && color3 != colorA0)
 231              product2b = Q_INTERPOLATE8 (color3, color3, color3, color2);
 232          else
 233          if (color5 == color2 && color2 == colorA2 && colorA1 != color3 && color2 != colorA3)
 234              product2b = Q_INTERPOLATE8 (color2, color2, color2, color3);
 235          else
 236              product2b = INTERPOLATE8 (color2, color3);
 237
 238          if (color6 == color3 && color6 == colorB1 && color5 != colorB2 && color6 != colorB0)
 239              product1b = Q_INTERPOLATE8 (color6, color6, color6, color5);
 240          else
 241          if (color5 == color2 && color5 == colorB2 && colorB1 != color6 && color5 != colorB3)
 242              product1b = Q_INTERPOLATE8 (color6, color5, color5, color5);
 243          else
 244              product1b = INTERPOLATE8 (color5, color6);
 245         }
 246
 247        if (color5 == color3 && color2 != color6 && color4 == color5 && color5 != colorA2)
 248         product2a = INTERPOLATE8(color2, color5);
 249        else
 250        if (color5 == color1 && color6 == color5 && color4 != color2 && color5 != colorA0)
 251         product2a = INTERPOLATE8(color2, color5);
 252        else
 253         product2a = color2;
 254
 255        if (color2 == color6 && color5 != color3 && color1 == color2 && color2 != colorB2)
 256         product1a = INTERPOLATE8(color2, color5);
 257        else
 258        if (color4 == color2 && color3 == color2 && color1 != color5 && color2 != colorB0)
 259         product1a = INTERPOLATE8(color2, color5);
 260        else
 261         product1a = color5;
 262
 263        *dP=product1a;
 264        *(dP+1)=product1b;
 265        *(dP+(srcPitchHalf))=product2a;
 266        *(dP+1+(srcPitchHalf))=product2b;
 267
 268        bP += 1;
 269        dP += 2;
 270       }//end of for ( finish= width etc..)
 271
 272      line += 2;
 273      srcPtr += srcPitch;
 274         }; //endof: for (; height; height--)
 275   }
 276 }
 277
 278 ////////////////////////////////////////////////////////////////////////
 279
 280 void Std2xSaI_ex8(unsigned char *srcPtr, DWORD srcPitch,
 281                   unsigned char *dstBitmap, int width, int height)
 282 {
 283  DWORD dstPitch        = srcPitch<<1;
 284  DWORD srcPitchHalf    = srcPitch>>1;
 285  int   finWidth        = srcPitch>>2;
 286  DWORD line;
 287  DWORD *dP;
 288  DWORD *bP;
 289  int iXA,iXB,iXC,iYA,iYB,iYC,finish;
 290
 291  finalw=width<<1;
 292  finalh=height<<1;
 293
 294  DWORD colorA, colorB;
 295  DWORD colorC, colorD,
 296        colorE, colorF, colorG, colorH,
 297        colorI, colorJ, colorK, colorL,
 298        colorM, colorN, colorO, colorP;
 299  DWORD product, product1, product2;
 300
 301  line = 0;
 302
 303   {
 304    for (; height; height-=1)
 305         {
 306      bP = (DWORD *)srcPtr;
 307          dP = (DWORD *)(dstBitmap + line*dstPitch);
 308      for (finish = width; finish; finish -= 1 )
 309       {
 310 //---------------------------------------
 311 // Map of the pixels:                    I|E F|J
 312 //                                       G|A B|K
 313 //                                       H|C D|L
 314 //                                       M|N O|P
 315        if(finish==finWidth) iXA=0;
 316        else                 iXA=1;
 317        if(finish>4) {iXB=1;iXC=2;}
 318        else
 319        if(finish>3) {iXB=1;iXC=1;}
 320        else         {iXB=0;iXC=0;}
 321        if(line==0)  {iYA=0;}
 322        else         {iYA=finWidth;}
 323        if(height>4) {iYB=finWidth;iYC=srcPitchHalf;}
 324        else
 325        if(height>3) {iYB=finWidth;iYC=finWidth;}
 326        else         {iYB=0;iYC=0;}
 327
 328        colorI = *(bP- iYA - iXA);
 329        colorE = *(bP- iYA);
 330        colorF = *(bP- iYA + iXB);
 331        colorJ = *(bP- iYA + iXC);
 332
 333        colorG = *(bP  - iXA);
 334        colorA = *(bP);
 335        colorB = *(bP  + iXB);
 336        colorK = *(bP + iXC);
 337
 338        colorH = *(bP  + iYB  - iXA);
 339        colorC = *(bP  + iYB);
 340        colorD = *(bP  + iYB  + iXB);
 341        colorL = *(bP  + iYB  + iXC);
 342
 343        colorM = *(bP + iYC - iXA);
 344        colorN = *(bP + iYC);
 345        colorO = *(bP + iYC + iXB);
 346        colorP = *(bP + iYC + iXC);
 347
 348
 349        if((colorA == colorD) && (colorB != colorC))
 350         {
 351          if(((colorA == colorE) && (colorB == colorL)) ||
 352             ((colorA == colorC) && (colorA == colorF) &&
 353              (colorB != colorE) && (colorB == colorJ)))
 354           {
 355            product = colorA;
 356           }
 357          else
 358           {
 359            product = INTERPOLATE8(colorA, colorB);
 360           }
 361
 362          if(((colorA == colorG) && (colorC == colorO)) ||
 363             ((colorA == colorB) && (colorA == colorH) &&
 364              (colorG != colorC) && (colorC == colorM)))
 365           {
 366            product1 = colorA;
 367           }
 368          else
 369           {
 370            product1 = INTERPOLATE8(colorA, colorC);
 371           }
 372          product2 = colorA;
 373         }
 374        else
 375        if((colorB == colorC) && (colorA != colorD))
 376         {
 377          if(((colorB == colorF) && (colorA == colorH)) ||
 378             ((colorB == colorE) && (colorB == colorD) &&
 379              (colorA != colorF) && (colorA == colorI)))
 380           {
 381            product = colorB;
 382           }
 383          else
 384           {
 385            product = INTERPOLATE8(colorA, colorB);
 386           }
 387
 388          if(((colorC == colorH) && (colorA == colorF)) ||
 389             ((colorC == colorG) && (colorC == colorD) &&
 390              (colorA != colorH) && (colorA == colorI)))
 391           {
 392            product1 = colorC;
 393           }
 394          else
 395           {
 396            product1=INTERPOLATE8(colorA, colorC);
 397           }
 398          product2 = colorB;
 399         }
 400        else
 401        if((colorA == colorD) && (colorB == colorC))
 402         {
 403          if (colorA == colorB)
 404           {
 405            product = colorA;
 406            product1 = colorA;
 407            product2 = colorA;
 408           }
 409          else
 410           {
 411            register int r = 0;
 412            product1 = INTERPOLATE8(colorA, colorC);
 413            product = INTERPOLATE8(colorA, colorB);
 414
 415            r += GetResult1 (colorA&0x00FFFFFF, colorB&0x00FFFFFF, colorG&0x00FFFFFF, colorE&0x00FFFFFF, colorI&0x00FFFFFF);
 416            r += GetResult2 (colorB&0x00FFFFFF, colorA&0x00FFFFFF, colorK&0x00FFFFFF, colorF&0x00FFFFFF, colorJ&0x00FFFFFF);
 417            r += GetResult2 (colorB&0x00FFFFFF, colorA&0x00FFFFFF, colorH&0x00FFFFFF, colorN&0x00FFFFFF, colorM&0x00FFFFFF);
 418            r += GetResult1 (colorA&0x00FFFFFF, colorB&0x00FFFFFF, colorL&0x00FFFFFF, colorO&0x00FFFFFF, colorP&0x00FFFFFF);
 419
 420            if (r > 0)
 421             product2 = colorA;
 422            else
 423            if (r < 0)
 424             product2 = colorB;
 425            else
 426             {
 427              product2 = Q_INTERPOLATE8(colorA, colorB, colorC, colorD);
 428             }
 429           }
 430         }
 431        else
 432         {
 433          product2 = Q_INTERPOLATE8(colorA, colorB, colorC, colorD);
 434
 435          if ((colorA == colorC) && (colorA == colorF) &&
 436              (colorB != colorE) && (colorB == colorJ))
 437           {
 438            product = colorA;
 439           }
 440          else
 441          if ((colorB == colorE) && (colorB == colorD) && (colorA != colorF) && (colorA == colorI))
 442           {
 443            product = colorB;
 444           }
 445          else
 446           {
 447            product = INTERPOLATE8(colorA, colorB);
 448           }
 449
 450          if ((colorA == colorB) && (colorA == colorH) &&
 451              (colorG != colorC) && (colorC == colorM))
 452           {
 453            product1 = colorA;
 454           }
 455          else
 456          if ((colorC == colorG) && (colorC == colorD) &&
 457              (colorA != colorH) && (colorA == colorI))
 458           {
 459            product1 = colorC;
 460           }
 461          else
 462           {
 463            product1 = INTERPOLATE8(colorA, colorC);
 464           }
 465         }
 466
 467 //////////////////////////
 468
 469        *dP=colorA;
 470        *(dP+1)=product;
 471        *(dP+(srcPitchHalf))=product1;
 472        *(dP+1+(srcPitchHalf))=product2;
 473
 474        bP += 1;
 475        dP += 2;
 476       }//end of for ( finish= width etc..)
 477
 478      line += 2;
 479      srcPtr += srcPitch;
 480         }; //endof: for (; height; height--)
 481   }
 482 }
 483
 484 ////////////////////////////////////////////////////////////////////////
 485
 486 void SuperEagle_ex8(unsigned char *srcPtr, DWORD srcPitch,
 487                         unsigned char  *dstBitmap, int width, int height)
 488 {
 489  DWORD dstPitch        = srcPitch<<1;
 490  DWORD srcPitchHalf    = srcPitch>>1;
 491  int   finWidth        = srcPitch>>2;
 492  DWORD line;
 493  DWORD *dP;
 494  DWORD *bP;
 495  int iXA,iXB,iXC,iYA,iYB,iYC,finish;
 496  DWORD color4, color5, color6;
 497  DWORD color1, color2, color3;
 498  DWORD colorA1, colorA2,
 499        colorB1, colorB2,
 500        colorS1, colorS2;
 501  DWORD product1a, product1b,
 502        product2a, product2b;
 503
 504  finalw=width<<1;
 505  finalh=height<<1;
 506
 507  line = 0;
 508
 509   {
 510    for (; height; height-=1)
 511         {
 512      bP = (DWORD *)srcPtr;
 513          dP = (DWORD *)(dstBitmap + line*dstPitch);
 514      for (finish = width; finish; finish -= 1 )
 515       {
 516        if(finish==finWidth) iXA=0;
 517        else                 iXA=1;
 518        if(finish>4) {iXB=1;iXC=2;}
 519        else
 520        if(finish>3) {iXB=1;iXC=1;}
 521        else         {iXB=0;iXC=0;}
 522        if(line==0)  {iYA=0;}
 523        else         {iYA=finWidth;}
 524        if(height>4) {iYB=finWidth;iYC=srcPitchHalf;}
 525        else
 526        if(height>3) {iYB=finWidth;iYC=finWidth;}
 527        else         {iYB=0;iYC=0;}
 528
 529        colorB1 = *(bP- iYA);
 530        colorB2 = *(bP- iYA + iXB);
 531
 532        color4 = *(bP  - iXA);
 533        color5 = *(bP);
 534        color6 = *(bP  + iXB);
 535        colorS2 = *(bP + iXC);
 536
 537        color1 = *(bP  + iYB  - iXA);
 538        color2 = *(bP  + iYB);
 539        color3 = *(bP  + iYB  + iXB);
 540        colorS1= *(bP  + iYB  + iXC);
 541
 542        colorA1 = *(bP + iYC);
 543        colorA2 = *(bP + iYC + iXB);
 544
 545        if(color2 == color6 && color5 != color3)
 546         {
 547          product1b = product2a = color2;
 548          if((color1 == color2) ||
 549             (color6 == colorB2))
 550           {
 551            product1a = INTERPOLATE8(color2, color5);
 552            product1a = INTERPOLATE8(color2, product1a);
 553           }
 554          else
 555           {
 556            product1a = INTERPOLATE8(color5, color6);
 557           }
 558
 559          if((color6 == colorS2) ||
 560             (color2 == colorA1))
 561           {
 562            product2b = INTERPOLATE8(color2, color3);
 563            product2b = INTERPOLATE8(color2, product2b);
 564           }
 565          else
 566           {
 567            product2b = INTERPOLATE8(color2, color3);
 568           }
 569         }
 570        else
 571        if (color5 == color3 && color2 != color6)
 572         {
 573          product2b = product1a = color5;
 574
 575          if ((colorB1 == color5) ||
 576              (color3 == colorS1))
 577           {
 578            product1b = INTERPOLATE8(color5, color6);
 579            product1b = INTERPOLATE8(color5, product1b);
 580           }
 581          else
 582           {
 583            product1b = INTERPOLATE8(color5, color6);
 584           }
 585
 586          if ((color3 == colorA2) ||
 587              (color4 == color5))
 588           {
 589            product2a = INTERPOLATE8(color5, color2);
 590            product2a = INTERPOLATE8(color5, product2a);
 591           }
 592          else
 593           {
 594            product2a = INTERPOLATE8(color2, color3);
 595           }
 596         }
 597        else
 598        if (color5 == color3 && color2 == color6)
 599         {
 600          register int r = 0;
 601
 602          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color1&0x00ffffff),  (colorA1&0x00ffffff));
 603          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color4&0x00ffffff),  (colorB1&0x00ffffff));
 604          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorA2&0x00ffffff), (colorS1&0x00ffffff));
 605          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorB2&0x00ffffff), (colorS2&0x00ffffff));
 606
 607          if (r > 0)
 608           {
 609            product1b = product2a = color2;
 610            product1a = product2b = INTERPOLATE8(color5, color6);
 611           }
 612          else
 613          if (r < 0)
 614           {
 615            product2b = product1a = color5;
 616            product1b = product2a = INTERPOLATE8(color5, color6);
 617           }
 618          else
 619           {
 620            product2b = product1a = color5;
 621            product1b = product2a = color2;
 622           }
 623         }
 624        else
 625         {
 626          product2b = product1a = INTERPOLATE8(color2, color6);
 627          product2b = Q_INTERPOLATE8(color3, color3, color3, product2b);
 628          product1a = Q_INTERPOLATE8(color5, color5, color5, product1a);
 629
 630          product2a = product1b = INTERPOLATE8(color5, color3);
 631          product2a = Q_INTERPOLATE8(color2, color2, color2, product2a);
 632          product1b = Q_INTERPOLATE8(color6, color6, color6, product1b);
 633         }
 634
 635 ////////////////////////////////
 636
 637        *dP=product1a;
 638        *(dP+1)=product1b;
 639        *(dP+(srcPitchHalf))=product2a;
 640        *(dP+1+(srcPitchHalf))=product2b;
 641
 642        bP += 1;
 643        dP += 2;
 644       }//end of for ( finish= width etc..)
 645
 646      line += 2;
 647      srcPtr += srcPitch;
 648         }; //endof: for (; height; height--)
 649   }
 650 }
 651
 652 /////////////////////////
 653
 654 //#include <assert.h>
 655
 656 static __inline void scale2x_32_def_whole(uint32_t*  dst0, uint32_t* dst1, const uint32_t* src0, const uint32_t* src1, const uint32_t* src2, unsigned count)
 657 {
 658
 659         //assert(count >= 2);
 660
 661         // first pixel
 662         if (src0[0] != src2[0] && src1[0] != src1[1]) {
 663                 dst0[0] = src1[0] == src0[0] ? src0[0] : src1[0];
 664                 dst0[1] = src1[1] == src0[0] ? src0[0] : src1[0];
 665                 dst1[0] = src1[0] == src2[0] ? src2[0] : src1[0];
 666                 dst1[1] = src1[1] == src2[0] ? src2[0] : src1[0];
 667         } else {
 668                 dst0[0] = src1[0];
 669                 dst0[1] = src1[0];
 670                 dst1[0] = src1[0];
 671                 dst1[1] = src1[0];
 672         }
 673         ++src0;
 674         ++src1;
 675         ++src2;
 676         dst0 += 2;
 677         dst1 += 2;
 678
 679         // central pixels
 680         count -= 2;
 681         while (count) {
 682                 if (src0[0] != src2[0] && src1[-1] != src1[1]) {
 683                         dst0[0] = src1[-1] == src0[0] ? src0[0] : src1[0];
 684                         dst0[1] = src1[1] == src0[0] ? src0[0] : src1[0];
 685                         dst1[0] = src1[-1] == src2[0] ? src2[0] : src1[0];
 686                         dst1[1] = src1[1] == src2[0] ? src2[0] : src1[0];
 687                 } else {
 688                         dst0[0] = src1[0];
 689                         dst0[1] = src1[0];
 690                         dst1[0] = src1[0];
 691                         dst1[1] = src1[0];
 692                 }
 693
 694                 ++src0;
 695                 ++src1;
 696                 ++src2;
 697                 dst0 += 2;
 698                 dst1 += 2;
 699                 --count;
 700         }
 701
 702         // last pixel
 703         if (src0[0] != src2[0] && src1[-1] != src1[0]) {
 704                 dst0[0] = src1[-1] == src0[0] ? src0[0] : src1[0];
 705                 dst0[1] = src1[0] == src0[0] ? src0[0] : src1[0];
 706                 dst1[0] = src1[-1] == src2[0] ? src2[0] : src1[0];
 707                 dst1[1] = src1[0] == src2[0] ? src2[0] : src1[0];
 708         } else {
 709                 dst0[0] = src1[0];
 710                 dst0[1] = src1[0];
 711                 dst1[0] = src1[0];
 712                 dst1[1] = src1[0];
 713         }
 714 }
 715
 716 void Scale2x_ex8(unsigned char *srcPtr, DWORD srcPitch,
 717                                  unsigned char  *dstPtr, int width, int height)
 718 {
 719         //const int srcpitch = srcPitch;
 720         const int dstPitch = srcPitch<<1;
 721
 722         int count = height;
 723
 724         finalw=width<<1;
 725         finalh=height<<1;
 726
 727         uint32_t  *dst0 = (uint32_t  *)dstPtr;
 728         uint32_t  *dst1 = dst0 + (dstPitch >> 2);
 729
 730         uint32_t  *src0 = (uint32_t  *)srcPtr;
 731         uint32_t  *src1 = src0 + (srcPitch >> 2);
 732         uint32_t  *src2 = src1 + (srcPitch >> 2);
 733         scale2x_32_def_whole(dst0, dst1, src0, src0, src1, width);
 734
 735         count -= 2;
 736         while(count) {
 737                 dst0 += dstPitch >> 1;
 738                 dst1 += dstPitch >> 1;
 739                 scale2x_32_def_whole(dst0, dst1, src0, src0, src1, width);
 740                 src0 = src1;
 741                 src1 = src2;
 742                 src2 += srcPitch >> 2;
 743                 --count;
 744         }
 745         dst0 += dstPitch >> 1;
 746         dst1 += dstPitch >> 1;
 747         scale2x_32_def_whole(dst0, dst1, src0, src1, src1, width);
 748
 749 }
 750
 751 ////////////////////////////////////////////////////////////////////////
 752
 753 static __inline void scale3x_32_def_whole(uint32_t* dst0, uint32_t* dst1, uint32_t* dst2, const uint32_t* src0, const uint32_t* src1, const uint32_t* src2, unsigned count)
 754 {
 755         //assert(count >= 2);
 756
 757         //first pixel
 758         if (src0[0] != src2[0] && src1[0] != src1[1]) {
 759                 dst0[0] = src1[0];
 760                 dst0[1] = (src1[0] == src0[0] && src1[0] != src0[1]) || (src1[1] == src0[0] && src1[0] != src0[0]) ? src0[0] : src1[0];
 761                 dst0[2] = src1[1] == src0[0] ? src1[1] : src1[0];
 762                 dst1[0] = (src1[0] == src0[0] && src1[0] != src2[0]) || (src1[0] == src2[0] && src1[0] != src0[0]) ? src1[0] : src1[0];
 763                 dst1[1] = src1[0];
 764                 dst1[2] = (src1[1] == src0[0] && src1[0] != src2[1]) || (src1[1] == src2[0] && src1[0] != src0[1]) ? src1[1] : src1[0];
 765                 dst2[0] = src1[0];
 766                 dst2[1] = (src1[0] == src2[0] && src1[0] != src2[1]) || (src1[1] == src2[0] && src1[0] != src2[0]) ? src2[0] : src1[0];
 767                 dst2[2] = src1[1] == src2[0] ? src1[1] : src1[0];
 768         } else {
 769                 dst0[0] = src1[0];
 770                 dst0[1] = src1[0];
 771                 dst0[2] = src1[0];
 772                 dst1[0] = src1[0];
 773                 dst1[1] = src1[0];
 774                 dst1[2] = src1[0];
 775                 dst2[0] = src1[0];
 776                 dst2[1] = src1[0];
 777                 dst2[2] = src1[0];
 778         }
 779         ++src0;
 780         ++src1;
 781         ++src2;
 782         dst0 += 3;
 783         dst1 += 3;
 784         dst2 += 3;
 785
 786         //central pixels
 787         count -= 2;
 788         while (count) {
 789                 if (src0[0] != src2[0] && src1[-1] != src1[1]) {
 790                         dst0[0] = src1[-1] == src0[0] ? src1[-1] : src1[0];
 791                         dst0[1] = (src1[-1] == src0[0] && src1[0] != src0[1]) || (src1[1] == src0[0] && src1[0] != src0[-1]) ? src0[0] : src1[0];
 792                         dst0[2] = src1[1] == src0[0] ? src1[1] : src1[0];
 793                         dst1[0] = (src1[-1] == src0[0] && src1[0] != src2[-1]) || (src1[-1] == src2[0] && src1[0] != src0[-1]) ? src1[-1] : src1[0];
 794                         dst1[1] = src1[0];
 795                         dst1[2] = (src1[1] == src0[0] && src1[0] != src2[1]) || (src1[1] == src2[0] && src1[0] != src0[1]) ? src1[1] : src1[0];
 796                         dst2[0] = src1[-1] == src2[0] ? src1[-1] : src1[0];
 797                         dst2[1] = (src1[-1] == src2[0] && src1[0] != src2[1]) || (src1[1] == src2[0] && src1[0] != src2[-1]) ? src2[0] : src1[0];
 798                         dst2[2] = src1[1] == src2[0] ? src1[1] : src1[0];
 799                 } else {
 800                         dst0[0] = src1[0];
 801                         dst0[1] = src1[0];
 802                         dst0[2] = src1[0];
 803                         dst1[0] = src1[0];
 804                         dst1[1] = src1[0];
 805                         dst1[2] = src1[0];
 806                         dst2[0] = src1[0];
 807                         dst2[1] = src1[0];
 808                         dst2[2] = src1[0];
 809                 }
 810
 811                 ++src0;
 812                 ++src1;
 813                 ++src2;
 814                 dst0 += 3;
 815                 dst1 += 3;
 816                 dst2 += 3;
 817                 --count;
 818         }
 819
 820         // last pixel
 821         if (src0[0] != src2[0] && src1[-1] != src1[0]) {
 822                 dst0[0] = src1[-1] == src0[0] ? src1[-1] : src1[0];
 823                 dst0[1] = (src1[-1] == src0[0] && src1[0] != src0[0]) || (src1[0] == src0[0] && src1[0] != src0[-1]) ? src0[0] : src1[0];
 824                 dst0[2] = src1[0];
 825                 dst1[0] = (src1[-1] == src0[0] && src1[0] != src2[-1]) || (src1[-1] == src2[0] && src1[0] != src0[-1]) ? src1[-1] : src1[0];
 826                 dst1[1] = src1[0];
 827                 dst1[2] = (src1[0] == src0[0] && src1[0] != src2[0]) || (src1[0] == src2[0] && src1[0] != src0[0]) ? src1[0] : src1[0];
 828                 dst2[0] = src1[-1] == src2[0] ? src1[-1] : src1[0];
 829                 dst2[1] = (src1[-1] == src2[0] && src1[0] != src2[0]) || (src1[0] == src2[0] && src1[0] != src2[-1]) ? src2[0] : src1[0];
 830                 dst2[2] = src1[0];
 831         } else {
 832                 dst0[0] = src1[0];
 833                 dst0[1] = src1[0];
 834                 dst0[2] = src1[0];
 835                 dst1[0] = src1[0];
 836                 dst1[1] = src1[0];
 837                 dst1[2] = src1[0];
 838                 dst2[0] = src1[0];
 839                 dst2[1] = src1[0];
 840                 dst2[2] = src1[0];
 841         }
 842 }
 843
 844
 845 void Scale3x_ex8(unsigned char *srcPtr, DWORD srcPitch,
 846                                  unsigned char  *dstPtr, int width, int height)
 847 {
 848         int count = height;
 849
 850         int dstPitch = srcPitch*3;
 851         int dstRowPixels = dstPitch>>2;
 852
 853         finalw=width*3;
 854         finalh=height*3;
 855
 856         uint32_t  *dst0 = (uint32_t  *)dstPtr;
 857         uint32_t  *dst1 = dst0 + dstRowPixels;
 858         uint32_t  *dst2 = dst1 + dstRowPixels;
 859
 860         uint32_t  *src0 = (uint32_t  *)srcPtr;
 861         uint32_t  *src1 = src0 + (srcPitch >> 2);
 862         uint32_t  *src2 = src1 + (srcPitch >> 2);
 863         scale3x_32_def_whole(dst0, dst1, dst2, src0, src0, src2, width);
 864
 865         count -= 2;
 866         while(count) {
 867                 dst0 += dstRowPixels*3;
 868                 dst1 += dstRowPixels*3;
 869                 dst2 += dstRowPixels*3;
 870
 871                 scale3x_32_def_whole(dst0, dst1, dst2, src0, src1, src2, width);
 872                 src0 = src1;
 873                 src1 = src2;
 874                 src2 += srcPitch >> 2;
 875                 --count;
 876         }
 877
 878         dst0 += dstRowPixels*3;
 879         dst1 += dstRowPixels*3;
 880         dst2 += dstRowPixels*3;
 881
 882         scale3x_32_def_whole(dst0, dst1, dst2, src0, src1, src1, width);
 883 }
 884
 885
 886 ////////////////////////////////////////////////////////////////////////
 887
 888 #ifndef MAX
 889 #define MAX(a,b)    (((a) > (b)) ? (a) : (b))
 890 #define MIN(a,b)    (((a) < (b)) ? (a) : (b))
 891 #endif
 892
 893
 894 ////////////////////////////////////////////////////////////////////////
 895 // X STUFF :)
 896 ////////////////////////////////////////////////////////////////////////
 897
 898
 899 static Cursor        cursor;
 900 XVisualInfo          vi;
 901 static XVisualInfo   *myvisual;
 902 Display              *display;
 903 static Colormap      colormap;
 904 Window        window;
 905 static GC            hGC;
 906 static XImage      * Ximage;
 907 static XvImage     * XCimage;
 908 static XImage      * XFimage;
 909 static XImage      * XPimage=0 ;
 910 char *               Xpixels;
 911 char *               pCaptionText;
 912
 913 static int fx=0;
 914
 915
 916 static Atom xv_intern_atom_if_exists( Display *display, char const * atom_name )
 917 {
 918   XvAttribute * attributes;
 919   int attrib_count,i;
 920   Atom xv_atom = None;
 921
 922   attributes = XvQueryPortAttributes( display, xv_port, &attrib_count );
 923   if( attributes!=NULL )
 924   {
 925     for ( i = 0; i < attrib_count; ++i )
 926     {
 927       if ( strcmp(attributes[i].name, atom_name ) == 0 )
 928       {
 929         xv_atom = XInternAtom( display, atom_name, False );
 930         break; // found what we want, break out
 931       }
 932     }
 933     XFree( attributes );
 934   }
 935
 936   return xv_atom;
 937 }
 938
 939
 940
 941 // close display
 942
 943 void DestroyDisplay(void)
 944 {
 945  if(display)
 946   {
 947    XFreeColormap(display, colormap);
 948    if(hGC)
 949     {
 950      XFreeGC(display,hGC);
 951      hGC = 0;
 952     }
 953    if(Ximage)
 954     {
 955      XDestroyImage(Ximage);
 956      Ximage=0;
 957     }
 958    if(XCimage)
 959     {
 960      XFree(XCimage);
 961      XCimage=0;
 962     }
 963    if(XFimage)
 964     {
 965      XDestroyImage(XFimage);
 966      XFimage=0;
 967     }
 968
 969         XShmDetach(display,&shminfo);
 970         shmdt(shminfo.shmaddr);
 971         shmctl(shminfo.shmid,IPC_RMID,NULL);
 972
 973   Atom atom_vsync = xv_intern_atom_if_exists(display, "XV_SYNC_TO_VBLANK");
 974   if (atom_vsync != None) {
 975         XvSetPortAttribute(display, xv_port, atom_vsync, xv_vsync);
 976   }
 977
 978    XSync(display,False);
 979
 980    XCloseDisplay(display);
 981   }
 982 }
 983
 984 static int depth=0;
 985 int root_window_id=0;
 986
 987
 988 // Create display
 989
 990 void CreateDisplay(void)
 991 {
 992  XSetWindowAttributes winattr;
 993  int                  myscreen;
 994  Screen *             screen;
 995  XEvent               event;
 996  XSizeHints           hints;
 997  XWMHints             wm_hints;
 998  MotifWmHints         mwmhints;
 999  Atom                 mwmatom;
1000
1001  Atom                   delwindow;
1002
1003  XGCValues            gcv;
1004  int i;
1005
1006  int ret, j, p;
1007  int formats;
1008  unsigned int p_num_adaptors=0, p_num_ports=0;
1009
1010  XvAdaptorInfo          *ai;
1011  XvImageFormatValues    *fo;
1012
1013  // Open display
1014  display = XOpenDisplay(NULL);
1015
1016  if (!display)
1017   {
1018    fprintf (stderr,"Failed to open display!!!\n");
1019    DestroyDisplay();
1020    return;
1021   }
1022
1023  myscreen=DefaultScreen(display);
1024
1025  // desktop fullscreen switch
1026  if (!iWindowMode) fx = 1;
1027
1028  screen=DefaultScreenOfDisplay(display);
1029
1030  root_window_id=RootWindow(display,DefaultScreen(display));
1031
1032   //Look for an Xvideo RGB port
1033   ret = XvQueryAdaptors(display, root_window_id, &p_num_adaptors, &ai);
1034   if (ret != Success) {
1035     if (ret == XvBadExtension)
1036       printf("XvBadExtension returned at XvQueryExtension.\n");
1037     else
1038       if (ret == XvBadAlloc)
1039         printf("XvBadAlloc returned at XvQueryExtension.\n");
1040       else
1041         printf("other error happaned at XvQueryAdaptors.\n");
1042
1043     exit(-1);
1044   }
1045
1046   depth = DefaultDepth(display, myscreen);
1047
1048   for (i = 0; i < p_num_adaptors; i++) {
1049         p_num_ports = ai[i].base_id + ai[i].num_ports;
1050         for (p = ai[i].base_id; p < p_num_ports; p++) {
1051                 fo = XvListImageFormats(display, p, &formats);
1052                 for (j = 0; j < formats; j++) {
1053                         //backup YUV mode
1054                         //hmm, should I bother check guid == 55595659-0000-0010-8000-00aa00389b71?
1055                         //and check byte order?   fo[j].byte_order == LSBFirst
1056 #ifdef __BIG_ENDIAN__
1057                         if ( fo[j].type == XvYUV && fo[j].bits_per_pixel == 16 && fo[j].format == XvPacked && strncmp("YUYV", fo[j].component_order, 5) == 0 )
1058 #else
1059                         if ( fo[j].type == XvYUV && fo[j].bits_per_pixel == 16 && fo[j].format == XvPacked && strncmp("UYVY", fo[j].component_order, 5) == 0 )
1060 #endif
1061                         {
1062                                 yuv_port = p;
1063                                 yuv_id = fo[j].id;
1064                         }
1065                         if (fo[j].type == XvRGB && fo[j].bits_per_pixel == 32)
1066                         {
1067                                 xv_port = p;
1068                                 xv_id = fo[j].id;
1069                                 xv_depth = fo[j].depth;
1070                                 printf("RGB mode found.  id: %x, depth: %d\n", xv_id, xv_depth);
1071
1072                                 if (xv_depth != depth) {
1073                                         printf("Warning: Depth does not match screen depth (%d)\n", depth);
1074                                 }
1075                                 else {
1076                                         //break out of loops
1077                                         j = formats;
1078                                         p = p_num_ports;
1079                                         i = p_num_adaptors;
1080                                 }
1081                         }
1082                 }
1083                 if (fo)
1084                         XFree(fo);
1085         }
1086   }
1087   if (p_num_adaptors > 0)
1088     XvFreeAdaptorInfo(ai);
1089   if (xv_port == -1 && yuv_port == -1)
1090   {
1091         printf("RGB & YUV not found.  Quitting.\n");
1092         exit(-1);
1093   }
1094   else if (xv_port == -1 && yuv_port != -1)
1095   {
1096         use_yuv = 1;
1097         printf("RGB not found.  Using YUV.\n");
1098         xv_port = yuv_port;
1099         xv_id = yuv_id;
1100   }
1101   else if (xv_depth && xv_depth != depth && yuv_port != -1)
1102   {
1103         use_yuv = 1;
1104         printf("Acceptable RGB mode not found.  Using YUV.\n");
1105         xv_port = yuv_port;
1106         xv_id = yuv_id;
1107   }
1108
1109   Atom atom_vsync = xv_intern_atom_if_exists(display, "XV_SYNC_TO_VBLANK");
1110   if (atom_vsync != None) {
1111         XvGetPortAttribute(display, xv_port, atom_vsync, &xv_vsync);
1112         XvSetPortAttribute(display, xv_port, atom_vsync, 0);
1113   }
1114
1115 myvisual = 0;
1116
1117 if(XMatchVisualInfo(display,myscreen, depth, TrueColor, &vi))
1118         myvisual = &vi;
1119
1120 if (!myvisual)
1121 {
1122         fprintf(stderr,"Failed to obtain visual!\n");
1123         DestroyDisplay();
1124         return;
1125 }
1126
1127  if(myvisual->red_mask==0x00007c00 &&
1128     myvisual->green_mask==0x000003e0 &&
1129     myvisual->blue_mask==0x0000001f)
1130      {iColDepth=15;}
1131  else
1132  if(myvisual->red_mask==0x0000f800 &&
1133     myvisual->green_mask==0x000007e0 &&
1134     myvisual->blue_mask==0x0000001f)
1135      {iColDepth=16;}
1136  else
1137  if(myvisual->red_mask==0x00ff0000 &&
1138     myvisual->green_mask==0x0000ff00 &&
1139     myvisual->blue_mask==0x000000ff)
1140      {iColDepth=32;}
1141  else
1142   {
1143    iColDepth=0;
1144 /*   fprintf(stderr,"COLOR DEPTH NOT SUPPORTED!\n");
1145    fprintf(stderr,"r: %08lx\n",myvisual->red_mask);
1146    fprintf(stderr,"g: %08lx\n",myvisual->green_mask);
1147    fprintf(stderr,"b: %08lx\n",myvisual->blue_mask);
1148    DestroyDisplay();
1149    return;*/
1150   }
1151
1152  // pffff... much work for a simple blank cursor... oh, well...
1153  if(iWindowMode) cursor=XCreateFontCursor(display,XC_trek);
1154  else
1155   {
1156    Pixmap p1,p2;
1157    XImage * img;
1158    XColor b,w;
1159    char * idata;
1160    XGCValues GCv;
1161    GC        GCc;
1162
1163    memset(&b,0,sizeof(XColor));
1164    memset(&w,0,sizeof(XColor));
1165    idata=(char *)malloc(8);
1166    memset(idata,0,8);
1167
1168    p1=XCreatePixmap(display,RootWindow(display,myvisual->screen),8,8,1);
1169    p2=XCreatePixmap(display,RootWindow(display,myvisual->screen),8,8,1);
1170
1171    img = XCreateImage(display,myvisual->visual,
1172                       1,XYBitmap,0,idata,8,8,8,1);
1173
1174    GCv.function   = GXcopy;
1175    GCv.foreground = ~0;
1176    GCv.background =  0;
1177    GCv.plane_mask = AllPlanes;
1178    GCc = XCreateGC(display,p1,
1179                    (GCFunction|GCForeground|GCBackground|GCPlaneMask),&GCv);
1180
1181    XPutImage(display, p1,GCc,img,0,0,0,0,8,8);
1182    XPutImage(display, p2,GCc,img,0,0,0,0,8,8);
1183    XFreeGC(display, GCc);
1184
1185    cursor = XCreatePixmapCursor(display,p1,p2,&b,&w,0,0);
1186
1187    XFreePixmap(display,p1);
1188    XFreePixmap(display,p2);
1189    XDestroyImage(img); // will free idata as well
1190   }
1191
1192  colormap=XCreateColormap(display,root_window_id,
1193                           myvisual->visual,AllocNone);
1194
1195  winattr.background_pixel=0;
1196  winattr.border_pixel=WhitePixelOfScreen(screen);
1197  winattr.bit_gravity=ForgetGravity;
1198  winattr.win_gravity=NorthWestGravity;
1199  winattr.backing_store=NotUseful;
1200
1201  winattr.override_redirect=False;
1202  winattr.save_under=False;
1203  winattr.event_mask=0;
1204  winattr.do_not_propagate_mask=0;
1205  winattr.colormap=colormap;
1206  winattr.cursor=None;
1207
1208  window=XCreateWindow(display,root_window_id,
1209                       0,0,iResX,iResY,
1210                       0,myvisual->depth,
1211                       InputOutput,myvisual->visual,
1212                       CWBorderPixel | CWBackPixel |
1213                       CWEventMask | CWDontPropagate |
1214                       CWColormap | CWCursor,
1215                       &winattr);
1216
1217  if(!window)
1218   {
1219    fprintf(stderr,"Failed in XCreateWindow()!!!\n");
1220    DestroyDisplay();
1221    return;
1222   }
1223
1224  delwindow = XInternAtom(display,"WM_DELETE_WINDOW",0);
1225  XSetWMProtocols(display, window, &delwindow, 1);
1226
1227  hints.flags=USPosition|USSize;
1228  hints.base_width = iResX;
1229  hints.base_height = iResY;
1230
1231  wm_hints.input=1;
1232  wm_hints.flags=InputHint;
1233
1234  XSetWMHints(display,window,&wm_hints);
1235  XSetWMNormalHints(display,window,&hints);
1236  if(pCaptionText)
1237       XStoreName(display,window,pCaptionText);
1238  else XStoreName(display,window,"P.E.Op.S SoftX PSX Gpu");
1239
1240  XDefineCursor(display,window,cursor);
1241
1242  // hack to get rid of window title bar
1243  if (fx)
1244   {
1245    mwmhints.flags=MWM_HINTS_DECORATIONS;
1246    mwmhints.decorations=0;
1247    mwmatom=XInternAtom(display,"_MOTIF_WM_HINTS",0);
1248    XChangeProperty(display,window,mwmatom,mwmatom,32,
1249                    PropModeReplace,(unsigned char *)&mwmhints,4);
1250   }
1251
1252  // key stuff
1253  XSelectInput(display,
1254               window,
1255               FocusChangeMask | ExposureMask |
1256               KeyPressMask | KeyReleaseMask
1257              );
1258
1259  XMapRaised(display,window);
1260  XClearWindow(display,window);
1261  XWindowEvent(display,window,ExposureMask,&event);
1262
1263  if (fx) // fullscreen
1264   {
1265    XResizeWindow(display,window,screen->width,screen->height);
1266
1267    hints.min_width   = hints.max_width = hints.base_width = screen->width;
1268    hints.min_height= hints.max_height = hints.base_height = screen->height;
1269
1270    XSetWMNormalHints(display,window,&hints);
1271
1272    // set the window layer for GNOME
1273    {
1274     XEvent xev;
1275
1276     memset(&xev, 0, sizeof(xev));
1277     xev.xclient.type = ClientMessage;
1278     xev.xclient.serial = 0;
1279     xev.xclient.send_event = 1;
1280     xev.xclient.message_type = XInternAtom(display, "_NET_WM_STATE", 0);
1281     xev.xclient.window = window;
1282     xev.xclient.format = 32;
1283     xev.xclient.data.l[0] = 1;
1284     xev.xclient.data.l[1] = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", 0);
1285     xev.xclient.data.l[2] = 0;
1286     xev.xclient.data.l[3] = 0;
1287     xev.xclient.data.l[4] = 0;
1288
1289     XSendEvent(display, root_window_id, 0,
1290       SubstructureRedirectMask | SubstructureNotifyMask, &xev);
1291    }
1292   }
1293
1294  gcv.graphics_exposures = False;
1295  hGC = XCreateGC(display,window,
1296                  GCGraphicsExposures, &gcv);
1297  if(!hGC)
1298   {
1299    fprintf(stderr,"No gfx context!!!\n");
1300    DestroyDisplay();
1301   }
1302
1303
1304
1305  Xpixels = (char *)malloc(220*15*4);
1306  memset(Xpixels,255,220*15*4);
1307  XFimage = XCreateImage(display,myvisual->visual,
1308                       depth, ZPixmap, 0,
1309                       (char *)Xpixels,
1310                       220, 15,
1311                       depth>16 ? 32 : 16,
1312                       0);
1313
1314  Xpixels = (char *)malloc(8*8*4);
1315  memset(Xpixels,0,8*8*4);
1316  XCimage = XvCreateImage(display,xv_port,xv_id,
1317                       (char *)Xpixels, 8, 8);
1318
1319
1320 /*
1321 Allocate max that could be needed:
1322 Big(est?) PSX res: 640x512
1323 32bpp (times 4)
1324 2xsai func= 3xwidth,3xheight
1325 = approx 11.8mb
1326 */
1327 shminfo.shmid = shmget(IPC_PRIVATE, 640*512*4*3*3, IPC_CREAT | 0777);
1328 shminfo.shmaddr = shmat(shminfo.shmid, 0, 0);
1329 shminfo.readOnly = 0;
1330
1331  if (!XShmAttach(display, &shminfo)) {
1332     printf("XShmAttach failed !\n");
1333     exit (-1);
1334  }
1335 }
1336
1337 void (*p2XSaIFunc) (unsigned char *, DWORD, unsigned char *, int, int);
1338 unsigned char *pBackBuffer = 0;
1339
1340 void BlitScreen32(unsigned char *surf, int32_t x, int32_t y)
1341 {
1342  unsigned char *pD;
1343  unsigned int startxy;
1344  uint32_t lu;
1345  unsigned short s;
1346  unsigned short row, column;
1347  unsigned short dx = PreviousPSXDisplay.Range.x1;
1348  unsigned short dy = PreviousPSXDisplay.DisplayMode.y;
1349
1350  int32_t lPitch = PSXDisplay.DisplayMode.x << 2;
1351
1352  uint32_t *destpix;
1353
1354  if (PreviousPSXDisplay.Range.y0) // centering needed?
1355   {
1356    memset(surf, 0, (PreviousPSXDisplay.Range.y0 >> 1) * lPitch);
1357
1358    dy -= PreviousPSXDisplay.Range.y0;
1359    surf += (PreviousPSXDisplay.Range.y0 >> 1) * lPitch;
1360
1361    memset(surf + dy * lPitch,
1362           0, ((PreviousPSXDisplay.Range.y0 + 1) >> 1) * lPitch);
1363   }
1364
1365  if (PreviousPSXDisplay.Range.x0)
1366   {
1367    for (column = 0; column < dy; column++)
1368     {
1369      destpix = (uint32_t *)(surf + (column * lPitch));
1370      memset(destpix, 0, PreviousPSXDisplay.Range.x0 << 2);
1371     }
1372    surf += PreviousPSXDisplay.Range.x0 << 2;
1373   }
1374
1375  if (PSXDisplay.RGB24)
1376   {
1377    for (column = 0; column < dy; column++)
1378     {
1379      startxy = ((1024) * (column + y)) + x;
1380      pD = (unsigned char *)&psxVuw[startxy];
1381      destpix = (uint32_t *)(surf + (column * lPitch));
1382      for (row = 0; row < dx; row++)
1383       {
1384        lu = *((uint32_t *)pD);
1385        destpix[row] =
1386           0xff000000 | (RED(lu) << 16) | (GREEN(lu) << 8) | (BLUE(lu));
1387        pD += 3;
1388       }
1389     }
1390   }
1391  else
1392   {
1393    for (column = 0;column<dy;column++)
1394     {
1395      startxy = (1024 * (column + y)) + x;
1396      destpix = (uint32_t *)(surf + (column * lPitch));
1397      for (row = 0; row < dx; row++)
1398       {
1399        s = GETLE16(&psxVuw[startxy++]);
1400        destpix[row] =
1401           (((s << 19) & 0xf80000) | ((s << 6) & 0xf800) | ((s >> 7) & 0xf8)) | 0xff000000;
1402       }
1403     }
1404   }
1405 }
1406
1407 void BlitToYUV(unsigned char * surf,int32_t x,int32_t y)
1408 {
1409  unsigned char * pD;
1410  unsigned int startxy;
1411  uint32_t lu;unsigned short s;
1412  unsigned short row,column;
1413  unsigned short dx = PreviousPSXDisplay.Range.x1;
1414  unsigned short dy = PreviousPSXDisplay.DisplayMode.y;
1415  int Y,U,V, R,G,B;
1416
1417  int32_t lPitch = PSXDisplay.DisplayMode.x << 2;
1418  uint32_t *destpix;
1419
1420  if (PreviousPSXDisplay.Range.y0) // centering needed?
1421   {
1422    for (column = 0; column < (PreviousPSXDisplay.Range.y0 >> 1); column++)
1423     {
1424      destpix = (uint32_t *)(surf + column * lPitch);
1425      for (row = 0; row < dx; row++)
1426      {
1427       destpix[row] = (4 << 24) | (128 << 16) | (4 << 8) | 128;
1428      }
1429     }
1430
1431    dy -= PreviousPSXDisplay.Range.y0;
1432    surf += (PreviousPSXDisplay.Range.y0 >> 1) * lPitch;
1433
1434    for (column = 0; column < (PreviousPSXDisplay.Range.y0 + 1) >> 1; column++)
1435     {
1436      destpix = (uint32_t *)(surf + (dy + column) * lPitch);
1437      for (row = 0; row < dx; row++)
1438      {
1439       destpix[row] = (4 << 24) | (128 << 16) | (4 << 8) | 128;
1440      }
1441     }
1442   }
1443
1444  if (PreviousPSXDisplay.Range.x0)
1445   {
1446    for (column = 0; column < dy; column++)
1447     {
1448      destpix = (uint32_t *)(surf + (column * lPitch));
1449      for (row = 0; row < PreviousPSXDisplay.Range.x0; row++)
1450       {
1451        destpix[row] = (4 << 24) | (128 << 16) | (4 << 8) | 128;
1452       }
1453     }
1454    surf += PreviousPSXDisplay.Range.x0 << 2;
1455   }
1456
1457  if (PSXDisplay.RGB24)
1458   {
1459    for (column = 0; column < dy; column++)
1460     {
1461      startxy = (1024 * (column + y)) + x;
1462      pD = (unsigned char *)&psxVuw[startxy];
1463      destpix = (uint32_t *)(surf + (column * lPitch));
1464      for (row = 0; row < dx; row++)
1465       {
1466        lu = *((uint32_t *)pD);
1467
1468        R = RED(lu);
1469        G = GREEN(lu);
1470        B = BLUE(lu);
1471
1472        Y = min(abs(R * 2104 + G * 4130 + B * 802 + 4096 + 131072) >> 13, 235);
1473        U = min(abs(R * -1214 + G * -2384 + B * 3598 + 4096 + 1048576) >> 13, 240);
1474        V = min(abs(R * 3598 + G * -3013 + B * -585 + 4096 + 1048576) >> 13, 240);
1475
1476 #ifdef __BIG_ENDIAN__
1477        destpix[row] = Y << 24 | U << 16 | Y << 8 | V;
1478 #else
1479        destpix[row] = Y << 24 | V << 16 | Y << 8 | U;
1480 #endif
1481        pD += 3;
1482       }
1483     }
1484   }
1485  else
1486   {
1487    for (column = 0; column < dy; column++)
1488     {
1489      startxy = (1024 * (column + y)) + x;
1490      destpix = (uint32_t *)(surf + (column * lPitch));
1491      for (row = 0; row < dx; row++)
1492       {
1493        s = GETLE16(&psxVuw[startxy++]);
1494
1495        R = (s << 3) &0xf8;
1496        G = (s >> 2) &0xf8;
1497        B = (s >> 7) &0xf8;
1498
1499        Y = min(abs(R * 2104 + G * 4130 + B * 802 + 4096 + 131072) >> 13, 235);
1500        U = min(abs(R * -1214 + G * -2384 + B * 3598 + 4096 + 1048576) >> 13, 240);
1501        V = min(abs(R * 3598 + G * -3013 + B * -585 + 4096 + 1048576) >> 13, 240);
1502
1503 #ifdef __BIG_ENDIAN__
1504        destpix[row] = Y << 24 | U << 16 | Y << 8 | V;
1505 #else
1506        destpix[row] = Y << 24 | V << 16 | Y << 8 | U;
1507 #endif
1508       }
1509     }
1510   }
1511 }
1512
1513 //dst will have half the pitch (32bit to 16bit)
1514 void RGB2YUV(uint32_t *s, int width, int height, uint32_t *d)
1515 {
1516         int x,y;
1517         int R,G,B, Y1,Y2,U,V;
1518
1519         for (y=0; y<height; y++) {
1520                 for(x=0; x<width>>1; x++) {
1521                         R = (*s >> 16) & 0xff;
1522                         G = (*s >> 8) & 0xff;
1523                         B = *s & 0xff;
1524                         s++;
1525
1526                         Y1 = min(abs(R * 2104 + G * 4130 + B * 802 + 4096 + 131072) >> 13, 235);
1527                         U = min(abs(R * -1214 + G * -2384 + B * 3598 + 4096 + 1048576) >> 13, 240);
1528                         V = min(abs(R * 3598 + G * -3013 + B * -585 + 4096 + 1048576) >> 13, 240);
1529
1530                         R = (*s >> 16) & 0xff;
1531                         G = (*s >> 8) & 0xff;
1532                         B = *s & 0xff;
1533                         s++;
1534
1535                         Y2 = min(abs(R * 2104 + G * 4130 + B * 802 + 4096 + 131072) >> 13, 235);
1536
1537 #ifdef __BIG_ENDIAN__
1538                         *d = V | Y2 << 8 | U << 16 | Y1 << 24;
1539 #else
1540                         *d = U | Y1 << 8 | V << 16 | Y2 << 24;
1541 #endif
1542                         d++;
1543                 }
1544         }
1545 }
1546
1547 time_t tStart;
1548
1549 //Note: dest x,y,w,h are both input and output variables
1550 inline void MaintainAspect(unsigned int *dx,unsigned int *dy,unsigned int *dw,unsigned int *dh)
1551 {
1552         //Currently just 4/3 aspect ratio
1553         int t;
1554
1555         if (*dw * 3 > *dh * 4) {
1556                 t = *dh * 4.0f / 3;     //new width aspect
1557                 *dx = (*dw - t) / 2;    //centering
1558                 *dw = t;
1559         } else {
1560                 t = *dw * 3.0f / 4;
1561                 *dy = (*dh - t) / 2;
1562                 *dh = t;
1563         }
1564 }
1565
1566 void DoBufferSwap(void)
1567 {
1568         Screen *screen;
1569         Window _dw;
1570         XvImage *xvi;
1571         unsigned int dstx, dsty, srcy = 0;
1572         unsigned int _d, _w, _h;        //don't care about _d
1573
1574         finalw = PSXDisplay.DisplayMode.x;
1575         finalh = PSXDisplay.DisplayMode.y;
1576
1577         if (finalw == 0 || finalh == 0)
1578                 return;
1579
1580         XSync(display,False);
1581
1582         if(use_yuv) {
1583                 if (iUseNoStretchBlt==0 || finalw > 320 || finalh > 256) {
1584                         BlitToYUV((unsigned char *)shminfo.shmaddr, PSXDisplay.DisplayPosition.x, PSXDisplay.DisplayPosition.y);
1585                         finalw <<= 1;
1586                 } else {
1587                         BlitScreen32((unsigned char *)pBackBuffer, PSXDisplay.DisplayPosition.x, PSXDisplay.DisplayPosition.y);
1588                         p2XSaIFunc(pBackBuffer, finalw<<2, (unsigned char *)pSaIBigBuff,finalw,finalh);
1589                         RGB2YUV( (uint32_t*)pSaIBigBuff, finalw, finalh, (uint32_t*)shminfo.shmaddr);
1590                 }
1591         } else if(iUseNoStretchBlt==0 || finalw > 320 || finalh > 256) {
1592                 BlitScreen32((unsigned char *)shminfo.shmaddr, PSXDisplay.DisplayPosition.x, PSXDisplay.DisplayPosition.y);
1593         } else {
1594                 BlitScreen32((unsigned char *)pBackBuffer, PSXDisplay.DisplayPosition.x, PSXDisplay.DisplayPosition.y);
1595                 p2XSaIFunc(pBackBuffer, finalw<<2, (unsigned char *)shminfo.shmaddr,finalw,finalh);
1596         }
1597
1598         XGetGeometry(display, window, &_dw, (int *)&_d, (int *)&_d, &_w, &_h, &_d, &_d);
1599         if (use_yuv) {
1600                 xvi = XvShmCreateImage(display, yuv_port, yuv_id, 0, finalw, finalh, &shminfo);
1601         } else
1602                 xvi = XvShmCreateImage(display, xv_port, xv_id, 0, finalw, finalh, &shminfo);
1603
1604         xvi->data = shminfo.shmaddr;
1605
1606         screen=DefaultScreenOfDisplay(display);
1607         //screennum = DefaultScreen(display);
1608
1609         if (!iWindowMode) {
1610                 _w = screen->width;
1611                 _h = screen->height;
1612         }
1613
1614         dstx = 0;
1615         dsty = 0;
1616
1617         if (iMaintainAspect)
1618                 MaintainAspect(&dstx, &dsty, &_w, &_h);
1619
1620         if (ulKeybits&KEY_SHOWFPS)      //to avoid flicker, don't paint overtop FPS bar
1621         {
1622                 srcy = 15 * finalh / _h;
1623                 dsty += 15;
1624         }
1625
1626         XvShmPutImage(display, xv_port, window, hGC, xvi,
1627                 0,srcy,         //src x,y
1628                 finalw,finalh,  //src w,h
1629                 dstx,dsty,      //dst x,y
1630                 _w,_h,          //dst w,h
1631                 1
1632                 );
1633
1634         if(ulKeybits&KEY_SHOWFPS) //DisplayText();               // paint menu text
1635         {
1636                 if(szDebugText[0] && ((time(NULL) - tStart) < 2))
1637                 {
1638                         strcpy(szDispBuf,szDebugText);
1639                 }
1640                 else
1641                 {
1642                         szDebugText[0]=0;
1643                         strcat(szDispBuf,szMenuBuf);
1644                 }
1645
1646                 //XPutImage(display,window,hGC, XFimage,
1647                 //          0, 0, 0, 0, 220,15);
1648                 XFree(xvi);
1649                 xvi = XvCreateImage(display, xv_port, xv_id, XFimage->data, 220, 15);
1650                 XvPutImage(display, xv_port, window, hGC, xvi,
1651                         0,0,            //src x,y
1652                         220,15,         //src w,h
1653                         0,0,            //dst x,y
1654                         220,15          //dst w,h
1655                         );
1656
1657                 XDrawString(display,window,hGC,2,13,szDispBuf,strlen(szDispBuf));
1658         }
1659
1660         //if(XPimage) DisplayPic();
1661
1662
1663         XFree(xvi);
1664 }
1665
1666 void DoClearScreenBuffer(void)                         // CLEAR DX BUFFER
1667 {
1668  Window _dw;
1669  unsigned int _d, _w, _h;       //don't care about _d
1670
1671  XGetGeometry(display, window, &_dw, (int *)&_d, (int *)&_d, &_w, &_h, &_d, &_d);
1672
1673  XvPutImage(display, xv_port, window, hGC, XCimage,
1674            0, 0, 8, 8, 0, 0, _w, _h);
1675  //XSync(display,False);
1676 }
1677
1678 void DoClearFrontBuffer(void)                          // CLEAR DX BUFFER
1679 {/*
1680  XPutImage(display,window,hGC, XCimage,
1681            0, 0, 0, 0, iResX, iResY);
1682  XSync(display,False);*/
1683 }
1684
1685 int Xinitialize()
1686 {
1687    iDesktopCol=32;
1688
1689
1690  if(iUseNoStretchBlt>0)
1691   {
1692    pBackBuffer=(unsigned char *)malloc(640*512*sizeof(uint32_t));
1693    memset(pBackBuffer,0,640*512*sizeof(uint32_t));
1694    if (use_yuv) {
1695     pSaIBigBuff=malloc(640*512*4*3*3);
1696     memset(pSaIBigBuff,0,640*512*4*3*3);
1697    }
1698   }
1699
1700  p2XSaIFunc=NULL;
1701
1702 #if 0
1703  if(iUseNoStretchBlt==1)
1704   {
1705    p2XSaIFunc=Std2xSaI_ex8;
1706   }
1707
1708  if(iUseNoStretchBlt==2)
1709   {
1710    p2XSaIFunc=Super2xSaI_ex8;
1711   }
1712
1713  if(iUseNoStretchBlt==3)
1714   {
1715    p2XSaIFunc=SuperEagle_ex8;
1716   }
1717
1718  if(iUseNoStretchBlt==4)
1719   {
1720    p2XSaIFunc=Scale2x_ex8;
1721   }
1722  if(iUseNoStretchBlt==5)
1723   {
1724    p2XSaIFunc=Scale3x_ex8;
1725   }
1726  if(iUseNoStretchBlt==6)
1727   {
1728    p2XSaIFunc=hq2x_32;
1729   }
1730  if(iUseNoStretchBlt==7)
1731   {
1732    p2XSaIFunc=hq3x_32;
1733   }
1734 #endif
1735
1736  bUsingTWin=FALSE;
1737
1738  InitMenu();
1739
1740  bIsFirstFrame = FALSE;                                // done
1741
1742  if(iShowFPS)
1743   {
1744    iShowFPS=0;
1745    ulKeybits|=KEY_SHOWFPS;
1746    szDispBuf[0]=0;
1747    //BuildDispMenu(0);
1748   }
1749
1750  return 0;
1751 }
1752
1753 void Xcleanup()                                        // X CLEANUP
1754 {
1755  CloseMenu();
1756
1757  if(iUseNoStretchBlt>0)
1758   {
1759    if(pBackBuffer)  free(pBackBuffer);
1760    pBackBuffer=0;
1761    if(pSaIBigBuff) free(pSaIBigBuff);
1762    pSaIBigBuff=0;
1763   }
1764 }
1765
1766 unsigned long ulInitDisplay(void)
1767 {
1768  CreateDisplay();                                      // x stuff
1769  Xinitialize();                                        // init x
1770  return (unsigned long)display;
1771 }
1772
1773 void CloseDisplay(void)
1774 {
1775  Xcleanup();                                           // cleanup dx
1776  DestroyDisplay();
1777 }
1778
1779 void CreatePic(unsigned char * pMem)
1780 {
1781  unsigned char * p=(unsigned char *)malloc(128*96*4);
1782  unsigned char * ps; int x,y;
1783
1784  ps=p;
1785
1786  if(iDesktopCol==16)
1787   {
1788    unsigned short s;
1789    for(y=0;y<96;y++)
1790     {
1791      for(x=0;x<128;x++)
1792       {
1793        s=(*(pMem+0))>>3;
1794        s|=((*(pMem+1))&0xfc)<<3;
1795        s|=((*(pMem+2))&0xf8)<<8;
1796        pMem+=3;
1797        *((unsigned short *)(ps+y*256+x*2))=s;
1798       }
1799     }
1800   }
1801  else
1802  if(iDesktopCol==15)
1803   {
1804    unsigned short s;
1805    for(y=0;y<96;y++)
1806     {
1807      for(x=0;x<128;x++)
1808       {
1809        s=(*(pMem+0))>>3;
1810        s|=((*(pMem+1))&0xfc)<<2;
1811        s|=((*(pMem+2))&0xf8)<<7;
1812        pMem+=3;
1813        *((unsigned short *)(ps+y*256+x*2))=s;
1814       }
1815     }
1816   }
1817  else
1818  if(iDesktopCol==32)
1819   {
1820    uint32_t l;
1821    for(y=0;y<96;y++)
1822     {
1823      for(x=0;x<128;x++)
1824       {
1825        l=  *(pMem+0);
1826        l|=(*(pMem+1))<<8;
1827        l|=(*(pMem+2))<<16;
1828        pMem+=3;
1829        *((uint32_t *)(ps+y*512+x*4))=l;
1830       }
1831     }
1832   }
1833
1834  XPimage = XCreateImage(display,myvisual->visual,
1835                         depth, ZPixmap, 0,
1836                         (char *)p,
1837                         128, 96,
1838                         depth>16 ? 32 : 16,
1839                         0);
1840 }
1841
1842 void DestroyPic(void)
1843 {
1844  if(XPimage)
1845   { /*
1846    XPutImage(display,window,hGC, XCimage,
1847           0, 0, 0, 0, iResX, iResY);*/
1848    XDestroyImage(XPimage);
1849    XPimage=0;
1850   }
1851 }
1852
1853 void DisplayPic(void)
1854 {
1855  XPutImage(display,window,hGC, XPimage,
1856            0, 0, iResX-128, 0,128,96);
1857 }
1858
1859 void ShowGpuPic(void)
1860 {
1861 }
1862
1863 void ShowTextGpuPic(void)
1864 {
1865 }
1866
1867 #if 0
1868 static void hq2x_32_def(uint32_t * dst0, uint32_t * dst1, const uint32_t * src0, const uint32_t * src1, const uint32_t * src2, unsigned count)
1869 {
1870         static unsigned char cache_vert_mask[640];
1871         unsigned char cache_horiz_mask = 0;
1872
1873         unsigned i;
1874         unsigned char mask;
1875         uint32_t  c[9];
1876
1877         if (src0 == src1)       //processing first row
1878                 memset(cache_vert_mask, 0, count);
1879
1880         for(i=0;i<count;++i) {
1881                 c[1] = src0[0];
1882                 c[4] = src1[0];
1883                 c[7] = src2[0];
1884
1885                 if (i>0) {
1886                         c[0] = src0[-1];
1887                         c[3] = src1[-1];
1888                         c[6] = src2[-1];
1889                 } else {
1890                         c[0] = c[1];
1891                         c[3] = c[4];
1892                         c[6] = c[7];
1893                 }
1894
1895                 if (i<count-1) {
1896                         c[2] = src0[1];
1897                         c[5] = src1[1];
1898                         c[8] = src2[1];
1899                 } else {
1900                         c[2] = c[1];
1901                         c[5] = c[4];
1902                         c[8] = c[7];
1903                 }
1904
1905                 mask = 0;
1906
1907                 mask |= interp_32_diff(c[0], c[4]) << 0;
1908                 mask |= cache_vert_mask[i];
1909                 mask |= interp_32_diff(c[2], c[4]) << 2;
1910                 mask |= cache_horiz_mask;
1911                 cache_horiz_mask = interp_32_diff(c[5], c[4]) << 3;
1912                 mask |= cache_horiz_mask << 1;  // << 3 << 1 == << 4
1913                 mask |= interp_32_diff(c[6], c[4]) << 5;
1914                 cache_vert_mask[i] = interp_32_diff(c[7], c[4]) << 1;
1915                 mask |= cache_vert_mask[i] << 5; // << 1 << 5 == << 6
1916                 mask |= interp_32_diff(c[8], c[4]) << 7;
1917
1918
1919                 switch (mask) {
1920 #include "hq2x.h"
1921                 }
1922
1923
1924                 src0 += 1;
1925                 src1 += 1;
1926                 src2 += 1;
1927                 dst0 += 2;
1928                 dst1 += 2;
1929         }
1930 }
1931
1932 void hq2x_32( unsigned char * srcPtr,  DWORD srcPitch, unsigned char * dstPtr, int width, int height)
1933 {
1934         const int dstPitch = srcPitch<<1;
1935
1936         int count = height;
1937
1938         finalw=width*2;
1939         finalh=height*2;
1940
1941         uint32_t  *dst0 = (uint32_t  *)dstPtr;
1942         uint32_t  *dst1 = dst0 + (dstPitch >> 2);
1943
1944         uint32_t  *src0 = (uint32_t  *)srcPtr;
1945         uint32_t  *src1 = src0 + (srcPitch >> 2);
1946         uint32_t  *src2 = src1 + (srcPitch >> 2);
1947         hq2x_32_def(dst0, dst1, src0, src0, src1, width);
1948
1949
1950         count -= 2;
1951         while(count) {
1952                 dst0 += dstPitch >> 1;          //next 2 lines (dstPitch / 4 char per int * 2)
1953                 dst1 += dstPitch >> 1;
1954                 hq2x_32_def(dst0, dst1, src0, src1, src2, width);
1955                 src0 = src1;
1956                 src1 = src2;
1957                 src2 += srcPitch >> 2;
1958                 --count;
1959         }
1960         dst0 += dstPitch >> 1;
1961         dst1 += dstPitch >> 1;
1962         hq2x_32_def(dst0, dst1, src0, src1, src1, width);
1963 }
1964
1965 static void hq3x_32_def(uint32_t*  dst0, uint32_t*  dst1, uint32_t*  dst2, const uint32_t* src0, const uint32_t* src1, const uint32_t* src2, unsigned count)
1966 {
1967         static unsigned char cache_vert_mask[640];
1968         unsigned char cache_horiz_mask = 0;
1969
1970         unsigned i;
1971         unsigned char mask;
1972         uint32_t  c[9];
1973
1974         if (src0 == src1)       //processing first row
1975                 memset(cache_vert_mask, 0, count);
1976
1977         for(i=0;i<count;++i) {
1978                 c[1] = src0[0];
1979                 c[4] = src1[0];
1980                 c[7] = src2[0];
1981
1982                 if (i>0) {
1983                         c[0] = src0[-1];
1984                         c[3] = src1[-1];
1985                         c[6] = src2[-1];
1986                 } else {
1987                         c[0] = c[1];
1988                         c[3] = c[4];
1989                         c[6] = c[7];
1990                 }
1991
1992                 if (i<count-1) {
1993                         c[2] = src0[1];
1994                         c[5] = src1[1];
1995                         c[8] = src2[1];
1996                 } else {
1997                         c[2] = c[1];
1998                         c[5] = c[4];
1999                         c[8] = c[7];
2000                 }
2001
2002                 mask = 0;
2003
2004                 mask |= interp_32_diff(c[0], c[4]) << 0;
2005                 mask |= cache_vert_mask[i];
2006                 mask |= interp_32_diff(c[2], c[4]) << 2;
2007                 mask |= cache_horiz_mask;
2008                 cache_horiz_mask = interp_32_diff(c[5], c[4]) << 3;
2009                 mask |= cache_horiz_mask << 1;  // << 3 << 1 == << 4
2010                 mask |= interp_32_diff(c[6], c[4]) << 5;
2011                 cache_vert_mask[i] = interp_32_diff(c[7], c[4]) << 1;
2012                 mask |= cache_vert_mask[i] << 5; // << 1 << 5 == << 6
2013                 mask |= interp_32_diff(c[8], c[4]) << 7;
2014
2015                 switch (mask) {
2016 #include "hq3x.h"
2017                 }
2018
2019                 src0 += 1;
2020                 src1 += 1;
2021                 src2 += 1;
2022                 dst0 += 3;
2023                 dst1 += 3;
2024                 dst2 += 3;
2025         }
2026 }
2027
2028 void hq3x_32( unsigned char * srcPtr,  DWORD srcPitch, unsigned char * dstPtr, int width, int height)
2029 {
2030         int count = height;
2031
2032         int dstPitch = srcPitch*3;
2033         int dstRowPixels = dstPitch>>2;
2034
2035         finalw=width*3;
2036         finalh=height*3;
2037
2038         uint32_t  *dst0 = (uint32_t  *)dstPtr;
2039         uint32_t  *dst1 = dst0 + dstRowPixels;
2040         uint32_t  *dst2 = dst1 + dstRowPixels;
2041
2042         uint32_t  *src0 = (uint32_t  *)srcPtr;
2043         uint32_t  *src1 = src0 + (srcPitch >> 2);
2044         uint32_t  *src2 = src1 + (srcPitch >> 2);
2045         hq3x_32_def(dst0, dst1, dst2, src0, src0, src2, width);
2046
2047         count -= 2;
2048         while(count) {
2049                 dst0 += dstRowPixels * 3;
2050                 dst1 += dstRowPixels * 3;
2051                 dst2 += dstRowPixels * 3;
2052
2053                 hq3x_32_def(dst0, dst1, dst2, src0, src1, src2, width);
2054                 src0 = src1;
2055                 src1 = src2;
2056                 src2 += srcPitch >> 2;
2057                 --count;
2058         }
2059         dst0 += dstRowPixels * 3;
2060         dst1 += dstRowPixels * 3;
2061         dst2 += dstRowPixels * 3;
2062
2063         hq3x_32_def(dst0, dst1, dst2, src0, src1, src1, width);
2064
2065 }
2066 #endif