← Back to branch summary

~ubuntu-branches/ubuntu/karmic/libsdl1.2/karmic

« back to all changes in this revision

Viewing changes to src/video/symbian/EKA2/dsa.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-12-05 20:29:43 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20071205202943-ryogi07hodn5cdif
Tags: 1.2.12-1ubuntu1
* Merge with Debian; remaining changes:
  - Remove svgalib support.
  - Prefer libgl1-mesa-dev build-dependency over xlibmesa-gl-dev.
  - Build for lpia as for i386.
* Link using -Wl,-Bsymbolic-functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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