# HG changeset patch # User hgs # Date 1283560622 18000 # Node ID e1b6d78dfe6a910b3ec0accc0afa18bd6146c056 # Parent b818131c88a34cedac3cdf29bffed2cfc0f397bc 201035 diff -r b818131c88a3 -r e1b6d78dfe6a group/bld.inf --- a/group/bld.inf Wed Aug 25 00:54:11 2010 -0500 +++ b/group/bld.inf Fri Sep 03 19:37:02 2010 -0500 @@ -1,20 +1,18 @@ /* -* ============================================================================== -* Name : bld.inf -* Part of : -* Description : -* Version : +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". * -* Copyright © 2006 Nokia. All rights reserved. -* This material, including documentation and any related -* computer programs, is protected by copyright controlled by -* Nokia Corporation. All rights are reserved. Copying, -* including reproducing, storing, adapting or translating, any -* or all of this material requires the prior written consent of -* Nokia. This material also contains confidential -* information which may not be disclosed to others without the -* prior written consent of Nokia. -* ============================================================================== +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Build information file for helix +* */ #include diff -r b818131c88a3 -r e1b6d78dfe6a helix_ren/group/bld.inf --- a/helix_ren/group/bld.inf Wed Aug 25 00:54:11 2010 -0500 +++ b/helix_ren/group/bld.inf Fri Sep 03 19:37:02 2010 -0500 @@ -1,20 +1,18 @@ /* -* ============================================================================== -* Name : bld.inf -* Part of : HELIXENGINE -* Description : This main bld.inf file for HELIX_MDF -* Version : +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". * -* Copyright © 2006 Nokia Corporation. -* This material, including documentation and any related -* computer programs, is protected by copyright controlled by -* Nokia Corporation. All rights are reserved. Copying, -* including reproducing, storing, adapting or translating, any -* or all of this material requires the prior written consent of -* Nokia Corporation. This material also contains confidential -* information which may not be disclosed to others without the -* prior written consent of Nokia Corporation. -* ============================================================================== +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Build information file for helix +* */ #include diff -r b818131c88a3 -r e1b6d78dfe6a package_definition.xml --- a/package_definition.xml Wed Aug 25 00:54:11 2010 -0500 +++ b/package_definition.xml Fri Sep 03 19:37:02 2010 -0500 @@ -1,8 +1,8 @@ - - - + + + @@ -11,6 +11,11 @@ - + + + + + + diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/common/testappbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/common/testappbase.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,1330 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Source file containing common test app functionality. + * + */ + +#include +#include +#include + +#include "testappbase.h" + +const TInt KLeftSoftKeyCode = EKeyDevice0; +const TInt KRightSoftKeyCode = EKeyDevice1; + +const TInt KHelpWindowBorderPixels = 20; +const TInt KHelpWindowSpaceBetweenColumns = 25; +const TInt KHelpWindowSpaceBetweenRows = 2; + +struct TKeyListEntry + { + TInt keyCode; + const TText* keyName; + }; + +const TKeyListEntry KSupportedKeys[KSupportedKeysCount] = + { + {EKeyEnter, STR("Enter")}, + {EKeyUpArrow, STR("Up")}, + {EKeyDownArrow, STR("Down")}, + {EKeyLeftArrow, STR("Left")}, + {EKeyRightArrow, STR("Right")}, + {'0', STR("0")}, + {'1', STR("1")}, + {'2', STR("2")}, + {'3', STR("3")}, + {'4', STR("4")}, + {'5', STR("5")}, + {'6', STR("6")}, + {'7', STR("7")}, + {'8', STR("8")}, + {'9', STR("9")}, + {'*', STR("*")}, + {'#', STR("#")} + }; + +static TPtrC KeyName( TInt aIndex ) + { + return TPtrC(KSupportedKeys[aIndex].keyName); + } + +// Portable app implementation + +CTestAppBase::CTestAppBase( TInt aFontSize ) : + CActive( EPriorityStandard ), + iFontSize( aFontSize ), + iHelpSemitransparentBackgroundActive( true ) + { + CActiveScheduler::Add(this); + } + +CTestAppBase::~CTestAppBase() + { + delete iInterfaceSelector; + delete iHelpWindow; + delete iSelectionWindow; + delete iGc; + delete iWindowGroup; + delete iScreenDevice; + delete iTypefaceStore; + iWs.Close(); + iFs.Close(); + iFileHistory.ResetAndDestroy(); + } + +void CTestAppBase::BaseConstructL( const TOperationsPage* aKeyMap, TInt aPageCount ) + { + iKeyMap = aKeyMap; + iPageCount = aPageCount; + + User::LeaveIfError( iFs.Connect() ); + + User::LeaveIfError( iWs.Connect() ); + + iScreenDevice = new(ELeave) CWsScreenDevice( iWs ); + User::LeaveIfError( iScreenDevice->Construct() ); + iDisplaySize = iScreenDevice->SizeInPixels(); + + User::LeaveIfError( iScreenDevice->CreateContext(iGc) ); + + iWindowGroup = new(ELeave) RWindowGroup( iWs ); + User::LeaveIfError( iWindowGroup->Construct( KNullWsHandle ) ); + + iSelectionWindow = new(ELeave) RWindow( iWs ); + User::LeaveIfError( iSelectionWindow->Construct( *iWindowGroup, KNullWsHandle ) ); + iSelectionWindow->SetVisible(false); + iSelectionWindow->Activate(); + + // Load the font to be used for all text operations. + TFontSpec fontSpec; + fontSpec.iHeight = iFontSize; + iTypefaceStore = CFbsTypefaceStore::NewL(NULL); + + User::LeaveIfError( iTypefaceStore->GetNearestFontToDesignHeightInPixels(iFont, fontSpec) ); + + CalculateHelpWindowSize(); + + iHelpWindowTopRight = TPoint(iDisplaySize.iWidth/2 - iHelpWindowSize.iWidth/2, + iDisplaySize.iHeight/2 - iHelpWindowSize.iHeight/2); + + iHelpWindow = new(ELeave) RWindow( iWs ); + User::LeaveIfError( iHelpWindow->Construct( *iWindowGroup, KNullWsHandle ) ); + iHelpWindow->SetExtent( iHelpWindowTopRight, iHelpWindowSize ); + iHelpWindow->SetTransparencyAlphaChannel(); + iHelpWindow->SetBackgroundColor(KRgbTransparent); + iHelpWindow->SetVisible(false); + iHelpWindow->Activate(); + iHelpWindow->PointerFilter(EPointerFilterDrag, 0); + + // Initialize soft key indices + for( TInt i = 0; i < aPageCount; i++ ) + { + iSoftkeyIndices[i] = iKeyMap[i].defaultSoftkeyIndex; + } + + // Only need to draw the help text when the options page is changed. Window is displayed later by + // toggling the visibility of the window. + DrawHelpText(); + + // THE FOLLOWING CODE IS COMMENTED OUT BECAUSE IT CAUSES A CRASH IN NCP BUILDS. + // THIS CAN BE ENABLED IN DFS BUILDS, TO ALLOW FOR TWO BUTTON OPERATION USING THE VOLUME KEYS. + // + // Since some phone have no keyboard or soft keys, treat the volume keys like the soft keys. + // SetupVolumeKeysL(); + } + +void CTestAppBase::SetupVolumeKeysL() + { + iInterfaceSelector = CRemConInterfaceSelector::NewL(); + iCoreTarget = CRemConCoreApiTarget::NewL(*iInterfaceSelector, *this); + iInterfaceSelector->OpenTargetL(); + } + +void CTestAppBase::StartMonitoringWindowEvents() + { + // Request notification for windows server events, to detect key presses. + SetActive(); + iWs.EventReady( &iStatus ); + } + +TInt CTestAppBase::CurrentPageNumber() + { + return iCurrentPage+1; + } + +TPtrC CTestAppBase::CurrentPageName() + { + return TPtrC(iKeyMap[iCurrentPage].pageName); + } + +TPtrC CTestAppBase::CurrentSoftkeyName() + { + return TPtrC(iKeyMap[iCurrentPage].mapping[iSoftkeyIndices[iCurrentPage]].text); + } + +TPtrC CTestAppBase::KeyMapText( TInt aIndex, TInt aPage ) + { + return TPtrC(iKeyMap[aPage].mapping[aIndex].text); + } + +TInt CTestAppBase::KeyMapOperation(TInt aIndex, TInt aPage ) + { + return iKeyMap[aPage].mapping[aIndex].operation; + } + +void CTestAppBase::IncrementKeymapIndex( TInt& aIndex, TInt aPage ) + { + aIndex = (aIndex + 1) % KSupportedKeysCount; + while( iKeyMap[aPage].mapping[aIndex].operation == KOperation_None ) + { + aIndex = (aIndex + 1) % KSupportedKeysCount; + } + } + +void CTestAppBase::DecrementKeymapIndex( TInt& aIndex, TInt aPage ) + { + aIndex = (aIndex + KSupportedKeysCount - 1) % KSupportedKeysCount; + while( iKeyMap[aPage].mapping[aIndex].operation == KOperation_None ) + { + aIndex = (aIndex + KSupportedKeysCount - 1) % KSupportedKeysCount; + } + } + +void CTestAppBase::CalculateHelpWindowSize() + { + iHelpWindowColumn1Width = 0; + iHelpWindowColumn2Width = 0; + + // Find the widest strings for each column to determine the width of the window. + for( TInt index = 0; index < KSupportedKeysCount; index++ ) + { + TInt width = iFont->TextWidthInPixels(KeyName(index)); + if( width > iHelpWindowColumn1Width ) + { + iHelpWindowColumn1Width = width; + } + + for( TInt index2 = 0; index2 < iPageCount; index2++ ) + { + width = iFont->TextWidthInPixels(KeyMapText(index,index2)); + if( width > iHelpWindowColumn2Width ) + { + iHelpWindowColumn2Width = width; + } + } + } + + iHelpWindowSize.iWidth = 2*KHelpWindowBorderPixels + iHelpWindowColumn1Width + + KHelpWindowSpaceBetweenColumns + iHelpWindowColumn2Width; + + iHelpWindowSize.iHeight = 2*KHelpWindowBorderPixels + iFontSize*KSupportedKeysCount + + KHelpWindowSpaceBetweenRows*(KSupportedKeysCount-1); + } + +void CTestAppBase::StartReceivingPointerEvents() + { + iRoutePointerEventsToApp = true; + } + +void CTestAppBase::StopReceivingPointerEvents() + { + iRoutePointerEventsToApp = false; + } + +//virtual void HandlePointerEvent( const TPointerEvent& aEvent ) {} + +CTestAppBase::TTestAppPointerEvent CTestAppBase::CharacterizePointerEvent( const TAdvancedPointerEvent& event ) + { + TTestAppPointerEvent returnValue = EPointerEvent_None; + + RDebug::Printf( "POINTER EVENT:" ); + RDebug::Printf( "iType=%i", event.iType ); + RDebug::Printf( "iModifiers=%x", event.iModifiers ); + RDebug::Printf( "iPosition=%i,%i", event.iPosition.iX, event.iPosition.iY ); + RDebug::Printf( "iParentPosition=%i,%i", event.iParentPosition.iX, event.iParentPosition.iY ); + RDebug::Printf( "PointerNumber=%i", event.PointerNumber() ); + RDebug::Printf( "Proximity=%i", event.Proximity() ); + RDebug::Printf( "Pressure=%i", event.Pressure() ); + RDebug::Printf( "ProximityAndPressure=%i", event.ProximityAndPressure() ); + RDebug::Printf( "Position3D=%i,%i,%i", event.Position3D().iX, event.Position3D().iY, event.Position3D().iZ ); + RDebug::Printf( "Pressure3D=%i,%i,%i", event.Pressure3D().iX, event.Pressure3D().iY, event.Pressure3D().iZ ); + RDebug::Printf( "PositionAndPressure3D=%i,%i,%i", event.PositionAndPressure3D().iX, event.PositionAndPressure3D().iY, event.PositionAndPressure3D().iZ ); + + switch( event.iType ) + { + case TPointerEvent::EButton1Down: + { + iPointerDownPosition = event.iPosition; + break; + } + case TPointerEvent::EButton1Up: + { + TInt xDelta = event.iPosition.iX - iPointerDownPosition.iX; + TInt yDelta = event.iPosition.iY - iPointerDownPosition.iY; + + TInt xMagnitude = xDelta; + if( xMagnitude < 0 ) + { + xMagnitude = -xMagnitude; + } + + TInt yMagnitude = yDelta; + if( yMagnitude < 0 ) + { + yMagnitude = -yMagnitude; + } + + const TInt KTapThreshold = 30; + + if( yMagnitude > xMagnitude ) + { + if( yMagnitude < KTapThreshold ) + { + RDebug::Printf( "POINTER EVENT ENTER x=%i y=%i", xDelta, yDelta ); + returnValue = EPointerEvent_Select; + } + else if( yDelta < 0 ) + { + RDebug::Printf( "POINTER EVENT UP x=%i y=%i", xDelta, yDelta ); + returnValue = EPointerEvent_Up; + } + else + { + RDebug::Printf( "POINTER EVENT DOWN x=%i y=%i", xDelta, yDelta ); + returnValue = EPointerEvent_Down; + } + } + else + { + if( xMagnitude < KTapThreshold ) + { + RDebug::Printf( "POINTER EVENT ENTER x=%i y=%i", xDelta, yDelta ); + returnValue = EPointerEvent_Select; + } + else if( xDelta < 0 ) + { + RDebug::Printf( "POINTER EVENT LEFT x=%i y=%i", xDelta, yDelta ); + returnValue = EPointerEvent_Left; + } + else + { + RDebug::Printf( "POINTER EVENT RIGHT x=%i y=%i", xDelta, yDelta ); + returnValue = EPointerEvent_Right; + } + } + break; + } + } + + return returnValue; + } + +void CTestAppBase::RunL() + { + if( iWait.IsStarted() ) + { + // This is an event during synchronous list selection. Stop the nested scheduler. + iWait.AsyncStop(); + return; + } + + TWsEvent event; + iWs.GetEvent(event); + + TInt operationIndex = -1; + + TInt keyCode = 0; + bool processKeyCode = false; + + TInt operation = KOperation_None; + + // Other potentially useful events are EEventKeyUp and EEventKeyDown. + + if( event.Type() == EEventKey ) + { + keyCode = event.Key()->iCode; + + RDebug::Printf( "key event keyCode=%x/%c scanCode=%x/%c", keyCode, keyCode, event.Key()->iScanCode, event.Key()->iScanCode ); + + // Allow subclasses a chance to consume the key event directly. If that happens, then + // do not handle the key as normal. + if( !ConsumeKeyEvent( keyCode ) ) + { + processKeyCode = true; + } + } + else if( event.Type() == EEventPointer ) + { + TAdvancedPointerEvent* p = event.Pointer(); + + if( iRoutePointerEventsToApp ) + { + HandlePointerEvent( *p ); + } + else + { + TTestAppPointerEvent pointerEvent = CharacterizePointerEvent( *p ); + + switch( pointerEvent ) + { + case EPointerEvent_None: + // Do nothing. + break; + case EPointerEvent_Up: + operation = KOperation_PreviousOption; + break; + case EPointerEvent_Down: + operation = KOperation_NextOption; + break; + case EPointerEvent_Left: + operation = KOperation_PreviousOptionPage; + break; + case EPointerEvent_Right: + operation = KOperation_NextOptionPage; + break; + case EPointerEvent_Select: + operation = KOperation_ExecuteOption; + break; + } + } + } + else + { + RDebug::Printf( "other event, type=%i", event.Type() ); + } + + if( processKeyCode ) + { + // If one of the softkeys were pressed then take the appropriate action. + // This is to support a two button touch device with no numeric keypad. + // Support 'A' and 'B' also, for the NCP emulator where a keyboard is + // not displayed. + switch( keyCode ) + { + case KLeftSoftKeyCode: + case 'a': + case 'A': + { + operation = KOperation_NextOption; + break; + } + case KRightSoftKeyCode: + case 'b': + case 'B': + { + // Execute softkey function. + operation = KOperation_ExecuteOption; + break; + } + default: + { + // Search for keycode in keymap. If not found then the key was not a valid + // key, so ignore. + TInt index = 0; + while( (index < KSupportedKeysCount) && (operationIndex == -1)) + { + if( KSupportedKeys[index].keyCode == keyCode ) + { + // Found! + operationIndex = index; + } + else + { + index++; + } + } + break; + } + } + } + + if( operation == KOperation_ExecuteOption ) + { + operationIndex = iSoftkeyIndices[iCurrentPage]; + } + + if( operationIndex >= 0 ) + { + operation = KeyMapOperation(operationIndex, iCurrentPage); + } + + if( operation != KOperation_None ) + { + // Valid operation. + + switch( operation ) + { + case KOperation_Exit: + { + CActiveScheduler::Stop(); + break; + } + case KOperation_PreviousOption: + { + // Change softkey function. + DecrementKeymapIndex( iSoftkeyIndices[iCurrentPage], iCurrentPage ); + + // Redraw help text, since a new function should now be underlined. + DrawHelpText(); + + // Notify subclass that softkey function has been updated. + SoftkeyFunctionUpdated(); + break; + } + case KOperation_NextOption: + { + // Change softkey function. + IncrementKeymapIndex( iSoftkeyIndices[iCurrentPage], iCurrentPage ); + + // Redraw help text, since a new function should now be underlined. + DrawHelpText(); + + // Notify subclass that softkey function has been updated. + SoftkeyFunctionUpdated(); + break; + } + case KOperation_PreviousOptionPage: + { + iCurrentPage = (iCurrentPage + iPageCount - 1) % iPageCount; + DrawHelpText(); + SoftkeyFunctionUpdated(); + break; + } + case KOperation_NextOptionPage: + { + iCurrentPage = (iCurrentPage + 1) % iPageCount; + DrawHelpText(); + SoftkeyFunctionUpdated(); + break; + } + case KOperation_ToggleHelpVisibility: + { + // Toggle help text on/off. + iHelpActive = !iHelpActive; + iHelpWindow->SetVisible(iHelpActive); + break; + } + case KOperation_ToggleHelpTransparency: + { + iHelpSemitransparentBackgroundActive = !iHelpSemitransparentBackgroundActive; + if( iHelpSemitransparentBackgroundActive ) + { + // Turn on help if it is currently off. + iHelpActive = true; + iHelpWindow->SetVisible(true); + } + DrawHelpText(); + break; + } + default: + { + // Pass operation to subclass. + TPtrC operatioName( KeyMapText(operationIndex, iCurrentPage) ); + ExecuteOperation( operation, operatioName ); + break; + } + } + } + + SetActive(); + iWs.EventReady( &iStatus ); + } + +void CTestAppBase::DoCancel() + { + iWs.EventReadyCancel(); + } + +// TODO: ALLOW SUBCLASS TO SPECIFY COLOR SELECTIONS + +TInt CTestAppBase::SelectFromListL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + RPointerArray& aSelectionList, + TInt aInitialSelectionIndex ) + { + iSelectionWindow->SetExtent( aTopLeft, aSize ); + iSelectionWindow->SetVisible( true ); + + const TInt KRowIncrement = iFontSize + 2; + + TInt entriesPerPage = aSize.iHeight / KRowIncrement - 4; + + TInt returnValue = -2; + TInt startIndex = 0; + TInt selected = aInitialSelectionIndex; + + while( returnValue == -2 ) + { + iGc->Activate(*iSelectionWindow); + + iSelectionWindow->Invalidate(); + iSelectionWindow->BeginRedraw(); + + iGc->Reset(); + + iGc->UseFont(iFont); + iGc->SetBrushColor(KRgbDarkBlue); + + iGc->Clear(); + + // KRgbWhite seems to be having problems (0xffffff) in some emulators, + // but 0xfefefe is working, so use that instead of white. + iGc->SetPenColor(0xfefefe); + + const TInt KHeaderColumn = 5; + const TInt KEntryColumn = 15; + + TInt row = KRowIncrement; + + iGc->SetUnderlineStyle(EUnderlineOff); + + iGc->DrawText( aHeaderText, TPoint(KHeaderColumn, row) ); + row += (KRowIncrement + 5); + + TBool again = true; + TInt backIndex = -1; + TInt forwardIndex = -1; + TInt offset = 0; + + while( again ) + { + if( selected == offset ) + { + iGc->SetUnderlineStyle(EUnderlineOn); + } + else + { + iGc->SetUnderlineStyle(EUnderlineOff); + } + + if( (offset < entriesPerPage) && (startIndex+offset < aSelectionList.Count()) ) + { + iGc->DrawText( *aSelectionList[startIndex+offset], TPoint(KEntryColumn, row) ); + row += KRowIncrement; + + offset++; + } + else + { + again = false; + if( startIndex + offset < aSelectionList.Count() ) + { + iGc->DrawText( _L(""), TPoint(KEntryColumn, row) ); + row += KRowIncrement; + + forwardIndex = offset; + offset++; + } + if( startIndex > 0 ) + { + if( selected == offset ) + { + iGc->SetUnderlineStyle(EUnderlineOn); + } + else + { + iGc->SetUnderlineStyle(EUnderlineOff); + } + + iGc->DrawText( _L(""), TPoint(KEntryColumn, row) ); + row += KRowIncrement; + + backIndex = offset; + offset++; + } + } + } + + iSelectionWindow->EndRedraw(); + + iGc->Deactivate(); + + TInt keyCode = WaitForAnyKey(); + + switch( keyCode ) + { + case EKeyUpArrow: + if( selected == 0 ) + { + selected = offset-1; + } + else + { + selected -= 1; + } + break; + + case EKeyDownArrow: + case KLeftSoftKeyCode: + case 'a': + case 'A': + selected += 1; + if( selected == offset ) + { + selected = 0; + } + break; + + case EKeyLeftArrow: + if( backIndex >= 0 ) + { + startIndex -= entriesPerPage; + selected = 0; + } + else + { + returnValue = -1; + again = false; + } + break; + + case EKeyRightArrow: + if( forwardIndex >= 0 ) + { + startIndex += entriesPerPage; + selected = 0; + } + break; + + case EKeyEnter: + case KRightSoftKeyCode: + case 'b': + case 'B': + if( selected == forwardIndex ) + { + startIndex += entriesPerPage; + selected = 0; + } + else if( selected == backIndex ) + { + startIndex -= entriesPerPage; + selected = 0; + } + else + { + returnValue = startIndex+selected; + } + break; + } + } + + iSelectionWindow->SetVisible( false ); + + return returnValue; + } + +TInt CTestAppBase::SelectFromListL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + RPointerArray& aSelectionList, + TInt aInitialSelectionIndex ) + { + RPointerArray aSelectionList2; + + for( TInt index = 0; index < aSelectionList.Count(); index++ ) + { + aSelectionList2.Append( aSelectionList[index]); + } + + TInt returnValue = SelectFromListL( aTopLeft, aSize, aHeaderText, aSelectionList2, aInitialSelectionIndex ); + + aSelectionList2.Close(); + + return returnValue; + } + +void CTestAppBase::BuildDriveListL( RPointerArray& aDrives ) + { + TDriveList driveList; + TInt err = iFs.DriveList( driveList ); + + for( TInt index = 0; index < driveList.Length(); index++ ) + { + if( driveList[index] != 0 ) + { + HBufC* drive = HBufC::NewL( 2 ); + drive->Des().Format( _L("%c:"), 'A' + index); + aDrives.Append( drive ); + } + } + } + +bool CTestAppBase::SelectDriveL( TPoint aTopLeft, + TSize aWindowSize, + const TDesC& aHeaderText, + TDes& aDrive ) + { + RPointerArray drives; + BuildDriveListL( drives ); + + TInt index = SelectFromListL( aTopLeft, aWindowSize, aHeaderText, drives ); + + bool returnValue = false; + + if( index >= 0 ) + { + returnValue = true; + aDrive.Copy( *(drives[index]) ); + aDrive.Append( _L("\\") ); + } + + drives.ResetAndDestroy(); + + return returnValue; + } + +bool CTestAppBase::SelectFileL( TPoint aTopLeft, + TSize aWindowSize, + const TDesC& aHeaderText, + const TDesC& aDrive, + TDes& aFullFilename ) + { + TFileName directory; + + DoSelectFileL( aTopLeft, aWindowSize, aHeaderText, aDrive, 0, directory, aFullFilename ); + + aFullFilename.Insert( 0, directory ); + + return aFullFilename.Length() > 0; + } + +bool CTestAppBase::SelectFileWithHistoryL( TPoint aTopLeft, + TSize aSize, + TDes& aFullFilename, + const TDesC& aHistoryFilename, + TInt aMaxHistoryEntries, + const TDesC& aPrompt ) + { + RPointerArray drives; + BuildDriveListL( drives ); + + RPointerArray selections; + + for( TInt index = 0; index < drives.Count(); index++ ) + { + selections.Append( drives[index]); + } + TInt drivesBaseIndex = 0; + + // Add file history to the end of the drive list. Newest files are last, so add in reverse order. + // For convenience, add the last history entry at the top, before the drive list. + ReadFileHistory( aHistoryFilename ); + if( iFileHistory.Count() > 0 ) + { + selections.Insert( iFileHistory[iFileHistory.Count()-1], 0 ); + drivesBaseIndex++; + } + for(TInt index = iFileHistory.Count()-2; index >= 0; index-- ) + { + selections.Append( iFileHistory[index]); + } + + bool done = false; + bool selected = true; + + while( !done ) + { + TInt index = SelectFromListL( aTopLeft, aSize, aPrompt, selections ); + + if( index < 0 ) + { + selected = false; + done = true; + } + else if( (index >= drivesBaseIndex) && (index - drivesBaseIndex < drives.Count()) ) + { + TBuf<10> drive; + drive.Copy( *(selections[index]) ); + drive.Append( _L("\\") ); + + done = SelectFileL( aTopLeft, aSize, aPrompt, drive, aFullFilename ); + } + else + { + // Remove the selected file from the history, so that it will pop up to the top of the list + // as the most recently selected file. + TInt historyIndex; + if( index == 0 ) + { + historyIndex = iFileHistory.Count() - 1; + } + else + { + historyIndex = iFileHistory.Count() - index + drives.Count() - 1; + } + aFullFilename.Copy( *(selections[index]) ); + delete iFileHistory[historyIndex]; + iFileHistory.Remove( historyIndex ); + + done = true; + } + } + + if( selected ) + { + AddToFileHistory( aFullFilename, aHistoryFilename, aMaxHistoryEntries ); + } + + selections.Reset(); + drives.ResetAndDestroy(); + + return selected; + } + +bool CTestAppBase::SelectIntegerL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + TInt aMin, + TInt aMax, + TInt& aSelection ) + { + // currently no way to exit out of this selection + + iSelectionWindow->SetExtent( aTopLeft, aSize ); + iSelectionWindow->SetVisible( true ); + + bool done = false; + + while( !done ) + { + iGc->Activate(*iSelectionWindow); + + iSelectionWindow->Invalidate(); + iSelectionWindow->BeginRedraw(); + + iGc->Reset(); + + iGc->UseFont(iFont); + iGc->SetBrushColor(KRgbDarkBlue); + + iGc->Clear(); + + // KRgbWhite seems to be having problems (0xffffff) in some emulators, + // but 0xfefefe is working, so use that instead of white. + iGc->SetPenColor(0xfefefe); + + TBuf<120> buffer; + buffer.Copy( aHeaderText ); + buffer.AppendFormat( _L(" %i"), aSelection ); + + iGc->DrawText( buffer, TPoint(5, iFontSize+2) ); + + iSelectionWindow->EndRedraw(); + + iGc->Deactivate(); + + TInt keyCode = WaitForAnyKey(); + + switch( keyCode ) + { + case EKeyUpArrow: + aSelection -= 10; + break; + + case EKeyDownArrow: + case KLeftSoftKeyCode: + case 'a': + case 'A': + aSelection += 10; + break; + + case EKeyLeftArrow: + aSelection--; + break; + + case EKeyRightArrow: + aSelection++; + break; + + case EKeyEnter: + case KRightSoftKeyCode: + case 'b': + case 'B': + done = true; + break; + } + + if( aSelection > aMax ) + { + aSelection = aMin; + } + else if( aSelection < aMin ) + { + aSelection = aMax; + } + } + + iSelectionWindow->SetVisible( false ); + + return true; + } + +TInt CTestAppBase::WaitForAnyKey() + { + TInt returnValue = 0; + + bool done = false; + + while( !done ) + { + // Have to use this tricky nested active scheduler technique to allow the active object + // used to remap volume keys to run. + SetActive(); + iWs.EventReady( &iStatus ); + iWait.Start(); + + TWsEvent event; + iWs.GetEvent(event); + + // Other potentially useful events are EEventKeyUp and EEventKeyDown. + + if( event.Type() == EEventKey ) + { + done = true; + returnValue = event.Key()->iCode; + } + else if( event.Type() == EEventPointer ) + { + TAdvancedPointerEvent* p = event.Pointer(); + + TTestAppPointerEvent pointerEvent = CharacterizePointerEvent( *p ); + + switch( pointerEvent ) + { + case EPointerEvent_None: + // Do nothing. + break; + case EPointerEvent_Up: + returnValue = EKeyUpArrow; + done = true; + break; + case EPointerEvent_Down: + returnValue = EKeyDownArrow; + done = true; + break; + case EPointerEvent_Left: + returnValue = EKeyLeftArrow; + done = true; + break; + case EPointerEvent_Right: + returnValue = EKeyRightArrow; + done = true; + break; + case EPointerEvent_Select: + returnValue = EKeyEnter; + done = true; + break; + } + } + } + + return returnValue; + } + +TInt CTestAppBase::ReadFile( const TDesC& aFilename, RPointerArray& aContents ) + { + RFile inputFile; + TInt err = inputFile.Open(iFs, aFilename, EFileShareReadersOnly | EFileStream | EFileRead ); + + if( err == KErrNone ) + { + TInt fileSize; + inputFile.Size( fileSize ); + + RBuf8 contents; + contents.Create( fileSize ); + + inputFile.Read( contents, fileSize ); + + inputFile.Close(); + + TPtrC8 remaining( contents ); + + while( remaining.Length() > 0 ) + { + // Removing leading CR/LFs, if any. + while( remaining.Length() > 0 && (remaining[0] == '\n' || remaining[0] == '\r') ) + { + remaining.Set(remaining.Right(remaining.Length()-1)); + } + + if( remaining.Length() == 0 ) + { + break; + } + + // Find next CR/LF, or end of string. + TInt separatorIndex = 1; + while( (separatorIndex < remaining.Length()) && + (remaining[separatorIndex] != '\n') && + (remaining[separatorIndex] != '\r')) + { + separatorIndex++; + } + + HBufC* line = HBufC::NewL( separatorIndex ); + TPtrC8 line8 = remaining.Left( separatorIndex ); + line->Des().Copy( line8 ); + + aContents.Append( line ); + + TInt remainingLength = remaining.Length() - separatorIndex; + + remaining.Set(remaining.Right(remainingLength)); + } + + contents.Close(); + } + + return err; + } + +void CTestAppBase::ReadFileHistory( const TDesC& aHistoryFilename ) + { + iFileHistory.ResetAndDestroy(); + + ReadFile( aHistoryFilename, iFileHistory ); + } + +void CTestAppBase::AddToFileHistory( const TDesC& aFilename, const TDesC& aHistoryFilename, TInt aMaxHistoryEntries ) + { + HBufC* filename = HBufC::NewL( aFilename.Length() ); + filename->Des().Copy( aFilename ); + iFileHistory.Append( filename ); + + while( iFileHistory.Count() > aMaxHistoryEntries ) + { + delete iFileHistory[0]; + iFileHistory.Remove( 0 ); + } + + RFile historyFile; + TInt err = historyFile.Create(iFs, aHistoryFilename, EFileStream | EFileWrite ); + if( err == KErrAlreadyExists ) + { + err = historyFile.Open(iFs, aHistoryFilename, EFileStream | EFileWrite ); + historyFile.SetSize(0); + } + + if( err == KErrNone ) + { + for( TInt index = 0; index < iFileHistory.Count(); index++ ) + { + TBuf8 filename8; + filename8.Copy( iFileHistory[index]->Des() ); + historyFile.Write( filename8 ); + historyFile.Write( _L8("\n") ); + } + } + + historyFile.Close(); + } + +void CTestAppBase::DoSelectFileL( TPoint aTopRight, + TSize aWindowSize, + const TDesC& aHeaderText, + const TFileName& aDirectory, + TInt aDirectoryLevel, + TDes& aSelectedDirectory, + TDes& aSelectedFilename ) + { + RPointerArray fileNames; + + ReadDirectoryEntriesL( aDirectory, fileNames ); + + TInt initialSelectionIndex = 0; + + _LIT( KUp, ".." ); + if( aDirectoryLevel > 0 ) + { + TFileName* newEntry = new(ELeave) TFileName; + newEntry->Copy( KUp ); + fileNames.Insert( newEntry, 0 ); + initialSelectionIndex++; + } + + bool done = false; + + while( !done && (aSelectedFilename.Length() == 0) ) + { + TInt index = SelectFromListL( aTopRight, aWindowSize, aHeaderText, fileNames, initialSelectionIndex ); + + if( index < 0 || index >= fileNames.Count() ) + { + done = true; + } + else if( fileNames[index]->Compare(KUp) == 0 ) + { + // Go up one directory. Return to caller without setting aFilename + break; + } + else if( (*fileNames[index])[fileNames[index]->Length()-1] == '\\' ) + { + // Directory selected. + TFileName directory; + directory.Copy( aDirectory ); + directory.Append( *fileNames[index] ); + DoSelectFileL( aTopRight, aWindowSize, aHeaderText, directory, aDirectoryLevel+1, aSelectedDirectory, aSelectedFilename ); + } + else + { + // File selected. + aSelectedDirectory.Copy( aDirectory ); + aSelectedFilename.Copy( *fileNames[index] ); + done = true; + } + + } + + fileNames.ResetAndDestroy(); + } + +void CTestAppBase::ReadDirectoryEntriesL( const TFileName& aDirectoryName, RPointerArray& aFileNames ) + { + aFileNames.ResetAndDestroy(); + + RDir dir; + User::LeaveIfError( dir.Open( iFs, aDirectoryName, KEntryAttNormal|KEntryAttDir) ); + + TEntryArray entries; + TInt err = KErrNone; + TInt directoryCount = 0; + while( err == KErrNone ) + { + err = dir.Read( entries ); + + for( TInt index = 0; index < entries.Count(); index++ ) + { + // It was observed that not all devices sorted the list by default, so do an + // insertion sort here. + TFileName* newEntry = new(ELeave) TFileName; + newEntry->Copy( entries[index].iName ); + + // Put the directories first in the list. + if( entries[index].IsDir()) + { + newEntry->Append( _L("\\") ); + + TInt insertionIndex = 0; + while( insertionIndex < directoryCount && newEntry->CompareF(*aFileNames[insertionIndex]) > 0 ) + { + insertionIndex++; + } + aFileNames.Insert( newEntry, insertionIndex ); + + directoryCount++; + } + else + { + TInt insertionIndex = directoryCount; + while( insertionIndex < aFileNames.Count() && newEntry->CompareF(*aFileNames[insertionIndex]) > 0 ) + { + insertionIndex++; + } + aFileNames.Insert( newEntry, insertionIndex ); + } + } + } + + dir.Close(); + } + +void CTestAppBase::DrawHelpText() + { + iGc->Activate(*iHelpWindow); + + iHelpWindow->Invalidate(); + iHelpWindow->BeginRedraw(); + + iGc->Reset(); + + iGc->UseFont(iFont); + iGc->SetBrushColor(KRgbTransparent); + + iGc->Clear(); + + if( iHelpSemitransparentBackgroundActive ) + { + iGc->SetPenColor(KRgbTransparent); + iGc->SetBrushStyle(CWindowGc::ESolidBrush); + iGc->SetBrushColor( TRgb(0x7f7f7faf) ); + iGc->DrawRect( TRect(iHelpWindowSize) ); + } + + // KRgbWhite seems to be having problems (0xffffff) in some emulators, + // but 0xfefefe is working, so use that instead of white. + iGc->SetPenColor(0xfefefe); + + const TInt KColumn1 = KHelpWindowBorderPixels; + const TInt KColumn2 = KColumn1 + iHelpWindowColumn1Width + KHelpWindowSpaceBetweenColumns; + const TInt KRowIncrement = iFontSize + KHelpWindowSpaceBetweenRows; + + TInt row = iFontSize + KHelpWindowBorderPixels; + + for( TInt index = 0; index < KSupportedKeysCount; index++ ) + { + iGc->SetUnderlineStyle(EUnderlineOff); + + TPtrC text = KeyMapText( index, iCurrentPage ); + + iGc->DrawText( KeyName(index), TPoint(KColumn1, row) ); + + if( index == iSoftkeyIndices[iCurrentPage] ) + { + iGc->SetUnderlineStyle(EUnderlineOn); + } + else + { + iGc->SetUnderlineStyle(EUnderlineOff); + } + + iGc->DrawText( text, TPoint(KColumn2, row) ); + + row += KRowIncrement; + } + + iHelpWindow->EndRedraw(); + + iGc->Deactivate(); + } + +void CTestAppBase::MrccatoCommand( TRemConCoreApiOperationId aOperationId, + TRemConCoreApiButtonAction /*aButtonAct*/ ) + { + // Treat volume up like the right soft key, and volume down like the left soft key. + TKeyEvent keyEvent; + keyEvent.iCode = 0; + keyEvent.iScanCode = 0; + keyEvent.iModifiers = 0; + keyEvent.iRepeats = 0; + + switch (aOperationId) + { + case ERemConCoreApiVolumeUp: + keyEvent.iCode = KRightSoftKeyCode; + iWs.SimulateKeyEvent(keyEvent); + iWs.Flush(); + break; + case ERemConCoreApiVolumeDown: + keyEvent.iCode = KLeftSoftKeyCode; + iWs.SimulateKeyEvent(keyEvent); + iWs.Flush(); + break; + default: + break; + } + } diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/common/testappbase.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/common/testappbase.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,282 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Header specifying the common test functionality. + * + */ + +#ifndef __TEST_APP_BASE_H__ +#define __TEST_APP_BASE_H__ + +#include +#include +#include // for volume key handling + +class CRemConCoreApiTarget; +class CRemConInterfaceSelector; + +#define STR(a) (TText*)L##a + +// 17 keys are supported. The keys are in this order: +// Enter, Up, Down, Left, Right, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, *, # +const TInt KSupportedKeysCount = 17; + +struct TOperationEntry + { + const TText* text; + TInt operation; + }; + +struct TOperationsPage + { + const TText* pageName; + TInt defaultSoftkeyIndex; + TOperationEntry mapping[KSupportedKeysCount]; + }; + +// Predefined standard operations +const TInt KOperation_None = 0; +const TInt KOperation_Exit = 1; +const TInt KOperation_PreviousOptionPage = 2; +const TInt KOperation_NextOptionPage = 3; +const TInt KOperation_NextOption = 4; +const TInt KOperation_PreviousOption = 5; +const TInt KOperation_ExecuteOption = 6; +const TInt KOperation_ToggleHelpVisibility = 7; +const TInt KOperation_ToggleHelpTransparency = 8; +const TInt KOperation_FirstCustomIndex = 10; // app-specific operations can start here + +const TUint32 KNullWsHandle = 0xFFFFFFFF; + +class ITestAppPrompts + { +public: + + // Presents a selection list to the user and returns the index of the selected entry. + // Synchronous call. + // returns -1 if the selection was backed out without making a selection + virtual TInt SelectFromListL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + RPointerArray& aSelectionList, + TInt aInitialSelectionIndex = 0 ) = 0; + + // overload with HBufC instead of TDesC + virtual TInt SelectFromListL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + RPointerArray& aSelectionList, + TInt aInitialSelectionIndex = 0 ) = 0; + + // Synchronous call. + // returns false if the selection was backed out without making a selection + virtual bool SelectDriveL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + TDes& aDrive ) = 0; + + // Synchronous call. + // returns false if the selection was backed out without making a selection + virtual bool SelectFileL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + const TDesC& aDrive, + TDes& aFullFilename ) = 0; + + // Synchronous call. + // returns false if the selection was backed out without making a selection + virtual bool SelectFileWithHistoryL( TPoint aTopLeft, + TSize aSize, + TDes& aFullFilename, + const TDesC& aHistoryFilename, + TInt aMaxHistoryEntries, + const TDesC& aPrompt = _L("Select drive or recent file:") ) = 0; + + // Synchronous call. + // returns false if the selection was backed out without making a selection + virtual bool SelectIntegerL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + TInt aMin, + TInt aMax, + TInt& aSelection ) = 0; // set aSelection to default value + + // Synchronous call. Returns the scan code of the pressed key. + virtual TInt WaitForAnyKey() = 0; + + virtual TSize DisplaySize() = 0; + }; + +class CTestAppBase : public CActive, + protected ITestAppPrompts, + private MRemConCoreApiTargetObserver + { +public: + + CTestAppBase( TInt aFontSize ); + + ~CTestAppBase(); + + // inherited from CActive + void RunL(); + void DoCancel(); + +protected: + + enum TTestAppPointerEvent + { + EPointerEvent_None, + EPointerEvent_Up, + EPointerEvent_Down, + EPointerEvent_Left, + EPointerEvent_Right, + EPointerEvent_Select + }; + + virtual void ExecuteOperation( TInt aOperation, const TDesC& aOperationText ) = 0; + + // Subclasses can override this function to take action when the current softkey function has been changed. + virtual void SoftkeyFunctionUpdated() {}; + + // Subclasses can override this function to override the default key event handling. + virtual bool ConsumeKeyEvent( TInt /*aKeyCode*/ ) { return false; }; + + void BaseConstructL( const TOperationsPage* aKeyMap, TInt aPageCount ); + + void SetupVolumeKeysL(); + + void StartMonitoringWindowEvents(); + + TInt CurrentPageNumber(); + + TPtrC CurrentPageName(); + + TPtrC CurrentSoftkeyName(); + + // Each line in the file will be an entry in the aContents array + TInt ReadFile( const TDesC& aFilename, RPointerArray& aContents ); + + void BuildDriveListL( RPointerArray& aDrives ); + + void StartReceivingPointerEvents(); + void StopReceivingPointerEvents(); + + TTestAppPointerEvent CharacterizePointerEvent( const TAdvancedPointerEvent& event ); + + virtual void HandlePointerEvent( const TAdvancedPointerEvent& /*aEvent*/ ) {} + + // inherited from ITestAppPrompts + TInt SelectFromListL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + RPointerArray& aSelectionList, + TInt aInitialSelectionIndex = 0 ); + TInt SelectFromListL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + RPointerArray& aSelectionList, + TInt aInitialSelectionIndex = 0 ); + bool SelectDriveL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + TDes& aDrive ); + bool SelectFileL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + const TDesC& aDrive, + TDes& aFullFilename ); + bool SelectFileWithHistoryL( TPoint aTopLeft, + TSize aSize, + TDes& aFullFilename, + const TDesC& aHistoryFilename, + TInt aMaxHistoryEntries, + const TDesC& aPrompt = _L("Select drive or recent file:") ); + bool SelectIntegerL( TPoint aTopLeft, + TSize aSize, + const TDesC& aHeaderText, + TInt aMin, + TInt aMax, + TInt& aSelection ); // set aSelection to default value + TInt WaitForAnyKey(); + TSize DisplaySize() {return iDisplaySize;} + + const TInt iFontSize; + + RFs iFs; + RWsSession iWs; + CWsScreenDevice* iScreenDevice; + RWindowGroup* iWindowGroup; + CWindowGc* iGc; + CFont* iFont; + CFbsTypefaceStore* iTypefaceStore; + TSize iDisplaySize; + RWindow* iSelectionWindow; + RWindow* iHelpWindow; + +private: + + // inherited from MRemConCoreApiTargetObserver + void MrccatoCommand(TRemConCoreApiOperationId aOperationId, + TRemConCoreApiButtonAction aButtonAct); + + TInt KeyMapOperation(TInt aIndex, TInt aPage ); + + TPtrC KeyMapText( TInt aIndex, TInt aPage ); + + void IncrementKeymapIndex( TInt& aIndex, TInt aPage ); + + void DecrementKeymapIndex( TInt& aIndex, TInt aPage ); + + void CalculateHelpWindowSize(); + + void DrawHelpText(); + + void DoSelectFileL( TPoint aTopRight, + TSize aWindowSize, + const TDesC& aHeaderText, + const TFileName& aDirectory, + TInt aDirectoryLevel, + TDes& aSelectedDirectory, + TDes& aSelectedFilename ); + + void ReadDirectoryEntriesL( const TFileName& aDirectoryName, RPointerArray& aFileNames ); + + void ReadFileHistory( const TDesC& aHistoryFilename ); + + void AddToFileHistory( const TDesC& aFilename, const TDesC& aHistoryFilename, TInt aMaxHistoryEntries ); + + const TOperationsPage* iKeyMap; + TInt iPageCount; + TInt iCurrentPage; + TInt iSoftkeyIndices[30]; + RPointerArray iFileHistory; + + CActiveSchedulerWait iWait; + + TPoint iHelpWindowTopRight; + TSize iHelpWindowSize; + TInt iHelpWindowColumn1Width; + TInt iHelpWindowColumn2Width; + bool iHelpActive; + bool iHelpSemitransparentBackgroundActive; + + bool iRoutePointerEventsToApp; + TPoint iPointerDownPosition; + + // For volume key support + CRemConCoreApiTarget* iCoreTarget; + CRemConInterfaceSelector* iInterfaceSelector; + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/common/timercallback.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/common/timercallback.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Source code for handling the timer. + * + */ + +#include "timercallback.h" + +CTimerCallback::CTimerCallback( ITimerCallbackClient& aClient ) : + CActive( EPriorityStandard ), + iClient( aClient ) + { + CActiveScheduler::Add(this); + } + +CTimerCallback::~CTimerCallback() + { + Cancel(); + } + +void CTimerCallback::Start(TTimeIntervalMicroSeconds32 aInterval) + { + iInterval = aInterval; + + if( iTimer.CreateLocal() == KErrNone ) + { + SetActive(); + iTimer.After( iStatus, 0 ); + } + } + +// inherited from CActive + +void CTimerCallback::RunL() + { + SetActive(); + iTimer.After( iStatus, iInterval ); + + iClient.TimerCallback(); + } + +void CTimerCallback::DoCancel() + { + iTimer.Cancel(); + } + + diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/common/timercallback.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/common/timercallback.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Header specifying the timer handling. + * + */ + +#ifndef __TIMER_CALLBACK_H__ +#define __TIMER_CALLBACK_H__ + +#include + +class ITimerCallbackClient + { +public: + + virtual void TimerCallback() = 0; + + }; + +class CTimerCallback : public CActive + { +public: + + CTimerCallback( ITimerCallbackClient& aClient ); + + ~CTimerCallback(); + + void Start( TTimeIntervalMicroSeconds32 aInterval ); + + // inherited from CActive + void RunL(); + void DoCancel(); + +private: + + RTimer iTimer; + ITimerCallbackClient& iClient; + TTimeIntervalMicroSeconds32 iInterval; + + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/group/bld.inf Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + */ + +PRJ_MMPFILES + +#include "..\player\group\bld.inf" +#include "..\thumbnail\group\bld.inf" diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/bld.inf Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * This file provides the information required for building the + * Console Player test app. + * + */ + +PRJ_MMPFILES + +ConsolePlayer.mmp +ExternalPlayer.mmp +ExternalPlayer2.mmp diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/consoleplayer.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/consoleplayer.mmp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * This file provides the information required for building the + * Console Player test app. + */ + +#include +#include + +TARGET consoleplayer.exe +TARGETTYPE exe +UID 0x0 0x10207C89 +VENDORID VID_DEFAULT + +CAPABILITY ALL -TCB + +EPOCSTACKSIZE 0x5000 //20KB +EPOCHEAPSIZE 0x100000 0x1000000 //1MB-16MB + +START RESOURCE consoleplayer_reg.rss +TARGETPATH \private\10003a3f\apps +END + +USERINCLUDE ..\..\common +USERINCLUDE ..\inc +USERINCLUDE ..\src\mmf + +SOURCEPATH ..\..\common +SOURCE testappbase.cpp +SOURCE timercallback.cpp + +SOURCEPATH ..\src +SOURCE consoleplayer.cpp +SOURCE playerwindow.cpp + +SOURCEPATH ..\src\mmf +SOURCE mmfplayerwindow.cpp + +MW_LAYER_SYSTEMINCLUDE +SYSTEMINCLUDE \epoc32\include +SYSTEMINCLUDE \epoc32\include\stdapis + +LIBRARY euser.lib +LIBRARY efsrv.lib +LIBRARY mediaclientvideo.lib +LIBRARY gce.lib +LIBRARY ws32.lib +LIBRARY gdi.lib +LIBRARY fntstr.lib +LIBRARY fbscli.lib +LIBRARY estor.lib +LIBRARY ecom.lib + +// for volume key handling +LIBRARY remconcoreapi.lib +LIBRARY remconinterfacebase.lib + +// ---------------------------- +// CVideoPlayer TESTING SUPPORT +// ---------------------------- + +// Uncomment this out to use CVideoPlayerUtility API instead of CVideoPlayerUtility2. +//MACRO __USE_VIDEOPLAYER_1__ + +// -------------------------- +// OpenMAX AL TESTING SUPPORT +// -------------------------- + +#ifdef FF_OPENMAX_AL + +SYSTEMINCLUDE \epoc32\include\platform\mw\khronos + +USERINCLUDE ..\src\openmax_al +SOURCEPATH ..\src\openmax_al + +SOURCE opmaxplayerwindow.cpp +SOURCE openmaxplayerutility.cpp +LIBRARY openmaxal.lib +LIBRARY libc.lib + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/consoleplayer.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/consoleplayer.pkg Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,37 @@ +; +; Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +; All rights reserved. +; This component and the accompanying materials are made available +; under the terms of "Eclipse Public License v1.0" +; which accompanies this distribution, and is available +; at the URL "http://www.eclipse.org/legal/epl-v10.html". +; +; Initial Contributors: +; Nokia Corporation - initial contribution. +; +; Contributors: +; +; Description: Console Player - UREL build +; +;File: consoleplayer.pkg + +;Languages +&EN + +;Header +#{"consoleplayer EXE"},(0x10207C89),1,0,0 + +;Series 60 v5.0 +[0x1028315F], 0,0,0, {"Series60ProductID"} + +;Localised Vendor name +%{"Nokia"} + +;Unique Vendor name +:"Nokia" + +;Files To Copy... +"/epoc32/release/armv5/urel/consoleplayer.exe" -"!:/sys/bin/consoleplayer.exe" +"/epoc32/release/armv5/urel/externalplayer.exe" -"!:/sys/bin/externalplayer.exe" +"/epoc32/release/armv5/urel/externalplayer2.exe" -"!:/sys/bin/externalplayer2.exe" +"/epoc32/data/z/private/10003a3f/apps/consoleplayer_reg.rsc" -"!:/private/10003a3f/import/apps/consoleplayer_reg.rsc" diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/consoleplayer_reg.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/consoleplayer_reg.rss Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Resource file for registering the ConsolePlayer to the Application + * Menu. + * + */ + +#include + +UID2 KUidAppRegistrationResourceFile +UID3 0x10207C89 + +RESOURCE APP_REGISTRATION_INFO +{ + app_file="consoleplayer"; +} diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/create_sis.bat --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/create_sis.bat Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,22 @@ +cls +@echo off +echo. + +rem Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +rem All rights reserved. +rem This component and the accompanying materials are made available +rem under the terms of the "Eclipse Public License v1.0" +rem which accompanies this distribution, and is available +rem at the URL "http://www.eclipse.org/legal/epl-v10.html". +rem +rem Initial Contributors: +rem Nokia Corporation - initial contribution. +rem +rem Contributors: +rem +echo Description: Console Player package creation utility +rem + +del consoleplayer.sis* +makesis consoleplayer.pkg consoleplayer.sis +signsis consoleplayer.sis consoleplayer.sisx rd.crt rd.key diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/externalplayer.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/externalplayer.mmp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * This file provides the information required for building the + * External Player executable used by Console Player test app. + */ + +#include + +TARGET externalplayer.exe +TARGETTYPE exe +UID 0x0 0x10207CB0 +VENDORID VID_DEFAULT + +CAPABILITY ALL -TCB + +EPOCSTACKSIZE 0x5000 //20KB +EPOCHEAPSIZE 0x400 0x1000000 //1KB-16MB + +USERINCLUDE ..\..\common +USERINCLUDE ..\inc +USERINCLUDE ..\src\mmf + +SOURCEPATH ..\src +SOURCE externalplayer.cpp +SOURCE playerwindow.cpp + +SOURCEPATH ..\src\mmf +SOURCE mmfplayerwindow.cpp + +MW_LAYER_SYSTEMINCLUDE +USERINCLUDE . +SYSTEMINCLUDE \epoc32\include + +LIBRARY euser.lib +LIBRARY efsrv.lib +LIBRARY mediaclientvideo.lib +LIBRARY gce.lib +LIBRARY ws32.lib +LIBRARY gdi.lib +LIBRARY fntstr.lib +LIBRARY fbscli.lib \ No newline at end of file diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/group/externalplayer2.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/group/externalplayer2.mmp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * This file provides the information required for building the + * External Player2 executable used by Console Player test app. + */ + +#include + +TARGET externalplayer2.exe +TARGETTYPE exe +UID 0x0 0x10207CB1 +VENDORID VID_DEFAULT + +CAPABILITY ALL -TCB + +EPOCSTACKSIZE 0x5000 //20KB +EPOCHEAPSIZE 0x400 0x1000000 //1KB-16MB + +USERINCLUDE ..\..\common +USERINCLUDE ..\inc +USERINCLUDE ..\src\mmf + +SOURCEPATH ..\src +SOURCE externalplayer.cpp +SOURCE playerwindow.cpp + +SOURCEPATH ..\src\mmf +SOURCE mmfplayerwindow.cpp + +MW_LAYER_SYSTEMINCLUDE +USERINCLUDE . +SYSTEMINCLUDE \epoc32\include + +LIBRARY euser.lib +LIBRARY efsrv.lib +LIBRARY mediaclientvideo.lib +LIBRARY gce.lib +LIBRARY ws32.lib +LIBRARY gdi.lib +LIBRARY fntstr.lib +LIBRARY fbscli.lib \ No newline at end of file diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/inc/consoleplayer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/inc/consoleplayer.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * The header for the main class of the ConsolePlayer test app. + * + */ + +#ifndef __CONSOLE_PLAYER_H__ +#define __CONSOLE_PLAYER_H__ + +#include + +#include "testappbase.h" +#include "timercallback.h" +#include "playerwindow.h" +#include "externalplayer.h" + +class CPlayerWindow; + +enum TOperations + { + EOperation_ChangeDisplayMode = KOperation_FirstCustomIndex, + EOperation_AbnormalTermination, + EOperation_ToggleSecondVideo, + EOperation_ToggleThirdVideo, + EOperation_ToggleExternalPlayer, + EOperation_ToggleExternalPlayer2, + EOperation_ObscureWindow, + EOperation_DragWindow, + EOperation_ToggleOrdinalPositions, + EOperation_LaunchAllWindows + }; + +const TInt KMaxHistoryEntries = 10; +_LIT( KHistoryFilename, "c:\\console_player_history.txt" ); + +_LIT( KUrlListFilename, "c:\\data\\urls.txt" ); + +class CConsolePlayer : public CTestAppBase, + private MPlayerWindowObserver, + private ITimerCallbackClient, + private MPlayerCommands + +{ +public: // Methods + + static void ExecuteL(); + +private: // Methods + + enum TActionToPerform + { + EAction_None = 0x0000, + EAction_PlayLocalFile = 0x0001, + EAction_PlayUrl = 0x0002, + EAction_SameAsMainPlayer = 0x0008 + }; + + enum TApiToUse + { + EApi_VideoPlayer = 0x1, + EApi_OpenMaxAl = 0x2 + }; + + CConsolePlayer(); + + ~CConsolePlayer(); + + void InitL(); + + void Main(); + + void MainL(); + + bool SelectUrlL( TDes& aUrl ); + + void UpdateVideoWindow(); + + void UpdateWindowOrdinalPositions(); + + void EnableDragging(); + + void DisableDragging(); + + void SelectAction( TUint aActionMask, + TUint aApiMask, + bool aPresentPerformanceModeOption, + TActionToPerform& aAction, + TApiToUse& aApi, + bool& aPerformanceMode, + TFileName& aLocation ); + + void DoSelectAction( TUint aActionMask, + bool aPresentPerformanceModeOption, + TActionToPerform& aAction, + bool& aPerformanceMode ); + + bool DoSelectApi( TUint aApiMask, + TApiToUse& aApi ); + + CPlayerWindow* PlayerWindowNewL( TApiToUse aApi, + TPoint aTopLeft, + TSize aSize, + bool aTransparent, + TRgb aBackgroundColor, + bool aSuppressGraphicsContext ); + + TInt CreateAnotherPlayer( CPlayerWindow** aPlayerWindow, + CExternalPlayer** aExternalPlayer, + const TDesC& aExternalPlayerExeName, + TSize aSize, + TPoint aTopLeft ); + + MPlayerCommands* CurrentPlayer(); + + void SendOperationToAllPlayers( TInt aOperation ); + + void DrawBorderAroundActiveWindows(); + + // inherited from CTestAppBase + virtual void SoftkeyFunctionUpdated(); + virtual bool ConsumeKeyEvent( TInt aKeyCode ); + virtual void ExecuteOperation( TInt aOperation, const TDesC& aOperationText ); + virtual void HandlePointerEvent( const TAdvancedPointerEvent& aEvent ); + + // inherited from MPlayerWindowObserver + virtual void PlayInitiated(); + virtual void PlayStateChanged(); + virtual void Error(TInt aError); + + // inherited from MPlayerCommands + virtual TInt ExecuteOperation( TInt aOperation ); + virtual void MoveWindow( TPoint aNewCenter ); + virtual void SetOrdinalPosition( TInt aPosition ); + + // inherited from ITimerCallbackClient + void TimerCallback(); + +private: // Attributes + + CTimerCallback* iTimerCallback; + TBuf<120> iBuffer; + TInt iLastError; + TInt iVideoWindowTextMode; + TBuf<120> iSelectedOptionText; + TInt iSelectedOptionTextCounter; + TInt iOrdinalIndex; + bool iVideoWindow2Transparent; + CPlayerWindow* iVideoPlayer; + CPlayerWindow* iVideoPlayer2; + CPlayerWindow* iVideoPlayer3; + CExternalPlayer* iExternalPlayer; + CExternalPlayer* iExternalPlayer2; + MPlayerCommands* iActivePlayer; + MPlayerCommands* iPlayerBeingDragged; + RWindow* iFullScreenWindow; + bool iObscured; + TInt iFinalResult; + TActionToPerform iMainPlayerAction; + TApiToUse iMainPlayerApi; + + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/inc/externalplayer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/inc/externalplayer.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Header for the external player main class. + * + */ + +#ifndef __EXTERNAL_PLAYER_H__ +#define __EXTERNAL_PLAYER_H__ + +#include +#include +#include + +#include "PlayerWindow.h" + +// Note: the executable name is also used as the message queue name. +_LIT( KExternalPlayerExe, "externalplayer.exe" ); +_LIT( KExternalPlayerExe2, "externalplayer2.exe" ); + +enum TExternalPlayerCommands + { + EExternalPlayer_StartPlayback, + EExternalPlayer_ExecuteOperation, + EExternalPlayer_MoveWindow, + EExternalPlayer_Shutdown + }; + +struct TStartPlayback + { + TInt x; + TInt y; + TInt width; + TInt height; + TInt idOfParentWindowGroup; + bool locationIsFilename; + TInt length; + unsigned char name[200]; + }; + +struct TStartPlaybackReturn + { + TInt windowGroupId; + }; + +struct TExecuteOperation + { + TInt operation; + }; + +struct TMoveWindow + { + TInt centerX; + TInt centerY; + }; + +_LIT( KMsgQueuePrefix, "-msg=" ); + +// This is the client-side class for launching and controlling an external player executable. + +class CExternalPlayer : public CBase, public MPlayerCommands + { +public: + + ~CExternalPlayer() + { + Terminate(); + } + + CExternalPlayer( RWsSession& aWs ) : iWs( aWs ) + { + } + + TInt SendMsg( TExternalPlayerCommands aMsg ) + { + TRequestStatus status; + status = KRequestPending; + iProcess.Rendezvous( status ); + + iMsgQueue.SendBlocking( aMsg ); + + User::WaitForRequest( status ); + + return status.Int(); + } + + TInt Launch( const TDesC& aExeName, + RWindowGroup& aParentWindowGroup, + const TDesC& aLocation, + bool aLocationIsFilename, // false means location is URL + TPoint aTopRight, + TSize aSize ) + { + // The base name for message queue and chunk is the name of the executable followed by the address of this instance. + TBuf<80> nameBase; + nameBase.Copy( aExeName ); + nameBase.AppendFormat(_L("%08x"), this ); + + TBuf<100> commandLineArguments; + commandLineArguments.Copy( KMsgQueuePrefix ); + commandLineArguments.Append( nameBase ); + + TInt err = iProcess.Create( aExeName, commandLineArguments ); + + if( err == KErrNone ) + { + aParentWindowGroup.AllowProcessToCreateChildWindowGroups( iProcess.SecureId() ); + + iProcess.Resume(); + + TRequestStatus status; + status = KRequestPending; + iProcess.Rendezvous( status ); + User::WaitForRequest( status ); + + err = status.Int(); + + if( err == KErrNone ) + { + err = iMsgQueue.OpenGlobal( nameBase ); + } + + if( err == KErrNone ) + { + nameBase.Append( _L("_chunk") ); + err = iChunk.OpenGlobal( nameBase, EFalse ); + } + + if( err == KErrNone ) + { + iActive = true; + + // Send the start messages to the external player. + + TStartPlayback* chunk = (TStartPlayback*)iChunk.Base(); + + TPtr8 filename( chunk->name, 0, 200 ); + filename.Copy( aLocation ); + chunk->length = filename.Length(); + chunk->locationIsFilename = aLocationIsFilename; + + chunk->x = aTopRight.iX; + chunk->y = aTopRight.iY; + chunk->width = aSize.iWidth; + chunk->height = aSize.iHeight; + chunk->idOfParentWindowGroup = aParentWindowGroup.Identifier(); + err = SendMsg( EExternalPlayer_StartPlayback ); + + if( err == KErrNone ) + { + TStartPlaybackReturn* chunk = (TStartPlaybackReturn*)iChunk.Base(); + iWindowGroupId = chunk->windowGroupId; + } + } + else + { + iProcess.Kill( KErrCancel ); + iProcess.Close(); + } + + } + + return err; + } + + // inherited from MPlayerCommands + TInt ExecuteOperation( TInt aOperation ) + { + TInt err = KErrNone; + + if( iActive ) + { + TExecuteOperation* chunk = (TExecuteOperation*)iChunk.Base(); + chunk->operation = aOperation; + err = SendMsg( EExternalPlayer_ExecuteOperation ); + } + + return err; + } + + // inherited from MPlayerCommands + void MoveWindow( TPoint aNewCenter ) + { + if( iActive ) + { + TMoveWindow* chunk = (TMoveWindow*)iChunk.Base(); + chunk->centerX = aNewCenter.iX; + chunk->centerY = aNewCenter.iY; + SendMsg( EExternalPlayer_MoveWindow ); + } + } + + void SetOrdinalPosition( TInt /*aPosition*/ ) + { + if( iActive ) + { +// TODO: DEBUG THIS. HOW DOES WINDOW GROUP ORDINAL POSITION RELATE TO WINDOW ORDINAL POSITION? +// iWs.SetWindowGroupOrdinalPosition( iWindowGroupId, aPosition ); + } + } + + void Terminate() + { + if( iActive ) + { + SendMsg( EExternalPlayer_Shutdown ); + + iProcess.Close(); + iMsgQueue.Close(); + + iActive = false; + } + } + +private: + + RWsSession& iWs; + RProcess iProcess; + bool iActive; + RMsgQueue iMsgQueue; + RChunk iChunk; + TInt iWindowGroupId; + + }; + +#endif + diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/inc/playerwindow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/inc/playerwindow.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,273 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Header specifying the abstract Player Window. + * + */ + +#ifndef __PLAYER_WINDOW_H__ +#define __PLAYER_WINDOW_H__ + +#include +#include +#include + +#include "testappbase.h" + +enum TPlayerWindowOperations + { + EOperation_PauseResume = KOperation_FirstCustomIndex+100, + EOperation_Pause, + EOperation_Resume, + EOperation_StopPlay, + EOperation_SeekBack, + EOperation_SeekForward, + EOperation_SeekStart, + EOperation_SeekEnd, + EOperation_Rotate, + EOperation_Autoscale, + EOperation_IncreaseHeightScale, + EOperation_DecreaseHeightScale, + EOperation_IncreaseWidthScale, + EOperation_DecreaseWidthScale, + EOperation_ClipRectangle, + EOperation_Extent, + EOperation_ResetToDefaults, + EOperation_IncreaseVolume, + EOperation_DecreaseVolume, + EOperation_MaximumVolume, + EOperation_Mute, + EOperation_BalanceLeft, + EOperation_BalanceRight, + EOperation_BalanceCenter, + EOperation_BalanceMaxLeft, + EOperation_BalanceMaxRight, + EOperation_FrameStepForward, + EOperation_FrameStepBackward, + EOperation_IncreasePlayVelocity, + EOperation_DecreasePlayVelocity, + EOperation_MoveWindowUp, + EOperation_MoveWindowDown, + EOperation_MoveWindowLeft, + EOperation_MoveWindowRight, + EOperation_ChangeWindowSize, + EOperation_ToggleWindowTransparency, + EOperation_DrawWhiteBorderAroundWindow, + EOperation_DrawRedBorderAroundWindow, + EOperation_ClearBorderAroundWindow + }; + +class MPlayerWindowObserver + { +public: + + virtual void PlayInitiated() = 0; + + virtual void PlayStateChanged() = 0; + + virtual void Error(TInt aError) = 0; + }; + +class MPlayerCommands + { +public: + + virtual TInt ExecuteOperation( TInt aOperation ) = 0; + + virtual void MoveWindow( TPoint aNewCenter ) = 0; + + virtual void SetOrdinalPosition( TInt aPosition ) = 0; + }; + +class CPlayerWindow : public CBase, public MPlayerCommands + { +public: + + enum TPlayState + { + EStopped, + EPlaying, + EPaused + }; + + enum TAutoscaleMode + { + EDoNotAutoscale, + EBestFit, + EStretch + }; + + virtual ~CPlayerWindow(); + + // inherited from MPlayerCommands + virtual TInt ExecuteOperation( TInt aOperation ); + virtual void MoveWindow( TPoint aNewCenter ); + virtual void SetOrdinalPosition( TInt aPosition ); + + void StartWithFilenameL( const TDesC& aFullFilename, + TAutoscaleMode aDefaultAutoscale, + MPlayerWindowObserver* aObserver = NULL ); + + void StartWithUrlL( const TDesC& aUrl, + TAutoscaleMode aDefaultAutoscale, + MPlayerWindowObserver* aObserver = NULL ); + + RWindow& Window(); + + void WriteAdvancedText( CWindowGc& aGc, TInt aColumn, TInt& aRow, TInt aRowIncrement ); + + const TDesC& FullFilename(); + + const TDesC& Filename(); + + const TDesC& Url(); + + TPlayState PlayState(); + + TSize VideoSize(); + + TInt PositionInMs(); + + TInt DurationInMs(); + + virtual TInt SetVideoExtent( TRect aExtent ) = 0; + + virtual TInt Play() = 0; + + virtual TInt Pause() = 0; + +protected: + + CPlayerWindow( RFs& aFs, RWsSession& aWs, CWsScreenDevice& aScreenDevice, bool aSuppressGraphicsContext ); + + void CheckWindowLimits(); + + void DrawBorderAroundWindow(); + + // These functions must be called by subclasses + + void BaseConstructL( const RWindowTreeNode &aParentWindow, TPoint aTopLeft, TSize aSize, bool aTransparent, TRgb aBackgroundColor ); + void PlayInitiated(); + void PlayComplete(); + void CheckError( TInt aError, const char* pDescription ); + void Error( TInt aError, const char* pDescription = NULL ); + + // These functions must be implemented by subclasses + + virtual void InitializeParameters( TSize& aVideoSize, + TTimeIntervalMicroSeconds& aDuration, + TInt& aMaxVolume, + TInt& aCurrentVolume, + TInt& aBalanceCenter, + TInt& aBalanceMaxLeft, + TInt& aBalanceMaxRight, + TInt& aDefaultBalance, + TInt& aCurrentBalance ) = 0; + + virtual void SetDefaultAutoscaleMode( TAutoscaleMode aDefaultAutoscale ) = 0; + + virtual void PreparePlayerWithFile( RFile& aFile ) = 0; + + virtual void PreparePlayerWithUrl( const TDesC& aUrl ) = 0; + + virtual TInt DoExecuteOperation( TInt aOperation ) = 0; + + virtual TTimeIntervalMicroSeconds Position() = 0; // microseconds + + virtual TInt SetVolume( TInt aVolume ) = 0; + + virtual TInt SetBalance( TInt aBalance ) = 0; + + virtual TInt RotationAngle() = 0; + + virtual TInt NextRotationAngle() = 0; + + virtual TInt ResetRotation() = 0; + + virtual TInt NextAutoscaleMode() = 0; + + virtual TInt ResetAutoscale() = 0; + + virtual void AppendAutoscaleModeText( TDes& aString ) = 0; + + virtual TInt SetClipRectangle( TRect aRect ) = 0; + + virtual TInt SetScaleFactor( TReal aWidthScaleFactor, TReal aHeightScaleFactor ) = 0; + + virtual TInt Stop() = 0; + + virtual TInt SetPosition( TTimeIntervalMicroSeconds ) = 0; + + virtual TInt StepForward() = 0; + + virtual TInt StepBackward() = 0; + + virtual TInt SetPlayVelocity( TInt aVelocity ) = 0; + + RFs& iFs; + RFile iFile; + RWsSession& iWs; + CWsScreenDevice& iScreenDevice; + CWindowGc* iGc; + + RWindow iWindow; + TBuf<120> iBuffer; + +private: + + TRect Rectangle( TInt aModeIndex ); + + TInt Seek( TTimeIntervalMicroSeconds aPosition ); + + TInt UpdateScaleFactor(); + + TInt ResetToDefaults(); + + TFileName iFullFilename; + TFileName iFilename; + TFileName iUrl; + MPlayerWindowObserver* iObserver; + bool iSuppressGraphicsContext; + + TPlayState iPlayState; + TTimeIntervalMicroSeconds iDuration; + TInt iDurationInMs; + TInt iCurrentVelocity; + + // Video attributes + TSize iVideoSize; + TInt iWidthScaleIndex; + TInt iHeightScaleIndex; + TInt iClipModeIndex; + TInt iExtentModeIndex; + TPoint iWindowTopLeft; + TSize iDefaultWindowSize; + TSize iWindowSize; + TInt iWindowSizeDivisor; + bool iWindowTransparent; + TRgb iBorderColor; + + // Audio attributes + TInt iMaxVolume; + TInt iDefaultVolume; + TInt iCurrentVolume; + TInt iBalanceCenter; + TInt iBalanceMaxRight; + TInt iBalanceMaxLeft; + TInt iDefaultBalance; + TInt iCurrentBalance; + + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/consoleplayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/consoleplayer.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,1502 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Source file for the main class of the ConsolePlayer test app. + * + */ + +#include "consoleplayer.h" + +#include +#include +#include +#include + +#include "MmfPlayerWindow.h" +#include "ExternalPlayer.h" + +#ifdef FF_OPENMAX_AL +#include "opmaxplayerwindow.h" +#endif + +const TInt KFontSize = 15; + +const TInt KOrdinalPositionConfigurationCount = 7; +const TInt KPlayerCount = 5; + +enum TPlayerNames + { + EVideoPlayer, + EVideoPlayer2, + EVideoPlayer3, + EExternalPlayer, + EExternalPlayer2 + }; + +// entries are sorted with foreground windows first +const TPlayerNames KOrdinalPositions[KOrdinalPositionConfigurationCount][KPlayerCount] = + { + {EVideoPlayer3, EVideoPlayer2, EExternalPlayer, EExternalPlayer2, EVideoPlayer}, + {EVideoPlayer2, EVideoPlayer3, EExternalPlayer2, EExternalPlayer, EVideoPlayer}, + {EExternalPlayer, EExternalPlayer2, EVideoPlayer3, EVideoPlayer2, EVideoPlayer}, + {EVideoPlayer3, EExternalPlayer2, EVideoPlayer2, EExternalPlayer, EVideoPlayer}, + {EVideoPlayer3, EVideoPlayer2, EVideoPlayer, EExternalPlayer, EExternalPlayer2}, + {EExternalPlayer, EExternalPlayer2, EVideoPlayer, EVideoPlayer3, EVideoPlayer2}, + {EVideoPlayer, EVideoPlayer3, EVideoPlayer2, EExternalPlayer, EExternalPlayer2} + }; + +// Key map +// This section maps the options to keys for each page of options. + +const TInt KKeyMapPageCount = 9; + +const TInt KWindow2Page = 5; +const TInt KWindow3Page = 6; +const TInt KExternalPlayerPage = 7; +const TInt KExternalPlayer2Page = 8; +const TInt KAllPlayersPage = 9; + +const TOperationsPage KKeyMap[KKeyMapPageCount] = + { + {STR("Standard controls"), + 5, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Seek back 5 seconds"), EOperation_SeekBack}, + {STR("Seek forward 5 seconds"), EOperation_SeekForward}, + {STR("Seek to start of clip"), EOperation_SeekStart}, + {STR("Seek to end minus 5 secs"), EOperation_SeekEnd}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Stop/Play"), EOperation_StopPlay}, + {STR("Obscure entire screen"), EOperation_ObscureWindow}, + {STR("Toggle help transparency"), KOperation_ToggleHelpTransparency}, + {STR("Change video window size"), EOperation_ChangeWindowSize}, + {STR("Panic this process"), EOperation_AbnormalTermination}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Video controls"), + 7, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Increase height scale"), EOperation_IncreaseHeightScale}, + {STR("Decrease height scale"), EOperation_DecreaseHeightScale}, + {STR("Increase width scale"), EOperation_IncreaseWidthScale}, + {STR("Decrease width scale"), EOperation_DecreaseWidthScale}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Change rotation angle"), EOperation_Rotate}, + {STR("Change autoscale mode"), EOperation_Autoscale}, + {STR("Change clipping rectangle"), EOperation_ClipRectangle}, + {STR("Change extent rectangle"), EOperation_Extent}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Trick play"), + 5, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Frame step forward"), EOperation_FrameStepForward}, + {STR("Frame step backward"), EOperation_FrameStepBackward}, + {STR("Decrease play velocity"), EOperation_DecreasePlayVelocity}, + {STR("Increase play velocity"), EOperation_IncreasePlayVelocity}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Audio controls"), + 0, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Increase volume 10%"), EOperation_IncreaseVolume}, + {STR("Decrease volume 10%"), EOperation_DecreaseVolume}, + {STR("Balance left"), EOperation_BalanceLeft}, + {STR("Balance right"), EOperation_BalanceRight}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Maximum volume"), EOperation_MaximumVolume}, + {STR("Mute"), EOperation_Mute}, + {STR("Balance maximum left"), EOperation_BalanceMaxLeft}, + {STR("Balance maximum right"), EOperation_BalanceMaxRight}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Video window #2 (same process)"), + 7, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Move window up"), EOperation_MoveWindowUp}, + {STR("Move window down"), EOperation_MoveWindowDown}, + {STR("Move window left"), EOperation_MoveWindowLeft}, + {STR("Move window right"), EOperation_MoveWindowRight}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Toggle window on/off"), EOperation_ToggleSecondVideo}, + {STR("Drag window"), EOperation_DragWindow}, + {STR("Toggle window transparency"), EOperation_ToggleWindowTransparency}, + {STR("Change video window size"), EOperation_ChangeWindowSize}, + {STR("Change autoscale mode"), EOperation_Autoscale}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Video window #3 (same process)"), + 7, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Move window up"), EOperation_MoveWindowUp}, + {STR("Move window down"), EOperation_MoveWindowDown}, + {STR("Move window left"), EOperation_MoveWindowLeft}, + {STR("Move window right"), EOperation_MoveWindowRight}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Toggle window on/off"), EOperation_ToggleThirdVideo}, + {STR("Drag window"), EOperation_DragWindow}, + {STR("Toggle window transparency"), EOperation_ToggleWindowTransparency}, + {STR("Change video window size"), EOperation_ChangeWindowSize}, + {STR("Change autoscale mode"), EOperation_Autoscale}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Video window #4 (another process)"), + 7, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Move window up"), EOperation_MoveWindowUp}, + {STR("Move window down"), EOperation_MoveWindowDown}, + {STR("Move window left"), EOperation_MoveWindowLeft}, + {STR("Move window right"), EOperation_MoveWindowRight}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Toggle window on/off"), EOperation_ToggleExternalPlayer}, + {STR("Drag window"), EOperation_DragWindow}, + {STR("Toggle window transparency"), EOperation_ToggleWindowTransparency}, + {STR("Change video window size"), EOperation_ChangeWindowSize}, + {STR("Change autoscale mode"), EOperation_Autoscale}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Video window #5 (another process)"), + 7, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Move window up"), EOperation_MoveWindowUp}, + {STR("Move window down"), EOperation_MoveWindowDown}, + {STR("Move window left"), EOperation_MoveWindowLeft}, + {STR("Move window right"), EOperation_MoveWindowRight}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Toggle window on/off"), EOperation_ToggleExternalPlayer2}, + {STR("Drag window"), EOperation_DragWindow}, + {STR("Toggle window transparency"), EOperation_ToggleWindowTransparency}, + {STR("Change video window size"), EOperation_ChangeWindowSize}, + {STR("Change autoscale mode"), EOperation_Autoscale}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + }, + {STR("Control all windows"), + 7, // default softkey index + { + // Enter + {STR("Pause/Resume"), EOperation_PauseResume}, + // Up / Down / Left / Right + {STR("Seek back 5 seconds"), EOperation_SeekBack}, + {STR("Seek forward 5 seconds"), EOperation_SeekForward}, + {STR("Seek to start of clip"), EOperation_SeekStart}, + {STR("Seek to end minus 5 secs"), EOperation_SeekEnd}, + // 0 - 9 + {STR("Help text on/off"), KOperation_ToggleHelpVisibility}, + {STR("Go to next options page"), KOperation_NextOptionPage}, + {STR("Create all windows"), EOperation_LaunchAllWindows}, + {STR("Toggle ordinal positions"), EOperation_ToggleOrdinalPositions}, + {STR("Pause all"), EOperation_Pause}, + {STR("Resume all"), EOperation_Resume}, + {STR("Stop/Play all"), EOperation_StopPlay}, + {STR(""), KOperation_None}, + {STR(""), KOperation_None}, + {STR("Reset to defaults"), EOperation_ResetToDefaults}, + // *, # + {STR("Change display mode"), EOperation_ChangeDisplayMode}, + {STR("Exit"), KOperation_Exit} + } + } + }; + + +// Console player implementation + +void CConsolePlayer::ExecuteL() + { + CConsolePlayer* self = new(ELeave) CConsolePlayer; + CleanupStack::PushL( self ); + self->InitL(); + self->Main(); + CleanupStack::PopAndDestroy( self ); + } + +CConsolePlayer::CConsolePlayer() : + CTestAppBase( KFontSize ), + iLastError( KErrNone ), + iVideoWindowTextMode( 1 ), + iFinalResult( 0 ) + { + } + +CConsolePlayer::~CConsolePlayer() + { + Cancel(); + + if( iGc && iFullScreenWindow ) + { + iGc->Activate(*iFullScreenWindow); + + iFullScreenWindow->Invalidate(); + iFullScreenWindow->BeginRedraw(); + + iGc->Reset(); + + iGc->UseFont(iFont); + iGc->SetBrushColor(KRgbDarkBlue); + + iGc->Clear(); + + if( iFinalResult == KErrNone ) + { + // KRgbWhite seems to be having problems (0xffffff) in some emulators, + // but 0xfefefe is working, so use that instead of white. + iGc->SetPenColor(0xfefefe); + } + else + { + iGc->SetPenColor(KRgbRed); + } + + iBuffer.Format( _L("CONSOLEPLAYER EXIT, result = %i"), iFinalResult ); + iGc->DrawText( iBuffer, TPoint(5, 20) ); + + iFullScreenWindow->EndRedraw(); + + iGc->Deactivate(); + + iFullScreenWindow->SetVisible( ETrue ); + + WaitForAnyKey(); + } + + delete iExternalPlayer; + delete iExternalPlayer2; + delete iVideoPlayer; + delete iVideoPlayer2; + delete iVideoPlayer3; + delete iTimerCallback; + delete iFullScreenWindow; + } + +void CConsolePlayer::InitL() + { + BaseConstructL( KKeyMap, KKeyMapPageCount ); + + iFullScreenWindow = new(ELeave) RWindow( iWs ); + User::LeaveIfError( iFullScreenWindow->Construct( *iWindowGroup, KNullWsHandle ) ); + iFullScreenWindow->SetExtent( TPoint(0,0), iDisplaySize ); + iFullScreenWindow->SetNonTransparent(); + iFullScreenWindow->SetBackgroundColor(KRgbBlack); + iFullScreenWindow->SetVisible(false); + iFullScreenWindow->Activate(); + + iGc->Activate(*iFullScreenWindow); + + iFullScreenWindow->BeginRedraw(); + + iGc->Reset(); + iGc->UseFont(iFont); + iGc->SetBrushStyle(CWindowGc::ESolidBrush); + iGc->SetBrushColor(KRgbBlack); + iGc->Clear(); + + iFullScreenWindow->EndRedraw(); + + iGc->Deactivate(); + } + +void CConsolePlayer::Main() + { + TRAPD( err, MainL() ); + + RDebug::Printf( "CONSOLEPLAYER Completed, err=%i", err ); + } + +void CConsolePlayer::DoSelectAction( TUint aActionMask, + bool aPresentPerformanceModeOption, + TActionToPerform& aAction, + bool& aPerformanceMode ) + { + RPointerArray operations; + + TInt sameAsMainPlayerIndex = -2; + TInt playLocalFileIndex = -2; + TInt playLocalFilePerformanceIndex = -2; + TInt playUrlIndex = -2; + TInt playUrlPerformanceIndex = -2; + + if( aActionMask & EAction_SameAsMainPlayer ) + { + _LIT( KSameAsMainPlayer, "Same as main player" ); + sameAsMainPlayerIndex = operations.Count(); + operations.Append( &KSameAsMainPlayer ); + } + + if( aActionMask & EAction_PlayLocalFile ) + { + _LIT( KPlayLocalFile, "Play local file" ); + playLocalFileIndex = operations.Count(); + operations.Append( &KPlayLocalFile ); + + if( aPresentPerformanceModeOption ) + { + _LIT( KPlayLocalFilePerformance, "Play local file (performance mode)" ); + playLocalFilePerformanceIndex = operations.Count(); + operations.Append( &KPlayLocalFilePerformance ); + } + } + + if( aActionMask & EAction_PlayUrl ) + { + _LIT( KPlayUrl, "Play URL from c:\\data\\urls.txt" ); + playUrlIndex = operations.Count(); + operations.Append( &KPlayUrl ); + + if( aPresentPerformanceModeOption ) + { + _LIT( KPlayUrlPerformance, "Play URL from c:\\data\\urls.txt (performance mode)" ); + playUrlPerformanceIndex = operations.Count(); + operations.Append( &KPlayUrlPerformance ); + } + } + + _LIT( KExit, "Exit" ); + operations.Append( &KExit ); + + TInt index = 0; + + if( operations.Count() > 1 ) + { + index = SelectFromListL( TPoint(0,0), iDisplaySize, _L("Select operation to perform:"), operations ); + } + + if( index == sameAsMainPlayerIndex ) + { + aAction = EAction_SameAsMainPlayer; + } + else if( index == playLocalFileIndex ) + { + aAction = EAction_PlayLocalFile; + aPerformanceMode = false; + } + else if( index == playLocalFilePerformanceIndex ) + { + aAction = EAction_PlayLocalFile; + aPerformanceMode = true; + } + else if( index == playUrlIndex ) + { + aAction = EAction_PlayUrl; + aPerformanceMode = false; + } + else if( index == playUrlPerformanceIndex ) + { + aAction = EAction_PlayUrl; + aPerformanceMode = true; + } + else + { + aAction = EAction_None; + } + + operations.Close(); + } + +bool CConsolePlayer::DoSelectApi( TUint aApiMask, + TApiToUse& aApi ) + { + RPointerArray apiList; + + TInt videoPlayerIndex = -2; + TInt omxAlIndex = -2; + + if( aApiMask & EApi_VideoPlayer ) + { + _LIT( KVideoPlayer, "Video player" ); + videoPlayerIndex = apiList.Count(); + apiList.Append( &KVideoPlayer ); + } + + if( aApiMask & EApi_OpenMaxAl ) + { + _LIT( KOmxAl, "OpenMAX AL" ); + omxAlIndex = apiList.Count(); + apiList.Append( &KOmxAl ); + } + + TInt index = 0; + + if( apiList.Count() > 1 ) + { + index = SelectFromListL( TPoint(0,0), iDisplaySize, _L("Select API to use:"), apiList ); + } + + bool selected = true; + + if( index == videoPlayerIndex ) + { + aApi = EApi_VideoPlayer; + } + else if( index == omxAlIndex ) + { + aApi = EApi_OpenMaxAl; + } + else + { + selected = false; + } + + apiList.Close(); + + return selected; + } + +void CConsolePlayer::SelectAction( TUint aActionMask, + TUint aApiMask, + bool aPresentPerformanceModeOption, + TActionToPerform& aAction, + TApiToUse& aApi, + bool& aPerformanceMode, + TFileName& aLocation ) + { + bool done = false; + + while( !done ) + { + DoSelectAction( aActionMask, aPresentPerformanceModeOption, aAction, aPerformanceMode ); + + switch( aAction ) + { + case EAction_None: + case EAction_SameAsMainPlayer: + + done = true; + break; + + case EAction_PlayLocalFile: + + while( !done && DoSelectApi( aApiMask, aApi ) ) + { + done = SelectFileWithHistoryL( TPoint(0,0), iDisplaySize, aLocation, KHistoryFilename, KMaxHistoryEntries ); + } + break; + + case EAction_PlayUrl: + + while( !done && DoSelectApi( aApiMask, aApi ) ) + { + done = SelectUrlL( aLocation ); + } + break; + } + } + } + +void CConsolePlayer::MainL() + { + bool performanceMode; + TFileName location; + + TUint actionMask = (EAction_PlayLocalFile | EAction_PlayUrl); + + TUint apiMask = EApi_VideoPlayer; + +#ifdef FF_OPENMAX_AL + apiMask |= EApi_OpenMaxAl; +#endif + + bool done = false; + + while( !done ) + { + SelectAction( actionMask, apiMask, true, iMainPlayerAction, iMainPlayerApi, performanceMode, location ); + + switch( iMainPlayerAction ) + { + case EAction_None: + + // Do nothing. Exit program. + done = true; + break; + + case EAction_PlayLocalFile: + case EAction_PlayUrl: + { + CPlayerWindow::TAutoscaleMode autoscale = CPlayerWindow::EDoNotAutoscale; + + if( performanceMode ) + { + // turn off text + iVideoWindowTextMode = 0; + + // stretch video to full window + autoscale = CPlayerWindow::EStretch; + + // do not use timer in performance mode + } + else + { + iTimerCallback = new(ELeave) CTimerCallback( *this ); + } + + // The first video player window is full screen. + iVideoPlayer = PlayerWindowNewL( iMainPlayerApi, + TPoint(0,0), + iDisplaySize, + false, // not transparent + KRgbDarkBlue, + true ); + + iActivePlayer = iVideoPlayer; + + if( iMainPlayerAction == EAction_PlayLocalFile ) + { + // RDebug::Printf only supports 8-bit strings, but RawPrint can handle 16-bit descriptors. + RDebug::Printf( "CONSOLEPLAYER file:" ); + RDebug::RawPrint( location ); + + iVideoPlayer->StartWithFilenameL(location, autoscale, this); + } + else + { + // RDebug::Printf only supports 8-bit strings, but RawPrint can handle 16-bit descriptors. + RDebug::Printf( "CONSOLEPLAYER URL:" ); + RDebug::RawPrint( location ); + + iVideoPlayer->StartWithUrlL(location, autoscale, this); + } + + done = true; + CActiveScheduler::Start(); + } + break; + + } + } + } + +bool CConsolePlayer::SelectUrlL( TDes& aUrl ) + { + RPointerArray urlList; + TInt err = ReadFile( KUrlListFilename, urlList ); + + bool selected = false; + + if( err == KErrNone ) + { + TInt index = SelectFromListL( TPoint(0,0), iDisplaySize, _L("Select URL:"), urlList ); + + if( index >= 0 ) + { + selected = true; + aUrl.Copy( urlList[index]->Des() ); + } + } + + urlList.ResetAndDestroy(); + + return selected; + } + +MPlayerCommands* CConsolePlayer::CurrentPlayer() + { + MPlayerCommands* player = NULL; + + switch( CurrentPageNumber() ) + { + case KWindow2Page: + player = iVideoPlayer2; + break; + case KWindow3Page: + player = iVideoPlayer3; + break; + case KExternalPlayerPage: + player = iExternalPlayer; + break; + case KExternalPlayer2Page: + player = iExternalPlayer2; + break; + case KAllPlayersPage: + player = this; // means to route command to all players + break; + default: + // By default, route other commands to the main player. + player = iVideoPlayer; + break; + } + + return player; + } + +void CConsolePlayer::SoftkeyFunctionUpdated() + { + MPlayerCommands* currentPlayer = CurrentPlayer(); + + if( currentPlayer != iActivePlayer ) + { + if( iActivePlayer != NULL ) + { + iActivePlayer->ExecuteOperation( EOperation_ClearBorderAroundWindow ); + } + + iActivePlayer = currentPlayer; + + DrawBorderAroundActiveWindows(); + } + + UpdateVideoWindow(); + } + +void CConsolePlayer::DrawBorderAroundActiveWindows() + { + if( (iActivePlayer != NULL) && (iActivePlayer != iVideoPlayer) ) + { + iActivePlayer->ExecuteOperation( EOperation_DrawWhiteBorderAroundWindow ); + } + } + +bool CConsolePlayer::ConsumeKeyEvent( TInt /*aKeyCode*/ ) + { + return false; + } + +void CConsolePlayer::UpdateVideoWindow() + { + iGc->Activate(iVideoPlayer->Window()); + + iVideoPlayer->Window().Invalidate(); + iVideoPlayer->Window().BeginRedraw(); + + iGc->Reset(); + iGc->SetBrushColor(KRgbTransparent); + iGc->Clear(); + + iGc->SetPenColor(KRgbCyan); + + if( iVideoWindowTextMode > 0 ) + { + iGc->UseFont(iFont); + + if( iSelectedOptionText.Length() > 0 ) + { + // POPUP WINDOW (AFTER OPTION IS SELECTED) + + iGc->SetBrushStyle(CWindowGc::ESolidBrush); + iGc->SetBrushColor(KRgbBlue); + + const TInt KSelectionWindowWidth = iFont->TextWidthInPixels(iSelectedOptionText)+10; + const TInt KSelectionWindowHeight = KFontSize+10; + const TInt KOffsetFromBottom = 20; + + TRect box(iDisplaySize.iWidth/2-KSelectionWindowWidth/2, + iDisplaySize.iHeight-KOffsetFromBottom-KSelectionWindowHeight, + iDisplaySize.iWidth/2+KSelectionWindowWidth/2, + iDisplaySize.iHeight-KOffsetFromBottom); + iGc->DrawText( iSelectedOptionText, box, KFontSize+2, CWindowGc::ECenter); + + iGc->SetBrushStyle(CWindowGc::ENullBrush); + iGc->SetBrushColor(KRgbTransparent); + } + + // BASIC TEXT + + TInt posInSec = iVideoPlayer->PositionInMs() / 1000; + + TInt durationInSec = iVideoPlayer->DurationInMs() / 1000; + + const TInt KColumn = 3; + const TInt KRowIncrement = KFontSize + 1; + TInt row = KRowIncrement; + + iBuffer.Format( _L("Options page %i: "), CurrentPageNumber() ); + iBuffer.Append( CurrentPageName() ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Copy( _L("Softkey: ") ); + iBuffer.Append( CurrentSoftkeyName() ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Position: %i/%i secs "), posInSec, durationInSec ); + switch( iVideoPlayer->PlayState() ) + { + case CPlayerWindow::EPlaying: + iBuffer.Append( _L("") ); + break; + case CPlayerWindow::EPaused: + iBuffer.Append( _L("") ); + break; + case CPlayerWindow::EStopped: + iBuffer.Append( _L("") ); + break; + } + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + if( iLastError != KErrNone ) + { + iGc->SetPenColor(KRgbRed); + } + + iBuffer.Format ( _L("Last error: %i"), iLastError ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iGc->SetPenColor(KRgbCyan); + + RDebug::Printf( "CONSOLEPLAYER position=%i", posInSec ); + + + if( iVideoWindowTextMode > 1 ) + { + // ADVANCED TEXT + + // skip a row + row += KRowIncrement; + + iGc->DrawText( iVideoPlayer->Filename(), TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Display size: %ix%i"), iDisplaySize.iWidth, iDisplaySize.iHeight ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Video size: %ix%i"), iVideoPlayer->VideoSize().iWidth, iVideoPlayer->VideoSize().iHeight ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iVideoPlayer->WriteAdvancedText( *iGc, KColumn, row, KRowIncrement ); + } + } + + iVideoPlayer->Window().EndRedraw(); + + iGc->Deactivate(); + + iWs.Flush(); + } + +void CConsolePlayer::UpdateWindowOrdinalPositions() + { + TInt nextOrdinal = 0; + + iSelectionWindow->SetOrdinalPosition( nextOrdinal ); + nextOrdinal++; + + iHelpWindow->SetOrdinalPosition( nextOrdinal ); + nextOrdinal++; + + iFullScreenWindow->SetOrdinalPosition( nextOrdinal ); + nextOrdinal++; + + for( TInt playerIndex = 0; playerIndex < KPlayerCount; playerIndex++ ) + { + MPlayerCommands* player = NULL; + + switch( KOrdinalPositions[iOrdinalIndex][playerIndex] ) + { + case EVideoPlayer: + player = iVideoPlayer; + break; + case EVideoPlayer2: + player = iVideoPlayer2; + break; + case EVideoPlayer3: + player = iVideoPlayer3; + break; + case EExternalPlayer: + player = iExternalPlayer; + break; + case EExternalPlayer2: + player = iExternalPlayer2; + break; + } + + if( player ) + { + player->SetOrdinalPosition( nextOrdinal ); + nextOrdinal++; + } + } + } + +CPlayerWindow* CConsolePlayer::PlayerWindowNewL( TApiToUse aApi, + TPoint aTopLeft, + TSize aSize, + bool aTransparent, + TRgb aBackgroundColor, + bool aSuppressGraphicsContext ) + { + CPlayerWindow* player = NULL; + + switch( aApi ) + { + case EApi_VideoPlayer: + + player = CMmfPlayerWindow::NewL( iFs, + iWs, + *iScreenDevice, + *iWindowGroup, + aTopLeft, + aSize, + aTransparent, + aBackgroundColor, + aSuppressGraphicsContext ); + break; + + case EApi_OpenMaxAl: +#ifdef FF_OPENMAX_AL + + player = COpMaxPlayerWindow::NewL( iFs, + iWs, + *iScreenDevice, + *iWindowGroup, + aTopLeft, + aSize, + aTransparent, + aBackgroundColor, + aSuppressGraphicsContext); +#endif + break; + } + + return player; + } + +void CConsolePlayer::EnableDragging() + { + iPlayerBeingDragged = CurrentPlayer(); + + if( iPlayerBeingDragged ) + { + iPlayerBeingDragged->ExecuteOperation( EOperation_DrawRedBorderAroundWindow ); + StartReceivingPointerEvents(); + } + } + +void CConsolePlayer::DisableDragging() + { + if( iPlayerBeingDragged ) + { + // Stop routing pointer events to app. + StopReceivingPointerEvents(); + + if( iPlayerBeingDragged == CurrentPlayer() ) + { + iPlayerBeingDragged->ExecuteOperation( EOperation_DrawWhiteBorderAroundWindow ); + } + else + { + iPlayerBeingDragged->ExecuteOperation( EOperation_ClearBorderAroundWindow ); + } + + iPlayerBeingDragged = NULL; + } + } + +TInt CConsolePlayer::CreateAnotherPlayer( CPlayerWindow** aPlayerWindow, + CExternalPlayer** aExternalPlayer, + const TDesC& aExternalPlayerExeName, + TSize aSize, + TPoint aTopLeft ) + { + TInt err = KErrNone; + + bool resumePlayer1 = false; + bool resumePlayer2 = false; + bool resumePlayer3 = false; + bool resumeExternalPlayer1 = false; + bool resumeExternalPlayer2 = false; + + if( iVideoPlayer->PlayState() == CPlayerWindow::EPlaying ) + { + iVideoPlayer->Pause(); + resumePlayer1 = true; + } + + if( iVideoPlayer2 && iVideoPlayer2->PlayState() == CPlayerWindow::EPlaying ) + { + iVideoPlayer2->Pause(); + resumePlayer2 = true; + } + + if( iVideoPlayer3 && iVideoPlayer3->PlayState() == CPlayerWindow::EPlaying ) + { + iVideoPlayer3->Pause(); + resumePlayer3 = true; + } + + if( iExternalPlayer ) + { + iExternalPlayer->ExecuteOperation( EOperation_Pause ); + resumeExternalPlayer1 = true; + } + + if( iExternalPlayer2 ) + { + iExternalPlayer2->ExecuteOperation( EOperation_Pause ); + resumeExternalPlayer2 = true; + } + + TActionToPerform action; + TApiToUse api; + bool dummy; + TFileName location; + + TUint actionMask = (EAction_PlayLocalFile | EAction_PlayUrl | EAction_SameAsMainPlayer ); + + TUint apiMask = EApi_VideoPlayer; + + SelectAction( actionMask, apiMask, false, action, api, dummy, location ); + + if( action == EAction_SameAsMainPlayer ) + { + action = iMainPlayerAction; + api = iMainPlayerApi; + + if( action == EAction_PlayLocalFile ) + { + location = iVideoPlayer->FullFilename(); + } + else + { + location = iVideoPlayer->Url(); + } + } + + if( location.Length() > 0 ) + { + if( aPlayerWindow != NULL ) + { + // Create player as another window within this process. + TRAP( err, (*aPlayerWindow) = PlayerWindowNewL( api, + aTopLeft, + aSize, + true, // transparent + KRgbTransparent, + false ) ); + if( (*aPlayerWindow ) != NULL ) + { + if( action == EAction_PlayLocalFile ) + { + TRAP( err, (*aPlayerWindow)->StartWithFilenameL( location, CPlayerWindow::EBestFit) ); + } + else + { + TRAP( err, (*aPlayerWindow)->StartWithUrlL( location, CPlayerWindow::EBestFit) ); + } + + if( err != KErrNone ) + { + delete (*aPlayerWindow); + aPlayerWindow = NULL; + } + } + } + else + { + // Launch player within another process. + (*aExternalPlayer) = new CExternalPlayer( iWs ); + + if( (*aExternalPlayer) == NULL ) + { + err = KErrNoMemory; + } + else if( action == EAction_PlayLocalFile ) + { + err = (*aExternalPlayer)->Launch( aExternalPlayerExeName, + *iWindowGroup, + location, + true, + aTopLeft, + aSize ); + } + else + { + err = (*aExternalPlayer)->Launch( aExternalPlayerExeName, + *iWindowGroup, + location, + false, + aTopLeft, + aSize ); + } + } + + UpdateWindowOrdinalPositions(); + } + + if( resumePlayer1 ) + { + iVideoPlayer->Play(); + } + + if( resumePlayer2 ) + { + iVideoPlayer2->Play(); + } + + if( resumePlayer3 ) + { + iVideoPlayer3->Play(); + } + + if( resumeExternalPlayer1 ) + { + iExternalPlayer->ExecuteOperation( EOperation_Resume ); + } + + if( resumeExternalPlayer2 ) + { + iExternalPlayer2->ExecuteOperation( EOperation_Resume ); + } + + return err; + } + +TInt CConsolePlayer::ExecuteOperation( TInt aOperation ) + { + SendOperationToAllPlayers( aOperation ); + return KErrNone; + } + +void CConsolePlayer::MoveWindow( TPoint /*aNewCenter*/ ) + { + // Not used. + } + +void CConsolePlayer::SetOrdinalPosition( TInt /*aPosition*/ ) + { + // Not used. + } + +void CConsolePlayer::SendOperationToAllPlayers( TInt aOperation ) + { + iVideoPlayer->ExecuteOperation(aOperation); + if( iVideoPlayer2 ) + { + iVideoPlayer2->ExecuteOperation(aOperation); + } + if( iVideoPlayer3 ) + { + iVideoPlayer3->ExecuteOperation(aOperation); + } + if( iExternalPlayer ) + { + iExternalPlayer->ExecuteOperation(aOperation); + } + if( iExternalPlayer2 ) + { + iExternalPlayer2->ExecuteOperation(aOperation); + } + } + +void CConsolePlayer::ExecuteOperation( TInt aOperation, const TDesC& aOperationText ) + { + iSelectedOptionText.Copy( aOperationText ); + iSelectedOptionTextCounter = 2; + + RDebug::Printf( "CONSOLE PLAYER executing operation:" ); + RDebug::RawPrint( iSelectedOptionText ); + + if( iPlayerBeingDragged != NULL ) + { + DisableDragging(); + } + + iLastError = KErrNone; + + switch( aOperation ) + { + case EOperation_ChangeDisplayMode: + { + // Change video window text mode. + iVideoWindowTextMode = (iVideoWindowTextMode+1) % 3; + break; + } + case EOperation_ToggleSecondVideo: + { + if( iVideoPlayer2 ) + { + delete iVideoPlayer2; + iVideoPlayer2 = NULL; + iActivePlayer = NULL; + } + else + { + iLastError = CreateAnotherPlayer(&iVideoPlayer2, + NULL, + KNullDesC, + TSize(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2), + TPoint(0,iDisplaySize.iHeight/2)); + + iActivePlayer = iVideoPlayer2; + EnableDragging(); + } + break; + } + case EOperation_ToggleThirdVideo: + { + if( iVideoPlayer3 ) + { + delete iVideoPlayer3; + iVideoPlayer3 = NULL; + iActivePlayer = NULL; + } + else + { + iLastError = CreateAnotherPlayer(&iVideoPlayer3, + NULL, + KNullDesC, + TSize(iDisplaySize.iWidth/3,iDisplaySize.iHeight/3), + TPoint(0,2*iDisplaySize.iHeight/3)); + + iActivePlayer = iVideoPlayer3; + EnableDragging(); + } + break; + } + case EOperation_DragWindow: + { + EnableDragging(); + iSelectedOptionTextCounter = 1000; + break; + } + case EOperation_ToggleOrdinalPositions: + { + iOrdinalIndex = (iOrdinalIndex+1) % KOrdinalPositionConfigurationCount; + UpdateWindowOrdinalPositions(); + + iSelectedOptionTextCounter = 6; + iSelectedOptionText.Format(_L("Ordinals: %i %i %i %i %i"), + KOrdinalPositions[iOrdinalIndex][0] + 1, + KOrdinalPositions[iOrdinalIndex][1] + 1, + KOrdinalPositions[iOrdinalIndex][2] + 1, + KOrdinalPositions[iOrdinalIndex][3] + 1, + KOrdinalPositions[iOrdinalIndex][4] + 1 ); + break; + } + case EOperation_AbnormalTermination: + { + User::Panic( _L("Abnormal termination"), 123 ); + break; + } + case EOperation_ToggleExternalPlayer: + { + if( iExternalPlayer ) + { + delete iExternalPlayer; + iExternalPlayer = NULL; + iActivePlayer = NULL; + } + else + { + iLastError = CreateAnotherPlayer(NULL, + &iExternalPlayer, + KExternalPlayerExe, + TSize(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2), + TPoint(iDisplaySize.iWidth/2, 0)); + iActivePlayer = iExternalPlayer; + EnableDragging(); + } + break; + } + case EOperation_ToggleExternalPlayer2: + { + if( iExternalPlayer2 ) + { + delete iExternalPlayer2; + iExternalPlayer2 = NULL; + iActivePlayer = NULL; + } + else + { + iLastError = CreateAnotherPlayer(NULL, + &iExternalPlayer2, + KExternalPlayerExe2, + TSize(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2), + TPoint(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2)); + iActivePlayer = iExternalPlayer2; + EnableDragging(); + } + break; + } + case EOperation_LaunchAllWindows: + { + if( iVideoPlayer->FullFilename().Length() > 0 ) + { + if( iVideoPlayer2 == NULL ) + { + iVideoPlayer2 = PlayerWindowNewL( iMainPlayerApi, + TPoint(0,iDisplaySize.iHeight/2), + TSize(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2), + true, // transparent + KRgbTransparent, + false ); + + iVideoPlayer2->StartWithFilenameL( iVideoPlayer->FullFilename(), CPlayerWindow::EBestFit); + } + + if( iVideoPlayer3 == NULL ) + { + iVideoPlayer3 = PlayerWindowNewL( iMainPlayerApi, + TPoint(0,2*iDisplaySize.iHeight/3), + TSize(iDisplaySize.iWidth/3,iDisplaySize.iHeight/3), + true, // transparent + KRgbTransparent, + false ); + + iVideoPlayer3->StartWithFilenameL( iVideoPlayer->FullFilename(), CPlayerWindow::EBestFit); + } + + if( iExternalPlayer == NULL ) + { + iExternalPlayer = new CExternalPlayer( iWs ); + + iExternalPlayer->Launch( KExternalPlayerExe, + *iWindowGroup, + iVideoPlayer->FullFilename(), + true, + TPoint(iDisplaySize.iWidth/2, 0), + TSize(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2) ); + } + + /* TODO: FIGURE OUT HOW TO LAUNCH TWO EXTERNAL WINDOWS + if( iExternalPlayer2 == NULL ) + { + iExternalPlayer2 = new CExternalPlayer(); + + iExternalPlayer2->Launch( KExternalPlayerExe2, + *iWindowGroup, + iVideoPlayer->FullFilename(), + true, + TPoint(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2), + TSize(iDisplaySize.iWidth/2, iDisplaySize.iHeight/2) ); + + } + */ + + UpdateWindowOrdinalPositions(); + + DrawBorderAroundActiveWindows(); + } + break; + } + case EOperation_ObscureWindow: + { + iObscured = !iObscured; + iFullScreenWindow->SetVisible( iObscured ); + break; + } + default: + { + // Route the operation to the appropriate player window. + MPlayerCommands* player = CurrentPlayer(); + if( player ) + { + iLastError = player->ExecuteOperation( aOperation ); + } + else + { + // Do not show the operation text. + iSelectedOptionText.SetLength(0); + } + break; + } + } + + UpdateVideoWindow(); + + if( iLastError != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER error=%i", iLastError ); + } + } + +void CConsolePlayer::HandlePointerEvent( const TAdvancedPointerEvent& aEvent ) + { + TTestAppPointerEvent pointerEvent = CharacterizePointerEvent( aEvent ); + + if( pointerEvent == EPointerEvent_Select ) + { + DisableDragging(); + iSelectedOptionText.Copy( _L("Drag disabled") ); + iSelectedOptionTextCounter = 3; + UpdateVideoWindow(); + } + else + { + MPlayerCommands* player = CurrentPlayer(); + if( player ) + { + player->MoveWindow( aEvent.iParentPosition ); + } + + UpdateVideoWindow(); + } + } + +void CConsolePlayer::PlayInitiated() + { + RDebug::Printf( "CONSOLEPLAYER PlayInitiated" ); + + UpdateWindowOrdinalPositions(); + + if( iTimerCallback ) + { + iTimerCallback->Start( 1000000 ); // 1 second + } + + // Display this text at startup. + iSelectedOptionText.Copy( _L("Press '0' during playback for help") ); + iSelectedOptionTextCounter = 5; + + StartMonitoringWindowEvents(); + } + +void CConsolePlayer::PlayStateChanged() + { + UpdateVideoWindow(); + } + +void CConsolePlayer::Error(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER error=%i", aError ); + CActiveScheduler::Stop(); + + iFinalResult = aError; + } + +void CConsolePlayer::TimerCallback() + { + if( iSelectedOptionText.Length() > 0 ) + { + iSelectedOptionTextCounter--; + + if( iSelectedOptionTextCounter == 0 ) + { + iSelectedOptionText.SetLength(0); + } + } + + if( iVideoWindowTextMode > 0 ) + { + UpdateVideoWindow(); + } + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + CActiveScheduler* scheduler = new CActiveScheduler; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if( scheduler != NULL && cleanup != NULL ) + { + CActiveScheduler::Install( scheduler ); + TRAP_IGNORE( CConsolePlayer::ExecuteL() ); + } + delete cleanup; + delete scheduler; + REComSession::FinalClose(); + __UHEAP_MARKEND; + return 0; + } + diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/externalplayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/externalplayer.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Source file for the main class of the external player executable. + * + */ + +#include "externalplayer.h" +#include "mmfplayerwindow.h" +#include "testappbase.h" + +// This is the implementation for the external player executable. + +class CExternalPlayerExe : public CActive + { +public: + + static void ExecuteL() + { + CExternalPlayerExe* self = new(ELeave) CExternalPlayerExe; + CleanupStack::PushL( self ); + self->MainL(); + CleanupStack::PopAndDestroy( self ); + } + +private: + + CExternalPlayerExe() : CActive( EPriorityStandard ) + { + CActiveScheduler::Add( this ); + } + + ~CExternalPlayerExe() + { + Cancel(); + iMsgQueue.Close(); + iChunk.Close(); + delete iVideoPlayer; + delete iWindowGroup; + delete iScreenDevice; + iWs.Close(); + iFs.Close(); + } + + void MainL() + { + TInt err = KErrNone; + + User::LeaveIfError( iFs.Connect() ); + + User::LeaveIfError( iWs.Connect() ); + + iScreenDevice = new(ELeave) CWsScreenDevice( iWs ); + User::LeaveIfError( iScreenDevice->Construct() ); + + TBuf<200> commandLine; + User::CommandLine( commandLine ); + + TInt startIndex = commandLine.Find(KMsgQueuePrefix); + + if( startIndex < 0 ) + { + err = startIndex; + } + else + { + TPtrC msgQueueName = commandLine.Right( commandLine.Length() - startIndex - KMsgQueuePrefix().Length()); + err = iMsgQueue.CreateGlobal( msgQueueName, 3 ); + + if( err == KErrNone ) + { + TBuf<80> chunkName; + chunkName.Copy( msgQueueName ); + chunkName.Append( _L("_chunk") ); + err = iChunk.CreateGlobal( chunkName, 2048, 2048 ); // 2K chunk + } + } + + RProcess::Rendezvous( err ); + + if( err == KErrNone ) + { + SetActive(); + iMsgQueue.NotifyDataAvailable( iStatus ); + + CActiveScheduler::Start(); + } + } + + // inherited from CActive + + void RunL() + { + if( iStatus == KErrNone ) + { + TInt err = KErrNone; + + TExternalPlayerCommands msg; + iMsgQueue.Receive( msg ); + + RDebug::Printf( "EXTERNALPLAYER RunL() msg=%i", msg ); + + switch( msg ) + { + case EExternalPlayer_StartPlayback: + { + TStartPlayback* chunk = (TStartPlayback*)iChunk.Base(); + + TPtrC8 filename( chunk->name, chunk->length ); + iLocation.Copy( filename ); + iLocationIsFilename = chunk->locationIsFilename; + + iWindowTopRight.iX = chunk->x; + iWindowTopRight.iY = chunk->y; + iWindowSize.iWidth = chunk->width; + iWindowSize.iHeight = chunk->height; + + iWindowGroup = new RWindowGroup( iWs ); + err = iWindowGroup->ConstructChildApp( chunk->idOfParentWindowGroup, + KNullWsHandle, + false ); + ASSERT( err == KErrNone ); + + TStartPlaybackReturn* chunkReturn = (TStartPlaybackReturn*)iChunk.Base(); + + chunkReturn->windowGroupId = iWindowGroup->Identifier(); + + iVideoPlayer = CMmfPlayerWindow::NewL( iFs, + iWs, + *iScreenDevice, + *iWindowGroup, + iWindowTopRight, + iWindowSize, + true, // transparent + KRgbTransparent, + true ); + + if( iLocationIsFilename ) + { + iVideoPlayer->StartWithFilenameL( iLocation, CPlayerWindow::EBestFit); + } + else + { + iVideoPlayer->StartWithUrlL( iLocation, CPlayerWindow::EBestFit); + } + + RDebug::Printf( "EXTERNALPLAYER player started" ); + break; + } + case EExternalPlayer_ExecuteOperation: + { + TExecuteOperation* chunk = (TExecuteOperation*)iChunk.Base(); + err = iVideoPlayer->ExecuteOperation(chunk->operation ); + break; + } + case EExternalPlayer_MoveWindow: + { + TMoveWindow* chunk = (TMoveWindow*)iChunk.Base(); + iVideoPlayer->MoveWindow( TPoint(chunk->centerX, chunk->centerY) ); + break; + } + case EExternalPlayer_Shutdown: + { + RDebug::Printf( "EXTERNALPLAYER player stopped" ); + + CActiveScheduler::Stop(); + break; + } + } + + RProcess::Rendezvous( err ); + + SetActive(); + iMsgQueue.NotifyDataAvailable( iStatus ); + } + } + + void DoCancel() + { + iMsgQueue.CancelDataAvailable(); + } + + RFs iFs; + RWsSession iWs; + CWsScreenDevice* iScreenDevice; + RWindowGroup* iWindowGroup; + CPlayerWindow* iVideoPlayer; + RMsgQueue iMsgQueue; + RChunk iChunk; + TFileName iLocation; + bool iLocationIsFilename; + TPoint iWindowTopRight; + TSize iWindowSize; + + }; + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + CActiveScheduler* scheduler = new CActiveScheduler; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if( scheduler != NULL && cleanup != NULL ) + { + CActiveScheduler::Install( scheduler ); + TRAP_IGNORE( CExternalPlayerExe::ExecuteL() ); + } + delete cleanup; + delete scheduler; + __UHEAP_MARKEND; + return 0; + } + diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/mmf/mmfplayerwindow.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/mmf/mmfplayerwindow.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,507 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Source file for the MMF Player Window. + * + */ + +#include "mmfplayerwindow.h" + +bool IgnoreError( TInt aError ) + { + bool ignore = false; + // Some errors should be ignored. + + if( aError == -12017 ) + { + // partial playback - do not treat as an error + ignore = true; + RDebug::Printf( "CONSOLEPLAYER partial playback" ); + } + + return ignore; + } + +CMmfPlayerWindow* CMmfPlayerWindow::NewL( RFs& aFs, + RWsSession& aWs, + CWsScreenDevice& aScreenDevice, + const RWindowTreeNode &aParentWindow, + TPoint aTopRight, + TSize aSize, + bool aTransparent, + TRgb aBackgroundColor, + bool aSuppressGraphicsContext, + TUint32 aControllerUid ) + { + CMmfPlayerWindow* self = new(ELeave) CMmfPlayerWindow( aFs, aWs, aScreenDevice, aSuppressGraphicsContext, aControllerUid ); + CleanupStack::PushL( self ); + self->ConstructL( aParentWindow, aTopRight, aSize, aTransparent, aBackgroundColor ); + CleanupStack::Pop(); + return self; + } + +CMmfPlayerWindow::CMmfPlayerWindow( RFs& aFs, RWsSession& aWs, CWsScreenDevice& aScreenDevice, bool aSuppressGraphicsContext, TUint32 aControllerUid ) : + CPlayerWindow( aFs, aWs, aScreenDevice, aSuppressGraphicsContext ), + iControllerUid( aControllerUid ) + { + } + +CMmfPlayerWindow::~CMmfPlayerWindow() + { + delete iVideoPlayer; + } + +void CMmfPlayerWindow::ConstructL( const RWindowTreeNode &aParentWindow, TPoint aTopRight, TSize aSize, bool aTransparent, TRgb aBackgroundColor ) + { + BaseConstructL( aParentWindow, aTopRight, aSize, aTransparent, aBackgroundColor ); + +#ifdef __USE_VIDEOPLAYER_1__ + iVideoPlayer = CVideoPlayerUtility::NewL(*this, + EMdaPriorityNormal, + EMdaPriorityPreferenceTimeAndQuality, + iWs, + iScreenDevice, + iWindow, + TRect(iScreenDevice.SizeInPixels()), + TRect(iScreenDevice.SizeInPixels())); +#else + iVideoPlayer = CVideoPlayerUtility2::NewL(*this,EMdaPriorityNormal,EMdaPriorityPreferenceTimeAndQuality); +#endif + } + + +void CMmfPlayerWindow::InitializeParameters( TSize& aVideoSize, + TTimeIntervalMicroSeconds& aDuration, + TInt& aMaxVolume, + TInt& aCurrentVolume, + TInt& aBalanceCenter, + TInt& aBalanceMaxLeft, + TInt& aBalanceMaxRight, + TInt& aDefaultBalance, + TInt& aCurrentBalance ) + { + TRAPD( err, iVideoPlayer->VideoFrameSizeL(aVideoSize) ); + CheckError( err, "VideoFrameSizeL" ); + TRAP( err, aDuration = iVideoPlayer->DurationL() ); + CheckError( err, "DurationL" ); + aMaxVolume = iVideoPlayer->MaxVolume(); + aCurrentVolume = iVideoPlayer->Volume(); + aBalanceCenter = KMMFBalanceCenter; + aBalanceMaxLeft = KMMFBalanceMaxLeft; + aBalanceMaxRight = KMMFBalanceMaxRight; + aDefaultBalance = iVideoPlayer->Balance(); + aCurrentBalance = aDefaultBalance; + } + +void CMmfPlayerWindow::SetDefaultAutoscaleMode( TAutoscaleMode aDefaultAutoscale ) + { + switch( aDefaultAutoscale ) + { + case EDoNotAutoscale: + iAutoScale = EAutoScaleNone; + break; + case EBestFit: + iAutoScale = EAutoScaleBestFit; + break; + case EStretch: + iAutoScale = EAutoScaleStretch; + break; + } + iDefaultAutoScale = iAutoScale; +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD(err, iVideoPlayer->SetAutoScaleL(iAutoScale)); +#else + TRAPD(err, iVideoPlayer->SetAutoScaleL(iWindow, iAutoScale)); +#endif + if( err == KErrNotReady ) + { + // Too soon to call this. Will get called later, at the appropriate time. + } + else + { + CheckError( err, "SetDefaultAutoscaleMode" ); + } + } + +void CMmfPlayerWindow::PreparePlayerWithFile( RFile& aFile ) + { + const TUid KUidController = { iControllerUid }; + TRAPD( err, iVideoPlayer->OpenFileL(aFile, KUidController) ); + CheckError( err, "OpenFileL" ); + + // Now wait for MvpuoOpenComplete callback. + } + +void CMmfPlayerWindow::PreparePlayerWithUrl( const TDesC& aUrl ) + { + TRAPD( err, iVideoPlayer->OpenUrlL(aUrl) ); + CheckError( err, "OpenUrlL" ); + + // Now wait for MvpuoOpenComplete callback. + } + +TInt CMmfPlayerWindow::DoExecuteOperation( TInt /*aOperation*/ ) + { + // Currently there are no MMF-specific commands. + return KErrNotSupported; + } + +TTimeIntervalMicroSeconds CMmfPlayerWindow::Position() + { + TTimeIntervalMicroSeconds position = 0; + TRAPD( err, position = iVideoPlayer->PositionL() ); + CheckError( err, "PositionL" ); + return position; + } + +TInt CMmfPlayerWindow::SetVolume( TInt aVolume ) + { + TRAPD( err, iVideoPlayer->SetVolumeL( aVolume ) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetVolumeL %i err=%i", aVolume, err ); + } + return err; + } + +TInt CMmfPlayerWindow::SetBalance( TInt aBalance ) + { + TRAPD( err, iVideoPlayer->SetBalanceL( aBalance ) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetBalanceL %i err=%i", aBalance, err ); + } + return err; + } + +TInt CMmfPlayerWindow::RotationAngle() + { + switch( iRotation ) + { + case EVideoRotationClockwise90: + return 90; + case EVideoRotationClockwise180: + return 180; + case EVideoRotationClockwise270: + return 270; + default: + return 0; + } + } + +TInt CMmfPlayerWindow::NextRotationAngle() + { + switch( iRotation ) + { + case EVideoRotationNone: + iRotation = EVideoRotationClockwise90; + break; + case EVideoRotationClockwise90: + iRotation = EVideoRotationClockwise180; + break; + case EVideoRotationClockwise180: + iRotation = EVideoRotationClockwise270; + break; + case EVideoRotationClockwise270: + iRotation = EVideoRotationNone; + break; + } +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD( err, iVideoPlayer->SetRotationL(iRotation) ); +#else + TRAPD( err, iVideoPlayer->SetRotationL(iWindow, iRotation) ); +#endif + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetRotationL(%i) err=%i", iRotation, err ); + } + return err; + } + +TInt CMmfPlayerWindow::ResetRotation() + { + iRotation = EVideoRotationNone; +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD( err, iVideoPlayer->SetRotationL(iRotation) ); +#else + TRAPD( err, iVideoPlayer->SetRotationL(iWindow, iRotation) ); +#endif + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetRotationL(reset) err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::NextAutoscaleMode() + { + switch( iAutoScale ) + { + case EAutoScaleNone: + iAutoScale = EAutoScaleBestFit; + break; + case EAutoScaleBestFit: + iAutoScale = EAutoScaleClip; + break; + case EAutoScaleClip: + iAutoScale = EAutoScaleStretch; + break; + case EAutoScaleStretch: + iAutoScale = EAutoScaleNone; + break; + } +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD( err, iVideoPlayer->SetAutoScaleL(iAutoScale) ); +#else + TRAPD( err, iVideoPlayer->SetAutoScaleL(iWindow, iAutoScale) ); +#endif + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetAutoScaleL(%i) err=%i", iAutoScale, err ); + } + return err; + } + +TInt CMmfPlayerWindow::ResetAutoscale() + { + iAutoScale = iDefaultAutoScale; +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD( err, iVideoPlayer->SetAutoScaleL(iAutoScale) ); +#else + TRAPD( err, iVideoPlayer->SetAutoScaleL(iWindow, iAutoScale) ); +#endif + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetAutoScaleL(%i) err=%i", iAutoScale, err ); + } + return err; + } + +void CMmfPlayerWindow::AppendAutoscaleModeText( TDes& aString ) + { + switch( iAutoScale ) + { + case EAutoScaleNone: + aString.Append(_L("None")); + break; + case EAutoScaleBestFit: + aString.Append(_L("Best Fit")); + break; + case EAutoScaleClip: + aString.Append(_L("Clip")); + break; + case EAutoScaleStretch: + aString.Append(_L("Stretch")); + break; + } + } + +TInt CMmfPlayerWindow::SetClipRectangle( TRect aRect ) + { +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD( err, iVideoPlayer->SetCropRegionL(aRect) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetCropRegionL err=%i", err ); + } +#else + TRAPD( err, iVideoPlayer->SetWindowClipRectL(iWindow, aRect) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetCropRegionL err=%i", err ); + } +#endif + return err; + } + +TInt CMmfPlayerWindow::SetVideoExtent( TRect aExtent ) + { +#ifdef __USE_VIDEOPLAYER_1__ + // TODO: HOW DO YOU DO THIS WITH OLD VIDEO PLAYER? + TInt err = KErrNotSupported; + RDebug::Printf( "CONSOLEPLAYER SetVideoExtent not supported with video player 1" ); +#else + TRAPD( err, iVideoPlayer->SetVideoExtentL(iWindow, aExtent) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetVideoExtentL err=%i", err ); + } +#endif + return err; + } + +TInt CMmfPlayerWindow::SetScaleFactor( TReal aWidthScaleFactor, TReal aHeightScaleFactor ) + { +#ifdef __USE_VIDEOPLAYER_1__ + // TODO: WHAT VALUE SHOULD BE USED FOR aAntiAliasFiltering? + TRAPD( err, iVideoPlayer->SetScaleFactorL(aWidthScaleFactor, aHeightScaleFactor, ETrue) ); +#else + TRAPD( err, iVideoPlayer->SetScaleFactorL(iWindow, aWidthScaleFactor, aHeightScaleFactor) ); +#endif + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetScaleFactorL err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::Play() + { + iVideoPlayer->Play(); + return KErrNone; + } + +TInt CMmfPlayerWindow::Pause() + { + TRAPD(err, iVideoPlayer->PauseL()); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER PauseL err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::Stop() + { + TInt err = iVideoPlayer->Stop(); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER Stop err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::SetPosition( TTimeIntervalMicroSeconds aPositionInMs ) + { + TRAPD( err, iVideoPlayer->SetPositionL( aPositionInMs ) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetPositionL err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::StepForward() + { + TRAPD( err, iVideoPlayer->StepFrameL(1) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER StepFrameL(1) err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::StepBackward() + { + TRAPD( err, iVideoPlayer->StepFrameL(-1) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER StepFrameL(-1) err=%i", err ); + } + return err; + } + +TInt CMmfPlayerWindow::SetPlayVelocity( TInt aVelocity ) + { + TRAPD( err,iVideoPlayer->SetPlayVelocityL(aVelocity) ); + if( err != KErrNone ) + { + RDebug::Printf( "CONSOLEPLAYER SetPlayVelocityL %i err=%i", aVelocity, err ); + } + return err; + } + +// inherited from MVideoPlayerUtilityObserver + +void CMmfPlayerWindow::MvpuoOpenComplete(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoOpenComplete(%i)", aError ); + + if( aError == KErrNone ) + { + iVideoPlayer->Prepare(); + + // Now wait for MvpuoPrepareComplete callback. + } + else if( !IgnoreError( aError ) ) + { + CheckError( aError, "MvpuOpenComplete" ); + } + } + +void CMmfPlayerWindow::MvpuoPrepareComplete(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoPrepareComplete(%i)", aError ); + + if( aError == KErrNone ) + { +#ifdef __USE_VIDEOPLAYER_1__ + TRAPD( err, iVideoPlayer->SetDisplayWindowL( iWs, + iScreenDevice, + iWindow, + TRect(iWindow.Position(), iWindow.Size()), + TRect(iWindow.Position(), iWindow.Size())) ); +#else + TRAPD( err, iVideoPlayer->AddDisplayWindowL( iWs, iScreenDevice, iWindow ) ); +#endif + if( err == KErrNone ) + { + Play(); + ResetAutoscale(); + } + else + { + RDebug::Printf("CONSOLEPLAYER AddDisplayWindowL failed, err=%i", err ); + } + PlayInitiated(); + } + else if( !IgnoreError( aError ) ) + { + Error( aError ); + } + } + +void CMmfPlayerWindow::MvpuoFrameReady(CFbsBitmap& /*aFrame*/,TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoFrameReady(%i)", aError ); + + if( (aError != KErrNone) && !IgnoreError( aError ) ) + { + Error( aError ); + } + } + +void CMmfPlayerWindow::MvpuoPlayComplete(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoPlayComplete(%i)", aError ); + + if( aError == KErrNone ) + { + PlayComplete(); + } + else if( !IgnoreError( aError ) ) + { + Error( aError ); + } + } + +void CMmfPlayerWindow::MvpuoEvent(const TMMFEvent& aEvent) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoEvent event=%x error=%i", aEvent.iEventType.iUid, aEvent.iErrorCode ); + + if( aEvent.iErrorCode != KErrNone && !IgnoreError( aEvent.iErrorCode ) ) + { + Error( aEvent.iErrorCode ); + } + } diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/mmf/mmfplayerwindow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/mmf/mmfplayerwindow.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Header file specifing the interface for the MMF Player Window. + * + */ + +#ifndef __MMF_PLAYER_WINDOW_H__ +#define __MMF_PLAYER_WINDOW_H__ + +#include + +#ifdef __USE_VIDEOPLAYER_1__ +#include +#else +#include +#endif + +#include "playerwindow.h" + +const TUint32 KUidVideoController = { 0x101f8514 }; + +class CMmfPlayerWindow : public CPlayerWindow, + private MVideoPlayerUtilityObserver + { +public: + + static CMmfPlayerWindow* NewL( RFs& aFs, + RWsSession& aWs, + CWsScreenDevice& aScreenDevice, + const RWindowTreeNode &aParentWindow, + TPoint aTopRight, + TSize aSize, + bool aTransparent, + TRgb aBackgroundColor, + bool aSuppressGraphicsContext, + TUint32 aControllerUid = KUidVideoController ); + + virtual ~CMmfPlayerWindow(); + + // inherited from CPlayerWindow + virtual TTimeIntervalMicroSeconds Position(); + virtual TInt SetVolume( TInt aVolume ); + virtual TInt SetBalance( TInt aBalance ); + virtual TInt RotationAngle(); + virtual TInt NextRotationAngle(); + virtual TInt ResetRotation(); + virtual TInt NextAutoscaleMode(); + virtual TInt ResetAutoscale(); + virtual void AppendAutoscaleModeText( TDes& aString ); + virtual TInt SetClipRectangle( TRect aRect ); + virtual TInt SetVideoExtent( TRect aExtent ); + virtual TInt SetScaleFactor( TReal aWidthScaleFactor, TReal aHeightScaleFactor ); + virtual TInt Play(); + virtual TInt Pause(); + virtual TInt Stop(); + virtual TInt SetPosition( TTimeIntervalMicroSeconds aPositionInMs ); + virtual TInt StepForward(); + virtual TInt StepBackward(); + virtual TInt SetPlayVelocity( TInt aVelocity ); + virtual TInt DoExecuteOperation( TInt aOperation ); + virtual void InitializeParameters( TSize& aVideoSize, + TTimeIntervalMicroSeconds& aDuration, + TInt& aMaxVolume, + TInt& aCurrentVolume, + TInt& aBalanceCenter, + TInt& aBalanceMaxLeft, + TInt& aBalanceMaxRight, + TInt& aDefaultBalance, + TInt& aCurrentBalance ); + virtual void SetDefaultAutoscaleMode( TAutoscaleMode aDefaultAutoscale ); + virtual void PreparePlayerWithFile( RFile& aFile ); + virtual void PreparePlayerWithUrl( const TDesC& aUrl ); + +private: + + CMmfPlayerWindow( RFs& aFs, RWsSession& aWs, CWsScreenDevice& aScreenDevice, bool aSuppressGraphicsContext, TUint32 aControllerUid ); + + void ConstructL( const RWindowTreeNode &aParentWindow, TPoint aTopRight, TSize aSize, bool aTransparent, TRgb aBackgroundColor ); + + // inherited from MVideoPlayerUtilityObserver + virtual void MvpuoOpenComplete(TInt aError); + virtual void MvpuoPrepareComplete(TInt aError); + virtual void MvpuoFrameReady(CFbsBitmap& aFrame,TInt aError); + virtual void MvpuoPlayComplete(TInt aError); + virtual void MvpuoEvent(const TMMFEvent& aEvent); + +#ifdef __USE_VIDEOPLAYER_1__ + CVideoPlayerUtility* iVideoPlayer; +#else + CVideoPlayerUtility2* iVideoPlayer; +#endif + + TVideoRotation iRotation; + TAutoScaleType iDefaultAutoScale; + TAutoScaleType iAutoScale; + TUint32 iControllerUid; + + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/openmax_al/openmaxplayerutility.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/openmax_al/openmaxplayerutility.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,453 @@ +#include +#include +#include "openmaxplayerutility.h" + +#define FILE_EXTN "file:///" +#define FILE_EXTN_LEN strlen("file:///") + +XAboolean bIsPlayDone = XA_BOOLEAN_FALSE; + +void PlayCallbackFun (XAPlayItf /*caller*/, void* pContext, XAuint32 event) +{ + char callback_string[50]; + COpenMaxPlayerUtility* pSelf = (COpenMaxPlayerUtility*)pContext; + if(event & XA_PLAYEVENT_HEADMOVING) + { + strcpy(callback_string, "XA_PLAYEVENT_HEADMOVING"); + } + else if(event & XA_PLAYEVENT_HEADATEND) + { + strcpy(callback_string, "XA_PLAYEVENT_HEADATEND"); + bIsPlayDone = XA_BOOLEAN_TRUE; + pSelf->Stop(); + } + else if(event & XA_PLAYEVENT_HEADATMARKER) + { + strcpy(callback_string, "XA_PLAYEVENT_HEADATMARKER"); + } + else if(event & XA_PLAYEVENT_HEADATNEWPOS) + { + strcpy(callback_string, "XA_PLAYEVENT_HEADATNEWPOS"); + } + else if(event & XA_PLAYEVENT_HEADSTALLED) + { + strcpy(callback_string, "XA_PLAYEVENT_HEADSTALLED"); + } + //LOGFILE (callback_string); +} + +COpenMaxPlayerUtility::COpenMaxPlayerUtility() +{ + Init(); +} + +COpenMaxPlayerUtility::~COpenMaxPlayerUtility() +{ + /* Destroy the player */ + DestroyPlayer (); + + /* Destroy Output Mix object */ + (*m_outputMix)->Destroy(m_outputMix); + + /* Shutdown OpenMAX AL */ + (*m_engine)->Destroy(m_engine); +} + +// Initializes the OpenMAX AL engine and start the playback of some +// music from a file and draw the graphical equalizer +// +void COpenMaxPlayerUtility::Init (void) +{ + XAresult res; + int i; + XAEngineOption EngineOption[] = { + (XAuint32) XA_ENGINEOPTION_THREADSAFE, + (XAuint32) XA_BOOLEAN_TRUE + }; + + /* Create OpenMAX AL */ + res = xaCreateEngine(&m_engine, 1, EngineOption, 0, NULL, NULL); + CheckErr(res, "xaCreateEngine"); + + /* Realizing the XA Engine in synchronous mode. */ + res = (*m_engine)->Realize(m_engine, XA_BOOLEAN_FALSE); + CheckErr(res, "Realize(engine)"); + + /* Get the XA Engine Interface which is implicit */ + res = (*m_engine)->GetInterface(m_engine, XA_IID_ENGINE, (void**) &m_EngineItf); + CheckErr(res, "GetInterface(engine)"); + + /* Initialize arrays required[] and iidArray[] */ + for (i = 0; i < MAX_NUMBER_INTERFACES; i++) + { + m_required[i] = XA_BOOLEAN_FALSE; + m_iidArray[i] = XA_IID_NULL; + } + + /* Set arrays required[] and iidArray[] for VOLUME and EQUALIZER interfaces */ + m_required[0] = XA_BOOLEAN_TRUE; + m_iidArray[0] = XA_IID_VOLUME; + m_required[1] = XA_BOOLEAN_TRUE; + m_iidArray[1] = XA_IID_EQUALIZER; + + /* Create Output Mix object to be used by player */ + res = (*m_EngineItf)->CreateOutputMix(m_EngineItf, &m_outputMix, 2, m_iidArray, m_required); + CheckErr(res, "CreateOutputMix"); + + /* Realizing the Output Mix object in synchronous mode. */ + res = (*m_outputMix)->Realize(m_outputMix, XA_BOOLEAN_FALSE); + CheckErr(res, "Realize(outputMix)"); + + /* Get volume and equalizer interfaces */ + res = (*m_outputMix)->GetInterface(m_outputMix, XA_IID_VOLUME, (void**) &m_volumeItf); + CheckErr(res, "GetInterface(volume)"); + res = (*m_outputMix)->GetInterface(m_outputMix, XA_IID_EQUALIZER, (void**) &m_equalizerItf); + CheckErr(res, "GetInterface(equalizer)"); + + // Setup the audio sink structure + m_locator_outputmix.locatorType = XA_DATALOCATOR_OUTPUTMIX; + m_locator_outputmix.outputMix = m_outputMix; + m_audioSink.pLocator = (void*) &m_locator_outputmix; + m_audioSink.pFormat = NULL; + + /* Set arrays required[] and iidArray[] for no interfaces (PlayItf is implicit) */ + m_required[0] = XA_BOOLEAN_TRUE; + m_iidArray[0] = XA_IID_DYNAMICSOURCE; + m_required[1] = XA_BOOLEAN_FALSE; + m_iidArray[1] = XA_IID_NULL; + + // Setup the video sink structure + // Set nativeWindowHandle and nativeDisplayHandle to platform specific values + XANativeHandle nativeWindowHandle = NULL; + XANativeHandle nativeDisplayHandle = NULL; + + m_locator_displayregion.locatorType = XA_DATALOCATOR_NATIVEDISPLAY; + m_locator_displayregion.hDisplay = nativeDisplayHandle; + m_locator_displayregion.hWindow = nativeWindowHandle; + m_videoSink.pLocator = (void*) &m_locator_displayregion; + m_videoSink.pFormat = NULL; + + /* Before we start set volume to -3dB (-300mB) and enable equalizer */ + XAmillibel minVol = m_nVolume = XA_MILLIBEL_MIN; + XAmillibel maxVol = 0; + res = (*m_volumeItf)->GetMaxVolumeLevel (m_volumeItf, &maxVol); + CheckErr(res, "GetMaxVolumeLevel"); + + // before Play, set volume + res = (*m_volumeItf)->SetVolumeLevel(m_volumeItf, minVol); + CheckErr(res, "SetVolumeLevel"); +} + +void COpenMaxPlayerUtility::DestroyPlayer () + { + XAresult res; + XAuint32 playState; + /* Stop the music */ + res = (*m_playItf)->GetPlayState(m_playItf, &playState); + CheckErr(res, "GetPlayState"); + + if ( playState != XA_PLAYSTATE_STOPPED ) + { + res = (*m_playItf)->SetPlayState(m_playItf, XA_PLAYSTATE_STOPPED); + CheckErr(res, "SetPlayState(stopped)"); + } + + // Destroy the player caused app to crash +// (*player)->Destroy(player); + } + +/* +* Called when the display is repainted. +*/ +void COpenMaxPlayerUtility::DrawEQDisplay (void) +{ + XAuint16 numBands; + XAmillibel bandLevel; + XAmillibel minLevel; + XAmillibel maxLevel; + XAmilliHertz minFreq; + XAmilliHertz maxFreq; + int band; + XAresult res; + res = (*m_equalizerItf)->GetNumberOfBands(m_equalizerItf, &numBands); + CheckErr(res, "GetNumberOfBands(equalizerItf)"); + res = (*m_equalizerItf)->GetBandLevelRange(m_equalizerItf, &minLevel, &maxLevel); + CheckErr(res, "GetBandLevelRange(equalizerItf)"); + for (band = 0; bandGetBandFreqRange(m_equalizerItf, (XAint16) band, &minFreq, &maxFreq); + CheckErr(res, "GetBandFreqRange(equalizerItf)"); + res = (*m_equalizerItf)->GetBandLevel(m_equalizerItf, (XAint16)band, &bandLevel); + CheckErr(res, "GetBandLevel(equalizerItf)"); + // drawEQBand(minFreq, maxFreq, bandLevel); + } +} + +void COpenMaxPlayerUtility::VideoFrameSize(TSize& /*aSize*/) const +{ +} + +TTimeIntervalMicroSeconds COpenMaxPlayerUtility::Position() const +{ + return 0; +} + +TTimeIntervalMicroSeconds COpenMaxPlayerUtility::Duration() const +{ + return 0; +} + +TInt COpenMaxPlayerUtility::Volume() const + { + return m_nVolume; + } + +TInt COpenMaxPlayerUtility::MaxVolume() const + { + return m_nVolume; + } + +TInt COpenMaxPlayerUtility::Balance()const +{ + return 0; +} + +TVideoRotation COpenMaxPlayerUtility::Rotation() const +{ + return EVideoRotationNone; +} + +void COpenMaxPlayerUtility::SetVolume(TInt aVolume) + { + m_nVolume = aVolume; + XAresult res = (*m_volumeItf)->SetVolumeLevel(m_volumeItf, (XAmillibel)m_nVolume); + CheckErr(res, "SetVolumeL"); + } + +void COpenMaxPlayerUtility::SetBalance(TInt /*aBalance*/) + { + } + +void COpenMaxPlayerUtility::SetPosition(const TTimeIntervalMicroSeconds& /*aPosition*/) + { + + } + +void COpenMaxPlayerUtility::SetRotation(const RWindow& /*aWindow*/, TVideoRotation /*aRotation*/) + { + + } + +void COpenMaxPlayerUtility::SetScaleFactor(const RWindow& /*aWindow*/, TReal32 /*aWidthPercentage*/, + TReal32 /*aHeightPercentage*/) + { + + } + +void COpenMaxPlayerUtility::SetAutoScale(const RWindow& /*aWindow*/, TAutoScaleType /*aScaleType*/) + { + + } + +void COpenMaxPlayerUtility::StepFrame(TInt /*aStep*/) + { + + } + +void COpenMaxPlayerUtility::OpenFile(const TDesC& aFileName, TUid /*aControllerUid*/) + { + const TUint16 *pFile = aFileName.Ptr(); + TInt len = aFileName.Length(); + + if (pFile) + { + strcpy((char*)m_sourceName, FILE_EXTN); + len = wcstombs((char*)&m_sourceName[FILE_EXTN_LEN], (const wchar_t *)pFile, len); + m_sourceName[FILE_EXTN_LEN + len] = '\0'; + uri.locatorType = XA_DATALOCATOR_URI; + uri.URI = (XAchar*) m_sourceName; + m_mime.formatType = XA_DATAFORMAT_MIME; + m_mime.mimeType = (XAchar *) "audio/ra"; + + //Do we need this here? + PlaySource (uri); + } + } + +void COpenMaxPlayerUtility::OpenUrl(const TDesC& /*aUrl*/) + { + + } + +void COpenMaxPlayerUtility::Prepare() + { + + } + +void COpenMaxPlayerUtility::Close() + { + + } + +void COpenMaxPlayerUtility::Pause() + { + XAresult res; + res = (*m_playItf)->SetPlayState(m_playItf, XA_PLAYSTATE_PAUSED); + CheckErr(res, "SetPlayState(paused)"); + } + +void COpenMaxPlayerUtility::Play() + { + XAresult res; + res = (*m_playItf)->SetPlayState(m_playItf, XA_PLAYSTATE_PLAYING); + CheckErr(res, "SetPlayState(playing)"); + } + +TInt COpenMaxPlayerUtility::Stop() + { + DestroyPlayer(); + return 0; + } + +void COpenMaxPlayerUtility::AddDisplayWindow(RWsSession& aWs, CWsScreenDevice& /*aScreenDevice*/, RWindow& aWindow) + { + m_locator_displayregion.hDisplay = &aWs; //pointer to RWsSession + m_locator_displayregion.hWindow = &aWindow; //pointer to RWindow + } + +void COpenMaxPlayerUtility::SetWindowClipRect(const RWindow& /*aWindow*/, const TRect& /*aWindowClipRect*/) + { + + } + +void COpenMaxPlayerUtility::SetVideoExtent(const RWindow& /*aWindow*/, const TRect& /*aVideoExtent*/) + { + + } + +/* Checks for error. If any errors exit the application! */ +bool COpenMaxPlayerUtility::CheckErr (XAresult res, char* /*aMsg*/) +{ + return (res == XA_RESULT_SUCCESS); +} + + +/* +* Called by UI when user increases or decreases a band level. +*/ +void COpenMaxPlayerUtility::SetBandLevel(XAint16 band, XAboolean increase) +{ + XAuint16 numBands; + XAmillibel bandLevel; + XAmillibel minLevel; + XAmillibel maxLevel; + XAresult res; + + res = (*m_equalizerItf)->GetNumberOfBands(m_equalizerItf, &numBands); + CheckErr(res, "GetNumberOfBands"); + + res = (*m_equalizerItf)->GetBandLevelRange(m_equalizerItf, &minLevel, &maxLevel); + CheckErr(res, "GetBandLevelRange"); + if (band >= numBands) + { + /* Error. Insert debug print here. */ + exit(0); + } + + res = (*m_equalizerItf)->GetBandLevel(m_equalizerItf, band, &bandLevel); + CheckErr(res, "GetBandLevel"); + + if (increase==XA_BOOLEAN_TRUE) + { + /* increase the level by 1 dB (100mB) if the max supported level + * is not exceeded */ + bandLevel = bandLevel + 100; + if(bandLevel < maxLevel) + { + res = (*m_equalizerItf)->SetBandLevel(m_equalizerItf, band, bandLevel); + CheckErr(res); + DrawEQDisplay(); + } + } + else /* increase==false */ + { + /* decrease the level by 1 dB (100mB) if the min supported level + * is not crossed */ + bandLevel = bandLevel - 100; + if( bandLevel > minLevel ) + { + res = (*m_equalizerItf)->SetBandLevel(m_equalizerItf, band, bandLevel); + CheckErr(res); + DrawEQDisplay(); + } + } +} + +void COpenMaxPlayerUtility::PlaySource(const XADataLocator_URI &source) + { + m_dataSource.pLocator = (void*) &source; + m_dataSource.pFormat = (void*) &m_mime; + + // Create the music player // + XAresult res; + res = (*m_EngineItf)->CreateMediaPlayer ( m_EngineItf, &player, &m_dataSource, NULL, &m_audioSink, + &m_videoSink, NULL, NULL, 1, m_iidArray, m_required); + CheckErr(res, "CreateMediaPlayer"); + + // Realizing the player in synchronous mode. + res = (*player)->Realize(player, XA_BOOLEAN_FALSE); + CheckErr(res, "Realize(player)"); + + // Get the play interface + res = (*player)->GetInterface(player, XA_IID_PLAY, (void**) &m_playItf); + CheckErr(res, "GetInterface(player)"); + +/* XADynamicSourceItf sourceItf; + res = (*player)->GetInterface(player, XA_IID_DYNAMICSOURCE, (void**) &sourceItf); + CheckErr(res, "GetDynamicSource"); + + res = (*sourceItf)->SetSource (sourceItf, &m_dataSource); + CheckErr(res, "SetSource"); +*/ + // before Play, set volume + res = (*m_volumeItf)->SetVolumeLevel(m_volumeItf, m_nVolume); + CheckErr(res, "SetVolumeLevel"); + + XAmillisecond playDuration = 0; + res = (*m_playItf)->GetDuration(m_playItf, &playDuration); + bool b = CheckErr(res, "GetDuration"); + //if ( b && (playDuration != XA_DURATION_UNKNOWN) ) + //SetDurationL ((playDuration/1000)); + + res = (*m_playItf)->SetCallbackEventsMask(m_playItf, XA_PLAYEVENT_HEADATEND | XA_PLAYEVENT_HEADMOVING); + CheckErr(res, "SetCallbackEventsMask"); + + res = (*m_playItf)->RegisterCallback(m_playItf, PlayCallbackFun, this); + CheckErr(res, "RegisterCallback"); + //Do we need this here? + Play(); + } + +void COpenMaxPlayerUtility::PlayPause(bool bChecked) + { + if (bChecked) + { + Pause(); + } + else + { + Play(); + } + } + +void COpenMaxPlayerUtility::MuteChanged(bool bChecked) + { + XAresult res = (*m_volumeItf)->SetMute(m_volumeItf, (XAboolean)bChecked); + CheckErr(res, "MuteChanged"); + } + +TInt COpenMaxPlayerUtility::SetPlayVelocity( TInt aVelocity ) + { + m_Velocity = aVelocity; + return 0; + } diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/openmax_al/openmaxplayerutility.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/openmax_al/openmaxplayerutility.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,89 @@ +#ifndef OPENMAX_PLAYER_UTILITY_H +#define OPENMAX_PLAYER_UTILITY_H + +#include +#include +#include +#include // for TVideoRotation and TAutoScaleType +#include "playerwindow.h" +#include "openmaxal.h" + +#define MAX_NUMBER_INTERFACES 5 + +class COpenMaxPlayerUtility +{ +public: + COpenMaxPlayerUtility(); + ~COpenMaxPlayerUtility(); + + void VideoFrameSize(TSize& aSize) const; + TTimeIntervalMicroSeconds Position() const; + TTimeIntervalMicroSeconds Duration() const; + TInt Volume() const; + TInt MaxVolume() const; + TInt Balance()const; + TVideoRotation Rotation() const; + + void SetVolume(TInt aVolume); + void SetBalance(TInt aBalance); + void SetPosition(const TTimeIntervalMicroSeconds& aPosition); + void SetRotation(const RWindow& aWindow, TVideoRotation aRotation); + void SetScaleFactor(const RWindow& aWindow, TReal32 aWidthPercentage, TReal32 aHeightPercentage); + void SetAutoScale(const RWindow& aWindow, TAutoScaleType aScaleType); + void StepFrame(TInt aStep); + + void OpenFile(const TDesC& aFileName,TUid aControllerUid = KNullUid); + void OpenUrl(const TDesC& aUrl); + void Prepare(); + void Close(); + void Play(); + TInt Stop(); + void Pause(); + + void AddDisplayWindow(RWsSession& aWs, CWsScreenDevice& aScreenDevice, RWindow& aWindow); + void SetWindowClipRect(const RWindow& aWindow, const TRect& aWindowClipRect); + void SetVideoExtent(const RWindow& aWindow, const TRect& aVideoExtent); + + bool CheckErr (XAresult res, char* aMsg = ""); + + void Init (void); + void DestroyPlayer (); + void DrawEQDisplay (void); + void SetBandLevel(XAint16 band, XAboolean increase); + void PlaySource(const XADataLocator_URI &source); + void PlayPause(bool); + void MuteChanged(bool); + TInt SetPlayVelocity( TInt aVelocity ); + +protected: + void StartBackLightTimer(); + void CancelBackLightTimer(); + +private: + XAObjectItf m_engine; /* OpenMAX AL Engine */ + XAObjectItf player; + XAObjectItf m_outputMix; + + XAEngineItf m_EngineItf; + XAPlayItf m_playItf; + XAEqualizerItf m_equalizerItf; + XAVolumeItf m_volumeItf; + + XAInterfaceID m_iidArray[MAX_NUMBER_INTERFACES]; + XAboolean m_required[MAX_NUMBER_INTERFACES]; + + XADataSource m_dataSource; + XADataSink m_audioSink; + XADataSink m_videoSink; + XADataFormat_MIME m_mime; + XADataLocator_OutputMix m_locator_outputmix; + XADataLocator_NativeDisplay m_locator_displayregion; + XADataLocator_URI uri; + + TRect m_displayRect; + int m_nVolume; + int m_Velocity; + XAchar m_sourceName[1000]; +}; + +#endif // OPENMAX_PLAYER_UTILITY_H diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/openmax_al/opmaxplayerwindow.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/openmax_al/opmaxplayerwindow.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,347 @@ +#include "opmaxplayerwindow.h" +#include "openmaxplayerutility.h" + + +/** +Balance values from mmfstandardcustomcommands.h +*/ +#if 0 +const TInt KMMFBalanceCenter = 0; +const TInt KMMFBalanceMaxLeft = -100; +const TInt KMMFBalanceMaxRight = 100; +#endif + +COpMaxPlayerWindow* COpMaxPlayerWindow::NewL( RFs& aFs, + RWsSession& aWs, + CWsScreenDevice& aScreenDevice, + const RWindowTreeNode &aParentWindow, + TPoint aTopRight, + TSize aSize, + bool aTransparent, + TRgb aBackgroundColor, + bool aSuppressGraphicsContext) + { + COpMaxPlayerWindow* self = new(ELeave) COpMaxPlayerWindow( aFs, aWs, aScreenDevice, aSuppressGraphicsContext); + CleanupStack::PushL( self ); + self->ConstructL( aParentWindow, aTopRight, aSize, aTransparent, aBackgroundColor ); + CleanupStack::Pop(); + return self; + } + +COpMaxPlayerWindow::COpMaxPlayerWindow( RFs& aFs, RWsSession& aWs, CWsScreenDevice& aScreenDevice, bool aSuppressGraphicsContext ) : + CPlayerWindow( aFs, aWs, aScreenDevice, aSuppressGraphicsContext ) + { + } + +COpMaxPlayerWindow::~COpMaxPlayerWindow() + { + delete iVideoPlayer; + } + +void COpMaxPlayerWindow::ConstructL( const RWindowTreeNode &aParentWindow, TPoint aTopRight, TSize aSize, bool aTransparent, TRgb aBackgroundColor ) + { + BaseConstructL( aParentWindow, aTopRight, aSize, aTransparent, aBackgroundColor ); + + iVideoPlayer = new (ELeave) COpenMaxPlayerUtility; + iVideoPlayer->AddDisplayWindow( iWs, iScreenDevice, iWindow ); + } + + +void COpMaxPlayerWindow::InitializeParameters( TSize& aVideoSize, + TTimeIntervalMicroSeconds& aDuration, + TInt& aMaxVolume, + TInt& aCurrentVolume, + TInt& aBalanceCenter, + TInt& aBalanceMaxLeft, + TInt& aBalanceMaxRight, + TInt& aDefaultBalance, + TInt& aCurrentBalance ) + { + iVideoPlayer->VideoFrameSize(aVideoSize); + aDuration = iVideoPlayer->Duration(); + aMaxVolume = iVideoPlayer->MaxVolume(); + aCurrentVolume = iVideoPlayer->Volume(); + aBalanceCenter = KMMFBalanceCenter; + aBalanceMaxLeft = KMMFBalanceMaxLeft; + aBalanceMaxRight = KMMFBalanceMaxRight; + aDefaultBalance = iVideoPlayer->Balance(); + aCurrentBalance = aDefaultBalance; + } + +void COpMaxPlayerWindow::SetDefaultAutoscaleMode( TAutoscaleMode aDefaultAutoscale ) + { + switch( aDefaultAutoscale ) + { + case EDoNotAutoscale: + iAutoScale = EAutoScaleNone; + break; + case EBestFit: + iAutoScale = EAutoScaleBestFit; + break; + case EStretch: + iAutoScale = EAutoScaleStretch; + break; + } + iDefaultAutoScale = iAutoScale; + iVideoPlayer->SetAutoScale(iWindow, iAutoScale); + } + +void COpMaxPlayerWindow::PreparePlayerWithFile( RFile& aFile ) + { + TFileName fileName; + aFile.FullName(fileName); + iVideoPlayer->OpenFile(fileName); + + // Now wait for MvpuoOpenComplete callback. + PlayInitiated(); + } + +void COpMaxPlayerWindow::PreparePlayerWithUrl( const TDesC& aUrl ) + { + iVideoPlayer->OpenFile(aUrl); + + // Now wait for MvpuoOpenComplete callback. + } + +TInt COpMaxPlayerWindow::DoExecuteOperation( TInt /*aOperation*/ ) + { + // Currently there are no MMF-specific commands. + return KErrNotSupported; + } + +TTimeIntervalMicroSeconds COpMaxPlayerWindow::Position() + { + TTimeIntervalMicroSeconds position = iVideoPlayer->Position(); + return position; + } + +TInt COpMaxPlayerWindow::SetVolume( TInt aVolume ) + { + iVideoPlayer->SetVolume( aVolume ); + return 0; + } + +TInt COpMaxPlayerWindow::SetBalance( TInt aBalance ) + { + iVideoPlayer->SetBalance( aBalance ); + return 0; + } + +TInt COpMaxPlayerWindow::RotationAngle() + { + TInt rotAngle = 0; + switch( iRotation ) + { + case EVideoRotationClockwise90: + rotAngle = 90; + case EVideoRotationClockwise180: + rotAngle = 180; + case EVideoRotationClockwise270: + rotAngle = 270; + default: + rotAngle = 0; + } + return rotAngle; + } + +TInt COpMaxPlayerWindow::NextRotationAngle() + { + switch( iRotation ) + { + case EVideoRotationNone: + iRotation = EVideoRotationClockwise90; + break; + case EVideoRotationClockwise90: + iRotation = EVideoRotationClockwise180; + break; + case EVideoRotationClockwise180: + iRotation = EVideoRotationClockwise270; + break; + case EVideoRotationClockwise270: + iRotation = EVideoRotationNone; + break; + } + iVideoPlayer->SetRotation(iWindow, iRotation); + return 0; + } + +TInt COpMaxPlayerWindow::ResetRotation() + { + iRotation = EVideoRotationNone; + iVideoPlayer->SetRotation(iWindow, iRotation); + return 0; + } + +TInt COpMaxPlayerWindow::NextAutoscaleMode() + { + switch( iAutoScale ) + { + case EAutoScaleNone: + iAutoScale = EAutoScaleBestFit; + break; + case EAutoScaleBestFit: + iAutoScale = EAutoScaleClip; + break; + case EAutoScaleClip: + iAutoScale = EAutoScaleStretch; + break; + case EAutoScaleStretch: + iAutoScale = EAutoScaleNone; + break; + } + iVideoPlayer->SetAutoScale(iWindow, iAutoScale); + return 0; + } + +TInt COpMaxPlayerWindow::ResetAutoscale() + { + iAutoScale = iDefaultAutoScale; + iVideoPlayer->SetAutoScale(iWindow, iAutoScale); + return 0; + } + +void COpMaxPlayerWindow::AppendAutoscaleModeText( TDes& aString ) + { + switch( iAutoScale ) + { + case EAutoScaleNone: + aString.Append(_L("None")); + break; + case EAutoScaleBestFit: + aString.Append(_L("Best Fit")); + break; + case EAutoScaleClip: + aString.Append(_L("Clip")); + break; + case EAutoScaleStretch: + aString.Append(_L("Stretch")); + break; + } + } + +TInt COpMaxPlayerWindow::SetClipRectangle( TRect aRect ) + { + iVideoPlayer->SetWindowClipRect(iWindow, aRect); + return 0; + } + +TInt COpMaxPlayerWindow::SetVideoExtent( TRect aExtent ) + { + iVideoPlayer->SetVideoExtent(iWindow, aExtent); + return 0; + } + +TInt COpMaxPlayerWindow::SetScaleFactor( TReal aWidthScaleFactor, TReal aHeightScaleFactor ) + { + iVideoPlayer->SetScaleFactor(iWindow, aWidthScaleFactor, aHeightScaleFactor); + return 0; + } + +TInt COpMaxPlayerWindow::Play() + { + iVideoPlayer->Play(); + return KErrNone; + } + +TInt COpMaxPlayerWindow::Pause() + { + iVideoPlayer->Pause(); + return 0; + } + +TInt COpMaxPlayerWindow::Stop() + { + return iVideoPlayer->Stop(); + } + +TInt COpMaxPlayerWindow::SetPosition( TTimeIntervalMicroSeconds aPositionInMs ) + { + iVideoPlayer->SetPosition( aPositionInMs ); + return 0; + } + +TInt COpMaxPlayerWindow::StepForward() + { + iVideoPlayer->StepFrame(1); + return 0; + } + +TInt COpMaxPlayerWindow::StepBackward() + { + iVideoPlayer->StepFrame(-1); + return 0; + } + +TInt COpMaxPlayerWindow::SetPlayVelocity( TInt aVelocity ) + { + TRAPD( err, iVideoPlayer->SetPlayVelocity(aVelocity) ); + return err; + } + +// inherited from MVideoPlayerUtilityObserver +void COpMaxPlayerWindow::MvpuoOpenComplete(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoOpenComplete(%i)", aError ); + + if( aError == KErrNone ) + { + iVideoPlayer->Prepare(); + + // Now wait for MvpuoPrepareComplete callback. + } + else + { + Error( aError ); + } + } + +void COpMaxPlayerWindow::MvpuoPrepareComplete(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoPrepareComplete(%i)", aError ); + + if( aError == KErrNone ) + { + iVideoPlayer->AddDisplayWindow( iWs, iScreenDevice, iWindow ); + Play(); + ResetAutoscale(); + PlayInitiated(); + } + else + { + Error( aError ); + } + } + +void COpMaxPlayerWindow::MvpuoFrameReady(CFbsBitmap& /*aFrame*/,TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoFrameReady(%i)", aError ); + + if( aError != KErrNone ) + { + Error( aError ); + } + } + +void COpMaxPlayerWindow::MvpuoPlayComplete(TInt aError) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoPlayComplete(%i)", aError ); + + if( aError == KErrNone ) + { + PlayComplete(); + } + else + { + Error( aError ); + } + } + +void COpMaxPlayerWindow::MvpuoEvent(const TMMFEvent& aEvent) + { + RDebug::Printf( "CONSOLEPLAYER MvpuoEvent event=%x error=%i", aEvent.iEventType.iUid, aEvent.iErrorCode ); + + if( aEvent.iErrorCode != KErrNone ) + { + Error( aEvent.iErrorCode ); + } + } diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/openmax_al/opmaxplayerwindow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/openmax_al/opmaxplayerwindow.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,85 @@ +#ifndef __OPMAX_PLAYER_WINDOW_H__ +#define __OPMAX_PLAYER_WINDOW_H__ + +#include +#ifdef __USE_VIDEOPLAYER_1__ +#include +#else +#include +#endif +#include "playerwindow.h" +#include "openmaxplayerutility.h" + +class COpMaxPlayerWindow : public CPlayerWindow + , private MVideoPlayerUtilityObserver + { +public: + + static COpMaxPlayerWindow* NewL( RFs& aFs, + RWsSession& aWs, + CWsScreenDevice& aScreenDevice, + const RWindowTreeNode &aParentWindow, + TPoint aTopRight, + TSize aSize, + bool aTransparent, + TRgb aBackgroundColor, + bool aSuppressGraphicsContext); + + virtual ~COpMaxPlayerWindow(); + + // inherited from CPlayerWindow + virtual TTimeIntervalMicroSeconds Position(); + virtual TInt SetVolume( TInt aVolume ); + virtual TInt SetBalance( TInt aBalance ); + virtual TInt RotationAngle(); + virtual TInt NextRotationAngle(); + virtual TInt ResetRotation(); + virtual TInt NextAutoscaleMode(); + virtual TInt ResetAutoscale(); + virtual void AppendAutoscaleModeText( TDes& aString ); + virtual TInt SetClipRectangle( TRect aRect ); + virtual TInt SetVideoExtent( TRect aExtent ); + virtual TInt SetScaleFactor( TReal aWidthScaleFactor, TReal aHeightScaleFactor ); + virtual TInt Play(); + virtual TInt Pause(); + virtual TInt Stop(); + virtual TInt SetPosition( TTimeIntervalMicroSeconds aPositionInMs ); + virtual TInt StepForward(); + virtual TInt StepBackward(); + virtual TInt SetPlayVelocity( TInt aVelocity ); + virtual TInt DoExecuteOperation( TInt aOperation ); + virtual void InitializeParameters( TSize& aVideoSize, + TTimeIntervalMicroSeconds& aDuration, + TInt& aMaxVolume, + TInt& aCurrentVolume, + TInt& aBalanceCenter, + TInt& aBalanceMaxLeft, + TInt& aBalanceMaxRight, + TInt& aDefaultBalance, + TInt& aCurrentBalance ); + virtual void SetDefaultAutoscaleMode( TAutoscaleMode aDefaultAutoscale ); + virtual void PreparePlayerWithFile( RFile& aFile ); + virtual void PreparePlayerWithUrl( const TDesC& aUrl ); + + +private: + + COpMaxPlayerWindow( RFs& aFs, RWsSession& aWs, CWsScreenDevice& aScreenDevice, bool aSuppressGraphicsContext ); + + void ConstructL( const RWindowTreeNode &aParentWindow, TPoint aTopRight, TSize aSize, bool aTransparent, TRgb aBackgroundColor ); + + // inherited from MVideoPlayerUtilityObserver + virtual void MvpuoOpenComplete(TInt aError); + virtual void MvpuoPrepareComplete(TInt aError); + virtual void MvpuoFrameReady(CFbsBitmap& aFrame,TInt aError); + virtual void MvpuoPlayComplete(TInt aError); + virtual void MvpuoEvent(const TMMFEvent& aEvent); + + COpenMaxPlayerUtility* iVideoPlayer; + TVideoRotation iRotation; + TAutoScaleType iDefaultAutoScale; + TAutoScaleType iAutoScale; + + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/player/src/playerwindow.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/player/src/playerwindow.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,704 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * The source of the common Player Window functionality. + * + */ + +#include "playerwindow.h" +#include "consoleplayer.h" + +const TInt KDefaultScalePercentagesIndex = 5; +const TInt KScalePercentagesCount = 10; +const TReal KScalePercentages[] = {10.0, 25.0, 50.0, 75.0, 100.0, 125.0, 150.0, 175.0, 200.0, 250.0}; + +// this constant must be consistent with the Rectangle function +const TInt KRectangleModeCount = 5; + +const TInt KMoveWindowDelta = 8; + + +CPlayerWindow::CPlayerWindow( RFs& aFs, RWsSession& aWs, CWsScreenDevice& aScreenDevice, bool aSuppressGraphicsContext ) : + iFs( aFs ), + iWs( aWs ), + iScreenDevice( aScreenDevice ), + iWindow( aWs ), + iSuppressGraphicsContext( aSuppressGraphicsContext ), + iCurrentVelocity( 100 ), + iWidthScaleIndex( KDefaultScalePercentagesIndex ), + iHeightScaleIndex( KDefaultScalePercentagesIndex ) + { + } + +void CPlayerWindow::BaseConstructL( const RWindowTreeNode &aParentWindow, TPoint aTopLeft, TSize aSize, bool aTransparent, TRgb aBackgroundColor ) + { + // A graphics context should not be used with performance mode. + if( !iSuppressGraphicsContext ) + { + User::LeaveIfError( iScreenDevice.CreateContext(iGc) ); + } + + User::LeaveIfError( iWindow.Construct( aParentWindow, KNullWsHandle ) ); + + iWindowTopLeft = aTopLeft; + iDefaultWindowSize = aSize; + iWindowSize = aSize; + iWindowSizeDivisor = 1; + + iWindow.SetExtent( aTopLeft, aSize ); + if( aTransparent ) + { + iWindow.SetTransparencyAlphaChannel(); + } + else + { + iWindow.SetNonTransparent(); + } + iWindow.SetBackgroundColor(aBackgroundColor); + iWindow.SetVisible(false); + iWindow.Activate(); + + // enable drag events + iWindow.PointerFilter(EPointerFilterDrag, 0); + } + +CPlayerWindow::~CPlayerWindow() + { + delete iGc; + iFile.Close(); + } + +void CPlayerWindow::StartWithFilenameL( const TDesC& aFullFilename, + TAutoscaleMode aDefaultAutoscale, + MPlayerWindowObserver* aObserver ) + { + iFullFilename.Copy( aFullFilename ); + iObserver = aObserver; + + SetDefaultAutoscaleMode( aDefaultAutoscale ); + + User::LeaveIfError( iFile.Open( iFs, iFullFilename, EFileShareReadersOnly | EFileStream | EFileRead ) ); + + iFile.Name( iFilename ); + + PreparePlayerWithFile( iFile ); + + // Now wait for subclass to call PrepareComplete. + } + +void CPlayerWindow::StartWithUrlL( const TDesC& aUrl, + TAutoscaleMode aDefaultAutoscale, + MPlayerWindowObserver* aObserver ) + { + iUrl.Copy( aUrl ); + iObserver = aObserver; + + SetDefaultAutoscaleMode( aDefaultAutoscale ); + + PreparePlayerWithUrl( aUrl ); + + // Now wait for subclass to call PrepareComplete. + } + +RWindow& CPlayerWindow::Window() + { + return iWindow; + } + +const TDesC& CPlayerWindow::FullFilename() + { + return iFullFilename; + } + +const TDesC& CPlayerWindow::Filename() + { + return iFilename; + } + +const TDesC& CPlayerWindow::Url() + { + return iUrl; + } + +void CPlayerWindow::PlayInitiated() + { + InitializeParameters( iVideoSize, + iDuration, + iMaxVolume, + iCurrentVolume, + iBalanceCenter, + iBalanceMaxLeft, + iBalanceMaxRight, + iDefaultBalance, + iCurrentBalance ); + + iDurationInMs = iDuration.Int64() / 1000; + + if( iBorderColor != 0 ) + { + DrawBorderAroundWindow(); + } + + iWindow.SetVisible(true); + + iPlayState = EPlaying; + + if( iObserver ) + { + iObserver->PlayInitiated(); + } + } + +void CPlayerWindow::PlayComplete() + { + iPlayState = EStopped; + + if( iObserver ) + { + iObserver->PlayStateChanged(); + } + } + +void CPlayerWindow::Error( TInt aError, const char* pDescription ) + { + if( pDescription != NULL ) + { + RDebug::Printf( "CONSOLEPLAYER ERROR %i %s", pDescription ); + } + + if( iObserver ) + { + iObserver->Error( aError ); + } + } + +void CPlayerWindow::CheckError( TInt aError, const char* pDescription ) + { + if( aError != KErrNone ) + { + Error( aError, pDescription ); + } + } + +CPlayerWindow::TPlayState CPlayerWindow::PlayState() + { + return iPlayState; + } + +TInt CPlayerWindow::PositionInMs() + { + return Position().Int64() / 1000; + } + +TInt CPlayerWindow::DurationInMs() + { + return iDurationInMs;; + } + +TSize CPlayerWindow::VideoSize() + { + return iVideoSize; + } + +TInt CPlayerWindow::Seek( TTimeIntervalMicroSeconds position ) + { + RDebug::Printf( "CONSOLEPLAYER Seek %lu", position.Int64() ); + + if( position < 0 ) + { + position = 0; + } + else if( position > iDuration ) + { + position = iDuration; + } + + TInt err = Pause(); + + if( err == KErrNone ) + { + err = SetPosition( position.Int64() ); + } + + if( (err == KErrNone) && (iPlayState == EPlaying) ) + { + err = Play(); + } + + return err; + } + +TInt CPlayerWindow::UpdateScaleFactor() + { + return SetScaleFactor(KScalePercentages[iWidthScaleIndex], KScalePercentages[iHeightScaleIndex]); + } + +TInt CPlayerWindow::ResetToDefaults() + { + iWidthScaleIndex = KDefaultScalePercentagesIndex; + iHeightScaleIndex = KDefaultScalePercentagesIndex; + iExtentModeIndex = 0; + iClipModeIndex = 0; + iCurrentVelocity = 100; + iCurrentVolume = iDefaultVolume; + iCurrentBalance = iDefaultBalance; + iWindowSize = iDefaultWindowSize; + iWindowSizeDivisor = 1; + ResetAutoscale(); + ResetRotation(); + UpdateScaleFactor(); + SetClipRectangle(Rectangle(iClipModeIndex)); + SetVideoExtent(Rectangle(iExtentModeIndex)); + SetPlayVelocity(iCurrentVelocity); + SetVolume(iCurrentVolume); + SetBalance(iCurrentBalance); + return KErrNone; + } + +// Iterates through a standard set of rectangles for the clipping and extent. +TRect CPlayerWindow::Rectangle( TInt aModeIndex ) + { + TRect rectangle; + + TSize windowSize = iWindow.Size(); + + switch( aModeIndex ) + { + case 0: + // Full window. + rectangle = TRect(windowSize); ; + break; + case 1: + // 100x100 square in center of window. + rectangle = TRect( windowSize.iWidth/2 - 50, windowSize.iHeight/2 - 50, + windowSize.iWidth/2 + 50, windowSize.iHeight/2 + 50 ); + break; + case 2: + // Top half of window. + rectangle = TRect( 0, 0, windowSize.iWidth, windowSize.iHeight/2 ); + break; + case 3: + // Left half of window. + rectangle = TRect( 0, 0, windowSize.iWidth/2, windowSize.iHeight ); + break; + case 4: + // Top-Left quarter of window. + rectangle = TRect( 0, 0, windowSize.iWidth/2, windowSize.iHeight/2 ); + break; + } + + return rectangle; + } + +// Checks to make sure that the second video window is within the limits of the display. +void CPlayerWindow::CheckWindowLimits() + { + if( iWindowTopLeft.iX < 0 ) + { + iWindowTopLeft.iX = 0; + } + else if( iWindowTopLeft.iX + iWindowSize.iWidth > iScreenDevice.SizeInPixels().iWidth ) + { + iWindowTopLeft.iX = iScreenDevice.SizeInPixels().iWidth - iWindowSize.iWidth; + } + + if( iWindowTopLeft.iY < 0 ) + { + iWindowTopLeft.iY = 0; + } + else if( iWindowTopLeft.iY + iWindowSize.iHeight > iScreenDevice.SizeInPixels().iHeight ) + { + iWindowTopLeft.iY = iScreenDevice.SizeInPixels().iHeight - iWindowSize.iHeight; + } + } + +TInt CPlayerWindow::ExecuteOperation( TInt aOperation ) + { + TInt err = KErrNone; + + switch( aOperation ) + { + case EOperation_StopPlay: + { + if( iPlayState == EStopped ) + { + err = Play(); + iPlayState = EPlaying; + } + else + { + err = Stop(); + iPlayState = EStopped; + } + break; + } + case EOperation_PauseResume: + { + if( iPlayState == EPaused ) + { + err = Play(); + iPlayState = EPlaying; + } + else if( iPlayState == EPlaying ) + { + err = Pause(); + iPlayState = EPaused; + } + break; + } + case EOperation_Pause: + { + if( iPlayState == EPlaying ) + { + err = Pause(); + iPlayState = EPaused; + } + break; + } + case EOperation_Resume: + { + if( iPlayState == EPaused ) + { + err = Play(); + iPlayState = EPlaying; + } + break; + } + case EOperation_SeekBack: + { + // Reverse seek 5 seconds + TInt64 pos = Position().Int64(); + pos -= 5000000; + err = Seek( pos ); + break; + } + case EOperation_SeekForward: + { + // Forward 5 seconds + TInt64 pos = Position().Int64(); + pos += 5000000; + err = Seek( pos ); + break; + } + case EOperation_SeekStart: + { + err = Seek( 0 ); + break; + } + case EOperation_SeekEnd: + { + // Seek to 5 seconds before the end of the clip. + TInt64 pos = iDuration.Int64() - 5000000; + err = Seek( pos ); + break; + } + case EOperation_FrameStepForward: + { + err = StepForward(); + break; + } + case EOperation_FrameStepBackward: + { + err = StepBackward(); + break; + } + case EOperation_IncreasePlayVelocity: + { + iCurrentVelocity += 50; + err = SetPlayVelocity( iCurrentVelocity ); + break; + } + case EOperation_DecreasePlayVelocity: + { + iCurrentVelocity -= 50; + err = SetPlayVelocity( iCurrentVelocity ); + break; + } + case EOperation_IncreaseHeightScale: + { + if( iHeightScaleIndex < KScalePercentagesCount ) + { + iHeightScaleIndex++; + } + err = UpdateScaleFactor(); + break; + } + case EOperation_DecreaseHeightScale: + { + if( iHeightScaleIndex > 0 ) + { + iHeightScaleIndex--; + } + err = UpdateScaleFactor(); + break; + } + case EOperation_IncreaseWidthScale: + { + if( iWidthScaleIndex < KScalePercentagesCount ) + { + iWidthScaleIndex++; + } + err = UpdateScaleFactor(); + break; + } + case EOperation_DecreaseWidthScale: + { + if( iWidthScaleIndex > 0 ) + { + iWidthScaleIndex--; + } + err = UpdateScaleFactor(); + break; + } + case EOperation_Rotate: + { + err = NextRotationAngle(); + break; + } + case EOperation_Autoscale: + { + err = NextAutoscaleMode(); + break; + } + case EOperation_ClipRectangle: + { + iClipModeIndex = (iClipModeIndex+1) % KRectangleModeCount; + err = SetClipRectangle(Rectangle( iClipModeIndex )); + break; + } + case EOperation_Extent: + { + // Advance to next extent mode. + iExtentModeIndex = (iExtentModeIndex+1) % KRectangleModeCount; + err = SetVideoExtent(Rectangle( iExtentModeIndex )); + break; + } + case EOperation_ResetToDefaults: + { + err = ResetToDefaults(); + break; + } + case EOperation_IncreaseVolume: + { + err = SetVolume( iCurrentVolume + iMaxVolume / 10 ); + break; + } + case EOperation_DecreaseVolume: + { + err = SetVolume( iCurrentVolume - iMaxVolume / 10 ); + break; + } + case EOperation_MaximumVolume: + { + err = SetVolume( iMaxVolume ); + break; + } + case EOperation_Mute: + { + err = SetVolume( 0 ); + break; + } + case EOperation_BalanceLeft: + { + err = SetBalance( iCurrentBalance - 10 ); + break; + } + case EOperation_BalanceRight: + { + err = SetBalance( iCurrentBalance + 10 ); + break; + } + case EOperation_BalanceCenter: + { + err = SetBalance( iBalanceCenter ); + break; + } + case EOperation_BalanceMaxLeft: + { + err = SetBalance( iBalanceMaxLeft ); + break; + } + case EOperation_BalanceMaxRight: + { + err = SetBalance( iBalanceMaxRight ); + break; + } + case EOperation_MoveWindowUp: + { + iWindowTopLeft.iY -= KMoveWindowDelta; + CheckWindowLimits(); + iWindow.SetExtent( iWindowTopLeft, iWindowSize ); + break; + } + case EOperation_MoveWindowDown: + { + iWindowTopLeft.iY += KMoveWindowDelta; + CheckWindowLimits(); + iWindow.SetExtent( iWindowTopLeft, iWindowSize ); + break; + } + case EOperation_MoveWindowLeft: + { + iWindowTopLeft.iX -= KMoveWindowDelta; + CheckWindowLimits(); + iWindow.SetExtent( iWindowTopLeft, iWindowSize ); + break; + } + case EOperation_MoveWindowRight: + { + iWindowTopLeft.iX += KMoveWindowDelta; + CheckWindowLimits(); + iWindow.SetExtent( iWindowTopLeft, iWindowSize ); + break; + } + case EOperation_ChangeWindowSize: + { + iWindowSizeDivisor = (iWindowSizeDivisor % 5) + 1; + + iWindowSize = TSize(iDefaultWindowSize.iWidth/iWindowSizeDivisor, + iDefaultWindowSize.iHeight/iWindowSizeDivisor); + CheckWindowLimits(); + iWindow.SetExtent( iWindowTopLeft, iWindowSize); + SetVideoExtent( TRect(iWindowSize) ); + + if( iBorderColor != 0 ) + { + DrawBorderAroundWindow(); + } + break; + } + case EOperation_ToggleWindowTransparency: + { + // Black is completely transparent, and white is completely opaque. + iWindowTransparent = !iWindowTransparent; + iWindow.SetTransparencyFactor( KRgbGray ); + iWindow.SetSurfaceTransparency( iWindowTransparent ); + break; + } + case EOperation_DrawWhiteBorderAroundWindow: + { + iBorderColor = 0xfefefe; + DrawBorderAroundWindow(); + break; + } + case EOperation_DrawRedBorderAroundWindow: + { + iBorderColor = KRgbRed; + DrawBorderAroundWindow(); + break; + } + case EOperation_ClearBorderAroundWindow: + { + iBorderColor = 0; + if( iGc ) + { + iGc->Activate(iWindow); + iWindow.Invalidate(); + iWindow.BeginRedraw(); + iGc->Reset(); + iWindow.EndRedraw(); + iGc->Deactivate(); + } + break; + } + default: + { + // Give operation to subclass to execute. + err = DoExecuteOperation( aOperation ); + break; + } + } + + return err; + } + +void CPlayerWindow::DrawBorderAroundWindow() + { + if( iGc ) + { + iGc->Activate(iWindow); + + iWindow.Invalidate(); + iWindow.BeginRedraw(); + + iGc->Reset(); + + iGc->SetPenColor(iBorderColor); + iGc->SetPenStyle(CWindowGc::ESolidPen); + iGc->DrawRect( TRect(iWindow.Size()) ); + + iWindow.EndRedraw(); + + iGc->Deactivate(); + } + } + + +void CPlayerWindow::WriteAdvancedText( CWindowGc& aGc, TInt aColumn, TInt& aRow, TInt aRowIncrement ) + { + TRect rect = Rectangle( iExtentModeIndex ); + iBuffer.Format( _L("Extent: (%i,%i) (%i,%i)"), rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + rect = Rectangle( iClipModeIndex ); + iBuffer.Format( _L("Clip: (%i,%i) (%i,%i)"), rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + iBuffer.Copy( _L("Autoscale: ") ); + AppendAutoscaleModeText( iBuffer ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + aGc.DrawText( _L("Scale factor:"), TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + iBuffer.Format( _L("width=%.1f"), KScalePercentages[iWidthScaleIndex] ); + aGc.DrawText( iBuffer, TPoint(aColumn+25, aRow) ); + aRow += aRowIncrement; + + iBuffer.Format( _L("height=%.1f"), KScalePercentages[iHeightScaleIndex] ); + aGc.DrawText( iBuffer, TPoint(aColumn+25, aRow) ); + aRow += aRowIncrement; + + iBuffer.Format( _L("Rotation: %i"), RotationAngle() ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + iBuffer.Format( _L("Velocity: %i"), iCurrentVelocity ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + iBuffer.Format( _L("Volume: %i/%i"), iCurrentVolume, iMaxVolume ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + + iBuffer.Format( _L("Balance: %i"), iCurrentBalance ); + aGc.DrawText( iBuffer, TPoint(aColumn, aRow) ); + aRow += aRowIncrement; + } + +void CPlayerWindow::MoveWindow( TPoint aCenter ) + { + iWindowTopLeft.iX = aCenter.iX - iWindowSize.iWidth / 2; + iWindowTopLeft.iY = aCenter.iY- iWindowSize.iHeight / 2;; + CheckWindowLimits(); + iWindow.SetExtent( iWindowTopLeft, iWindowSize ); + } + +void CPlayerWindow::SetOrdinalPosition( TInt aPosition ) + { + iWindow.SetOrdinalPosition( aPosition ); + } diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/group/bld.inf Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * This file provides the information required for building the + * Thumbnail Tester test app. + * + */ + +PRJ_MMPFILES + +thumbnailtester.mmp diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/group/create_sis.bat --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/group/create_sis.bat Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,22 @@ +cls +@echo off +echo. + +rem Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +rem All rights reserved. +rem This component and the accompanying materials are made available +rem under the terms of the "Eclipse Public License v1.0" +rem which accompanies this distribution, and is available +rem at the URL "http://www.eclipse.org/legal/epl-v10.html". +rem +rem Initial Contributors: +rem Nokia Corporation - initial contribution. +rem +rem Contributors: +rem +echo Description: Thumbnail Tester package creation utility +rem + +del consoleplayer.sis* +makesis thumbnailtester.pkg thumbnailtester.sis +signsis thumbnailtester.sis thumbnailtester.sisx rd.crt rd.key diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/group/thumbnailtester.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/group/thumbnailtester.mmp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * This file provides the information required for building the + * Thumbnail Tester test app. + */ + +#include + +TARGET thumbnailtester.exe +TARGETTYPE exe +UID 0x0 0xE9081726 +VENDORID VID_DEFAULT + +CAPABILITY ALL -TCB + +EPOCSTACKSIZE 0x5000 //20KB +EPOCHEAPSIZE 0x100000 0x1000000 //1MB-16MB + +START RESOURCE thumbnailtester_reg.rss +TARGETPATH \private\10003a3f\apps +END + +USERINCLUDE ..\..\common + +SOURCEPATH ..\..\common +SOURCE testappbase.cpp + +SOURCEPATH ..\src +SOURCE thumbnailtester.cpp +SOURCE yuv2rgb24.cpp + +MW_LAYER_SYSTEMINCLUDE +SYSTEMINCLUDE \epoc32\include +SYSTEMINCLUDE \epoc32\include\stdapis +USERINCLUDE \sf\mw\helix\helix_ren\src\datatype\tools\metadataeng\common\pub +USERINCLUDE \sf\mw\helix\helix_ren\src\datatype\tools\metadataeng\utility\platform\symbian + +STATICLIBRARY hxmetadatautil.lib +LIBRARY flogger.lib + +LIBRARY euser.lib +LIBRARY efsrv.lib +LIBRARY gce.lib +LIBRARY ws32.lib +LIBRARY gdi.lib +LIBRARY fntstr.lib +LIBRARY fbscli.lib +LIBRARY estor.lib +LIBRARY ecom.lib + +// for volume key handling +LIBRARY remconcoreapi.lib +LIBRARY remconinterfacebase.lib diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/group/thumbnailtester.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/group/thumbnailtester.pkg Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,35 @@ +; +; Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +; All rights reserved. +; This component and the accompanying materials are made available +; under the terms of "Eclipse Public License v1.0" +; which accompanies this distribution, and is available +; at the URL "http://www.eclipse.org/legal/epl-v10.html". +; +; Initial Contributors: +; Nokia Corporation - initial contribution. +; +; Contributors: +; +; Description: Thumbnail Tester - UREL build +; +; File: thumbnailtester.pkg + +;Languages +&EN + +;Header +#{"thumbnailtester EXE"},(0xE9081726),1,0,0 + +;Series 60 v5.0 +[0x1028315F], 0,0,0, {"Series60ProductID"} + +;Localised Vendor name +%{"Nokia"} + +;Unique Vendor name +:"Nokia" + +;Files To Copy... +"/epoc32/release/armv5/urel/thumbnailtester.exe" -"!:/sys/bin/thumbnailtester.exe" +"/epoc32/data/z/private/10003a3f/apps/thumbnailtester_reg.rsc" -"!:/private/10003a3f/import/apps/thumbnailtester_reg.rsc" diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/group/thumbnailtester_reg.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/group/thumbnailtester_reg.rss Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Resource file for registering the Thumbnail Tester to the Application + * Menu. + * + */ + +#include + +UID2 KUidAppRegistrationResourceFile +UID3 0xE9081726 + +RESOURCE APP_REGISTRATION_INFO +{ + app_file="thumbnailtester"; +} diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/src/brightnesscontrast.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/src/brightnesscontrast.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,64 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Const parameters for brightness/constrast enhancement +* The tuning has 9 steps, each represented by 3 parameters. +* The smaller indices in the table generate "lighter" pictures. +* +*/ + + + +#ifndef __BRIGHTNESSCONTRAST_H__ +#define __BRIGHTNESSCONTRAST_H__ + + +const TInt KMinBrightnessContrastIndex = 0; +const TInt KMedBrightnessContrastIndex = 10; +const TInt KMaxBrightnessContrastIndex = 20; + +const TInt KMaxBCInputIndex = 100; + +struct SEnhParam { + TReal a; + TReal b; + TReal g; +}; + +const struct SEnhParam KBrightnessContrastEnhParam[21] = { + {2.35, -0.1215, 0.5}, + {2.17, -0.0936, 0.55}, + {2, -0.07, 0.6}, + {1.84, -0.0504, 0.65}, + {1.69, -0.0345, 0.7}, + {1.55, -0.022, 0.75}, + {1.42, -0.0126, 0.8}, + {1.3, -0.006, 0.85}, + {1.19, -0.0019, 0.9}, + {1.09, 0, 0.95}, + {1, 0, 1}, + {1.04, -0.04, 1.05}, + {1.09, -0.0891, 1.1}, + {1.15, -0.147, 1.15}, + {1.22, -0.2134, 1.2}, + {1.3, -0.288, 1.25}, + {1.39, -0.3705, 1.3}, + {1.49, -0.4606, 1.35}, + {1.6, -0.558, 1.4}, + {1.72, -0.6624, 1.45}, + {1.85, -0.7735, 1.5} +}; + +#endif // __BRIGHTNESSCONTRAST_H__ + +// End of File diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/src/thumbnailtester.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/src/thumbnailtester.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,488 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * Source file for the main class of the Thumbnail Tester test app. + * + */ + +#include "thumbnailtester.h" +#include "yuv2rgb24.h" + +#include +#include +#include + +const TInt KFontSize = 15; + +// Thumbnail tester implementation + +void CThumbnailTester::ExecuteL() + { + CThumbnailTester* self = new(ELeave) CThumbnailTester; + CleanupStack::PushL( self ); + self->InitL(); + self->Main(); + CleanupStack::PopAndDestroy( self ); + } + +CThumbnailTester::CThumbnailTester() : + CTestAppBase( KFontSize ) + { + } + +CThumbnailTester::~CThumbnailTester() + { + Cancel(); + + if( iGc && iFullScreenWindow ) + { + iGc->Activate(*iFullScreenWindow); + + iFullScreenWindow->Invalidate(); + iFullScreenWindow->BeginRedraw(); + + iGc->Reset(); + + iGc->UseFont(iFont); + iGc->SetBrushColor(KRgbDarkBlue); + + iGc->Clear(); + + if( iFinalResult == KErrNone ) + { + // KRgbWhite seems to be having problems (0xffffff) in some emulators, + // but 0xfefefe is working, so use that instead of white. + iGc->SetPenColor(0xfefefe); + } + else + { + iGc->SetPenColor(KRgbRed); + } + + iBuffer.Format( _L("THUMBNAILTESTER EXIT, result = %i"), iFinalResult ); + iGc->DrawText( iBuffer, TPoint(5, 20) ); + + iFullScreenWindow->EndRedraw(); + + iGc->Deactivate(); + + iFullScreenWindow->SetVisible( ETrue ); + + WaitForAnyKey(); + } + + } + +void CThumbnailTester::InitL() + { + BaseConstructL( NULL, 0 ); // this app doesn't use the option pages concept + + iFullScreenWindow = new(ELeave) RWindow( iWs ); + User::LeaveIfError( iFullScreenWindow->Construct( *iWindowGroup, KNullWsHandle ) ); + iFullScreenWindow->SetExtent( TPoint(0,0), iDisplaySize ); + iFullScreenWindow->SetNonTransparent(); + iFullScreenWindow->SetBackgroundColor(KRgbBlack); + iFullScreenWindow->SetVisible(false); + iFullScreenWindow->Activate(); + + iGc->Activate(*iFullScreenWindow); + + iFullScreenWindow->BeginRedraw(); + + iGc->Reset(); + iGc->UseFont(iFont); + iGc->SetBrushStyle(CWindowGc::ESolidBrush); + iGc->SetBrushColor(KRgbBlack); + iGc->Clear(); + + iFullScreenWindow->EndRedraw(); + + iGc->Deactivate(); + } + +void CThumbnailTester::Main() + { + TRAPD( err, MainL() ); + + RDebug::Printf( "THUMBNAILTESTER Completed, err=%i", err ); + } + +void CThumbnailTester::MainL() + { + TFileName filename; + + SelectFileWithHistoryL( TPoint(0,0), iDisplaySize, filename, KHistoryFilename, KMaxHistoryEntries ); + + GenerateThumbnailL( filename ); + } + +void CThumbnailTester::GenerateThumbnailL( TDes& aFileName ) + { + SelectIntegerL( TPoint(0,0), iDisplaySize, _L("Select starting position(seconds):"), 0, 9999, iStartPositionInMs ); + + // Convert from seconds to ms. + iStartPositionInMs *= 1000; + + _LIT( KFull, "Full speed" ); + _LIT( KMedium, "100 millisecond delay" ); + _LIT( KSlow, "1 second delay" ); + + RPointerArray speed; + speed.Append( &KFull ); + speed.Append( &KMedium ); + speed.Append( &KSlow ); + + TInt index = SelectFromListL( TPoint(0,0), iDisplaySize, _L("Select speed:"), speed ); + + speed.Reset(); + + switch( index ) + { + case 0: + iDelayBetweenFrames = 0; + break; + case 1: + iDelayBetweenFrames = 100000; // 1/10 second + break; + case 2: + iDelayBetweenFrames = 1000000; // 1 second + break; + } + + RFile file; + User::LeaveIfError( file.Open( iFs, aFileName, EFileShareReadersOnly | EFileStream | EFileRead ) ); + + iThumbnailUtility = CHXThumbnailUtility::NewL(*this); + + bool done = false; + + iStopThumbnailGeneration = false; + + StartMonitoringWindowEvents(); + + TInt originalStartPositionInMs = iStartPositionInMs; + + while( !done ) + { + iThumbnailUtility->OpenFileL( file, iStartPositionInMs ); + + // OpenFileL will block until all bitmaps have been passed to PacketReady. + + // This isn't necessarily exact, but advance the start position by the time represented + // by the number of renderered frames. + iStartPositionInMs = originalStartPositionInMs + (iTotalFramesRendered * 1000) / iFrameRateInSec; + + done = ((iFramesRendered < 5) || iStopThumbnailGeneration); + + iFramesRendered = 0; + } + + Cancel(); + + WaitForAnyKey(); + + delete iThumbnailUtility; + iThumbnailUtility = NULL; + + file.Close(); + } + +bool CThumbnailTester::ConsumeKeyEvent( TInt /*aKeyCode*/ ) + { + // Stop thumbnail generation when a key is pressed. + iStopThumbnailGeneration = true; + iThumbnailUtility->CancelThumb(); + return true; + } + +void CThumbnailTester::ExecuteOperation( TInt aOperation, const TDesC& aOperationText ) + { + } + +void CThumbnailTester::MetaDataReady(TInt aError) + { + RDebug::Printf( "THUMBNAILTESTER MetadataReady(%i)", aError ); + + // Get basic meta data. + + TUint lCount = 0; + TUint i=0; + + iThumbnailUtility->GetMetaDataCount(lCount); + + RDebug::Printf( "THUMBNAILTESTER metadata count=%i", lCount ); + + for (i=0; iGetMetaDataAt(i, id, pDes); + + const char* key = ""; + + for( TInt j = 0; j < sizeof(HXMetaDataKeyTab)/sizeof(HXMetaDataKeys); j++ ) + { + if( id == HXMetaDataKeyTab[j].m_id ) + { + key = HXMetaDataKeyTab[j].m_pHXKey; + } + } + + for( TInt j = 0; j < sizeof(HXStreamMetaDataKeyTab)/sizeof(HXMetaDataKeys); j++ ) + { + if( id == HXStreamMetaDataKeyTab[j].m_id ) + { + key = HXStreamMetaDataKeyTab[j].m_pHXKey; + } + } + + RDebug::Printf( "THUMBNAILTESTER metadata[%i] id=%i key=%s", i, id, key ); + + TInt current = 0; + TBuf8<400> outputLine; + while( current < pDes->Length() ) + { + char c = pDes->Des()[current]; + char c2 = c; + if( c2 < ' ' || c2 > '~' ) + { + c2 = ' '; + } + + outputLine.AppendFormat(_L8("%02x/%c "), c, c2 ); + + current++; + + if( (current % 20 == 0) || current == pDes->Length() ) + { + outputLine.Append( '\0' ); + RDebug::Printf( (char*)outputLine.Ptr() ); + outputLine.SetLength(0); + } + } + + if (id == HXMetaDataKeys::EHXFrameSize && pDes) + { + TPtr pFrameSizePtr = pDes->Des(); + _LIT(KChar_x, "x"); + TInt xLoc = pFrameSizePtr.Find(KChar_x); + if (xLoc != KErrNotFound) + { + TLex lexWidth(pFrameSizePtr.Mid(0, xLoc)); + TLex lexHeight(pFrameSizePtr.Mid(xLoc+1)); + lexWidth.Val(iWidth); // Storing into local iWidth variable + lexHeight.Val(iHeight); // Storing into local iHeight variable + } + } + else if (id == HXMetaDataKeys::EHXDuration && pDes) + { + TLex lexDuration(pDes->Des()); + lexDuration.Val(iDuration); + } + else if (id == HXMetaDataKeys::EHXFramesPerSecond && pDes) + { + TLex lexFramesPerSecond(pDes->Des()); + lexFramesPerSecond.Val(iFrameRateInSec); + } + else if (id == HXMetaDataKeys::EHXClipBitRate && pDes) + { + TLex lexBitRate(pDes->Des()); + lexBitRate.Val(iClipBitRate); + } + else if (id == HXMetaDataKeys::EHXVideoBitRate && pDes) + { + TLex lexBitRate(pDes->Des()); + lexBitRate.Val(iVideoBitRate); + } + else if (id == HXMetaDataKeys::EHXAudioBitRate && pDes) + { + TLex lexBitRate(pDes->Des()); + lexBitRate.Val(iAudioBitRate); + } + + } // end for + + iTotalFrameCount = ( (iDuration+500)/1000 ) * iFrameRateInSec; + + RDebug::Printf( "THUMBNAILTESTER width=%i", iWidth ); + RDebug::Printf( "THUMBNAILTESTER height=%i", iHeight ); + RDebug::Printf( "THUMBNAILTESTER frame rate=%i", iFrameRateInSec ); + RDebug::Printf( "THUMBNAILTESTER duration=%i", iDuration ); + RDebug::Printf( "THUMBNAILTESTER frame count=%i", iTotalFrameCount ); + RDebug::Printf( "THUMBNAILTESTER clip bit rate=%i", iClipBitRate ); + RDebug::Printf( "THUMBNAILTESTER video bit rate=%i", iVideoBitRate ); + RDebug::Printf( "THUMBNAILTESTER audio bit rate=%i", iAudioBitRate ); + } + +void CThumbnailTester::PacketReady(TInt /*aError*/, void *pYuvBuffer, TUint32 /*aYuvBufferSize*/) + { + // TODO: HANDLE aError + + iFramesRendered++; + iTotalFramesRendered++; + + // Convert from YUV420 to RGB24. + + const TInt KBytesPerPixel = 3; // 24-bit rgb takes 3 bytes + + TUint32 rgbBufferSize = iWidth * iHeight * KBytesPerPixel; + TUint8 *pRgbBuffer =(TUint8*) User::AllocL(rgbBufferSize); + + CYuv2Rgb24* yuvConverter = NULL; + TRAPD(err, yuvConverter = new(ELeave) CYuv2Rgb24); + + // TODO: CHECK ERROR + + TRAP(err, yuvConverter->ConstructL(iWidth, iHeight, iWidth, iHeight)) + + // TODO: CHECK ERROR + + TInt scanLineLength = iWidth * KBytesPerPixel; + + TUint8* yBuf = (TUint8*)pYuvBuffer; + TUint8* uBuf = yBuf + iWidth*iHeight; + TUint8* vBuf = uBuf + (iWidth*iHeight)/4; + + yuvConverter->Convert(yBuf, uBuf, vBuf, iWidth, iHeight, pRgbBuffer, scanLineLength); + + delete yuvConverter; + + // Use RGB24 buffer to create CFbsBitmap. + + CFbsBitmap* pBitmap = NULL; + + TRAP(err, pBitmap = new (ELeave) CFbsBitmap); + if( err == KErrNone ) + { + err = pBitmap->Create(TSize(iWidth, iHeight), EColor16M); + + if( err == KErrNone ) + { + // fill image from rgb buffer to input bitmap buffer + TPtr8 linePtr(0,0); + TInt lineLength = pBitmap->ScanLineLength(iWidth, EColor16M); + for(int j=0, i=0; jSetScanLine((TDes8&)linePtr,j); + } + + iGc->Activate(*iSelectionWindow); + + iSelectionWindow->Invalidate(); + iSelectionWindow->BeginRedraw(); + + iGc->Reset(); + + iGc->UseFont(iFont); + iGc->SetBrushColor(KRgbDarkBlue); + + iGc->Clear(); + + // KRgbWhite seems to be having problems (0xffffff) in some emulators, + // but 0xfefefe is working, so use that instead of white. + iGc->SetPenColor(0xfefefe); + + TPoint topLeft( iDisplaySize.iWidth/2 - iWidth/2, + iDisplaySize.iHeight/2 - iHeight/2 ); + iGc->BitBlt( topLeft, pBitmap ); + + const TInt KColumn = 3; + const TInt KRowIncrement = KFontSize + 1; + TInt row = KRowIncrement; + + iBuffer.Format( _L("Frame # %i"), iFramesRendered ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Total frames rendered: %i"), iTotalFramesRendered ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Start time(ms): %i"), iStartPositionInMs ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Display size: %ix%i"), iDisplaySize.iWidth, iDisplaySize.iHeight ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Video size: %ix%i"), iWidth, iHeight ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Total frame count: %i"), iTotalFrameCount ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Duration: %i"), iDuration ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Frame rate: %i"), iFrameRateInSec ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Clip bit rate: %i"), iClipBitRate ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Video bit rate: %i"), iVideoBitRate ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iBuffer.Format( _L("Audio bit rate: %i"), iAudioBitRate ); + iGc->DrawText( iBuffer, TPoint(KColumn, row) ); + row += KRowIncrement; + + iGc->DrawText( _L(""), TPoint(KColumn, iDisplaySize.iHeight-10) ); + + iSelectionWindow->EndRedraw(); + + iGc->Deactivate(); + + iSelectionWindow->SetVisible( ETrue ); + } + + delete pBitmap; + } + + delete pRgbBuffer; + + User::After( iDelayBetweenFrames ); + } + +void CThumbnailTester::EndOfPackets() + { + RDebug::Printf( "THUMBNAILTESTER end of packets" ); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + CActiveScheduler* scheduler = new CActiveScheduler; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if( scheduler != NULL && cleanup != NULL ) + { + CActiveScheduler::Install( scheduler ); + TRAP_IGNORE( CThumbnailTester::ExecuteL() ); + } + delete cleanup; + delete scheduler; + REComSession::FinalClose(); + __UHEAP_MARKEND; + return 0; + } + diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/src/thumbnailtester.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/src/thumbnailtester.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * The header for the main class of the ConsolePlayer test app. + * + */ + +#ifndef __CONSOLE_PLAYER_H__ +#define __CONSOLE_PLAYER_H__ + +#include + +#include "hxtnutil.h" +#include "testappbase.h" + +const TInt KMaxHistoryEntries = 10; +_LIT( KHistoryFilename, "c:\\thumbnail_tester_history.txt" ); + +class CThumbnailTester : public CTestAppBase, + private MHXThumbnailUtilityImplObserver + +{ +public: // Methods + + static void ExecuteL(); + +private: // Methods + + CThumbnailTester(); + + ~CThumbnailTester(); + + void InitL(); + + void Main(); + + void MainL(); + + void GenerateThumbnailL( TDes& aFileName ); + + // inherited from CTestAppBase + virtual bool ConsumeKeyEvent( TInt aKeyCode ); + virtual void ExecuteOperation( TInt aOperation, const TDesC& aOperationText ); + +private: + + // inherited from MHXThumbnailUtilityImplObserver + virtual void MetaDataReady(TInt aError); + virtual void PacketReady(TInt aError, void *pData, TUint32 aDataSize); + virtual void EndOfPackets(); + + TBuf<120> iBuffer; + RWindow* iFullScreenWindow; + CHXThumbnailUtility* iThumbnailUtility; + TInt iFinalResult; + TInt iStartPositionInMs; + TInt iFramesRendered; + TInt iTotalFramesRendered; + TInt iWidth; + TInt iHeight; + TUint iClipBitRate; + TUint iVideoBitRate; + TUint iAudioBitRate; + TUint iFrameRateInSec; + TUint iDuration; + TInt iTotalFrameCount; + TInt iDelayBetweenFrames; + bool iStopThumbnailGeneration; + + }; + +#endif diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/src/yuv2rgb24.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/src/yuv2rgb24.cpp Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,417 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of class CYuv2Rgb24. +* YUV to EColor16M colorspace converter concrete classes +* +*/ + + + + + +// EXTERNAL RESOURCES + + +// Include Files + +#include +#include "yuv2rgb24.h" +#include "brightnesscontrast.h" + + +// MEMBER FUNCTIONS + + +//============================================================================= + +/* +----------------------------------------------------------------------------- + + CYuv2Rgb24 + + CYuv2Rgb24() + + Standard C++ constructor + +----------------------------------------------------------------------------- +*/ + +CYuv2Rgb24::CYuv2Rgb24() +{ + iRgbLookupTable = 0; + iGamma = 65536; + iBrightnessContrast = KMedBrightnessContrastIndex; + +} + + + +/* +----------------------------------------------------------------------------- + + CYuv2Rgb24 + + ~CYuv2Rgb24() + + Standard C++ destructor + +----------------------------------------------------------------------------- +*/ + +CYuv2Rgb24::~CYuv2Rgb24() +{ + User::Free(iRgbLookupTable); +} + + + +/* +----------------------------------------------------------------------------- + + CYuv2Rgb24 + + ConstructL() + + Standard Symbian OS second-phase constructor. Initializes the object. + +----------------------------------------------------------------------------- +*/ + +void CYuv2Rgb24::ConstructL(TUint aWidth, TUint aHeight, TUint aMaxWidth, TUint aMaxHeight) +{ + // Remember the dimensions +// __ASSERT_ALWAYS(((aWidth & 1) == 0) && ((aHeight & 1) == 0), +// User::Leave(KErrArgument)); + iWidth = aWidth; + iHeight = aHeight; + if ( iWidth > aMaxWidth ) { + iCropWidth = (iWidth-aMaxWidth)/2; + iWidth = aMaxWidth; + } + else { + iCropWidth = 0; + } + if ( iHeight > aMaxHeight ) { + iCropHeight = (iHeight-aMaxHeight)/2; + iHeight = aMaxHeight; + } + else { + iCropHeight = 0; + } + + // Allocate the RGB saturate/gamma lookup table + iRgbLookupTable = (TUint8*) User::AllocL(ESaturateLength); + + // Initialize brightness & contrast value, this will calculate the conversion table + // Since this uses the median index, it makes no difference if the preferred + // enhancement is this or gamma. Furthermore, changes to the value will be done using + // the appropriate method. + SetBrightnessContrast(KMaxBCInputIndex/2); +} + + + +/* +----------------------------------------------------------------------------- + + CYuv2Rgb24 + + SetGamma() + + Sets the conversion gamma value and recalculates the look-up table + +----------------------------------------------------------------------------- +*/ + +void CYuv2Rgb24::SetGamma(TInt aGamma) +{ + TInt i, v; + TReal vNorm; + + // Remember gamma and convert it to floating point + iGamma = aGamma; + TReal fGamma = TReal(iGamma) / TReal(65536); + + // Calculate table entries for all possible RGB values: + for ( i = 0; i < ESaturateLength; i++ ) + { + // Actual RGB value for this table index + v = i - ESaturateOffset; + + // Saturate if <0 or >255, otherwise calculate gamma + if ( v < 0 ) + v = 0; + else if ( v > 255 ) + v = 255; + else + { + // Normalize v: + vNorm = TReal(v) / TReal(255); + + // Gamma-correct: v = v ^ gamma + Math::Pow(vNorm, vNorm, fGamma); + + // Scale back to [0..255] and clamp: + vNorm = (TReal(255) * vNorm) + 0.5; + v = (TInt) vNorm; + if ( v < 0 ) v = 0; + if ( v > 255 ) v = 255; + } + + // 24bpp RGB has range [0..255] for all components, store to table: + iRgbLookupTable[i] = (TUint8) v; + } +} + +/* +----------------------------------------------------------------------------- + + CYuv2Rgb24 + + SetBrightnessContrast() + + Sets the index to the predefined brightness&contrast lookup table + (KBrightnessContrastEnhParam) and recalculates the RGB look-up table + The algorithm was developed by IMAAMI for Kenny display. + +----------------------------------------------------------------------------- +*/ +void CYuv2Rgb24::SetBrightnessContrast(TInt aBCIndex) +{ + TInt i, v; + TReal vNorm; + + // Convert & remember brightness-contrast index. aBCIndex == 0 to KMaxBCInputIndex. + iBrightnessContrast = (aBCIndex*KMaxBrightnessContrastIndex)/KMaxBCInputIndex; + + // Calculate table entries for all possible RGB values: + for ( i = 0; i < ESaturateLength; i++ ) + { + // Actual RGB value for this table index + v = 298 * (i - ESaturateOffset - 16) / 256; + // (see Convert()) + + // Saturate if <0 or >255, otherwise calculate value + if ( v < 0 ) + v = 0; + else if ( v > 255 ) + v = 255; + else + { + + // Normalize v: + vNorm = TReal(v) / TReal(255); + + vNorm = KBrightnessContrastEnhParam[iBrightnessContrast].a * vNorm + KBrightnessContrastEnhParam[iBrightnessContrast].b; + if ( vNorm < 0 ) + vNorm = 0; + else if ( vNorm > 1 ) + vNorm = 1; + Math::Pow( vNorm, vNorm, KBrightnessContrastEnhParam[iBrightnessContrast].g ); + + // Scale back to [0..255] and clamp: + vNorm = (TReal(255) * vNorm) + 0.5; + v = (TInt) vNorm; + if ( v < 0 ) v = 0; + if ( v > 255 ) v = 255; + } + + // 24bpp RGB has range [0..255] for all components, store to table: + iRgbLookupTable[i] = (TUint8) v; + } +} + + +/* +----------------------------------------------------------------------------- + + CYuv2Rgb24 + + Convert() + + Converts a YUV frame to a EColor16M frame + +----------------------------------------------------------------------------- +*/ + +void CYuv2Rgb24::Convert(const TUint8 *aYBuf, const TUint8 *aUBuf, + const TUint8 *aVBuf, + TUint aBufWidth, TUint aBufHeight, + TUint8 *aTarget, TUint aTargetScanlineLength) +{ + TUint cols; + TUint rows = iHeight; + TUint8 *target; + TUint8 *target2; + const TUint8 *yb, *yb2; + TInt rc, gc, bc; + TInt y; + TInt uval, vval; + TUint8 val; + + + __ASSERT_ALWAYS((aBufWidth >= iWidth) && (aBufHeight >= iHeight), + User::Invariant()); + + // Cropping needed? + if ( iCropWidth > 0 ) { + //sets offset to buffers; from now on increments below will always result the same offset, since the increment is aBufWidth + aYBuf += iCropWidth; + aUBuf += iCropWidth/2; + aVBuf += iCropWidth/2; + } + if ( iCropHeight > 0 ) { + //skip lines on top + aYBuf += iCropHeight*aBufWidth; + aUBuf += (iCropHeight/2)*aBufWidth/2; + aVBuf += (iCropHeight/2)*aBufWidth/2; + } + // We don't interpolate the chrominance values at all, since that way we + // can save a lot of multiplications. This actually doesn't affect the + // subjective picture quality much, if at all, with natural images. + + // Conversion is done 2x2 pixels at a time + + // Luminance-only conversion? + if ( (aUBuf != NULL) && (aVBuf != NULL) ) + { + // Full conversion + + // Convert all rows, two at a time + while ( rows ) + { + // Convert all pixels in this row, two at a time + cols = iWidth; + target = aTarget; + target2 = aTarget + aTargetScanlineLength; + yb = aYBuf; + yb2 = aYBuf + aBufWidth; + + while ( cols ) + { + // Charles Poynton: Color FAQ + // (http://www.inforamp.net/~poynton/ColorFAQ.html) + // 30. How do I encode Y'CBCR components from computer R'G'B' ? + + // [normalized] + // R = 1.1643828125 * (Y-16) + 1.59602734375 * (Cr-128) + // G = 1.1643828125 * (Y-16) + -0.39178515625 * (Cb-128) + -0.81296875 * (Cr-128) + // B = 1.1643828125 * (Y-16) + 2.01723046875 * (Cb-128) + + // We'll use fixed-point with 16 bits of fractional part for + // accuracy. Besides, 24bpp RGB is not likely to be used in + // low-CPU devices in the near future... + + // Red chrominance part for this 2x2 block: + vval = ((TInt) aVBuf[0]) - 128; + rc = 104597 * vval; + + // Green chrominance: + uval = ((TInt) aUBuf[0]) - 128; + gc = -25676*uval - 53279*vval; + + // Blue chrominance: + bc = 132201 * uval; + + // Upper left pixel y part for all components: + y = 76309 * (((TInt) yb[0]) - 16) + 32768; // round up + + // Calculate components and store: + // Bitmap format: bbbbbbbb gggggggg rrrrrrrr + target[0] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset]; + target[1] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset]; + target[2] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset]; + + // Upper right pixel: + y = 76309 * (((TInt) yb[1]) - 16) + 32768; + target[3] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset]; + target[4] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset]; + target[5] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset]; + + // Lower left: + y = 76309 * (((TInt) yb2[0]) - 16) + 32768; + target2[0] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset]; + target2[1] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset]; + target2[2] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset]; + + // Lower right: + y = 76309 * (((TInt) yb2[1]) - 16) + 32768; + target2[3] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset]; + target2[4] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset]; + target2[5] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset]; + + // Next two pixels: + target += 6; + target2 += 6; + yb += 2; + yb2 += 2; + aUBuf++; + aVBuf++; + cols -= 2; + } + + // Next rows + rows -= 2; + aYBuf += 2*aBufWidth; + aUBuf += (aBufWidth - iWidth)/2; + aVBuf += (aBufWidth - iWidth)/2; + aTarget += 2*aTargetScanlineLength; + } + } + else + { + // No chrominance given, do a luminance-only conversion + + // Convert all rows + while ( rows ) + { + // Convert all pixels in this row, two at a time + cols = iWidth; + target = aTarget; + + while ( cols ) + { + // Do a pixel: + y = 76309 * (((TInt) aYBuf[0]) - 16) + 32768; + val = iRgbLookupTable[(y >> 16) + ESaturateOffset]; + target[0] = val; + target[1] = val; + target[2] = val; + + // And another one: + y = 76309 * (((TInt) aYBuf[1]) - 16) + 32768; + val = iRgbLookupTable[(y >> 16) + ESaturateOffset]; + target[3] = val; + target[4] = val; + target[5] = val; + + // Next two pixels: + target += 6; + aYBuf += 2; + cols -= 2; + } + + // Next row + rows--; + aYBuf += aBufWidth - iWidth; + aTarget += aTargetScanlineLength; + } + } +} + + + + + +// End of File diff -r b818131c88a3 -r e1b6d78dfe6a tsrc/consoleplayer/thumbnail/src/yuv2rgb24.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/consoleplayer/thumbnail/src/yuv2rgb24.h Fri Sep 03 19:37:02 2010 -0500 @@ -0,0 +1,56 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: YUV to EColor16M colorspace converter concrete classes +* +*/ + +#ifndef __YUV2RGB24_H__ +#define __YUV2RGB24_H__ + +// INCLUDES +#include + +// CLASS DEFINITIONS + +// Normal YUV to Rgb24 +class CYuv2Rgb24 : public CBase +{ +public: // CYuvConverter methods + // Constructors & destructor + CYuv2Rgb24(); + ~CYuv2Rgb24(); + void ConstructL(TUint aWidth, TUint aHeight, TUint aMaxWidth, TUint aMaxHeight); + + void SetGamma(TInt aGamma); + void SetBrightnessContrast(TInt aBCIndex); + void Convert(const TUint8 *aYBuf, const TUint8 *aUBuf, + const TUint8 *aVBuf, + TUint aBufWidth, TUint aBufHeight, + TUint8 *aTarget, TUint aTargetScanlineLength); + +protected: // Data + enum + { + ESaturateOffset = 276, // saturation table offset + ESaturateLength = 561+ESaturateOffset // table length + }; + TUint8 *iRgbLookupTable; // RGB clamp/gamma lookup table + TUint iWidth, iHeight, iCropWidth, iCropHeight; + TInt iGamma; + TInt iBrightnessContrast; +}; + +#endif // __YUV2RGB24_H__ + +// End of File