1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <barsread.h>

    17 #include <bidi.h>

    18 #include <eikenv.h>

    19 #include <techview/eikchlst.h>

    20 #include <techview/eikinfo.h>

    21 #include <techview/eikmenup.h>

    22 #include <e32math.h>

    23 #include <badesca.h>

    24 #include <techview/eikon.rsg>	

    25 #include <eikpriv.rsg>

    26 #include <techview/eiktxlbx.h>

    27 #include <techview/eikmfne.h>

    28 #include <techview/eiktxlbm.h>

    29 #include <iclexif.h>

    30 

    31 #include <icl/icl_uids.hrh>

    32 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    33 #include <icl/icl_uids_const.hrh>

    34 #include <icl/icl_uids_def.hrh>

    35 #endif

    36 #include "TImageViewer.h"

    37 

    38 const TInt KVideoMinZoomFactor = -3;

    39 const TInt KVideoMaxZoomFactor = 0;

    40 

    41 const TInt KDefaultStreamDelay = 1000000; // 1s. Used when streaming non-animated

    42 const TInt KDefaultFolderDelay = 2000000; // 2s. Used when playing a folder

    43 

    44 const TInt KButtonMoveIncr = 16;

    45 const TInt KScaleFactor = 10;

    46 

    47 const TInt KInfoBufferSize = 1024;

    48 

    49 _LIT(KDefPath, "C:\\");

    50 const TInt KShortestPossiblePath=4;

    51 

    52 // #define __USE_PURE_SCALING // fine scaling scales to 1/2, 1/4 and 1/8 - check non-universal scaling

    53 

    54 #define __CLEAR_BITMAPS_FIRST // for debugging purposes, get TImageViewer to clear bitmaps prior to

    55 							  // decode conversion. Really the codecs should do this, but...

    56 

    57 inline TBool IsMngImage(const CImageDecoder* aDecoder)

    58 	{

    59 	TUid type, subtype;

    60 	aDecoder->ImageType(0, type, subtype);

    61 	return (type.iUid==KMngMimeTypeUidValue);

    62 	}

    63 

    64 inline TBool HasMoreMngFrames(const CImageDecoder* aDecoder)

    65 	{

    66 	const TFrameInfo& info=aDecoder->FrameInfo(0);

    67 	return (info.iFlags & TFrameInfo::EMngMoreFramesToDecode);

    68 	}

    69 

    70 CPluginInfoArray* CPluginInfoArray::NewL()

    71 	{

    72 	CPluginInfoArray* self = new (ELeave) CPluginInfoArray;

    73 	CleanupStack::PushL(self);

    74 	self->ConstructL();

    75 	CleanupStack::Pop(self);

    76 	return self;

    77 	}

    78 

    79 void CPluginInfoArray::ConstructL()

    80 	{

    81 	RefreshPluginListL();

    82 	}

    83 

    84 CPluginInfoArray::CPluginInfoArray()

    85 	{

    86 	}

    87 

    88 void CPluginInfoArray::Reset()

    89 	{

    90 	iPluginArray.ResetAndDestroy();

    91 	}

    92 

    93 void CPluginInfoArray::RefreshPluginListL()

    94 	{

    95 	Reset();

    96 	CImageEncoder::GetImageTypesL(iPluginArray);

    97 	}

    98 

    99 CPluginInfoArray::~CPluginInfoArray()

   100 	{

   101 	Reset();

   102 	}

   103 

   104 TInt CPluginInfoArray::MdcaCount() const

   105 	{

   106 	return iPluginArray.Count();

   107 	}

   108 

   109 TPtrC CPluginInfoArray::MdcaPoint(TInt aIndex) const

   110 	{

   111 	return iPluginArray[aIndex]->Description(); 

   112 	}

   113 

   114 TUid CPluginInfoArray::ImageType(TInt aIndex)

   115 	{

   116 	return iPluginArray[aIndex]->ImageType(); 

   117 	}

   118 

   119 TUid CPluginInfoArray::SubType(TInt aIndex)

   120 	{

   121 	return iPluginArray[aIndex]->SubType(); 

   122 	}

   123 

   124 // CFrameInfoDialog

   125 class CFrameInfoDialog : public CEikDialog

   126 	{

   127 public:

   128 	CFrameInfoDialog(const TDesC& aPropertiesText, const TDesC& aImageCommentText, const TDesC& aFrameCommentText);

   129 

   130 protected:

   131 	void PreLayoutDynInitL();

   132 

   133 private:

   134 	const TDesC& iPropertiesText;

   135 	const TDesC& iImageCommentText;

   136 	const TDesC& iFrameCommentText;

   137 	};

   138 

   139 CFrameInfoDialog::CFrameInfoDialog(const TDesC& aPropertiesText, const TDesC& aImageCommentText, const TDesC& aFrameCommentText)

   140 	: iPropertiesText(aPropertiesText), iImageCommentText(aImageCommentText), iFrameCommentText(aFrameCommentText)

   141 	{

   142 	}

   143 

   144 void CFrameInfoDialog::PreLayoutDynInitL()

   145 	{

   146 	// Grab each Edwin and set the text.

   147 	CEikEdwin* page = STATIC_CAST(CEikEdwin*, Control(EFramePropertiesPage));

   148 	page->SetTextL(&iPropertiesText);

   149 

   150 	page = STATIC_CAST(CEikEdwin*, Control(EImageCommentsPage));

   151 	page->SetTextL(&iImageCommentText);

   152 

   153 	page = STATIC_CAST(CEikEdwin*, Control(EFrameCommentsPage));

   154 	page->SetTextL(&iFrameCommentText);

   155 	}

   156 

   157 //

   158 // CVideoWalker

   159 //

   160 

   161 class CVideoWalker : public CActive

   162 	{

   163 public:

   164 	static CVideoWalker* NewL(CVideoAppUi* aAppUi);

   165 	~CVideoWalker();

   166 	TRequestStatus& ActiveStatus();

   167 	void SelfComplete(TInt aError);

   168 protected:

   169 	CVideoWalker(CVideoAppUi* aAppUi);

   170 	// from CActive

   171 	void RunL();

   172 	void DoCancel();

   173 protected:

   174 	CVideoAppUi* const iAppUi; // not owned

   175 	};

   176 

   177 

   178 //

   179 //  CVideoAppUi

   180 //

   181 

   182 CVideoAppUi::CVideoAppUi():

   183 	iStreamBuffer(NULL,0,0)

   184 	{

   185 	iDecoderOptions = (CImageDecoder::EAllowGeneratedMask | CImageDecoder::EPreferFastDecode);

   186 	}

   187 

   188 void CVideoAppUi::ConstructL()

   189     {

   190 	CEikAppUi::ConstructL();

   191 

   192     iAppView = CVideoAppView::NewL(ClientRect());

   193 

   194 	::new(&iFrame) CWsBitmap(iEikonEnv->WsSession());

   195 	::new(&iMask) CWsBitmap(iEikonEnv->WsSession());

   196 

   197 	iRotator = CBitmapRotator::NewL();

   198 	iScaler = CBitmapScaler::NewL();

   199 

   200 	iBackgroundColor = KRgbWhite.Color16();

   201 

   202 	iAppView->SetBackgroundColor(TRgb::Color16(iBackgroundColor), ENoDrawNow);

   203 

   204 	iWalker = CVideoWalker::NewL(this);

   205 	User::LeaveIfError(iTimer.CreateLocal());

   206 	iStreamGen = CVideoWalker::NewL(this);

   207 	User::LeaveIfError(iStreamTimer.CreateLocal());

   208 

   209 	// Note iStreamSeed deliberated left as 0 to give consistent behaviour

   210 

   211 	iSaveInfo.iImageTypeUid = KImageTypeJPGUid;

   212 	iSaveInfo.iBpp = 6;

   213 	iSaveInfo.iColor = ETrue;

   214 	iSaveInfo.iQualityFactor = 40;

   215 	iSaveInfo.iSampling = 2;

   216 	

   217 	iUseNativeDisplayMode = ETrue;

   218 	

   219 	iScalingCoefficient = 1; // Full size

   220 	}

   221 

   222 CVideoAppUi::~CVideoAppUi()

   223 	{

   224 	Cancel();

   225 

   226 	iFrame.Reset();

   227 	iMask.Reset();

   228 	if (iAppView)

   229 		{

   230 		RemoveFromStack(iAppView);

   231 		delete iAppView;

   232 		}

   233 	delete iFrameImageData;

   234 	delete iLoadUtil;

   235 	delete iSaveUtil;

   236 	delete iRotator;

   237 	delete iScaler;

   238 	delete iWalker;

   239 	iTimer.Close();

   240 	iStreamTimer.Close();

   241 	delete iStreamGen;

   242 	User::Free(REINTERPRET_CAST(TAny*,CONST_CAST(TUint8*, iStreamBuffer.Ptr())));

   243 	delete iDir;

   244 	iOperations.Close();

   245 	}

   246 

   247 void CVideoAppUi::Cancel()

   248 	{

   249 	if (iWalker)

   250 		iWalker->Cancel(); // if active will callback on DoCancel()

   251 	if (iStreamGen)

   252 		iStreamGen->Cancel();

   253 	iState = EIdle;

   254 	}

   255 

   256 TKeyResponse CVideoAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

   257 	{

   258 	TKeyResponse ret = EKeyWasConsumed;

   259 

   260 	if (aType!=EEventKey)

   261 		return ret;

   262 

   263 	TUint code = aKeyEvent.iCode;

   264 

   265 	switch (code)

   266 		{

   267 	case EKeyLeftArrow:

   268 	case EKeyRightArrow:

   269 	case EKeyUpArrow:

   270 	case EKeyDownArrow:

   271 		{

   272 		if ( aKeyEvent.iModifiers & EModifierShift )

   273 			{

   274 			// update crop region

   275 			UpdateClippingRect(code);

   276 			}

   277 		else

   278 			{

   279 			TPoint moveBy;

   280 			switch (code)

   281 				{

   282 			case EKeyLeftArrow:

   283 				moveBy.SetXY(KButtonMoveIncr,0);

   284 				break;

   285 			case EKeyRightArrow:

   286 				moveBy.SetXY(-KButtonMoveIncr,0);

   287 				break;

   288 			case EKeyUpArrow:

   289 				moveBy.SetXY(0,KButtonMoveIncr);

   290 				break;

   291 			case EKeyDownArrow:

   292 				moveBy.SetXY(0,-KButtonMoveIncr);

   293 				break;

   294 				}

   295 			iAppView->MoveBy(moveBy);

   296 			}

   297 		}

   298 		break;

   299 	case EKeyEscape:

   300 		Cancel();

   301 		ASSERT(iState==EIdle);

   302 		iEikonEnv->BusyMsgCancel();

   303 		iEikonEnv->InfoMsg(_L("Cancelled"));

   304 		break;

   305 	default:

   306 		ret = EKeyWasNotConsumed;

   307 		break;

   308 		}

   309 	return ret;

   310 	}

   311 

   312 void CVideoAppUi::HandleCommandL(TInt aCommand)

   313 	{

   314 	switch (aCommand)

   315 		{

   316 	case EVideoCmdOpenFile:

   317 		OpenFileL(EFileTypeUnknown);

   318 		break;

   319 	case EVideoCmdOpenOtaFile:

   320 		OpenFileL(EFileTypeOta);

   321 		break;

   322 	case EVideoCmdOpenWbmpFile:

   323 		OpenFileL(EFileTypeWbmp);

   324 		break;

   325 	case EVideoCmdOpenFolder:

   326 		OpenFolderL();

   327 		break;

   328 	case EVideoCmdSaveAs:

   329 		SaveAsL();

   330 		break;

   331 	case EVideoCmdMask:

   332 		iDisableMask = ! iDisableMask;

   333 		if (iDisableMask)

   334 			{

   335 			iEikonEnv->InfoMsg(_L("Mask reset"));

   336 			}

   337 		else

   338 			{

   339 			iEikonEnv->InfoMsg(_L("Mask enabled"));

   340 			}

   341 		if (iMask.Handle() && iDisableMask)

   342 			{

   343 			iMask.Reset();

   344 			}

   345 		else if (iMask.Handle()==0 && !iDisableMask)

   346 			{

   347 			User::LeaveIfError(iMask.Create(TSize(0,0),EGray256));

   348 			}

   349 		break;

   350 	case EVideoCmdZoomIn:

   351 		iZoomFactor++;

   352 		if (iZoomFactor > KVideoMaxZoomFactor)

   353 			iZoomFactor = KVideoMinZoomFactor;

   354 		if ( iUseExtensions )

   355 			{

   356 			iScalingCoefficient = iZoomFactor - 1;

   357 			}

   358 		LoadFileL();

   359 		break;

   360 	case EVideoCmdZoomOut:

   361 		iZoomFactor--;

   362 		if (iZoomFactor < KVideoMinZoomFactor)

   363 			iZoomFactor = KVideoMaxZoomFactor;

   364 		if ( iUseExtensions )

   365 			{

   366 			iScalingCoefficient = iZoomFactor - 1;

   367 			}

   368 		LoadFileL();

   369 		break;

   370 	case EVideoCmdFineZoomIn:

   371 		ZoomFrameL(ETrue);

   372 		break;

   373 	case EVideoCmdFineZoomOut:

   374 		ZoomFrameL(EFalse);

   375 		break;

   376 	case EVideoCmdDisplayMode:

   377 		DisplayModeL();

   378 		break;

   379 	case EVideoCmdBackgroundColor:

   380 		BackgroundColorL();

   381 		break;

   382 	case EVideoCmdPlay:

   383 		if (iState == EPlaying || iState == ELoading)

   384 			iEikonEnv->InfoMsg(_L("Busy..."));

   385 		else

   386 			PlayClipL();

   387 		break;

   388 	case EVideoCmdStream:

   389 		StreamPlayL(EFileTypeUnknown);

   390 		break;

   391 	case EVideoCmdOtaStream:

   392 		StreamPlayL(EFileTypeOta);

   393 		break;

   394 	case EVideoCmdWbmpStream:

   395 		StreamPlayL(EFileTypeWbmp);

   396 		break;

   397 	case EVideoCmdDecoderOptions:

   398 		DecoderOptionsL();

   399 		break;

   400 	case EVideoCmdExtension:

   401 		ExtensionOptionsL();

   402 		break;

   403 	case EVideoCmdUseExtensions:

   404 	    iUseExtensions = !iUseExtensions;

   405 		break;

   406 	case EVideoCmdRefresh:

   407 		LoadFileL();

   408 		break;

   409 	case EVideoCmdExtractFrame:

   410 		ExtractFrameL();

   411 		break;

   412 	case EVideoCmdExtractStreamedFrame:

   413 		StreamPlayL(EFileTypeUnknown, ETrue);

   414 		break;

   415 	case EVideoCmdFrameInfo:

   416 		FrameInfoL(); 

   417 		break;

   418 	case EVideoCmdRotateClockwise:

   419 		FrameRotateL(ETrue);

   420 		break;

   421 	case EVideoCmdRotateAntiClockwise:

   422 		FrameRotateL(EFalse);

   423 		break;

   424 	case EVideoCmdMirrorHorizontalAxis:

   425 		FrameMirrorL(ETrue);

   426 		break;

   427 	case EVideoCmdMirrorVerticalAxis:

   428 		FrameMirrorL(EFalse);

   429 		break;

   430 	case EEikCmdExit:

   431 		Exit();

   432 		break;

   433 	default:

   434 		iEikonEnv->InfoMsg(R_VIDEO_UNKNOWN);

   435 		break;

   436 		}

   437 	}

   438 

   439 TBool CVideoAppUi::ProcessCommandParametersL(TApaCommand aCommand,TFileName& aDocumentName,const TDesC8& aTail)

   440 	{

   441 	switch (aCommand)

   442 		{

   443 	case EApaCommandOpen:

   444 		iLoadFileName = aDocumentName;

   445 		break;

   446 	case EApaCommandCreate:

   447 	case EApaCommandRun:

   448 		break;

   449 	case EApaCommandBackground:

   450 	default:

   451 		break;

   452 		}

   453 

   454 	return CEikAppUi::ProcessCommandParametersL(aCommand,aDocumentName,aTail);

   455 	}

   456 

   457 void CVideoAppUi::OpenFileL(TFileType aFileType)

   458 	{

   459 	if (iLoadFileName.Length() < KShortestPossiblePath)

   460 		iLoadFileName = KDefPath;

   461 

   462 	Cancel();

   463 	delete iLoadUtil; iLoadUtil = NULL;

   464 

   465 	TInt title;

   466 	switch (aFileType)

   467 		{

   468 		default:

   469 			title = 0;

   470 			break;

   471 		case EFileTypeWbmp:

   472 			title = R_VIDEO_OPEN_WBMP;

   473 			break;

   474 		case EFileTypeOta:

   475 			title = R_VIDEO_OPEN_OTA;

   476 			break;

   477 		}

   478 	CEikDialog* dialog = new(ELeave) CEikFileOpenDialog(&iLoadFileName, title);

   479 	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

   480 		return;

   481 

   482 	iLastFileType = aFileType;

   483 	iOpeningFolder = EFalse;

   484 	LoadFileL();

   485 	}

   486 

   487 void CVideoAppUi::OpenFolderL()

   488 	{

   489 	Cancel();

   490 

   491 	if (iLoadFileName.Length() < KShortestPossiblePath)

   492 		iLoadFileName = KDefPath;

   493 

   494 	TFileName folderName = iLoadFileName;

   495 

   496 	CEikDialog* dialog = new(ELeave) CEikFileOpenDialog(&folderName, R_VIDEO_SELECT_FOLDER);

   497 	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

   498 		return;

   499 

   500 	iLastFileType = EFileTypeUnknown;

   501 	iOpeningFolder = ETrue;

   502 	LoadFolderL(folderName);

   503 	}

   504 	

   505 void CVideoAppUi::DecoderOptionsL()

   506 	{

   507 	CEikDialog* dialog = new(ELeave) CDecoderOptionsDialog(iDecoderOptions);

   508 	dialog->ExecuteLD(R_VIDEO_DECODER_OPTIONS_DIALOG);

   509 	}

   510 

   511 void CVideoAppUi::ExtensionOptionsL()

   512 	{

   513 	CEikDialog* dialog = new(ELeave) CExtensionOptionsDialog(iClippingRect,

   514 															 iOperations,

   515 															 iScalingCoefficient,

   516 															 iScalingQuality,

   517 															 iLockAspectRatio);

   518 	TInt buttonPressed = dialog->ExecuteLD(R_VIDEO_DECODER_EXTENSION_DIALOG);

   519 	if ( buttonPressed == EEikBidOk && iLoadUtil )

   520 		{

   521 		// re-convert the image e.g. if clipping rect has changed

   522 		LoadFileL();

   523 		}

   524 	}

   525 	

   526 void CVideoAppUi::LoadFileL()

   527 	{

   528 	Cancel();

   529 	if ( !iLoadUtil )

   530 		{

   531 		if (iLoadFileName.Length() < KShortestPossiblePath)

   532 			return;

   533 

   534 		TUid format;

   535 		switch (iLastFileType)

   536 			{

   537 			case EFileTypeOta:

   538 				format = KImageTypeOTAUid;

   539 				break;

   540 			case EFileTypeWbmp:

   541 				format = KImageTypeWBMPUid;

   542 				break;

   543 			default:

   544 				format = KNullUid;

   545 			}

   546 

   547 		TRAPD(error,iLoadUtil = CImageDecoder::FileNewL(iCoeEnv->FsSession(), iLoadFileName, CImageDecoder::TOptions(iDecoderOptions), format));

   548 		if (error!=KErrNone)

   549 			{

   550 			iEikonEnv->HandleError(error);

   551 			iAppView->Reset(EDrawNow); // ensure we redraw whole screen - replace previous cross if required

   552 			return;

   553 			}

   554 		}

   555 

   556 	HandleNewlyOpenedImageL();

   557 

   558 	StartFrameOpen(EPlaying);

   559 	}

   560 

   561 void CVideoAppUi::LoadFolderL(const TDesC& aDirName)

   562 	{

   563 	delete iDir; iDir = NULL;

   564 

   565 	TParsePtrC parse(aDirName);

   566 	iDirName = parse.DriveAndPath();

   567 

   568 	iEikonEnv->FsSession().GetDir(iDirName, 0, 0, iDir);

   569 

   570 	if (iDir->Count()==0)

   571 		{

   572 		iEikonEnv->InfoMsg(R_VIDEO_EMPTY_FOLDER);

   573 		return;

   574 		}

   575 

   576 	iDirIndex = 0; 

   577 	OpenNextFolderEntry();

   578 	}

   579 

   580 void CVideoAppUi::OpenNextFolderEntry()

   581 	{

   582 	if (iDirIndex >= iDir->Count())

   583 		{

   584 		// end of processing - so stop

   585 		iEikonEnv->BusyMsgCancel();

   586 		Cancel(); 

   587 		iState = EIdle;

   588 		return;

   589 		}

   590 

   591 	const TEntry& entry = (*iDir)[iDirIndex];

   592 	iLoadFileName.Copy(iDirName);

   593 	iLoadFileName.Append(entry.iName);

   594 

   595 	delete iLoadUtil; 

   596 	iLoadUtil = NULL;

   597 	TRAPD(error, LoadFileL());

   598 

   599 	if (error==KErrNone)

   600 		iEikonEnv->InfoMsg(entry.iName);

   601 	else

   602 		{

   603 		TBuf<64> errorMsg;

   604 		errorMsg.Format(_L("%S - error %d"), &entry.iName, error);

   605 		iEikonEnv->InfoMsg(errorMsg);

   606 		LoadFolderWait();

   607 		}

   608 	}

   609 

   610 void CVideoAppUi::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)

   611 	{

   612 	if(aResourceId==R_VIDEO_CLIP_MENU)

   613 		{

   614 		if (iLoadUtil==NULL || iState!=EIdle) // nothing open or we are busy

   615 			aMenuPane->SetItemDimmed(EVideoCmdPlay,ETrue);

   616 		}

   617 	else if (aResourceId==R_VIDEO_OPERATE_MENU)

   618 		{

   619 		if (iLoadUtil==NULL || iState!=EIdle || iUseExtensions)

   620 			{

   621 			// nothing open or we are busy

   622 			aMenuPane->SetItemDimmed(EVideoCmdRotateClockwise,ETrue);

   623 			aMenuPane->SetItemDimmed(EVideoCmdRotateAntiClockwise,ETrue);

   624 			aMenuPane->SetItemDimmed(EVideoCmdMirrorHorizontalAxis,ETrue);

   625 			aMenuPane->SetItemDimmed(EVideoCmdMirrorVerticalAxis,ETrue);

   626 			}

   627 		}

   628 	else if (aResourceId==R_VIDEO_ZOOM_MENU)

   629 		{

   630 		if (iLoadUtil==NULL || iState!=EIdle || iUseExtensions)

   631 			{

   632 			aMenuPane->SetItemDimmed(EVideoCmdZoomIn,ETrue);

   633 			aMenuPane->SetItemDimmed(EVideoCmdZoomOut,ETrue);

   634 			}

   635 		}

   636 	else if ( aResourceId==R_VIDEO_VIEW_MENU )

   637 		{

   638 		aMenuPane->SetItemButtonState(EVideoCmdUseExtensions,(iUseExtensions) ? EEikMenuItemSymbolOn : 0);

   639 		}

   640 	}

   641 

   642 TBool CVideoAppUi::CheckHotKeyNotDimmedL(TInt aCommandId)

   643 	{

   644 	TInt result = ETrue;

   645 	switch (aCommandId)

   646 		{

   647 		case EVideoCmdPlay:

   648 		case EVideoCmdRotateClockwise:

   649 		case EVideoCmdRotateAntiClockwise:

   650 		case EVideoCmdFineZoomIn:

   651 		case EVideoCmdFineZoomOut:

   652 		case EVideoCmdMirrorHorizontalAxis:

   653 		case EVideoCmdMirrorVerticalAxis:

   654 			if (iLoadUtil==NULL || iState!=EIdle || iUseExtensions)

   655 				result = EFalse;

   656 			break;

   657 		default:

   658 			// do nothing

   659 			break;

   660 		}

   661 	return result;

   662 	}

   663 

   664 void CVideoAppUi::LoadFolderWait()

   665 	{

   666 	ASSERT(!iWalker->IsActive()); // if we get here, should not be doing anything

   667 	

   668 	iTimer.After(iWalker->ActiveStatus(), KDefaultFolderDelay);

   669 	iState = EFolderWait;

   670 	}

   671 

   672 void CVideoAppUi::HandleNewlyOpenedImageL()

   673 	{

   674 	ASSERT(iLoadUtil); // should have already been opened

   675 

   676 	TFrameInfo frameInfo = iLoadUtil->FrameInfo(0);

   677 

   678 	// jf 3/12/01. Assume frame 0 gives the main image characteristics

   679 	iOverallSize = frameInfo.iOverallSizeInPixels;

   680 	if (iOverallSize.iWidth==0 || iOverallSize.iHeight==0)

   681 		{

   682 		iOverallSize = frameInfo.iFrameCoordsInPixels.Size();

   683 		if (iOverallSize.iWidth==0 || iOverallSize.iHeight==0)

   684 			{

   685 			iEikonEnv->InfoMsg(_L("Invalid image dimensions."));

   686 			User::Leave(KErrCorrupt);

   687 			}

   688 		}	

   689 	

   690 	iAnimating = (frameInfo.iDelay != TTimeIntervalMicroSeconds(0) || IsMngImage(iLoadUtil));

   691 

   692 	iFrameNumber = 0;

   693 

   694 	iTime.HomeTime();

   695 	}

   696 

   697 void CVideoAppUi::ExtractFrameL()

   698 	{

   699 	if (iLoadFileName.Length() < KShortestPossiblePath)

   700 		return;

   701 

   702 	ASSERT(iLoadUtil);

   703 

   704 	Cancel();

   705 

   706 	TInt frameCount = iLoadUtil->FrameCount();

   707 

   708 	if (iFrameNumber >= frameCount)

   709 		iFrameNumber = 0;

   710 

   711 	CEikDialog* dialog = new(ELeave) CVideoCurrentFrameDialog(iFrameNumber,frameCount);

   712 	if (!dialog->ExecuteLD(R_VIDEO_FRAME_DIALOG))

   713 		return;

   714 

   715 	StartFrameOpen(ELoading);

   716 	}

   717 

   718 void CVideoAppUi::StartFrameOpen(TState aNextState, TBool aSizeFrame)

   719 	{

   720 	TRAPD(error, DoStartFrameOpenL(aSizeFrame));

   721 	if (error!=KErrNone)

   722 		iWalker->SelfComplete(error);

   723 	iState = aNextState; // what ever happens we go to next state, and will handle any error there

   724 	}

   725 

   726 void CVideoAppUi::DoStartFrameOpenL(TBool aSizeFrame)

   727 	{

   728 	ASSERT(iLoadUtil); // should be true by now

   729 	ASSERT(!iWalker->IsActive()); // we are going to use it

   730 

   731 	ASSERT(iFrameNumber>=0 && iFrameNumber<iLoadUtil->FrameCount());

   732 

   733 	// Set up extensions

   734 	if ( iClippingRect.IsEmpty() )

   735 		{

   736 		TRAPD(err, iLoadUtil->SetClippingRectL(NULL));

   737 		// Plugin may not support the call at all

   738 		if(err != KErrNone && err != KErrNotSupported)

   739 			{

   740 			User::Leave(err);

   741 			}

   742 		}

   743 	else

   744 		{

   745 		TRAPD(err,iLoadUtil->SetClippingRectL((iUseExtensions) ? &iClippingRect : NULL ));

   746 		// Plugin may not support the call at all

   747 		if(err == KErrNotSupported)

   748 			{

   749 			iEikonEnv->InfoMsg(_L("Clipping Not Supported using this codec."));

   750 			}

   751 		}

   752 	

   753 	TImageConvScaler* scaler = NULL;

   754 	TRAPD(err,scaler = iLoadUtil->ScalerL());

   755 	if ( err == KErrNone )

   756 		{

   757 		scaler->SetScalingL( (iUseExtensions) ? iScalingCoefficient : -1 , iScalingQuality);	

   758 		}

   759 	else if ( iScalingCoefficient != -1 && err == KErrNotSupported )

   760 		{

   761 		iEikonEnv->InfoMsg(_L("Scaler extension Not Supported using this codec."));

   762 		}

   763 		

   764 	

   765 	if ( iOperations.Count() )

   766 		{

   767 		TImageConvOperation* operation = NULL;

   768 		TRAPD(err,operation = iLoadUtil->OperationL());

   769 		if ( err == KErrNone )

   770 			{

   771 			operation->ClearOperationStack();

   772 			

   773 			if ( iUseExtensions)

   774 				{

   775 				for ( TInt i = 0; i < iOperations.Count(); i++)

   776 					{

   777 					operation->AddOperationL(static_cast<TImageConvOperation::TOperation>(iOperations[i]));

   778 					}

   779 				}

   780 			}

   781 		else if ( err == KErrNotSupported )

   782 			{

   783 			iEikonEnv->InfoMsg(_L("Operations Not Supported using this codec."));

   784 			}

   785 		}

   786 

   787 	if (aSizeFrame)

   788 		{

   789 		TFrameInfo frameInfo = iLoadUtil->FrameInfo(iFrameNumber);

   790 

   791 		if (iFrame.Handle() == 0) // Only create the bitmap if we haven't done it already.

   792 			{

   793 			if ( !iUseNativeDisplayMode && (frameInfo.iFlags & TFrameInfo::ECanDither) )

   794 				User::LeaveIfError(iFrame.Create(TSize(0,0),iAppView->DisplayMode())); 

   795 			else

   796 				User::LeaveIfError(iFrame.Create(TSize(0,0),frameInfo.iFrameDisplayMode)); 

   797 			}

   798 

   799 		// with 16MA and 16MAP we don't use the mask anymore, this since the introduction

   800 		// with CR894 & CR1111 of alpha channel support in PNG decoding

   801 

   802 		if (frameInfo.iFlags & TFrameInfo::ETransparencyPossible && !iDisableMask

   803 			 && iAppView->DisplayMode() != EColor16MA && iAppView->DisplayMode() != EColor16MAP )

   804 			{

   805 			if (iMask.Handle() == 0)

   806 				User::LeaveIfError(iMask.Create(TSize(0,0),EGray256));

   807 			}

   808 		else

   809 			{

   810 			if (iMask.Handle())

   811 				iMask.Reset();

   812 			}

   813 

   814 		

   815 		SetFrameSizeAndPosL(frameInfo.iFrameCoordsInPixels,frameInfo.iOverallSizeInPixels); 

   816 		}

   817 

   818 	ASSERT(iDisableMask && iMask.Handle()==0 || !iDisableMask); // iDisableMask -> iMask.Handle()==0

   819 	ASSERT(iMask.Handle()==0 || iFrame.SizeInPixels()==iMask.SizeInPixels()); // if mask must be same size

   820 	

   821 	// DEF090667: T: SetDisplayMode causes another file to be opened with wrong size

   822 	if(iFrameNumber == 0)

   823 		{

   824 		iAppView->Reset(ENoDrawNow);

   825 		}

   826 

   827 	if (iMask.Handle())

   828 		iLoadUtil->Convert(&(iWalker->ActiveStatus()),iFrame,iMask,iFrameNumber); 

   829 	else

   830 		iLoadUtil->Convert(&(iWalker->ActiveStatus()),iFrame,iFrameNumber); 

   831 

   832 	iViewResized = EFalse;

   833 	}

   834 	

   835 TBool CVideoAppUi::ExtensionIsSetup()

   836 	{

   837 	return ( ( !iClippingRect.IsEmpty() ) || Abs(iScalingCoefficient) > 1 || iOperations.Count() );

   838 	}

   839 

   840 void CVideoAppUi::PlayClipL()

   841 	{

   842 	iFrameNumber = 0;

   843 	iTime.HomeTime();

   844 

   845 	StartFrameOpen(EPlaying);

   846 	}

   847 

   848 void CVideoAppUi::SaveAsL()

   849 	{

   850 	if (iSaveFileName.Length() < KShortestPossiblePath)

   851 		iSaveFileName = KDefPath;

   852 

   853 	Cancel();

   854 

   855 	CEikDialog* dialog = new(ELeave) CVideoSaveAsDialog(&iSaveFileName,iSaveInfo,iEncodeOperations,iCreateThumbnail,iSaveAsEXIF);

   856 	if (!dialog->ExecuteLD(R_VIDEO_FILE_SAVEAS_DIALOG))

   857 		return;

   858 	iEikonEnv->FsSession().Delete(iSaveFileName);

   859 

   860 	delete iFrameImageData; iFrameImageData = NULL;

   861 

   862 	const TUid imageType = iSaveInfo.iImageTypeUid;

   863 	TImageDataBlock *imageData = NULL;

   864 	TFrameDataBlock *frameData = NULL;

   865 

   866 	if(imageType == KImageTypeBMPUid)

   867 		{

   868 		imageData = new (ELeave) TBmpImageData;

   869 		TBmpImageData* data = STATIC_CAST(TBmpImageData*, imageData);

   870 		switch (iSaveInfo.iBpp)

   871 			{

   872 		case 0:		data->iBitsPerPixel = 1; break;

   873 		case 2:		data->iBitsPerPixel = 4; break;

   874 		case 3:		data->iBitsPerPixel = 8; break;

   875 		case 6:		data->iBitsPerPixel = 24; break;

   876 		default:	ASSERT(EFalse);			break;

   877 			}

   878 		}

   879 	else if(imageType == KImageTypeGIFUid)

   880 		{// gif does not have encoding options

   881 		}

   882 	else if(imageType == KImageTypeJPGUid)

   883 		{

   884 		imageData = new (ELeave) TJpegImageData;

   885 		TJpegImageData* data = STATIC_CAST(TJpegImageData*, imageData);

   886 		if (!iSaveInfo.iColor)

   887 			data->iSampleScheme = TJpegImageData::EMonochrome;

   888 		else

   889 			data->iSampleScheme = TJpegImageData::TColorSampling(3 - iSaveInfo.iSampling);

   890 		data->iQualityFactor = iSaveInfo.iQualityFactor;

   891 		}

   892 	else if(imageType == KImageTypeMBMUid)

   893 		{

   894 		frameData = new (ELeave) TMbmEncodeData;

   895 		TMbmEncodeData* data = STATIC_CAST(TMbmEncodeData*, frameData);

   896 		switch (iSaveInfo.iBpp)

   897 			{

   898 		case 0:		data->iDisplayMode = EGray2;		break;

   899 		case 1:		data->iDisplayMode = EGray4;		break;

   900 		case 2:		data->iDisplayMode = iSaveInfo.iColor ? EColor16 : EGray16;	break;

   901 		case 3:		data->iDisplayMode = iSaveInfo.iColor ? EColor256 : EGray256;	break;

   902 		case 4:		data->iDisplayMode = EColor4K;		break;

   903 		case 5:		data->iDisplayMode = EColor64K;	break;

   904 		case 6:		data->iDisplayMode = EColor16M;	break;

   905 		case 7:		data->iDisplayMode = EColor16MU;	break;		

   906 		default:	ASSERT(EFalse);	break;

   907 			}

   908 		}

   909 	else if(imageType == KImageTypePNGUid)

   910 		{

   911 		frameData = new (ELeave) TPngEncodeData;

   912 		TPngEncodeData* data = STATIC_CAST(TPngEncodeData*, frameData);

   913 		// bpp

   914 		switch (iSaveInfo.iBpp)

   915 			{

   916 			case 0:		data->iBitsPerPixel = 1; break;		// 1 bpp 

   917 			case 1:		data->iBitsPerPixel = 2; break;		// 2 bpp

   918 			case 2:		data->iBitsPerPixel = 4; break;		// 4 bpp

   919 			case 3:		data->iBitsPerPixel = 8; break;		// 8 bpp

   920 			case 6:		data->iBitsPerPixel = 24; break;	// 24 bpp

   921 			default:	ASSERT(EFalse);	break;				// unsupported bit depth

   922 			}

   923 		// colour or grayscale?

   924 		data->iColor = iSaveInfo.iColor;

   925 		// compression level

   926 		switch (iSaveInfo.iCompression)

   927 			{

   928 			case 0:

   929 				data->iLevel = TPngEncodeData::EDefaultCompression;

   930 				break;

   931 			case 1:

   932 				data->iLevel = TPngEncodeData::ENoCompression;

   933 				break;

   934 			case 2:

   935 				data->iLevel = TPngEncodeData::EBestSpeed;

   936 				break;

   937 			case 3:

   938 				data->iLevel = TPngEncodeData::EBestCompression;

   939 				break;

   940 			default:			// unsupported compression

   941 				ASSERT(EFalse);

   942 				break;		

   943 			}

   944 		}

   945 	else

   946 		{

   947 		//custom encoder

   948 		}

   949 

   950 	if (frameData)

   951 		CleanupStack::PushL(frameData);

   952 

   953 	if (imageData)

   954 		CleanupStack::PushL(imageData);

   955 

   956 	delete iSaveUtil; iSaveUtil = NULL;

   957 	if ( iSaveAsEXIF && (imageType == KImageTypeJPGUid) )

   958 		{

   959 		iSaveUtil = CJPEGExifEncoder::FileNewL(iCoeEnv->FsSession(), iSaveFileName, CImageEncoder::EOptionNone, imageType);

   960 		// force creation of metadata - this will cause save as EXIF rather than JFIF

   961 	    MExifMetadataWriter* metaData=static_cast<CJPEGExifEncoder*>(iSaveUtil)->ExifMetadata(); 

   962 		}

   963 		else

   964 		{

   965 		iSaveUtil = CImageEncoder::FileNewL(iCoeEnv->FsSession(), iSaveFileName, CImageEncoder::EOptionNone, imageType);		

   966 		}

   967 

   968 

   969 	ASSERT(iFrameImageData==NULL); // deleted above

   970 	if (imageData)

   971 		{

   972 		iFrameImageData = CFrameImageData::NewL();

   973 

   974 		User::LeaveIfError(iFrameImageData->AppendImageData(imageData));

   975 		CleanupStack::Pop(); // imageData - ownership now passed to iFrameImageData

   976 		}

   977 

   978 	if (frameData)

   979 		{

   980 		if (iFrameImageData == NULL)

   981 			iFrameImageData = CFrameImageData::NewL();

   982 

   983 		User::LeaveIfError(iFrameImageData->AppendFrameData(frameData));

   984 		CleanupStack::Pop(); // frameData - ownership now passed to iFrameImageData

   985 		}

   986 		

   987 	if (iCreateThumbnail)

   988 	{

   989 		iSaveUtil->SetThumbnail(iCreateThumbnail);

   990 	}

   991 		

   992 	if ( iEncodeOperations.Count() )

   993 		{

   994 		TImageConvOperation* operation = NULL;

   995 		TRAPD(err, operation = iSaveUtil->OperationL());

   996 		if ( err == KErrNone )

   997 			{

   998 			operation->ClearOperationStack();

   999 			

  1000 			for ( TInt i = 0; i < iEncodeOperations.Count(); i++)

  1001 				{

  1002 				operation->AddOperationL(static_cast<TImageConvOperation::TOperation>(iEncodeOperations[i]));

  1003 				}

  1004 			}

  1005 		}

  1006 

  1007 	StartFrameSave();

  1008 	}

  1009 

  1010 void CVideoAppUi::DisplayModeL()

  1011 	{

  1012 	Cancel();

  1013 	TDisplayMode displayMode = iAppView->DisplayMode();

  1014 	CEikDialog* dialog = new(ELeave) CVideoDisplayModeDialog(displayMode,iUseNativeDisplayMode);

  1015 	if (dialog->ExecuteLD(R_VIDEO_DISPLAY_MODE_DIALOG))

  1016 		{

  1017 		if ( iUseNativeDisplayMode && iLoadUtil )

  1018 			{

  1019 			TFrameInfo frameInfo = iLoadUtil->FrameInfo(0);

  1020 			displayMode = frameInfo.iFrameDisplayMode;

  1021 			}

  1022 

  1023 		iAppView->SetDisplayModeL(displayMode, &iFrame);

  1024 		}

  1025 	}

  1026 

  1027 void CVideoAppUi::BackgroundColorL()

  1028 	{

  1029 	Cancel();

  1030 	TInt backgroundColor = iBackgroundColor;

  1031 	TBool override = iOverrideBackgroundColor;

  1032 	CEikDialog* dialog = new(ELeave) CVideoBackgroundColorDialog(backgroundColor, override);

  1033 	if (dialog->ExecuteLD(R_VIDEO_BACKGROUND_COLOR_DIALOG))

  1034 		{

  1035 		iBackgroundColor = backgroundColor;

  1036 		iOverrideBackgroundColor = override;

  1037 		if (iOverrideBackgroundColor)

  1038 			{

  1039 			iAppView->SetBackgroundColor(TRgb::Color16(iBackgroundColor), ENoDrawNow);

  1040 			iAppView->Clear(ENoDrawNow);

  1041 			//redraw without reloading

  1042 			if (iMask.Handle()==0)

  1043 				iAppView->DrawImage(&iFrame, iOffset, EDrawNow);

  1044 			else

  1045 				iAppView->DrawImage(&iFrame, &iMask, iOffset, EDrawNow);

  1046 			}

  1047 		}

  1048 	}

  1049 

  1050 void CVideoAppUi::StreamPlayL(TFileType aFileType, TBool aMultiFrameStreaming)

  1051 	{

  1052 	Cancel();

  1053 	iLastFileType = aFileType;

  1054 	iMultiFrameStreaming = aMultiFrameStreaming;

  1055 

  1056 	if (iLoadFileName.Length() < 4)

  1057 		iLoadFileName = KDefPath;

  1058 	CEikDialog* dialog = new(ELeave) CEikFileOpenDialog(&iLoadFileName);

  1059 	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

  1060 		return;

  1061 

  1062 	delete iLoadUtil; iLoadUtil = NULL;

  1063 

  1064 	User::Free(REINTERPRET_CAST(TAny*,CONST_CAST(TUint8*, iStreamBuffer.Ptr())));

  1065 	iStreamBuffer.Set(NULL, 0, 0);

  1066 

  1067 	RFile file;

  1068 	User::LeaveIfError(file.Open(iEikonEnv->FsSession(), iLoadFileName, EFileShareReadersOnly|EFileStream|EFileRead));

  1069 	CleanupClosePushL(file);

  1070 	TInt fileSize;

  1071 	User::LeaveIfError(file.Size(fileSize));

  1072 	iStreamBuffer.Set(STATIC_CAST(TUint8 *, User::AllocL(fileSize)), 0, fileSize);

  1073 	User::LeaveIfError(file.Read(iStreamBuffer));

  1074 	CleanupStack::PopAndDestroy(); // file

  1075 

  1076 	iEikonEnv->BusyMsgL(_L("Busy..."));

  1077 

  1078 	// NB. State machine assumes no leaves after this point

  1079 

  1080 	ASSERT(!iStreamGen->IsActive()); // no async behav should be going on at this point

  1081 	ASSERT(!iWalker->IsActive());

  1082 

  1083 	// initialize the buffer

  1084 	iStreamBuffer.SetLength(0); // data is in buffer, and we increase length to simulate data arriving

  1085 	User::LeaveIfError(ExtendStreamBuffer());

  1086 

  1087 	iState = EStreamOpening;

  1088 	}

  1089 

  1090 TInt CVideoAppUi::ExtendStreamBuffer()

  1091 	{

  1092 //	ASSERT(iStreamBuffer.Length()<iStreamBuffer.MaxLength()); // assumed we don't call when no more streaming to do

  1093 

  1094 	// We CAN get called when there's no more data if the decoders have failed

  1095 	// to detect end-of-data - e.g. when the input file's header contains a length

  1096 	// greater than the file size - so return KErrUnderflow if this happens

  1097 	ASSERT(iStreamBuffer.Length() <= iStreamBuffer.MaxLength()); 

  1098 	if (iStreamBuffer.Length() == iStreamBuffer.MaxLength())

  1099 		return KErrUnderflow;

  1100 

  1101 	// 95% change of 128 bytes - else random 1..128

  1102 	TInt chance = Math::Rand(iStreamSeed) % 100;

  1103 	TInt increment;

  1104 	if (chance < 95)

  1105 		increment = 128;

  1106 	else

  1107 		increment = Math::Rand(iStreamSeed) % 127 + 1; // 1 .. 128

  1108 	TInt newSize = Min(iStreamBuffer.Length()+increment, iStreamBuffer.MaxLength());

  1109 	iStreamBuffer.SetLength(newSize);

  1110 

  1111 	// random time is 99% chance between 0 and 1/20s, with remainder between 0 and 5s

  1112 	chance = Math::Rand(iStreamSeed) % 100;

  1113 	TInt waitTime;

  1114 	if (chance>=99)

  1115 		waitTime = Math::Rand(iStreamSeed) % 5000000;

  1116 	else

  1117 		waitTime = Math::Rand(iStreamSeed) % 50000;

  1118 

  1119 	iStreamTimer.After(iStreamGen->ActiveStatus(), waitTime);

  1120 	iSourceHasGrown = ETrue;

  1121 

  1122 #if defined(_DEBUG) && defined(__ENABLE_DEBUG_OUTPUT)

  1123 	RDebug::Print(_L("ExtendingStreamBuffer(%d,%d->%d)"), increment, waitTime, newSize); 

  1124 #endif 

  1125 

  1126 	return KErrNone;

  1127 	}

  1128 

  1129 void CVideoAppUi::FrameInfoL()

  1130 	{

  1131 	if (iFrame.Handle() == 0)

  1132 		return;

  1133 

  1134 	Cancel();

  1135