add some NEON 32bpp blitters
[sdl_omap.git] / src / video / symbian / EKA2 / dsa.cpp
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