src/video/symbian/EKA2/dsa_new.cpp

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