← Back to branch summary

~ubuntu-branches/ubuntu/lucid/fceux/lucid

« back to all changes in this revision

Viewing changes to fceu/src/drivers/common/vidblit.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-12-14 08:05:17 UTC
  • Revision ID: james.westby@ubuntu.com-20091214080517-abi5tj8avthfan7c
Tags: upstream-2.1.2+repack
Import upstream version 2.1.2+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
fceu/src/drivers/common/vidblit.cpp
 
1
/* FCE Ultra - NES/Famicom Emulator
 
2
 *
 
3
 * Copyright notice for this file:
 
4
 *  Copyright (C) 2002 Xodnizel
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 */
 
20
 
 
21
#include <stdlib.h>
 
22
#include "scalebit.h"
 
23
#include "hq2x.h"
 
24
#include "hq3x.h"
 
25
 
 
26
#include "../../types.h"
 
27
 
 
28
static uint32 CBM[3];
 
29
static uint32 *palettetranslate=0;
 
30
 
 
31
static uint16 *specbuf=NULL;            // 8bpp -> 16bpp, pre hq2x/hq3x
 
32
static uint32 *specbuf32bpp = NULL;      // Buffer to hold output
 
33
                                        // of hq2x/hq3x when converting
 
34
                                        // to 16bpp and 24bpp
 
35
static int backBpp, backshiftr[3], backshiftl[3];
 
36
//static uint32 backmask[3];
 
37
 
 
38
static uint8 *specbuf8bpp = NULL;       // For 2xscale, 3xscale.
 
39
 
 
40
 
 
41
static int silt;
 
42
 
 
43
static int Bpp; // BYTES per pixel
 
44
static int highefx;
 
45
 
 
46
#define BLUR_RED        20
 
47
#define BLUR_GREEN      20
 
48
#define BLUR_BLUE       10
 
49
 
 
50
#define FVB_SCANLINES   1
 
51
 
 
52
/* The blur effect is only available for bpp>=16.  It could be easily modified
 
53
   to look like what happens on the real NES and TV, but lack of decent
 
54
   synchronization to the vertical retrace period makes it look rather
 
55
   blah.
 
56
*/
 
57
#define FVB_BLUR        2
 
58
 
 
59
static void CalculateShift(uint32 *CBM, int *cshiftr, int *cshiftl)
 
60
{
 
61
             int a,x,z,y;
 
62
             cshiftl[0]=cshiftl[1]=cshiftl[2]=-1;
 
63
             for(a=0;a<3;a++)
 
64
             {
 
65
              for(x=0,y=-1,z=0;x<32;x++)
 
66
              {
 
67
               if(CBM[a]&(1<<x))
 
68
               {
 
69
                if(cshiftl[a]==-1) cshiftl[a]=x;
 
70
                z++;
 
71
               }
 
72
              }
 
73
              cshiftr[a]=(8-z);
 
74
             }
 
75
}
 
76
 
 
77
 
 
78
int InitBlitToHigh(int b, uint32 rmask, uint32 gmask, uint32 bmask, int efx, int specfilt)
 
