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