diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/symbian/EKA2/dsa_old.cpp')
-rw-r--r-- | apps/plugins/sdl/src/video/symbian/EKA2/dsa_old.cpp | 1075 |
1 files changed, 1075 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/symbian/EKA2/dsa_old.cpp b/apps/plugins/sdl/src/video/symbian/EKA2/dsa_old.cpp new file mode 100644 index 0000000000..7e32de2cfd --- /dev/null +++ b/apps/plugins/sdl/src/video/symbian/EKA2/dsa_old.cpp | |||
@@ -0,0 +1,1075 @@ | |||
1 | #include "dsa.h" | ||
2 | #include "sdlepocapi.h" | ||
3 | #include <cdsb.h> | ||
4 | |||
5 | LOCAL_C TInt BytesPerPixel(TDisplayMode aMode) | ||
6 | { | ||
7 | return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1; | ||
8 | } | ||
9 | |||
10 | |||
11 | //////////////////////////////////////////////////////////////////////////////////////////////// | ||
12 | |||
13 | NONSHARABLE_CLASS(CDsaA) : public CDsa | ||
14 | { | ||
15 | public: | ||
16 | CDsaA(RWsSession& aSession); | ||
17 | private: | ||
18 | ~CDsaA(); | ||
19 | TUint8* LockSurface(); | ||
20 | void UnlockHWSurfaceRequestComplete(); | ||
21 | void UnlockHwSurface(); | ||
22 | void CreateSurfaceL(); | ||
23 | void Wipe(TInt aLength); | ||
24 | void RecreateL(); | ||
25 | void Free(); | ||
26 | TInt ExternalUpdate() {return 0;} | ||
27 | private: | ||
28 | CFbsBitmap* iBmp; | ||
29 | }; | ||
30 | |||
31 | |||
32 | CDsaA::CDsaA(RWsSession& aSession) : CDsa(aSession) | ||
33 | { | ||
34 | } | ||
35 | |||
36 | void CDsaA::Free() | ||
37 | { | ||
38 | delete iBmp; | ||
39 | iBmp = NULL; | ||
40 | } | ||
41 | |||
42 | CDsaA::~CDsaA() | ||
43 | { | ||
44 | __ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady)); | ||
45 | } | ||
46 | |||
47 | TUint8* CDsaA::LockSurface() | ||
48 | { | ||
49 | iBmp->LockHeap(); | ||
50 | return reinterpret_cast<TUint8*>(iBmp->DataAddress()); | ||
51 | } | ||
52 | |||
53 | void CDsaA::UnlockHWSurfaceRequestComplete() | ||
54 | { | ||
55 | PANIC(KErrNotSupported); | ||
56 | } | ||
57 | |||
58 | void CDsaA::UnlockHwSurface() | ||
59 | { | ||
60 | iBmp->UnlockHeap(); | ||
61 | SetUpdating(EFalse); | ||
62 | Dsa().Gc()->BitBlt(HwRect().iTl, iBmp); | ||
63 | Dsa().ScreenDevice()->Update(); | ||
64 | } | ||
65 | |||
66 | void CDsaA::CreateSurfaceL() | ||
67 | { | ||
68 | delete iBmp; | ||
69 | iBmp = NULL; | ||
70 | iBmp = new (ELeave) CFbsBitmap(); | ||
71 | User::LeaveIfError(iBmp->Create(HwRect().Size(), DisplayMode())); | ||
72 | } | ||
73 | |||
74 | void CDsaA::Wipe(TInt aLength) //dont call in drawing | ||
75 | { | ||
76 | iBmp->LockHeap(); | ||
77 | Mem::FillZ(iBmp->DataAddress(), aLength); | ||
78 | iBmp->UnlockHeap(); | ||
79 | } | ||
80 | |||
81 | void CDsaA::RecreateL() | ||
82 | { | ||
83 | } | ||
84 | |||
85 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | ||
86 | |||
87 | NONSHARABLE_CLASS(MDsbObs) | ||
88 | { | ||
89 | public: | ||
90 | virtual void SurfaceReady() = 0; | ||
91 | virtual CDirectScreenBitmap& Dsb() = 0; | ||
92 | }; | ||
93 | |||
94 | NONSHARABLE_CLASS(CDsbSurface) : public CActive | ||
95 | { | ||
96 | public: | ||
97 | CDsbSurface(MDsbObs& aDsb); | ||
98 | TUint8* Address(); | ||
99 | void Complete(); | ||
100 | ~CDsbSurface(); | ||
101 | private: | ||
102 | void RunL(); | ||
103 | void DoCancel(); | ||
104 | private: | ||
105 | MDsbObs& iDsb; | ||
106 | TUint8* iAddress; | ||
107 | }; | ||
108 | |||
109 | CDsbSurface::CDsbSurface(MDsbObs& aDsb) : CActive(CActive::EPriorityHigh) , iDsb(aDsb) | ||
110 | { | ||
111 | CActiveScheduler::Add(this); | ||
112 | } | ||
113 | |||
114 | CDsbSurface::~CDsbSurface() | ||
115 | { | ||
116 | Cancel(); | ||
117 | } | ||
118 | |||
119 | void CDsbSurface::Complete() | ||
120 | { | ||
121 | if(iAddress != NULL && !IsActive()) | ||
122 | { | ||
123 | iAddress = NULL; | ||
124 | SetActive(); | ||
125 | iDsb.Dsb().EndUpdate(iStatus); | ||
126 | } | ||
127 | } | ||
128 | |||
129 | TUint8* CDsbSurface::Address() | ||
130 | { | ||
131 | if(iAddress == NULL && !IsActive()) | ||
132 | { | ||
133 | TAcceleratedBitmapInfo info; | ||
134 | if(KErrNone == iDsb.Dsb().BeginUpdate(info)) | ||
135 | iAddress = info.iAddress; | ||
136 | } | ||
137 | return iAddress; | ||
138 | } | ||
139 | |||
140 | void CDsbSurface::RunL() | ||
141 | { | ||
142 | iDsb.SurfaceReady(); | ||
143 | } | ||
144 | |||
145 | void CDsbSurface::DoCancel() | ||
146 | { | ||
147 | //empty | ||
148 | } | ||
149 | |||
150 | NONSHARABLE_CLASS(CDsaB) : public CDsa, public MDsbObs | ||
151 | { | ||
152 | public: | ||
153 | CDsaB(RWsSession& aSession); | ||
154 | private: | ||
155 | ~CDsaB(); | ||
156 | TUint8* LockSurface(); | ||
157 | void UnlockHWSurfaceRequestComplete(); | ||
158 | void UnlockHwSurface(); | ||
159 | void CreateSurfaceL(); | ||
160 | void Wipe(TInt aLength); | ||
161 | void RecreateL(); | ||
162 | void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice); | ||
163 | void Free(); | ||
164 | CDirectScreenBitmap& Dsb(); | ||
165 | void SurfaceReady(); | ||
166 | TInt ExternalUpdate() {return 0;} | ||
167 | private: | ||
168 | CDsbSurface* iSurface1; | ||
169 | CDsbSurface* iSurface2; | ||
170 | CDirectScreenBitmap* iDsb; | ||
171 | }; | ||
172 | |||
173 | CDsaB::CDsaB(RWsSession& aSession) : CDsa(aSession) | ||
174 | { | ||
175 | } | ||
176 | |||
177 | void CDsaB::Free() | ||
178 | { | ||
179 | } | ||
180 | |||
181 | void CDsaB::UnlockHWSurfaceRequestComplete() | ||
182 | { | ||
183 | iSurface1->Complete(); | ||
184 | iSurface2->Complete(); | ||
185 | } | ||
186 | |||
187 | void CDsaB::CreateSurfaceL() | ||
188 | { | ||
189 | } | ||
190 | |||
191 | void CDsaB::Wipe(TInt aLength) //dont call in drawing | ||
192 | { | ||
193 | TUint8* addr = LockSurface(); | ||
194 | if(addr != NULL) | ||
195 | { | ||
196 | Mem::FillZ(addr, aLength); | ||
197 | UnlockHwSurface(); | ||
198 | } | ||
199 | } | ||
200 | |||
201 | void CDsaB::UnlockHwSurface() | ||
202 | { | ||
203 | EpocSdlEnv::Request(CDsa::ERequestUpdate); | ||
204 | } | ||
205 | |||
206 | TUint8* CDsaB::LockSurface() | ||
207 | { | ||
208 | TUint8* addr = iSurface1->Address(); | ||
209 | if(addr == NULL) | ||
210 | addr = iSurface2->Address(); | ||
211 | SetUpdating(addr == NULL); | ||
212 | return addr; | ||
213 | } | ||
214 | |||
215 | void CDsaB::SurfaceReady() | ||
216 | { | ||
217 | SetUpdating(EFalse); | ||
218 | } | ||
219 | |||
220 | CDirectScreenBitmap& CDsaB::Dsb() | ||
221 | { | ||
222 | return *iDsb; | ||
223 | } | ||
224 | |||
225 | void CDsaB::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice) | ||
226 | { | ||
227 | if(iDsb == NULL) | ||
228 | iDsb = CDirectScreenBitmap::NewL(); | ||
229 | CDsa::ConstructL(aWindow, aDevice); | ||
230 | iSurface1 = new (ELeave) CDsbSurface(*this); | ||
231 | iSurface2 = new (ELeave) CDsbSurface(*this); | ||
232 | } | ||
233 | |||
234 | CDsaB::~CDsaB() | ||
235 | { | ||
236 | delete iSurface1; | ||
237 | delete iSurface2; | ||
238 | delete iDsb; | ||
239 | } | ||
240 | |||
241 | void CDsaB::RecreateL() | ||
242 | { | ||
243 | iDsb->Close(); | ||
244 | iDsb->Create(HwRect(), CDirectScreenBitmap::EDoubleBuffer); | ||
245 | } | ||
246 | |||
247 | ///////////////////////////////////////////////////////////////////////////////////////////////////// | ||
248 | |||
249 | |||
250 | TSize CDsa::WindowSize() const | ||
251 | { | ||
252 | TSize size = HwRect().Size(); | ||
253 | if(iStateFlags & EOrientation90) | ||
254 | { | ||
255 | const TInt tmp = size.iWidth; | ||
256 | size.iWidth = size.iHeight; | ||
257 | size.iHeight = tmp; | ||
258 | } | ||
259 | return size; | ||
260 | } | ||
261 | |||
262 | void CDsa::SetSuspend() | ||
263 | { | ||
264 | iStateFlags |= ESdlThreadSuspend; | ||
265 | } | ||
266 | |||
267 | void CDsa::ReleaseStop() | ||
268 | { | ||
269 | iStateFlags &= ~ESdlThreadExplicitStop; | ||
270 | } | ||
271 | |||
272 | |||
273 | TBool CDsa::Stopped() const | ||
274 | { | ||
275 | return (iStateFlags & ESdlThreadExplicitStop); | ||
276 | } | ||
277 | |||
278 | void CDsa::SetOrientation(CSDL::TOrientationMode aOrientation) | ||
279 | { | ||
280 | TInt flags = 0; | ||
281 | switch(aOrientation) | ||
282 | { | ||
283 | case CSDL::EOrientation90: | ||
284 | flags = EOrientation90; | ||
285 | break; | ||
286 | case CSDL::EOrientation180: | ||
287 | flags = EOrientation180; | ||
288 | break; | ||
289 | case CSDL::EOrientation270: | ||
290 | flags = EOrientation90 | EOrientation180; | ||
291 | break; | ||
292 | case CSDL::EOrientation0: | ||
293 | flags = 0; | ||
294 | break; | ||
295 | } | ||
296 | if(flags != (iStateFlags & EOrientationFlags)) | ||
297 | { | ||
298 | iStateFlags |= EOrientationChanged; | ||
299 | iNewFlags = flags; //cannot be set during drawing... | ||
300 | } | ||
301 | } | ||
302 | |||
303 | CDsa::~CDsa() | ||
304 | { | ||
305 | if(iDsa != NULL) | ||
306 | { | ||
307 | iDsa->Cancel(); | ||
308 | } | ||
309 | delete iDsa; | ||
310 | User::Free(iLut256); | ||
311 | } | ||
312 | |||
313 | void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice) | ||
314 | { | ||
315 | if(iDsa != NULL) | ||
316 | { | ||
317 | iDsa->Cancel(); | ||
318 | delete iDsa; | ||
319 | iDsa = NULL; | ||
320 | } | ||
321 | |||
322 | |||
323 | iDsa = CDirectScreenAccess::NewL( | ||
324 | iSession, | ||
325 | aDevice, | ||
326 | aWindow, | ||
327 | *this); | ||
328 | |||
329 | if(iLut256 == NULL) | ||
330 | iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32)); | ||
331 | iTargetMode = aWindow.DisplayMode(); | ||
332 | iTargetBpp = BytesPerPixel(DisplayMode()); | ||
333 | iTargetRect = TRect(aWindow.Position(), aWindow.Size()); | ||
334 | RestartL(); | ||
335 | } | ||
336 | |||
337 | void CDsa::LockPalette(TBool aLock) | ||
338 | { | ||
339 | if(aLock) | ||
340 | iStateFlags |= EPaletteLocked; | ||
341 | else | ||
342 | iStateFlags &= ~EPaletteLocked; | ||
343 | } | ||
344 | TInt CDsa::SetPalette(TInt aFirst, TInt aCount, TUint32* aPalette) | ||
345 | { | ||
346 | if(iLut256 == NULL) | ||
347 | return KErrNotFound; | ||
348 | const TInt count = aCount - aFirst; | ||
349 | if(count > 256) | ||
350 | return KErrArgument; | ||
351 | if(iStateFlags & EPaletteLocked) | ||
352 | return KErrNone; | ||
353 | for(TInt i = aFirst; i < count; i++) //not so busy here:-) | ||
354 | { | ||
355 | iLut256[i] = aPalette[i]; | ||
356 | } | ||
357 | return KErrNone; | ||
358 | } | ||
359 | |||
360 | |||
361 | |||
362 | |||
363 | void CDsa::RestartL() | ||
364 | { | ||
365 | //const TBool active = iDsa->IsActive(); | ||
366 | |||
367 | //if(!active) | ||
368 | iDsa->StartL(); | ||
369 | |||
370 | RRegion* r = iDsa->DrawingRegion(); | ||
371 | iDsa->Gc()->SetClippingRegion(r); | ||
372 | TRect rect = r->BoundingRect(); | ||
373 | |||
374 | if(rect.IsEmpty()) | ||
375 | { | ||
376 | return; | ||
377 | } | ||
378 | |||
379 | iScreenRect = rect; //to ensure properly set, albeit may not(?) match to value SDL has - therefore may has to clip | ||
380 | |||
381 | RecreateL(); | ||
382 | |||
383 | iStateFlags |= ERunning; | ||
384 | // iScanLineWidth = iTargetBpp * HwRect().Width(); | ||
385 | ReleaseStop(); | ||
386 | if(iStateFlags & ESdlThreadSuspend) | ||
387 | { | ||
388 | EpocSdlEnv::Resume(); | ||
389 | iStateFlags &= ~ ESdlThreadSuspend; | ||
390 | } | ||
391 | } | ||
392 | |||
393 | CDsa::CDsa(RWsSession& aSession) : | ||
394 | iSession(aSession), | ||
395 | iStateFlags(0) | ||
396 | { | ||
397 | // CActiveScheduler::Add(this); | ||
398 | iCFTable[0] = CopyMem; | ||
399 | iCFTable[1] = CopyMemFlipReversed; | ||
400 | iCFTable[2] = CopyMemReversed; | ||
401 | iCFTable[3] = CopyMemFlip; | ||
402 | |||
403 | iCFTable[4] = Copy256; | ||
404 | iCFTable[5] = Copy256FlipReversed; | ||
405 | iCFTable[6] = Copy256Reversed; | ||
406 | iCFTable[7] = Copy256Flip; | ||
407 | |||
408 | |||
409 | iCFTable[8] = CopySlow; | ||
410 | iCFTable[9] = CopySlowFlipReversed; | ||
411 | iCFTable[10] = CopySlowReversed; | ||
412 | iCFTable[11] = CopySlowFlip; | ||
413 | } | ||
414 | |||
415 | RWsSession& CDsa::Session() | ||
416 | { | ||
417 | return iSession; | ||
418 | } | ||
419 | |||
420 | |||
421 | |||
422 | TUint8* CDsa::LockHwSurface() | ||
423 | { | ||
424 | if((iStateFlags & EUpdating) == 0) //else frame is skipped | ||
425 | { | ||
426 | return LockSurface(); | ||
427 | } | ||
428 | return NULL; | ||
429 | } | ||
430 | |||
431 | /* | ||
432 | void CDsa::RunL() | ||
433 | { | ||
434 | iStateFlags &= ~EUpdating; | ||
435 | } | ||
436 | |||
437 | |||
438 | void CDsa::DoCancel() | ||
439 | { | ||
440 | iStateFlags &= ~EUpdating; | ||
441 | //nothing can do, just wait? | ||
442 | } | ||
443 | */ | ||
444 | |||
445 | TInt CDsa::AllocSurface(TBool aHwSurface, const TSize& aSize, TDisplayMode aMode) | ||
446 | { | ||
447 | if(aHwSurface && aMode != DisplayMode()) | ||
448 | return KErrArgument; | ||
449 | |||
450 | iSourceMode = aMode; | ||
451 | |||
452 | iSourceBpp = BytesPerPixel(aMode); | ||
453 | |||
454 | const TSize size = WindowSize(); | ||
455 | if(aSize.iWidth > size.iWidth) | ||
456 | return KErrTooBig; | ||
457 | if(aSize.iHeight > size.iHeight) | ||
458 | return KErrTooBig; | ||
459 | |||
460 | TRAPD(err, CreateSurfaceL()); | ||
461 | if(err != KErrNone) | ||
462 | return err; | ||
463 | |||
464 | |||
465 | SetCopyFunction(); | ||
466 | |||
467 | EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved); | ||
468 | |||
469 | return KErrNone; | ||
470 | } | ||
471 | |||
472 | |||
473 | /* | ||
474 | void SaveBmp(const TDesC& aName, const TAny* aData, TInt aLength, const TSize& aSz, TDisplayMode aMode) | ||
475 | { | ||
476 | CFbsBitmap* s = new CFbsBitmap(); | ||
477 | s->Create(aSz, aMode); | ||
478 | s->LockHeap(); | ||
479 | TUint32* addr = s->DataAddress(); | ||
480 | Mem::Copy(addr, aData, aLength); | ||
481 | s->UnlockHeap(); | ||
482 | s->Save(aName); | ||
483 | s->Reset(); | ||
484 | delete s; | ||
485 | } | ||
486 | |||
487 | void SaveBmp(const TDesC& aName, const TUint32* aData, const TSize& aSz) | ||
488 | { | ||
489 | CFbsBitmap* s = new CFbsBitmap(); | ||
490 | s->Create(aSz, EColor64K); | ||
491 | TBitmapUtil bmp(s); | ||
492 | bmp.Begin(TPoint(0, 0)); | ||
493 | for(TInt j = 0; j < aSz.iHeight; j++) | ||
494 | { | ||
495 | bmp.SetPos(TPoint(0, j)); | ||
496 | for(TInt i = 0; i < aSz.iWidth; i++) | ||
497 | { | ||
498 | bmp.SetPixel(*aData); | ||
499 | aData++; | ||
500 | bmp.IncXPos(); | ||
501 | } | ||
502 | } | ||
503 | bmp.End(); | ||
504 | s->Save(aName); | ||
505 | s->Reset(); | ||
506 | delete s; | ||
507 | } | ||
508 | |||
509 | TBuf<16> FooName(TInt aFoo) | ||
510 | { | ||
511 | TBuf<16> b; | ||
512 | b.Format(_L("C:\\pic%d.mbm"), aFoo); | ||
513 | return b; | ||
514 | } | ||
515 | */ | ||
516 | void CDsa::ClipCopy(TUint8* aTarget, const TUint8* aSource, const TRect& aRect, const TRect& aTargetPos) const | ||
517 | { | ||
518 | TUint8* target = aTarget; | ||
519 | const TUint8* source = aSource; | ||
520 | const TInt lineWidth = aRect.Width(); | ||
521 | source += iSourceBpp * (aRect.iTl.iY * lineWidth); | ||
522 | TInt sourceStartOffset = iSourceBpp * aRect.iTl.iX; | ||
523 | source += sourceStartOffset; | ||
524 | target += iTargetBpp * ((aTargetPos.iTl.iY + aRect.iTl.iY ) * lineWidth); | ||
525 | TInt targetStartOffset = iTargetBpp * (aRect.iTl.iX + aTargetPos.iTl.iX); | ||
526 | target += targetStartOffset; | ||
527 | TUint32* targetPtr = reinterpret_cast<TUint32*>(target); | ||
528 | const TInt targetWidth = HwRect().Size().iWidth; | ||
529 | const TInt height = aRect.Height(); | ||
530 | |||
531 | TInt lineMove = iStateFlags & EOrientation90 ? 1 : lineWidth; | ||
532 | |||
533 | if(iStateFlags & EOrientation180) | ||
534 | { | ||
535 | |||
536 | targetPtr += targetWidth * (height - 1); | ||
537 | |||
538 | for(TInt i = 0; i < height; i++) //source is always smaller | ||
539 | { | ||
540 | iCopyFunction(*this, targetPtr, source, lineWidth, height); | ||
541 | source += lineMove; | ||
542 | targetPtr -= targetWidth; | ||
543 | } | ||
544 | } | ||
545 | else | ||
546 | { | ||
547 | |||
548 | |||
549 | for(TInt i = 0; i < height; i++) //source is always smaller | ||
550 | { | ||
551 | iCopyFunction(*this, targetPtr, source, lineWidth, height); | ||
552 | source += lineMove; | ||
553 | targetPtr += targetWidth; | ||
554 | } | ||
555 | } | ||
556 | |||
557 | } | ||
558 | |||
559 | |||
560 | |||
561 | |||
562 | void CDsa::Wipe() //dont call in drawing | ||
563 | { | ||
564 | if(IsDsaAvailable()) | ||
565 | Wipe(iTargetBpp * iScreenRect.Width() * iScreenRect.Height()); | ||
566 | } | ||
567 | |||
568 | void CDsa::SetCopyFunction() | ||
569 | { | ||
570 | //calculate offset to correct function in iCFTable according to given parameters | ||
571 | TInt function = 0; | ||
572 | const TInt KCopyFunctions = 4; | ||
573 | const TInt KOffsetToNative = 0; | ||
574 | const TInt KOffsetTo256 = KOffsetToNative + KCopyFunctions; | ||
575 | const TInt KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions; | ||
576 | const TInt KOffsetTo90Functions = 1; | ||
577 | const TInt KOffsetTo180Functions = 2; | ||
578 | |||
579 | if(iSourceMode == DisplayMode()) | ||
580 | function = KOffsetToNative; //0 | ||
581 | else if(iSourceMode == EColor256) | ||
582 | function = KOffsetTo256; //4 | ||
583 | else | ||
584 | function = KOffsetToOtherModes; //8 | ||
585 | |||
586 | if(iStateFlags & EOrientation90) | ||
587 | function += KOffsetTo90Functions; // + 1 | ||
588 | if(iStateFlags & EOrientation180) | ||
589 | function += KOffsetTo180Functions; //+ 2 | ||
590 | |||
591 | iCopyFunction = iCFTable[function]; | ||
592 | |||
593 | Wipe(); | ||
594 | } | ||
595 | |||
596 | inline void Rotate(TRect& aRect) | ||
597 | { | ||
598 | const TInt dx = aRect.iBr.iX - aRect.iTl.iX; | ||
599 | const TInt dy = aRect.iBr.iY - aRect.iTl.iY; | ||
600 | |||
601 | aRect.iBr.iX = aRect.iTl.iX + dy; | ||
602 | aRect.iBr.iY = aRect.iTl.iY + dx; | ||
603 | |||
604 | const TInt tmp = aRect.iTl.iX; | ||
605 | aRect.iTl.iX = aRect.iTl.iY; | ||
606 | aRect.iTl.iY = tmp; | ||
607 | } | ||
608 | |||
609 | /* | ||
610 | int bar = 0; | ||
611 | */ | ||
612 | TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect) | ||
613 | { | ||
614 | |||
615 | if(iStateFlags & EOrientationChanged) | ||
616 | { | ||
617 | iStateFlags &= ~EOrientationFlags; | ||
618 | iStateFlags |= iNewFlags; | ||
619 | SetCopyFunction(); | ||
620 | iStateFlags &= ~EOrientationChanged; | ||
621 | EpocSdlEnv::WaitDeviceChange(); | ||
622 | return EFalse; //skip this frame as data is may be changed | ||
623 | } | ||
624 | |||
625 | if(iTargetAddr == NULL) | ||
626 | { | ||
627 | iTargetAddr = LockHwSurface(); | ||
628 | } | ||
629 | TUint8* target = iTargetAddr; | ||
630 | if(target == NULL) | ||
631 | return EFalse; | ||
632 | |||
633 | |||
634 | TRect targetRect = HwRect(); | ||
635 | TRect sourceRect = aRect; | ||
636 | TRect updateRect = aUpdateRect; | ||
637 | |||
638 | if(iStateFlags & EOrientation90) | ||
639 | { | ||
640 | Rotate(sourceRect); | ||
641 | Rotate(updateRect); | ||
642 | } | ||
643 | |||
644 | if(iSourceMode != DisplayMode() || targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0)) | ||
645 | { | ||
646 | sourceRect.Intersection(targetRect); //so source always smaller or equal than target | ||
647 | updateRect.Intersection(targetRect); | ||
648 | ClipCopy(target, aBits, updateRect, sourceRect); | ||
649 | } | ||
650 | else | ||
651 | { | ||
652 | const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored | ||
653 | Mem::Copy(target, aBits, byteCount); | ||
654 | } | ||
655 | |||
656 | return ETrue; | ||
657 | } | ||
658 | |||
659 | CDsa* CDsa::CreateL(RWsSession& aSession) | ||
660 | { | ||
661 | if(EpocSdlEnv::Flags(CSDL::EDrawModeDSB)) | ||
662 | { | ||
663 | TInt flags = CDirectScreenBitmap::ENone; | ||
664 | if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBDoubleBuffer)) | ||
665 | flags |= CDirectScreenBitmap::EDoubleBuffer; | ||
666 | if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBIncrentalUpdate)) | ||
667 | flags |= CDirectScreenBitmap::EIncrementalUpdate; | ||
668 | return new (ELeave) CDsaB(aSession); | ||
669 | } | ||
670 | else | ||
671 | return new (ELeave) CDsaA(aSession); | ||
672 | } | ||
673 | |||
674 | void CDsa::CreateZoomerL(const TSize& aSize) | ||
675 | { | ||
676 | iSwSize = aSize; | ||
677 | iStateFlags |= EResizeRequest; | ||
678 | CreateSurfaceL(); | ||
679 | SetTargetRect(); | ||
680 | } | ||
681 | |||
682 | TPoint CDsa::WindowCoordinates(const TPoint& aPoint) const | ||
683 | { | ||
684 | TPoint pos = aPoint - iScreenRect.iTl; | ||
685 | const TSize asz = iScreenRect.Size(); | ||
686 | if(iStateFlags & EOrientation180) | ||
687 | { | ||
688 | pos.iX = asz.iWidth - pos.iX; | ||
689 | pos.iY = asz.iHeight - pos.iY; | ||
690 | } | ||
691 | if(iStateFlags & EOrientation90) | ||
692 | { | ||
693 | pos.iX = aPoint.iY; | ||
694 | pos.iY = aPoint.iX; | ||
695 | } | ||
696 | pos.iX <<= 16; | ||
697 | pos.iY <<= 16; | ||
698 | pos.iX /= asz.iWidth; | ||
699 | pos.iY /= asz.iHeight; | ||
700 | pos.iX *= iSwSize.iWidth; | ||
701 | pos.iY *= iSwSize.iHeight; | ||
702 | pos.iX >>= 16; | ||
703 | pos.iY >>= 16; | ||
704 | return pos; | ||
705 | } | ||
706 | |||
707 | void CDsa::SetTargetRect() | ||
708 | { | ||
709 | iTargetRect = iScreenRect; | ||
710 | if(iStateFlags & EResizeRequest && EpocSdlEnv::Flags(CSDL::EAllowImageResizeKeepRatio)) | ||
711 | { | ||
712 | const TSize asz = iScreenRect.Size(); | ||
713 | const TSize sz = iSwSize; | ||
714 | |||
715 | TRect rect; | ||
716 | |||
717 | const TInt dh = (sz.iHeight << 16) / sz.iWidth; | ||
718 | |||
719 | if((asz.iWidth * dh ) >> 16 <= asz.iHeight) | ||
720 | { | ||
721 | rect.SetRect(TPoint(0, 0), TSize(asz.iWidth, (asz.iWidth * dh) >> 16)); | ||
722 | } | ||
723 | else | ||
724 | { | ||
725 | const TInt dw = (sz.iWidth << 16) / sz.iHeight; | ||
726 | rect.SetRect(TPoint(0, 0), TSize((asz.iHeight * dw) >> 16, asz.iHeight)); | ||
727 | } | ||
728 | rect.Move((asz.iWidth - rect.Size().iWidth) >> 1, (asz.iHeight - rect.Size().iHeight) >> 1); | ||
729 | |||
730 | iTargetRect = rect; | ||
731 | iTargetRect.Move(iScreenRect.iTl); | ||
732 | |||
733 | } | ||
734 | if(!(iStateFlags & EResizeRequest)) | ||
735 | iSwSize = iScreenRect.Size(); | ||
736 | // iScanLineWidth = /*iTargetBpp **/ SwSize().iWidth; | ||
737 | } | ||
738 | |||
739 | void CDsa::RecreateL() | ||
740 | { | ||
741 | } | ||
742 | |||
743 | void CDsa::Free() | ||
744 | { | ||
745 | } | ||
746 | |||
747 | void CDsa::UpdateSwSurface() | ||
748 | { | ||
749 | iTargetAddr = NULL; | ||
750 | UnlockHwSurface(); //could be faster if does not use AO, but only check status before redraw, then no context switch needed | ||
751 | } | ||
752 | |||
753 | void CDsa::SetBlitter(MBlitter* aBlitter) | ||
754 | { | ||
755 | iBlitter = aBlitter; | ||
756 | } | ||
757 | |||
758 | void CDsa::DrawOverlays() | ||
759 | { | ||
760 | const TInt last = iOverlays.Count() - 1; | ||
761 | for(TInt i = last; i >= 0 ; i--) | ||
762 | iOverlays[i].iOverlay->Draw(*iDsa->Gc(), HwRect(), SwSize()); | ||
763 | } | ||
764 | |||
765 | TInt CDsa::AppendOverlay(MOverlay& aOverlay, TInt aPriority) | ||
766 | { | ||
767 | TInt i; | ||
768 | for(i = 0; i < iOverlays.Count() && iOverlays[i].iPriority < aPriority; i++) | ||
769 | {} | ||
770 | const TOverlay overlay = {&aOverlay, aPriority}; | ||
771 | return iOverlays.Insert(overlay, i); | ||
772 | } | ||
773 | |||
774 | TInt CDsa::RemoveOverlay(MOverlay& aOverlay) | ||
775 | { | ||
776 | for(TInt i = 0; i < iOverlays.Count(); i++) | ||
777 | { | ||
778 | if(iOverlays[i].iOverlay == &aOverlay) | ||
779 | { | ||
780 | iOverlays.Remove(i); | ||
781 | return KErrNone; | ||
782 | } | ||
783 | } | ||
784 | return KErrNotFound; | ||
785 | } | ||
786 | |||
787 | TInt CDsa::RedrawRequest() | ||
788 | { | ||
789 | if(!(iStateFlags & (EUpdating) && (iStateFlags & ERunning))) | ||
790 | { | ||
791 | return ExternalUpdate(); | ||
792 | } | ||
793 | return KErrNotReady; | ||
794 | } | ||
795 | |||
796 | |||
797 | void CDsa::Resume() | ||
798 | { | ||
799 | if(Stopped()) | ||
800 | Restart(RDirectScreenAccess::ETerminateRegion); | ||
801 | } | ||
802 | |||
803 | void CDsa::DoStop() | ||
804 | { | ||
805 | if(IsDsaAvailable()) | ||
806 | iStateFlags |= ESdlThreadExplicitStop; | ||
807 | Stop(); | ||
808 | } | ||
809 | |||
810 | void CDsa::Stop() | ||
811 | { | ||
812 | iStateFlags &= ~ERunning; | ||
813 | // Cancel(); //can be called only from main! | ||
814 | iDsa->Cancel(); | ||
815 | } | ||
816 | |||
817 | void CDsa::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/) | ||
818 | { | ||
819 | // iStateFlags |= EChangeNotify; | ||
820 | Stop(); | ||
821 | } | ||
822 | |||
823 | void CDsa::Restart(RDirectScreenAccess::TTerminationReasons aReason) | ||
824 | { | ||
825 | if(aReason == RDirectScreenAccess::ETerminateRegion) //auto restart | ||
826 | { | ||
827 | TRAPD(err, RestartL()); | ||
828 | PANIC_IF_ERROR(err); | ||
829 | } | ||
830 | } | ||
831 | /*) | ||
832 | TBool CDsa::ChangeTrigger() | ||
833 | { | ||
834 | const TBool change = iStateFlags & EChangeNotify; | ||
835 | iStateFlags &= ~EChangeNotify; | ||
836 | return change; | ||
837 | } | ||
838 | */ | ||
839 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// | ||
840 | |||
841 | void CDsa::Copy256(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt) | ||
842 | { | ||
843 | TUint32* target = aTarget; | ||
844 | const TUint32* endt = target + aBytes; | ||
845 | const TUint8* source = aSource; | ||
846 | while(target < endt) | ||
847 | { | ||
848 | *target++ = aDsa.iLut256[*source++]; | ||
849 | } | ||
850 | } | ||
851 | |||
852 | void CDsa::Copy256Reversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt) | ||
853 | { | ||
854 | const TUint32* target = aTarget; | ||
855 | TUint32* endt = aTarget + aBytes; | ||
856 | const TUint8* source = aSource; | ||
857 | while(target < endt) | ||
858 | { | ||
859 | *(--endt) = aDsa.iLut256[*source++]; | ||
860 | } | ||
861 | } | ||
862 | |||
863 | void CDsa::Copy256Flip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen) | ||
864 | { | ||
865 | TUint32* target = aTarget; | ||
866 | const TUint32* endt = target + aBytes; | ||
867 | const TUint8* column = aSource; | ||
868 | |||
869 | while(target < endt) | ||
870 | { | ||
871 | *target++ = aDsa.iLut256[*column]; | ||
872 | column += aLineLen; | ||
873 | } | ||
874 | } | ||
875 | |||
876 | void CDsa::Copy256FlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen) | ||
877 | { | ||
878 | const TUint32* target = aTarget; | ||
879 | TUint32* endt = aTarget + aBytes; | ||
880 | const TUint8* column = aSource; | ||
881 | |||
882 | while(target < endt) | ||
883 | { | ||
884 | *(--endt) = aDsa.iLut256[*column]; | ||
885 | column += aLineLen; | ||
886 | } | ||
887 | } | ||
888 | |||
889 | void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt) | ||
890 | { | ||
891 | Mem::Copy(aTarget, aSource, aBytes); | ||
892 | } | ||
893 | |||
894 | void CDsa::CopyMemFlip(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen) | ||
895 | { | ||
896 | TUint32* target = aTarget; | ||
897 | const TUint32* endt = target + aBytes; | ||
898 | const TUint32* column = reinterpret_cast<const TUint32*>(aSource); | ||
899 | |||
900 | while(target < endt) | ||
901 | { | ||
902 | *target++ = *column; | ||
903 | column += aLineLen; | ||
904 | } | ||
905 | } | ||
906 | |||
907 | void CDsa::CopyMemReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt) | ||
908 | { | ||
909 | const TUint32* target = aTarget; | ||
910 | TUint32* endt = aTarget + aBytes; | ||
911 | const TUint32* source = reinterpret_cast<const TUint32*>(aSource); | ||
912 | while(target < endt) | ||
913 | { | ||
914 | *(--endt) = *source++; | ||
915 | } | ||
916 | } | ||
917 | |||
918 | |||
919 | void CDsa::CopyMemFlipReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen) | ||
920 | { | ||
921 | const TUint32* target = aTarget; | ||
922 | TUint32* endt = aTarget + aBytes; | ||
923 | const TUint32* column = reinterpret_cast<const TUint32*>(aSource); | ||
924 | |||
925 | while(target < endt) | ||
926 | { | ||
927 | *(--endt) = *column; | ||
928 | column += aLineLen; | ||
929 | } | ||
930 | } | ||
931 | |||
932 | |||
933 | typedef TRgb (*TRgbFunc) (TInt aValue); | ||
934 | |||
935 | LOCAL_C TRgb rgb16MA(TInt aValue) | ||
936 | { | ||
937 | return TRgb::Color16MA(aValue); | ||
938 | } | ||
939 | |||
940 | NONSHARABLE_CLASS(MRgbCopy) | ||
941 | { | ||
942 | public: | ||
943 | virtual void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed) = 0; | ||
944 | virtual void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed) = 0; | ||
945 | }; | ||
946 | template <class T> | ||
947 | NONSHARABLE_CLASS(TRgbCopy) : public MRgbCopy | ||
948 | { | ||
949 | public: | ||
950 | TRgbCopy(TDisplayMode aMode); | ||
951 | void* operator new(TUint aBytes, TAny* aMem); | ||
952 | void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed); | ||
953 | void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed); | ||
954 | private: | ||
955 | TRgbFunc iFunc; | ||
956 | }; | ||
957 | |||
958 | template <class T> | ||
959 | void* TRgbCopy<T>::operator new(TUint /*aBytes*/, TAny* aMem) | ||
960 | { | ||
961 | return aMem; | ||
962 | } | ||
963 | |||
964 | template <class T> | ||
965 | TRgbCopy<T>::TRgbCopy(TDisplayMode aMode) | ||
966 | { | ||
967 | switch(aMode) | ||
968 | { | ||
969 | case EGray256 : iFunc = TRgb::Gray256; break; | ||
970 | case EColor256 : iFunc = TRgb::Color256; break; | ||
971 | case EColor4K : iFunc = TRgb::Color4K; break; | ||
972 | case EColor64K : iFunc = TRgb::Color64K; break; | ||
973 | case EColor16M : iFunc = TRgb::Color16M; break; | ||
974 | case EColor16MU : iFunc = TRgb::Color16MU; break; | ||
975 | case EColor16MA : iFunc = rgb16MA; break; | ||
976 | default: | ||
977 | PANIC(KErrNotSupported); | ||
978 | } | ||
979 | } | ||
980 | |||
981 | template <class T> | ||
982 | void TRgbCopy<T>::Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed) | ||
983 | { | ||
984 | const T* source = reinterpret_cast<const T*>(aSource); | ||
985 | TUint32* target = aTarget; | ||
986 | TUint32* endt = target + aBytes; | ||
987 | |||
988 | if(aReversed) | ||
989 | { | ||
990 | while(target < endt) | ||
991 | { | ||
992 | TUint32 value = *source++; | ||
993 | *(--endt) = iFunc(value).Value(); | ||
994 | } | ||
995 | } | ||
996 | else | ||
997 | { | ||
998 | while(target < endt) | ||
999 | { | ||
1000 | TUint32 value = *source++; | ||
1001 | *target++ = iFunc(value).Value(); | ||
1002 | } | ||
1003 | } | ||
1004 | } | ||
1005 | |||
1006 | template <class T> | ||
1007 | void TRgbCopy<T>::FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed) | ||
1008 | { | ||
1009 | const T* column = reinterpret_cast<const T*>(aSource); | ||
1010 | TUint32* target = aTarget; | ||
1011 | TUint32* endt = target + aBytes; | ||
1012 | |||
1013 | if(aReversed) | ||
1014 | { | ||
1015 | while(target < endt) | ||
1016 | { | ||
1017 | *(--endt) = iFunc(*column).Value(); | ||
1018 | column += aLineLen; | ||
1019 | } | ||
1020 | } | ||
1021 | else | ||
1022 | { | ||
1023 | while(target < endt) | ||
1024 | { | ||
1025 | *target++ = iFunc(*column).Value(); | ||
1026 | column += aLineLen; | ||
1027 | } | ||
1028 | } | ||
1029 | } | ||
1030 | |||
1031 | |||
1032 | typedef TUint64 TStackMem; | ||
1033 | |||
1034 | LOCAL_C MRgbCopy* GetCopy(TAny* mem, TDisplayMode aMode) | ||
1035 | { | ||
1036 | if(aMode == EColor256 || aMode == EGray256) | ||
1037 | { | ||
1038 | return new (mem) TRgbCopy<TUint8>(aMode); | ||
1039 | } | ||
1040 | if(aMode == EColor4K || aMode == EColor64K) | ||
1041 | { | ||
1042 | return new (mem) TRgbCopy<TUint16>(aMode); | ||
1043 | } | ||
1044 | if(aMode == EColor16M || aMode == EColor16MU || aMode == EColor16MA) | ||
1045 | { | ||
1046 | return new (mem) TRgbCopy<TUint32>(aMode); | ||
1047 | } | ||
1048 | PANIC(KErrNotSupported); | ||
1049 | return NULL; | ||
1050 | } | ||
1051 | |||
1052 | |||
1053 | void CDsa::CopySlowFlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen) | ||
1054 | { | ||
1055 | TStackMem mem = 0; | ||
1056 | GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, ETrue); | ||
1057 | } | ||
1058 | |||
1059 | void CDsa::CopySlowFlip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen) | ||
1060 | { | ||
1061 | TStackMem mem = 0; | ||
1062 | GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, EFalse); | ||
1063 | } | ||
1064 | |||
1065 | void CDsa::CopySlow(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt) | ||
1066 | { | ||
1067 | TStackMem mem = 0; | ||
1068 | GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, EFalse); | ||
1069 | } | ||
1070 | |||
1071 | void CDsa::CopySlowReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt) | ||
1072 | { | ||
1073 | TStackMem mem = 0; | ||
1074 | GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, ETrue); | ||
1075 | } \ No newline at end of file | ||