MCL/sf/app/photos: comparison photosgallery/viewframework/tvout/src/glxhdmisurfaceupdater.cpp

equal deleted inserted replaced

-:6b87b143d312
+:71da52165949
 // ReleaseContent
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::ReleaseContent()
 {
 TRACER("void CGlxHdmiSurfaceUpdater::ReleaseContent()");
+if ( iGlxDecoderAO )
-iGlxDecoderAO->Cancel();
+{
-if(iDecodedBitmap)
+iGlxDecoderAO->Cancel();
+}
+if ( iDecodedBitmap )
 {
 delete iDecodedBitmap;
 iDecodedBitmap= NULL;
 }
-if (iSurfBufferAO->IsActive())
+if ( iSurfBufferAO->IsActive() )
 {
 iSurfBufferAO->Cancel();
 }
-if(iImageDecoder)
+if ( iImageDecoder )
 {
 delete iImageDecoder;
 iImageDecoder = NULL;
 }
 iSurfUpdateSession.CancelAllUpdateNotifications();
 CreateHdmiL();
 error = iSurfUpdateSession.Connect();
 #ifdef _DEBUG
 iStartTime.HomeTime();
 #endif
-//to refresh the HD screen for the first time.
-iFirstTime = ETrue;
 //start decoding the image
 iGlxDecoderAO->ConvertImageL(*iDecodedBitmap,0,iImageDecoder);
 if (KErrNone !=error)
 {
 // -----------------------------------------------------------------------------
 // UpdateNewImageL
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::UpdateNewImageL(const TDesC& aImageFile,
-TInt /*aFrameCount*/)
+TInt /*aFrameCount*/,TSize aImageDimensions)
 {
 TRACER("CGlxHdmiSurfaceUpdater::UpdateNewImageL()");
+iOrigImageDimensions = aImageDimensions;
 	iBitmapReady = EFalse;
 ReleaseContent();
 CreateImageDecoderL(aImageFile);
 CreateBitmapL();
 CreateHdmiL(EFalse);
 {
 TRACER("CGlxHdmiSurfaceUpdater::CreateHdmiL()");
 if (aCreateSurface)
 {
-TSize rectSz = iDecodedBitmap->SizeInPixels(); // For animation
+GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::CreateHdmiL() Create Surface");
-GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::CreateHdmiL() Size height = %d and width = %d", rectSz.iHeight, rectSz.iWidth);
+CreateSurfaceL();
-CreateSurfaceL(rectSz);
 }
 // Active objects for double buffered draw signalling
 if(!iSurfBufferAO)
 {
 iSurfBufferAO = new(ELeave) CGlxActiveCallBack(TCallBack(SurfBuffer0Ready, this),
 CActive::EPriorityStandard-1);
 CActiveScheduler::Add(iSurfBufferAO);
 }
 }
 // -----------------------------------------------------------------------------
 // CreateSurfaceL
 // -----------------------------------------------------------------------------
-void CGlxHdmiSurfaceUpdater::CreateSurfaceL(TSize aSize)
+void CGlxHdmiSurfaceUpdater::CreateSurfaceL()
 {
 TRACER("CGlxHdmiSurfaceUpdater::CreateSurfaceL()");
+TSize surfaceSize = iWindow->Size();   // create surface of the screen size, i.e 1280x720
 iSurfManager = new(ELeave) RSurfaceManager();
 TInt error = iSurfManager->Open();
 if (error != KErrNone)
 {
 GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::CreateSurfaceL Open Surface manager failed with error = %d", error);
 User::LeaveIfError(error);
 }
 RSurfaceManager::TSurfaceCreationAttributesBuf attributes;
 attributes().iPixelFormat           = EUidPixelFormatARGB_8888;// EUidPixelFormatYUV_420Planar;
-attributes().iSize                  = aSize;
+attributes().iSize                  = surfaceSize;
 attributes().iBuffers               = 1;
-attributes().iStride                = aSize.iWidth * KMulFactorToCreateBitmap;
+attributes().iStride                = surfaceSize.iWidth * KMulFactorToCreateBitmap;
 attributes().iAlignment             = KMulFactorToCreateBitmap;
 attributes().iContiguous            = EFalse;
 attributes().iMappable              = ETrue;
 error = iSurfManager->CreateSurface(attributes, iSurfId);
 GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::CreateSurfaceL, Creating surface failed with error : %d",error);
 User::LeaveIfError(error);
 }
 //Map the surface and stride the surface info
 MapSurfaceL();
-//Set the background Surface
+// Set the Configuration to the surface ID when creating a surface
-iWindow->SetBackgroundSurface(iSurfId);
+iConfig.SetSurfaceId(iSurfId);
 }
 // -----------------------------------------------------------------------------
 // MapSurfaceL
 // -----------------------------------------------------------------------------
 User::LeaveIfError(error);
 TInt offset = 0;
 iSurfManager->GetBufferOffset( iSurfId, 0,offset);
 iSurfBuffer = iSurfChunk->Base()+offset;
 }
 // -----------------------------------------------------------------------------
 // SurfBuffer0Ready
 // -----------------------------------------------------------------------------
 TInt CGlxHdmiSurfaceUpdater::SurfBuffer0Ready(TAny* /*aObject*/)
 {
 // Refresh
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::Refresh()
 {
 TRACER("CGlxHdmiSurfaceUpdater::Refresh()");
+// copy the decoded bitmap on to the surface
 SwapBuffers();
+// Modify the surface position with respect to the buffer size
+	ModifySurfacePostion();
+	// refresh the window
 iCallBack->DoGenCallback();
-if(iFirstTime)
-{
-iFirstTime = EFalse;
-iWindow->RemoveBackgroundSurface(ETrue);
-iWindow->SetBackgroundSurface(iSurfId);
-}
 }
 // -----------------------------------------------------------------------------
 // SwapBuffers
 // This is used to sawp the buffers shown and to be shown
 // StartImageDecodeL
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::CreateBitmapL()
 {
 TRACER("CGlxHdmiSurfaceUpdater::StartImageDecodeL()");
-TSize decodeSize;
+TSize scrnSize = iWindow->Size();
-decodeSize.iHeight = (iOrigImageDimensions.iHeight>KHdTvHeight? KHdTvHeight:
+TSize targetBitmapSize;
-iOrigImageDimensions.iHeight);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::StartImageDecodeL() - bitmapsize=%d, %d",iOrigImageDimensions.iWidth,iOrigImageDimensions.iHeight);
-decodeSize.iWidth = (iOrigImageDimensions.iWidth>KHdTvWidth? KHdTvWidth:
+TReal32 scaleFactor = 0.0f;
-iOrigImageDimensions.iWidth);
+if (scrnSize.iWidth * iOrigImageDimensions.iHeight > scrnSize.iHeight
-GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::StartImageDecodeL() - decodeSize width = %d and height %d",
+* iOrigImageDimensions.iWidth)
-decodeSize.iWidth, decodeSize.iHeight );
+{
+scaleFactor = (TReal32) scrnSize.iHeight
+/ (TReal32) iOrigImageDimensions.iHeight;
+}
+else
+{
+scaleFactor = (TReal32) scrnSize.iWidth
+/ (TReal32) iOrigImageDimensions.iWidth;
+}
+GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::StartImageDecodeL() - scaleFactor=%f",scaleFactor);
+targetBitmapSize.iHeight = iOrigImageDimensions.iHeight * scaleFactor;
+targetBitmapSize.iWidth = iOrigImageDimensions.iWidth * scaleFactor;
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::StartImageDecodeL() - targetBitmapSize=%d, %d",targetBitmapSize.iWidth,targetBitmapSize.iHeight);
 //create the bitmap for the required size
-iDecodedBitmap = new(ELeave) CFbsBitmap();
+iDecodedBitmap = new (ELeave) CFbsBitmap();
-TInt err = iDecodedBitmap->Create(decodeSize,EColor16MU );
+TInt err = iDecodedBitmap->Create(targetBitmapSize, EColor16MU);
 User::LeaveIfNull(iDecodedBitmap);
 }
 // -----------------------------------------------------------------------------
 // HandleRunL
 // -----------------------------------------------------------------------------
