diff options
author | Franklin Wei <git@fwei.tk> | 2017-01-21 15:18:31 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2017-12-23 21:01:26 -0500 |
commit | a855d6202536ff28e5aae4f22a0f31d8f5b325d0 (patch) | |
tree | 8c75f224dd64ed360505afa8843d016b0d75000b /apps/plugins/sdl/src/video/symbian/EKA2/dsa.cpp | |
parent | 01c6dcf6c7b9bb1ad2fa0450f99bacc5f3d3e04b (diff) | |
download | rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.tar.gz rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.zip |
Port of Duke Nukem 3D
This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL
for Rockbox.
Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9
Diffstat (limited to 'apps/plugins/sdl/src/video/symbian/EKA2/dsa.cpp')
-rw-r--r-- | apps/plugins/sdl/src/video/symbian/EKA2/dsa.cpp | 1505 |
1 files changed, 1505 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/symbian/EKA2/dsa.cpp b/apps/plugins/sdl/src/video/symbian/EKA2/dsa.cpp new file mode 100644 index 0000000000..07b1ab4137 --- /dev/null +++ b/apps/plugins/sdl/src/video/symbian/EKA2/dsa.cpp | |||
@@ -0,0 +1,1505 @@ | |||
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> | ||
15 | NONSHARABLE_CLASS(CBitmapSurface) : public T | ||
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) : | ||
833 | iStateFlags(0), | ||
834 | iSession(aSession) | ||
835 | |||
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 | ||