79
{
 
80
 if(specfilt == 2 || specfilt == 4) // scale2x and scale3x
 
81
 {
 
82
  int multi = ((specfilt == 2) ? 2 * 2 : 3 * 3);
 
83
 
 
84
  specbuf8bpp = (uint8*)malloc(256*240*multi); //mbg merge 7/17/06 added cast
 
85
 
 
86
 }
 
87
 else if(specfilt == 1 || specfilt == 3) // hq2x and hq3x
 
88
 { 
 
89
  if(b == 1) 
 
90
   return(0);
 
91
 
 
92
  if(b == 2 || b == 3)          // 8->16->(hq2x)->32-> 24 or 16.  YARGH.
 
93
  {
 
94
   uint32 tmpCBM[3];
 
95
   backBpp = b;
 
96
   tmpCBM[0]=rmask;
 
97
   tmpCBM[1]=gmask;
 
98
   tmpCBM[2]=bmask;
 
99
 
 
100
   CalculateShift(tmpCBM, backshiftr, backshiftl);
 
101
 
 
102
   if(b == 2)
 
103
   {
 
104
    // ark
 
105
    backshiftr[0] += 16;
 
106
    backshiftr[1] += 8;
 
107
    backshiftr[2] += 0;
 
108
 
 
109
    // Begin iffy code(requires 16bpp and 32bpp to have same RGB order)
 
110
    //backmask[0] = (rmask>>backshiftl[0]) << (backshiftr[0]);
 
111
    //backmask[1] = (gmask>>backshiftl[1]) << (backshiftr[1]);
 
112
    //backmask[2] = (bmask>>backshiftl[2]) << (backshiftr[2]);
 
113
 
 
114
    //int x;
 
115
    //for(x=0;x<3;x++) 
 
116
    // backshiftr[x] -= backshiftl[x];
 
117
    // End iffy code
 
118
   }
 
119
   if(specfilt == 1) specbuf32bpp = (uint32*)malloc(256*240*4*sizeof(uint32)); //mbg merge 7/17/06 added cast
 
120
   else if(specfilt == 3) specbuf32bpp = (uint32*)malloc(256*240*9*sizeof(uint32)); //mbg merge 7/17/06 added cast
 
121
  }
 
122
 
 
123
  efx=0;
 
124
  b=2;
 
125
  rmask=0x1F<<11;
 
126
  gmask=0x3F<<5;
 
127
  bmask=0x1F;
 
128
 
 
129
  if(specfilt == 3)
 
130
   hq3x_InitLUTs();
 
131
  else
 
132
   hq2x_InitLUTs();
 
133
 
 
134
  specbuf=(uint16*)malloc(256*240*sizeof(uint16)); //mbg merge 7/17/06 added cast
 
135
 }
 
136
 
 
137
 silt = specfilt;
 
138
 
 
139
 Bpp=b;
 
140
 
 
141
 highefx=efx;
 
142
 
 
143
 if(Bpp<=1 || Bpp>4)
 
144
  return(0);
 
145
 
 
146
 if(efx&FVB_BLUR)
 
147
 {
 
148
  if(Bpp==2)
 
149
   palettetranslate=(uint32 *)malloc(65536*4);
 
150
  else if(Bpp>=3)
 
151
   palettetranslate=(uint32 *)malloc(65536*4);
 
152
 }
 
153
 else
 
154
 {
 
155
  if(Bpp==2)
 
156
   palettetranslate=(uint32*)malloc(65536*4);
 
157
  else if(Bpp>=3)
 
158
   palettetranslate=(uint32*)malloc(256*4);
 
159
 }
 
160
 
 
161
 if(!palettetranslate)
 
162
  return(0);
 
163
 
 
164
 
 
165
 CBM[0]=rmask;
 
166
 CBM[1]=gmask;
 
167
 CBM[2]=bmask;
 
168
 return(1);
 
169
}
 
170
 
 
171
void KillBlitToHigh(void)
 
172
{
 
173
 if(palettetranslate)
 
174
 {
 
175
  free(palettetranslate);
 
176
  palettetranslate=NULL;
 
177
 }
 
178
 
 
179
 if(specbuf8bpp)
 
180
 {
 
181
  free(specbuf8bpp);
 
182
  specbuf8bpp = NULL;
 
183
 }
 
184
 if(specbuf32bpp)
 
185
 {
 
186
  free(specbuf32bpp);
 
187
  specbuf32bpp = NULL;
 
188
 }
 
189
 if(specbuf)
 
190
 {
 
191
  if(silt == 3)
 
192
   hq3x_Kill();
 
193
  else
 
194
   hq2x_Kill();
 
195
  specbuf=NULL;
 
196
 }
 
197
}
 
198
 
 
199
 
 
200
void SetPaletteBlitToHigh(uint8 *src)
 
