MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/graphicscomposition/openwfsupport/src/openwfcstream.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // openwfcstream.cpp

    15 // C API for surface stream implementation of OpenWF-C NativeStream 

    16 //

    17 

    18 

    19 //  Include Files  

    20 #include <e32def.h>

    21 #include <pixelformats.h>

    22 #include <graphics/suerror.h>

    23 #include "symbianstream.h"

    24 #include "surfacestream.h"

    25 #include "streammap.h"

    26 #include "openwfcpanic.h"

    27 

    28 

    29 extern "C"{

    30 

    31 EXPORT_C TErrCode SymbianStreamAcquire( const TSurfaceId* aId, SymbianStreamType* aReturnStream)

    32 	{

    33 	if (aId && !aId->IsNull())

    34 		{

    35         CSurfaceStream* stream = NULL;

    36         if (aId->Type()==TSurfaceId::EStreamHandle)

    37             {

    38             stream=CSurfaceStream::FromHandle(aId);

    39             __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamUnexpectedError));

    40             stream->AddReference();

    41             *aReturnStream= stream->ToHandle();

    42             return KErrNone;

    43             }

    44         else

    45             {

    46             TRAPD(err,stream = COpenWfcStreamMap::InstanceL().AcquireL(*aId));

    47             if (stream)

    48                 {

    49                 *aReturnStream = stream->ToHandle();

    50                 return KErrNone;

    51                 }

    52             else

    53                 {

    54                 return err;

    55                 }

    56             }

    57 		}

    58 	else

    59 		{

    60 		*aReturnStream = NULL;

    61 		return KErrBadHandle;

    62 		}	

    63 	}

    64 

    65 EXPORT_C TErrCode SymbianStreamFind( const TSurfaceId* aId, SymbianStreamType* aReturnStream)

    66 	{

    67 	if (aId && !aId->IsNull())

    68 		{

    69         CSurfaceStream* stream=NULL;

    70         if (aId->Type()==TSurfaceId::EStreamHandle)

    71             {

    72             stream=CSurfaceStream::FromHandle(aId);

    73             __ASSERT_DEBUG(stream, Panic(EOwfSymbianStreamBadArgument));

    74             stream->AddReference();

    75             *aReturnStream= stream->ToHandle();

    76             return KErrNone;

    77             }

    78         else

    79             {

    80             TRAPD(err,stream = COpenWfcStreamMap::InstanceL().Find(*aId));

    81             if (stream)

    82                 {

    83                 *aReturnStream = stream->ToHandle();

    84                 return KErrNone;

    85                 }

    86             else

    87                 {

    88                 *aReturnStream = NULL;

    89                 if (err==KErrNone)

    90                     {

    91                     return KErrNotFound;

    92                     }

    93                 else

    94                     {

    95                     return err;

    96                     }

    97                 }

    98             }

    99         }

   100 	else

   101 		{

   102 		*aReturnStream = NULL;

   103 		return KErrBadHandle;

   104 		}	

   105 	}

   106 

   107 EXPORT_C void SymbianStreamAddReference(SymbianStreamType aStream)

   108 	{

   109 	CSurfaceStream*	sstream=CSurfaceStream::FromHandle(aStream);

   110 	if (sstream)

   111 		{

   112 		sstream->AddReference();

   113 		}

   114 	}

   115 

   116 EXPORT_C TErrCode SymbianStreamGetBufferId( SymbianStreamType aStream, 

   117                         SymbianStreamBuffer aBufferHandle, 

   118                         khronos_int32_t* aReturnIndex, 

   119                         const TSurfaceId** aReturnSurface)

   120 	{

   121 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   122     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   123     if (aReturnIndex)

   124         {

   125         *aReturnIndex=stream->BufferHandleToIndex(aBufferHandle);

   126         *aReturnSurface = &stream->SurfaceId();

   127         }

   128     return KErrNone;

   129 	}

   130 

   131 EXPORT_C void SymbianStreamRemoveReference(SymbianStreamType aStream)

   132 	{

   133 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   134     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   135     stream->ReleaseReference();

   136 	}

   137 EXPORT_C void SymbianStreamGetHeader( SymbianStreamType aStream,

   138                             khronos_int32_t* aWidth, 

   139                             khronos_int32_t* aHeight, 

   140                             khronos_int32_t* aStride, 

   141                             khronos_int32_t* aFormat, 

   142                             khronos_int32_t* aPixelSize)

   143 	{

   144 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   145     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   146     stream->GetHeader(aWidth,aHeight,aStride,aFormat,aPixelSize);

   147 	}

   148 

   149 EXPORT_C TErrCode SymbianStreamAcquireReadBuffer( SymbianStreamType aStream, SymbianStreamBuffer* aReturnBuffer)

   150 	{

   151 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   152     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   153     *aReturnBuffer = stream->AcquireReadBuffer();

   154     return KErrNone;

   155 	}

   156 EXPORT_C TErrCode SymbianStreamReleaseReadBuffer( SymbianStreamType aStream, 

   157                                                     SymbianStreamBuffer aBuffer)

   158 	{

   159 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   160     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   161     return stream->ReleaseReadBuffer(aBuffer);

   162 	}

   163 

   164 EXPORT_C TErrCode SymbianStreamAcquireWriteBuffer( SymbianStreamType aStream, SymbianStreamBuffer* aReturnBuffer)

   165 	{

   166 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   167     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   168     *aReturnBuffer = stream->AcquireWriteBuffer();

   169     if (*aReturnBuffer != NULL)

   170         {

   171         return KErrNone;

   172         }

   173     else 

   174         {

   175         return KErrInUse;

   176         }

   177 	}

   178 

   179 EXPORT_C TErrCode SymbianStreamReleaseWriteBuffer( SymbianStreamType aStream, 

   180                                                     SymbianStreamBuffer aBuffer)

   181 	{

   182 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   183     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   184     stream->ReleaseWriteBuffer(aBuffer);

   185     return KErrNone;

   186 	}

   187 

   188 EXPORT_C TErrCode SymbianStreamAddObserver( SymbianStreamType aStream, 

   189                             SymbianStreamCallback aObserver, 

   190                             void* aData)

   191 	{

   192     CSurfaceStream* stream=CSurfaceStream::FromHandle(aStream);

   193     if (stream && aObserver)

   194         {

   195         SYMOWF_DEFAULT_EVENT_PARAM eventPar;

   196         eventPar.length = sizeof(eventPar);

   197         eventPar.event = ESOWF_NoEvent;

   198         aObserver(SYMBIAN_INVALID_HANDLE, ESOWF_ObserverReturnDefaultEvent, NULL, &eventPar);

   199         return stream->AddObserver(aObserver, eventPar.event, KNoAssociatedScreenNumber, aData);

   200         }

   201     return KErrBadHandle;

   202 	}

   203 

   204 EXPORT_C TErrCode SymbianStreamRemoveObserver( SymbianStreamType aStream, 

   205                                                 void* aData, 

   206                                                 SymbianStreamEventBits aEvents)

   207     {

   208     CSurfaceStream* stream = CSurfaceStream::FromHandle(aStream);

   209     if (stream)

   210         {

   211             return stream->RemoveObserver(aEvents, aData);

   212         }

   213     return KErrBadHandle;

   214     }

   215 

   216 

   217 EXPORT_C TErrCode SymbianStreamGetBufferPointer( SymbianStreamType aStream, 

   218                             SymbianStreamBuffer aBuffer,

   219                             void** aReturnPointer)

   220 	{

   221 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   222     __ASSERT_ALWAYS(stream, Panic(EOwfSymbianStreamBadArgument));

   223     *aReturnPointer = NULL;

   224     TRAPD(err,*aReturnPointer = stream->GetBufferPtrL(aBuffer));

   225     return err;

   226 	}

   227 

   228 EXPORT_C void 

   229 SymbianStreamSetProtectionFlag( SymbianStreamType aStream, khronos_bool aFlag)

   230 	{

   231 	CSurfaceStream*	stream=CSurfaceStream::FromHandle(aStream);

   232 	if (stream)

   233 		{

   234 		stream->SetProtectionFlag(aFlag);

   235 		}

   236 	}

   237 

   238 /*!

   239  * \brief Register a screen number for surface update notifications.

   240  *

   241  * \param aScreenNum Screen number.

   242  * 

   243  * 

   244  * \return Standard error code or KErrNone

   245  */

   246 EXPORT_C TErrCode SymbianStreamRegisterScreenNotifications( khronos_int32_t aScreenNumber, 

   247                                             khronos_int32_t aPriority, 

   248                                             khronos_int32_t aInternalVersion)

   249 	{

   250 	khronos_int32_t err2=KErrUnknown;

   251 	TRAPD(err,err2=COpenWfcStreamMap::InstanceL().RegisterScreenNotifications(aScreenNumber,aPriority,aInternalVersion));

   252 	if (err)

   253 		{

   254 		return err;

   255 		}

   256 	else

   257 		{

   258 		return err2;

   259 		}

   260 	}

   261 /*!

   262  * \brief Get handle to registration of a screen number for surface update notifications.

   263  *

   264  * \param aScreenNum Screen number.

   265  * 

   266  * 

   267  * \return Handle to internal object (currently a CBase), or NULL if not registered

   268  */

   269 EXPORT_C TErrCode 

   270 SymbianStreamHasRegisteredScreenNotifications( khronos_int32_t aScreenNumber,void** aReturnState)

   271     {

   272     TRAPD(err,*aReturnState=(COpenWfcStreamMap::InstanceL().RegisteredScreenNotifications(aScreenNumber)));

   273     return err;

   274     }

   275 

   276 

   277 /*!

   278  * \brief Unregister a screen number for surface update notifications.

   279  *

   280  * \param aScreenNum Screen number.

   281  * 

   282  * 

   283  * \return Standard error code or KErrNone

   284  */

   285 EXPORT_C TErrCode 

   286 SymbianStreamUnregisterScreenNotifications(khronos_int32_t aScreenNumber)

   287 	{

   288 	khronos_int32_t err2=KErrUnknown;

   289 	TRAPD(err,err2=COpenWfcStreamMap::InstanceL().UnregisterScreenNotifications(aScreenNumber));

   290 	if (err)

   291 		{

   292 		return err;

   293 		}

   294 	else

   295 		{

   296 		return err2;

   297 		}

   298 	}

   299 

   300 /*!

   301  * \brief Check if two stream objects are the same surface.

   302  *

   303  * \param 	aStream 	compare these two streams.

   304  * \param	aStream2	compare these two streams.

   305  * 

   306  * \return TRUE if they are the same object.

   307  */

   308 EXPORT_C khronos_bool SymbianStreamSame(SymbianStreamType aStream, SymbianStreamType aStream2)

   309 	{

   310 	if  (aStream==aStream2)

   311 		return KHR_BOOLEAN_TRUE;

   312 	if (!aStream || !aStream2)

   313 		return KHR_BOOLEAN_FALSE;

   314 	if (*aStream==*aStream2)

   315 		return KHR_BOOLEAN_TRUE;

   316 	SymbianStreamType found;

   317 	if (	aStream->Type()!=aStream->EStreamHandle

   318 		&&	aStream2->Type()==aStream2->EStreamHandle)

   319 		{

   320 		if(KErrNone==SymbianStreamFind(aStream,&found))

   321 			{

   322 			if  (found==aStream2)

   323 				return KHR_BOOLEAN_TRUE;

   324 			}

   325 		return KHR_BOOLEAN_FALSE;

   326 		}

   327 	if (	aStream2->Type()!=aStream2->EStreamHandle

   328 		&&	aStream->Type()==aStream->EStreamHandle)

   329 		{

   330 		if(KErrNone==SymbianStreamFind(aStream2,&found))

   331 			{

   332 			if  (aStream==found)

   333 				return KHR_BOOLEAN_TRUE;

   334 			}

   335 		return KHR_BOOLEAN_FALSE;

   336 		}

   337 	return KHR_BOOLEAN_FALSE;

   338 	}

   339 

   340 EXPORT_C void

   341 SymbianStreamProcessNotifications(SymbianStreamType aStream, 

   342                                   khronos_int32_t aEvent, 

   343                                   khronos_int32_t aScreenNumber,

   344                                   khronos_int32_t aSerialNumber,

   345                                   khronos_int32_t* aReturnMask)

   346     {

   347     CSurfaceStream* stream = CSurfaceStream::FromHandle(aStream);

   348     if (stream)

   349         {

   350         stream->ProcessNotifications(aEvent, aScreenNumber, CSurfaceStream::EDefaultOperation, aSerialNumber, aReturnMask);

   351         }

   352     }

   353 

   354 EXPORT_C void

   355 SymbianStreamCheckVisible(SymbianStreamType aStream, 

   356                           khronos_int32_t aEvent, 

   357                           khronos_int32_t aScreenNumber,

   358                           khronos_int32_t aSerialNumber)

   359     {

   360     CSurfaceStream* stream = CSurfaceStream::FromHandle(aStream);

   361     if (stream)

   362         {

   363         stream->ProcessNotifications(aEvent, aScreenNumber, CSurfaceStream::ECheckVisibleOperation, aSerialNumber, NULL);

   364         }

   365     }

   366 

   367 EXPORT_C TErrCode 

   368 SymbianStreamAddExtendedObserver(SymbianStreamType aStream, 

   369                                 SymbianStreamCallback aObserver, 

   370                                 void* aData, 

   371                                 khronos_int32_t aScreenNumber, 

   372                                 SymbianStreamEventBits aEvents)

   373     {

   374     CSurfaceStream* stream=CSurfaceStream::FromHandle(aStream);

   375     if (stream && aObserver)

   376         {

   377         TInt ret = KErrNone;

   378         if (!((ret = stream->AddObserver(aObserver, aEvents, aScreenNumber, aData)) == KErrNone) || aEvents != ESOWF_EventUpdated)

   379             {

   380             return ret;

   381             }

   382         if (!((ret = stream->AddObserver(NULL, ESOWF_EventAvailable, aScreenNumber, aData)) == KErrNone))

   383             {

   384             return ret;

   385             }

   386         if (!((ret = stream->AddObserver(NULL, ESOWF_EventDisplayed, aScreenNumber, aData)) == KErrNone))

   387             {

   388             return ret;

   389             }

   390         ret = stream->AddObserver(NULL, ESOWF_EventDisplayedX, aScreenNumber, aData);

   391         return ret;

   392         }

   393     else

   394         {

   395         return KErrArgument;

   396         }

   397     }

   398 

   399 

   400 

   401 EXPORT_C void

   402 SymbianStreamSetFlipState(SymbianStreamType aStream, SymOwfBool aFlip)

   403     {

   404     CSurfaceStream* stream = CSurfaceStream::FromHandle(aStream);

   405     if (stream)

   406         {

   407         stream->SetFlipState(aFlip);

   408         }

   409     }

   410 

   411 EXPORT_C TErrCode

   412 SymbianStreamGetChunkHandle(SymbianStreamType aStream, TInt* aHandle)

   413     {

   414     CSurfaceStream* stream = CSurfaceStream::FromHandle(aStream);

   415     if (stream && aHandle)

   416         {

   417         *aHandle = stream->GetChunkHandle();

   418         return KErrNone;

   419         }

   420     return KErrArgument;

   421     }

   422 

   423 }   //extern "C" helps fix and verify linkage
Symaptic