src/video/symbian/EKA2/dsa_old.cpp

   1 #include "dsa.h"
   2 #include "sdlepocapi.h"
   3 #include <cdsb.h>
   4
   5 LOCAL_C TInt BytesPerPixel(TDisplayMode aMode)
   6         {
   7         return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1;
   8         }
   9
  10
  11 ////////////////////////////////////////////////////////////////////////////////////////////////
  12
  13 NONSHARABLE_CLASS(CDsaA) : public CDsa
  14         {
  15         public:
  16                 CDsaA(RWsSession& aSession);
  17         private:
  18                 ~CDsaA();
  19                 TUint8* LockSurface();
  20                 void UnlockHWSurfaceRequestComplete();
  21                 void UnlockHwSurface();
  22                 void CreateSurfaceL();
  23                 void Wipe(TInt aLength);
  24                 void RecreateL();
  25                 void Free();
  26                 TInt ExternalUpdate() {return 0;}
  27         private:
  28                 CFbsBitmap* iBmp;
  29         };
  30
  31
  32 CDsaA::CDsaA(RWsSession& aSession) : CDsa(aSession)
  33         {
  34         }
  35
  36 void CDsaA::Free()
  37         {
  38         delete iBmp;
  39         iBmp = NULL;
  40         }
  41
  42 CDsaA::~CDsaA()
  43         {
  44         __ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));
  45         }
  46
  47 TUint8* CDsaA::LockSurface()
  48         {
  49         iBmp->LockHeap();
  50         return reinterpret_cast<TUint8*>(iBmp->DataAddress());
  51         }
  52
  53 void CDsaA::UnlockHWSurfaceRequestComplete()
  54         {
  55         PANIC(KErrNotSupported);
  56         }
  57
  58 void CDsaA::UnlockHwSurface()
  59         {
  60         iBmp->UnlockHeap();
  61         SetUpdating(EFalse);
  62         Dsa().Gc()->BitBlt(HwRect().iTl, iBmp);
  63         Dsa().ScreenDevice()->Update();
  64         }
  65
  66 void CDsaA::CreateSurfaceL()
  67         {
  68         delete iBmp;
  69         iBmp = NULL;
  70         iBmp  = new (ELeave) CFbsBitmap();
  71         User::LeaveIfError(iBmp->Create(HwRect().Size(), DisplayMode()));
  72         }
  73
  74 void CDsaA::Wipe(TInt aLength) //dont call in drawing
  75         {
  76         iBmp->LockHeap();
  77         Mem::FillZ(iBmp->DataAddress(), aLength);
  78         iBmp->UnlockHeap();
  79         }
  80
  81 void CDsaA::RecreateL()
  82         {
  83         }
  84
  85 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  86
  87 NONSHARABLE_CLASS(MDsbObs)
  88         {
  89         public:
  90                 virtual void SurfaceReady() = 0;
  91                 virtual CDirectScreenBitmap& Dsb() = 0;
  92         };
  93
  94 NONSHARABLE_CLASS(CDsbSurface) : public CActive
  95         {
  96         public:
  97                 CDsbSurface(MDsbObs& aDsb);
  98                 TUint8* Address();
  99                 void Complete();
 100                 ~CDsbSurface();
 101         private:
 102                 void RunL();
 103                 void DoCancel();
 104         private:
 105                 MDsbObs& iDsb;
 106                 TUint8* iAddress;
 107         };
 108
 109 CDsbSurface::CDsbSurface(MDsbObs& aDsb) : CActive(CActive::EPriorityHigh) , iDsb(aDsb)
 110         {
 111         CActiveScheduler::Add(this);
 112         }
 113
 114 CDsbSurface::~CDsbSurface()
 115         {
 116         Cancel();
 117         }
 118
 119 void CDsbSurface::Complete()
 120         {
 121         if(iAddress != NULL && !IsActive())
 122                 {
 123                 iAddress = NULL;
 124                 SetActive();
 125                 iDsb.Dsb().EndUpdate(iStatus);
 126                 }
 127         }
 128
 129 TUint8* CDsbSurface::Address()
 130         {
 131         if(iAddress == NULL && !IsActive())
 132                 {
 133                 TAcceleratedBitmapInfo info;
 134                 if(KErrNone == iDsb.Dsb().BeginUpdate(info))
 135                         iAddress = info.iAddress;
 136                 }
 137         return iAddress;
 138         }
 139
 140 void CDsbSurface::RunL()
 141         {
 142         iDsb.SurfaceReady();
 143         }
 144
 145 void CDsbSurface::DoCancel()
 146         {
 147         //empty
 148         }
 149
 150 NONSHARABLE_CLASS(CDsaB) : public CDsa, public MDsbObs
 151         {
 152         public:
 153                 CDsaB(RWsSession& aSession);
 154         private:
 155                 ~CDsaB();
 156                 TUint8* LockSurface();
 157                 void UnlockHWSurfaceRequestComplete();
 158                 void UnlockHwSurface();
 159                 void CreateSurfaceL();
 160                 void Wipe(TInt aLength);
 161                 void RecreateL();
 162                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 163                 void Free();
 164                 CDirectScreenBitmap& Dsb();
 165                 void SurfaceReady();
 166                 TInt ExternalUpdate() {return 0;}
 167         private:
 168                 CDsbSurface* iSurface1;
 169                 CDsbSurface* iSurface2;
 170                 CDirectScreenBitmap* iDsb;
 171         };
 172
 173 CDsaB::CDsaB(RWsSession& aSession) : CDsa(aSession)
 174         {
 175         }
 176
 177 void CDsaB::Free()
 178         {
 179         }
 180
 181 void CDsaB::UnlockHWSurfaceRequestComplete()
 182         {
 183         iSurface1->Complete();
 184         iSurface2->Complete();
 185         }
 186
 187 void CDsaB::CreateSurfaceL()
 188         {
 189         }
 190
 191 void CDsaB::Wipe(TInt aLength) //dont call in drawing
 192         {
 193         TUint8* addr = LockSurface();
 194         if(addr != NULL)
 195                 {
 196                 Mem::FillZ(addr, aLength);
 197                 UnlockHwSurface();
 198                 }
 199         }
 200
 201 void CDsaB::UnlockHwSurface()
 202         {
 203         EpocSdlEnv::Request(CDsa::ERequestUpdate);
 204         }
 205
 206 TUint8* CDsaB::LockSurface()
 207         {
 208         TUint8* addr =  iSurface1->Address();
 209         if(addr == NULL)
 210                 addr =  iSurface2->Address();
 211         SetUpdating(addr == NULL);
 212         return addr;
 213         }
 214
 215 void CDsaB::SurfaceReady()
 216         {
 217         SetUpdating(EFalse);
 218         }
 219
 220 CDirectScreenBitmap& CDsaB::Dsb()
 221         {
 222         return *iDsb;
 223         }
 224
 225 void CDsaB::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 226         {
 227         if(iDsb == NULL)
 228                 iDsb = CDirectScreenBitmap::NewL();
 229         CDsa::ConstructL(aWindow, aDevice);
 230         iSurface1 = new (ELeave) CDsbSurface(*this);
 231         iSurface2 = new (ELeave) CDsbSurface(*this);
 232         }
 233
 234 CDsaB::~CDsaB()
 235         {
 236         delete iSurface1;
 237         delete iSurface2;
 238         delete iDsb;
 239         }
 240
 241 void CDsaB::RecreateL()
 242         {
 243     iDsb->Close();
 244     iDsb->Create(HwRect(), CDirectScreenBitmap::EDoubleBuffer);
 245         }
 246
 247 /////////////////////////////////////////////////////////////////////////////////////////////////////
 248
 249
 250 TSize CDsa::WindowSize() const
 251         {
 252         TSize size = HwRect().Size();
 253         if(iStateFlags & EOrientation90)
 254                 {
 255                 const TInt tmp = size.iWidth;
 256                 size.iWidth = size.iHeight;
 257                 size.iHeight = tmp;
 258                 }
 259         return size;
 260         }
 261
 262 void CDsa::SetSuspend()
 263         {
 264         iStateFlags |= ESdlThreadSuspend;
 265         }
 266
 267 void CDsa::ReleaseStop()
 268         {
 269         iStateFlags &= ~ESdlThreadExplicitStop;
 270         }
 271
 272
 273 TBool CDsa::Stopped() const
 274         {
 275         return (iStateFlags & ESdlThreadExplicitStop);
 276         }
 277
 278 void CDsa::SetOrientation(CSDL::TOrientationMode aOrientation)
 279         {
 280         TInt flags = 0;
 281         switch(aOrientation)
 282                 {
 283                 case CSDL::EOrientation90:
 284                         flags = EOrientation90;
 285                         break;
 286                 case CSDL::EOrientation180:
 287                         flags = EOrientation180;
 288                         break;
 289                 case CSDL::EOrientation270:
 290                         flags = EOrientation90 | EOrientation180;
 291                         break;
 292                 case CSDL::EOrientation0:
 293                         flags = 0;
 294                         break;
 295                 }
 296         if(flags != (iStateFlags & EOrientationFlags))
 297                 {
 298                 iStateFlags |= EOrientationChanged;
 299                 iNewFlags = flags; //cannot be set during drawing...
 300                 }
 301         }
 302
 303 CDsa::~CDsa()
 304     {
 305     if(iDsa != NULL)
 306         {
 307         iDsa->Cancel();
 308         }
 309     delete iDsa;
 310     User::Free(iLut256);
 311     }
 312
 313 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 314     {
 315     if(iDsa != NULL)
 316         {
 317         iDsa->Cancel();
 318         delete iDsa;
 319         iDsa = NULL;
 320         }
 321
 322
 323     iDsa = CDirectScreenAccess::NewL(
 324                                 iSession,
 325                                         aDevice,
 326                                         aWindow,
 327                                         *this);
 328
 329         if(iLut256 == NULL)
 330                 iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32));
 331         iTargetMode = aWindow.DisplayMode();
 332         iTargetBpp = BytesPerPixel(DisplayMode());
 333         iTargetRect = TRect(aWindow.Position(), aWindow.Size());
 334     RestartL();
 335     }
 336
 337 void CDsa::LockPalette(TBool aLock)
 338         {
 339         if(aLock)
 340                 iStateFlags |= EPaletteLocked;
 341         else
 342                 iStateFlags &= ~EPaletteLocked;
 343         }
 344 TInt CDsa::SetPalette(TInt aFirst, TInt aCount, TUint32* aPalette)
 345         {
 346         if(iLut256 == NULL)
 347                 return KErrNotFound;
 348         const TInt count = aCount - aFirst;
 349         if(count > 256)
 350                 return KErrArgument;
 351         if(iStateFlags & EPaletteLocked)
 352                 return KErrNone;
 353         for(TInt i = aFirst; i < count; i++) //not so busy here:-)
 354                 {
 355                 iLut256[i] = aPalette[i];
 356                 }
 357         return KErrNone;
 358         }
 359
 360
 361
 362
 363 void CDsa::RestartL()
 364     {
 365     //const TBool active = iDsa->IsActive();
 366
 367     //if(!active)
 368     iDsa->StartL();
 369
 370     RRegion* r = iDsa->DrawingRegion();
 371     iDsa->Gc()->SetClippingRegion(r);
 372     TRect rect = r->BoundingRect();
 373
 374     if(rect.IsEmpty())
 375         {
 376         return;
 377         }
 378
 379     iScreenRect = rect; //to ensure properly set, albeit may not(?) match to value SDL has - therefore may has to clip
 380
 381         RecreateL();
 382
 383     iStateFlags |= ERunning;
 384 //    iScanLineWidth = iTargetBpp * HwRect().Width();
 385     ReleaseStop();
 386     if(iStateFlags & ESdlThreadSuspend)
 387         {
 388         EpocSdlEnv::Resume();
 389         iStateFlags &= ~ ESdlThreadSuspend;
 390         }
 391     }
 392
 393 CDsa::CDsa(RWsSession& aSession) :
 394         iSession(aSession),
 395         iStateFlags(0)
 396         {
 397 //      CActiveScheduler::Add(this);
 398         iCFTable[0] = CopyMem;
 399         iCFTable[1] = CopyMemFlipReversed;
 400         iCFTable[2] = CopyMemReversed;
 401         iCFTable[3] = CopyMemFlip;
 402
 403         iCFTable[4] = Copy256;
 404         iCFTable[5] = Copy256FlipReversed;
 405         iCFTable[6] = Copy256Reversed;
 406         iCFTable[7] = Copy256Flip;
 407
 408
 409         iCFTable[8] = CopySlow;
 410         iCFTable[9] = CopySlowFlipReversed;
 411         iCFTable[10] = CopySlowReversed;
 412         iCFTable[11] = CopySlowFlip;
 413         }
 414
 415 RWsSession& CDsa::Session()
 416         {
 417         return iSession;
 418         }
 419
 420
 421
 422 TUint8* CDsa::LockHwSurface()
 423         {
 424         if((iStateFlags & EUpdating) == 0) //else frame is skipped
 425                 {
 426                 return LockSurface();
 427                 }
 428         return NULL;
 429         }
 430
 431 /*
 432 void CDsa::RunL()
 433         {
 434         iStateFlags &= ~EUpdating;
 435         }
 436
 437
 438 void CDsa::DoCancel()
 439         {
 440         iStateFlags &= ~EUpdating;
 441         //nothing can do, just wait?
 442         }
 443 */
 444
 445 TInt CDsa::AllocSurface(TBool aHwSurface, const TSize& aSize, TDisplayMode aMode)
 446         {
 447         if(aHwSurface && aMode != DisplayMode())
 448                 return KErrArgument;
 449
 450         iSourceMode = aMode;
 451
 452         iSourceBpp = BytesPerPixel(aMode);
 453
 454         const TSize size = WindowSize();
 455         if(aSize.iWidth > size.iWidth)
 456                 return KErrTooBig;
 457         if(aSize.iHeight > size.iHeight)
 458                 return KErrTooBig;
 459
 460         TRAPD(err, CreateSurfaceL());
 461         if(err != KErrNone)
 462                 return err;
 463
 464
 465         SetCopyFunction();
 466
 467         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);
 468
 469         return KErrNone;
 470         }
 471
 472
 473 /*
 474 void SaveBmp(const TDesC& aName, const TAny* aData, TInt aLength, const TSize& aSz, TDisplayMode aMode)
 475         {
 476         CFbsBitmap* s = new CFbsBitmap();
 477         s->Create(aSz, aMode);
 478         s->LockHeap();
 479         TUint32* addr = s->DataAddress();
 480         Mem::Copy(addr, aData, aLength);
 481         s->UnlockHeap();
 482         s->Save(aName);
 483         s->Reset();
 484         delete s;
 485         }
 486
 487 void SaveBmp(const TDesC& aName, const TUint32* aData, const TSize& aSz)
 488         {
 489         CFbsBitmap* s = new CFbsBitmap();
 490         s->Create(aSz, EColor64K);
 491         TBitmapUtil bmp(s);
 492         bmp.Begin(TPoint(0, 0));
 493         for(TInt j = 0; j < aSz.iHeight; j++)
 494                 {
 495                 bmp.SetPos(TPoint(0, j));
 496                 for(TInt i = 0; i < aSz.iWidth; i++)
 497                         {
 498                         bmp.SetPixel(*aData);
 499                         aData++;
 500                         bmp.IncXPos();
 501                         }
 502                 }
 503         bmp.End();
 504         s->Save(aName);
 505         s->Reset();
 506         delete s;
 507         }
 508
 509 TBuf<16> FooName(TInt aFoo)
 510         {
 511         TBuf<16> b;
 512         b.Format(_L("C:\\pic%d.mbm"), aFoo);
 513         return b;
 514         }
 515 */
 516 void CDsa::ClipCopy(TUint8* aTarget, const TUint8* aSource, const TRect& aRect, const TRect& aTargetPos) const
 517         {
 518         TUint8* target = aTarget;
 519         const TUint8* source = aSource;
 520         const TInt lineWidth = aRect.Width();
 521         source += iSourceBpp * (aRect.iTl.iY * lineWidth);
 522         TInt sourceStartOffset = iSourceBpp *  aRect.iTl.iX;
 523         source += sourceStartOffset;
 524         target += iTargetBpp * ((aTargetPos.iTl.iY + aRect.iTl.iY ) * lineWidth);
 525         TInt targetStartOffset = iTargetBpp * (aRect.iTl.iX + aTargetPos.iTl.iX);
 526         target += targetStartOffset;
 527         TUint32* targetPtr = reinterpret_cast<TUint32*>(target);
 528         const TInt targetWidth = HwRect().Size().iWidth;
 529         const TInt height = aRect.Height();
 530
 531         TInt lineMove = iStateFlags & EOrientation90 ? 1 : lineWidth;
 532
 533         if(iStateFlags & EOrientation180)
 534                 {
 535
 536                 targetPtr += targetWidth *  (height - 1);
 537
 538                 for(TInt i = 0; i < height; i++) //source is always smaller
 539                         {
 540                         iCopyFunction(*this, targetPtr, source, lineWidth, height);
 541                         source += lineMove;
 542                         targetPtr -= targetWidth;
 543                         }
 544                 }
 545         else
 546                 {
 547
 548
 549                 for(TInt i = 0; i < height; i++) //source is always smaller
 550                         {
 551                         iCopyFunction(*this, targetPtr, source, lineWidth, height);
 552                         source += lineMove;
 553                         targetPtr += targetWidth;
 554                         }
 555                 }
 556
 557         }
 558
 559
 560
 561
 562 void CDsa::Wipe() //dont call in drawing
 563         {
 564         if(IsDsaAvailable())
 565                 Wipe(iTargetBpp * iScreenRect.Width() * iScreenRect.Height());
 566         }
 567
 568 void CDsa::SetCopyFunction()
 569         {
 570         //calculate offset to correct function in iCFTable according to given parameters
 571         TInt function = 0;
 572         const TInt KCopyFunctions = 4;
 573         const TInt KOffsetToNative = 0;
 574         const TInt KOffsetTo256 = KOffsetToNative + KCopyFunctions;
 575         const TInt KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions;
 576         const TInt KOffsetTo90Functions = 1;
 577         const TInt KOffsetTo180Functions = 2;
 578
 579         if(iSourceMode == DisplayMode())
 580                 function = KOffsetToNative;             //0
 581         else if(iSourceMode == EColor256)
 582                 function = KOffsetTo256;                        //4
 583         else
 584                 function = KOffsetToOtherModes;         //8
 585
 586         if(iStateFlags & EOrientation90)
 587                 function += KOffsetTo90Functions;       // + 1
 588         if(iStateFlags & EOrientation180)
 589                 function += KOffsetTo180Functions;      //+ 2
 590
 591         iCopyFunction = iCFTable[function];
 592
 593         Wipe();
 594         }
 595
 596 inline void Rotate(TRect& aRect)
 597         {
 598         const TInt dx = aRect.iBr.iX - aRect.iTl.iX;
 599         const TInt dy = aRect.iBr.iY - aRect.iTl.iY;
 600
 601         aRect.iBr.iX = aRect.iTl.iX + dy;
 602         aRect.iBr.iY = aRect.iTl.iY + dx;
 603
 604         const TInt tmp = aRect.iTl.iX;
 605         aRect.iTl.iX = aRect.iTl.iY;
 606         aRect.iTl.iY = tmp;
 607         }
 608
 609 /*
 610 int bar = 0;
 611 */
 612 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)
 613         {
 614
 615         if(iStateFlags & EOrientationChanged)
 616                 {
 617                 iStateFlags &= ~EOrientationFlags;
 618                 iStateFlags |= iNewFlags;
 619                 SetCopyFunction();
 620                 iStateFlags &= ~EOrientationChanged;
 621             EpocSdlEnv::WaitDeviceChange();
 622             return EFalse; //skip this frame as data is may be changed
 623                 }
 624
 625         if(iTargetAddr == NULL)
 626                 {
 627                 iTargetAddr = LockHwSurface();
 628                 }
 629         TUint8* target = iTargetAddr;
 630         if(target == NULL)
 631                 return EFalse;
 632
 633
 634         TRect targetRect = HwRect();
 635         TRect sourceRect = aRect;
 636         TRect updateRect = aUpdateRect;
 637
 638         if(iStateFlags & EOrientation90)
 639                 {
 640                 Rotate(sourceRect);
 641                 Rotate(updateRect);
 642                 }
 643
 644         if(iSourceMode != DisplayMode() ||  targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0))
 645                 {
 646                 sourceRect.Intersection(targetRect); //so source always smaller or equal than target
 647                 updateRect.Intersection(targetRect);
 648                 ClipCopy(target, aBits, updateRect, sourceRect);
 649                 }
 650         else
 651                 {
 652                 const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored
 653                 Mem::Copy(target, aBits, byteCount);
 654                 }
 655
 656         return ETrue;
 657         }
 658
 659 CDsa* CDsa::CreateL(RWsSession& aSession)
 660         {
 661         if(EpocSdlEnv::Flags(CSDL::EDrawModeDSB))
 662                 {
 663                 TInt flags = CDirectScreenBitmap::ENone;
 664                 if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBDoubleBuffer))
 665                         flags |= CDirectScreenBitmap::EDoubleBuffer;
 666                 if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBIncrentalUpdate))
 667                         flags |= CDirectScreenBitmap::EIncrementalUpdate;
 668                 return new (ELeave) CDsaB(aSession);
 669                 }
 670     else
 671         return new (ELeave) CDsaA(aSession);
 672         }
 673
 674 void CDsa::CreateZoomerL(const TSize& aSize)
 675         {
 676         iSwSize = aSize;
 677         iStateFlags |= EResizeRequest;
 678         CreateSurfaceL();
 679         SetTargetRect();
 680         }
 681
 682 TPoint CDsa::WindowCoordinates(const TPoint& aPoint) const
 683         {
 684         TPoint pos = aPoint - iScreenRect.iTl;
 685         const TSize asz = iScreenRect.Size();
 686         if(iStateFlags & EOrientation180)
 687                 {
 688                 pos.iX = asz.iWidth - pos.iX;
 689                 pos.iY = asz.iHeight - pos.iY;
 690                 }
 691         if(iStateFlags & EOrientation90)
 692                 {
 693                 pos.iX = aPoint.iY;
 694                 pos.iY = aPoint.iX;
 695                 }
 696         pos.iX <<= 16;
 697         pos.iY <<= 16;
 698         pos.iX /= asz.iWidth;
 699         pos.iY /= asz.iHeight;
 700         pos.iX *= iSwSize.iWidth;
 701         pos.iY *= iSwSize.iHeight;
 702         pos.iX >>= 16;
 703         pos.iY >>= 16;
 704         return pos;
 705         }
 706
 707 void CDsa::SetTargetRect()
 708         {
 709         iTargetRect = iScreenRect;
 710         if(iStateFlags & EResizeRequest && EpocSdlEnv::Flags(CSDL::EAllowImageResizeKeepRatio))
 711                 {
 712                 const TSize asz = iScreenRect.Size();
 713                 const TSize sz = iSwSize;
 714
 715                 TRect rect;
 716
 717                 const TInt dh = (sz.iHeight << 16) / sz.iWidth;
 718
 719                 if((asz.iWidth * dh ) >> 16 <= asz.iHeight)
 720                         {
 721                         rect.SetRect(TPoint(0, 0), TSize(asz.iWidth, (asz.iWidth * dh) >> 16));
 722                         }
 723                 else
 724                         {
 725                         const TInt dw = (sz.iWidth << 16) / sz.iHeight;
 726                 rect.SetRect(TPoint(0, 0), TSize((asz.iHeight * dw) >> 16, asz.iHeight));
 727                         }
 728                 rect.Move((asz.iWidth - rect.Size().iWidth) >> 1, (asz.iHeight - rect.Size().iHeight) >> 1);
 729
 730                 iTargetRect = rect;
 731                 iTargetRect.Move(iScreenRect.iTl);
 732
 733                 }
 734         if(!(iStateFlags & EResizeRequest))
 735                 iSwSize = iScreenRect.Size();
 736 //      iScanLineWidth = /*iTargetBpp **/ SwSize().iWidth;
 737         }
 738
 739 void CDsa::RecreateL()
 740         {
 741         }
 742
 743 void CDsa::Free()
 744         {
 745         }
 746
 747 void CDsa::UpdateSwSurface()
 748         {
 749         iTargetAddr = NULL;
 750         UnlockHwSurface();      //could be faster if does not use AO, but only check status before redraw, then no context switch needed
 751         }
 752
 753 void CDsa::SetBlitter(MBlitter* aBlitter)
 754         {
 755         iBlitter = aBlitter;
 756         }
 757
 758 void CDsa::DrawOverlays()
 759         {
 760         const TInt last = iOverlays.Count() - 1;
 761         for(TInt i = last; i >= 0 ; i--)
 762                 iOverlays[i].iOverlay->Draw(*iDsa->Gc(), HwRect(), SwSize());
 763         }
 764
 765 TInt CDsa::AppendOverlay(MOverlay& aOverlay, TInt aPriority)
 766         {
 767         TInt i;
 768         for(i = 0; i < iOverlays.Count() && iOverlays[i].iPriority < aPriority; i++)
 769                 {}
 770         const TOverlay overlay = {&aOverlay, aPriority};
 771         return iOverlays.Insert(overlay, i);
 772         }
 773
 774 TInt CDsa::RemoveOverlay(MOverlay& aOverlay)
 775         {
 776         for(TInt i = 0; i < iOverlays.Count(); i++)
 777                 {
 778                 if(iOverlays[i].iOverlay == &aOverlay)
 779                         {
 780                         iOverlays.Remove(i);
 781                         return KErrNone;
 782                         }
 783                 }
 784         return KErrNotFound;
 785         }
 786
 787 TInt CDsa::RedrawRequest()
 788         {
 789         if(!(iStateFlags & (EUpdating) && (iStateFlags & ERunning)))
 790                 {
 791                 return ExternalUpdate();
 792                 }
 793         return KErrNotReady;
 794         }
 795
 796
 797 void CDsa::Resume()
 798         {
 799         if(Stopped())
 800                 Restart(RDirectScreenAccess::ETerminateRegion);
 801         }
 802
 803 void CDsa::DoStop()
 804         {
 805         if(IsDsaAvailable())
 806                 iStateFlags |= ESdlThreadExplicitStop;
 807         Stop();
 808         }
 809
 810 void CDsa::Stop()
 811         {
 812         iStateFlags &= ~ERunning;
 813 //      Cancel(); //can be called only from main!
 814         iDsa->Cancel();
 815         }
 816
 817 void CDsa::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 818         {
 819 //      iStateFlags |= EChangeNotify;
 820         Stop();
 821         }
 822
 823 void CDsa::Restart(RDirectScreenAccess::TTerminationReasons aReason)
 824         {
 825         if(aReason == RDirectScreenAccess::ETerminateRegion) //auto restart
 826                 {
 827                 TRAPD(err, RestartL());
 828                 PANIC_IF_ERROR(err);
 829                 }
 830         }
 831 /*)
 832 TBool CDsa::ChangeTrigger()
 833         {
 834         const TBool change = iStateFlags & EChangeNotify;
 835         iStateFlags &= ~EChangeNotify;
 836         return change;
 837         }
 838 */
 839 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 840
 841 void CDsa::Copy256(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
 842         {
 843         TUint32* target = aTarget;
 844         const TUint32* endt = target + aBytes;
 845         const TUint8* source = aSource;
 846         while(target < endt)
 847                 {
 848                 *target++ = aDsa.iLut256[*source++];
 849                 }
 850         }
 851
 852 void CDsa::Copy256Reversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
 853         {
 854         const TUint32* target = aTarget;
 855         TUint32* endt = aTarget + aBytes;
 856         const TUint8* source = aSource;
 857         while(target < endt)
 858                 {
 859                 *(--endt) = aDsa.iLut256[*source++];
 860                 }
 861         }
 862
 863 void CDsa::Copy256Flip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
 864         {
 865         TUint32* target = aTarget;
 866         const TUint32* endt = target + aBytes;
 867         const TUint8* column = aSource;
 868
 869         while(target < endt)
 870                 {
 871                 *target++ = aDsa.iLut256[*column];
 872                 column += aLineLen;
 873                 }
 874         }
 875
 876 void CDsa::Copy256FlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
 877         {
 878         const TUint32* target = aTarget;
 879         TUint32* endt = aTarget + aBytes;
 880         const TUint8* column = aSource;
 881
 882         while(target < endt)
 883                 {
 884                 *(--endt) = aDsa.iLut256[*column];
 885                 column += aLineLen;
 886                 }
 887         }
 888
 889 void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
 890         {
 891         Mem::Copy(aTarget, aSource, aBytes);
 892         }
 893
 894 void CDsa::CopyMemFlip(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
 895         {
 896         TUint32* target = aTarget;
 897         const TUint32* endt = target + aBytes;
 898         const TUint32* column = reinterpret_cast<const TUint32*>(aSource);
 899
 900         while(target < endt)
 901                 {
 902                 *target++ = *column;
 903                 column += aLineLen;
 904                 }
 905         }
 906
 907 void CDsa::CopyMemReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
 908         {
 909         const TUint32* target = aTarget;
 910         TUint32* endt = aTarget + aBytes;
 911         const TUint32* source = reinterpret_cast<const TUint32*>(aSource);
 912         while(target < endt)
 913                 {
 914                 *(--endt) = *source++;
 915                 }
 916         }
 917
 918
 919 void CDsa::CopyMemFlipReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
 920         {
 921         const TUint32* target = aTarget;
 922         TUint32* endt = aTarget + aBytes;
 923         const TUint32* column = reinterpret_cast<const TUint32*>(aSource);
 924
 925         while(target < endt)
 926                 {
 927                 *(--endt) = *column;
 928                 column += aLineLen;
 929                 }
 930         }
 931
 932
 933 typedef TRgb (*TRgbFunc) (TInt aValue);
 934
 935 LOCAL_C TRgb rgb16MA(TInt aValue)
 936         {
 937         return TRgb::Color16MA(aValue);
 938         }
 939
 940 NONSHARABLE_CLASS(MRgbCopy)
 941         {
 942         public:
 943         virtual void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed) = 0;
 944         virtual void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed) = 0;
 945         };
 946 template <class T>
 947 NONSHARABLE_CLASS(TRgbCopy) : public MRgbCopy
 948         {
 949         public:
 950         TRgbCopy(TDisplayMode aMode);
 951         void* operator new(TUint aBytes, TAny* aMem);
 952         void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed);
 953         void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed);
 954         private:
 955                 TRgbFunc iFunc;
 956         };
 957
 958 template <class T>
 959 void* TRgbCopy<T>::operator new(TUint /*aBytes*/, TAny* aMem)
 960         {
 961         return aMem;
 962         }
 963
 964 template <class T>
 965 TRgbCopy<T>::TRgbCopy(TDisplayMode aMode)
 966         {
 967         switch(aMode)
 968         {
 969         case EGray256 : iFunc = TRgb::Gray256; break;
 970         case EColor256 : iFunc = TRgb::Color256; break;
 971         case EColor4K : iFunc = TRgb::Color4K; break;
 972         case EColor64K : iFunc = TRgb::Color64K; break;
 973         case EColor16M : iFunc = TRgb::Color16M; break;
 974         case EColor16MU : iFunc = TRgb::Color16MU; break;
 975         case EColor16MA : iFunc = rgb16MA; break;
 976         default:
 977                 PANIC(KErrNotSupported);
 978         }
 979         }
 980
 981 template <class T>
 982 void TRgbCopy<T>::Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed)
 983         {
 984         const T* source = reinterpret_cast<const T*>(aSource);
 985         TUint32* target = aTarget;
 986         TUint32* endt = target + aBytes;
 987
 988         if(aReversed)
 989                 {
 990                 while(target < endt)
 991                         {
 992                         TUint32 value = *source++;
 993                         *(--endt) = iFunc(value).Value();
 994                         }
 995                 }
 996         else
 997                 {
 998                 while(target < endt)
 999                         {
1000                         TUint32 value = *source++;
1001                         *target++ = iFunc(value).Value();
1002                         }
1003                 }
1004         }
1005
1006 template <class T>
1007 void TRgbCopy<T>::FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed)
1008         {
1009         const T* column = reinterpret_cast<const T*>(aSource);
1010         TUint32* target = aTarget;
1011         TUint32* endt = target + aBytes;
1012
1013         if(aReversed)
1014                 {
1015                 while(target < endt)
1016                         {
1017                         *(--endt) = iFunc(*column).Value();
1018                         column += aLineLen;
1019                         }
1020                 }
1021         else
1022                 {
1023                 while(target < endt)
1024                         {
1025                         *target++ = iFunc(*column).Value();
1026                         column += aLineLen;
1027                         }
1028                 }
1029         }
1030
1031
1032 typedef TUint64 TStackMem;
1033
1034 LOCAL_C MRgbCopy* GetCopy(TAny* mem, TDisplayMode aMode)
1035         {
1036         if(aMode == EColor256 || aMode == EGray256)
1037                 {
1038                 return new (mem) TRgbCopy<TUint8>(aMode);
1039                 }
1040         if(aMode == EColor4K || aMode == EColor64K)
1041                 {
1042                 return new (mem) TRgbCopy<TUint16>(aMode);
1043                 }
1044         if(aMode == EColor16M || aMode == EColor16MU || aMode == EColor16MA)
1045                 {
1046                 return new (mem) TRgbCopy<TUint32>(aMode);
1047                 }
1048         PANIC(KErrNotSupported);
1049         return NULL;
1050         }
1051
1052
1053 void CDsa::CopySlowFlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1054         {
1055         TStackMem mem = 0;
1056         GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, ETrue);
1057         }
1058
1059 void CDsa::CopySlowFlip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
1060         {
1061         TStackMem mem = 0;
1062         GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, EFalse);
1063         }
1064
1065 void CDsa::CopySlow(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1066         {
1067         TStackMem mem = 0;
1068         GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, EFalse);
1069         }
1070
1071 void CDsa::CopySlowReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
1072         {
1073         TStackMem mem = 0;
1074         GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, ETrue);
1075         }