201
{ 
 
202
             int cshiftr[3];
 
203
             int cshiftl[3];
 
204
             int x,y;
 
205
 
 
206
              CalculateShift(CBM, cshiftr, cshiftl);
 
207
 
 
208
 switch(Bpp)
 
209
 {
 
210
    case 2:
 
211
             if(highefx&FVB_BLUR)
 
212
             {
 
213
              for(x=0;x<256;x++)   
 
214
              {
 
215
               uint32 r,g,b;
 
216
               for(y=0;y<256;y++)
 
217
               {
 
218
                r=src[x<<2]*(100-BLUR_RED);
 
219
                g=src[(x<<2)+1]*(100-BLUR_GREEN);
 
220
                b=src[(x<<2)+2]*(100-BLUR_BLUE);
 
221
  
 
222
                r+=src[y<<2]*BLUR_RED;
 
223
                g+=src[(y<<2)+1]*BLUR_GREEN;
 
224
                b+=src[(y<<2)+2]*BLUR_BLUE;
 
225
                r/=100;
 
226
                g/=100; 
 
227
                b/=100;
 
228
 
 
229
                if(r>255) r=255; if(g>255) g=255; if(b>255) b=255;
 
230
                palettetranslate[x|(y<<8)]=((r>>cshiftr[0])<<cshiftl[0])|
 
231
                                           ((g>>cshiftr[1])<<cshiftl[1])|
 
232
                                           ((b>>cshiftr[2])<<cshiftl[2]);
 
233
               }
 
234
              }
 
235
             }
 
236
             else
 
237
             for(x=0;x<65536;x++)
 
238
             {
 
239
              uint16 lower,upper;
 
240
 
 
241
              lower=(src[((x&255)<<2)]>>cshiftr[0])<<cshiftl[0];
 
242
              lower|=(src[((x&255)<<2)+1]>>cshiftr[1])<<cshiftl[1];
 
243
              lower|=(src[((x&255)<<2)+2]>>cshiftr[2])<<cshiftl[2];
 
244
              upper=(src[((x>>8)<<2)]>>cshiftr[0])<<cshiftl[0];
 
245
              upper|=(src[((x>>8)<<2)+1]>>cshiftr[1])<<cshiftl[1];
 
246
              upper|=(src[((x>>8)<<2)+2]>>cshiftr[2])<<cshiftl[2];
 
247
 
 
248
              palettetranslate[x]=lower|(upper<<16);
 
249
             }
 
250
            break;
 
251
    case 3:
 
252
    case 4:
 
253
            for(x=0;x<256;x++)
 
254
            {
 
255
             uint32 r,g,b;
 
256
 
 
257
             if(!(highefx&FVB_BLUR))
 
258
             {
 
259
              r=src[x<<2];
 
260
              g=src[(x<<2)+1];
 
261
              b=src[(x<<2)+2];
 
262
              palettetranslate[x]=(r<<cshiftl[0])|(g<<cshiftl[1])|(b<<cshiftl[2]);
 
263
             }
 
264
             else       
 
265
             for(y=0;y<256;y++)
 
266
             {
 
267
                r=src[x<<2]*(100-BLUR_RED);
 
268
                g=src[(x<<2)+1]*(100-BLUR_GREEN);
 
269
                b=src[(x<<2)+2]*(100-BLUR_BLUE);
 
270
 
 
271
                r+=src[y<<2]*BLUR_RED;
 
272
                g+=src[(y<<2)+1]*BLUR_GREEN;
 
273
                b+=src[(y<<2)+2]*BLUR_BLUE;
 
274
               
 
275
                r/=100;
 
276
                g/=100;
 
277
                b/=100;                  
 
278
                if(r>255) r=255; if(g>255) g=255; if(b>255) b=255;
 
279
 
 
280
                palettetranslate[x|(y<<8)]=(r<<cshiftl[0])|(g<<cshiftl[1])|(b<<cshiftl[2]);
 
281
             }
 
282
            }
 
283
            break;
 
284
 }
 
285
}
 
286
 
 
287
void Blit32to24(uint32 *src, uint8 *dest, int xr, int yr, int dpitch)
 
