static void draw(void) { const VGint w = 48; VGImage img1, img2; VGint x, y; vgSetfv(VG_CLEAR_COLOR, 4, white); vgClear(0, 0, window_width(), window_height()); img1 = vgCreateImage(VG_sRGBA_8888, w, w, VG_IMAGE_QUALITY_NONANTIALIASED); img2 = vgCreateImage(VG_sRGBA_8888, w, w, VG_IMAGE_QUALITY_NONANTIALIASED); x = 5; y = (window_height() - w) / 2; /* test vgSetPixels */ vgSetfv(VG_CLEAR_COLOR, 4, red); vgClearImage(img1, 0, 0, w, w / 2); vgSetfv(VG_CLEAR_COLOR, 4, black); vgClearImage(img1, 0, w / 2, w, w / 2); vgSetPixels(x, y, img1, 0, 0, w, w); x += w + 5; /* test vgDrawImage */ vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE); vgLoadIdentity(); vgTranslate(x, y); vgDrawImage(img1); /* test vgGetPixels */ vgGetPixels(img1, 0, 0, x, y, w, w); x += w + 5; vgSetPixels(x, y, img1, 0, 0, w, w); x += w + 5; /* test vgCopyImage */ vgCopyImage(img2, 0, 0, img1, 0, 0, w, w, VG_FALSE); vgSetPixels(x, y, img2, 0, 0, w, w); /* vgCopyPixels */ vgCopyPixels(x + w + 5, y, x, y, w, w); vgDestroyImage(img1); vgDestroyImage(img2); }
// makeimage makes an image from a raw raster of red, green, blue, alpha values void makeimage(VGfloat x, VGfloat y, int w, int h, VGubyte * data) { unsigned int dstride = w * 4; VGImageFormat rgbaFormat = VG_sABGR_8888; VGImage img = vgCreateImage(rgbaFormat, w, h, VG_IMAGE_QUALITY_BETTER); vgImageSubData(img, (void *)data, dstride, rgbaFormat, 0, 0, w, h); vgSetPixels(x, y, img, 0, 0, w, h); vgDestroyImage(img); }
void CEglTest_EGL_Image_Multi_Thread_Parallel::doThreadFunctionL(TInt aIdx) { INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Parallel::doThreadFunctionL, Thread %d"),aIdx); GetDisplayL(); CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx); eglSess->InitializeL(); eglSess->OpenSgDriverL(); // create a reference bitmap (we give index 7, as there's only 1 image in this test case) TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 7); CleanupStack::PushL(bitmap); // Create an RSgImage INFO_PRINTF2(_L("Thread %d, Creating a RSgImage having the reference bitmap's content"),aIdx); TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize); RSgImage rSgImageLocal; CleanupClosePushL(rSgImageLocal); ASSERT_EQUALS(rSgImageLocal.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone); INFO_PRINTF2(_L("Thread %d, Creating an EGLImage from the shared RSgImage"),aIdx); EGLImageKHR eglImageLocal = eglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &rSgImageLocal, KEglImageAttribsPreservedTrue); ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR); CleanupStack::PopAndDestroy(&rSgImageLocal); //transferring ownership of the buffer to the EGLImage CleanupStack::PopAndDestroy(bitmap); INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx); TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat); TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize); // Create a pixmap surface matching the native image pixel format eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo2,CTestEglSession::EResourceCloseSgImageEarly); INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the EGLImage"),aIdx); VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)eglImageLocal); ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE); ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, eglImageLocal)); // Copy the source VGImage to the surface vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); // destroy VGImage vgDestroyImage(vgImageLocal); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); // we can now compare the VgImage to the one we would expect for this particular thread CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 7); CleanupStack::PushL(refBitmap); eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap); CleanupStack::PopAndDestroy(refBitmap); INFO_PRINTF2(_L("Drawing successful, Thread %d"),aIdx); // cleanup eglSess->CloseSgDriver(); CleanupStack::PopAndDestroy(eglSess); }
//------------------------------------------------------------------------------ void term_show(tTermState * ts, bool swap) { if (ts->image == 0) return; clear_screen(false); vgSetPixels(ts->tvXY.x, ts->tvXY.y, ts->image, 0, 0, ts->tv_width, ts->tv_height); Roundrect(ts->imageXY.x, ts->imageXY.y, ts->image_width, ts->image_height, 20, 20, numRectPenSize, rectColor, bgColor); int x, y; char temp[2]; temp[1] = 0x00; tPointXY pos; pos.x = ts->txtXY.x; pos.y = ts->txtXY.y; tScrChr * pBuff = &ts->term_vbuff[0]; for (y = 0; y < ts->term_h ; y++) { for(x = 0; x < ts->term_w ; x++) { temp[0] = pBuff->c; Text(&fontDefs[ts->numFont], //Topaz font pos.x, pos.y, temp, ts->numPointFont, &colorScheme[pBuff->color], VG_FILL_PATH); pos.x += ts->term_x_inc; pBuff++; } pos.y -= ts->term_y_inc; pos.x = ts->txtXY.x; } if(swap) eglSwapBuffers(state->display, state->surface); }
//------------------------------------------------------------------------------ bool draw_boing(int x, int y, int width, int height, bool next) { static int frame = 0; int result = true; if(boingAnim[frame].image == -1) { //boingAnim[frame].image = create_image_from_buf( boingAnim[frame].image = createImageFromBuf( //boingAnim[frame].image = OMXCreateImageFromBuf( boingAnim[frame].rawData, boingAnim[frame].rawDataSize, width, height); result = false; } if(boingAnim[frame].image > 0) vgSetPixels(x, y, boingAnim[frame].image, 0, 0, width, height); if(next && boingAnim[++frame].image == -2) frame = 0; return result; }
int main() { setlocale(LC_ALL, ""); int width, height; int i = 0; width = 640; height = 480; init(&width, &height); loadConf(); TMain Main; initMain(&Main, width, height); for(i = 0; i <= (widget_count - 1); i++){ Widgets[i].init( &Widgets[i], &Main ); } while(Main.work >= 1) { Start(width, height); vgSetPixels(Main.mX, Main.mY, background_image, 0, 0, width, height); loadConf(); for(i = 0; i <= (widget_count -1); i++){ if(Widgets[i].state == 1){ Widgets[i].draw( &Widgets[i], &Main ); } } End(); usleep(10000); } finish(); exit(0); return 0; }
void CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doThreadFunctionL(TInt aIdx) { INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doThreadFunctionL, Thread %d"),aIdx); GetDisplayL(); CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx); eglSess->InitializeL(); eglSess->OpenSgDriverL(); TRequestStatus statusThread1; VGImage vgImageLocal = VG_INVALID_HANDLE; EGLint surfaceWidth; EGLint surfaceHeigth; //Thread0 asks to be notified when Thread1 exits //Creates a RSgImage having the reference bitmap as content //Creates a EGLImage from the RSgImage //Creates a surface //Creates a VGImage from the EGLImage if(aIdx == 0) { // Thread0 asks to be notified when Thread1 exits iThreadStatus[1].iThread.Logon(statusThread1); RSgImage rSgImageLocal; CleanupClosePushL(rSgImageLocal); // create a reference bitmap (we give index 9, as there's only 1 image in this test case) TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 9); CleanupStack::PushL(bitmap); // Create an RSgImage INFO_PRINTF2(_L("Thread %d, Creating a RSgImage having the reference bitmap's content"),aIdx); TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize); ASSERT_EQUALS(rSgImageLocal.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone); CleanupStack::PopAndDestroy(bitmap); INFO_PRINTF2(_L("Thread %d, Creating an EGLImage from the shared RSgImage"),aIdx); EGLImageKHR eglImageLocal = eglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &rSgImageLocal, KEglImageAttribsPreservedTrue); ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR); CleanupStack::PopAndDestroy(&rSgImageLocal); //transferring ownership of the buffer to the EGLImage INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx); TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat); TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize); // Create a pixmap surface matching the native image pixel format eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo2,CTestEglSession::EResourceCloseSgImageEarly); //We now store the size of the surface because after eglTerminate is called on the display //it will not be possible to use explicitly all the resources linked to it //i.e. every call to an EGL API who takes a display as an argument will raise a EGL_BAD_DISPLAY error eglQuerySurface(iDisplay, eglSess->Surface(), EGL_WIDTH, &surfaceWidth); eglQuerySurface(iDisplay, eglSess->Surface(), EGL_HEIGHT, &surfaceHeigth); INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the EGLImage"),aIdx); vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)eglImageLocal); ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE); ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, eglImageLocal)); } Rendezvous(aIdx); //Thread1 calls eglTerminate and exit if(aIdx == 1) { INFO_PRINTF2(_L(", Thread %d, Calling eglTerminate and exiting"),aIdx); TerminateDisplayL(); } Rendezvous(aIdx); //Thread0 resumes when Thread1 exits //and it uses the resources that are linked to the just destroyed display if(aIdx == 0) { User::WaitForRequest(statusThread1); // It's still possible to use the current context, surface and VGImage even though the display has been terminated //Copy the source VGImage to the surface vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); // we can now compare the VgImage to the one we would expect for this particular thread TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 9); CleanupStack::PushL(refBitmap); eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap); CleanupStack::PopAndDestroy(refBitmap); INFO_PRINTF2(_L("Drawing successful, Thread %d"),aIdx); vgDestroyImage(vgImageLocal); ASSERT_TRUE(vgGetError() == VG_NO_ERROR); eglReleaseThread(); } // cleanup eglSess->CloseSgDriver(); CleanupStack::PopAndDestroy(eglSess); }
void CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doThreadFunctionL(TInt aIdx) { INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doThreadFunctionL, Thread %d"),aIdx); CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx); eglSess->InitializeL(); eglSess->OpenSgDriverL(); // check there is no eglImage at the start of either thread ASSERT_EGL_TRUE(iEGLImageShared == EGL_NO_IMAGE_KHR); TRequestStatus statusThread0; if(aIdx == 1) { INFO_PRINTF2(_L("Thread %d, Asking to be notified when thread 0 exits"),aIdx); iThreadStatus[0].iThread.Logon(statusThread0); } Rendezvous(aIdx); //Thread 0 creates the EGLImage and exit if(aIdx == 0) { // Create an EGLImage from the RSgImage (member variable as it is 'shared' in the thread function...) INFO_PRINTF2(_L("Thread %d, Creating the shared EGLImage"),aIdx); iEGLImageShared = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue); ASSERT_EGL_TRUE(iEGLImageShared != EGL_NO_IMAGE_KHR); iSgImageShared.Close(); INFO_PRINTF2(_L("Thread %d ----- Exiting ---- EGLImage should be kept alive"),aIdx); } //Thread1 waits for Thread0 to exit and then uses the EGLImage and performs some drawing if(aIdx == 1) { INFO_PRINTF2(_L("Thread %d, Waiting for thread 0 to exit"),aIdx); User::WaitForRequest(statusThread0); INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx); TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat); TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize); // Create a pixmap surface matching the native image pixel format eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo,CTestEglSession::EResourceCloseSgImageEarly); // Create a VGImage from the EGLImage INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the shared EGLImage"),aIdx); VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)iEGLImageShared); ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE); INFO_PRINTF2(_L("Thread %d, Drawing the VGImage to the current surface"),aIdx); // Copy the source VGImage to the surface vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); // we can now compare the VgImage to the one we expect after changing it in the other thread TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 2); CleanupStack::PushL(refBitmap); eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap); CleanupStack::PopAndDestroy(refBitmap); INFO_PRINTF2(_L("Thread %d, Drawing successful"),aIdx); vgDestroyImage(vgImageLocal); ASSERT_TRUE(vgGetError() == VG_NO_ERROR); ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, iEGLImageShared)); iEGLImageShared = EGL_NO_IMAGE_KHR; } // cleanup eglSess->CloseSgDriver(); CleanupStack::PopAndDestroy(eglSess); }
void CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doThreadFunctionL(TInt aIdx) { INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doThreadFunctionL, Thread %d"),aIdx); CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx); eglSess->InitializeL(); eglSess->OpenSgDriverL(); // check there is no eglImage at the start of either thread ASSERT_EGL_TRUE(iEGLImageShared == EGL_NO_IMAGE_KHR); // Wait for both thread to reach this point // This is important for multicore platforms (i.e., naviengine) as the execution order is not known and it could // happen that the first thread has already created the image before the second checks there is no eglImage Rendezvous(aIdx); if(aIdx == 0) { // Create an EGLImage from the RSgImage (member variable as it is 'shared' in the thread function...) INFO_PRINTF2(_L("Thread %d, Creating the shared EGLImage"),aIdx); iEGLImageShared = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue); ASSERT_EGL_TRUE(iEGLImageShared != EGL_NO_IMAGE_KHR); iSgImageShared.Close(); } Rendezvous(aIdx); if(aIdx == 1) { INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx); TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat); TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize); // Create a pixmap surface matching the native image pixel format eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo,CTestEglSession::EResourceCloseSgImageEarly); // Create a VGImage from the EGLImage INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the shared EGLImage"),aIdx); VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)iEGLImageShared); ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE); INFO_PRINTF2(_L("Thread %d, Drawing the VGImage to the current surface"),aIdx); // Copy the source VGImage to the surface vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); // we can now compare the VgImage to the one we expect from the main thread TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 5); CleanupStack::PushL(refBitmap); eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap); CleanupStack::PopAndDestroy(refBitmap); INFO_PRINTF2(_L("Thread %d, Drawing successful"),aIdx); vgDestroyImage(vgImageLocal); ASSERT_TRUE(vgGetError() == VG_NO_ERROR); } Rendezvous(aIdx); if(aIdx == 0) { ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, iEGLImageShared)); iEGLImageShared = EGL_NO_IMAGE_KHR; } // cleanup eglSess->CloseSgDriver(); CleanupStack::PopAndDestroy(eglSess); }
void CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doThreadFunctionL(TInt aIdx) { INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doThreadFunctionL, Thread %d"),aIdx); CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx); eglSess->InitializeL(); eglSess->OpenSgDriverL(); INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx); TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat); TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize); // Create a pixmap surface matching the native image pixel format eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo,CTestEglSession::EResourceCloseSgImageEarly); // Create a VGImage from the EGLImage INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the shared EGLImage"),aIdx); VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)iEGLImageShared); ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE); Rendezvous(aIdx); if(aIdx == 0) { INFO_PRINTF2(_L("Thread %d, Updating contents of the VGImage from the shared EGLImage"),aIdx); TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8); // Add pixel data to the VGImage reference from the bitmap reference. // Mind the fact that CFbsBitmap and VGImages use different coordinates origin! TSize bitmapSize = bitmap->SizeInPixels(); TUint8* address = reinterpret_cast<TUint8*>(bitmap->DataAddress()); TInt stride = bitmap->DataStride(); address += (bitmapSize.iHeight - 1) * stride; vgImageSubData(vgImageLocal, address, -stride, KDefaultSurfaceFormat, 0,0, bitmapSize.iWidth, bitmapSize.iHeight); delete bitmap; bitmap = NULL; ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); } Rendezvous(aIdx); if(aIdx == 1) { INFO_PRINTF2(_L("Thread %d, Drawing the VGImage to the current surface"),aIdx); // Copy the source VGImage to the surface vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); // we can now compare the VgImage to the one we expect after changing it in the other thread TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat); CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8); CleanupStack::PushL(refBitmap); eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap); CleanupStack::PopAndDestroy(refBitmap); INFO_PRINTF2(_L("Thread %d, Drawing successful"),aIdx); } // cleanup vgDestroyImage(vgImageLocal); ASSERT_TRUE(vgGetError() == VG_NO_ERROR); eglSess->CloseSgDriver(); CleanupStack::PopAndDestroy(eglSess); }
// Image places an image at the specifed location void Image(VGfloat x, VGfloat y, int w, int h, const char *filename) { VGImage img = createImageFromJpeg(filename); vgSetPixels(x, y, img, 0, 0, w, h); vgDestroyImage(img); }
// Image places an image at the specified location, using an image previously loaded void ImageI(VGfloat x, VGfloat y, int w, int h, VGImage img) { vgSetPixels(x,y,img,0,0,w,h); }
// restoreCursor restores the pixels under the mouse cursor void restoreCursor(VGImage CursorBuffer) { if (cur_saved != 0) { vgSetPixels(cur_sx, cur_sy, CursorBuffer, 0, 0, cur_w, cur_h); } }
void drawPhotos(TWidget *Widget, TMain *Main) { vgSetPixels(Widget->X+Main->mX, Widget->Y+Main->mY, bg, 0, 0, Main->width, Main->height); }
void drawTime(TWidget *Widget, TMain *Main) { vgSetPixels(Widget->X+Main->mX, Widget->Y+Main->mY, bg, 0, 0, Main->width, Main->height); viewTime(Widget, Main); }
/** @SYMTestCaseID GRAPHICS-EGL-0130 @SYMTestPriority 1 @SYMPREQ 39 @SYMREQ See SGL.GT0386.401 document @SYMTestCaseDesc When a RSgImage is used as both the source and target of a draw operation, then the operation should not panic. However the outcome is undefined. @SYMTestActions Create and fully construct an RSgImage object Pass the RSgImage objects into eglCreateImageKHR() with • The target parameter set to EGL_NATIVE_PIXMAP_KHR • Use the current display and EGL_NO_CONTEXT • Use a NULL attr_list Check that those calls to eglCreateImageKHR() do NOT return EGL_NO_IMAGE_KHR Use vgCreateEGLImageTargetKHR() to construct a VGImage object from the just created EGLImage. • Check for errors Create Pixmap Surface from the previous RSgImage and make it current in a way that is compatible as a target for the VGImage to be drawn to. • Set the iUsage bit to ESgUsageBitOpenVgSurface and ESgUsageBitOpenGlesSurface Use OpenVG to draw a single patern to the left half of the VGImage created from the EGLImage. Try to draw this VGImage to the right half of the pixmap surface currently linked to the context. Call eglWaitClient() to finish the above drawing instructions synchronously. Check that the pixmap contains expected pixel values. Pass the VGImage into vgDestroyImage() Pass the EGLImage into eglDestroyImageKHR() Close the RSgImage Destroy the pixmap Check for memory and handle leaks @SYMTestExpectedResults This test is not supposed to panic. The contents, though, are undefined since we are reading from and writing to the same memory No memory or handle leaks. */ TVerdict CEglTest_EGL_Image_Self_Drawing::doTestStepL() { SetTestStepID(_L("GRAPHICS-EGL-0130")); INFO_PRINTF1(_L("CEglTest_EGL_Image_Self_Drawing::doTestStepL")); TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image); if(!ret) { // The extension is not supported RecordTestResultL(); CloseTMSGraphicsStep(); return TestStepResult(); } // This test is performed for default pixel format PrintUsedPixelConfiguration(); // Create display object GetDisplayL(); CreateEglSessionL(); iEglSess->InitializeL(); iEglSess->OpenSgDriverL(); // Create a reference bitmap which we use to init the SgImage (we use index=8) TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat); CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8); CleanupStack::PushL(bitmap); INFO_PRINTF1(_L("Creating one RSgImage")); TSgImageInfoTest imageInfo; imageInfo.iSizeInPixels = KPixmapSize; imageInfo.iPixelFormat = iSourceFormat; #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE imageInfo.iUsage = ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface; #else imageInfo.iUsage = ESgUsageOpenVgImage | ESgUsageOpenVgTarget; #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE RSgImage sgImage; CleanupClosePushL(sgImage); ASSERT_EQUALS(sgImage.Create(imageInfo, bitmap->DataAddress(),bitmap->DataStride()), KErrNone); INFO_PRINTF1(_L("Creating one EGLImage from it")); EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue); ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR); INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENVG_API)")); ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API)); EGLint numConfigsWithPre = 0; EGLConfig configWithPre; const EGLint KAttribImagePre[] = { EGL_MATCH_NATIVE_PIXMAP, reinterpret_cast<EGLint>(&sgImage), EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT, EGL_SURFACE_TYPE, EGL_PIXMAP_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT, EGL_NONE }; ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KAttribImagePre, &configWithPre, 1, &numConfigsWithPre)); // Create a pixmap surface from the native image INFO_PRINTF1(_L("Calling eglCreatePixmapSurface")); EGLSurface surface = eglCreatePixmapSurface(iDisplay, configWithPre, &sgImage, KPixmapAttribsVgAlphaFormatPre ); ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE); // Create a context for drawing to/reading from the pixmap surface and make it current INFO_PRINTF1(_L("Calling eglCreateContext")); EGLContext context = eglCreateContext(iDisplay, configWithPre, EGL_NO_CONTEXT, NULL); ASSERT_EGL_TRUE(context != EGL_NO_CONTEXT); INFO_PRINTF1(_L("Calling eglMakeCurrent")); ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, surface, surface, context)); // Create a VGImage from the EGLImage INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage")); VGImage vgImage = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR); ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE); //Copy the source VGImage to the surface vgSetPixels(0, 0, vgImage, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); eglWaitClient(); //cleanup vgDestroyImage(vgImage); ASSERT_TRUE(vgGetError()==VG_NO_ERROR); ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR)); CleanupStack::PopAndDestroy(2, bitmap); // bitmap, sgImage //This test doesn't check the drawing because the content of the image are undefined //since we are using the same buffer both as target and as source //The main purpose of this test is to ensure we don't get a panic ASSERT_EGL_TRUE(eglDestroyContext(iDisplay, context)); //Closing eglContext context = EGL_NO_CONTEXT; ASSERT_EGL_TRUE(eglDestroySurface(iDisplay,surface)); //Destroying Target Surface handle CleanAll(); RecordTestResultL(); CloseTMSGraphicsStep(); return TestStepResult(); }