src/video/symbian/dsa.cpp

   1 #include "dsa.h"
   2 #include "sdlepocapi.h"
   3 #include <cdsb.h>
   4 #include <basched.h>
   5
   6 static int BytesPerPixel(TDisplayMode aMode)
   7 {
   8         return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1;
   9 }
  10
  11 template<class T>
  12 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(const TSize& aSize);
  23                 void Free();
  24                 void Update(CFbsBitmap& aBmp);
  25                 CFbsBitmap* iBmp;
  26 };
  27
  28 template<class T>
  29 void CBitmapSurface<T>::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
  30 {
  31         T::ConstructL(aWindow, aDevice);
  32 }
  33
  34 template<class T>
  35 CBitmapSurface<T>::CBitmapSurface(RWsSession& aSession) : T(aSession)
  36 {
  37 }
  38
  39 template<class T>
  40 void CBitmapSurface<T>::Free()
  41 {
  42         delete iBmp;
  43         iBmp = NULL;
  44         T::Free();
  45 }
  46
  47 template<class T>
  48 CBitmapSurface<T>::~CBitmapSurface()
  49 {
  50         __ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));
  51 }
  52
  53 template<class T>
  54 TUint8* CBitmapSurface<T>::LockSurface()
  55 {
  56         iBmp->LockHeap();
  57         return reinterpret_cast<TUint8*>(iBmp->DataAddress());
  58 }
  59
  60 template<class T>
  61 void CBitmapSurface<T>::UnlockHwSurface()
  62 {
  63         iBmp->UnlockHeap();
  64         Update(*iBmp);
  65 }
  66
  67 template<class T>
  68 void CBitmapSurface<T>::Update(CFbsBitmap& aBmp)
  69 {
  70         T::DoBlt(aBmp);
  71         T::CompleteUpdate();
  72 }
  73
  74 template<class T>
  75 void CBitmapSurface<T>::CreateSurfaceL(const TSize& aSize)
  76 {
  77         Free();
  78         iBmp = new CFbsBitmap();
  79         User::LeaveIfError(iBmp->Create(aSize, T::DisplayMode()));
  80 }
  81
  82 //////////////////////////////////////////////////////////////////////
  83
  84 class CDsaGles : public CDsa
  85 {
  86         public:
  87                 CDsaGles(RWsSession& aSession) : CDsa(aSession) {}
  88
  89         private:
  90                 TUint8* LockSurface() { return NULL; }
  91                 void UnlockHwSurface() {}
  92                 void CreateSurfaceL(const TSize& aSize) {}
  93 };
  94
  95 //////////////////////////////////////////////////////////////////////
  96
  97 class CDsaBase : public CDsa, public MDirectScreenAccess
  98 {
  99         protected:
 100                 CDsaBase(RWsSession& aSession) : CDsa(aSession) { m_updateWholeScreen = false; }
 101                 ~CDsaBase();
 102                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 103                 void Stop();
 104                 void CompleteUpdate();
 105                 void DoBlt(CFbsBitmap& aBmp);
 106
 107                 CDirectScreenAccess*  iDsa;
 108
 109         private:
 110                 void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);
 111                 void Restart(RDirectScreenAccess::TTerminationReasons aReason);
 112                 void RestartL();
 113 };
 114
 115 void CDsaBase::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 116 {
 117         CDsa::ConstructL(aWindow, aDevice);
 118         if(iDsa != NULL)
 119         {
 120                 iDsa->Cancel();
 121                 delete iDsa;
 122                 iDsa = NULL;
 123         }
 124
 125         iDsa = CDirectScreenAccess::NewL(Session(), aDevice, aWindow, *this);
 126         RestartL();
 127 }
 128
 129 void CDsaBase::CompleteUpdate()
 130 {
 131         iDsa->ScreenDevice()->Update();
 132 }
 133
 134 void CDsaBase::DoBlt(CFbsBitmap& aBmp)
 135 {
 136         iDsa->Gc()->BitBlt(TPoint(0, 0), &aBmp);
 137 }
 138
 139 CDsaBase::~CDsaBase()
 140 {
 141         if(iDsa != NULL)
 142         {
 143                 iDsa->Cancel();
 144         }
 145         delete iDsa;
 146 }
 147
 148 void CDsaBase::RestartL()
 149 {
 150         iDsa->StartL();
 151         iDsa->Gc()->SetClippingRegion(iDsa->DrawingRegion());
 152
 153         Start();
 154 }
 155
 156 void CDsaBase::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 157 {
 158         Stop();
 159 }
 160
 161 void CDsaBase::Restart(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 162 {
 163         TRAPD(err, RestartL());
 164         if(err == KLeaveExit)
 165         {
 166                 Stop();
 167         }
 168         else
 169         {
 170                 PANIC_IF_ERROR(err);
 171         }
 172 }
 173
 174 void CDsaBase::Stop()
 175 {
 176         CDsa::Stop();
 177         iDsa->Cancel();
 178 }
 179
 180 ///////////////////////////////////////////////////////////////////////
 181
 182 class TDsa
 183 {
 184         public:
 185                 inline TDsa(const CDsa& aDsa) : iDsa(aDsa) {}
 186                 inline void Copy(TUint32* aTarget, const TUint8* aSrc, int aBytes) const;
 187         private:
 188                 const CDsa& iDsa;
 189 };
 190
 191 inline void TDsa::Copy(TUint32* aTarget, const TUint8* aSrc, int aBytes) const
 192 {
 193         iDsa.iCopyFunction(iDsa, aTarget, aSrc, aBytes);
 194 }
 195
 196 template<class T, class S>
 197 void ClipCopy(const TDsa& iDsa, TUint8* aTarget,
 198                 const TUint8* aSource,
 199                 const TRect& aUpdateRect,
 200                 const TRect& aSourceRect)
 201 {
 202         const S* source = reinterpret_cast<const S*>(aSource);
 203         const int lineWidth = aSourceRect.Width();
 204
 205         source += (aUpdateRect.iTl.iY * lineWidth);
 206         const int sourceStartOffset = aUpdateRect.iTl.iX;
 207         source += sourceStartOffset;
 208
 209         T* targetPtr = reinterpret_cast<T*>(aTarget);
 210
 211         const int scanLineWidth = aSourceRect.iBr.iX;
 212
 213         targetPtr += aUpdateRect.iTl.iY * scanLineWidth;
 214         const int targetStartOffset = aUpdateRect.iTl.iX;
 215
 216         targetPtr += targetStartOffset;
 217
 218         const int height = aUpdateRect.Height();
 219
 220         const int lineMove = lineWidth;
 221         const int copyLen = aUpdateRect.Width();
 222
 223         for(int i = 0; i < height; i++) //source is always smaller
 224         {
 225                 iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen);
 226                 source += lineMove;
 227                 targetPtr += scanLineWidth;
 228         }
 229 }
 230
 231 /////////////////////////////////////////////////////////////////////////////////////////////////////
 232
 233 CDsa* CDsa::CreateL(RWsSession& aSession)
 234 {
 235         return new CBitmapSurface<CDsaBase>(aSession);
 236 }
 237
 238 void CDsa::Free()
 239 {
 240 }
 241
 242 CDsa::~CDsa()
 243 {
 244         delete[] iLut256;
 245 }
 246
 247 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& /*aDevice*/)
 248 {
 249         if(iLut256 == NULL)
 250                 iLut256 = new TUint32[256];
 251         iTargetMode = aWindow.DisplayMode();
 252         iTargetBpp = BytesPerPixel(DisplayMode());
 253         iWindow = &aWindow;
 254 }
 255
 256 void CDsa::DoBlt(CFbsBitmap& /*aBmp*/)
 257 {
 258 }
 259
 260 int CDsa::SetPalette(int aFirst, int aCount, TUint32* aPalette)
 261 {
 262         if(iLut256 == NULL)
 263                 return KErrNotFound;
 264         for(int i = aFirst; i < aFirst + aCount; i++)
 265         {
 266                 iLut256[i] = aPalette[i];
 267         }
 268         return KErrNone;
 269 }
 270
 271 CDsa::CDsa(RWsSession& aSession) :
 272         iRunning(false),
 273         iSession(aSession)
 274
 275 {
 276         iCFTable[0] = CopyMem;
 277         iCFTable[1] = Copy256;
 278         iCFTable[2] = CopySlow;
 279 }
 280
 281 RWsSession& CDsa::Session()
 282 {
 283         return iSession;
 284 }
 285
 286 TUint8* CDsa::LockHwSurface()
 287 {
 288         return LockSurface();
 289 }
 290
 291 int CDsa::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 292 {
 293         iSourceMode = aMode;
 294         iSourceBpp = BytesPerPixel(aMode);
 295
 296         TRAPD(err, CreateSurfaceL(aSize));
 297         if(err != KErrNone)
 298                 return err;
 299
 300         SetCopyFunction();
 301
 302         return KErrNone;
 303 }
 304
 305 void CDsa::ClipCopy(TUint8* aTarget,
 306                 const TUint8* aSource,
 307                 const TRect& aUpdateRect,
 308                 const TRect& aSourceRect) const
 309 {
 310         const TDsa dsa(*this);
 311         switch(iSourceBpp)
 312         {
 313                 case 1:
 314                         ::ClipCopy<TUint32, TUint8>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
 315                         break;
 316                 case 2:
 317                         ::ClipCopy<TUint32, TUint16>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
 318                         break;
 319                 case 4:
 320                         ::ClipCopy<TUint32, TUint32>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
 321                         break;
 322         }
 323 }
 324
 325 void CDsa::SetCopyFunction()
 326 {
 327         if(iSourceMode == DisplayMode())
 328                 iCopyFunction = iCFTable[0];
 329         else if(iSourceMode == EColor256)
 330                 iCopyFunction = iCFTable[1];
 331         else
 332                 iCopyFunction = iCFTable[2];
 333 }
 334
 335 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)
 336 {
 337         if(iTargetAddr == NULL)
 338         {
 339                 iTargetAddr = LockHwSurface();
 340         }
 341
 342         TUint8* target = iTargetAddr;
 343         if(target == NULL)
 344                 return EFalse;
 345
 346         TRect sourceRect = aRect;
 347         TRect updateRect = aUpdateRect;
 348
 349         if(iSourceMode != DisplayMode() || aRect != aUpdateRect)
 350         {
 351                 ClipCopy(target, aBits, aUpdateRect, aRect);
 352         }
 353         else
 354         {
 355                 const int byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored
 356                 memcpy(target, aBits, byteCount);
 357         }
 358
 359         return ETrue;
 360 }
 361
 362 void CDsa::UpdateSwSurface()
 363 {
 364         iTargetAddr = NULL;
 365         UnlockHwSurface();      //could be faster if does not use AO, but only check status before redraw, then no context switch needed
 366 }
 367
 368 void CDsa::Stop()
 369 {
 370         iRunning = false;
 371 }
 372
 373 void CDsa::Start()
 374 {
 375         iRunning = true;
 376 }
 377
 378 RWindow* CDsa::Window()
 379 {
 380         return iWindow;
 381 }
 382
 383 CDsa* CDsa::CreateGlesDsaL()
 384 {
 385         CDsa* dsa = new CDsaGles(Session());
 386         CWsScreenDevice* dummy = NULL;
 387         dsa->ConstructL(*Window(), *dummy);
 388         Free();
 389         delete this;
 390         return dsa;
 391 }
 392
 393 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 394
 395 void CDsa::Copy256(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, int aBytes)
 396 {
 397         TUint32* target = aTarget;
 398         const TUint32* endt = target + aBytes;
 399         const TUint8* source = aSource;
 400         while(target < endt)
 401         {
 402                 *target++ = aDsa.iLut256[*source++];
 403         }
 404 }
 405
 406 void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, int aBytes)
 407 {
 408         memcpy(aTarget, aSource, aBytes << 2);
 409 }
 410
 411 class MRgbCopy
 412 {
 413         public:
 414                 virtual void Copy(TUint32* aTarget, const TUint8* aSource, int aBytes) = 0;
 415 };
 416
 417 template <class T>
 418 class TRgbCopy : public MRgbCopy
 419 {
 420         public:
 421                 TRgbCopy(TDisplayMode aMode);
 422                 void* operator new(TUint aBytes, void* aMem);
 423                 void Copy(TUint32* aTarget, const TUint8* aSource, int aBytes);
 424                 static TUint32 Gray256(const TUint8& aPixel);
 425                 static TUint32 Color256(const TUint8& aPixel);
 426                 static TUint32 Color4K(const TUint16& aPixel);
 427                 static TUint32 Color64K(const TUint16& aPixel);
 428                 static TUint32 Color16M(const TUint32& aPixel);
 429                 static TUint32 Color16MU(const TUint32& aPixel);
 430                 static TUint32 Color16MA(const TUint32& aPixel);
 431         private:
 432                 typedef TUint32 (*TRgbFunc) (const T& aValue);
 433                 TRgbFunc iFunc;
 434 };
 435
 436 template <class T>
 437 void* TRgbCopy<T>::operator new(TUint /*aBytes*/, void* aMem)
 438 {
 439         return aMem;
 440 }
 441
 442 template <class T>
 443 TRgbCopy<T>::TRgbCopy(TDisplayMode aMode)
 444 {
 445         switch(aMode)
 446         {
 447                 case EGray256 : iFunc = (TRgbFunc) Gray256; break;
 448                 case EColor256 : iFunc =  (TRgbFunc) Color256; break;
 449                 case EColor4K : iFunc =  (TRgbFunc) Color4K; break;
 450                 case EColor64K : iFunc =  (TRgbFunc) Color64K; break;
 451                 case EColor16M : iFunc =  (TRgbFunc) Color16M; break;
 452                 case EColor16MU : iFunc =  (TRgbFunc) Color16MU; break;
 453                 case EColor16MA : iFunc =  (TRgbFunc) Color16MA; break;
 454                 default:
 455                                   PANIC(KErrNotSupported);
 456         }
 457 }
 458
 459 template <class T>
 460 void TRgbCopy<T>::Copy(TUint32* aTarget, const TUint8* aSource, int aBytes)
 461 {
 462         const T* source = reinterpret_cast<const T*>(aSource);
 463         TUint32* target = aTarget;
 464         TUint32* endt = target + aBytes;
 465
 466         while(target < endt)
 467         {
 468                 const T value = *source++;
 469                 *target++ = iFunc(value);
 470         }
 471 }
 472
 473 template <class T>
 474 TUint32 TRgbCopy<T>::Gray256(const TUint8& aPixel)
 475 {
 476         const TUint32 px = aPixel << 16 | aPixel << 8 | aPixel;
 477         return px;
 478 }
 479
 480 template <class T>
 481 TUint32 TRgbCopy<T>::Color256(const TUint8& aPixel)
 482 {
 483         return TRgb::Color256(aPixel).Value();
 484 }
 485
 486 template <class T>
 487 TUint32 TRgbCopy<T>::Color4K(const TUint16& aPixel)
 488 {
 489         TUint32 col = (aPixel & 0xF00) << 12;
 490         col |= (aPixel & 0xF00) << 8;
 491
 492         col |= (aPixel & 0x0F0) << 8;
 493         col |= (aPixel & 0x0F0);
 494
 495         col |= (aPixel & 0x00F) << 4;
 496         col |= (aPixel & 0x00F);
 497
 498         return col;
 499 }
 500
 501 template <class T>
 502 TUint32 TRgbCopy<T>::Color64K(const TUint16& aPixel)
 503 {
 504         TUint32 col = (aPixel & 0xF800)<< 8;
 505         col |= (aPixel & 0xE000) << 3;
 506
 507         col |= (aPixel & 0x07E0) << 5;
 508         col |= (aPixel & 0xC0) >> 1;
 509
 510         col |= (aPixel & 0x07E0) << 3;
 511         col |= (aPixel & 0x1C) >> 2;
 512
 513         return col;
 514 }
 515
 516 template <class T>
 517 TUint32 TRgbCopy<T>::Color16M(const TUint32& aPixel)
 518 {
 519         return TRgb::Color16M(aPixel).Value();
 520 }
 521
 522 template <class T>
 523 TUint32 TRgbCopy<T>::Color16MU(const TUint32& aPixel)
 524 {
 525         return TRgb::Color16MU(aPixel).Value();
 526 }
 527
 528 template <class T>
 529 TUint32 TRgbCopy<T>::Color16MA(const TUint32& aPixel)
 530 {
 531         return TRgb::Color16MA(aPixel).Value();
 532 }
 533
 534 typedef TUint64 TStackMem;
 535
 536 static MRgbCopy* GetCopy(void* mem, TDisplayMode aMode)
 537 {
 538         if(aMode == EColor256 || aMode == EGray256)
 539         {
 540                 return new (mem) TRgbCopy<TUint8>(aMode);
 541         }
 542         if(aMode == EColor4K || aMode == EColor64K)
 543         {
 544                 return new (mem) TRgbCopy<TUint16>(aMode);
 545         }
 546         if(aMode == EColor16M || aMode == EColor16MU || aMode == EColor16MA)
 547         {
 548                 return new (mem) TRgbCopy<TUint32>(aMode);
 549         }
 550         PANIC(KErrNotSupported);
 551         return NULL;
 552 }
 553
 554 void CDsa::CopySlow(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, int aBytes)
 555 {
 556         TStackMem mem = 0;
 557         GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes);
 558 }