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