288
{
 
289
 int x,y;
 
290
 
 
291
 for(y=yr;y;y--)
 
292
 {
 
293
  for(x=xr;x;x--)
 
294
  {
 
295
   uint32 tmp = *src;
 
296
   *dest = tmp;
 
297
   dest++;
 
298
   *dest = tmp>>8;
 
299
   dest++;
 
300
   *dest = tmp>>16;
 
301
   dest++;
 
302
   src++;
 
303
  }
 
304
  dest += dpitch / 3 - xr;
 
305
 }
 
306
}
 
307
 
 
308
 
 
309
void Blit32to16(uint32 *src, uint16 *dest, int xr, int yr, int dpitch,
 
310
        int shiftr[3], int shiftl[3])
 
311
{
 
312
 int x,y;
 
313
 //printf("%d\n",shiftl[1]);
 
314
 for(y=yr;y;y--)
 
315
 {
 
316
  for(x=xr;x;x--)
 
317
  {
 
318
   uint32 tmp = *src;
 
319
   uint16 dtmp;
 
320
 
 
321
   // Begin iffy code
 
322
   //dtmp = (tmp & backmask[2]) >> shiftr[2];
 
323
   //dtmp |= (tmp & backmask[1]) >> shiftr[1];
 
324
   //dtmp |= (tmp & backmask[0]) >> shiftr[0];
 
325
   // End iffy code
 
326
 
 
327
   // Begin non-iffy code
 
328
   dtmp =  ((tmp&0x0000FF) >> shiftr[2]) << shiftl[2];
 
329
   dtmp |= ((tmp&0x00FF00) >> shiftr[1]) << shiftl[1];
 
330
   dtmp |= ((tmp&0xFF0000) >> shiftr[0]) << shiftl[0];
 
331
   // End non-iffy code
 
332
 
 
333
   //dtmp = ((tmp&0x0000FF) >> 3);
 
334
   //dtmp |= ((tmp&0x00FC00) >>5);
 
335
   //dtmp |= ((tmp&0xF80000) >>8);
 
336
 
 
337
   *dest = dtmp;
 
338
   src++;
 
339
   dest++;
 
340
  }
 
341
  dest += dpitch / 2 - xr;
 
342
 }
 
343
}
 
344
 
 
345
 
 
346
void Blit8To8(uint8 *src, uint8 *dest, int xr, int yr, int pitch, int xscale, int yscale, int efx, int special)
 
347
{
 
348
 int x,y;
 
349
 int pinc;
 
350
 
 
351
 if(special==2)
 
352
 {
 
353
  if(xscale!=2 || yscale!=2) return;
 
354
  
 
355
  scale(2,dest,pitch,src,256,1,xr,yr);
 
356
  return;
 
357
 }
 
358
 
 
359
 if(special==4)
 
360
 {
 
361
  if(xscale!=3 || yscale!=3) return;
 
362
  scale(3,dest,pitch,src,256,1,xr,yr);
 
363
  return;
 
364
 }     
 
365
 
 
366
 pinc=pitch-(xr*xscale);
 
367
 if(xscale!=1 || yscale!=1)
 
368
 {
 
369
  if(efx&FVB_SCANLINES)
 
370
  {
 
371
   for(y=yr;y;y--,src+=256-xr)
 
372
   {
 
373
    int doo=yscale-(yscale>>1);
 
374
    do
 
375
    {
 
376
     for(x=xr;x;x--,src++)
 
377
     {
 
378
      int too=xscale;
 
379
      do
 
380
      {
 
381
       *(uint8 *)dest=*(uint8 *)src;
 
382
       dest++;
 
383
      } while(--too);
 
384
     }
 
385
     src-=xr;
 
386
     dest+=pinc;
 
387
    } while(--doo);
 
388
    //src-=xr*(yscale-(yscale>>1));
 
389
    dest+=pitch*(yscale>>1);
 
390
 
 
391
    src+=xr;
 
392
   }
 
393
 
 
394
  }
 
395
  else
 
396
  {
 
397
   for(y=yr;y;y--,src+=256-xr)
 
398
   {
 
399
    int doo=yscale;
 
400
    do
 
401
    {
 
402
     for(x=xr;x;x--,src++)
 
403
     {
 
404
      int too=xscale;
 
405
      do
 
406
      {
 
407
       *(uint8 *)dest=*(uint8 *)src;
 
408
       dest++;
 
409
      } while(--too);
 
410
     }
 
411
     src-=xr;
 
412
     dest+=pinc;
 
413
    } while(--doo);
 
414
    src+=xr;
 
415
   }
 
416
 }
 
417
 
 
418
 }
 
419
 else
 
420
 {
 
421
  for(y=yr;y;y--,dest+=pinc,src+=256-xr)
 
422
   for(x=xr;x;x-=4,dest+=4,src+=4)
 
423
    *(uint32 *)dest=*(uint32 *)src;
 
424
 }
 
425
}
 