-void CGlxHdmiSurfaceUpdater::HandleRunL()
+void CGlxHdmiSurfaceUpdater::HandleRunL(TRequestStatus& aStatus)
 {
 TRACER("CGlxHdmiSurfaceUpdater::HandleRunL()");
 #ifdef _DEBUG
 iStopTime.HomeTime();
 GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::HandleRunL() ConvertImageL took"
 " <%d> us", (TInt)iStopTime.MicroSecondsFrom(iStartTime).Int64());
 #endif
-	iBitmapReady = ETrue;
+if(aStatus.Int() !=KErrNone)
-iZoomRectSz = iDecodedBitmap->SizeInPixels();
+{
-if (iSurfBufferAO->iStatus != KRequestPending && !iSurfBufferAO->IsActive())
+GLX_LOG_INFO("HandleRunL - Convert failed");
-{
+ShiftToCloningMode();
-Refresh();
+}
-iSurfBufferAO->iStatus = KRequestPending;
+else
-iSurfBufferAO->SetActive();
+{
-iSurfUpdateSession.NotifyWhenAvailable(iSurfBufferAO->iStatus);
+iBitmapReady = ETrue;
-TInt err = iSurfUpdateSession.SubmitUpdate(1, iSurfId, 0, NULL);
+iZoomRectSz = iDecodedBitmap->SizeInPixels();
+if (iSurfBufferAO->iStatus != KRequestPending
+&& !iSurfBufferAO->IsActive())
+{
+Refresh();
+iSurfBufferAO->iStatus = KRequestPending;
+iSurfBufferAO->SetActive();
+iSurfUpdateSession.NotifyWhenAvailable(iSurfBufferAO->iStatus);
+TInt err = iSurfUpdateSession.SubmitUpdate(1, iSurfId, 0, NULL);
+}
 }
 	//release imagedecoder after the conversion is over
 if(iImageDecoder)
 {
 delete iImageDecoder;
 if (error!=KErrNone)
 {
 User::Leave(error);
 }
 }
 // -----------------------------------------------------------------------------
 // ActivateZoom
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::ActivateZoom()
 {
 TRACER("CGlxHdmiSurfaceUpdater::ActivateZoom()");
-iConfig.SetSurfaceId(iSurfId);
 iZoom = ETrue;
 if(!iTimer->IsActive() && iBitmapReady)
 {
 iTimer->Start(KZoomDelay,KZoomDelay,TCallBack( TimeOut,this ));
 }
 }
 // -----------------------------------------------------------------------------
 // DeactivateZoom
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::DeactivateZoom()
 {
 TSize bitmapsize = iDecodedBitmap->SizeInPixels();
 iConfig.SetViewport(TRect(0,0,bitmapsize.iWidth,bitmapsize.iHeight));
 iConfig.SetExtent(TRect(0,0,bitmapsize.iWidth,bitmapsize.iHeight));
 iWindow->SetBackgroundSurface(iConfig, ETrue);
 }
+}
-}
 // ---------------------------------------------------------------------------
 // TimeOut
 // ---------------------------------------------------------------------------
 //
 TInt CGlxHdmiSurfaceUpdater::TimeOut(TAny* aSelf)
 self->Zoom(ETrue);
 }
 }
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 // Zoom
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::Zoom(TBool aZoom)
 {
 iZoomRectSz.iWidth = TInt(iZoomRectSz.iWidth-KSingleStepForZoom);
 iZoomRectSz.iHeight = TInt(iZoomRectSz.iHeight-KSingleStepForZoom);
 iLeftCornerForZoom.iX =iLeftCornerForZoom.iX+KSingleStepForZoom/2;
 iLeftCornerForZoom.iY =iLeftCornerForZoom.iY+KSingleStepForZoom/2;
 GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::Zoom()--- 2,iZoomRectSz.iWidth = %d, iZoomRectSz.iHeight = %d", iZoomRectSz.iWidth,iZoomRectSz.iHeight);
-iConfig.SetViewport(TRect(iLeftCornerForZoom.iX,iLeftCornerForZoom.iY,iZoomRectSz.iWidth,iZoomRectSz.iHeight));
+iConfig.SetViewport(TRect(iLeftCornerForZoom.iX,iLeftCornerForZoom.iY,
+iZoomRectSz.iWidth,iZoomRectSz.iHeight));
 }
 else
 {
 iZoomRectSz.iWidth = TInt(iZoomRectSz.iWidth+KSingleStepForZoom);
 iZoomRectSz.iHeight = TInt(iZoomRectSz.iHeight+KSingleStepForZoom);
 {
 iTimer->Cancel();
 iZoom = ETrue;
 }
 GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::Zoom()--- 4,iZoomRectSz.iWidth = %d, iZoomRectSz.iHeight = %d", iZoomRectSz.iWidth,iZoomRectSz.iHeight);
-iConfig.SetViewport(TRect(iLeftCornerForZoom.iX,iLeftCornerForZoom.iY,iZoomRectSz.iWidth,iZoomRectSz.iHeight));
+iConfig.SetViewport(TRect(iLeftCornerForZoom.iX,iLeftCornerForZoom.iY,
-}
+iZoomRectSz.iWidth,iZoomRectSz.iHeight));
-iConfig.SetExtent(TRect(0,0,KHdTvWidth,KHdTvHeight));
+}
+iWindow->SetBackgroundSurface(iConfig, ETrue);
+}
+// -----------------------------------------------------------------------------
+// ModifySurfacePostion
+// -----------------------------------------------------------------------------
+void CGlxHdmiSurfaceUpdater::ModifySurfacePostion()
+	{
+	TRACER("CGlxHdmiSurfaceUpdater::ModifySurfacePostion()");
+	TSize bitmapSize = iDecodedBitmap->SizeInPixels();
+	TPoint startPoint(0,0);
+	if (bitmapSize.iWidth <KHdTvWidth)
+	    {
+	    startPoint.iX = (KHdTvWidth - bitmapSize.iWidth)/2;
+	    }
+	if (bitmapSize.iHeight <KHdTvHeight)
+	    {
+	    startPoint.iY = (KHdTvHeight - bitmapSize.iHeight)/2;
+	    }
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ModifySurfacePostion() - target bitmapsize=%d, %d",bitmapSize.iWidth,bitmapSize.iHeight);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ModifySurfacePostion() - startPoint =%d, %d",startPoint.iX,startPoint.iY);
+// target
+iConfig.SetExtent(TRect(startPoint.iX,startPoint.iY,(KHdTvWidth-startPoint.iX),
+(KHdTvHeight-startPoint.iY)));
+// source
+iConfig.SetViewport(TRect(TPoint(0,0),TSize(bitmapSize.iWidth,bitmapSize.iHeight)));
+#ifdef _DEBUG
+TRect ex, vp;
+iConfig.GetExtent(ex);
+iConfig.GetViewport(vp);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ModifySurfacePostion() - vp - TL=%d, %d",vp.iTl.iX,vp.iTl.iY);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ModifySurfacePostion() - vp - BR=%d, %d",vp.iBr.iX,vp.iBr.iY);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ModifySurfacePostion() - ex - TL=%d, %d",ex.iTl.iX,ex.iTl.iY);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ModifySurfacePostion() - ex - BR=%d, %d",ex.iBr.iX,ex.iBr.iY);
+#endif
 iWindow->SetBackgroundSurface(iConfig, ETrue);
 }
 // -----------------------------------------------------------------------------
 // ShiftToCloningMode
 // ShiftToPostingMode
 // -----------------------------------------------------------------------------
 void CGlxHdmiSurfaceUpdater::ShiftToPostingMode()
 	{
 	TRACER("CGlxHdmiSurfaceUpdater::ShiftToPostingMode()");
-	iWindow->SetBackgroundSurface(iSurfId);
+#ifdef _DEBUG
+	TRect ex, vp;
+	iConfig.GetExtent(ex);
+iConfig.GetViewport(vp);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ShiftToPostingMode() - vp - TL=%d, %d",vp.iTl.iX,vp.iTl.iY);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ShiftToPostingMode() - vp - BR=%d, %d",vp.iBr.iX,vp.iBr.iY);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ShiftToPostingMode() - ex - TL=%d, %d",ex.iTl.iX,ex.iTl.iY);
+GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::ShiftToPostingMode() - ex - BR=%d, %d",ex.iBr.iX,ex.iBr.iY);
+#endif
+iWindow->SetBackgroundSurface(iConfig, ETrue);
 	}

branch	RCL_3
changeset 11	71da52165949
parent 9	6b87b143d312
child 12	ce1c7ad1f18b