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 // Implementation of Test class for OpenWfc Native Stream 

    15 // 

    16 //

    17 

    18 #include <graphics/symbianstream.h>

    19 #include <graphics/streammap.h>

    20 #include <graphics/compositionsurfaceupdate.h>

    21 #include <graphics/extensioncontainer.h>

    22 #include <graphics/suerror.h>

    23 #include <test/extendtef.h>

    24 #include <dispchannel.h>

    25 #include <hal.h>

    26 #include "tnativestream.h"

    27 #include "surfaceutility.h"

    28 #include "owftestexithelper.inl"

    29 

    30 #define BUFFER_READ_HANDLE_BASE  0x100

    31 #define BUFFER_WRITE_HANDLE_BASE 0x200

    32 #define INDEX_TO_READ_HANDLE(x)  ((SymbianStreamBuffer) ((x)+BUFFER_READ_HANDLE_BASE))

    33 #define INDEX_TO_WRITE_HANDLE(x)  ((SymbianStreamBuffer) ((x)+BUFFER_WRITE_HANDLE_BASE))

    34 #define BUFFER_READ_HANDLE_TO_INDEX(x)  (TInt) (x > 0 ? (x&0xFF) : (x-BUFFER_READ_HANDLE_BASE))

    35 #define BUFFER_WRITE_HANDLE_TO_INDEX(x)  (TInt) (x > 0 ? (x&0xFF) : (x-BUFFER_WRITE_HANDLE_BASE))

    36 #define WFC_INVALID_HANDLE NULL

    37 #define KGrowCleanupStack   12

    38 #define KCompositorVersion 0x01023456

    39 #define KCompositorVersionMajor 0x1

    40 #define KCompositorVersionMinor 0x2

    41 #define KCompositorVersionRevision 0x3456

    42 

    43 void PopHeap(void* aHeapPtr)

    44     {

    45     User::SwitchHeap((RHeap*)aHeapPtr);

    46     }

    47 

    48 void GrowCleanupStackL()

    49     {

    50     TInt n = KGrowCleanupStack;

    51     while(n--)

    52         {

    53         CleanupStack::PushL((CBase*)NULL);

    54         }

    55     CleanupStack::Pop(KGrowCleanupStack);

    56     }

    57 

    58 // Helper functions

    59 /* supported external image formats */

    60 enum OWF_PIXEL_FORMAT   {

    61     OWF_IMAGE_NOT_SUPPORTED = 0,

    62     OWF_IMAGE_ARGB8888      = 0x8888,

    63     OWF_IMAGE_XRGB8888      = 0xf888,

    64     OWF_IMAGE_RGB888        = 0x888,

    65     OWF_IMAGE_RGB565        = 0x565,

    66     OWF_IMAGE_L32           = 0xA32,

    67     OWF_IMAGE_L16           = 0xA16,

    68     OWF_IMAGE_L8            = 0xA8,

    69     OWF_IMAGE_L1            = 0xA1,

    70     OWF_IMAGE_ARGB_INTERNAL = 0x666 /* OWFpixel rep */

    71 } ;

    72 

    73 struct CTestNativeStream::OWF_IMAGE_FORMAT{

    74     OWF_PIXEL_FORMAT        pixelFormat;

    75     bool              linear;

    76     bool              premultiplied;

    77     int                  rowPadding; /* row alignment, in bytes */

    78 } ;

    79 

    80 TInt CTestNativeStream::BytesPerPixel(TUidPixelFormat aPixelFormat)

    81     {

    82     switch (aPixelFormat)

    83         {

    84         case EUidPixelFormatXRGB_8888:

    85         case EUidPixelFormatARGB_8888:

    86         case EUidPixelFormatBGRX_8888:

    87         case EUidPixelFormatXBGR_8888:

    88         case EUidPixelFormatBGRA_8888:

    89         case EUidPixelFormatABGR_8888:  

    90         case EUidPixelFormatABGR_8888_PRE:

    91         case EUidPixelFormatARGB_8888_PRE:

    92         case EUidPixelFormatBGRA_8888_PRE:

    93         case EUidPixelFormatARGB_2101010:

    94         case EUidPixelFormatABGR_2101010:

    95             return 4;

    96         case EUidPixelFormatBGR_888:

    97         case EUidPixelFormatRGB_888:

    98             return 3;

    99         case EUidPixelFormatXRGB_4444:

   100         case EUidPixelFormatARGB_4444:

   101         case EUidPixelFormatXBGR_4444:

   102         case EUidPixelFormatRGB_565:

   103         case EUidPixelFormatBGR_565:

   104         case EUidPixelFormatARGB_1555:

   105         case EUidPixelFormatXRGB_1555:

   106         case EUidPixelFormatARGB_8332:

   107         case EUidPixelFormatBGRX_5551:

   108         case EUidPixelFormatBGRA_5551:

   109         case EUidPixelFormatBGRA_4444:

   110         case EUidPixelFormatBGRX_4444:

   111         case EUidPixelFormatAP_88:

   112             return  2;

   113         case EUidPixelFormatRGB_332:

   114         case EUidPixelFormatBGR_332:

   115         case EUidPixelFormatA_8:

   116         case EUidPixelFormatL_8:

   117             return  1;

   118         case EUidPixelFormatP_8:

   119             return -1;

   120         case EUidPixelFormatP_4:

   121         case EUidPixelFormatL_4:

   122             return -2;

   123         case EUidPixelFormatL_2:

   124         case EUidPixelFormatP_2:

   125             return -4;

   126         case EUidPixelFormatL_1 :

   127             return -8;

   128         default:

   129             {

   130             return 0;

   131             }

   132         }

   133     }

   134 

   135 /*****************************************

   136  * Helper Creates Surface from OWF spec 

   137  * 

   138  *

   139  */

   140 TSurfaceId CTestNativeStream::helperCreateSurfaceL(khronos_int32_t width,

   141         khronos_int32_t height,

   142         const OWF_IMAGE_FORMAT*   format,

   143         khronos_int32_t nbufs,

   144         TUidPixelFormat overridePixelFormat)

   145 	{

   146 	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

   147 	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

   148 	

   149 	TBool premultiplied = format->premultiplied;

   150 	OWF_PIXEL_FORMAT pixelFormat = format->pixelFormat;

   151 	khronos_int32_t bytesPerPixel = 0;

   152 	

   153 	if (overridePixelFormat != EUidPixelFormatUnknown)

   154 	    {

   155         bytesPerPixel = BytesPerPixel(overridePixelFormat);

   156         b.iAlignment = 4;

   157         b.iPixelFormat = overridePixelFormat;

   158 	    }

   159 	else

   160 	    {

   161         switch(pixelFormat)

   162             {

   163             case OWF_IMAGE_RGB565:

   164                 b.iPixelFormat = EUidPixelFormatRGB_565;

   165                 bytesPerPixel = 2;

   166                 b.iAlignment = 4;

   167                 break;

   168             case OWF_IMAGE_ARGB8888:

   169                 {

   170                 if (premultiplied)

   171                     {

   172                     b.iPixelFormat = EUidPixelFormatARGB_8888_PRE;

   173                     }

   174                 else

   175                     {

   176                     b.iPixelFormat = EUidPixelFormatARGB_8888;

   177                     }

   178                 bytesPerPixel = 4;

   179                 b.iAlignment = 4;

   180                 break;

   181                 }

   182             case OWF_IMAGE_XRGB8888 :

   183                 b.iPixelFormat = EUidPixelFormatXRGB_8888;

   184                 bytesPerPixel = 4;

   185                 b.iAlignment = 4;

   186                 break;

   187             case OWF_IMAGE_L8 :

   188                 b.iPixelFormat = EUidPixelFormatA_8;

   189                 bytesPerPixel = 1;

   190                 b.iAlignment = 4;

   191                 break;

   192             case OWF_IMAGE_L1 :

   193                 b.iPixelFormat = EUidPixelFormatL_1;

   194                 bytesPerPixel = -8;

   195                 b.iAlignment = 4;

   196                 break;

   197             default:

   198                 User::Leave(KErrNotSupported);	

   199                 break;

   200             }

   201 	    }

   202 	

   203 	b.iSize.iWidth = width;

   204 	b.iSize.iHeight = height;

   205 	b.iBuffers = nbufs;								// number of buffers in the surface

   206 	b.iOffsetToFirstBuffer = 0;						// way of reserving space before the surface pixel data

   207 	if (bytesPerPixel >= 0)

   208 	    {

   209 	    b.iStride = bytesPerPixel * width;	// number of bytes between start of one line and start of next	

   210 	    }

   211 	else

   212 	    {

   213 	    b.iStride = (width-(bytesPerPixel+1)) / (-bytesPerPixel);

   214 	    }

   215 	b.iContiguous = EFalse;

   216 	b.iMappable = ETrue;

   217 	

   218 	TSurfaceId surface = TSurfaceId::CreateNullId();

   219 	User::LeaveIfError(iUtility->Manager().CreateSurface(bf, surface));

   220 	

   221 	return surface;

   222 	}

   223 

   224 SymbianStreamType CTestNativeStream::helperCreateImageStream(khronos_int32_t width,

   225                                  khronos_int32_t height,

   226                                  const OWF_IMAGE_FORMAT*  format,

   227                                  khronos_int32_t nbufs,

   228                                  TUidPixelFormat overridePixelFormat)

   229 	{

   230 	TSurfaceId surface;

   231 	

   232 	TRAPD(err,surface = helperCreateSurfaceL(width, height, format, nbufs, overridePixelFormat));

   233 	if (err)

   234 	    {

   235 	    return WFC_INVALID_HANDLE;

   236 	    }

   237 	SymbianStreamType ns;

   238 	SymbianStreamAcquire(&surface, &ns);

   239 	

   240 	iUtility->Manager().CloseSurface(surface);

   241 	

   242 	return ns;

   243 	}

   244 

   245 RSemaphore      gSemaphore;

   246 

   247 TGlobalNativeStreamVar	gVarInstance={0};

   248 const TGlobalNativeStreamVar& TGlobalNativeStreamVar::Instance()

   249 	{

   250 	return gVarInstance;

   251 	}

   252 

   253 void TGlobalNativeStreamVar::SetSurfaceID(TSurfaceId aSurfaceID)

   254     {

   255     iSurfaceID = aSurfaceID;

   256     }

   257 

   258 void TGlobalNativeStreamVar::SetTestComplete(TBool aTestComplete)

   259     {

   260     iTestComplete = aTestComplete;

   261     }

   262 

   263 void TGlobalNativeStreamVar::SetBuffers(TInt aBuffers)

   264     {

   265     iBuffers = aBuffers;

   266     }

   267 

   268 TSurfaceId TGlobalNativeStreamVar::SurfaceID() const

   269     {

   270     return iSurfaceID;

   271     }

   272 

   273 TBool TGlobalNativeStreamVar::TestComplete() const

   274     {

   275     return iTestComplete;

   276     }

   277 

   278 TInt TGlobalNativeStreamVar::Buffers() const

   279     {

   280     return iBuffers;

   281     }

   282 

   283 /*

   284  * CTestNativeStream implementation

   285  * 

   286  * 

   287  * 

   288  * 

   289  */

   290 

   291 CTestNativeStream::CTestNativeStream(): iUtility(this)

   292 	{

   293 	// No implementation required

   294 	}

   295 

   296 CTestNativeStream::~CTestNativeStream()

   297 	{

   298 	DeleteOwfSingletons();

   299 	}

   300 

   301 void CTestNativeStream::SetupL()

   302 	{

   303 	TRAPD(err_FailedToCreateSurfaceUtility, iUtility = CSurfaceUtility::NewL( NULL ));

   304 	ASSERT_EQUALS(err_FailedToCreateSurfaceUtility,KErrNone);

   305 	DefineOwfSingletonKeys();

   306 	}

   307 

   308 /**

   309  * test Suite furniture 

   310  **/

   311 void CTestNativeStream::TearDownL()

   312 	{

   313 	delete iUtility();

   314 	}

   315 

   316 /**

   317 WFC context callback function invoked by native stream when the stream's content

   318 is updated. For testing, we simply call a class member function that checks that the

   319 correct native stream handle and events mask were supplied.

   320 */

   321 void CTestNativeStream::SourceStreamUpdatedCallback(

   322         SymbianStreamType aNs, khronos_int32_t aEvents, void* aData, void* aParam)

   323     {

   324     (void)aData;

   325     if (aEvents == ESOWF_ObserverReturnDefaultEvent && aParam)

   326         {

   327         SYMOWF_DEFAULT_EVENT_PARAM* parameter = (SYMOWF_DEFAULT_EVENT_PARAM*) aParam;

   328         if ((parameter->length) == sizeof(SYMOWF_DEFAULT_EVENT_PARAM))

   329             {

   330             parameter->event = ESOWF_EventUpdated;

   331             }

   332         return;

   333         }

   334         

   335     ASSERT(CTestNativeStream::iTester);

   336     CTestNativeStream::iTester->CheckSourceStreamUpdated(aNs, aParam);

   337     }

   338 

   339 void CTestNativeStream::CheckSourceStreamUpdated(SymbianStreamType aNs, void* aParam)

   340     {

   341     RHeap *h1 = &(User::Heap());

   342     if (aParam)

   343         {

   344         ASSERT_EQUALS(iNs, aNs);

   345         SYMOWF_CONTENT_UPDATED_PARAM* param = (SYMOWF_CONTENT_UPDATED_PARAM*) aParam;

   346         ASSERT_TRUE(param->id == SYM_CONTENT_UPDATE_BEGIN || 

   347                     param->id == SYM_CONTENT_UPDATE_END ||

   348                     param->id == SYM_CONTENT_UPDATE);

   349 

   350         iSourceStreamUpdatedCalled++;

   351         iStreamUpdatedParameter = param->id; 

   352         switch(param->id)

   353             {

   354             case SYM_CONTENT_UPDATE_BEGIN:

   355                 param->immediateAvailable = iImmediateAvailable;

   356                 param->immediateVisibility = iImmediateVisible;

   357                 param->serialNumber = iStreamUpdatedSerialNumber;

   358                 break;

   359                 

   360             case SYM_CONTENT_UPDATE:

   361             case SYM_CONTENT_UPDATE_END:

   362                 ASSERT_EQUALS(iExpectedSourceStreamUpdatedEventMask, param->par);        

   363                 iContextUpdatedFlags |= param->par & (~ESOWF_EventUpdated);    

   364                 break;

   365             default:

   366                 break;

   367             }

   368         }

   369     else

   370         {

   371         iSourceStreamUpdatedCalled++;

   372         }

   373         

   374     }

   375 

   376 /**

   377 Remove the native stream notifications. The creator of the source is responsible

   378 for destroying the native stream. 

   379 

   380 Now with the new SymbianStreamRemoveObserver function we need to pass in an observer

   381 */

   382 void CTestNativeStream::RemoveNsNotifications()

   383     {

   384     SymbianStreamRemoveObserver(iNs, &iScreenNo, ESOWF_EventAvailable);

   385     SymbianStreamRemoveObserver(iNs, &iScreenNo, ESOWF_EventDisplayed);

   386     SymbianStreamRemoveObserver(iNs, &iScreenNo, ESOWF_EventDisplayedX);

   387     }

   388 

   389 CTestNativeStream* CTestNativeStream::iTester = NULL;

   390 

   391 // Create a suite of all the tests

   392 CTestSuite* CTestNativeStream::CreateSuiteL(const TDesC& aName)

   393 	{

   394 	SymbianStreamRegisterScreenNotifications(0, 10, KCompositorVersion);

   395 	SUB_SUITE_OPT(CTestNativeStream,NULL);

   396 

   397 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0100L);

   398 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0101L);

   399 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0102L);

   400 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0103L);

   401 		

   402 		// Test with 1, 2 and 3 buffers

   403 		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0104L,1,4);

   404 		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0105L,1,4);

   405 		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0106L,1,4);

   406 		

   407 		// Concurrent tests

   408 		ADD_TEST_STEP_PARAM_RANGE(CreateSharedNativeStreamL,1,4);

   409 		ADD_THIS_TEST_STEP(DestroySharedNativeStreamL);

   410 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0107_1L);

   411 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0107_2L);

   412 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0107_3L);

   413 		

   414 		// Test SUS with OpenWF pipeline

   415 		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0108L, 1, 4);

   416 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0109L);

   417 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0110L);

   418 		

   419 		// Test various cases for Native Stream callbacks

   420 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0111L);

   421 		// Test multithreaded cases for Native Stream callbacks

   422 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_1L);

   423 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_2L);

   424 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_3L);

   425 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_4L);

   426 		

   427 		// Notification tests

   428 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0113L);

   429 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0114L);

   430 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0115L);

   431 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0116L);

   432 		

   433 		// Notification cancel

   434 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_1L);

   435 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_2L);

   436 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_3L);

   437 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_4L);

   438 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_1L);

   439 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_2L);

   440 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_3L);

   441 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_4L);

   442 		

   443 		// Notification overflow

   444 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0119_1L);

   445 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0119_2L);

   446 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0119_3L);

   447 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0120_1L);

   448 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0120_2L);

   449 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0120_3L);

   450 		

   451 		// Notifications cancelled due to removal of source observer

   452 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0122L);

   453 		

   454 		// Sym native stream add/remove observers

   455 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0130L);

   456 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0131L);

   457 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0132L);

   458 		

   459 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0133L);

   460 

   461 		// Test with 1, 2 and 3 buffers

   462 		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0140L,1,4);

   463 		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0141L,1,4);

   464 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0142L);

   465 

   466 	END_SUITE;	

   467 	

   468 	}

   469 

   470 // This handles any non-member uses of the extended ASSERT_XXX macros

   471 void TefUnitFailLeaveL()

   472 	{

   473 	User::Leave(KErrTEFUnitFail);

   474 	}

   475 

   476 SymbianStreamType CTestNativeStream::NsCheckL(const TSurfaceId aId, TInt aCheck, TBool aFind)

   477 	{

   478 	// Acquire (create OR find) the stream

   479 	SymbianStreamType ns = NULL;

   480 	TInt err;

   481 	if (aFind)

   482 		{

   483 		err = (TInt)SymbianStreamFind(&aId, &ns);

   484 		}

   485 	else

   486 		{

   487 		err = SymbianStreamAcquire(&aId, &ns);

   488 		}

   489 	ASSERT_TRUE(err == KErrNone);

   490 	// Check the hash map count

   491 	ASSERT_EQUALS((COpenWfcStreamMap::InstanceL().Count()), aCheck);

   492     SymbianStreamBuffer bufferHandle;

   493     err = SymbianStreamAcquireReadBuffer(ns,&bufferHandle);

   494     ASSERT_TRUE(err == KErrNone);

   495     long bufferIndex;

   496     const TSurfaceId* checkId = NULL;

   497     err = SymbianStreamGetBufferId(ns,bufferHandle,&bufferIndex,&checkId);

   498     ASSERT_TRUE(err == KErrNone);

   499     SymbianStreamReleaseReadBuffer(ns,bufferHandle);

   500 	ASSERT_NOT_NULL(checkId);

   501 	ASSERT_EQUALS(*checkId, aId);

   502 	return ns;

   503 	}

   504 

   505 void CTestNativeStream::CreateSharedNativeStreamL(TInt aBuffers)

   506 	{

   507     RHeap* mainHeap = COpenWfcStreamMap::InstanceL().GetMainHeap();

   508     GrowCleanupStackL();

   509     

   510 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   511 	

   512 	gVarInstance.SetTestComplete(EFalse);

   513 	gVarInstance.SetBuffers(aBuffers);

   514 	

   515 	TSize surfaceSize(TSize(100,100));

   516 	khronos_int32_t width = surfaceSize.iWidth;

   517 	khronos_int32_t height = surfaceSize.iHeight;

   518 	

   519 	OWF_IMAGE_FORMAT pixelFormat =

   520 		{

   521 		OWF_IMAGE_ARGB8888,

   522 		ETrue,

   523 		ETrue,

   524 		4

   525 		};	

   526 	

   527 	// Create the first stream

   528 	SymbianStreamType ns=helperCreateImageStream(width,

   529 													height,

   530 													&pixelFormat,

   531 													aBuffers);

   532 	ASSERT_TRUE(ns);

   533 	

   534     SymbianStreamBuffer bufferHandle;

   535     SymbianStreamAcquireReadBuffer(ns,&bufferHandle);

   536     long bufferIndex;

   537     const TSurfaceId* checkId = NULL;

   538     TInt err = SymbianStreamGetBufferId(ns,bufferHandle,&bufferIndex,&checkId);

   539     ASSERT_TRUE(err == KErrNone);

   540     SymbianStreamReleaseReadBuffer(ns,bufferHandle);

   541 	gVarInstance.SetSurfaceID(*checkId);

   542     gSemaphore.CreateLocal(1);

   543     gSemaphore.Wait(); 

   544     CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   545 	}

   546 

   547 void CTestNativeStream::DestroySharedNativeStreamL()

   548 	{

   549 	GrowCleanupStackL();

   550 	

   551 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(COpenWfcStreamMap::InstanceL().GetMainHeap())));

   552 	

   553 	gSemaphore.Close();

   554 	TSurfaceId id = gVarInstance.SurfaceID();

   555 	SymbianStreamType ns;

   556 	TInt err = SymbianStreamFind(&id,&ns);

   557 	ASSERT_TRUE(err == KErrNone);

   558 	ASSERT_TRUE(ns);

   559 	// Decrease stream's reference count by one. This removes reference added by owfNativeStreamFind()

   560 	SymbianStreamRemoveReference(ns);

   561 	// Decrease stream's reference count by one to make reference count zero, and destroy the stream

   562 	SymbianStreamRemoveReference(ns);

   563 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   564 	}

   565 

   566 // Test observers

   567 void TestUpdateCallback(SymbianStreamType aStream, khronos_int32_t aEvent, void* aData, void* aParam)

   568     {

   569     (void) aStream;

   570     switch (aEvent)

   571         {

   572         case ESOWF_ObserverReturnDefaultEvent:

   573             if (aParam)

   574                 {

   575                 SYMOWF_DEFAULT_EVENT_PARAM* parameter = (SYMOWF_DEFAULT_EVENT_PARAM*) aParam;

   576                 if ((parameter->length) == sizeof(SYMOWF_DEFAULT_EVENT_PARAM))

   577                     {

   578                     parameter->event = ESOWF_EventUpdated;

   579                     }

   580                 }

   581             return;

   582             

   583         case ESOWF_EventUpdated:

   584             {

   585             TInt* localNumber = (TInt*)aData;

   586              ++(*localNumber);

   587             }

   588             break;

   589         default:

   590             break;

   591         }

   592     }

   593 

   594 // Test compose target

   595 void TestComposedCallback(SymbianStreamType aStream, khronos_int32_t aEvent, void* aData, void* aParam)

   596     {

   597     (void) aStream;

   598     switch (aEvent)

   599         {

   600         case ESOWF_ObserverReturnDefaultEvent:

   601             if (aParam)

   602                 {

   603                 SYMOWF_DEFAULT_EVENT_PARAM* parameter = (SYMOWF_DEFAULT_EVENT_PARAM*) aParam;

   604                 if ((parameter->length) == sizeof(SYMOWF_DEFAULT_EVENT_PARAM))

   605                     {

   606                     parameter->event = ESOWF_EventComposed;

   607                     }

   608                 }

   609             return;

   610             

   611         case ESOWF_EventComposed:

   612             {

   613             TInt* localNumber = (TInt*)aData;

   614              ++(*localNumber);

   615             }

   616             break;

   617         default:

   618             break;

   619         }

   620     }

   621 

   622 /**

   623 @SYMTestCaseID			GFX_OPENWFC_NATIVESTREAM_0100

   624 @SYMTestCaseDesc		Create a native stream using SymbianStreamAcquire()

   625 @SYMREQ					

   626 @SYMPREQ				PREQ2400

   627 @SYMTestType			CT

   628 @SYMTestPriority		

   629 @SYMTestPurpose			Verify native stream objects can be created and persist unique surface ID values

   630 @SYMTestActions	

   631 		Create two surfaces,

   632 		Create two streams from the surfaces

   633 		Read back the surface Ids from the streams

   634 @SYMTestExpectedResults

   635 		The surface IDs should be non-null and unique

   636 		The streams should be non-null and unique

   637 		The returned surface Ids should match the constructed IDs

   638  **/		

   639 void CTestNativeStream::GRAPHICS_OPENWFC_NATIVESTREAM_0100L()

   640 	{

   641 	RHeap* mainHeap = COpenWfcStreamMap::InstanceL().GetMainHeap();

   642 	TRAPD(err, GrowCleanupStackL());

   643 	ASSERT_TRUE(err == KErrNone);

   644 	

   645 	TInt count = COpenWfcStreamMap::InstanceL().Count();

   646 	TSurfaceId surface=iUtility->CreateSurfaceL(TSize(100,100),EUidPixelFormatARGB_8888_PRE,400,2);

   647 	ASSERT_FALSE(surface.IsNull());

   648 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   649 	SymbianStreamType ns;

   650 	err = SymbianStreamAcquire(&surface, &ns);

   651 	ASSERT_TRUE(err == KErrNone);

   652     SymbianStreamBuffer bufferHandle;

   653     err = SymbianStreamAcquireReadBuffer(ns, &bufferHandle);

   654     ASSERT_TRUE(err == KErrNone);

   655     long bufferIndex;

   656     const TSurfaceId* getId = NULL;

   657     err = SymbianStreamGetBufferId(ns,bufferHandle,&bufferIndex,&getId);

   658     ASSERT_TRUE(err == KErrNone);

   659     err = SymbianStreamReleaseReadBuffer(ns,bufferHandle);

   660     ASSERT_TRUE(err == KErrNone);

   661 	ASSERT_EQUALS(*getId,surface);

   662 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   663 	

   664 	TSurfaceId surface2=iUtility->CreateSurfaceL(TSize(100,100),EUidPixelFormatARGB_8888_PRE,400,2);

   665 	ASSERT_FALSE(surface2.IsNull());

   666 	ASSERT_NOT_EQUALS(surface,surface2);

   667 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   668 	SymbianStreamType ns2;

   669 	err = SymbianStreamAcquire(&surface2,&ns2);

   670 	ASSERT_TRUE(err == KErrNone);

   671 	ASSERT_TRUE(ns2);

   672 	ASSERT_NOT_EQUALS(ns,ns2);

   673 	ASSERT_EQUALS((COpenWfcStreamMap::InstanceL().Count()), count + 2);

   674 	err = SymbianStreamAcquireReadBuffer(ns2,&bufferHandle);

   675 	ASSERT_TRUE(err == KErrNone);

   676     const TSurfaceId* getId2 = NULL;

   677     err = SymbianStreamGetBufferId(ns2,bufferHandle,&bufferIndex,&getId2);

   678     ASSERT_TRUE(err == KErrNone);

   679     err = SymbianStreamReleaseReadBuffer(ns2,bufferHandle);

   680     ASSERT_TRUE(err == KErrNone);

   681 	ASSERT_NOT_NULL(getId2);

   682 	ASSERT_EQUALS(*getId2,surface2);

   683 	

   684 	SymbianStreamRemoveReference(ns);

   685 	ASSERT_EQUALS((COpenWfcStreamMap::InstanceL().Count()), count + 1);

   686 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   687 	iUtility->DestroySurface(surface);

   688 	

   689 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   690 	SymbianStreamRemoveReference(ns2);

   691 	ASSERT_EQUALS((COpenWfcStreamMap::InstanceL().Count()), count);

   692 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   693 	iUtility->DestroySurface(surface2);

   694 	}

   695 

   696 /**

   697 @SYMTestCaseID			GFX_OPENWFC_NATIVESTREAM_0101

   698 @SYMTestCaseDesc		Create a native stream using SymbianStreamCreateImageStream()

   699 @SYMREQ					

   700 @SYMPREQ				PREQ2400

   701 @SYMTestType			CT

   702 @SYMTestPriority		

   703 @SYMTestPurpose			Verify native stream objects can be created and persist unique surface ID values

   704 @SYMTestActions	

   705 		Create two streams from the parameters passed in

   706 		Read back the surface Ids from the streams

   707 @SYMTestExpectedResults

   708 		The surface IDs should be non-null and unique

   709 		The streams should be non-null and unique

   710  **/

   711 void CTestNativeStream::GRAPHICS_OPENWFC_NATIVESTREAM_0101L()

   712 	{

   713 	RHeap* mainHeap = COpenWfcStreamMap::InstanceL().GetMainHeap();

   714 	TRAPD(err, GrowCleanupStackL());

   715 	ASSERT_TRUE(err == KErrNone);

   716 	

   717 	TSize surfaceSize(TSize(100,100));

   718 	TInt width = surfaceSize.iWidth;

   719 	TInt height = surfaceSize.iHeight;

   720 	TInt buffers = 2;

   721 

   722 	OWF_IMAGE_FORMAT pixelFormat =

   723 		{

   724 		OWF_IMAGE_ARGB8888,

   725 	    ETrue,

   726 	    ETrue,

   727 	    4

   728 	    };	

   729 	

   730 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   731 	

   732 	// Create the first stream

   733 	SymbianStreamType ns=helperCreateImageStream(width,

   734 													height,

   735 													&pixelFormat,

   736 													buffers);

   737 	ASSERT_TRUE(ns);

   738     SymbianStreamBuffer bufferHandle;

   739     err = SymbianStreamAcquireReadBuffer(ns,&bufferHandle);

   740     ASSERT_TRUE(err == KErrNone);

   741     long bufferIndex;

   742     const TSurfaceId* getId = NULL;

   743     err = SymbianStreamGetBufferId(ns,bufferHandle,&bufferIndex,&getId);

   744     ASSERT_TRUE(err == KErrNone);

   745     err = SymbianStreamReleaseReadBuffer(ns,bufferHandle);

   746     ASSERT_TRUE(err == KErrNone);

   747 	

   748 	// Create the second stream

   749 	SymbianStreamType ns2=helperCreateImageStream(width,

   750 													height,

   751 													&pixelFormat,

   752 													buffers);

   753 	ASSERT_TRUE(ns2);

   754 	

   755     err = SymbianStreamAcquireReadBuffer(ns2,&bufferHandle);

   756     ASSERT_TRUE(err == KErrNone);

   757     const TSurfaceId* getId2 = NULL;

   758     err = SymbianStreamGetBufferId(ns2,bufferHandle,&bufferIndex,&getId2);

   759     ASSERT_TRUE(err == KErrNone);

   760     err = SymbianStreamReleaseReadBuffer(ns2,bufferHandle);

   761     ASSERT_TRUE(err == KErrNone);

   762 	ASSERT_NOT_NULL(getId2);

   763 	

   764 	ASSERT_NOT_EQUALS(ns,ns2);

   765 	ASSERT_NOT_EQUALS(getId,getId2);

   766 	

   767 	SymbianStreamRemoveReference(ns);

   768 	SymbianStreamRemoveReference(ns2);

   769 	

   770 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   771 	}

   772 

   773 /**

   774 @SYMTestCaseID			GFX_OPENWFC_NATIVESTREAM_0102

   775 @SYMTestCaseDesc		Create a native stream 2

   776 @SYMREQ					

   777 @SYMPREQ				PREQ2400

   778 @SYMTestType			CT

   779 @SYMTestPriority		

   780 @SYMTestPurpose			Verify native stream objects can be created and persist unique surface ID values

   781 @SYMTestActions	

   782 		Create two surfaces,

   783 		Create two streams from the surfaces

   784 		Read back the surface Ids from the streams

   785 		Acquire multiple time the native streams

   786 		Find native streams

   787 @SYMTestExpectedResults

   788 		The surface IDs should be non-null and unique

   789 		The streams should be non-null and unique

   790 		The returned surface Ids should match the constructed IDs

   791 		The hash map counter should be updated accordingly when native streams are created or destroyed

   792  **/		

   793 void CTestNativeStream::GRAPHICS_OPENWFC_NATIVESTREAM_0102L()

   794 	{

   795 	RHeap* mainHeap = COpenWfcStreamMap::InstanceL().GetMainHeap();

   796 	TRAPD(err, GrowCleanupStackL());

   797 	ASSERT_TRUE(err == KErrNone);

   798 	

   799 	COpenWfcStreamMap& singleton = COpenWfcStreamMap::InstanceL();

   800 	TInt check = COpenWfcStreamMap::InstanceL().Count() + 1;

   801 	// Create the first surface

   802 	TSurfaceId surfaceId1 = iUtility->CreateSurfaceL(TSize(100, 100), EUidPixelFormatARGB_8888_PRE, 400, 2);

   803 	ASSERT_FALSE(surfaceId1.IsNull());

   804 	

   805 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   806 	SymbianStreamType ns1 = NsCheckL(surfaceId1, check, EFalse);

   807 	

   808 	TSurfaceId surfaceId2;

   809 	surfaceId2.CreateNullId();

   810 	SymbianStreamType ns2;

   811 	err = SymbianStreamFind(&surfaceId2,&ns2);

   812 	ASSERT_TRUE(err == KErrNotFound);

   813 	ASSERT_FALSE(ns2);

   814 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   815 	

   816 	// Create the second surface

   817 	surfaceId2 = iUtility->CreateSurfaceL(TSize(100, 100), EUidPixelFormatARGB_8888_PRE, 400, 2);

   818 	ASSERT_FALSE(surfaceId2.IsNull()); 

   819 	

   820 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   821 	err = SymbianStreamFind(&surfaceId2,&ns2);

   822 	ASSERT_TRUE(err == KErrNotFound);

   823 	ASSERT_FALSE(ns2);

   824 	

   825 	ns2 = NsCheckL(surfaceId2, ++check, EFalse);

   826 	

   827 	NsCheckL(surfaceId1, check, EFalse);

   828 	

   829 	NsCheckL(surfaceId1, check, ETrue);

   830 	

   831 	NsCheckL(surfaceId2, check, ETrue);

   832 	

   833 	SymbianStreamRemoveReference(ns1);

   834 	ASSERT_EQUALS((singleton.Count()), check);

   835 	

   836 	SymbianStreamRemoveReference(ns2);

   837 	ASSERT_EQUALS((singleton.Count()), check);

   838 	

   839 	SymbianStreamRemoveReference(ns2);

   840 	ASSERT_EQUALS((singleton.Count()), --check);

   841 

   842 	SymbianStreamRemoveReference(ns1);

   843 	ASSERT_EQUALS((singleton.Count()), check);

   844 	

   845 	SymbianStreamRemoveReference(ns1);

   846 	ASSERT_EQUALS((singleton.Count()), --check);

   847 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   848 	

   849 	iUtility->DestroySurface(surfaceId1);

   850 	iUtility->DestroySurface(surfaceId2);

   851 	

   852 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

   853 	err = SymbianStreamFind(&surfaceId2,&ns2);

   854 	ASSERT_TRUE(err == KErrNotFound);

   855 	ASSERT_FALSE(ns2);

   856 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

   857 	}

   858 

   859 struct SupportedFormats

   860     {

   861     TUidPixelFormat symbianPixelFormat;

   862     } supportedFormats[]=

   863     {

   864         EUidPixelFormatXRGB_8888,

   865         EUidPixelFormatARGB_8888,

   866         EUidPixelFormatBGRX_8888,

   867         EUidPixelFormatXBGR_8888,

   868         EUidPixelFormatBGRA_8888,

   869         EUidPixelFormatABGR_8888, 

   870         EUidPixelFormatABGR_8888_PRE,

   871         EUidPixelFormatARGB_8888_PRE,

   872         EUidPixelFormatBGRA_8888_PRE,

   873         EUidPixelFormatARGB_2101010,

   874         EUidPixelFormatABGR_2101010,

   875         EUidPixelFormatBGR_888,

   876         EUidPixelFormatRGB_888,

   877         EUidPixelFormatXRGB_4444,

   878         EUidPixelFormatARGB_4444,

   879         EUidPixelFormatXBGR_4444,

   880         EUidPixelFormatRGB_565,

   881         EUidPixelFormatBGR_565,

   882         EUidPixelFormatARGB_1555,

   883         EUidPixelFormatXRGB_1555,

   884         EUidPixelFormatARGB_8332,

   885         EUidPixelFormatBGRX_5551,

   886         EUidPixelFormatBGRA_5551,

   887         EUidPixelFormatBGRA_4444,

   888         EUidPixelFormatBGRX_4444,

   889         EUidPixelFormatAP_88,

   890         EUidPixelFormatRGB_332,

   891         EUidPixelFormatBGR_332,

   892         EUidPixelFormatA_8,

   893         EUidPixelFormatL_8,

   894         EUidPixelFormatP_8,

   895         EUidPixelFormatP_4,

   896         EUidPixelFormatL_4,

   897         EUidPixelFormatL_2,

   898         EUidPixelFormatP_2,

   899         EUidPixelFormatL_1

   900     };

   901 

   902 /**

   903 @SYMTestCaseID			GFX_OPENWFC_NATIVESTREAM_0103

   904 @SYMTestCaseDesc		Retrieve stream attributes using SymbianStreamGetHeader()

   905 @SYMREQ					

   906 @SYMPREQ				PREQ2400

   907 @SYMTestType			CT

   908 @SYMTestPriority		

   909 @SYMTestPurpose			Verify native stream object attributes can be retrieved.

   910 @SYMTestActions	

   911 		Create a native stream based on a supported image/pixel format

   912 		Retrieve all of the stream attributes

   913 		Retreive none of the stream attributes

   914 @SYMTestExpectedResults

   915 		The retrieved attributes should match the parameters used to create the surface stream

   916 		Retrieving no attributes should not cause a crash

   917  **/

   918 void CTestNativeStream::GRAPHICS_OPENWFC_NATIVESTREAM_0103L()

   919 	{

   920 	// Native stream attributes

   921     TSize surfaceSize(TSize(100,50));

   922     khronos_int32_t width = surfaceSize.iWidth;

   923     khronos_int32_t height = surfaceSize.iHeight;

   924     khronos_int32_t numBuffers = 2;

   925     

   926     for (TInt x=0; x<sizeof(supportedFormats)/sizeof(supportedFormats[0]); x++)

   927         {

   928         INFO_PRINTF2(_L("Pixel format %x"),supportedFormats[x]);

   929         khronos_int32_t streamPixelSize = BytesPerPixel(supportedFormats[x].symbianPixelFormat);

   930         

   931         OWF_IMAGE_FORMAT pixelFormat =

   932             {

   933             OWF_IMAGE_NOT_SUPPORTED,

   934             EFalse,

   935             EFalse,

   936             2

   937             };  

   938         

   939         SymbianStreamType ns=helperCreateImageStream(width,

   940                                                      height,

   941                                                      &pixelFormat,

   942                                                      numBuffers,

   943                                                      supportedFormats[x].symbianPixelFormat);      //will ignore pixelFormat

   944         ASSERT_TRUE(ns);

   945         

   946         // Store the retrieved attributes

   947         TInt32 attWidth = 0;

   948         TInt32 attHeight = 0;

   949         TInt32 attStreamStride = 0;

   950         TUidPixelFormat attStreamFormat = EUidPixelFormatUnknown;

   951         TInt32 attStreamPixelSize = 0;

   952         

   953         SymbianStreamGetHeader(ns, &attWidth, &attHeight, &attStreamStride, &attStreamFormat, &attStreamPixelSize);		

   954             

   955         ASSERT_EQUALS(attWidth, width);

   956         ASSERT_EQUALS(attHeight, height);

   957         ASSERT_EQUALS(attStreamFormat, supportedFormats[x].symbianPixelFormat);

   958         if (BytesPerPixel(supportedFormats[x].symbianPixelFormat) > 0)

   959             {

   960             ASSERT_EQUALS(attStreamStride, (streamPixelSize * width));

   961             }

   962         else

   963             {

   964             ASSERT_EQUALS(attStreamStride, (width-(streamPixelSize+1)) / (-streamPixelSize));

   965             }

   966         ASSERT_EQUALS(attStreamPixelSize, (TInt32)BytesPerPixel(supportedFormats[x].symbianPixelFormat));	

   967             

   968         SymbianStreamGetHeader(ns, NULL, NULL, NULL, NULL, NULL);

   969         

   970         SymbianStreamRemoveReference(ns);

   971         }

   972 	}

   973 

   974 /**

   975 @SYMTestCaseID			GFX_OPENWFC_NATIVESTREAM_0104

   976 @SYMTestCaseDesc		Acquire write/read buffers and retrieve the buffer ptr (single threaded test).

   977 @SYMREQ					

   978 @SYMPREQ				PREQ2400

   979 @SYMTestType			CT

   980 @SYMTestPriority		

   981 @SYMTestPurpose         Verify owfNativeStreamAcquireWriteBuffer(), owfNativeStreamReleaseWriteBuffer(),

   982                         owfNativeStreamAcquireReadBuffer() and owfNativeStreamReleaseReadBuffer() methods

   983 						work as expected.

   984 						

   985 @SYMTestActions	

   986 		Create a native stream 

   987 		For each buffer:

   988 		- Acquire the write buffer (wB)

   989 		- Get the write buffer ptr (pWB)

   990 		- Release the write buffer

   991 		- Acquire the read buffer (rB)

   992 		- Get the read buffer ptr (pRB)

   993 		- Release the read buffer	

   994 		Repeat for each buffer. Finally:

   995 		Acquire the write buffer

   996 		Release the write buffer	

   997 @SYMTestExpectedResults

   998 		For each buffer of the native stream, check:

   999 		- The read buffer (rB) should be the same as the write buffer (wB)

  1000 		- The read buffer address (pRB) should be the same as the write buffer address (pWB)

  1001 		If the number of buffers > 1, check:

  1002 		- The write buffer number from the previous acquire write buffer call should not be the same 

  1003 		as the write buffer number from the next acquire write buffer call

  1004 		The final acquire/release write/read calls should check:

  1005 		The write buffer number should acquire the first buffer number

  1006  **/

  1007 void CTestNativeStream::GRAPHICS_OPENWFC_NATIVESTREAM_0104L(TInt aNumBuffers)

  1008 	{

  1009 	RHeap* mainHeap = COpenWfcStreamMap::InstanceL().GetMainHeap();

  1010 	TRAPD(err, GrowCleanupStackL());

  1011 	ASSERT_TRUE(err == KErrNone);

  1012 

  1013 	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

  1014 	

  1015 	ASSERT_TRUE(aNumBuffers > 0);

  1016 	

  1017 	TSize surfaceSize(TSize(100,100));

  1018 	khronos_int32_t width = surfaceSize.iWidth;

  1019 	khronos_int32_t height = surfaceSize.iHeight;

  1020 	

  1021 	OWF_IMAGE_FORMAT pixelFormat =

  1022 		{

  1023 		OWF_IMAGE_ARGB8888,

  1024 	    ETrue,

  1025 	    ETrue,

  1026 	    aNumBuffers

  1027 	    };	

  1028 	

  1029 	SymbianStreamType ns=helperCreateImageStream(width,

  1030 													height,

  1031 													&pixelFormat,

  1032 													aNumBuffers);

  1033 	ASSERT_TRUE(ns);

  1034 	

  1035 	TUint8 *pWriteBuffer = NULL;

  1036 	TUint8 *pReadBuffer = NULL;

  1037 	TUint8 *pPrevWriteBuffer = pWriteBuffer;

  1038 	khronos_int32_t writeBuffer;

  1039 	khronos_int32_t readBuffer;

  1040 	khronos_int32_t bufferIndexWrite;

  1041 	khronos_int32_t bufferIndexRead;

  1042 	khronos_int32_t bufferIndexWriteFirst;

  1043 	khronos_int32_t bufferIndexWriteFinal;

  1044 	khronos_int32_t finalWriteBuffer;

  1045 	const TSurfaceId* getId = NULL;

  1046 	

  1047 	TInt bufferCount = aNumBuffers;

  1048 	

  1049 	// Loop through the buffers

  1050 	for (TInt count=0; count<bufferCount; count++)

  1051 		{

  1052 		// Acquire the write buffer

  1053 		err = SymbianStreamAcquireWriteBuffer(ns,&writeBuffer);

  1054 		ASSERT_TRUE(err == KErrNone);

  1055 		err = SymbianStreamGetBufferId(ns,writeBuffer,&bufferIndexWrite,&getId);

  1056 		ASSERT_TRUE(err == KErrNone);

  1057 		

  1058 		if (count == 0)

  1059 		    {

  1060 		    bufferIndexWriteFirst = bufferIndexWrite;

  1061 		    }

  1062 		

  1063 		err = SymbianStreamGetBufferPointer(ns,writeBuffer,reinterpret_cast<void**>(&pWriteBuffer));

  1064 		ASSERT_TRUE(err == KErrNone);

  1065 		ASSERT_NOT_NULL(pWriteBuffer);

  1066 		

  1067 		err = SymbianStreamReleaseWriteBuffer(ns,writeBuffer);

  1068 		ASSERT_TRUE(err == KErrNone);

  1069 		

  1070 		// Acquire the read buffer

  1071 		err = SymbianStreamAcquireReadBuffer(ns,&readBuffer);

  1072 		ASSERT_TRUE(err == KErrNone);

  1073 		err = SymbianStreamGetBufferId(ns,writeBuffer,&bufferIndexRead,&getId);

  1074 		ASSERT_TRUE(err == KErrNone);

  1075 		

  1076 		err = SymbianStreamGetBufferPointer(ns,readBuffer,reinterpret_cast<void**>(&pReadBuffer));

  1077 		ASSERT_TRUE(err == KErrNone);

  1078 		ASSERT_NOT_NULL(pReadBuffer);

  1079 		

  1080 		err = SymbianStreamReleaseReadBuffer(ns,readBuffer);

  1081 		ASSERT_TRUE(err == KErrNone);

  1082 		

  1083 		// Life-cycle checks

  1084 		ASSERT_EQUALS(bufferIndexWrite, bufferIndexRead)

  1085 		ASSERT_SAME(pWriteBuffer, pReadBuffer);

  1086 		

  1087 		if (count > 0)

  1088 			{

  1089 			ASSERT_NOT_SAME(pWriteBuffer, pPrevWriteBuffer);

  1090 			}

  1091 		

  1092 		pPrevWriteBuffer = pWriteBuffer;

  1093 		}	

  1094 

  1095 	// The next acquire write/reads should return the first buffer (0).

  1096 

  1097 	err = SymbianStreamAcquireWriteBuffer(ns,&finalWriteBuffer);

  1098 	ASSERT_TRUE(err == KErrNone);

  1099 	err = SymbianStreamGetBufferId(ns,finalWriteBuffer,&bufferIndexWriteFinal,&getId);

  1100 	ASSERT_TRUE(err == KErrNone);

  1101 	err = SymbianStreamReleaseWriteBuffer(ns,finalWriteBuffer);

  1102 	ASSERT_TRUE(err == KErrNone);

  1103 	

  1104 	// Final checks

  1105 	ASSERT_EQUALS(bufferIndexWriteFinal, bufferIndexWriteFirst);

  1106 	

  1107 	SymbianStreamRemoveReference(ns);

  1108 	

  1109 	CleanupStack::PopAndDestroy(); // switch the heap back to current thread's one

  1110 	}

  1111 

  1112 /**

  1113 @SYMTestCaseID			GFX_OPENWFC_NATIVESTREAM_0105

  1114 @SYMTestCaseDesc		Create a native stream and acquire a write buffer which is written to (single threaded test)

  1115 @SYMREQ					

  1116 @SYMPREQ				PREQ2400

  1117 @SYMTestType			CT

  1118 @SYMTestPriority		

  1119 @SYMTestPurpose			Verify native stream buffers can be written to and read from.

  1120 @SYMTestActions	

  1121 		Create a surface and fill it Red

  1122 		Create a native stream surface with the same surface properties (size, pixel format etc.)

  1123 		Acquire the native stream write buffer

  1124 		Fill the native stream surface Red

  1125 		Release the write buffer

  1126 		Acquire the native stream read buffer

  1127 		Compare the pixel data of the surface to the native stream surface

  1128 		Fill the Blue

  1129 		Compare the pixel data of the surface to the native stream surface

  1130 @SYMTestExpectedResults

  1131 		The surface pixel data is the same as the native stream surface pixel data

  1132 		After the surface pixel data is changed to Blue, the native stream surface should not be the same

  1133  **/

  1134 void CTestNativeStream::GRAPHICS_OPENWFC_NATIVESTREAM_0105L(TInt aNumBuffers)