1 #include "dsa.h"

     2 #include "sdlepocapi.h"

     3 #include <cdsb.h>

     4 

     5 

     6 LOCAL_C TInt BytesPerPixel(TDisplayMode aMode)

     7 	{

     8 	return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1; 

     9 	}

    10 

    11 

    12 NONSHARABLE_CLASS(TDsa)

    13 	{

    14 	public:

    15 		inline TDsa(const CDsa& aDsa);

    16 		inline TBool IsFlip() const;

    17 		inline TBool IsTurn() const;

    18 		inline const TSize& SwSize() const;

    19 		inline void Copy(TUint32* aTarget, const TUint8* aSrc, TInt aBytes, TInt aHeight) const;

    20 	private:

    21 		const CDsa& iDsa;

    22 	};

    23 

    24 

    25 inline TDsa::TDsa(const CDsa& aDsa) : iDsa(aDsa)

    26 	{	

    27 	}

    28 

    29 inline TBool TDsa::IsTurn() const

    30 	{

    31 	return iDsa.iStateFlags & CDsa::EOrientation90;

    32 	}

    33 	

    34 inline TBool TDsa::IsFlip() const

    35 	{

    36 	return iDsa.iStateFlags & CDsa::EOrientation180;

    37 	}	

    38 	

    39 inline const TSize& TDsa::SwSize() const

    40 	{

    41 	return iDsa.SwSize();

    42 	}

    43 		

    44 inline void TDsa::Copy(TUint32* aTarget, const TUint8* aSrc, TInt aBytes, TInt aHeight) const

    45 	{

    46 	iDsa.iCopyFunction(iDsa, aTarget, aSrc, aBytes, aHeight);

    47 	}

    48 	

    49 template<class T, class S>	

    50 void ClipCopy(const TDsa& iDsa, TUint8* aTarget,

    51  					const TUint8* aSource,

    52  					const TRect& aUpdateRect,

    53  					const TRect& aSourceRect)

    54 	{

    55 	const S* source = reinterpret_cast<const S*>(aSource);

    56 	const TInt lineWidth = aSourceRect.Width();

    57 	

    58 	source += (aUpdateRect.iTl.iY * lineWidth); 

    59 	const TInt sourceStartOffset = aUpdateRect.iTl.iX;

    60 	source += sourceStartOffset;

    61 	

    62 	T* targetPtr = reinterpret_cast<T*>(aTarget);

    63 	

    64 	const TInt scanLineWidth = iDsa.SwSize().iWidth;

    65 	

    66 	targetPtr += (aSourceRect.iTl.iY + aUpdateRect.iTl.iY ) * scanLineWidth; 

    67 	const TInt targetStartOffset = (aUpdateRect.iTl.iX + aSourceRect.iTl.iX);

    68 	

    69 	targetPtr += targetStartOffset;

    70 	

    71 	

    72 	const TInt height = aUpdateRect.Height(); 

    73 		

    74 	const TInt lineMove = iDsa.IsTurn() ? 1 : lineWidth;

    75 	const TInt copyLen = aUpdateRect.Width();

    76 	

    77 	

    78 	if(iDsa.IsFlip())

    79 		{

    80 		

    81 		targetPtr += scanLineWidth *  (height - 1);

    82 	

    83 		for(TInt i = 0; i < height; i++) //source is always smaller

    84 			{

    85 			iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);

    86 			source += lineMove;

    87 			targetPtr -= scanLineWidth;

    88 			}

    89 		}

    90 	else

    91 		{

    92 		

    93 		

    94 		for(TInt i = 0; i < height; i++) //source is always smaller

    95 			{

    96 			iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);

    97 			source += lineMove;

    98 			targetPtr += scanLineWidth; // >> 2;

    99 			}

   100 		}

   101 

   102 	}

   103 	

   104 

   105   

   106 NONSHARABLE_CLASS(CDsaA) : public CDsa

   107 	{

   108 	public:

   109 		CDsaA(RWsSession& aSession);

   110 	private:

   111 		~CDsaA();

   112 		TUint8* LockSurface();

   113 		void UnlockHWSurfaceRequestComplete();

   114 		void UnlockHwSurface();

   115 		void CreateSurfaceL();

   116 		void Wipe(TInt aLength);

   117 		void Free();

   118 		void Update(CFbsBitmap& aBmp);

   119 		void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);

   120 		TInt ExternalUpdate();

   121 	//	void ExternalUpdate();

   122 	protected:

   123 		CFbsBitmap* iBmp;

   124 		CFbsBitmap* iCopyBmp;

   125 	};

   126 	

   127 	

   128 CDsaA::CDsaA(RWsSession& aSession) : CDsa(aSession)

   129 	{

   130 	}

   131 	

   132 	

   133 void CDsaA::Free()

   134 	{

   135 	delete iBmp;

   136 	iBmp = NULL;

   137 	}

   138 

   139 CDsaA::~CDsaA()

   140 	{

   141 	__ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));

   142 	delete iCopyBmp;

   143 	}

   144 	

   145 TUint8* CDsaA::LockSurface()

   146 	{

   147 	iBmp->LockHeap();

   148 	return reinterpret_cast<TUint8*>(iBmp->DataAddress());

   149 	}

   150 

   151 void CDsaA::UnlockHWSurfaceRequestComplete()

   152 	{

   153 	PANIC(KErrNotSupported);

   154 	}

   155 

   156 void CDsaA::UnlockHwSurface()

   157 	{

   158 	iBmp->UnlockHeap();

   159 	SetUpdating(EFalse);

   160 	Update(*iBmp);

   161 	}

   162 	

   163 void CDsaA::Update(CFbsBitmap& aBmp)

   164 	{

   165 	if(!Blitter(aBmp))

   166 		{

   167 		if(SwSize() == HwRect().Size())

   168 			Dsa().Gc()->BitBlt(HwRect().iTl, &aBmp);

   169 		else

   170 			Dsa().Gc()->DrawBitmap(HwRect(), &aBmp);

   171 		}

   172 	DrawOverlays();

   173 	Dsa().ScreenDevice()->Update();	

   174 	}

   175 void CDsaA::CreateSurfaceL()

   176 	{

   177 	delete iBmp;

   178 	iBmp = NULL;

   179 	iBmp  = new (ELeave) CFbsBitmap();

   180 	User::LeaveIfError(iBmp->Create(SwSize(), DisplayMode()));

   181 	}

   182 

   183 void CDsaA::Wipe(TInt aLength) //dont call in drawing

   184 	{

   185 	iBmp->LockHeap();

   186 	Mem::FillZ(iBmp->DataAddress(), aLength);

   187 	iBmp->UnlockHeap();

   188 	}

   189 	

   190 

   191 		

   192 TInt CDsaA::ExternalUpdate()

   193 	{

   194 	if(iCopyBmp->Handle() == 0)

   195 		{

   196 		const TInt err = iCopyBmp->Duplicate(iBmp->Handle());

   197 		if(err != KErrNone)

   198 			return err;

   199 		}

   200 	Update(*iCopyBmp);

   201 	return KErrNone;

   202 	}

   203 	

   204 void CDsaA::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)		

   205 	{

   206 	iCopyBmp = new (ELeave) CFbsBitmap();

   207 	CDsa::ConstructL(aWindow, aDevice);

   208 	}

   209 	

   210 	

   211 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   212 

   213 NONSHARABLE_CLASS(MDsbObs)

   214 	{

   215 	public:

   216 		virtual void SurfaceReady() = 0;

   217 		virtual CDirectScreenBitmap& Dsb() = 0;

   218 	};

   219 	

   220 NONSHARABLE_CLASS(CDsbSurface) : public CActive

   221 	{

   222 	public:

   223 		CDsbSurface(MDsbObs& aDsb);

   224 		TUint8* Address();

   225 		void Complete();

   226 		~CDsbSurface();

   227 	private:

   228 		void RunL();

   229 		void DoCancel();

   230 	private:

   231 		MDsbObs& iDsb; 

   232 		TUint8* iAddress;

   233 	};	

   234 

   235 CDsbSurface::CDsbSurface(MDsbObs& aDsb) : CActive(CActive::EPriorityHigh) , iDsb(aDsb)

   236 	{

   237 	CActiveScheduler::Add(this);

   238 	}

   239 

   240 CDsbSurface::~CDsbSurface()

   241 	{

   242 	Cancel();

   243 	}

   244 	

   245 void CDsbSurface::Complete()

   246 	{

   247 	if(iAddress != NULL && !IsActive())

   248 		{

   249 		iAddress = NULL;

   250 		SetActive();

   251 		iDsb.Dsb().EndUpdate(iStatus);

   252 		}

   253 	}

   254 	

   255 TUint8* CDsbSurface::Address()

   256 	{

   257 	if(iAddress == NULL && !IsActive())

   258 		{

   259 		TAcceleratedBitmapInfo info;

   260 		if(KErrNone == iDsb.Dsb().BeginUpdate(info))

   261 			iAddress = info.iAddress;

   262 		}

   263 	return iAddress;

   264 	}

   265 	

   266 void CDsbSurface::RunL()

   267 	{

   268 	iDsb.SurfaceReady();

   269 	}

   270 

   271 void CDsbSurface::DoCancel()

   272 	{

   273 	//empty

   274 	}

   275 		

   276 NONSHARABLE_CLASS(CDsaB) : public CDsa, public MDsbObs

   277 	{

   278 	public:

   279 		CDsaB(RWsSession& aSession, TInt aFlags);

   280 	private:

   281 		~CDsaB();

   282 		TUint8* LockSurface();

   283 		void UnlockHWSurfaceRequestComplete();

   284 		void UnlockHwSurface();

   285 		void CreateSurfaceL();

   286 		void Wipe(TInt aLength);

   287 		void RecreateL();

   288 		void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);

   289 		CDirectScreenBitmap& Dsb();

   290 		void SurfaceReady();

   291 		TInt ExternalUpdate();

   292 	private:

   293 		CDsbSurface* iSurface1;

   294 		CDsbSurface* iSurface2;

   295 		CDirectScreenBitmap* iDsb;

   296 		TInt iType;

   297 	};

   298 

   299 CDsaB::CDsaB(RWsSession& aSession, TInt aFlags) : CDsa(aSession), iType(aFlags)

   300 	{

   301 	}

   302 

   303 

   304 	

   305 void CDsaB::UnlockHWSurfaceRequestComplete()

   306 	{

   307 	iSurface1->Complete();

   308 	if(iSurface2 != NULL)

   309 		iSurface2->Complete();

   310 	}	

   311 

   312 void CDsaB::CreateSurfaceL()

   313 	{

   314 	__ASSERT_ALWAYS(SwSize() == HwRect().Size(), PANIC(KErrNotSupported));

   315 	}

   316 	

   317 void CDsaB::Wipe(TInt aLength) //dont call in drawing

   318 	{

   319 	TUint8* addr = LockSurface();

   320 	if(addr != NULL) 

   321 		{

   322 		Mem::FillZ(addr, aLength);

   323 		UnlockHwSurface();

   324 		}

   325 	}

   326 	

   327 

   328 void CDsaB::UnlockHwSurface()

   329 	{

   330 	EpocSdlEnv::Request(CDsa::ERequestUpdate);

   331 	}

   332 	

   333 TUint8* CDsaB::LockSurface()

   334 	{

   335 	TUint8* addr =  iSurface1->Address();

   336 	if(addr == NULL && iSurface2 != NULL)

   337 		addr =  iSurface2->Address();

   338 	SetUpdating(addr == NULL);

   339 	return addr;

   340 	}

   341 	

   342 void CDsaB::SurfaceReady()	

   343 	{

   344 	SetUpdating(EFalse);

   345 	}

   346 

   347 CDirectScreenBitmap& CDsaB::Dsb()

   348 	{

   349 	return *iDsb;

   350 	}

   351 	

   352 void CDsaB::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)

   353 	{

   354 	if(iDsb == NULL)

   355 		iDsb = CDirectScreenBitmap::NewL();	

   356 	CDsa::ConstructL(aWindow, aDevice);

   357 	if(iSurface1 == NULL)	

   358 		iSurface1 = new (ELeave) CDsbSurface(*this);

   359 	if(iSurface2 == NULL && iType & CDirectScreenBitmap::EDoubleBuffer)

   360 		iSurface2 = new (ELeave) CDsbSurface(*this);

   361 	}

   362 	

   363 CDsaB::~CDsaB()

   364 	{

   365 	delete iSurface1;

   366 	delete iSurface2;

   367 	delete iDsb;

   368 	}	

   369 

   370 void CDsaB::RecreateL()

   371 	{

   372     iDsb->Close();

   373     iDsb->Create(HwRect(), CDirectScreenBitmap::TSettingsFlags(iType));

   374 	}

   375 	

   376 TInt CDsaB::ExternalUpdate()

   377 	{

   378 	if(LockSurface())

   379 		{

   380 		UnlockHWSurfaceRequestComplete();

   381 		return KErrNone;

   382 		}

   383 	return KErrNotReady;

   384 	}

   385 		

   386 

   387 /////////////////////////////////////////////////////////////////////////////////////////////////////	

   388 

   389 

   390 CDsa* CDsa::CreateL(RWsSession& aSession)

   391 	{

   392 	if(EpocSdlEnv::Flags(CSDL::EDrawModeDSB))

   393 		{

   394 		TInt flags = CDirectScreenBitmap::ENone;

   395 		if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBDoubleBuffer))

   396 			flags |= CDirectScreenBitmap::EDoubleBuffer;

   397 		if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBIncrentalUpdate))

   398 			flags |= CDirectScreenBitmap::EIncrementalUpdate;

   399 		return new (ELeave) CDsaB(aSession, flags);

   400 		}

   401     else

   402         return new (ELeave) CDsaA(aSession);

   403 	}   

   404 	

   405 	

   406 void CDsa::RecreateL()

   407 	{

   408 	}

   409 

   410 void CDsa::Free()

   411 	{

   412 	}

   413 	

   414 TSize CDsa::WindowSize() const

   415 	{

   416 	TSize size = iSwSize;

   417 	if(iStateFlags & EOrientation90)

   418 		{

   419 		const TInt tmp = size.iWidth;

   420 		size.iWidth = size.iHeight;

   421 		size.iHeight = tmp;

   422 		}

   423 	return size;

   424 	}

   425 	

   426 void CDsa::SetSuspend()

   427 	{

   428 	iStateFlags |= ESdlThreadSuspend;

   429 	}

   430 

   431 void CDsa::ReleaseStop()

   432 	{

   433 	iStateFlags &= ~ESdlThreadExplicitStop;

   434 	}

   435 

   436 

   437 TBool CDsa::Stopped() const

   438 	{

   439 	return (iStateFlags & ESdlThreadExplicitStop);

   440 	}

   441 

   442 void CDsa::SetOrientation(CSDL::TOrientationMode aOrientation)

   443 	{

   444 	TInt flags = 0;

   445 	switch(aOrientation)

   446 		{

   447 		case CSDL::EOrientation90:

   448 			flags = EOrientation90;

   449 			break;

   450 		case CSDL::EOrientation180:

   451 			flags = EOrientation180;

   452 			break;

   453 		case CSDL::EOrientation270:

   454 			flags = EOrientation90 | EOrientation180;

   455 			break;

   456 		case CSDL::EOrientation0:

   457 			flags = 0;

   458 			break;

   459 		}

   460 	if(flags != (iStateFlags & EOrientationFlags))

   461 		{

   462 		iStateFlags |= EOrientationChanged;

   463 		iNewFlags = flags; //cannot be set during drawing...

   464 		}

   465 	}

   466 

   467 CDsa::~CDsa()

   468     {

   469     if(iDsa != NULL)

   470         {

   471         iDsa->Cancel();

   472         }

   473     iOverlays.Close();

   474     delete iDsa;

   475     User::Free(iLut256);

   476     }

   477          

   478 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)

   479     {

   480     if(iDsa != NULL)

   481     	{

   482     	iDsa->Cancel();

   483     	delete iDsa;

   484     	iDsa = NULL;

   485     	}

   486     	

   487     iDsa = CDirectScreenAccess::NewL(

   488     				iSession,

   489 					aDevice,

   490 					aWindow,

   491 					*this);				

   492 

   493 	if(iLut256 == NULL)

   494 		iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32));

   495 	iTargetMode = aWindow.DisplayMode();

   496 	iTargetBpp = BytesPerPixel(DisplayMode());

   497 	iScreenRect = TRect(aWindow.Position(), aWindow.Size());

   498 	SetTargetRect();

   499     RestartL();

   500     }

   501     

   502 void CDsa::DrawOverlays()

   503 	{

   504 	const TInt last = iOverlays.Count() - 1;

   505 	for(TInt i = last; i >= 0 ; i--)

   506 		iOverlays[i].iOverlay->Draw(*iDsa->Gc(), HwRect(), SwSize());

   507 	}

   508 

   509 TInt CDsa::AppendOverlay(MOverlay& aOverlay, TInt aPriority)

   510 	{

   511 	TInt i;

   512 	for(i = 0; i < iOverlays.Count() && iOverlays[i].iPriority < aPriority; i++)

   513 		{}

   514 	const TOverlay overlay = {&aOverlay, aPriority};

   515 	return iOverlays.Insert(overlay, i);

   516 	}

   517 	

   518 TInt CDsa::RemoveOverlay(MOverlay& aOverlay)

   519 	{

   520 	for(TInt i = 0; i < iOverlays.Count(); i++)

   521 		{

   522 		if(iOverlays[i].iOverlay == &aOverlay)

   523 			{

   524 			iOverlays.Remove(i);

   525 			return KErrNone;

   526 			}

   527 		}

   528 	return KErrNotFound;

   529 	}

   530 

   531 void CDsa::LockPalette(TBool aLock)

   532 	{

   533 	if(aLock)

   534 		iStateFlags |= EPaletteLocked;

   535 	else

   536 		iStateFlags &= ~EPaletteLocked;

   537 	}

   538 TInt CDsa::SetPalette(TInt aFirst, TInt aCount, TUint32* aPalette)

   539 	{

   540 	if(iLut256 == NULL)

   541 		return KErrNotFound;

   542 	const TInt count = aCount - aFirst;

   543 	if(count > 256)

   544 		return KErrArgument;

   545 	if(iStateFlags & EPaletteLocked)

   546 		return KErrNone;

   547 	for(TInt i = aFirst; i < count; i++) //not so busy here:-)

   548 		{

   549 		iLut256[i] = aPalette[i];

   550 		}

   551 	return KErrNone;

   552 	}

   553 	

   554 	

   555 

   556 void CDsa::RestartL()

   557     {

   558     //const TBool active = iDsa->IsActive();

   559     

   560     //if(!active)

   561     

   562     iDsa->StartL();	

   563     

   564     const RRegion* r = iDsa->DrawingRegion();

   565     const TRect rect = r->BoundingRect();

   566     iDsa->Gc()->SetClippingRegion(r);	

   567    

   568     if(rect != iScreenRect)

   569     	{

   570     //	iDsa->Cancel();

   571     	return ;	

   572    	 	}

   573    	 	

   574      

   575     	

   576     //iScreenRect = rect; //to ensure properly set, albeit may not(?) match to value SDL has - therefore may has to clip

   577 	//targetrect shall no change

   578 	SetTargetRect();

   579 	RecreateL();

   580 

   581     iStateFlags |= ERunning;

   582     

   583     ReleaseStop();

   584     if(iStateFlags & ESdlThreadSuspend)

   585     	{

   586     	EpocSdlEnv::Resume();

   587     	iStateFlags &= ~ ESdlThreadSuspend;

   588     	}	

   589     EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);	

   590     }

   591     

   592 CDsa::CDsa(RWsSession& aSession) : 

   593  	iSession(aSession),

   594   	iStateFlags(0)

   595 	{

   596 //	CActiveScheduler::Add(this);

   597 	iCFTable[0] = CopyMem;

   598 	iCFTable[1] = CopyMemFlipReversed;

   599 	iCFTable[2] = CopyMemReversed;

   600 	iCFTable[3] = CopyMemFlip;	

   601 	

   602 	iCFTable[4] = Copy256;

   603 	iCFTable[5] = Copy256FlipReversed;

   604 	iCFTable[6] = Copy256Reversed;

   605 	iCFTable[7] = Copy256Flip;	

   606 	

   607 	

   608 	iCFTable[8] = CopySlow;

   609 	iCFTable[9] = CopySlowFlipReversed;

   610 	iCFTable[10] = CopySlowReversed;

   611 	iCFTable[11] = CopySlowFlip;	

   612 	}

   613 	

   614 RWsSession& CDsa::Session()

   615 	{

   616 	return iSession;

   617 	}

   618 

   619 TInt CDsa::RedrawRequest()

   620 	{

   621 	if(!(iStateFlags & (EUpdating) && (iStateFlags & ERunning)))

   622 		{

   623 		return ExternalUpdate();

   624 		}

   625 	return KErrNotReady;

   626 	}

   627 

   628 TUint8* CDsa::LockHwSurface()

   629 	{

   630 	if((iStateFlags & EUpdating) == 0) //else frame is skipped

   631 		{

   632 		return LockSurface();

   633 		}

   634 	return NULL; 

   635 	}

   636 

   637 /*	

   638 void CDsa::RunL()

   639 	{

   640 	iStateFlags &= ~EUpdating;

   641 	}

   642 		

   643 	

   644 void CDsa::DoCancel()

   645 	{

   646 	iStateFlags &= ~EUpdating;

   647 	//nothing can do, just wait?

   648 	}

   649 */	

   650 

   651 	

   652 TInt CDsa::AllocSurface(TBool aHwSurface, const TSize& aSize, TDisplayMode aMode)

   653 	{

   654 	if(aHwSurface && aMode != DisplayMode())

   655 		return KErrArgument;

   656 	

   657 	iSourceMode = aMode;

   658 	

   659 	iSourceBpp = BytesPerPixel(aMode);

   660 	

   661 	const TSize size = WindowSize();

   662 	if(aSize.iWidth > size.iWidth)

   663 		return KErrTooBig;

   664 	if(aSize.iHeight > size.iHeight)

   665 		return KErrTooBig;

   666 	

   667 	TRAPD(err, CreateSurfaceL());

   668 	if(err != KErrNone)

   669 		return err;

   670 

   671 	SetCopyFunction();

   672 	

   673 	return KErrNone;

   674 	}

   675 	

   676 

   677 void CDsa::CreateZoomerL(const TSize& aSize)

   678 	{

   679 	iSwSize = aSize;

   680 	iStateFlags |= EResizeRequest;

   681 	CreateSurfaceL();

   682 	SetTargetRect();

   683 	}

   684 	

   685 

   686 /*

   687 void SaveBmp(const TDesC& aName, const TAny* aData, TInt aLength, const TSize& aSz, TDisplayMode aMode)

   688 	{

   689 	CFbsBitmap* s = new CFbsBitmap();

   690 	s->Create(aSz, aMode);

   691 	s->LockHeap();

   692 	TUint32* addr = s->DataAddress();

   693 	Mem::Copy(addr, aData, aLength);

   694 	s->UnlockHeap();

   695 	s->Save(aName);

   696 	s->Reset();

   697 	delete s;

   698 	}

   699 	

   700 void SaveBmp(const TDesC& aName, const TUint32* aData, const TSize& aSz)

   701 	{

   702 	CFbsBitmap* s = new CFbsBitmap();

   703 	s->Create(aSz, EColor64K);

   704 	TBitmapUtil bmp(s);

   705 	bmp.Begin(TPoint(0, 0));

   706 	for(TInt j = 0; j < aSz.iHeight; j++)

   707 		{

   708 		bmp.SetPos(TPoint(0, j));

   709 		for(TInt i = 0; i < aSz.iWidth; i++)

   710 			{

   711 			bmp.SetPixel(*aData);

   712 			aData++;

   713 			bmp.IncXPos();

   714 			}

   715 		}

   716 	bmp.End();

   717 	s->Save(aName);

   718 	s->Reset();

   719 	delete s;

   720 	}	

   721 	

   722 TBuf<16> FooName(TInt aFoo)

   723 	{

   724 	TBuf<16> b;

   725 	b.Format(_L("C:\\pic%d.mbm"), aFoo);

   726 	return b;

   727 	}

   728 	

   729 void ClipCopy(TUint8* aTarget, const TUint8* aSource, const TRect& aRect, const TPoint& aTargetPos)

   730 	{

   731 	const TInt iSourceBpp = 1;

   732 	const TInt iTargetBpp = 4;

   733 	const TInt iScanLineWidth = 800; 

   734 	

   735 	TUint8* target = aTarget;

   736 	const TUint8* source = aSource;

   737 	const TInt lineWidth = aRect.Width();

   738 	source += iSourceBpp * (aRect.iTl.iY * lineWidth); 

   739 	const TInt sourceStartOffset = iSourceBpp *  aRect.iTl.iX;

   740 	source += sourceStartOffset;

   741 	target += iTargetBpp * ((aTargetPos.iY + aRect.iTl.iY ) * lineWidth); 

   742 	const TInt targetStartOffset = iTargetBpp * (aRect.iTl.iX + aTargetPos.iX);

   743 	target += targetStartOffset;

   744 	TUint32* targetPtr = reinterpret_cast<TUint32*>(target);

   745 	const TInt targetWidth = iScanLineWidth >> 2;

   746 	const TInt height = aRect.Height(); 

   747 	}	

   748 */

   749 /*

   750 void CDsa::ClipCopy(TUint8* aTarget,

   751  					const TUint8* aSource,

   752  					const TRect& aUpdateRect,

   753  					const TRect& aSourceRect) const

   754 	{

   755 	//TUint8* target = aTarget;

   756 	const TUint32* source = (const TUint32*) aSource;

   757 	const TInt lineWidth = aSourceRect.Width();

   758 	

   759 	source +=  (aUpdateRect.iTl.iY * lineWidth); 

   760 	const TInt sourceStartOffset =   aUpdateRect.iTl.iX;

   761 	source += sourceStartOffset;

   762 	

   763 	TUint32* targetPtr = reinterpret_cast<TUint32*>(aTarget);

   764 	

   765 	targetPtr +=  (aSourceRect.iTl.iY + aUpdateRect.iTl.iY ) * SwSize().iWidth; 

   766 	const TInt targetStartOffset =  (aUpdateRect.iTl.iX + aSourceRect.iTl.iX);

   767 	

   768 	targetPtr += targetStartOffset;

   769 	

   770 //	TUint32* targetPtr = reinterpret_cast<TUint32*>(target);

   771 	

   772 	const TInt targetWidth32 = SwSize().iWidth;

   773 	

   774 	const TInt height = aUpdateRect.Height(); 

   775 		

   776 	const TInt lineMove = iStateFlags & EOrientation90 ? 1 : lineWidth;

   777 	const TInt copyLen = aUpdateRect.Width();

   778 	

   779 	

   780 	if(iStateFlags & EOrientation180)

   781 		{

   782 		

   783 		targetPtr += targetWidth32 *  (height - 1);

   784 	

   785 		for(TInt i = 0; i < height; i++) //source is always smaller

   786 			{

   787 			iCopyFunction(*this, targetPtr, (TUint8*)source, copyLen, height);

   788 			source += lineMove;

   789 			targetPtr -= targetWidth32;

   790 			}

   791 		}

   792 	else

   793 		{

   794 		

   795 		

   796 		for(TInt i = 0; i < height; i++) //source is always smaller

   797 			{

   798 			iCopyFunction(*this, targetPtr, (TUint8*)source, copyLen, height);

   799 			source += lineMove;

   800 			targetPtr += targetWidth32; // >> 2;

   801 			}

   802 		}

   803 

   804 	}

   805 	

   806 */

   807 

   808 void CDsa::ClipCopy(TUint8* aTarget, const TUint8* aSource, const TRect& aRect, const TPoint& aTargetPos) const

   809 	{

   810 	TUint8* target = aTarget;

   811 	const TUint8* source = aSource;

   812 	const TInt lineWidth = aRect.Width();

   813 	source += iSourceBpp * (aRect.iTl.iY * lineWidth); 

   814 	TInt sourceStartOffset = iSourceBpp *  aRect.iTl.iX;

   815 	source += sourceStartOffset;

   816 	target += iTargetBpp * ((aTargetPos.iY + aRect.iTl.iY ) * lineWidth); 

   817 	TInt targetStartOffset = iTargetBpp * (aRect.iTl.iX + aTargetPos.iX);

   818 	target += targetStartOffset;

   819 	TUint32* targetPtr = reinterpret_cast<TUint32*>(target);

   820 	const TInt targetWidth = iScanLineWidth >> 2;

   821 	const TInt height = aRect.Height(); 

   822 	

   823 	TInt lineMove = iStateFlags & EOrientation90 ? 1 : lineWidth;

   824 	

   825 	if(iStateFlags & EOrientation180)

   826 		{

   827 		

   828 		targetPtr += targetWidth *  (height - 1);

   829 	

   830 		for(TInt i = 0; i < height; i++) //source is always smaller

   831 			{

   832 			iCopyFunction(*this, targetPtr, source, lineWidth, height);

   833 			source += lineMove;

   834 			targetPtr -= targetWidth;

   835 			}

   836 		}

   837 	else

   838 		{

   839 		

   840 		

   841 		for(TInt i = 0; i < height; i++) //source is always smaller

   842 			{

   843 			iCopyFunction(*this, targetPtr, source, lineWidth, height);

   844 			source += lineMove;

   845 			targetPtr += targetWidth;

   846 			}

   847 		}

   848 

   849 	}

   850 	

   851 		

   852 	

   853 	/*

   854 void CDsa::ClipCopy(TUint8* aTarget,

   855  					const TUint8* aSource,

   856  					const TRect& aUpdateRect,

   857  					const TRect& aSourceRect) const

   858  		{

   859  		const TDsa dsa(*this);

   860  		switch(iSourceBpp)

   861  			{

   862  			case 1:

   863  				::ClipCopy<TUint32, TUint8>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);

   864  				break;

   865  			case 2:

   866  				::ClipCopy<TUint32, TUint16>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);

   867  				break;

   868  			case 4:

   869  				::ClipCopy<TUint32, TUint32>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);

   870  				break;

   871  			}

   872  		}	

   873 

   874 

   875 */

   876 

   877 

   878 

   879 void CDsa::Wipe() //dont call in drawing

   880 	{

   881 	if(IsDsaAvailable())

   882 		Wipe(iTargetBpp * SwSize().iWidth * SwSize().iHeight);

   883 	}

   884 	

   885 void CDsa::SetCopyFunction()

   886 	{

   887 	//calculate offset to correct function in iCFTable according to given parameters

   888 	TInt function = 0;

   889 	const TInt KCopyFunctions = 4;

   890 	const TInt KOffsetToNative = 0;

   891 	const TInt KOffsetTo256 = KOffsetToNative + KCopyFunctions;

   892 	const TInt KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions;

   893 	const TInt KOffsetTo90Functions = 1;

   894 	const TInt KOffsetTo180Functions = 2;

   895 	

   896 	if(iSourceMode == DisplayMode())

   897 		function = KOffsetToNative; 		//0

   898 	else if(iSourceMode == EColor256)

   899 		function = KOffsetTo256;			//4

   900 	else

   901 		function = KOffsetToOtherModes; 	//8

   902 	

   903 	if(iStateFlags & EOrientation90)

   904 		function += KOffsetTo90Functions; 	// + 1

   905 	if(iStateFlags & EOrientation180)

   906 		function += KOffsetTo180Functions; 	//+ 2

   907 	

   908 	iCopyFunction = iCFTable[function];

   909 	

   910 	Wipe();

   911 	}

   912 	

   913 inline void Rotate(TRect& aRect)

   914 	{

   915 	const TInt dx = aRect.iBr.iX - aRect.iTl.iX;

   916 	const TInt dy = aRect.iBr.iY - aRect.iTl.iY;

   917 

   918 	aRect.iBr.iX = aRect.iTl.iX + dy;

   919 	aRect.iBr.iY = aRect.iTl.iY + dx;

   920 	

   921 	const TInt tmp = aRect.iTl.iX;

   922 	aRect.iTl.iX = aRect.iTl.iY;

   923 	aRect.iTl.iY = tmp;

   924 	}

   925 	

   926 /*	

   927 int bar = 0;

   928 */	

   929 /*

   930 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)

   931 	{

   932 

   933 	if(iStateFlags & EOrientationChanged)

   934 		{

   935 		iStateFlags &= ~EOrientationFlags;

   936 		iStateFlags |= iNewFlags;

   937 		SetCopyFunction();

   938 		iStateFlags &= ~EOrientationChanged;

   939 	    EpocSdlEnv::WaitDeviceChange();

   940 	    return EFalse; //skip this frame as data is may be changed

   941 		}

   942 

   943 	if(iTargetAddr == NULL)

   944 		{

   945 		iTargetAddr = LockHwSurface();

   946 		}

   947 		

   948 	TUint8* target = iTargetAddr;

   949 	if(target == NULL)

   950 		return EFalse;

   951 	

   952 	

   953 	TRect targetRect = TRect(TPoint(0, 0), SwSize());

   954 	

   955 	TRect sourceRect = aRect;

   956 	TRect updateRect = aUpdateRect;

   957 	

   958 //	TPoint move(0, 0);

   959 	

   960 	

   961 	if(iStateFlags & EOrientation90)

   962 		{

   963 		Rotate(sourceRect);

   964 		Rotate(updateRect);

   965 		}

   966 		

   967 	if(iSourceMode != DisplayMode() ||  targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0))

   968 		{

   969 		sourceRect.Intersection(targetRect); //so source always smaller or equal than target

   970 		//updateRect.Intersection(targetRect);

   971 		ClipCopy(target, aBits, updateRect, sourceRect);

   972 		}

   973 	else

   974 		{

   975 		const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored

   976 		Mem::Copy(target, aBits, byteCount);

   977 		}

   978 

   979 	return ETrue;

   980 	}

   981 	*/

   982 	

   983 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)

   984 	{

   985 

   986 	if(iStateFlags & EOrientationChanged)

   987 		{

   988 		iStateFlags &= ~EOrientationFlags;

   989 		iStateFlags |= iNewFlags;

   990 		SetCopyFunction();

   991 		iStateFlags &= ~EOrientationChanged;

   992 	    EpocSdlEnv::WaitDeviceChange();

   993 	    return EFalse; //skip this frame as data is may be changed

   994 		}

   995 

   996 	if(iTargetAddr == NULL)

   997 		{

   998 		iTargetAddr = LockHwSurface();

   999 		}

  1000 	TUint8* target = iTargetAddr;

  1001 	if(target == NULL)

  1002 		return EFalse;

  1003 	

  1004 	

  1005 	TRect targetRect = Rect();

  1006 	TRect sourceRect = aRect;

  1007 	TRect updateRect = aUpdateRect;

  1008 	

  1009 	if(iStateFlags & EOrientation90)

  1010 		{

  1011 		Rotate(sourceRect);

  1012 		Rotate(updateRect);

  1013 		}

  1014 		

  1015 	if(iSourceMode != DisplayMode() ||  targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0))

  1016 		{

  1017 		sourceRect.Intersection(targetRect); //so source always smaller or equal than target

  1018 		updateRect.Intersection(targetRect);

  1019 		ClipCopy(target, aBits, updateRect, sourceRect.iTl);

  1020 		}

  1021 	else

  1022 		{

  1023 		const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored

  1024 		Mem::Copy(target, aBits, byteCount);

  1025 		}

  1026 

  1027 	return ETrue;

  1028 	}	

  1029 void CDsa::UpdateSwSurface()

  1030 	{

  1031 	iTargetAddr = NULL;

  1032 	UnlockHwSurface();	//could be faster if does not use AO, but only check status before redraw, then no context switch needed

  1033 	}

  1034 	

  1035 

  1036 void CDsa::Resume()	

  1037 	{

  1038 	if(Stopped())

  1039 		Restart(RDirectScreenAccess::ETerminateRegion);

  1040 	}

  1041 	

  1042 void CDsa::DoStop()

  1043 	{

  1044 	if(IsDsaAvailable())

  1045 		iStateFlags |= ESdlThreadExplicitStop;

  1046 	Stop();

  1047 	}

  1048 	

  1049 void CDsa::Stop()

  1050 	{

  1051 	iStateFlags &= ~ERunning;

  1052 //	Cancel(); //can be called only from main!

  1053 	iDsa->Cancel();

  1054 	}

  1055 	

  1056 void CDsa::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)

  1057 	{

  1058 //	iStateFlags |= EChangeNotify;

  1059 	Stop();

  1060 	}

  1061 	

  1062 void CDsa::Restart(RDirectScreenAccess::TTerminationReasons aReason)

  1063 	{

  1064 	if(aReason == RDirectScreenAccess::ETerminateRegion) //auto restart

  1065 		{												

  1066 		TRAPD(err, RestartL());

  1067 		PANIC_IF_ERROR(err);

  1068 		}

  1069 	}

  1070 	

  1071 void CDsa::SetBlitter(MBlitter* aBlitter)

  1072 	{

  1073 	iBlitter = aBlitter;

  1074 	}

  1075 	

  1076 	

  1077 TPoint CDsa::WindowCoordinates(const TPoint& aPoint) const	

  1078 	{

  1079 	TPoint pos = aPoint - iScreenRect.iTl;

  1080 	const TSize asz = iScreenRect.Size();

  1081 	if(iStateFlags & EOrientation180)

  1082 		{

  1083 		pos.iX = asz.iWidth - pos.iX;

  1084 		pos.iY = asz.iHeight - pos.iY;	

  1085 		}	

  1086 	if(iStateFlags & EOrientation90)

  1087 		{

  1088 		pos.iX = aPoint.iY;

  1089 		pos.iY = aPoint.iX;	

  1090 		}

  1091 	pos.iX <<= 16;

  1092 	pos.iY <<= 16;

  1093 	pos.iX /= asz.iWidth; 

  1094 	pos.iY /= asz.iHeight;

  1095 	pos.iX *= iSwSize.iWidth;

  1096 	pos.iY *= iSwSize.iHeight;

  1097 	pos.iX >>= 16;

  1098 	pos.iY >>= 16;

  1099 	return pos; 	

  1100 	}

  1101 	

  1102 void CDsa::SetTargetRect()

  1103 	{

  1104 	iTargetRect = iScreenRect;

  1105 	if(iStateFlags & EResizeRequest && EpocSdlEnv::Flags(CSDL::EAllowImageResizeKeepRatio))

  1106 		{

  1107 		const TSize asz = iScreenRect.Size();

  1108 		const TSize sz = iSwSize;

  1109 		

  1110 		TRect rect;

  1111 		

  1112 		const TInt dh = (sz.iHeight << 16) / sz.iWidth;

  1113 

  1114 		if((asz.iWidth * dh ) >> 16 <= asz.iHeight)

  1115 			{

  1116 			rect.SetRect(TPoint(0, 0), TSize(asz.iWidth, (asz.iWidth * dh) >> 16));

  1117 			}

  1118 		else

  1119 			{

  1120 			const TInt dw = (sz.iWidth << 16) / sz.iHeight;

  1121 	    	rect.SetRect(TPoint(0, 0), TSize((asz.iHeight * dw) >> 16, asz.iHeight));

  1122 			}

  1123 		rect.Move((asz.iWidth - rect.Size().iWidth) >> 1, (asz.iHeight - rect.Size().iHeight) >> 1);  

  1124 		

  1125 		iTargetRect = rect;

  1126 		iTargetRect.Move(iScreenRect.iTl);

  1127 

  1128 		} 

  1129 	if(!(iStateFlags & EResizeRequest))

  1130 		iSwSize = iScreenRect.Size();

  1131 //	iScanLineWidth = /*iTargetBpp **/ SwSize().iWidth;

  1132 	}

  1133 		

  1134 /*)

  1135 TBool CDsa::ChangeTrigger()