Mercurial > sdl-ios-xcode

comparison src/video/symbian/EKA2/dsa_new.cpp @ 3975:e85e65aec22f SDL-1.2

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