void createDebugSurface() {
if (getenv(SHOW_DEBUG_STRING) == NULL) return;
mComposerClient = new SurfaceComposerClient;
ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
mSurfaceControl = mComposerClient->createSurface(
String8("SRGBTest Surface"), DISPLAY_WIDTH, DISPLAY_HEIGHT,
PIXEL_FORMAT_RGBA_8888);
ASSERT_TRUE(mSurfaceControl != NULL);
ASSERT_TRUE(mSurfaceControl->isValid());
SurfaceComposerClient::openGlobalTransaction();
ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
SurfaceComposerClient::closeGlobalTransaction();
ANativeWindow_Buffer outBuffer;
ARect inOutDirtyBounds;
mOutputSurface = mSurfaceControl->getSurface();
mOutputSurface->lock(&outBuffer, &inOutDirtyBounds);
uint8_t* bytePointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
for (int y = 0; y < outBuffer.height; ++y) {
int rowOffset = y * outBuffer.stride; // pixels
for (int x = 0; x < outBuffer.width; ++x) {
int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
for (int c = 0; c < PIXEL_SIZE; ++c) {
int offset = colOffset + c;
bytePointer[offset] = ((c + 1) * 56) - 1;
}
}
}
mOutputSurface->unlockAndPost();
}
void klaatu_init_graphics(int *width, int *height)
{
android::DisplayInfo display_info;
printf("initting klaatu graphics\n");
// initial part shamelessly stolen from klaatu-api
static EGLint sDefaultContextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
static EGLint sDefaultConfigAttribs[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 16, EGL_STENCIL_SIZE, 8, EGL_NONE };
mSession = new android::SurfaceComposerClient();
int status = mSession->getDisplayInfo(0, &display_info);
*width = display_info.w;
*height = display_info.h;
mControl = mSession->createSurface(0,
*width, *height, android::PIXEL_FORMAT_RGB_888, 0);
android::SurfaceComposerClient::openGlobalTransaction();
mControl->setLayer(0x40000000);
android::SurfaceComposerClient::closeGlobalTransaction();
mAndroidSurface = mControl->getSurface();
EGLNativeWindowType eglWindow = mAndroidSurface.get();
mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
ASSERT_EQ(EGL_SUCCESS, eglGetError());
ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
EGLint majorVersion, minorVersion;
EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
EGLint numConfigs = 0;
EGLConfig mGlConfig;
EXPECT_TRUE(eglChooseConfig(mEglDisplay, sDefaultConfigAttribs, &mGlConfig, 1, &numConfigs));
mEglSurface = eglCreateWindowSurface(mEglDisplay, mGlConfig, eglWindow, NULL);
ASSERT_EQ(EGL_SUCCESS, eglGetError());
ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
mEglContext = eglCreateContext(mEglDisplay, mGlConfig, EGL_NO_CONTEXT, sDefaultContextAttribs);
ASSERT_EQ(EGL_SUCCESS, eglGetError());
ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
}
bool EncodeInputSurface::init(const char* inputFileName, uint32_t fourcc, int width, int height)
{
m_width = width;
m_height = height;
int surfaceWidth = width;
int surfaceHeight = height;
static sp<SurfaceComposerClient> client = new SurfaceComposerClient();
//create surface
static sp<SurfaceControl> surfaceCtl = client->createSurface(String8("testsurface"),
surfaceWidth, surfaceHeight, HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL, 0);
DEBUG("create surface with size %dx%d, format: 0x%x", surfaceWidth, surfaceHeight, HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL);
// configure surface
SurfaceComposerClient::openGlobalTransaction();
surfaceCtl->setLayer(100000);
surfaceCtl->setPosition(100, 100);
surfaceCtl->setSize(surfaceWidth, surfaceHeight);
SurfaceComposerClient::closeGlobalTransaction();
m_surface = surfaceCtl->getSurface();
mNativeWindow = m_surface;
int bufWidth = width;
int bufHeight = height;
int ret;
INFO("set buffers geometry %dx%d\n", width, height);
ret = native_window_set_buffers_dimensions(GET_ANATIVEWINDOW(mNativeWindow), width, height);
CHECK_RET(ret, "native_window_set_buffers_dimensions");
uint32_t format = HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
INFO("set buffers format %x\n", format);
ret = native_window_set_buffers_format(GET_ANATIVEWINDOW(mNativeWindow), format);
CHECK_RET(ret, "native_window_set_buffers_format");
INFO("set buffer usage\n");
ret = native_window_set_usage(GET_ANATIVEWINDOW(mNativeWindow),
GRALLOC_USAGE_HW_VIDEO_ENCODER | GRALLOC_USAGE_HW_TEXTURE);
CHECK_RET(ret, "native_window_set_usage");
INFO("set buffer count %d\n", m_bufferCount);
ret = native_window_set_buffer_count(GET_ANATIVEWINDOW(mNativeWindow), m_bufferCount);
CHECK_RET(ret, "native_window_set_buffer_count");
prepareInputBuffer();
return true;
}
EGLNativeWindowType QEglFSPandaHooks::createNativeWindowSurfaceFlinger(const QSize &size, const QSurfaceFormat &)
{
Q_UNUSED(size);
mSession = new SurfaceComposerClient();
DisplayInfo dinfo;
int status=0;
status = mSession->getDisplayInfo(0, &dinfo);
mControl = mSession->createSurface(
0, dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_888);
SurfaceComposerClient::openGlobalTransaction();
mControl->setLayer(0x40000000);
// mControl->setAlpha(1);
SurfaceComposerClient::closeGlobalTransaction();
mAndroidSurface = mControl->getSurface();
EGLNativeWindowType eglWindow = mAndroidSurface.get();
return eglWindow;
}
int main(int argc, char* argv[])
{
composerClient = new SurfaceComposerClient;
sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain));
DisplayInfo info;
SurfaceComposerClient::getDisplayInfo(display, &info);
ssize_t displayWidth = info.w;
ssize_t displayHeight = info.h;
printf("display is %ld x %ld\n", displayWidth, displayHeight);
control = composerClient->createSurface(
String8("A Surface"),
400,
400,
PIXEL_FORMAT_RGB_565,
0);
SurfaceComposerClient::openGlobalTransaction();
control->setLayer(21015);
control->setAlpha(0.8);
control->setMatrix(0.5, 0, 0, 0.5);
control->show();
SurfaceComposerClient::closeGlobalTransaction();
surface = control->getSurface();
//ANativeWindow *window = surface.get();
//native_window_set_buffers_geometry(window, 400, 400, HAL_PIXEL_FORMAT_YV12);
Surface::SurfaceInfo sinfo;
surface->lock(&sinfo);
memset(sinfo.bits, 0xff, sinfo.w*sinfo.h);
memset(sinfo.bits+sinfo.w*sinfo.h, 0xf, sinfo.w*sinfo.h);
surface->unlockAndPost();
sleep(10);
return 0;
}
bool createNativeWindow(__u32 pixelformat)
{
mClient = new SurfaceComposerClient();
mSurfaceCtl = mClient->createSurface(String8("testsurface"),
800, 600, pixelformat, 0);
// configure surface
SurfaceComposerClient::openGlobalTransaction();
mSurfaceCtl->setLayer(100000);
mSurfaceCtl->setPosition(100, 100);
mSurfaceCtl->setSize(800, 600);
SurfaceComposerClient::closeGlobalTransaction();
mSurface = mSurfaceCtl->getSurface();
mNativeWindow = mSurface;
int bufWidth = 640;
int bufHeight = 480;
CHECK_EQ(0,
native_window_set_usage(
mNativeWindow.get(),
GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN
| GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP));
CHECK_EQ(0,
native_window_set_scaling_mode(
mNativeWindow.get(),
NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW));
CHECK_EQ(0, native_window_set_buffers_geometry(
mNativeWindow.get(),
bufWidth,
bufHeight,
pixelformat));
return true;
}
