src/video/symbian/dsa.cpp

   1 #include "dsa.h"
   2 #include "sdlepocapi.h"
   3 #include <cdsb.h>
   4 #include <basched.h>
   5
   6 class CDsaGles : public CDsa
   7 {
   8         public:
   9                 CDsaGles(RWsSession& aSession) : CDsa(aSession) {}
  10
  11         private:
  12                 TUint8* LockSurface() { return NULL; }
  13                 void UnlockHwSurface() {}
  14                 void CreateSurfaceL(const TSize& aSize) {}
  15 };
  16
  17 //////////////////////////////////////////////////////////////////////
  18
  19 class CDsaBase : public CDsa, public MDirectScreenAccess
  20 {
  21         public:
  22                 CDsaBase(RWsSession& aSession) : CDsa(aSession), iBmp( NULL ) { m_updateWholeScreen = false; }
  23                 ~CDsaBase();
  24
  25         protected:
  26                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
  27                 void Stop();
  28
  29                 CDirectScreenAccess*  iDsa;
  30
  31         private:
  32                 void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);
  33                 void Restart(RDirectScreenAccess::TTerminationReasons aReason);
  34                 void RestartL();
  35
  36                 void Free();
  37
  38                 TUint8* LockSurface();
  39                 void UnlockHwSurface();
  40                 void CreateSurfaceL(const TSize& aSize);
  41
  42                 CFbsBitmap* iBmp;
  43 };
  44
  45 void CDsaBase::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
  46 {
  47         CDsa::ConstructL(aWindow, aDevice);
  48         if(iDsa != NULL)
  49         {
  50                 iDsa->Cancel();
  51                 delete iDsa;
  52                 iDsa = NULL;
  53         }
  54
  55         iDsa = CDirectScreenAccess::NewL(Session(), aDevice, aWindow, *this);
  56         RestartL();
  57 }
  58
  59 CDsaBase::~CDsaBase()
  60 {
  61         if(iDsa != NULL)
  62         {
  63                 iDsa->Cancel();
  64         }
  65         delete iDsa;
  66 }
  67
  68 void CDsaBase::RestartL()
  69 {
  70         iDsa->StartL();
  71         iDsa->Gc()->SetClippingRegion(iDsa->DrawingRegion());
  72
  73         Start();
  74 }
  75
  76 void CDsaBase::Free()
  77 {
  78         delete iBmp;
  79         iBmp = NULL;
  80 }
  81
  82 TUint8* CDsaBase::LockSurface()
  83 {
  84         iBmp->LockHeap();
  85         return (TUint8*)iBmp->DataAddress();
  86 }
  87
  88 void CDsaBase::UnlockHwSurface()
  89 {
  90         iBmp->UnlockHeap();
  91         iDsa->Gc()->BitBlt(TPoint(0, 0), iBmp);
  92         iDsa->ScreenDevice()->Update();
  93 }
  94
  95 void CDsaBase::CreateSurfaceL(const TSize& aSize)
  96 {
  97         Free();
  98         iBmp = new CFbsBitmap();
  99         User::LeaveIfError(iBmp->Create(aSize, EColor64K));
 100 }
 101
 102 void CDsaBase::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 103 {
 104         Stop();
 105 }
 106
 107 void CDsaBase::Restart(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 108 {
 109         TRAPD(err, RestartL());
 110         if(err == KLeaveExit)
 111         {
 112                 Stop();
 113         }
 114         else
 115         {
 116                 PANIC_IF_ERROR(err);
 117         }
 118 }
 119
 120 void CDsaBase::Stop()
 121 {
 122         CDsa::Stop();
 123         iDsa->Cancel();
 124 }
 125
 126 ///////////////////////////////////////////////////////////////////////
 127
 128 void ClipCopy1(const CDsa& iDsa, TUint8* aTarget,
 129                 const TUint8* aSource,
 130                 const TRect& aUpdateRect,
 131                 const TRect& aSourceRect)
 132 {
 133         const TUint8* source = (const TUint8*)aSource;
 134         const int lineWidth = aSourceRect.Width();
 135
 136         source += (aUpdateRect.iTl.iY * lineWidth);
 137         const int sourceStartOffset = aUpdateRect.iTl.iX;
 138         source += sourceStartOffset;
 139
 140         TUint16* targetPtr = (TUint16*)aTarget;
 141
 142         int scanLineWidth = aSourceRect.iBr.iX;
 143
 144         targetPtr += aUpdateRect.iTl.iY * scanLineWidth;
 145         const int targetStartOffset = aUpdateRect.iTl.iX;
 146
 147         targetPtr += targetStartOffset;
 148
 149         const int height = aUpdateRect.Height();
 150
 151         const int copyLen = aUpdateRect.Width();
 152         const int lineMove = lineWidth - copyLen;
 153         scanLineWidth -= copyLen;
 154
 155         for(int i = 0; i < height; i++) //source is always smaller
 156         {
 157                 int w = copyLen;
 158                 do
 159                 {
 160                         *targetPtr++ = iDsa.iLut256[*source++];
 161                 }
 162                 while(--w);
 163
 164                 source += lineMove;
 165                 targetPtr += scanLineWidth;
 166         }
 167 }
 168
 169 void ClipCopy2(const CDsa& iDsa, TUint8* aTarget,
 170                 const TUint8* aSource,
 171                 const TRect& aUpdateRect,
 172                 const TRect& aSourceRect)
 173 {
 174         const TUint16* source = (const TUint16*)aSource;
 175         const int lineWidth = aSourceRect.Width();
 176
 177         source += (aUpdateRect.iTl.iY * lineWidth);
 178         const int sourceStartOffset = aUpdateRect.iTl.iX;
 179         source += sourceStartOffset;
 180
 181         TUint16* targetPtr = (TUint16*)aTarget;
 182
 183         const int scanLineWidth = aSourceRect.iBr.iX;
 184
 185         targetPtr += aUpdateRect.iTl.iY * scanLineWidth;
 186         const int targetStartOffset = aUpdateRect.iTl.iX;
 187
 188         targetPtr += targetStartOffset;
 189
 190         const int height = aUpdateRect.Height();
 191
 192         const int lineMove = lineWidth;
 193         const int copyLen = aUpdateRect.Width() * 2;
 194
 195         for(int i = 0; i < height; i++) //source is always smaller
 196         {
 197                 memcpy( targetPtr, source, copyLen );
 198                 source += lineMove;
 199                 targetPtr += scanLineWidth;
 200         }
 201 }
 202
 203 void ClipCopy4(const CDsa& iDsa, TUint8* aTarget,
 204                 const TUint8* aSource,
 205                 const TRect& aUpdateRect,
 206                 const TRect& aSourceRect)
 207 {
 208         const TUint32* source = (const TUint32*)aSource;
 209         const int lineWidth = aSourceRect.Width();
 210
 211         source += (aUpdateRect.iTl.iY * lineWidth);
 212         const int sourceStartOffset = aUpdateRect.iTl.iX;
 213         source += sourceStartOffset;
 214
 215         TUint16* targetPtr = (TUint16*)aTarget;
 216
 217         int scanLineWidth = aSourceRect.iBr.iX;
 218
 219         targetPtr += aUpdateRect.iTl.iY * scanLineWidth;
 220         const int targetStartOffset = aUpdateRect.iTl.iX;
 221
 222         targetPtr += targetStartOffset;
 223
 224         const int height = aUpdateRect.Height();
 225
 226         const int copyLen = aUpdateRect.Width();
 227         const int lineMove = lineWidth - copyLen;
 228         scanLineWidth -= copyLen;
 229
 230         for(int i = 0; i < height; i++) //source is always smaller
 231         {
 232                 int w = copyLen;
 233                 do
 234                 {
 235                         *targetPtr++ =
 236                                 ( ( *source & 0xF80000 ) >> 8 ) |
 237                                 ( ( *source & 0x00FC00 ) >> 5 ) |
 238                                 ( ( *source & 0x0000F8 ) >> 3 );
 239                         source++;
 240                 }
 241                 while(--w);
 242
 243                 source += lineMove;
 244                 targetPtr += scanLineWidth;
 245         }
 246 }
 247
 248 /////////////////////////////////////////////////////////////////////////////////////////////////////
 249
 250 CDsa* CDsa::CreateL(RWsSession& aSession)
 251 {
 252         return new CDsaBase(aSession);
 253 }
 254
 255 void CDsa::Free()
 256 {
 257 }
 258
 259 CDsa::~CDsa()
 260 {
 261         delete[] iLut256;
 262 }
 263
 264 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& /*aDevice*/)
 265 {
 266         if(iLut256 == NULL)
 267                 iLut256 = new TUint32[256];
 268         iWindow = &aWindow;
 269 }
 270
 271 int CDsa::SetPalette(int aFirst, int aCount, TUint32* aPalette)
 272 {
 273         if(iLut256 == NULL)
 274                 return KErrNotFound;
 275         for(int i = aFirst; i < aFirst + aCount; i++)
 276         {
 277                 iLut256[i] = aPalette[i];
 278         }
 279         return KErrNone;
 280 }
 281
 282 CDsa::CDsa(RWsSession& aSession) :
 283         iRunning(false),
 284         iSession(aSession)
 285
 286 {
 287 }
 288
 289 RWsSession& CDsa::Session()
 290 {
 291         return iSession;
 292 }
 293
 294 int CDsa::AllocSurface(const TSize& aSize, int bpp)
 295 {
 296         iSourceBpp = bpp;
 297
 298         TRAPD(err, CreateSurfaceL(aSize));
 299         if(err != KErrNone)
 300                 return err;
 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         switch(iSourceBpp)
 311         {
 312                 case 1:
 313                         ::ClipCopy1(*this, aTarget, aSource, aUpdateRect, aSourceRect);
 314                         break;
 315                 case 2:
 316                         ::ClipCopy2(*this, aTarget, aSource, aUpdateRect, aSourceRect);
 317                         break;
 318                 case 4:
 319                         ::ClipCopy4(*this, aTarget, aSource, aUpdateRect, aSourceRect);
 320                         break;
 321         }
 322 }
 323
 324 bool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)
 325 {
 326         if(iTargetAddr == NULL)
 327         {
 328                 iTargetAddr = LockSurface();
 329         }
 330
 331         TUint8* target = iTargetAddr;
 332         if(target == NULL)
 333                 return false;
 334
 335         TRect sourceRect = aRect;
 336         TRect updateRect = aUpdateRect;
 337
 338         ClipCopy(target, aBits, aUpdateRect, aRect);
 339
 340         return true;
 341 }
 342
 343 void CDsa::UpdateSwSurface()
 344 {
 345         iTargetAddr = NULL;
 346         UnlockHwSurface();
 347 }
 348
 349 void CDsa::Stop()
 350 {
 351         iRunning = false;
 352 }
 353
 354 void CDsa::Start()
 355 {
 356         iRunning = true;
 357 }
 358
 359 RWindow* CDsa::Window()
 360 {
 361         return iWindow;
 362 }
 363
 364 CDsa* CDsa::CreateGlesDsaL()
 365 {
 366         CDsa* dsa = new CDsaGles(Session());
 367         CWsScreenDevice* dummy = NULL;
 368         dsa->ConstructL(*Window(), *dummy);
 369         Free();
 370         delete this;
 371         return dsa;
 372 }
 373
 374 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 375
 376 void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, int aBytes)
 377 {
 378         memcpy(aTarget, aSource, aBytes << 2);
 379 }