KernelLand/Kernel/drvutil_video.c

   1 /*
   2  * Acess2 Kernel
   3  * - By John Hodge
   4  *
   5  * drvutil.c
   6  * - Video Driver Helper Functions
   7  */
   8 #define DEBUG   0
   9 #include <acess.h>
  10 #include <api_drv_video.h>
  11
  12 // === TYPES ===
  13
  14 // === PROTOTYPES ===
  15 //int   DrvUtil_Video_2DStream(void *Ent, void *Buffer, int Length, tDrvUtil_Video_2DHandlers *Handlers, int SizeofHandlers);
  16 //size_t        DrvUtil_Video_WriteLFB(int Mode, tDrvUtil_Video_BufInfo *FBInfo, size_t Offset, size_t Length, void *Src);
  17 //void  DrvUtil_Video_SetCursor(tDrvUtil_Video_BufInfo *Buf, tVideo_IOCtl_Bitmap *Bitmap);
  18 //void  DrvUtil_Video_DrawCursor(tDrvUtil_Video_BufInfo *Buf, int X, int Y);
  19 void    DrvUtil_Video_RenderCursor(tDrvUtil_Video_BufInfo *Buf);
  20 //void  DrvUtil_Video_RemoveCursor(tDrvUtil_Video_BufInfo *Buf);
  21 void    DrvUtil_Video_2D_Fill(void *Ent, Uint16 X, Uint16 Y, Uint16 W, Uint16 H, Uint32 Colour);
  22 void    DrvUtil_Video_2D_Blit(void *Ent, Uint16 DstX, Uint16 DstY, Uint16 SrcX, Uint16 SrcY, Uint16 W, Uint16 H);
  23
  24 // === GLOBALS ===
  25 tDrvUtil_Video_2DHandlers       gDrvUtil_Stub_2DFunctions = {
  26         NULL,
  27         DrvUtil_Video_2D_Fill,
  28         DrvUtil_Video_2D_Blit
  29 };
  30 tVideo_IOCtl_Bitmap     gDrvUtil_TextModeCursor = {
  31         8, 16,
  32         0, 0,
  33         {
  34                 0, 0, 0         , 0, 0, 0, 0, 0,
  35                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  36                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  37                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  38                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  39                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  40                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  41                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  42                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  43                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  44                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  45                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  46                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  47                 0,-1, 0xFF000000, 0, 0, 0, 0, 0,
  48                 0, 0, 0         , 0, 0, 0, 0, 0,
  49                 0, 0, 0         , 0, 0, 0, 0, 0
  50         }
  51 };
  52
  53 // === CODE ===
  54 // --- Video Driver Helpers ---
  55 int DrvUtil_Video_2DStream(void *Ent, const void *Buffer, int Length,
  56         tDrvUtil_Video_2DHandlers *Handlers, int SizeofHandlers)
  57 {
  58         const Uint8     *stream = Buffer;
  59          int    rem = Length;
  60          int    op;
  61
  62         Uint16  tmp[6];
  63
  64         while( rem )
  65         {
  66                 rem --;
  67                 op = *stream;
  68                 stream ++;
  69
  70                 if(op > NUM_VIDEO_2DOPS) {
  71                         Log_Warning("DrvUtil",
  72                                 "DrvUtil_Video_2DStream: Unknown operation %i",
  73                                 op);
  74                         return Length-rem;
  75                 }
  76
  77                 if(op*sizeof(void*) > SizeofHandlers) {
  78                         Log_Warning("DrvUtil",
  79                                 "DrvUtil_Video_2DStream: Driver does not support op %i",
  80                                 op);
  81                         return Length-rem;
  82                 }
  83
  84                 switch(op)
  85                 {
  86                 case VIDEO_2DOP_NOP:    break;
  87
  88                 case VIDEO_2DOP_FILL:
  89                         if(rem < 12)    return Length-rem;
  90                         memcpy(tmp, stream, 6*2);
  91
  92                         if(!Handlers->Fill) {
  93                                 Log_Warning("DrvUtil", "DrvUtil_Video_2DStream: Driver"
  94                                         " does not support VIDEO_2DOP_FILL");
  95                                 return Length-rem;
  96                         }
  97
  98                         Handlers->Fill(
  99                                 Ent,
 100                                 tmp[0], tmp[1], tmp[2], tmp[3],
 101                                 tmp[4] | ((Uint32)tmp[5] << 16)
 102                                 );
 103
 104                         rem -= 12;
 105                         stream += 12;
 106                         break;
 107
 108                 case VIDEO_2DOP_BLIT:
 109                         if(rem < 12)    return Length-rem;
 110                         memcpy(tmp, stream, 6*2);
 111
 112                         if(!Handlers->Blit) {
 113                                 Log_Warning("DrvUtil", "DrvUtil_Video_2DStream: Driver"
 114                                         " does not support VIDEO_2DOP_BLIT");
 115                                 return Length-rem;
 116                         }
 117
 118                         Handlers->Blit(
 119                                 Ent,
 120                                 tmp[0], tmp[1], tmp[2], tmp[3],
 121                                 tmp[4], tmp[5]
 122                                 );
 123
 124                         rem -= 12;
 125                         stream += 12;
 126                         break;
 127
 128                 }
 129         }
 130         return 0;
 131 }
 132
 133 int DrvUtil_Video_WriteLFB(tDrvUtil_Video_BufInfo *FBInfo, size_t Offset, size_t Length, const void *Buffer)
 134 {
 135         Uint8   *dest;
 136         const Uint32    *src = Buffer;
 137          int    csr_x, csr_y;
 138          int    x, y;
 139          int    bytes_per_px = (FBInfo->Depth + 7) / 8;
 140         size_t  ofs;
 141         ENTER("pFBInfo xOffset xLength pBuffer",
 142                 FBInfo, Offset, Length, Buffer);
 143
 144         csr_x = FBInfo->CursorX;
 145         csr_y = FBInfo->CursorY;
 146
 147         if( FBInfo->BackBuffer )
 148                 dest = FBInfo->BackBuffer;
 149         else
 150                 dest = FBInfo->Framebuffer;
 151
 152         DrvUtil_Video_RemoveCursor(FBInfo);
 153
 154         switch( FBInfo->BufferFormat )
 155         {
 156         case VIDEO_BUFFMT_TEXT:
 157                 {
 158                 const tVT_Char  *chars = Buffer;
 159                  int    widthInChars = FBInfo->Width/giVT_CharWidth;
 160                  int    heightInChars = FBInfo->Height/giVT_CharHeight;
 161                  int    i;
 162
 163                 LOG("bytes_per_px = %i", bytes_per_px);
 164                 LOG("widthInChars = %i, heightInChars = %i", widthInChars, heightInChars);
 165
 166                 Length /= sizeof(tVT_Char);     Offset /= sizeof(tVT_Char);
 167
 168                 x = Offset % widthInChars;      y = Offset / widthInChars;
 169                 LOG("x = %i, y = %i", x, y);
 170
 171                 // Sanity Check
 172                 if(Offset > heightInChars * widthInChars)       LEAVE_RET('i', 0);
 173                 if(y >= heightInChars)  LEAVE_RET('i', 0);
 174
 175                 if( Offset + Length > heightInChars*widthInChars )
 176                 {
 177                         Length = heightInChars*widthInChars - Offset;
 178                 }
 179
 180                 LOG("dest = %p", dest);
 181                 ofs = y * giVT_CharHeight * FBInfo->Pitch;
 182                 dest += ofs;
 183
 184                 for( i = 0; i < Length; i++ )
 185                 {
 186                         if( y >= heightInChars )
 187                         {
 188                                 Log_Notice("DrvUtil", "Stopped at %i", i);
 189                                 break;
 190                         }
 191
 192                         VT_Font_Render(
 193                                 chars->Ch,
 194                                 dest + x*giVT_CharWidth*bytes_per_px, FBInfo->Depth, FBInfo->Pitch,
 195                                 VT_Colour12toN(chars->BGCol, FBInfo->Depth),
 196                                 VT_Colour12toN(chars->FGCol, FBInfo->Depth)
 197                                 );
 198
 199                         chars ++;
 200                         x ++;
 201                         if( x >= widthInChars )
 202                         {
 203                                 x = 0;
 204                                 y ++;
 205                                 dest += FBInfo->Pitch*giVT_CharHeight;
 206                                 LOG("dest = %p", dest);
 207                         }
 208                 }
 209                 if( x > 0 )
 210                         dest += FBInfo->Pitch*giVT_CharHeight;
 211                 Length = i * sizeof(tVT_Char);
 212
 213                 break; }
 214
 215         case VIDEO_BUFFMT_FRAMEBUFFER:
 216                 if(FBInfo->Width*FBInfo->Height*4 < Offset+Length)
 217                 {
 218                         Log_Warning("DrvUtil", "DrvUtil_Video_WriteLFB - Framebuffer Overflow");
 219                         return 0;
 220                 }
 221
 222                 switch(FBInfo->Depth)
 223                 {
 224                 case 15:
 225                 case 16:
 226                         Log_Warning("DrvUtil", "TODO: Support 15/16 bpp modes in LFB write");
 227                         dest = NULL;
 228                         break;
 229                 case 24:
 230                         x = Offset % FBInfo->Width;
 231                         y = Offset / FBInfo->Width;
 232                         ofs = y*FBInfo->Pitch;
 233                         dest += ofs;
 234                         for( ; Length >= 4; Length -= 4 )
 235                         {
 236                                 dest[x*3+0] = *src & 0xFF;
 237                                 dest[x*3+1] = (*src >> 8) & 0xFF;
 238                                 dest[x*3+2] = (*src >> 16) & 0xFF;
 239                                 x ++;
 240                                 if(x == FBInfo->Width) {
 241                                         dest += FBInfo->Pitch;
 242                                         x = 0;
 243                                 }
 244                         }
 245                         break;
 246                 case 32:
 247                         // Copy to Frambuffer
 248                         if( FBInfo->Pitch != FBInfo->Width*4 )
 249                         {
 250                                 Uint32  *px;
 251                                 // Pitch isn't 4*Width
 252                                 x = Offset % FBInfo->Width;
 253                                 y = Offset / FBInfo->Height;
 254
 255                                 ofs = y*FBInfo->Pitch;
 256                                 dest += ofs;
 257                                 px = (void*)dest;
 258
 259                                 for( ; Length >= 4; Length -= 4 )
 260                                 {
 261                                         px[x++] = *src ++;
 262                                         if( x == FBInfo->Width ) {
 263                                                 x = 0;
 264                                                 dest += FBInfo->Pitch;
 265                                                 px = (void*)dest;
 266                                         }
 267                                 }
 268                         }
 269                         else
 270                         {
 271                                 ofs = Offset;
 272                                 dest += ofs;
 273                                 memcpy(dest, Buffer, Length);
 274                         }
 275                         break;
 276                 default:
 277                         Log_Warning("DrvUtil", "DrvUtil_Video_WriteLFB - Unknown bit depth %i", FBInfo->Depth);
 278                         dest = NULL;
 279                         break;
 280                 }
 281                 break;
 282
 283         case VIDEO_BUFFMT_2DSTREAM:
 284                 Length = DrvUtil_Video_2DStream(
 285                         FBInfo, Buffer, Length,
 286                         &gDrvUtil_Stub_2DFunctions, sizeof(gDrvUtil_Stub_2DFunctions)
 287                         );
 288                 dest = NULL;
 289                 break;
 290
 291         default:
 292                 LEAVE('i', -1);
 293                 return -1;
 294         }
 295         if( FBInfo->BackBuffer && dest ) {
 296                 memcpy((char*)FBInfo->Framebuffer + ofs, (char*)FBInfo->BackBuffer + ofs,
 297                         ((tVAddr)dest - (tVAddr)FBInfo->BackBuffer) - ofs
 298                         );
 299         }
 300
 301         DrvUtil_Video_DrawCursor(FBInfo, csr_x, csr_y);
 302
 303         LEAVE('x', Length);
 304         return Length;
 305 }
 306
 307 int DrvUtil_Video_SetCursor(tDrvUtil_Video_BufInfo *Buf, tVideo_IOCtl_Bitmap *Bitmap)
 308 {
 309          int    csrX = Buf->CursorX, csrY = Buf->CursorY;
 310         size_t  size;
 311
 312         ENTER("pBuf pBitmap", Buf, Bitmap);
 313
 314         // Clear old bitmap
 315         if( Buf->CursorBitmap )
 316         {
 317                 LOG("Clearing old cursor");
 318                 DrvUtil_Video_RemoveCursor(Buf);
 319                 if( !Bitmap || Bitmap->W != Buf->CursorBitmap->W || Bitmap->H != Buf->CursorBitmap->H )
 320                 {
 321                         free( Buf->CursorSaveBuf );
 322                         Buf->CursorSaveBuf = NULL;
 323                 }
 324                 if( Buf->CursorBitmap != &gDrvUtil_TextModeCursor)
 325                         free(Buf->CursorBitmap);
 326                 Buf->CursorBitmap = NULL;
 327         }
 328
 329         // If the new bitmap is null, disable drawing
 330         if( !Bitmap )
 331         {
 332                 Buf->CursorX = -1;
 333                 Buf->CursorY = -1;
 334                 LEAVE('i', 0);
 335                 return 0;
 336         }
 337
 338         // Sanity check the bitmap
 339         LOG("Sanity checking plox");
 340         if( !CheckMem(Bitmap, sizeof(*Bitmap)) || !CheckMem(Bitmap->Data, Bitmap->W*Bitmap->H*sizeof(Uint32)) )
 341         {
 342                 Log_Warning("DrvUtil", "DrvUtil_Video_SetCursor: Bitmap (%p) is in invalid memory", Bitmap);
 343                 errno = -EINVAL;
 344                 LEAVE('i', -1);
 345                 return -1;
 346         }
 347
 348         // Don't take a copy of the DrvUtil provided cursor
 349         if( Bitmap == &gDrvUtil_TextModeCursor )
 350         {
 351                 LOG("No copy (provided cursor)");
 352                 Buf->CursorBitmap = Bitmap;
 353         }
 354         else
 355         {
 356                 LOG("Make copy");
 357                 size = sizeof(tVideo_IOCtl_Bitmap) + Bitmap->W*Bitmap->H*4;
 358
 359                 // Take a copy
 360                 Buf->CursorBitmap = malloc( size );
 361                 memcpy(Buf->CursorBitmap, Bitmap, size);
 362         }
 363
 364         // Restore cursor position
 365         LOG("Drawing");
 366         DrvUtil_Video_DrawCursor(Buf, csrX, csrY);
 367         LEAVE('i', 0);
 368         return 0;
 369 }
 370
 371 void DrvUtil_Video_DrawCursor(tDrvUtil_Video_BufInfo *Buf, int X, int Y)
 372 {
 373          int    render_ox=0, render_oy=0, render_w, render_h;
 374
 375         ENTER("pBuf iX iY", Buf, X, Y);
 376         DrvUtil_Video_RemoveCursor(Buf);
 377
 378         // X < 0 disables the cursor
 379         if( X < 0 ) {
 380                 Buf->CursorX = -1;
 381                 LEAVE('-');
 382                 return ;
 383         }
 384
 385         // Sanity checking
 386         if( X < 0 || Y < 0 || X >= Buf->Width || Y >= Buf->Height ) {
 387                 LEAVE('-');
 388                 return ;
 389         }
 390
 391         // Ensure the cursor is enabled
 392         if( !Buf->CursorBitmap ) {
 393                 LEAVE('-');
 394                 return ;
 395         }
 396
 397         // Save cursor position (for changing the bitmap)
 398         Buf->CursorX = X;       Buf->CursorY = Y;
 399         // Apply cursor's center offset
 400         X -= Buf->CursorBitmap->XOfs;
 401         Y -= Buf->CursorBitmap->YOfs;
 402
 403         // Get the width of the cursor on screen (clipping to right/bottom edges)
 404         render_w = X > Buf->Width  - Buf->CursorBitmap->W ? Buf->Width  - X : Buf->CursorBitmap->W;
 405         render_h = Y > Buf->Height - Buf->CursorBitmap->H ? Buf->Height - Y : Buf->CursorBitmap->H;
 406
 407         // Clipp to left/top edges
 408         if(X < 0) {     render_ox = -X; X = 0;  }
 409         if(Y < 0) {     render_oy = -Y; Y = 0;  }
 410
 411         // Save values
 412         Buf->CursorRenderW = render_w;  Buf->CursorRenderH = render_h;
 413         Buf->CursorDestX   = X;         Buf->CursorDestY = Y;
 414         Buf->CursorReadX   = render_ox; Buf->CursorReadY = render_oy;
 415
 416         LOG("%ix%i at %i,%i offset %i,%i",
 417                 render_w, render_h, X, Y, render_ox, render_oy);
 418
 419         // Call render routine
 420         DrvUtil_Video_RenderCursor(Buf);
 421         LEAVE('-');
 422 }
 423
 424 void DrvUtil_Video_RenderCursor(tDrvUtil_Video_BufInfo *Buf)
 425 {
 426          int    src_x = Buf->CursorReadX, src_y = Buf->CursorReadY;
 427          int    render_w = Buf->CursorRenderW, render_h = Buf->CursorRenderH;
 428          int    dest_x = Buf->CursorDestX, dest_y = Buf->CursorDestY;
 429          int    bytes_per_px = (Buf->Depth + 7) / 8;
 430          int    save_pitch = Buf->CursorBitmap->W * bytes_per_px;
 431         void    *dest;
 432         Uint32  *src;
 433          int    x, y;
 434
 435         dest = (Uint8*)Buf->Framebuffer + dest_y*Buf->Pitch + dest_x*bytes_per_px;
 436         src = Buf->CursorBitmap->Data + src_y * Buf->CursorBitmap->W + src_x;
 437
 438         LOG("dest = %p, src = %p", dest, src);
 439
 440         // Allocate save buffer if not already
 441         if( !Buf->CursorSaveBuf )
 442                 Buf->CursorSaveBuf = malloc( Buf->CursorBitmap->W*Buf->CursorBitmap->H*bytes_per_px );
 443
 444         LOG("Saving back");
 445         // Save behind the cursor
 446         for( y = 0; y < render_h; y ++ )
 447                 memcpy(
 448                         (Uint8*)Buf->CursorSaveBuf + y*save_pitch,
 449                         (Uint8*)dest + y*Buf->Pitch,
 450                         render_w*bytes_per_px
 451                         );
 452
 453         // Draw the cursor
 454         switch(Buf->Depth)
 455         {
 456         case 15:
 457         case 16:
 458                 Log_Warning("DrvUtil", "TODO: Support 15/16 bpp modes in cursor draw");
 459                 break;
 460         case 24:
 461                 LOG("24-bit render");
 462                 for( y = 0; y < render_h; y ++ )
 463                 {
 464                         Uint8   *px;
 465                         px = dest;
 466                         for(x = 0; x < render_w; x ++, px += 3)
 467                         {
 468                                 Uint32  value = src[x];
 469                                 // TODO: Should I implement alpha blending?
 470                                 if(value & 0xFF000000)
 471                                 {
 472                                         px[0] = value & 0xFF;
 473                                         px[1] = (value >> 8) & 0xFF;
 474                                         px[2] = (value >> 16) & 0xFF;
 475                                 }
 476                                 else
 477                                         ;
 478                         }
 479                         src += Buf->CursorBitmap->W;
 480                         dest = (Uint8*)dest + Buf->Pitch;
 481                 }
 482                 break;
 483         case 32:
 484                 LOG("32-bit render");
 485                 for( y = 0; y < render_h; y ++ )
 486                 {
 487                         Uint32  *px;
 488                         px = dest;
 489                         for(x = 0; x < render_w; x ++, px ++)
 490                         {
 491                                 Uint32  value = src[x];
 492                                 // TODO: Should I implement alpha blending?
 493                                 if(value & 0xFF000000)
 494                                         *px = value;
 495                                 else
 496                                         ;       // NOP, completely transparent
 497                         }
 498                         LOG("row %i/%i (%p-%P) done", y+1, render_h, dest, MM_GetPhysAddr(dest));
 499                         src += Buf->CursorBitmap->W;
 500                         dest = (Uint8*)dest + Buf->Pitch;
 501                 }
 502                 break;
 503         default:
 504                 Log_Error("DrvUtil", "RenderCursor - Unknown bit depth %i", Buf->Depth);
 505                 Buf->CursorX = -1;
 506                 break;
 507         }
 508 }
 509
 510 void DrvUtil_Video_RemoveCursor(tDrvUtil_Video_BufInfo *Buf)
 511 {
 512          int    bytes_per_px = (Buf->Depth + 7) / 8;
 513          int    y, save_pitch;
 514         Uint8   *dest, *src;
 515
 516         // Just a little sanity
 517         if( !Buf->CursorBitmap || Buf->CursorX == -1 )  return ;
 518         if( !Buf->CursorSaveBuf )       return ;
 519
 520 //      Debug("DrvUtil_Video_RemoveCursor: (Buf=%p) dest_x=%i, dest_y=%i", Buf, Buf->CursorDestX, Buf->CursorDestY);
 521
 522         // Set up
 523         save_pitch = Buf->CursorBitmap->W * bytes_per_px;
 524         dest = (Uint8*)Buf->Framebuffer + Buf->CursorDestY * Buf->Pitch + Buf->CursorDestX*bytes_per_px;
 525         src = Buf->CursorSaveBuf;
 526
 527         // Copy each line back
 528         for( y = 0; y < Buf->CursorRenderH; y ++ )
 529         {
 530                 memcpy( dest, src, Buf->CursorRenderW * bytes_per_px );
 531                 src += save_pitch;
 532                 dest += Buf->Pitch;
 533         }
 534
 535         // Set the cursor as removed
 536         Buf->CursorX = -1;
 537 }
 538
 539 void DrvUtil_Video_2D_Fill(void *Ent, Uint16 X, Uint16 Y, Uint16 W, Uint16 H, Uint32 Colour)
 540 {
 541         tDrvUtil_Video_BufInfo  *FBInfo = Ent;
 542
 543         switch( FBInfo->Depth )
 544         {
 545         case 32: {
 546                 // TODO: Be less hacky
 547                 size_t  pitch = FBInfo->Pitch/4;
 548                 size_t  ofs = Y*pitch + X;
 549                 Uint32  *buf = (Uint32*)FBInfo->Framebuffer + ofs;
 550                 Uint32  *cbuf = NULL;
 551                 if( FBInfo->BackBuffer )
 552                         cbuf = (Uint32*)FBInfo->BackBuffer + ofs;
 553                 while( H -- )
 554                 {
 555                         Uint32 *line;
 556                         line = buf;
 557                         for(int i = W; i--; line++)
 558                                 *line = Colour;
 559                         buf += pitch;
 560                         if( cbuf ) {
 561                                 line = cbuf;
 562                                 for(int i = W; i--; line++ )
 563                                         *line = Colour;
 564                                 cbuf += pitch;
 565                         }
 566                 }
 567                 break; }
 568         default:
 569                 // TODO: Handle non-32bit modes
 570                 Log_Warning("DrvUtil", "TODO: <32bpp _Fill");
 571                 break;
 572         }
 573 }
 574
 575 void DrvUtil_Video_2D_Blit(void *Ent, Uint16 DstX, Uint16 DstY, Uint16 SrcX, Uint16 SrcY, Uint16 W, Uint16 H)
 576 {
 577         tDrvUtil_Video_BufInfo  *FBInfo = Ent;
 578          int    scrnpitch = FBInfo->Pitch;
 579          int    bytes_per_px = (FBInfo->Depth + 7) / 8;
 580          int    dst = DstY*scrnpitch + DstX;
 581          int    src = SrcY*scrnpitch + SrcX;
 582          int    tmp;
 583         Uint8   *framebuffer = FBInfo->Framebuffer;
 584         Uint8   *backbuffer = FBInfo->BackBuffer;
 585         Uint8   *sourcebuffer = (FBInfo->BackBuffer ? FBInfo->BackBuffer : FBInfo->Framebuffer);
 586
 587         //Log("Vesa_2D_Blit: (Ent=%p, DstX=%i, DstY=%i, SrcX=%i, SrcY=%i, W=%i, H=%i)",
 588         //      Ent, DstX, DstY, SrcX, SrcY, W, H);
 589
 590         if(SrcX + W > FBInfo->Width)    W = FBInfo->Width - SrcX;
 591         if(DstX + W > FBInfo->Width)    W = FBInfo->Width - DstX;
 592         if(SrcY + H > FBInfo->Height)   H = FBInfo->Height - SrcY;
 593         if(DstY + H > FBInfo->Height)   H = FBInfo->Height - DstY;
 594
 595         //Debug("W = %i, H = %i", W, H);
 596
 597         if(W == FBInfo->Width && FBInfo->Pitch == FBInfo->Width*bytes_per_px)
 598         {
 599                 memmove(framebuffer + dst, sourcebuffer + src, H*FBInfo->Pitch);
 600                 if( backbuffer )
 601                         memmove(backbuffer + dst, sourcebuffer + src, H*FBInfo->Pitch);
 602         }
 603         else if( dst > src )
 604         {
 605                 // Reverse copy
 606                 dst += H*scrnpitch;
 607                 src += H*scrnpitch;
 608                 while( H -- )
 609                 {
 610                         dst -= scrnpitch;
 611                         src -= scrnpitch;
 612                         tmp = W*bytes_per_px;
 613                         for( tmp = W; tmp --; )
 614                         {
 615                                 size_t  src_o = src + tmp;
 616                                 size_t  dst_o = src + tmp;
 617                                 framebuffer[dst_o] = sourcebuffer[src_o];
 618                                 if( backbuffer )
 619                                         backbuffer[dst_o] = sourcebuffer[src_o];
 620                         }
 621                 }
 622         }
 623         else {
 624                 // Normal copy is OK
 625                 while( H -- )
 626                 {
 627                         memcpy(framebuffer + dst, sourcebuffer + src, W*bytes_per_px);
 628                         if( backbuffer )
 629                                 memcpy(backbuffer + dst, sourcebuffer + src, W*bytes_per_px);
 630                         dst += scrnpitch;
 631                         src += scrnpitch;
 632                 }
 633         }
 634         //Log("Vesa_2D_Blit: RETURN");
 635 }
 636
 637