src/video/symbian/dsa.cpp

   1 #include "dsa.h"
   2 #include "sdlepocapi.h"
   3 #include <cdsb.h>
   4 #include <basched.h>
   5
   6 LOCAL_C TInt BytesPerPixel(TDisplayMode aMode)
   7 {
   8         return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1;
   9 }
  10
  11 template<class T>
  12 NONSHARABLE_CLASS(CBitmapSurface) : public T
  13 {
  14         public:
  15                 CBitmapSurface(RWsSession& aSession);
  16
  17         private:
  18                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
  19                 ~CBitmapSurface();
  20                 TUint8* LockSurface();
  21                 void UnlockHwSurface();
  22                 void CreateSurfaceL();
  23                 void Wipe(TInt aLength);
  24                 void Free();
  25                 void Update(CFbsBitmap& aBmp);
  26                 TInt ExternalUpdate();
  27                 CFbsBitmap* iBmp;
  28                 CFbsBitmap* iCopyBmp;
  29 };
  30
  31         template<class T>
  32 void CBitmapSurface<T>::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
  33 {
  34         delete iCopyBmp;
  35         iCopyBmp = NULL;
  36         iCopyBmp = new (ELeave) CFbsBitmap();
  37         T::ConstructL(aWindow, aDevice);
  38 }
  39
  40         template<class T>
  41 CBitmapSurface<T>::CBitmapSurface(RWsSession& aSession) : T(aSession)
  42 {
  43 }
  44
  45         template<class T>
  46 void CBitmapSurface<T>::Free()
  47 {
  48         delete iBmp;
  49         iBmp = NULL;
  50         T::Free();
  51 }
  52
  53         template<class T>
  54 CBitmapSurface<T>::~CBitmapSurface()
  55 {
  56         __ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));
  57         delete iCopyBmp;
  58 }
  59
  60         template<class T>
  61 TUint8* CBitmapSurface<T>::LockSurface()
  62 {
  63         iBmp->LockHeap();
  64         return reinterpret_cast<TUint8*>(iBmp->DataAddress());
  65 }
  66
  67
  68         template<class T>
  69 void CBitmapSurface<T>::UnlockHwSurface()
  70 {
  71         iBmp->UnlockHeap();
  72         T::SetUpdating(EFalse);
  73         Update(*iBmp);
  74 }
  75
  76
  77         template<class T>
  78 void CBitmapSurface<T>::Update(CFbsBitmap& aBmp)
  79 {
  80         T::DoBlt(aBmp);
  81         T::DrawOverlays();
  82         T::CompleteUpdate();
  83 }
  84
  85         template<class T>
  86 void CBitmapSurface<T>::CreateSurfaceL()
  87 {
  88         Free();
  89         iBmp  = new (ELeave) CFbsBitmap();
  90         User::LeaveIfError(iBmp->Create(T::SwSize(), T::DisplayMode()));
  91         T::CreateSurfaceL(*iBmp);
  92 }
  93
  94         template<class T>
  95 void CBitmapSurface<T>::Wipe(TInt aLength) //dont call in drawing
  96 {
  97         iBmp->LockHeap();
  98         Mem::FillZ(iBmp->DataAddress(), aLength);
  99         iBmp->UnlockHeap();
 100 }
 101
 102         template<class T>
 103 TInt CBitmapSurface<T>::ExternalUpdate()
 104 {
 105         if(iCopyBmp->Handle() == 0)
 106         {
 107                 const TInt err = iCopyBmp->Duplicate(iBmp->Handle());
 108                 if(err != KErrNone)
 109                         return err;
 110         }
 111         Update(*iCopyBmp);
 112         return KErrNone;
 113 }
 114
 115
 116 //////////////////////////////////////////////////////////////////////
 117
 118 NONSHARABLE_CLASS(CDsaGles) : public CDsa
 119 {
 120         public:
 121                 CDsaGles(RWsSession& aSession);
 122         private:
 123                 TUint8* LockSurface();
 124                 void UnlockHWSurfaceRequestComplete();
 125                 void UnlockHwSurface();
 126                 void Resume();
 127                 void CreateSurfaceL();
 128                 void Wipe(TInt aLength);
 129                 TInt ExternalUpdate();
 130                 CBitmapContext* Gc();
 131 };
 132
 133 CDsaGles::CDsaGles(RWsSession& aSession) : CDsa(aSession)
 134 {
 135 }
 136
 137 TUint8* CDsaGles::LockSurface()
 138 {
 139         return NULL;
 140 }
 141
 142 void CDsaGles::UnlockHWSurfaceRequestComplete()
 143 {
 144 }
 145
 146 void CDsaGles::UnlockHwSurface()
 147 {
 148 }
 149
 150 void CDsaGles::Resume()
 151 {
 152 }
 153
 154 void CDsaGles::CreateSurfaceL()
 155 {
 156 }
 157
 158 void CDsaGles::Wipe(TInt aLength)
 159 {
 160 }
 161
 162 TInt CDsaGles::ExternalUpdate()
 163 {
 164         return KErrNotSupported;
 165 }
 166
 167 CBitmapContext* CDsaGles::Gc()
 168 {
 169         return NULL;
 170 }
 171
 172
 173 //////////////////////////////////////////////////////////////////////
 174
 175
 176 NONSHARABLE_CLASS(CDsaBitgdi) : public CDsa
 177 {
 178         public:
 179                 CDsaBitgdi(RWsSession& aSession);
 180         protected:
 181                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 182                 CBitmapContext* Gc();
 183                 void CompleteUpdate();
 184                 ~CDsaBitgdi();
 185                 void CreateSurfaceL(CFbsBitmap& aBmp);
 186                 void Free();
 187                 void UnlockHWSurfaceRequestComplete();
 188         private:
 189                 void Resume();
 190
 191                 CFbsBitGc* iGc;
 192                 CFbsDevice* iDevice;
 193                 CFbsBitmap* iBitGdiBmp;
 194                 CWindowGc* iWinGc;
 195                 RWindow* iWindow;
 196                 TInt iHandle;
 197 };
 198
 199
 200 CDsaBitgdi::CDsaBitgdi(RWsSession& aSession) : CDsa(aSession)
 201 {
 202 }
 203
 204 CDsaBitgdi::~CDsaBitgdi()
 205 {
 206         delete iWinGc;
 207         delete iBitGdiBmp;
 208 }
 209
 210 void CDsaBitgdi::CompleteUpdate()
 211 {
 212         EpocSdlEnv::Request(CDsa::ERequestUpdate);
 213 }
 214
 215
 216 void CDsaBitgdi::UnlockHWSurfaceRequestComplete()
 217 {
 218         if(iHandle == 0)
 219                 return;
 220
 221         if(iBitGdiBmp == NULL)
 222         {
 223                 iBitGdiBmp = new CFbsBitmap();
 224                 if(iBitGdiBmp == NULL)
 225                         return;
 226                 iBitGdiBmp->Duplicate(iHandle);
 227         }
 228
 229         iWindow->Invalidate();
 230
 231         iWindow->BeginRedraw();
 232         iWinGc->Activate(*iWindow);
 233
 234         if(!Blitter(*iBitGdiBmp))
 235         {
 236                 if(SwSize() == HwRect().Size())
 237                         iWinGc->BitBlt(HwRect().iTl, iBitGdiBmp);
 238                 else
 239                         iWinGc->DrawBitmap(HwRect(), iBitGdiBmp);
 240         }
 241
 242         iWinGc->Deactivate();
 243         iWindow->EndRedraw();
 244 }
 245
 246 void CDsaBitgdi::Resume()
 247 {
 248         Start();
 249 }
 250
 251 CBitmapContext* CDsaBitgdi::Gc()
 252 {
 253         return iWinGc;
 254 }
 255
 256 void CDsaBitgdi::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 257 {
 258
 259         delete iBitGdiBmp;
 260         iBitGdiBmp = NULL;
 261         delete iWinGc;
 262         iWinGc = NULL;
 263         iHandle = 0;
 264
 265         iWindow = &aWindow;
 266         User::LeaveIfError(aDevice.CreateContext(iWinGc));
 267         CDsa::ConstructL(aWindow, aDevice);
 268         Start();
 269 }
 270
 271 void CDsaBitgdi::CreateSurfaceL(CFbsBitmap& aBmp)
 272 {
 273         iDevice = CFbsBitmapDevice::NewL(&aBmp);
 274         User::LeaveIfError(iDevice->CreateContext(iGc));
 275         iHandle = aBmp.Handle();
 276 }
 277
 278 void CDsaBitgdi::Free()
 279 {
 280         delete iGc;
 281         iGc = NULL;
 282         delete iDevice;
 283         iDevice = NULL;
 284 }
 285
 286 ///////////////////////////////////////////////////////////////////////
 287
 288 NONSHARABLE_CLASS(CDsaBase) : public CDsa, public MDirectScreenAccess
 289 {
 290         protected:
 291                 inline CDirectScreenAccess& Dsa() const;
 292                 CDsaBase(RWsSession& aSession);
 293                 ~CDsaBase();
 294                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 295                 void Stop();
 296                 void Resume();
 297                 CBitmapContext* Gc();
 298         protected:
 299                 CDirectScreenAccess*  iDsa;
 300         private:
 301                 void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);
 302                 void Restart(RDirectScreenAccess::TTerminationReasons aReason);
 303         private:
 304                 void RestartL();
 305 };
 306
 307
 308 inline CDirectScreenAccess& CDsaBase::Dsa() const
 309 {
 310         return *iDsa;
 311 }
 312
 313
 314 CDsaBase::CDsaBase(RWsSession& aSession) : CDsa(aSession)
 315 {
 316 }
 317
 318 CBitmapContext* CDsaBase::Gc()
 319 {
 320         return Dsa().Gc();
 321 }
 322
 323 void CDsaBase::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 324 {
 325         CDsa::ConstructL(aWindow, aDevice);
 326         if(iDsa != NULL)
 327         {
 328                 iDsa->Cancel();
 329                 delete iDsa;
 330                 iDsa = NULL;
 331         }
 332
 333         iDsa = CDirectScreenAccess::NewL(
 334                         Session(),
 335                         aDevice,
 336                         aWindow,
 337                         *this);
 338         RestartL();
 339 }
 340
 341 void CDsaBase::Resume()
 342 {
 343         if(Stopped())
 344                 Restart(RDirectScreenAccess::ETerminateRegion);
 345 }
 346
 347 CDsaBase::~CDsaBase()
 348 {
 349         if(iDsa != NULL)
 350         {
 351                 iDsa->Cancel();
 352         }
 353         delete iDsa;
 354 }
 355
 356
 357 void CDsaBase::RestartL()
 358 {
 359
 360
 361         iDsa->StartL();
 362
 363         const RRegion* r = iDsa->DrawingRegion();
 364         const TRect rect = r->BoundingRect();
 365         iDsa->Gc()->SetClippingRegion(r);
 366
 367         if(rect != ScreenRect())
 368         {
 369                 return ;
 370         }
 371
 372
 373         SetTargetRect();
 374         RecreateL();
 375
 376         Start();
 377
 378
 379 }
 380
 381 void CDsaBase::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 382 {
 383         Stop();
 384 }
 385
 386 void CDsaBase::Restart(RDirectScreenAccess::TTerminationReasons aReason)
 387 {
 388         if(aReason == RDirectScreenAccess::ETerminateRegion) //auto restart
 389         {
 390                 TRAPD(err, RestartL());
 391                 if(err == KLeaveExit)
 392                 {
 393                         Stop();
 394                 }
 395                 else
 396                 {
 397                         PANIC_IF_ERROR(err);
 398                 }
 399         }
 400 }
 401
 402
 403 void CDsaBase::Stop()
 404 {
 405         CDsa::Stop();
 406         iDsa->Cancel();
 407 }
 408
 409 ///////////////////////////////////////////////////////////////////////
 410 NONSHARABLE_CLASS(TDsa)
 411 {
 412         public:
 413                 inline TDsa(const CDsa& aDsa);
 414                 inline TBool IsFlip() const;
 415                 inline TBool IsTurn() const;
 416                 inline const TSize& SwSize() const;
 417                 inline void Copy(TUint32* aTarget, const TUint8* aSrc, TInt aBytes, TInt aHeight) const;
 418         private:
 419                 const CDsa& iDsa;
 420 };
 421
 422 inline TDsa::TDsa(const CDsa& aDsa) : iDsa(aDsa)
 423 {
 424 }
 425
 426 inline TBool TDsa::IsTurn() const
 427 {
 428         return iDsa.iStateFlags & CDsa::EOrientation90;
 429 }
 430
 431 inline TBool TDsa::IsFlip() const
 432 {
 433         return iDsa.iStateFlags & CDsa::EOrientation180;
 434 }
 435
 436 inline const TSize& TDsa::SwSize() const
 437 {
 438         return iDsa.SwSize();
 439 }
 440
 441 inline void TDsa::Copy(TUint32* aTarget, const TUint8* aSrc, TInt aBytes, TInt aHeight) const
 442 {
 443         iDsa.iCopyFunction(iDsa, aTarget, aSrc, aBytes, aHeight);
 444 }
 445
 446         template<class T, class S>
 447 void ClipCopy(const TDsa& iDsa, TUint8* aTarget,
 448                 const TUint8* aSource,
 449                 const TRect& aUpdateRect,
 450                 const TRect& aSourceRect)
 451 {
 452         const S* source = reinterpret_cast<const S*>(aSource);
 453         const TInt lineWidth = aSourceRect.Width();
 454
 455         source += (aUpdateRect.iTl.iY * lineWidth);
 456         const TInt sourceStartOffset = aUpdateRect.iTl.iX;
 457         source += sourceStartOffset;
 458
 459         T* targetPtr = reinterpret_cast<T*>(aTarget);
 460
 461         const TInt scanLineWidth = iDsa.SwSize().iWidth;
 462
 463         targetPtr += (aSourceRect.iTl.iY + aUpdateRect.iTl.iY ) * scanLineWidth;
 464         const TInt targetStartOffset = (aUpdateRect.iTl.iX + aSourceRect.iTl.iX);
 465
 466         targetPtr += targetStartOffset;
 467
 468
 469         const TInt height = aUpdateRect.Height();
 470
 471         const TInt lineMove = iDsa.IsTurn() ? 1 : lineWidth;
 472         const TInt copyLen = aUpdateRect.Width();
 473
 474
 475         if(iDsa.IsFlip())
 476         {
 477
 478                 targetPtr += scanLineWidth *  (height - 1);
 479
 480                 for(TInt i = 0; i < height; i++) //source is always smaller
 481                 {
 482                         iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);
 483                         source += lineMove;
 484                         targetPtr -= scanLineWidth;
 485                 }
 486         }
 487         else
 488         {
 489
 490
 491                 for(TInt i = 0; i < height; i++) //source is always smaller
 492                 {
 493                         iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);
 494                         source += lineMove;
 495                         targetPtr += scanLineWidth; // >> 2;
 496                 }
 497         }
 498
 499 }
 500
 501
 502
 503 NONSHARABLE_CLASS(CDsaA) : public CDsaBase
 504 {
 505         public:
 506                 CDsaA(RWsSession& aSession);
 507         protected:
 508                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 509                 void CompleteUpdate();
 510                 void CreateSurfaceL(CFbsBitmap& aBmp);
 511                 void Free();
 512                 void UnlockHWSurfaceRequestComplete();
 513                 void DoBlt(CFbsBitmap& aBmp);
 514 };
 515
 516
 517 CDsaA::CDsaA(RWsSession& aSession) : CDsaBase(aSession)
 518 {
 519 }
 520
 521
 522 void CDsaA::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 523 {
 524         CDsaBase::ConstructL(aWindow, aDevice);
 525 }
 526
 527 void CDsaA::CompleteUpdate()
 528 {
 529         iDsa->ScreenDevice()->Update();
 530 }
 531
 532 void CDsaA::CreateSurfaceL(CFbsBitmap& /*aBmp*/)
 533 {
 534 }
 535
 536 void CDsaA::Free()
 537 {
 538 }
 539
 540 void CDsaA::DoBlt(CFbsBitmap& aBmp)
 541 {
 542         if(!Blitter(aBmp))
 543         {
 544                 if(SwSize() == HwRect().Size())
 545                         Gc()->BitBlt(HwRect().iTl, &aBmp);
 546                 else
 547                         Gc()->DrawBitmap(HwRect(), &aBmp);
 548         }
 549 }
 550
 551 void CDsaA::UnlockHWSurfaceRequestComplete()
 552 {
 553         PANIC(KErrNotSupported);
 554 }
 555
 556
 557
 558 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 559
 560 NONSHARABLE_CLASS(MDsbObs)
 561 {
 562         public:
 563                 virtual void SurfaceReady() = 0;
 564                 virtual CDirectScreenBitmap& Dsb() = 0;
 565 };
 566
 567 NONSHARABLE_CLASS(CDsbSurface) : public CActive
 568 {
 569         public:
 570                 CDsbSurface(MDsbObs& aDsb);
 571                 virtual TUint8* Address() = 0;
 572                 virtual void Complete() = 0;
 573                 virtual void Unlock() = 0;
 574                 ~CDsbSurface();
 575         protected:
 576                 void RunL();
 577                 void DoCancel();
 578         protected:
 579                 MDsbObs& iDsb;
 580                 TUint8* iAddress;
 581 };
 582
 583 CDsbSurface::CDsbSurface(MDsbObs& aDsb) : CActive(CActive::EPriorityHigh) , iDsb(aDsb)
 584 {
 585         CActiveScheduler::Add(this);
 586 }
 587
 588 CDsbSurface::~CDsbSurface()
 589 {
 590         Cancel();
 591 }
 592
 593 void CDsbSurface::RunL()
 594 {
 595         iDsb.SurfaceReady();
 596 }
 597
 598 void CDsbSurface::DoCancel()
 599 {
 600         //empty
 601 }
 602
 603 NONSHARABLE_CLASS(CDsbSyncSurface) : public CDsbSurface
 604 {
 605         public:
 606                 TUint8* Address();
 607                 CDsbSyncSurface(MDsbObs& aDsb);
 608                 void Unlock();
 609                 void Complete();
 610                 ~CDsbSyncSurface();
 611                 RSemaphore iSema;
 612         private:
 613                 void RunL();
 614 };
 615
 616 CDsbSyncSurface::CDsbSyncSurface(MDsbObs& aDsb) : CDsbSurface(aDsb)
 617 {
 618         iSema.CreateLocal(1);
 619 }
 620
 621 TUint8* CDsbSyncSurface::Address()
 622 {
 623         if(IsActive())
 624                 iSema.Wait();
 625         TAcceleratedBitmapInfo info;
 626         if(KErrNone == iDsb.Dsb().BeginUpdate(info))
 627                 iAddress = info.iAddress;
 628         return iAddress;
 629 }
 630
 631 void CDsbSyncSurface::Unlock()
 632 {
 633         EpocSdlEnv::Request(CDsa::ERequestUpdate);
 634 }
 635
 636 void CDsbSyncSurface::RunL()
 637 {
 638         CDsbSurface::RunL();
 639         iSema.Signal();
 640 }
 641
 642 CDsbSyncSurface::~CDsbSyncSurface()
 643 {
 644         iSema.Signal();
 645         iSema.Close();
 646 }
 647
 648 void CDsbSyncSurface::Complete()
 649 {
 650         if(iAddress != NULL && !IsActive())
 651         {
 652                 iAddress = NULL;
 653                 SetActive();
 654                 iDsb.Dsb().EndUpdate(iStatus);
 655         }
 656         else
 657                 iSema.Signal();
 658 }
 659
 660 NONSHARABLE_CLASS(CDsbAsyncSurface) : public CDsbSurface
 661 {
 662         public:
 663                 TUint8* Address();
 664                 CDsbAsyncSurface(MDsbObs& aDsb);
 665                 void Complete();
 666                 void Unlock();
 667                 ~CDsbAsyncSurface();
 668 };
 669
 670 TUint8* CDsbAsyncSurface::Address()
 671 {
 672         if(iAddress == NULL && !IsActive())
 673         {
 674                 TAcceleratedBitmapInfo info;
 675                 if(KErrNone == iDsb.Dsb().BeginUpdate(info))
 676                         iAddress = info.iAddress;
 677         }
 678         return iAddress;
 679 }
 680
 681 CDsbAsyncSurface::CDsbAsyncSurface(MDsbObs& aDsb) : CDsbSurface(aDsb)
 682 {
 683 }
 684
 685 CDsbAsyncSurface::~CDsbAsyncSurface()
 686 {
 687 }
 688
 689 void CDsbAsyncSurface::Unlock()
 690 {
 691         EpocSdlEnv::Request(CDsa::ERequestUpdate);
 692 }
 693
 694 void CDsbAsyncSurface::Complete()
 695 {
 696         if(iAddress != NULL && !IsActive())
 697         {
 698                 iAddress = NULL;
 699                 SetActive();
 700                 iDsb.Dsb().EndUpdate(iStatus);
 701         }
 702 }
 703
 704 NONSHARABLE_CLASS(CDsaB) : public CDsaBase,
 705         public MDsbObs
 706 {
 707         public:
 708                 enum {EDrawModeDSBAsync = 0x1000};
 709                 CDsaB(RWsSession& aSession, TInt aFlags);
 710         private:
 711                 ~CDsaB();
 712                 TUint8* LockSurface();
 713                 void UnlockHWSurfaceRequestComplete();
 714                 void UnlockHwSurface();
 715                 void CreateSurfaceL();
 716                 void Wipe(TInt aLength);
 717                 void RecreateL();
 718                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 719                 CDirectScreenBitmap& Dsb();
 720                 void SurfaceReady();
 721                 TInt ExternalUpdate();
 722         private:
 723                 CDsbSurface* iSurface1;
 724                 CDirectScreenBitmap* iDsb;
 725                 TInt iType;
 726 };
 727
 728 CDsaB::CDsaB(RWsSession& aSession, TInt aFlags) : CDsaBase(aSession), iType(aFlags)
 729 {
 730 }
 731
 732
 733
 734 void CDsaB::UnlockHWSurfaceRequestComplete()
 735 {
 736         iSurface1->Complete();
 737 }
 738
 739 void CDsaB::CreateSurfaceL()
 740 {
 741         __ASSERT_ALWAYS(SwSize() == HwRect().Size(), PANIC(KErrNotSupported));
 742 }
 743
 744 void CDsaB::Wipe(TInt aLength) //dont call in drawing
 745 {
 746         TUint8* addr = LockSurface();
 747         if(addr != NULL)
 748         {
 749                 Mem::FillZ(addr, aLength);
 750                 UnlockHwSurface();
 751         }
 752 }
 753
 754
 755 void CDsaB::UnlockHwSurface()
 756 {
 757         iSurface1->Unlock();
 758 }
 759
 760 TUint8* CDsaB::LockSurface()
 761 {
 762         TUint8* addr =  iSurface1->Address();
 763         SetUpdating(addr == NULL);
 764         return addr;
 765 }
 766
 767 void CDsaB::SurfaceReady()
 768 {
 769         SetUpdating(EFalse);
 770 }
 771
 772 CDirectScreenBitmap& CDsaB::Dsb()
 773 {
 774         return *iDsb;
 775 }
 776
 777 void CDsaB::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 778 {
 779         if(iDsb == NULL)
 780                 iDsb = CDirectScreenBitmap::NewL();
 781         CDsaBase::ConstructL(aWindow, aDevice);
 782         if(iSurface1 == NULL)
 783         {
 784                 if(     (iType & CDsaB::EDrawModeDSBAsync))
 785                         iSurface1 = new (ELeave) CDsbAsyncSurface(*this);
 786                 else
 787                         iSurface1 = new (ELeave) CDsbSyncSurface(*this);
 788         }
 789 }
 790
 791 CDsaB::~CDsaB()
 792 {
 793         delete iSurface1;
 794         delete iDsb;
 795 }
 796
 797 void CDsaB::RecreateL()
 798 {
 799         iDsb->Close();
 800         CDirectScreenBitmap::TSettingsFlags flags = CDirectScreenBitmap::TSettingsFlags(iType & 0xFF);
 801         iDsb->Create(HwRect(), flags);
 802 }
 803
 804 TInt CDsaB::ExternalUpdate()
 805 {
 806         if(LockSurface())
 807         {
 808                 UnlockHWSurfaceRequestComplete();
 809                 return KErrNone;
 810         }
 811         return KErrNotReady;
 812 }
 813
 814 /////////////////////////////////////////////////////////////////////////////////////////////////////
 815
 816 CDsa* CDsa::CreateL(RWsSession& aSession)
 817 {
 818         if(EpocSdlEnv::Flags(CSDL::EDrawModeDSB))
 819         {
 820                 TInt flags = CDirectScreenBitmap::ENone;
 821                 if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBDoubleBuffer))
 822                         flags |= CDirectScreenBitmap::EDoubleBuffer;
 823                 if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBIncrementalUpdate))
 824                         flags |= CDirectScreenBitmap::EIncrementalUpdate;
 825                 if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBAsync))
 826                         flags |= CDsaB::EDrawModeDSBAsync;
 827                 return new (ELeave) CDsaB(aSession, flags);
 828         }
 829         else if(EpocSdlEnv::Flags(CSDL::EDrawModeGdi))
 830         {
 831                 return new (ELeave) CBitmapSurface<CDsaBitgdi>(aSession);
 832         }
 833         else
 834         {
 835                 return new (ELeave) CBitmapSurface<CDsaA>(aSession);
 836         }
 837 }
 838
 839
 840 void CDsa::RecreateL()
 841 {
 842 }
 843
 844 void CDsa::Free()
 845 {
 846 }
 847
 848 TSize CDsa::WindowSize() const
 849 {
 850         TSize size = iSwSize;
 851         if(iStateFlags & EOrientation90)
 852         {
 853                 const TInt tmp = size.iWidth;
 854                 size.iWidth = size.iHeight;
 855                 size.iHeight = tmp;
 856         }
 857         return size;
 858 }
 859
 860 void CDsa::SetSuspend()
 861 {
 862         iStateFlags |= ESdlThreadSuspend;
 863 }
 864
 865
 866 void CDsa::SetUpdating(TBool aUpdate)
 867 {
 868         if(aUpdate)
 869                 iStateFlags |= EUpdating;
 870         else
 871                 iStateFlags &= ~EUpdating;
 872 }
 873
 874
 875 TBool CDsa::Stopped() const
 876 {
 877         return (iStateFlags & ESdlThreadExplicitStop);
 878 }
 879
 880 void CDsa::SetOrientation(CDsa::TOrientationMode aOrientation)
 881 {
 882         TInt flags = 0;
 883         switch(aOrientation)
 884         {
 885                 case CDsa::EViewOrientation90:
 886                         flags = EOrientation90;
 887                         break;
 888                 case CDsa::EViewOrientation180:
 889                         flags = EOrientation180;
 890                         break;
 891                 case CDsa::EViewOrientation270:
 892                         flags = EOrientation90 | EOrientation180;
 893                         break;
 894                 case CDsa::EViewOrientation0:
 895                         flags = 0;
 896                         break;
 897         }
 898         if(flags != (iStateFlags & EOrientationFlags))
 899         {
 900                 iStateFlags |= EOrientationChanged;
 901                 iNewFlags = flags; //cannot be set during drawing...
 902         }
 903 }
 904
 905 CDsa::~CDsa()
 906 {
 907         iOverlays.Close();
 908         User::Free(iLut256);
 909 }
 910
 911 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& /*aDevice*/)
 912 {
 913         if(iLut256 == NULL)
 914                 iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32));
 915         iTargetMode = aWindow.DisplayMode();
 916         iTargetBpp = BytesPerPixel(DisplayMode());
 917         iScreenRect = TRect(aWindow.Position(), aWindow.Size());
 918         SetTargetRect();
 919         iWindow = &aWindow;
 920 }
 921
 922
 923 void CDsa::DrawOverlays()
 924 {
 925         const TInt last = iOverlays.Count() - 1;
 926         for(TInt i = last; i >= 0 ; i--)
 927                 iOverlays[i].iOverlay->Draw(*Gc(), HwRect(), SwSize());
 928 }
 929
 930 void CDsa::DoBlt(CFbsBitmap& /*aBmp*/)
 931 {
 932 }
 933
 934 TInt CDsa::AppendOverlay(MOverlay& aOverlay, TInt aPriority)
 935 {
 936         TInt i;
 937         for(i = 0; i < iOverlays.Count() && iOverlays[i].iPriority < aPriority; i++)
 938         {}
 939         const TOverlay overlay = {&aOverlay, aPriority};
 940         return iOverlays.Insert(overlay, i);
 941 }
 942
 943 TInt CDsa::RemoveOverlay(MOverlay& aOverlay)
 944 {
 945         for(TInt i = 0; i < iOverlays.Count(); i++)
 946         {
 947                 if(iOverlays[i].iOverlay == &aOverlay)
 948                 {
 949                         iOverlays.Remove(i);
 950                         return KErrNone;
 951                 }
 952         }
 953         return KErrNotFound;
 954 }
 955
 956 void CDsa::LockPalette(TBool aLock)
 957 {
 958         if(aLock)
 959                 iStateFlags |= EPaletteLocked;
 960         else
 961                 iStateFlags &= ~EPaletteLocked;
 962 }
 963 TInt CDsa::SetPalette(TInt aFirst, TInt aCount, TUint32* aPalette)
 964 {
 965         if(iLut256 == NULL)
 966                 return KErrNotFound;
 967         const TInt count = aCount - aFirst;
 968         if(count > 256)
 969                 return KErrArgument;
 970         if(iStateFlags & EPaletteLocked)
 971                 return KErrNone;
 972         for(TInt i = aFirst; i < count; i++) //not so busy here:-)
 973         {
 974                 iLut256[i] = aPalette[i];
 975         }
 976         return KErrNone;
 977 }
 978
 979 CDsa::CDsa(RWsSession& aSession) :
 980         iStateFlags(0),
 981         iSession(aSession)
 982
 983 {
 984         iCFTable[0] = CopyMem;
 985         iCFTable[1] = CopyMemFlipReversed;
 986         iCFTable[2] = CopyMemReversed;
 987         iCFTable[3] = CopyMemFlip;
 988
 989         iCFTable[4] = Copy256;
 990         iCFTable[5] = Copy256FlipReversed;
 991         iCFTable[6] = Copy256Reversed;
 992         iCFTable[7] = Copy256Flip;
 993
 994
 995         iCFTable[8] = CopySlow;
 996         iCFTable[9] = CopySlowFlipReversed;
 997         iCFTable[10] = CopySlowReversed;
 998         iCFTable[11] = CopySlowFlip;
 999 }
