/*
* Copyright (c) 2006-2008 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: Handles serializing of data and sending it to alf streamer server.
*
*/
// Maybe...
// - EAlfCancelClippingRect is many times followed by EAlfSetClippingRect. Could the EAlfCancelClippingRect be ignored?
// - EAlfSetBrushStyle (etc. other non drawing commands) are followed by AlfReset and no drawing is done. Could the Set
// commands be ignored.
// Can ignoring be done faster than executing useless commands?
#include <barsread.h>
#include <barsc.h>
#include <e32std.h>
#include <alfstreamerconsts.h>
#include <huiwscanvascommands.h>
#include <uiacceltk/HuiUtil.h>
#include <alfdecoderserverclient.h>
#include <alflogger.h>
#include "alf/alfcompositionclient.h"
#include "alfrssendbuffer.h"
#include "alfrenderstage.h"
#include "alfcommanddebug.h"
#include <alfnonsupportedwscommands.rsg>
#include <data_caging_path_literals.hrh>
_LIT( KRendererSupportedCommands,"alfnonsupportedwscommands.rsc" );
const TInt KFrameHeaderSizeWhenCacheChunks = 500;
const TInt KFrameHeaderSize = 5000;
const TInt KFrameOffsetTemplate = 12345678;
const TInt KCacheChunkMinSize = 50000;
const TUint8 KDivisibleByX = 8;
const TInt KWindowFrameHeader1 = 6; // bytes
const TInt KWindowFrameHeader2 = 18 + 10; // bytes // TP +10
const TInt KAllRenderersMask = 63;
const TInt KPossiblePerformanceProblemInWindow = 64;
const TInt KPossiblePerformanceProblemInWindowThreshold = 1000;
enum TPatternSearchStates
{
ESeekSetClippingRegion = 0,
ESeekBitBlit = 1,
ESeekResetClipping = 2,
ESeekBrushStyle1 = 3,
ESeekBrushStyle2 = 4
};
#ifdef _OPTIMIZE_WS_COMMANDS_ADVANCED_
const TInt TSearchPatternBitBlit[2][3] = {
// Search command // state // alternative command in this state
{ EAlfSetClippingRegion, ESeekSetClippingRegion, KErrNotFound },
{ EAlfBitBltMasked, ESeekBitBlit, EAlfBitBltRect }};
#else
const TInt TSearchPatternBitBlit[5][3] = {
// Search command // state // alternative command in this state
{ EAlfSetClippingRegion, ESeekSetClippingRegion, KErrNotFound },
{ EAlfBitBltMasked, ESeekBitBlit, EAlfBitBltRect },
{ EAlfResetClippingRegion, ESeekResetClipping, KErrNotFound },
{ EAlfSetBrushStyle, ESeekBrushStyle1, KErrNotFound },
{ EAlfSetBrushStyle, ESeekBrushStyle2, EAlfSetPenStyle} };
#endif
// ---------------------------------------------------------------------------
// class CAlfObserver
// ---------------------------------------------------------------------------
//
NONSHARABLE_CLASS(CAlfObserver):public CActive
{
public:
// ---------------------------------------------------------------------------
// SetL
// ---------------------------------------------------------------------------
//
static void SetL(CAlfRsSendBuffer* aHost, TBool aStartServer )
{
CAlfObserver* me = new (ELeave) CAlfObserver(aHost, aStartServer);
me->SetActive();
// breahe one cycle to allow wserv kick its server object alive
TRequestStatus* status = &me->iStatus;
User::RequestComplete(status, KErrNone);
}
// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CAlfObserver(CAlfRsSendBuffer* aHost, TBool aStartServer):CActive(2*EPriorityHigh),
iHost(aHost), iStartServer(aStartServer), iBreathe(ETrue)
{
CActiveScheduler::Add(this);
iTimer.CreateLocal();
}
// ---------------------------------------------------------------------------
// RunL
// ---------------------------------------------------------------------------
//
void RunL()
{
if (iBreathe && iStartServer)
{
iBreathe = EFalse;
SetActive();
TRAPD(err, AlfServerStarter::StartL(iStatus, EFalse));
if (err)
{
// Important, and thus enabled even in release builds. Other option would be letting leave to fall through
// render stage stack and let window server panic the boot
RDebug::Print(_L("********* Error occurred when starting alf: %d"),err);
}
else
{
return;
}
}
else
{
if( !iHost->ConnectL() ) // if connecting fails, try again a bit later
{
SetActive();
if( iStartServer )
{
iTimer.After( iStatus, 250000); // primary display is more important
}
else
{
iTimer.After( iStatus, 1000000);
}
}
else
{
__ALFLOGSTRING("********************FLUSHING WSERV");
TRAP_IGNORE(iHost->PrepareBufferL());
TRAP_IGNORE(iHost->SendL( NULL ));
iTimer.Close();
delete this;
}
}
}
// ---------------------------------------------------------------------------
// DoCancel
// ---------------------------------------------------------------------------
//
void DoCancel()
{
// not applicable atm
}
private: // Data
CAlfRsSendBuffer* iHost;
TBool iStartServer;
TBool iBreathe;
RTimer iTimer;
};
// ---------------------------------------------------------------------------
// doFlushBuffer
// Local function
// ---------------------------------------------------------------------------
//
TInt doFlushBuffer( TAny* aPtr )
{
((CAlfRsSendBuffer*)aPtr)->FlushBuffer();
return 0; // must return something
}
// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CAlfRsSendBuffer* CAlfRsSendBuffer::NewL(CAlfRenderStage& aParent, TInt aScreenNumber )
{
CAlfRsSendBuffer* self = new(ELeave) CAlfRsSendBuffer( aParent, aScreenNumber );
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CAlfRsSendBuffer::~CAlfRsSendBuffer()
{
if ( iAlfBridgerClient )
{
iAlfBridgerClient->Close();
delete iAlfBridgerClient;
iAlfBridgerClient = NULL;
delete iAlfCompositionCntrlClient;
}
#ifdef _OLD_STREAM
if ( iBufStream )
{
iBufStream->Close();
delete iBufStream;
iBufStream = NULL;
}
#endif
iChunk.Close();
}
// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::ConstructL()
{
// If this is not the primary screen (0) do not send any commands to Alf server
iDisabled = (iScreenNumber != 0);
ReadNonSupportedCommandsL();
iChunkInUse = 0;
iBooting = ETrue;
#ifdef _ALF_PRINT_WS_COMMANDS_
iLog = 0;
iCommandDebugger = CAlfCommandDebug::NewL();
#endif
TBool runInsideWserv = ETrue; // EFalse;
if( runInsideWserv )
{
TBool startServer = ETrue;
if (iScreenNumber != 0) // we need one instance only
{
startServer = EFalse;
}
CAlfObserver::SetL(this, startServer);
}
else
{
CAlfObserver::SetL(this, EFalse);
}
MAlfCompositionController* compcntrl = (MAlfCompositionController*)iParent.ResolveObjectInterface(KAlfCompositionControllerIfUid);
if (compcntrl)
{
compcntrl->AlfBridgeCallback(MAlfBridge::EAlfBridgeCreated, (MAlfBridge*)this);
}
}
// ---------------------------------------------------------------------------
// ReadNonSupportedCommandsL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::ReadNonSupportedCommandsL()
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RResourceFile resFile;
TInt result;
// resolve the absolute path
// Read unsupported command resource
TFileName resourceFileName;
TPtrC driveLetter = TParsePtrC( RProcess().FileName() ).Drive();
resourceFileName.Copy( driveLetter );
resourceFileName.Append( KDC_ECOM_RESOURCE_DIR );
resourceFileName.Append( KRendererSupportedCommands );
TRAP( result, resFile.OpenL(fs,resourceFileName); );
if ( result == KErrNone )
{
CleanupClosePushL(resFile);
resFile.ConfirmSignatureL(0); // offset value.
TInt resId = R_ALF_NON_SUPPORTED_COMMANDS_ARRAY;
HBufC8* readData = resFile.AllocReadL(resId);
// now first get rid of RResourceFile and RFs as they are not needed any more
CleanupStack::PopAndDestroy(); // resFile
CleanupStack::PopAndDestroy(); // fs
CleanupStack::PushL(readData);
// now parse it and store the values in cmdTextArray
TResourceReader reader;
reader.SetBuffer(readData);
const TInt count = reader.ReadInt16();
TInt8 command;
TInt8 value;
TInt nonSupportedParameterCount = 0;
// resource file contains only non supported commands by renderers. Patch them to the iSupportedCommands
TInt supportedParameterIndex = 0;
for ( TInt i = 0; i < count ; i++ )
{
command = reader.ReadInt8();
value = ConvertToBitsL( 7, &reader );
nonSupportedParameterCount = reader.ReadInt16();
if ( nonSupportedParameterCount > 0 )
{
iSupportedCommandParameters[command][0] = supportedParameterIndex;
for ( TInt l = 0 ; l < nonSupportedParameterCount ; l ++ )
{
TInt8 parameterValue = reader.ReadInt8();
iSupportedParameters[supportedParameterIndex][0] = parameterValue;
TInt8 value2 = ConvertToBitsL( 6, &reader );
iSupportedParameters[supportedParameterIndex][1] = value2;
supportedParameterIndex++;
}
iSupportedCommandParameters[command][1] = supportedParameterIndex;
}
iNonSupportedCommands[command] = value;
}
CleanupStack::PopAndDestroy(readData);
}
else
{
__ALFLOGSTRING1("CAlfRsSendBuffer::ConstructL - WARNING! Failed to read unsupported commands from resource file: %S! Error code:st %d.", &resourceFileName );
CleanupStack::PopAndDestroy(); // fs
}
}
// ---------------------------------------------------------------------------
// ConvertToBitsL
// ---------------------------------------------------------------------------
//
TUint8 CAlfRsSendBuffer::ConvertToBitsL( TInt aCount, TResourceReader* aReader )
{
#ifdef _DEBUG
if ( aCount > 7 )
{
__ALFLOGSTRING("CAlfRsSendBuffer::ConvertToBitsL - Can convert only 7 sequantial bytes to one byte");
USER_INVARIANT(); //
}
#endif
TInt8 value = 0;
TInt8 notSupported[7];
aReader->Read( notSupported, aCount );
TUint8 mask = 1;
for (TInt j = 0; j < aCount ; j ++)
{
if ( notSupported[j] ){ value |= mask ; }
mask = mask << 1;
}
return value;
}
// ---------------------------------------------------------------------------
// RunL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::RunL()
{
switch( iState )
{
case EWaitingAck:
{
if ( iStatus == EAlfBridgerAsyncronousData || iStatus < 0 )
{
TInt chunkIndex = 0;
// The following is written to the last created chunk.
TInt cacheChunkCount = iCacheChunks.Count();
if ( cacheChunkCount > 0 )
{
// request destruction of all temporary chunks
while ( chunkIndex < cacheChunkCount )
{
WriteInt8L( EAlfDestroyChunk );
WriteInt8L( 0 ); // screen number, not used.
WriteInt32L( iCacheChunks[chunkIndex].Handle() );
WriteInt8L( EAlfCommandEndMarker );
chunkIndex++;
}
if ( !iBooting )
{
// This is not necessary in the first boot, because jump
// request has been already created in PrepareBufferL
JumpToAnotherChunkL( 0, iPrimaryChunkMaxSize );
OpenPrimaryChunkForWritingL();
SeekL(0); // rewind stream to the beginning
WriteInt8L( EAlfCommandEndMarker );
CommitL();
FlushBuffer();
}
// destroy renderstage side handles to the chunk. alfhierarchy
// has still open handles for a while.
while( iCacheChunks.Count() )
{
iCacheChunks[ 0 ].Close();
iCacheChunks.Remove( 0 );
}
}
iUsedChunkMaxSize = iPrimaryChunkMaxSize - sizeof( TChunkHeader);
iChunkInUse = 0;
iBooting = EFalse; // alf has acknowledged the first frame
iParent.EndCallBack( iQuedStatus );
iState = EIdle;
}
break;
}
case EWaitingHandle:
{
break;
}
case EIdle:
{
break;
}
default:;
}
}
// ---------------------------------------------------------------------------
// DoCancel
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::DoCancel()
{
// TODO
}
// ---------------------------------------------------------------------------
// WriteFlagsL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteFlagsL( )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
// space has been reserved for us
WriteInt8L( EAlfFrameFlags );
WriteInt32L( iFlags);
WriteInt8L( EAlfCommandEndMarker );
}
// ---------------------------------------------------------------------------
// WriteCommandL
// writes 1 TInt value to the stream
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteCommandL( const TUint8& aCommand, TInt aSize )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
if (
#ifdef _OLD_STREAM
iBufStream->Sink() &&
#endif
aCommand == EAlfPacketReady )
{
iReceivingDrawingCommands = EFalse;
// if offscreen content has not been flushed, we'll keep the frame in not completed state.
// it will be delivered to CHuiCanvasVisual, but not processed until finished packet arrives.
// make sure, that frame flags (iFlags) follow this command.
}
if (! InitCommandL( aCommand, aSize)){ return;}
#ifdef _ALF_PRINT_WS_COMMANDS_
if ( !iReceivingDrawingCommands )
{
aSize += sizeof(TUint8);
}
iCommandDebugger->SetDescriptionAndSize( aCommand, aSize, R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->Print();
#endif
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
if ( aCommand == EAlfPacketReady )
{
iReceivingDrawingCommands = EFalse;
iWrappingFrame = EFalse;
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->PrintStatistic();
iCommandDebugger->EndFrame();
#endif
}
}
// ---------------------------------------------------------------------------
// WriteIntsL
// writes aCount amount of variables to the stream and updates stream index.
// ---------------------------------------------------------------------------
//
// @todo Reference to Tint parameter was removed, because it did not pass armv5 compiler
void CAlfRsSendBuffer::WriteIntsL( const TUint8& aCommand, TInt aCount, TRefByValue<const TInt> aFirst,... )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
const TInt size = sizeof(TInt32) * aCount;
if (! InitCommandL( aCommand, size )){ return;}
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->SetDescriptionAndSize( aCommand, size, R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->Print();
#endif
if ( aCount > 0 )
{
aCount--; // first item is serialized separately. It seems to exist at different location as rest of the parameters.
WriteInt32L( aFirst );
WriteL( (TUint8*)&aFirst + sizeof(TInt32), aCount * sizeof(TInt32) );
//TInt size = sizeof(TInt32) * aCount;
//iBufStream->WriteL( (TUint8*)&aFirst + sizeof(TInt32), size ); iOffset += size ;
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
void CAlfRsSendBuffer::WriteIntsL(TUint8 aCommand, TInt aCount, TInt* aArray)
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
const TInt size = sizeof(TInt32) * aCount;
if (!InitCommandL( aCommand, size ))
{
return;
}
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->SetDescriptionAndSize( aCommand, size, R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->Print();
#endif
for(TInt i = 0; i < aCount; i++)
{
WriteInt32L( aArray[i] );
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// WriteIntL
// All possibly non-supported commands that have a parameter are using this version
// of WriteIntL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteIntL( const TUint8& aCommand, TInt aValue )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
TBool supported = EFalse;
if (iNonSupportedCommands[aCommand])
{
for( TInt i = iSupportedCommandParameters[aCommand][0]; i < iSupportedCommandParameters[aCommand][1]; i++ )
{
if ( !supported && aValue == iSupportedParameters[i][0])
{
supported = ETrue;
iNonSupportedCommands[aCommand] = iSupportedParameters[i][1];
}
}
}
else
{
supported = ETrue;
}
if ( !supported )
{
iNonSupportedCommands[aCommand] = KAllRenderersMask;
}
if (! InitCommandL( aCommand, sizeof(TInt32) )){ return;}
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->SetDescriptionAndSize( aCommand, sizeof(TInt32), R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->Print();
#endif
// only commands, that may not be supported use this function
if ( aCommand == EAlfSetPenStyle )
{
iPenStyle = aValue; // for patter search
}
WriteInt32L( aValue);
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// WriteRegionL
// writes aCount amount of variables to the stream and updates stream index.
// ---------------------------------------------------------------------------
//
// @todo Reference to Tint parameter was removed, because it did not pass armv5 compiler
void CAlfRsSendBuffer::WriteRegionL( const TUint8& aCommand, const TRegion& aRegion )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
TInt count = aRegion.Count();
const TInt size = sizeof(TInt32) * ( 4 * count + 1);
if (! InitCommandL( aCommand, size )){ return;}
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->SetDescriptionAndSize( aCommand, size, R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->SetRegion( aRegion );
iCommandDebugger->Print();
#endif
WriteInt32L( count );
TInt i = 0;
while( i < count )
{
WriteL( (TUint8*)&aRegion[i].iTl.iX, 4 * sizeof(TInt32 ));
if ( aCommand == EAlfSetClippingRegion )
{
iSearchPatternClipRegion.AddRect(aRegion[i]);
}
i++;
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// WriteDescriptorAndIntsL
// writes aCount amount of variables to the stream and updates stream index.
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteDescriptorAndIntsL(
const TUint8& aCommand,
const TDesC& aText,
const CGraphicsContext::TTextParameters* aTextParameter,
TInt aCount,
TRefByValue<const TInt> aFirst,... )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
if ( aText.Length() == 0 )
{
return;
}
TBool useCachedText( EFalse );
if ( iCachedText
&& iCachedText->Length() == aText.Length()
&& iCachedText->Compare( aText ) == 0 )
{
useCachedText = ETrue;
}
else
{
delete iCachedText;
iCachedText = aText.AllocL();
}
// calculate size for the command
TInt size = sizeof(TInt32) * ( 2 + aCount ) + // ints
+ 2 * sizeof(TInt8); // existances of: text and TextParameters
if ( !useCachedText )
{
size += aText.Size() + sizeof(TInt32); // text + its length
}
if ( aTextParameter )
{
size += ( 2 * sizeof(TInt32) )+ sizeof(TUint16);
}
if (! InitCommandL( aCommand, size )){ return;}
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->SetDescriptionAndSize( aCommand, size, R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->Print();
#endif
WriteInt8L( useCachedText );
if ( !useCachedText )
{
WriteInt32L( aText.Size() );
TInt offset = iOffset + 2 * sizeof(TUint8);
TInt startPadding = offset % KDivisibleByX;
startPadding = startPadding == 0 ? 0 : KDivisibleByX - startPadding;
WriteInt8L( startPadding );
TInt endPadding = (offset + startPadding + aText.Size() ) % KDivisibleByX;
endPadding = endPadding == 0 ? 0 : KDivisibleByX - endPadding;
WriteInt8L( endPadding );
TUint8 padding[KDivisibleByX];
WriteL( (TUint8*)padding, startPadding );
WriteL( (TUint8*)aText.Ptr(), aText.Size() );
WriteL( (TUint8*)padding, endPadding );
// aTextParameter can be null.
}
if ( aTextParameter )
{
// TODO: Remove commented code, when this is tested.
if ( aTextParameter->iStart == 0
&& aTextParameter->iEnd == aText.Length()
&& aTextParameter->iFlags == 0 )
{
// actually, this never comes so far...
WriteInt8L( 2 ); // Use the default values
}
else
{
WriteInt8L( 1 );
TInt size = 2 * sizeof (TInt) + sizeof (TUint16) ;
WriteL( (TUint8*)&aTextParameter->iStart, size);
}
}
else
{
WriteInt8L( 0 );
}
if ( aCount > 0 )
{
aCount--;
WriteInt32L( aFirst );
TInt size = aCount * sizeof(TInt32);
WriteL( (TUint8*)&aFirst + sizeof(TInt32), size );
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// WritePointArrayL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WritePointArrayL( const TUint8& aCommand, const CArrayFix<TPoint>* aPoWriteIntList )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
TInt count = aPoWriteIntList->Count();
const TInt size = sizeof(TInt32) * (2 * count + 1);
if (! InitCommandL( aCommand, size )){ return;}
TInt index(0);
WriteInt32L( count );
while( index < count )
{
WriteInt32L( aPoWriteIntList->At(index).iX );
WriteInt32L( aPoWriteIntList->At(index).iY );
index++;
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// WritePointArrayL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WritePointArrayL( const TUint8& aCommand, const TPoint* aPoWriteIntList, TInt aNumPoints )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
const TInt size = sizeof(TInt32) * (2 * aNumPoints + 1);
if (! InitCommandL( aCommand, size )){ return;}
TInt index(0);
WriteInt32L( aNumPoints );
while( index < aNumPoints )
{
WriteInt32L( aPoWriteIntList[index].iX );
WriteInt32L( aPoWriteIntList[index].iY );
index++;
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// WritePointArrayL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WritePointArrayL( const TUint8& aCommand, const TArray<TPoint>* aPoWriteIntList )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
const TInt size = sizeof(TInt32) * (2 * aPoWriteIntList->Count() + 1);
if (! InitCommandL( aCommand, size )){ return;}
TInt index(0);
TInt count = aPoWriteIntList->Count();
WriteInt32L( count );
TArray<TPoint> list = *aPoWriteIntList;
while( index < count )
{
const TPoint& point = list[index];
WriteInt32L( point.iX );
WriteInt32L( point.iY );
index++;
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
// ---------------------------------------------------------------------------
// Synchronize
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::Synchronize(TInt aId)
{
if ( iAlfBridgerClient )
{
TIpcArgs args(aId);
iAlfBridgerClient->SendSynch(EAlfSynchronize, args); // error ignored
}
}
// ---------------------------------------------------------------------------
// ConnectL
// ---------------------------------------------------------------------------
//
TBool CAlfRsSendBuffer::ConnectL()
{
/* if (iDisabled) // return if this send buffer is not in use
{
return ETrue;
}
*/
if ( iAlfBridgerClient )
{
return ETrue; // already connected
}
iAlfBridgerClient = new(ELeave)RAlfBridgerClient();
TInt result = iAlfBridgerClient->Connect();
if ( result != KErrNone )
{
// server is not available
delete iAlfBridgerClient;
iAlfBridgerClient = NULL;
return EFalse;
}
TIpcArgs args(iScreenNumber);
User::LeaveIfError(iAlfBridgerClient->SendSynch(KAlfCompositionWServScreenNumber, args));
MAlfCompositionController* compcntrl = (MAlfCompositionController*)iParent.ResolveObjectInterface(KAlfCompositionControllerIfUid);
if (compcntrl)
{
#ifndef USE_UI_LAYER_FOR_ALF
TAlfNativeWindowData data;
TPckg<TAlfNativeWindowData> pkg(data);
if( iScreenNumber == 0) // only for primary screen
{
User::LeaveIfError(iAlfBridgerClient->SendSynch(EAlfGetNativeWindowHandles, TIpcArgs(&pkg)));
compcntrl->AlfBridgeCallback(MAlfBridge::EAlfNativeWindowCreated, &data);
}
}
#endif //#ifdef USE_UI_LAYER_FOR_ALF
iAlfCompositionCntrlClient = CAlfCompositionCntrlClient::NewL(iAlfBridgerClient, compcntrl);
return ETrue;
}
// ---------------------------------------------------------------------------
// WriteWindowIdentifierL
// Convenience function
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteWindowIdentifierL( )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
#ifdef _OLD_STREAM
if ( !iBufStream->Sink() )
{
return;
}
#endif
// <HEADER1>
// if you change <HEADER1>, you must update its size in the beginning of this file
WriteInt8L( EAlfSetWindowId );
ResetPatternSearch();
WriteInt8L( iScreenNumber );
WriteInt32L( iWindowId );
// </HEADER1>
WriteFollowingFrameOffsetTemplateL();
}
// ---------------------------------------------------------------------------
// WriteWindowDataL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteWindowDataL(
TUint32 aWindowUid,
TInt aRegionSize,
TInt aShapeRegionSize )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
// TODO: TERO: END
iNonSupportedCommandsInWindow = 0;
iPerformanceIssueCommandCount = 0;
iFlags = 0;
delete iCachedText;
iCachedText = NULL;
iPreviousCommand = EAlfCommandNotInitialized;
// Note, the size tells the maximum space needed for the command
TInt size = sizeof(TUint32) + // windowId
sizeof(TUint32) + // next frame offset
3 * sizeof(TUint8) + // command + contains unsupported commands + end marker
sizeof(TUint8) + // screen number ( in WriteFollowingFrameOffsetTemplate)
sizeof(TUint32) * ( 4 * aRegionSize + 1 ) + // updateregion
sizeof(TUint8) * KDivisibleByX + // possible padding
sizeof(TUint32) * ( 4 * aShapeRegionSize + 1) + // possible shape region
sizeof(EAlfCommandEndMarker); // endmarker for update region and this command
if (! InitCommandL( EAlfSetWindowId, size )){ return;}
#ifdef _ALF_PRINT_WS_COMMANDS_
iCommandDebugger->StartFrame();
#endif
ResetPatternSearch();
iWindowId = aWindowUid;
WriteInt32L( aWindowUid );
WriteFollowingFrameOffsetTemplateL();
iReceivingDrawingCommands = ETrue; // WriteCommand will set to false, when ERedrawComplete is received
}
// ---------------------------------------------------------------------------
// WriteFollowingFrameOffsetTemplateL
// Convenience function
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::WriteFollowingFrameOffsetTemplateL()
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
#ifdef _OLD_STREAM
if ( iBufStream->Sink() )
#endif
{
iTemplateOpen++;
if ( iTemplateOpen != 1 )
{
USER_INVARIANT();
}
iNextFrameOffsetPos = iOffset;
// If you add anything to <HEADER2>, you must update its size in the beginning of the file.
// <HEADER2>
TInt chunkId = 0;
if ( iChunkInUse)
{
chunkId = iCacheChunks[iChunkInUse-1].Handle();
}
WriteInt32L( chunkId );
WriteInt32L( KFrameOffsetTemplate ); // we'll come back later on, and write the correct frame size to this location
// determine need for padding
TInt pos = iOffset;
TInt offset = pos + 2 * sizeof(TUint8) + sizeof(TUint8) + sizeof(TInt32); // padding and endmarker.
TInt startPadding = offset % KDivisibleByX;
startPadding = startPadding == 0 ? 0 : KDivisibleByX - startPadding;
WriteInt8L( EAlfFrameFlags );
WriteInt32L( 0 );
WriteInt8L( startPadding );
iFramePadding = startPadding;
WriteInt8L( EAlfCommandEndMarker );
// actual padding
while ( startPadding-- )
{
WriteInt8L( 0 );
}
iArrayImplOffset = iOffset;
InitMarker(iMarker);
WriteInt8L( EAlfFrameContainsUnsupportedCommands );
WriteInt8L( 0 );
WriteArrayHeaderTemplateL();
InitTOffsetElemArray(iOffsetArray);
// </HEADER2>
}
}
// ---------------------------------------------------------------------------
// WriteFollowingFrameOffsetL
// ---------------------------------------------------------------------------
//
TBool CAlfRsSendBuffer::WriteFollowingFrameOffsetL(TBool aSendArray)
{
if (iDisabled) // return if this send buffer is not in use
{
return ETrue;
}
TOffsetElem e;
if (aSendArray)
{
e = WriteIndexArrayL(iOffsetArray);
}
#ifdef _OLD_STREAM
if ( iBufStream->Sink() )
#endif
{
if ( iPerformanceIssueCommandCount > KPossiblePerformanceProblemInWindowThreshold )
{
if ( iPerformanceIssueCommandCount > iMaxPerformanceIssueCommandCount )
{
iMaxPerformanceIssueCommandCount = iPerformanceIssueCommandCount;
}
iNonSupportedCommandsInWindow |= KPossiblePerformanceProblemInWindow;
}
iTemplateOpen--;
// Empty frames should not be serialized as they cause unnecessary work on Alfserver side.
// WServ sends empty frames from time to time
TInt previousPos = iOffset;
// Remember to update KWindowFrameHeaderX, if you add stuff to frame header
TInt frameSize = previousPos - iNextFrameOffsetPos - KWindowFrameHeader2 - iFramePadding;
if ( !frameSize )
{
SeekL( iNextFrameOffsetPos - KWindowFrameHeader1 );
iReceivingDrawingCommands = EFalse;
return EFalse;
}
SeekL( iNextFrameOffsetPos );
// <HEADER2>
TInt chunkId = 0;
if ( iChunkInUse)
{
chunkId = iCacheChunks[iChunkInUse-1].Handle();
}
WriteInt32L( chunkId );
WriteInt32L( previousPos );
WriteInt8L( EAlfFrameFlags );
WriteInt32L( iFlags );
WriteInt8L( iFramePadding );
WriteInt8L( EAlfCommandEndMarker );
// Padding
while ( iFramePadding-- )
{
WriteInt8L( 0xff );
}
WriteInt8L( EAlfFrameContainsUnsupportedCommands );
WriteInt8L( iNonSupportedCommandsInWindow );
if (aSendArray)
{
WriteArrayHeaderL(e);
}
/*iWindowHeaderStruct.iWindowEndOffset = previousPos.Offset();
iWindowHeaderStruct.iUnsupportedCommandsInWindow = iNonSupportedCommandsInWindow;
iBufStream->WriteL( (TUint8*)&iWindowHeaderStruct, sizeof(TWindowHeaderStruct) );*/
// <HEADER2>
// return to end of frame
SeekL( previousPos );
if ( iTemplateOpen )
{
USER_INVARIANT();
}
}
return ETrue;
}
//
// ARRAY IMPLEMENTATION
//
const TInt KArrayOffsetTemplate = 23456789;
const TInt KArraySizeTemplate = 23456789;
void CAlfRsSendBuffer::WriteArrayHeaderTemplateL()
{
WriteInt8L( EAlfCommandIndexArrayHeader );
WriteInt8L( 0 ); // align
WriteInt32L( KArrayOffsetTemplate ); // these will be rewritten in WriteArrayHeader2
WriteInt32L( KArraySizeTemplate ); // these will be rewritten in WriteArrayHeader2
}
void CAlfRsSendBuffer::InitTOffsetElemArray(RArray<TOffsetElem> &aOffsets)
{
TInt count = aOffsets.Count();
for(TInt i=0;i<count;i++)
aOffsets.Remove(0);
}
CAlfRsSendBuffer::TOffsetElem CAlfRsSendBuffer::WriteIndexArrayL(const RArray<TOffsetElem> &aOffsets)
{
TInt marker = iBufStream->Sink()->TellL( MStreamBuf::EWrite ).Offset();
if (iPreviousBlockOffset != marker && iLayersEnabled)
{
TInt size = marker - iPreviousBlockOffset;
TOffsetElem e;
e.iOffset = iPreviousBlockOffset - iArrayImplOffset; //iFrameBeginOffset + KWindowFrameHeader1 + KWindowFrameHeader2;
e.iSize = size;
e.iBoundingRectangle = TRect(0,0,0,0);
e.iLayerId = iExtraLayerId++;
iOffsetArray.AppendL( e );
}
InsertPaddingL();
// first command to allow wspainter to skip the index array section
WriteInt8L(EAlfCommandIndexArray);
WriteInt8L(aOffsets.Count());
WriteInt8L(0);
WriteInt8L(0);
TInt offset = iOffset;
TInt count = aOffsets.Count();
// then the actual index array
for(TInt i = 0; i<count; i++)
{
WriteInt32L( aOffsets[i].iOffset );
WriteInt32L( aOffsets[i].iSize );
WriteInt32L( aOffsets[i].iLayerId);
WriteL( (TUint8*)&aOffsets[i].iBoundingRectangle, sizeof(TRect) );
}
TOffsetElem e;
e.iOffset = offset - iArrayImplOffset; //iFrameBeginOffset + KWindowFrameHeader1 + KWindowFrameHeader2;
e.iSize = aOffsets.Count()*sizeof(TOffsetElem);
return e;
}
void CAlfRsSendBuffer::WriteArrayHeaderL(const TOffsetElem &aIndexArrayOffset)
{
WriteInt8L( EAlfCommandIndexArrayHeader );
WriteInt8L( 0 ); // align
WriteInt32L( aIndexArrayOffset.iOffset );
WriteInt32L( aIndexArrayOffset.iSize );
}
void CAlfRsSendBuffer::InitMarker(TInt &aMarker)
{
aMarker = -1;
iPreviousBlockOffset = iBufStream->Sink()->TellL( MStreamBuf::EWrite ).Offset();
iExtraLayerId = 667;
iLayersEnabled = EFalse;
}
void CAlfRsSendBuffer::StartMarkerL(TInt &aMarker, TRect &aRectangle, TInt &aLayer, TRect aBoundingRectangle, TInt aLayerId)
{
ASSERT(aMarker == -1);
aMarker = iBufStream->Sink()->TellL( MStreamBuf::EWrite ).Offset();
if (iPreviousBlockOffset != aMarker)
{
TInt size = aMarker - iPreviousBlockOffset;
TOffsetElem e;
e.iOffset = iPreviousBlockOffset - iArrayImplOffset; //iFrameBeginOffset + KWindowFrameHeader1 + KWindowFrameHeader2;
e.iSize = size;
e.iBoundingRectangle = TRect(0,0,0,0);
e.iLayerId = iExtraLayerId++;
iOffsetArray.AppendL( e );
}
//aMarker = iOffset;
aRectangle = aBoundingRectangle;
aLayer = aLayerId;
iLayersEnabled = ETrue;
}
void CAlfRsSendBuffer::EndMarkerL(RArray<TOffsetElem> &aOffset, TInt &aMarker, const TRect &aRectangle, TInt aLayerId)
{
//TODO ASSERT(aMarker != -1);
if (aMarker==-1) return;
TInt offset = iBufStream->Sink()->TellL( MStreamBuf::EWrite ).Offset();
TInt size = offset - aMarker;
TOffsetElem e;
e.iOffset = aMarker - iArrayImplOffset; //iFrameBeginOffset + KWindowFrameHeader1 + KWindowFrameHeader2;
e.iSize = size;
e.iBoundingRectangle = aRectangle;
e.iLayerId = aLayerId;
aOffset.AppendL( e );
aMarker = -1;
iPreviousBlockOffset = offset;
}
void CAlfRsSendBuffer::StartMarkerL(TRect aBoundingRectangle, TInt aLayerId)
{
StartMarkerL(iMarker, iBoundingRectangle, iLayerId, aBoundingRectangle, aLayerId);
}
void CAlfRsSendBuffer::EndMarkerL()
{
EndMarkerL(iOffsetArray, iMarker, iBoundingRectangle, iLayerId);
}
// ---------------------------------------------------------------------------
// SendL
// sends data syncronously in one or more packets to the streamer server
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::SendL( TRequestStatus* aStatus )
{
// dont send to alf, if chunk is not available or nothing was written
if (iDisabled || !iChunk.Handle() )
{
if ( aStatus )
{
// AlfRenderStage may complete the request, because we wont do anything with the data
iParent.EndCallBack( aStatus );
}
return;
}
WriteInt8L( EAlfCommitBatch );
WriteInt8L( iScreenNumber );
WriteInt8L( EAlfCommandEndMarker );
iState = EWaitingAck;
TInt lastWrittenOffset( iOffset );
Commit();
TIpcArgs args( lastWrittenOffset );
// __ALFLOGSTRING1("CAlfRsSendBuffer::SendL, offset %d ( TRequestStatus)"), lastWrittenOffset );
if ( iFlushBufferTimer )
{
iFlushBufferTimer->Cancel();
}
iAlfBridgerClient->SendAsynchronous( EAlfBridgerAsyncronousData, args, iStatus );
if ( aStatus ) // aStatus is null, if this was event notification and not drawing
{
iQuedStatus = aStatus;
*aStatus = KRequestPending;
}
if ( !IsActive() )
{
SetActive();
}
}
// ---------------------------------------------------------------------------
// FlushBuffer
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::FlushBuffer()
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
TBool connected = (iAlfBridgerClient != NULL);
if (!connected)
{
TRAP_IGNORE(connected = ConnectL());
}
if (!connected)
{
// Cannot connect
return;
}
TIpcArgs args( 0 );
TInt result = iAlfBridgerClient->SendBlind( EAlfBridgerBlindSend, args );
if ( result != KErrNone && result != KErrServerBusy)
{
__ALFLOGSTRING1("CAlfRsSendBuffer::FlushBuffer, err %d", result );
// This means that AlfDecoderServer has died and is not coming back.
// There is no point of continuing with non updating UI.
USER_INVARIANT();
}
if ( iFlushBufferTimer )
{
iFlushBufferTimer->Cancel();
}
// during boot time, server is known to answer with this. Just try again little later.
if ( result == KErrServerBusy)
{
CommitL();
}
}
// ---------------------------------------------------------------------------
// CommitL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::CommitL( )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
if ( iBooting )
{
return;
}
Commit();
// RDebug::Print(_L("CAlfRsSendBuffer::CommitL - %d %d %d "), iChunkHeader, iChunkHeader->iCommittedWriteOffset, iOffset );
if ( !iFlushBufferTimer )
{
iFlushBufferTimer = CPeriodic::NewL( EPriorityNormal );
iFlushBufferTimer->Start( 5000, 10 * 1000000 , TCallBack( doFlushBuffer, this ));
}
if ( !iFlushBufferTimer->IsActive() )
{
//__ALFLOGSTRING("CAlfRsSendBuffer::CommitL, activating timer");
iFlushBufferTimer->After( 5000 );
}
else
{
//__ALFLOGSTRING("CAlfRsSendBuffer::CommitL, timer already active ");
}
}
// ---------------------------------------------------------------------------
// SendAsyncCmd
// Send asynchronous command
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::SendAsyncCmd(TInt aCmd, TDes8& aBuf, TRequestStatus& aStatus)
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
iAlfBridgerClient->SendAsynchronous(aCmd, TIpcArgs(&aBuf), aStatus);
}
// ---------------------------------------------------------------------------
// OpenPrimaryChunkForWritingL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::OpenPrimaryChunkForWritingL()
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
iChunkHeader = reinterpret_cast<TChunkHeader*>(iChunk.Base());
if ( iChunkHeader->iMemWriteStream )
{
#ifdef _OLD_STREAM
iBufStream->Close();
delete iBufStream;
iBufStream=NULL;
iBufStream = new(ELeave)RMemWriteStream;
// iBufStream = iChunkHeader->iMemWriteStream;
iBufStream->Open( iChunk.Base() + sizeof( TChunkHeader), iPrimaryChunkMaxSize );
#else
delete iStreamPtr;
iStreamPtr = new(ELeave)TPtr8( (TUint8*)(iChunk.Base() + sizeof( TChunkHeader)), iPrimaryChunkMaxSize - sizeof( TChunkHeader));
iChunkHeader->iMemWriteStream = (RMemWriteStream*)1;
#endif
SeekL( iOffset );
iChunkInUse = 0;
}
else
{
#ifdef _OLD_STREAM
iBufStream->Open( iChunk.Base() + sizeof( TChunkHeader), iPrimaryChunkMaxSize );
iChunkHeader->iMemWriteStream = iBufStream;
#else
iStreamPtr = new(ELeave)TPtr8( (TUint8*)(iChunk.Base() + sizeof( TChunkHeader)), iPrimaryChunkMaxSize - sizeof( TChunkHeader) );
iChunkHeader->iMemWriteStream = (RMemWriteStream*)1;
#endif
SeekL(0);
iChunkHeader->iMemWriteStreamUsers++;
}
WriteInt8L( EAlfCommandEndMarker );
Commit();
}
// ---------------------------------------------------------------------------
// Commit
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::Commit()
{
iChunkHeader->iCommittedWriteOffset = iOffset;
// RDebug::Print(_L("CAlfRsSendBuffer::Commit - %d"), iChunkHeader->iCommittedWriteOffset );
}
// ---------------------------------------------------------------------------
// PrepareBufferL
// Sets up the stream
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::PrepareBufferL()
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
// is alfstreamerserver running?
if ( !ConnectL() )
{
return;
}
iBeginTime.HomeTime();
// alfstreamerserver is now running, but do we already have chunk for serialization
if ( iChunk.Handle() == 0 )
{// Note, ConnectL() == ETrue and iChunk.Handle() == 0 is true ONLY ONCE in runtime.
// write jump to the primary chunk. This chunk jump gets special treatment in RunL. Look for iBooting variable.
JumpToAnotherChunkL( 0, iPrimaryChunkMaxSize ); // 2nd parameter is ignored on alfside, because it knows the primary chunksize
Commit();
#ifdef _OLD_STREAM
iBufStream->Close();
#endif
// Request chunk from server: handle and lenght of chunk come as response
TPckg<TInt> pkgLength( iUsedChunkMaxSize );
TIpcArgs args( &pkgLength, iScreenNumber );
TInt handle;
handle = iAlfBridgerClient->SendSynch( EAlfBridgerRequestDataBlock, args);
iPrimaryChunkMaxSize = iUsedChunkMaxSize;
iChunk.SetReturnedHandle( handle );
if ( iChunk.Handle() > 0 )
{
OpenPrimaryChunkForWritingL();
}
else
{
// Chunk was not received from server. We cannot continue
USER_INVARIANT();
}
}
// The first boot cache chunk is sent here.
if ( iBooting && iCacheChunks.Count() && iChunkInUse )
{
if ( iChunkHeader->iMemWriteStreamUsers > 1 )
{
// make "sure", that there will be space for all the cached data
CommitL();
}
while ( iChunkInUse )
{
iChunkInUse--;
TInt size( KCacheChunkMinSize );
TIpcArgs args( size, iCacheChunks[iChunkInUse], iChunkInUse == 0 /* open chunk for reading */);
iAlfBridgerClient->SendSynch( EAlfBridgerSendChunk, args);
}
}
iFrameBeginOffset = iOffset; // iBufStream->Sink()->TellL( MStreamBuf::EWrite);
}
// ---------------------------------------------------------------------------
// FrameContainsDataL
// ---------------------------------------------------------------------------
//
TBool CAlfRsSendBuffer::FrameContainsDataL()
{
if (iDisabled) // return if this send buffer is not in use
{
return EFalse; // Must return false as no draw commands are allowed
}
#ifdef _OLD_STREAM
if ( iBufStream->Sink() )
#endif
{
#ifdef _OLD_STREAM
iBufStream->CommitL();
#endif
return ( iFrameBeginOffset != iOffset );
}
#ifdef _OLD_STREAM
else
{
return EFalse;
}
#endif
}
// ---------------------------------------------------------------------------
// JumpToAnotherChunkL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::JumpToAnotherChunkL( TInt32 aChunkId, TInt aChunkSize )
{
WriteInt8L( EAlfJumpToAnotherChunk );
WriteInt8L( 0 ); // screen number, not used.
WriteInt32L( aChunkId );
WriteInt32L( aChunkSize );
WriteInt8L( EAlfCommandEndMarker );
Commit();
}
// ---------------------------------------------------------------------------
// DoCreateTemporaryChunkL
//
// If wserv pushes more data in frame that we can handle, separate one time use
// "temporary" chunks are taken into use.
// 1. Big enough chunk to contain atleast the command + minimum chunk size is created
// 2. Jump of from the current chunk to the temporary chunk is created
// 3. new chunk is taken as the active chunk
// 4. chunk is rewinded
// 5. commands can be serialized as before
//
// Same starts from the step 1, if temporary chunk turns out to be not big enough.
//
// Chunks are destroyed in RunL, when asyncronous (frame processed) complete is
// received. In RunL, (see RunL for the code)
//
// The following things are serialized to the active (the last temporary chunk created)
// 1. destroy command for each existing temporary chunk is created
// 2. if not in first boot, jump to the primary chunk is created.
// 3. handles to the temporary chunks on this side are closed
// and chunks removed.
//
// After AlfHierarchy has read the jump command, serialization will be in the normal mode.
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::DoCreateTemporaryChunkL( TInt aMinimumRequiredSize )
{
__ALFLOGSTRING2("CAlfRsSendBuffer::DoWaitWrapperL iReceivingDrawing commands %d chunk in use: %d", iReceivingDrawingCommands, iChunkInUse );
// Optimize bitblits backtracks in a _single chunk_, so changing or wrapping a chunk is
// a very bad idea. Lets skip the optimization, if this rare occation happens.
ResetPatternSearch();
if ( iReceivingDrawingCommands )
{
// if window drawing is active, the window commands are split.
InsertPaddingL(); // padding is required, that the combined parts on the other side have correct alignment for descriptors
WriteFollowingFrameOffsetL(EFalse);
WriteInt8L( EAlfPacketNotReady );
WriteInt8L( EAlfCommandEndMarker );
}
else
{
__ALFLOGSTRING("CAlfRsSendBuffer::DoCreateTemporaryChunkL, creating during hierarchy commands");
}
// rest of this frame will be serilized to cache chunk
CommitL();
if ( ConnectL() )
{
FlushBuffer();
}
TInt chunkSize = aMinimumRequiredSize;
if ( CreateTemporaryChunkL( chunkSize ) == KErrNone )
{
if ( ConnectL() )
{
TInt size( chunkSize );
TIpcArgs args( size, iCacheChunks[iChunkInUse], EFalse /* open chunk for reading */ );
iAlfBridgerClient->SendSynch( EAlfBridgerSendChunk, args); // alf server must open the chunk before it can be read. reading is asyncronous
}
JumpToAnotherChunkL( iCacheChunks[iChunkInUse].Handle(), chunkSize );
OpenRewindChunkL( chunkSize );
WriteInt8L( EAlfCommandEndMarker ); // This is must command after jumping to another chunk.
CommitL();
if ( iReceivingDrawingCommands )
{
WriteWindowIdentifierL();
}
}
else
{
// TODO: We could not reserve memory. The only option will be to ignore this frame.
// 1. rollback to the beginning of the frame
// 2. skip all sequential drawing commands to this frame.
// problem: what if OOM during hierarchy tree commmands
}
}
// ---------------------------------------------------------------------------
// ReserveSpaceL
//
// Check, if buffer has enough space for this command.
// If we encounter the end of buffer, then do a wrap around if possible.
// If wrap is not possible, create a temporary space for command
// ---------------------------------------------------------------------------
//
TBool CAlfRsSendBuffer::ReserveSpaceL( TInt aCommandSize )
{
// TInt minumumHeaderSize = iCacheChunks.Count() > 0 ? KFrameHeaderSizeWhenCacheChunks : KFrameHeaderSize;
TInt minumumHeaderSize = KFrameHeaderSize;
if ( iCacheChunks.Count() > 0 )
{
// if cache chunks still exists, then wserv is trying to push commands out of redrawstart/end loop and we hope that
minumumHeaderSize = KFrameHeaderSizeWhenCacheChunks;
}
TInt writeOffset = iOffset;
TInt commandTailOffset = writeOffset + aCommandSize + KFrameHeaderSize;
TInt readOffset = iChunkHeader->iReadOffset;
TInt bytesFree(0);
if ( readOffset > writeOffset)
{// V
// |RRRRRRRRR|W---------RRRRRRRRRRRR |
// ASSERT( iWrappingFrame );
bytesFree = readOffset - writeOffset;
}
if ( readOffset < writeOffset )
{
// V W
// | ----RRRRRRRRRRRRRRRW------ |
iWrappingFrame = EFalse;
bytesFree = iUsedChunkMaxSize - writeOffset; // there might be more free and the beginning of the chunk, but this is not relevant. The entire command needs to fit as one piece
}
if ( readOffset == writeOffset )
{
if ( iWrappingFrame )
{
// V
// | RRRRRRRRRRRRRWRRRRRRRRRRRRR |
bytesFree = 0;
}
else
{
// V
// | --------------------------- |
// the entire chunk is free
bytesFree = iUsedChunkMaxSize;
}
}
// are we trying to overwrite unprocessed data
if ( bytesFree < aCommandSize + minumumHeaderSize && commandTailOffset <= iUsedChunkMaxSize
|| ( bytesFree < aCommandSize + minumumHeaderSize && iWrappingFrame ))
{
// __ALFLOGSTRING("CAlfRsSendBuffer::CanWriteToBufferL -> DoCreateTemporaryChunkL");
DoCreateTemporaryChunkL( aCommandSize );
}
else if ( commandTailOffset > iUsedChunkMaxSize )
{
if ( !iChunkInUse )
{
DoWrapL( aCommandSize, aCommandSize > readOffset );
}
else
{
// we are already using temporary chunks and those cannot be wrapped. The only option is to create
// yet another temporary chunk.
DoCreateTemporaryChunkL( aCommandSize );
}
}
return ETrue;
}
// ---------------------------------------------------------------------------
// DoWrapL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::DoWrapL( TInt aCommandSize, TBool aCreateTempororaryChunk )
{
if ( iCacheChunks.Count() )
{
DoCreateTemporaryChunkL( aCommandSize );
}
__ALFLOGSTRING2("CanWriteToBufferL Read/Write %d/%d", iChunkHeader->iReadOffset, iChunkHeader->iWriteOffset);
if ( aCreateTempororaryChunk )
{
__ALFLOGSTRING("CAlfRsSendBuffer::DoWrapL -> DoCreateTemporaryChunkL");
DoCreateTemporaryChunkL( aCommandSize );
return;
}
else
{
if ( iReceivingDrawingCommands )
{
InsertPaddingL();
WriteFollowingFrameOffsetL(EFalse);
WriteInt8L( EAlfPacketNotReady );
WriteInt8L( EAlfCommandEndMarker );
}
else
{
__ALFLOGSTRING("CAlfRsSendBuffer::CanWriteToBufferL, non drawing command");
}
}
WriteInt8L( EAlfWrap );
WriteInt8L( iScreenNumber );
WriteInt8L( EAlfCommandEndMarker );
// Optimize bitblits backtracks in a _single chunk_, so changing or wrapping a chunk is
// a very bad idea. Lets skip the optimization, if this rare occation happens.
ResetPatternSearch();
iWrappingFrame = ETrue;
__ALFLOGSTRING1("CAlfRsSendBuffer::CanWriteToBufferL, Wrap at offset %d", iChunkHeader->iWriteOffset);
SeekL(0);
WriteInt8L( EAlfCommandEndMarker );
if ( iReceivingDrawingCommands )
{
WriteWindowIdentifierL();
}
else
{
__ALFLOGSTRING("CAlfRsSendBuffer::CanWriteToBufferL Wrapping while not receiving drawing commands");
}
}
// ---------------------------------------------------------------------------
// SetSupportedCommand
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::SetSupportedCommand( TInt aIndex, TInt8 aSupport )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
iNonSupportedCommands[aIndex] = aSupport;
}
// ---------------------------------------------------------------------------
// InitCommandL
// Takes care that data fits to the stream
// ---------------------------------------------------------------------------
//
TBool CAlfRsSendBuffer::InitCommandL( const TUint8& aCommand, TInt aCommandSize )
{
// THIS IS DIRTY HACK UNTIL WSERV STOPS DOING DRAWING OUTSIDE WINDOW
// RE-EVALUATE FOR WK14 RELEASE
if ( ( aCommand >= EAlfDrawCommandsStart && aCommand <= EAlfDrawCommandsEnd && !iReceivingDrawingCommands ) &&
( aCommand != EAlfPacketReady && aCommand != EAlfPacketNotReady ))
{
#ifdef _DEBUG
RDebug::Print(_L("CAlfRsSendBuffer::InitCommandL - Drawing outside window, Cmd: %d"), aCommand );
#endif
return EFalse;
}
// END OF DIRTY HACK
if ( iReceivingDrawingCommands )
{
aCommandSize += sizeof(EAlfCommandEndMarker);
}
iNonSupportedCommandsInWindow |= iNonSupportedCommands[aCommand] & KAllRenderersMask;
if ( iNonSupportedCommands[aCommand] & KPossiblePerformanceProblemInWindow ) // indicates possible performance problem if frame has many of this of commands
{
iPerformanceIssueCommandCount++;
}
// Check if chunk has been opened. Must for streaming.
if (
#ifdef _OLD_STREAM
!iBufStream &&
#else
!iChunkHeader &&
#endif
iCacheChunks.Count() == 0 )
{
TInt chunkSize = aCommandSize;
CreateTemporaryChunkL( chunkSize );
OpenRewindChunkL( chunkSize );
}
// EAlfPacketReady is the last command in the window, and it is guaranteened to fit without checking. Checking would possible slice the command stream unnecessary.
if ( aCommand != EAlfPacketReady )
{
// check for running out of space in the chunk
if ( !ReserveSpaceL( aCommandSize + 2*sizeof(TUint8)) )
{
return EFalse;
}
}
// write command to a chunk. There will be space.
// __ALFLOGSTRING3("Command %d, Offset: %d Screen: %d Command: %d", aCommand, iScreenNumber, aCommand );
WriteInt8L( aCommand );
iPreviousCommand = aCommand;
if ( aCommand < EAlfDrawCommandsStart || aCommand > EAlfDrawCommandsEnd )
{
WriteInt8L( iScreenNumber );
}
else
{
// Uncomment following line to do chaff bitblit optimization
#ifndef __NVG // TODO: Implement the 9-piece drawing for NVG
// DoPatternSearch( aCommand, aCommandSize );
#endif
}
return ETrue;
}
// ---------------------------------------------------------------------------
// CreateTemporaryChunkL
// ---------------------------------------------------------------------------
//
TBool CAlfRsSendBuffer::CreateTemporaryChunkL( TInt& aSize )
{
aSize+= KCacheChunkMinSize;
iCacheChunks.Append( RChunk() );
TInt result = iCacheChunks[iChunkInUse].CreateDisconnectedGlobal( KNullDesC, 0, aSize, aSize );
return result;
}
// ---------------------------------------------------------------------------
// OpenRewindChunkL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::OpenRewindChunkL( TInt aSize )
{
#ifdef _OLD_STREAM
if ( iBufStream && iChunkInUse)
{
iBufStream->Close();
}
iBufStream = new(ELeave)RMemWriteStream;
iBufStream->Open( iCacheChunks[iChunkInUse].Base() + sizeof( TChunkHeader), aSize );
#else
iStreamPtr = new(ELeave)TPtr8( (TUint8*)(iCacheChunks[iChunkInUse].Base() + sizeof( TChunkHeader)), aSize - sizeof( TChunkHeader));
#endif
iChunkHeader = reinterpret_cast<TChunkHeader*>(iCacheChunks[iChunkInUse].Base());
SeekL(0);
memset( iChunkHeader, 0, sizeof( TChunkHeader ) );
iUsedChunkMaxSize = aSize - sizeof( TChunkHeader);
iChunkInUse++;
}
// ---------------------------------------------------------------------------
// DoPatternSearch
//
// Pattern search seeks for predefined sequence of commands. In TSearchPatternBitBlit case the seqence is
// EAlfSetBrushStyle -> EAlfSetBrushStyle -> EAlfSetClippingRegion -> EAlfBitBltMasked -> EAlfResetClippingRegion .
//
// When possible pattern is found, the start offset of the pattern is saved. If pattern is
// noticed 8 or more times in sequence, the pattern is complete. Functions seeks back to the
// start offset and serializes cached data of the pattern. Some data can be dropped as it has
// no significance.
// ---------------------------------------------------------------------------
//
#ifdef _ALF_PRINT_WS_COMMANDS_
void CAlfRsSendBuffer::DoPatternSearch( const TUint8& aCommand, TInt aSize )
#else
void CAlfRsSendBuffer::DoPatternSearch( const TUint8& aCommand, TInt )
#endif
{
TInt sizeOfPattern = sizeof(TSearchPatternBitBlit) / (3 * sizeof(TInt32)); // rows = size / width
if ( ( TSearchPatternBitBlit[iPatternSearchState][0] == aCommand
|| ( TSearchPatternBitBlit[iPatternSearchState][2] != KErrNotFound && TSearchPatternBitBlit[iPatternSearchState][2] == aCommand ))
&& TSearchPatternBitBlit[iPatternSearchState][1] == iPatternSearchState )
{
TInt tmp = iPatternSearchState;
iPatternSearchState = TSearchPatternBitBlit[iPatternSearchState+1][1];
#ifdef _ALF_PRINT_WS_COMMANDS_
TPatternCommand command( aCommand, aSize );
iPatternCommands.Append( command );
#endif
if ( tmp == 0 && iPatterSearchSequentialBlits == 0 )
{
// This is the beginning of the sequence. Save position (offset minus size of the current command)
// the for later use.
iPatternCacheBeginPosition = iOffset;
#ifdef _OLD_STREAM
iPatternCacheBeginPosition = TStreamPos( iPatternCacheBeginPosition - sizeof(TUint8) ); // the command
#else
iPatternCacheBeginPosition = iPatternCacheBeginPosition - sizeof(TUint8) ; // the command
#endif
iSearchPatternClipRegion.Clear();
#ifdef _ALF_PRINT_WS_COMMANDS_
iPatternCommands.Reset();
#endif
}
else if ( tmp == sizeOfPattern - 1)
{
// Start from the beginning the next sequential pattern
iPatternSearchState = TSearchPatternBitBlit[0][1];
iPatterSearchSequentialBlits++;
}
}
else
{
TRAP_IGNORE(FinalizePatternL( aCommand ));
}
}
// ---------------------------------------------------------------------------
// FinalizePatternL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::FinalizePatternL( const TUint8& aCommand )
{
// We are looking 8 or more connected chaff pieces
if ( iPatterSearchSequentialBlits >= 9 )
{
iSearchPatternClipRegion.Tidy(); // will return only one region, if pieces are connected
iSearchPatternBlitRect.Tidy();
if ( iSearchPatternClipRegion.Count() == 1 && iSearchPatternBlitRect.Count() == 1)
{
#ifdef _OLD_STREAM
SeekL( iPatternCacheBeginPosition.Offset() );
#else
SeekL( iPatternCacheBeginPosition );
#endif
WriteInt8L( EAlfCombinedBitBlitMasked );
#ifdef _ALF_PRINT_WS_COMMANDS_
TInt size = iPatterSearchSequentialBlits * sizeof(TBlitStruct) + 2 * sizeof(TRect);
iCommandDebugger->SetDescriptionAndSize( EAlfCombinedBitBlitMasked, size, R_ALF_COMMAND_DESCRIPTION_ARRAY );
iCommandDebugger->Print();
while ( iPatternCommands.Count())
{
iCommandDebugger->AdjustCommand( iPatternCommands[0].iCommand, (-1) * iPatternCommands[0].iSize );
iPatternCommands.Remove(0);
}
#endif
// item count
WriteInt8L( iPatterSearchSequentialBlits );
// Clipping region for all the pieces.
// This contains the clippingregion (set by EAlfSetClippingRegion) and rect for all the pieces
// (from EAlfBitBlit, EAlfBitBltRect, EAlfBitBlitMasked )
TRect clipRect = iSearchPatternClipRegion.BoundingRect();
TRect clipBlitRect = iSearchPatternBlitRect.BoundingRect();
WriteL( (TUint8*)&clipRect, sizeof(TRect));
WriteL( (TUint8*)&clipBlitRect, sizeof(TRect));
// Items
while( iPatterSearchSequentialBlits-- )
{
TPoint point = iPatternHandleCache[iPatterSearchSequentialBlits].iTl;
WriteL( (TUint8*)&iPatternHandleCache[iPatterSearchSequentialBlits], sizeof(TBlitStruct) );
}
#ifndef _OPTIMIZE_WS_COMMANDS_ADVANCED_
WriteInt8L( EAlfSetPenStyle );
WriteInt32L( iPenStyle );
#endif
// Write again the current command (after the pattern sequence), because we just overwrote it
WriteInt8L( aCommand );
}
}
ResetPatternSearch();
}
// ---------------------------------------------------------------------------
// ResetPatternSearch
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::ResetPatternSearch()
{
iPatternSearchState = ESeekSetClippingRegion;
iPatterSearchSequentialBlits = 0;
iSearchPatternClipRegion.Clear();
iSearchPatternBlitRect.Clear();
iPatternHandleCache.Reset();
#ifdef _ALF_PRINT_WS_COMMANDS_
iPatternCommands.Reset();
#endif
}
// ---------------------------------------------------------------------------
// AppendPatternSearchCache
// saves masked bitblits to the cache
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::AppendPatternSearchCache( const CFbsBitmap& aSourceBitmap, const CFbsBitmap* aMaskBitmap, const TRect& aSourceRect, const TPoint& aDestPos, TBool aInvertMask )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
TSize size1 = aSourceRect.Size();
TSize size2 = aSourceBitmap.SizeInPixels();
if ( aInvertMask == 1 )
{
TInt handle = aMaskBitmap ? aMaskBitmap->Handle() : 0;
iPatternHandleCache.Append( TBlitStruct( aSourceBitmap.Handle(),handle, aDestPos ) );
TRect rect( TPoint(0,0), aSourceRect.Size() );
rect.Move( aDestPos );
iSearchPatternBlitRect.AddRect( rect );
}
else
{
ResetPatternSearch();
}
}
// ---------------------------------------------------------------------------
// InsertPaddingL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::InsertPaddingL()
{
// padding is required for the 1st part of the package, because the 2nd package
// is attached straight to it and it MUST start at offset divisible by 4. Otherwise
// possible strings in the second package will not be correctly alligned.
TInt offset = iOffset;
TInt padding = offset % KDivisibleByX;
if ( padding > 0)
{
padding = KDivisibleByX - ( offset + sizeof(TUint8) * 2 ) % KDivisibleByX; // 2 = sizeof( EAlfPacketPadding + padding )
WriteInt8L( EAlfPacketPadding );
WriteInt8L( padding );
while( padding--)
{
WriteInt8L( 0 );
}
if ( !iReceivingDrawingCommands )
{
WriteInt8L( EAlfCommandEndMarker );
}
}
#ifdef _DEBUG
ASSERT( ( offset = iOffset ) % KDivisibleByX == 0);
#endif
}
// ---------------------------------------------------------------------------
// SetFlag
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::SetFlag( TAlfSendBufferFrameFlags aFlag )
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
iFlags |= aFlag;
}
// ---------------------------------------------------------------------------
// EndFrameL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::EndFrameL()
{
if (iDisabled) // return if this send buffer is not in use
{
return;
}
TUint8 command(EAlfPacketReady);
if ( iFlags & EAlfTransparentContent && !(iFlags & EAlfTransparentContentFlush ) )
{
InsertPaddingL();
}
if ( WriteFollowingFrameOffsetL() )
{
WriteCommandL( command );
}
#ifdef ALF_DEBUG_TRACK_DRAWING
TInt trackThisNode = 0;
if ( trackThisNode )
{
WriteIntsL( EAlfDebugTrackNode, 2, (TInt32)&iWindowId, 1 );
}
#endif
}
// ---------------------------------------------------------------------------
// SeekL
// ---------------------------------------------------------------------------
//
void CAlfRsSendBuffer::SeekL( const TInt aOffset )
{
#ifdef _OLD_STREAM
iBufStream->Sink()->SeekL( MStreamBuf::EWrite, TStreamPos(aOffset));
#endif
iOffset = aOffset;
}