426
 
 
427
/* Todo:  Make sure 24bpp code works right with big-endian cpus */
 
428
 
 
429
void Blit8ToHigh(uint8 *src, uint8 *dest, int xr, int yr, int pitch, 
 
430
                 int xscale, int yscale)
 
431
{
 
432
 int x,y;
 
433
 int pinc;
 
434
 uint8 *destbackup = NULL;      /* For hq2x */
 
435
 int pitchbackup = 0;
 
436
 
 
437
 //static int google=0;
 
438
 //google^=1;
 
439
 
 
440
 if(specbuf8bpp)        // 2xscale/3xscale
 
441
 {
 
442
  int mult; 
 
443
  int base;
 
444
 
 
445
  if(silt == 2) mult = 2;
 
446
  else mult = 3;
 
447
 
 
448
  Blit8To8(src, specbuf8bpp, xr, yr, 256*mult, xscale, yscale, 0, silt);
 
449
 
 
450
  xr *= mult;
 
451
  yr *= mult;
 
452
  xscale=yscale=1;
 
453
  src = specbuf8bpp;
 
454
  base = 256*mult;
 
455
 
 
456
  switch(Bpp)
 
457
  {
 
458
    case 4:
 
459
    pinc=pitch-(xr<<2);
 
460
    for(y=yr;y;y--,src+=base-xr)
 
461
    {
 
462
     for(x=xr;x;x--)
 
463
     {
 
464
      *(uint32 *)dest=palettetranslate[(uint32)*src];
 
465
      dest+=4;
 
466
      src++;
 
467
     }
 
468
     dest+=pinc;
 
469
    }
 
470
    break;
 
471
   case 3:
 
472
    pinc=pitch-(xr+xr+xr);
 
473
    for(y=yr;y;y--,src+=base-xr)
 
474
    {
 
475
     for(x=xr;x;x--)
 
476
     {
 
477
      uint32 tmp=palettetranslate[(uint32)*src];
 
478
      *(uint8 *)dest=tmp;
 
479
      *((uint8 *)dest+1)=tmp>>8;
 
480
      *((uint8 *)dest+2)=tmp>>16;
 
481
      dest+=3;
 
482
      src++;
 
483
      src++;
 
484
     }
 
485
     dest+=pinc;
 
486
    }
 
487
    break; 
 
488
  case 2:
 
489
   pinc=pitch-(xr<<1);
 
490
 
 
491
   for(y=yr;y;y--,src+=base-xr)
 
492
   {
 
493
    for(x=xr>>1;x;x--)
 
494
    {
 
495
     *(uint32 *)dest=palettetranslate[*(uint16 *)src];
 
496
     dest+=4;
 
497
     src+=2;
 
498
    }
 
499
    dest+=pinc;
 
500
   }
 
501
   break;
 
502
  }
 
503
  return;
 
504
 }
 
505
 else if(specbuf)
 
506
 {
 
507
  destbackup=dest;
 
508
  dest=(uint8 *)specbuf;
 
509
  pitchbackup=pitch;
 
510
 
 
511
  pitch=xr*sizeof(uint16);
 
512
  xscale=1;
 
513
  yscale=1;
 
514
 }
 
515
 
 
516
 if(highefx&FVB_BLUR)   // DONE
 
517
 {
 
518
  if(xscale!=1 || yscale!=1 || (highefx&FVB_SCANLINES)) // DONE
 
519
  {
 
520
   switch(Bpp)
 
521
   {
 
522
    case 4:
 
523
     pinc=pitch-((xr*xscale)<<2);
 
524
     for(y=yr;y;y--,src+=256-xr)
 
525
     {
 
526
      int doo=yscale;   
 
527
     
 
528
      if(highefx&FVB_SCANLINES)
 
529
       doo-=yscale>>1;
 
530
      do
 
531
      {
 
532
       uint8 last=0x00;
 
533
 
 
534
       //if(doo == 1 && google) dest+=4;
 
535
       for(x=xr;x;x--,src++)
 
536
       {
 
537
        int too=xscale;
 
538
        do
 
539
        {
 
540
         *(uint32 *)dest=palettetranslate[*src|(last<<8)];
 
541
         dest+=4;
 
542
        } while(--too);
 
543
        last=*src;
 
544
       }
 
545
       //if(doo == 1 && google) dest-=4;
 
546
       src-=xr;
 
547
       dest+=pinc;
 
548
      } while(--doo);
 
549
      src+=xr;
 
550
      if(highefx&FVB_SCANLINES)
 
551
       dest+=pitch*(yscale>>1);
 
552
     }
 
553
     break;
 
554
  case 3:
 
555
     pinc=pitch-((xr*xscale)*3);
 
556
     for(y=yr;y;y--,src+=256-xr)
 
557
     {
 
558
      int doo=yscale;
 
559
 
 
560
      if(highefx&FVB_SCANLINES)
 
561
       doo-=yscale>>1;
 
562
      do
 
563
      {
 
564
       uint8 last=0x00;
 
565
       for(x=xr;x;x--,src++)
 
566
       {
 
567
        int too=xscale;
 
568
        do
 
569
        {  
 
570
         *(uint32 *)dest=palettetranslate[*src|(last<<8)];
 
571
         dest+=3;
 
572
        } while(--too);
 
573
        last=*src;
 
574
       }
 
575
       src-=xr;
 
576
       dest+=pinc;
 
577
      } while(--doo); 
 
578
      src+=xr;
 
579
      if(highefx&FVB_SCANLINES)
 
580
       dest+=pitch*(yscale>>1);
 
581
     }     
 
582
     break;
 
583
 
 
584
  case 2:
 
585
    pinc=pitch-((xr*xscale)<<1);
 
586
 
 
587
    for(y=yr;y;y--,src+=256-xr)
 
588
    {
 
589
     int doo=yscale;
 
590
 
 
591
     if(highefx& FVB_SCANLINES)
 
592
      doo-=yscale>>1;     
 
593
     do
 
594
     {
 
595
      uint8 last=0x00;
 
596
      for(x=xr;x;x--,src++)
 
597
      {
 
598
       int too=xscale;
 
599
       do
 
600
       {
 
601
        *(uint16 *)dest=palettetranslate[*src|(last<<8)];
 
602
        dest+=2;
 
603
       } while(--too);
 
604
       last=*src;
 
605
      }
 
606
     src-=xr;
 
607
     dest+=pinc;
 
608
     } while(--doo);
 
609
     src+=xr;
 
610
     if(highefx&FVB_SCANLINES) 
 
611
      dest+=pitch*(yscale>>1);
 
612
    }
 
613
    break;   
 
614
   }   
 
615
  }
 
616
  else // No scaling, no scanlines, just blurring. - DONE
 
617
  switch(Bpp)
 
618
  {
 
619
   case 4:   
 
620
    pinc=pitch-(xr<<2);
 
621
    for(y=yr;y;y--,src+=256-xr)
 
622
    {
 
623
     uint8 last=0x00;
 
624
     for(x=xr;x;x--)
 
625
     {
 
626
      *(uint32 *)dest=palettetranslate[*src|(last<<8)];
 
627
      last=*src;
 
628
      dest+=4;
 
629
      src++; 
 
630
     }
 
631
     dest+=pinc;
 
632
    }
 
633
    break;
 
634
   case 3:
 
635
    pinc=pitch-(xr+xr+xr);
 
636
    for(y=yr;y;y--,src+=256-xr)
 
637
    {
 
638
     uint8 last=0x00;
 
639
     for(x=xr;x;x--)
 
640
     {
 
641
      uint32 tmp=palettetranslate[*src|(last<<8)];
 
642
      last=*src;
 
643
      *(uint8 *)dest=tmp;
 
644
      *((uint8 *)dest+1)=tmp>>8;
 
645
      *((uint8 *)dest+2)=tmp>>16;
 
646
      dest+=3;
 
647
      src++;   
 
648
     }
 
649
     dest+=pinc;
 
650
    }
 
651
    break;
 
652
  case 2:
 
653
   pinc=pitch-(xr<<1);
 
654
   for(y=yr;y;y--,src+=256-xr)
 
655
   {
 
656
    uint8 last=0x00;
 
657
    for(x=xr;x;x--)
 
658
    {
 
659
     *(uint16 *)dest=palettetranslate[*src|(last<<8)];
 
660
     last=*src;
 
661
     dest+=2;
 
662
     src++;
 
663
    }
 
664
    dest+=pinc;
 
665
   }
 
666
   break;
 
667
  }
 
668
 }
 
669
 else   // No blur effects.
 
670
 {
 
671
  if(xscale!=1 || yscale!=1 || (highefx&FVB_SCANLINES))
 
672
  {
 
673
   switch(Bpp)
 
674
   {
 
675
    case 4:
 
676
    pinc=pitch-((xr*xscale)<<2);
 
677
    for(y=yr;y;y--,src+=256-xr)
 
678
    {
 
679
     int doo=yscale;
 
680
             
 
681
     if(highefx& FVB_SCANLINES)
 
682
      doo-=yscale>>1;
 
683
     do
 
684
     {
 
685
      for(x=xr;x;x--,src++)
 
686
      {
 
687
       int too=xscale;
 
688
       do
 
689
       {
 
690
        *(uint32 *)dest=palettetranslate[*src]; 
 
691
        dest+=4;
 
692
       } while(--too);
 
693
      }
 
694
      src-=xr;
 
695
      dest+=pinc;
 
696
     } while(--doo);
 
697
     src+=xr;
 
698
     if(highefx&FVB_SCANLINES)
 
699
      dest+=pitch*(yscale>>1);
 
700
    }  
 
701
    break;
 
702
 
 
703
   case 3:
 
704
    pinc=pitch-((xr*xscale)*3);
 
705
    for(y=yr;y;y--,src+=256-xr)
 
706
    {  
 
707
     int doo=yscale;
 
708
      
 
709
     if(highefx& FVB_SCANLINES)
 
710
      doo-=yscale>>1;
 
711
     do
 
712
     {
 
713
      for(x=xr;x;x--,src++)
 
714
      {    
 
715
       int too=xscale;
 
716
       do
 
717
       {
 
718
        uint32 tmp=palettetranslate[(uint32)*src];
 
719
        *(uint8 *)dest=tmp;
 
720
        *((uint8 *)dest+1)=tmp>>8;
 
721
        *((uint8 *)dest+2)=tmp>>16;
 
722
        dest+=3;
 
723
 
 
724
        //*(uint32 *)dest=palettetranslate[*src];
 
725
        //dest+=4;
 
726
       } while(--too);
 
727
      }
 
728
      src-=xr;
 
729
      dest+=pinc;
 
730
     } while(--doo);
 
731
     src+=xr;
 
732
     if(highefx&FVB_SCANLINES)
 
733
      dest+=pitch*(yscale>>1);
 
734
    }
 
735
    break;
 
736
 
 
737
  case 2:
 
738
    pinc=pitch-((xr*xscale)<<1);
 
739
       
 
740
    for(y=yr;y;y--,src+=256-xr)
 
741
    {   
 
742
     int doo=yscale;
 
743
        
 
744
     if(highefx& FVB_SCANLINES)
 
745
      doo-=yscale>>1;
 
746
     do
 
747
     {
 
748
      for(x=xr;x;x--,src++)
 
749
      {
 
750
       int too=xscale;
 
751
       do
 
752
       {
 
753
        *(uint16 *)dest=palettetranslate[*src];
 
754
        dest+=2;
 
755
       } while(--too);
 
756
      }
 
757
     src-=xr;
 
758
     dest+=pinc;
 
759
     } while(--doo);
 
760
     src+=xr;
 
761
     if(highefx&FVB_SCANLINES)
 
762
      dest+=pitch*(yscale>>1);
 
763
    }  
 
764
    break;
 
765
   }
 
766
  }
 
767
  else
 
768
  switch(Bpp)
 
769
  {
 
770
    case 4:
 
771
    pinc=pitch-(xr<<2);
 
772
    for(y=yr;y;y--,src+=256-xr)
 
773
    {
 
774
     for(x=xr;x;x--)
 
775
     {
 
776
      *(uint32 *)dest=palettetranslate[(uint32)*src];
 
777
      dest+=4;
 
778
      src++;
 
779
     }
 
780
     dest+=pinc;
 
781
    }
 
782
    break;
 
783
   case 3:
 
784
    pinc=pitch-(xr+xr+xr);
 
785
    for(y=yr;y;y--,src+=256-xr)
 
786
    {
 
787
     for(x=xr;x;x--)
 
788
     {     
 
789
      uint32 tmp=palettetranslate[(uint32)*src];
 
790
      *(uint8 *)dest=tmp;
 
791
      *((uint8 *)dest+1)=tmp>>8;
 
792
      *((uint8 *)dest+2)=tmp>>16;
 
793
      dest+=3;
 
794
      src++;
 
795
     }
 
796
     dest+=pinc;
 
797
    }
 
798
    break;
 
799
  case 2:
 
800
   pinc=pitch-(xr<<1);
 
801
 
 
802
   for(y=yr;y;y--,src+=256-xr)
 
803
   {
 
804
    for(x=xr>>1;x;x--)
 
805
    {
 
806
     *(uint32 *)dest=palettetranslate[*(uint16 *)src];
 
807
     dest+=4;
 
808
     src+=2;
 
809
    }
 
810
    dest+=pinc;
 
811
   }
 
812
   break;
 
813
  }
 
814
 }
 
815
 
 
816
 if(specbuf)
 
817
 {
 
818
  if(specbuf32bpp)
 
819
  {
 
820
   int mult = (silt == 3)?3:2;
 
821
 
 
822
   if(silt == 3)
 
823
    hq3x_32((uint8 *)specbuf,(uint8*)specbuf32bpp,xr,yr,xr*3*sizeof(uint32));
 
824
   else
 
825
    hq2x_32((uint8 *)specbuf,(uint8*)specbuf32bpp,xr,yr,xr*2*sizeof(uint32));
 
826
 
 
827
   if(backBpp == 2)
 
828
    Blit32to16(specbuf32bpp, (uint16*)destbackup, xr*mult, yr*mult, pitchbackup, backshiftr,backshiftl);
 
829
   else // == 3
 
830
    Blit32to24(specbuf32bpp, (uint8*)destbackup, xr*mult, yr*mult, pitchbackup);
 
831
  }
 
832
  else
 
833
  {
 
834
   if(silt == 3)
 
835
    hq3x_32((uint8 *)specbuf,destbackup,xr,yr,pitchbackup);
 
836
   else
 
837
    hq2x_32((uint8 *)specbuf,destbackup,xr,yr,pitchbackup);
 
838
  }
 
839
 }
 
840
}