1000
1001 RWsSession& CDsa::Session()
1002 {
1003         return iSession;
1004 }
1005
1006 TInt CDsa::RedrawRequest()
1007 {
1008         if(!(iStateFlags & (EUpdating) && (iStateFlags & ERunning)))
1009         {
1010                 return ExternalUpdate();
1011         }
1012         return KErrNotReady;
1013 }
1014
1015 TUint8* CDsa::LockHwSurface()
1016 {
1017         if((iStateFlags & EUpdating) == 0) //else frame is skipped
1018         {
1019                 return LockSurface();
1020         }
1021         return NULL;
1022 }
1023
1024 TInt CDsa::AllocSurface(TBool aHwSurface, const TSize& aSize, TDisplayMode aMode)
1025 {
1026         if(aHwSurface && aMode != DisplayMode())
1027                 return KErrArgument;
1028
1029         iSourceMode = aMode;
1030
1031         iSourceBpp = BytesPerPixel(aMode);
1032
1033         const TSize size = WindowSize();
1034         if(aSize.iWidth > size.iWidth)
1035                 return KErrTooBig;
1036         if(aSize.iHeight > size.iHeight)
1037                 return KErrTooBig;
1038
1039         TRAPD(err, CreateSurfaceL());
1040         if(err != KErrNone)
1041                 return err;
1042
1043         SetCopyFunction();
1044
1045         return KErrNone;
1046 }
1047
1048
1049 void CDsa::CreateZoomerL(const TSize& aSize)
1050 {
1051         iSwSize = aSize;
1052         iStateFlags |= EResizeRequest;
1053         CreateSurfaceL();
1054         SetTargetRect();
1055 }
1056
1057 void CDsa::ClipCopy(TUint8* aTarget,
1058                 const TUint8* aSource,
1059                 const TRect& aUpdateRect,
1060                 const TRect& aSourceRect) const
1061 {
1062         const TDsa dsa(*this);
1063         switch(iSourceBpp)
1064         {
1065                 case 1:
1066                         ::ClipCopy<TUint32, TUint8>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
1067                         break;
1068                 case 2:
1069                         ::ClipCopy<TUint32, TUint16>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
1070                         break;
1071                 case 4:
1072                         ::ClipCopy<TUint32, TUint32>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
1073                         break;
1074         }
1075 }
1076
1077
1078 void CDsa::Wipe() //dont call in drawing
1079 {
1080         if(IsDsaAvailable())
1081                 Wipe(iTargetBpp * SwSize().iWidth * SwSize().iHeight);
1082 }
1083
1084 void CDsa::SetCopyFunction()
1085 {
1086         //calculate offset to correct function in iCFTable according to given parameters
1087         TInt function = 0;
1088         const TInt KCopyFunctions = 4;
1089         const TInt KOffsetToNative = 0;
1090         const TInt KOffsetTo256 = KOffsetToNative + KCopyFunctions;
1091         const TInt KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions;
1092         const TInt KOffsetTo90Functions = 1;
1093         const TInt KOffsetTo180Functions = 2;
1094
1095         if(iSourceMode == DisplayMode())
1096                 function = KOffsetToNative;             //0
1097         else if(iSourceMode == EColor256)
1098                 function = KOffsetTo256;                        //4
1099         else
1100                 function = KOffsetToOtherModes;         //8
1101
1102         if(iStateFlags & EOrientation90)
1103                 function += KOffsetTo90Functions;       // + 1
1104         if(iStateFlags & EOrientation180)
1105                 function += KOffsetTo180Functions;      //+ 2
1106
1107         iCopyFunction = iCFTable[function];
1108
1109         Wipe();
1110 }
1111
1112 inline void Rotate(TRect& aRect)
1113 {
1114         const TInt dx = aRect.iBr.iX - aRect.iTl.iX;
1115         const TInt dy = aRect.iBr.iY - aRect.iTl.iY;
1116
1117         aRect.iBr.iX = aRect.iTl.iX + dy;
1118         aRect.iBr.iY = aRect.iTl.iY + dx;
1119
1120         const TInt tmp = aRect.iTl.iX;
1121         aRect.iTl.iX = aRect.iTl.iY;
1122         aRect.iTl.iY = tmp;
1123 }
1124
1125 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)
1126 {
1127
1128         if(iStateFlags & EOrientationChanged)
1129         {
1130                 iStateFlags &= ~EOrientationFlags;
1131                 iStateFlags |= iNewFlags;
1132                 SetCopyFunction();
1133                 iStateFlags &= ~EOrientationChanged;
1134                 EpocSdlEnv::WaitDeviceChange();
1135                 return EFalse; //skip this frame as data is may be changed
1136         }
1137
1138         if(iTargetAddr == NULL)
1139         {
1140                 iTargetAddr = LockHwSurface();
1141         }
1142
1143         TUint8* target = iTargetAddr;
1144         if(target == NULL)
1145                 return EFalse;
1146
1147
1148         TRect targetRect = TRect(TPoint(0, 0), SwSize());
1149
1150         TRect sourceRect = aRect;
1151         TRect updateRect = aUpdateRect;
1152
1153         if(iStateFlags & EOrientation90)
1154         {
1155                 Rotate(sourceRect);
1156                 Rotate(updateRect);
1157         }
1158
1159         if(iSourceMode != DisplayMode() ||  targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0))
1160         {
1161                 sourceRect.Intersection(targetRect); //so source always smaller or equal than target
1162                 ClipCopy(target, aBits, updateRect, sourceRect);
1163         }
1164         else
1165         {
1166                 const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored
1167                 Mem::Copy(target, aBits, byteCount);
1168         }
1169
1170         return ETrue;
1171 }
1172
1173
1174 void CDsa::UpdateSwSurface()
1175 {
1176         iTargetAddr = NULL;
1177         UnlockHwSurface();      //could be faster if does not use AO, but only check status before redraw, then no context switch needed
1178 }
1179
1180 void CDsa::DoStop()
1181 {
1182         if(IsDsaAvailable())
1183                 iStateFlags |= ESdlThreadExplicitStop;
1184         Stop();
1185 }
1186
1187
1188 void CDsa::Stop()
1189 {
1190         iStateFlags &= ~ERunning;
1191 }
1192
1193 void CDsa::Start()
1194 {
1195         iStateFlags |= ERunning;
1196
1197         iStateFlags &= ~ESdlThreadExplicitStop;
1198
1199         if(iStateFlags & ESdlThreadSuspend)
1200         {
1201                 EpocSdlEnv::Resume();
1202                 iStateFlags &= ~ ESdlThreadSuspend;
1203         }
1204         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);
1205 }
1206
1207
1208 TBool CDsa::Blitter(CFbsBitmap& aBmp)
1209 {
1210         return iBlitter && iBlitter->BitBlt(*Gc(), aBmp, HwRect(), SwSize());
1211 }
1212
1213 void CDsa::SetBlitter(MBlitter* aBlitter)
1214 {
1215         iBlitter = aBlitter;
1216 }
1217
1218
1219 TPoint CDsa::WindowCoordinates(const TPoint& aPoint) const
1220 {
1221         TPoint pos = aPoint - iScreenRect.iTl;
1222         const TSize asz = iScreenRect.Size();
1223         if(iStateFlags & EOrientation180)
1224         {
1225                 pos.iX = asz.iWidth - pos.iX;
1226                 pos.iY = asz.iHeight - pos.iY;
1227         }
1228         if(iStateFlags & EOrientation90)
1229         {
1230                 pos.iX = aPoint.iY;
1231                 pos.iY = aPoint.iX;
1232         }
1233         pos.iX <<= 16;
1234         pos.iY <<= 16;
1235         pos.iX /= asz.iWidth;
1236         pos.iY /= asz.iHeight;
1237         pos.iX *= iSwSize.iWidth;
1238         pos.iY *= iSwSize.iHeight;
1239         pos.iX >>= 16;
1240         pos.iY >>= 16;
1241         return pos;
1242 }
1243
1244 void CDsa::SetTargetRect()
1245 {
1246         iTargetRect = iScreenRect;
1247         if(iStateFlags & EResizeRequest && EpocSdlEnv::Flags(CSDL::EAllowImageResizeKeepRatio))
1248         {
1249                 const TSize asz = iScreenRect.Size();
1250                 const TSize sz = iSwSize;
1251
1252                 TRect rect;
1253
1254                 const TInt dh = (sz.iHeight << 16) / sz.iWidth;
1255
1256                 if((asz.iWidth * dh ) >> 16 <= asz.iHeight)
1257                 {
1258                         rect.SetRect(TPoint(0, 0), TSize(asz.iWidth, (asz.iWidth * dh) >> 16));
1259                 }
1260                 else
1261                 {
1262                         const TInt dw = (sz.iWidth << 16) / sz.iHeight;
1263                         rect.SetRect(TPoint(0, 0), TSize((asz.iHeight * dw) >> 16, asz.iHeight));
1264                 }
1265                 rect.Move((asz.iWidth - rect.Size().iWidth) >> 1, (asz.iHeight - rect.Size().iHeight) >> 1);
1266
1267                 iTargetRect = rect;
1268                 iTargetRect.Move(iScreenRect.iTl);
1269
1270         }
1271         if(!(iStateFlags & EResizeRequest))
1272                 iSwSize = iScreenRect.Size();
1273
1274 }
1275
1276 RWindow* CDsa::Window()
1277 {
1278         return iWindow;
1279 }
1280
1281 CDsa* CDsa::CreateGlesDsaL()
1282 {
1283         CDsa* dsa = new (ELeave) CDsaGles(Session());
1284         CWsScreenDevice* dummy = NULL;
1285         dsa->ConstructL(*Window(), *dummy);
1286         Free();
1287         delete this;
1288         return dsa;
1289 }
1290
1291
1292 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1293
1294 void CDsa::Copy256(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1295 {
1296         TUint32* target = aTarget;
1297         const TUint32* endt = target + aBytes;
1298         const TUint8* source = aSource;
1299         while(target < endt)
1300         {
1301                 *target++ = aDsa.iLut256[*source++];
1302         }
1303 }
1304
1305 void CDsa::Copy256Reversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1306 {
1307         const TUint32* target = aTarget;
1308         TUint32* endt = aTarget + aBytes;
1309         const TUint8* source = aSource;
1310         while(target < endt)
1311         {
1312                 *(--endt) = aDsa.iLut256[*source++];
1313         }
1314 }
1315
1316 void CDsa::Copy256Flip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1317 {
1318         TUint32* target = aTarget;
1319         const TUint32* endt = target + aBytes;
1320         const TUint8* column = aSource;
1321
1322         while(target < endt)
1323         {
1324                 *target++ = aDsa.iLut256[*column];
1325                 column += aLineLen;
1326         }
1327 }
1328
1329 void CDsa::Copy256FlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1330 {
1331         const TUint32* target = aTarget;
1332         TUint32* endt = aTarget + aBytes;
1333         const TUint8* column = aSource;
1334
1335         while(target < endt)
1336         {
1337                 *(--endt) = aDsa.iLut256[*column];
1338                 column += aLineLen;
1339         }
1340 }
1341
1342 void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1343 {
1344         const TUint32* src = reinterpret_cast<const TUint32*>(aSource);
1345         Mem::Copy(aTarget, src, aBytes << 2);
1346 }
1347
1348 void CDsa::CopyMemFlip(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1349 {
1350         TUint32* target = aTarget;
1351         const TUint32* endt = target + aBytes;
1352         const TUint32* column = reinterpret_cast<const TUint32*>(aSource);
1353
1354         while(target < endt)
1355         {
1356                 *target++ = *column;
1357                 column += aLineLen;
1358         }
1359 }
1360
1361 void CDsa::CopyMemReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1362 {
1363         const TUint32* target = aTarget;
1364         TUint32* endt = aTarget + aBytes;
1365         const TUint32* source = reinterpret_cast<const TUint32*>(aSource);
1366         while(target < endt)
1367         {
1368                 *(--endt) = *source++;
1369         }
1370 }
1371
1372
1373 void CDsa::CopyMemFlipReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1374 {
1375         const TUint32* target = aTarget;
1376         TUint32* endt = aTarget + aBytes;
1377         const TUint32* column = reinterpret_cast<const TUint32*>(aSource);
1378
1379         while(target < endt)
1380         {
1381                 *(--endt) = *column;
1382                 column += aLineLen;
1383         }
1384 }
1385
1386 NONSHARABLE_CLASS(MRgbCopy)
1387 {
1388         public:
1389                 virtual void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed) = 0;
1390                 virtual void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed) = 0;
1391 };
1392
1393 template <class T>
1394 NONSHARABLE_CLASS(TRgbCopy) : public MRgbCopy
1395 {
1396         public:
1397                 TRgbCopy(TDisplayMode aMode);
1398                 void* operator new(TUint aBytes, TAny* aMem);
1399                 void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed);
1400                 void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed);
1401                 static TUint32 Gray256(const TUint8& aPixel);
1402                 static TUint32 Color256(const TUint8& aPixel);
1403                 static TUint32 Color4K(const TUint16& aPixel);
1404                 static TUint32 Color64K(const TUint16& aPixel);
1405                 static TUint32 Color16M(const TUint32& aPixel);
1406                 static TUint32 Color16MU(const TUint32& aPixel);
1407                 static TUint32 Color16MA(const TUint32& aPixel);
1408         private:
1409                 typedef TUint32 (*TRgbFunc) (const T& aValue);
1410                 TRgbFunc iFunc;
1411 };
1412
1413
1414         template <class T>
1415 void* TRgbCopy<T>::operator new(TUint /*aBytes*/, TAny* aMem)
1416 {
1417         return aMem;
1418 }
1419
1420         template <class T>
1421 TRgbCopy<T>::TRgbCopy(TDisplayMode aMode)
1422 {
1423         switch(aMode)
1424         {
1425                 case EGray256 : iFunc = (TRgbFunc) Gray256; break;
1426                 case EColor256 : iFunc =  (TRgbFunc) Color256; break;
1427                 case EColor4K : iFunc =  (TRgbFunc) Color4K; break;
1428                 case EColor64K : iFunc =  (TRgbFunc) Color64K; break;
1429                 case EColor16M : iFunc =  (TRgbFunc) Color16M; break;
1430                 case EColor16MU : iFunc =  (TRgbFunc) Color16MU; break;
1431                 case EColor16MA : iFunc =  (TRgbFunc) Color16MA; break;
1432                 default:
1433                                   PANIC(KErrNotSupported);
1434         }
1435 }
1436
1437         template <class T>
1438 void TRgbCopy<T>::Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed)
1439 {
1440         const T* source = reinterpret_cast<const T*>(aSource);
1441         TUint32* target = aTarget;
1442         TUint32* endt = target + aBytes;
1443
1444         if(aReversed)
1445         {
1446                 while(target < endt)
1447                 {
1448                         const T value = *source++;
1449                         *(--endt) = iFunc(value);
1450                 }
1451         }
1452         else
1453         {
1454                 while(target < endt)
1455                 {
1456                         const T value = *source++;
1457                         *target++ = iFunc(value);
1458                 }
1459         }
1460 }
1461
1462         template <class T>
1463 void TRgbCopy<T>::FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed)
1464 {
1465         const T* column = reinterpret_cast<const T*>(aSource);
1466         TUint32* target = aTarget;
1467         TUint32* endt = target + aBytes;
1468
1469         if(aReversed)
1470         {
1471                 while(target < endt)
1472                 {
1473                         *(--endt) = iFunc(*column);
1474                         column += aLineLen;
1475                 }
1476         }
1477         else
1478         {
1479                 while(target < endt)
1480                 {
1481                         *target++ = iFunc(*column);
1482                         column += aLineLen;
1483                 }
1484         }
1485 }
1486
1487 template <class T> TUint32 TRgbCopy<T>::Gray256(const TUint8& aPixel)
1488 {
1489         const TUint32 px = aPixel << 16 | aPixel << 8 | aPixel;
1490         return px;
1491 }
1492
1493 template <class T> TUint32 TRgbCopy<T>::Color256(const TUint8& aPixel)
1494 {
1495         return TRgb::Color256(aPixel).Value();
1496 }
1497
1498 template <class T> TUint32 TRgbCopy<T>::Color4K(const TUint16& aPixel)
1499 {
1500         TUint32 col = (aPixel & 0xF00) << 12;
1501         col |= (aPixel & 0xF00) << 8;
1502
1503         col |= (aPixel & 0x0F0) << 8;
1504         col |= (aPixel & 0x0F0);
1505
1506         col |= (aPixel & 0x00F) << 4;
1507         col |= (aPixel & 0x00F);
1508
1509         return col;
1510 }
1511
1512 template <class T> TUint32 TRgbCopy<T>::Color64K(const TUint16& aPixel)
1513 {
1514         TUint32 col = (aPixel & 0xF800)<< 8;
1515         col |= (aPixel & 0xE000) << 3;
1516
1517         col |= (aPixel & 0x07E0) << 5;
1518         col |= (aPixel & 0xC0) >> 1;
1519
1520         col |= (aPixel & 0x07E0) << 3;
1521         col |= (aPixel & 0x1C) >> 2;
1522
1523         return col;
1524 }
1525
1526 template <class T> TUint32 TRgbCopy<T>::Color16M(const TUint32& aPixel)
1527 {
1528         return TRgb::Color16M(aPixel).Value();
1529 }
1530
1531 template <class T> TUint32 TRgbCopy<T>::Color16MU(const TUint32& aPixel)
1532 {
1533         return TRgb::Color16MU(aPixel).Value();
1534 }
1535
1536 template <class T> TUint32 TRgbCopy<T>::Color16MA(const TUint32& aPixel)
1537 {
1538         return TRgb::Color16MA(aPixel).Value();
1539 }
1540
1541 typedef TUint64 TStackMem;
1542
1543 LOCAL_C MRgbCopy* GetCopy(TAny* mem, TDisplayMode aMode)
1544 {
1545         if(aMode == EColor256 || aMode == EGray256)
1546         {
1547                 return new (mem) TRgbCopy<TUint8>(aMode);
1548         }
1549         if(aMode == EColor4K || aMode == EColor64K)
1550         {
1551                 return new (mem) TRgbCopy<TUint16>(aMode);
1552         }
1553         if(aMode == EColor16M || aMode == EColor16MU || aMode == EColor16MA)
1554         {
1555                 return new (mem) TRgbCopy<TUint32>(aMode);
1556         }
1557         PANIC(KErrNotSupported);
1558         return NULL;
1559 }
1560
1561
1562 void CDsa::CopySlowFlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1563 {
1564         TStackMem mem = 0;
1565         GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, ETrue);
1566 }
1567
1568 void CDsa::CopySlowFlip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1569 {
1570         TStackMem mem = 0;
1571         GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, EFalse);
1572 }
1573
1574 void CDsa::CopySlow(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1575 {
1576         TStackMem mem = 0;
1577         GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, EFalse);
1578 }
1579
1580 void CDsa::CopySlowReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1581 {
1582         TStackMem mem = 0;
1583         GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, ETrue);
1584 }