void QEglFSPandaHooks::ensureFramebufferNativeWindowCreated()
{
if (mFramebufferNativeWindow.get())
return;
mFramebufferNativeWindow = new FramebufferNativeWindow();
framebuffer_device_t const *fbDev = mFramebufferNativeWindow->getDevice();
if (!fbDev)
qFatal("Failed to get valid FramebufferNativeWindow, no way to create EGL surfaces");
ANativeWindow *window = mFramebufferNativeWindow.get();
window->query(window, NATIVE_WINDOW_FORMAT, &mFramebufferVisualId);
}
MemoryHeapPmem::MemoryHeapPmem(const sp<MemoryHeapBase>& pmemHeap,
uint32_t flags)
: MemoryHeapBase()
{
char const * const device = pmemHeap->getDevice();
#ifdef HAVE_ANDROID_OS
if (device) {
int fd = open(device, O_RDWR | (flags & NO_CACHING ? O_SYNC : 0));
ALOGE_IF(fd<0, "couldn't open %s (%s)", device, strerror(errno));
if (fd >= 0) {
int err = ioctl(fd, PMEM_CONNECT, pmemHeap->heapID());
if (err < 0) {
ALOGE("PMEM_CONNECT failed (%s), mFD=%d, sub-fd=%d",
strerror(errno), fd, pmemHeap->heapID());
close(fd);
} else {
// everything went well...
mParentHeap = pmemHeap;
MemoryHeapBase::init(fd,
pmemHeap->getBase(),
pmemHeap->getSize(),
pmemHeap->getFlags() | flags,
device);
}
}
}
#else
mParentHeap = pmemHeap;
MemoryHeapBase::init(
dup(pmemHeap->heapID()),
pmemHeap->getBase(),
pmemHeap->getSize(),
pmemHeap->getFlags() | flags,
device);
#endif
}
int
main(int argc, char** argv) {
LOGE("*** Noodleland ***");
gNativeWindow = new FramebufferNativeWindow();
const framebuffer_device_t* fbDev = gNativeWindow->getDevice();
if (!fbDev) {
LOGE("Display subsystem failed to initialise. check logs. exiting...");
return 0;
}
const ANativeWindow* window = gNativeWindow.get();
int width = 0, height = 0, format = 0;
window->query(window, NATIVE_WINDOW_WIDTH, &width);
window->query(window, NATIVE_WINDOW_HEIGHT, &height);
window->query(window, NATIVE_WINDOW_FORMAT, &format);
LOGE("width = %d", width);
LOGE("height = %d", height);
LOGE("format = 0x%08X", format);
LOGE("xdpi = %f", window->xdpi);
LOGE("ydpi = %f", window->ydpi);
EGLint numConfigs;
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(display, NULL, NULL);
eglGetConfigs(display, NULL, 0, &numConfigs);
EGLint attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE
};
EGLConfig config = NULL;
status_t err = selectConfigForPixelFormat(display, attribs, format, &config);
LOGE_IF(err, "couldn't find an EGLConfig matching the screen format");
EGLint r,g,b,a;
eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
LOGE("r = %d, g = %d, b = %d, a = %d", r, g, b, a);
EGLSurface surface = eglCreateWindowSurface(display, config, gNativeWindow.get(), NULL);
eglQuerySurface(display, surface, EGL_WIDTH, &gWidth);
eglQuerySurface(display, surface, EGL_HEIGHT, &gHeight);
if (gNativeWindow->isUpdateOnDemand()) {
LOGE("*** PARTIAL UPDATES");
eglSurfaceAttrib(display, surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
}
EGLint contextAttribs[] = {
EGL_NONE
};
EGLContext context = eglCreateContext(display, config, NULL, contextAttribs);
EGLBoolean result;
result = eglMakeCurrent(display, surface, surface, context);
if (!result) {
LOGE("Couldn't create a working GLES context. check logs. exiting...");
return 0;
}
LOGE("EGL information");
LOGE("# of configs: %d", numConfigs);
LOGE("vendor : %s", eglQueryString(display, EGL_VENDOR));
LOGE("version : %s", eglQueryString(display, EGL_VERSION));
LOGE("extensions : %s", eglQueryString(display, EGL_EXTENSIONS));
LOGE("client API : %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
LOGE("EGL surface : %d-%d-%d-%d, config=%p", r, g, b, a, config);
LOGE("OpenGL information");
LOGE("vendor : %s", glGetString(GL_VENDOR));
LOGE("renderer : %s", glGetString(GL_RENDERER));
LOGE("version : %s", glGetString(GL_VERSION));
LOGE("extensions : %s", glGetString(GL_EXTENSIONS));
/* AMD Performance Counters */
GLint num_groups;
char buffer[512];
glGetPerfMonitorGroupsAMD(&num_groups, 0, NULL);
for (int group = 0; group < num_groups; group++) {
glGetPerfMonitorGroupStringAMD(group, 512, NULL, buffer);
LOGE("Perf Monitor Group [%d]: %s", group, buffer);
GLint num_counters, max_active_counters;
glGetPerfMonitorCountersAMD(group, &num_counters, &max_active_counters, 0, NULL);
LOGE(" Counters #: %d, Max Active: %d", num_counters, max_active_counters);
GLuint* counters = new GLuint[num_counters];
glGetPerfMonitorCountersAMD(group, NULL, NULL, num_counters, counters);
for (int c = 0; c < num_counters; c++) {
GLuint counter = counters[c];
glGetPerfMonitorCounterStringAMD(group, counter, 512, NULL, buffer);
LOGE(" %s (%u/0x%08x)", buffer, counter, counter);
}
delete [] counters;
}
err = hw_get_module(HWC_HARDWARE_MODULE_ID, &gHwcModule);
if (err) {
LOGE(HWC_HARDWARE_MODULE_ID " module not found.");
return 0;
}
err = hwc_open(gHwcModule, &gHwc);
if (err) {
LOGE(HWC_HARDWARE_COMPOSER " device failed to initialize (%s)", strerror(-err));
return 0;
}
if (gHwc->registerProcs) {
gHwcProcs.invalidate = hwc_invalidate_cb;
gHwc->registerProcs(gHwc, &gHwcProcs);
}
gHwcDisplay = (hwc_display_t) display;
gHwcSurface = (hwc_surface_t) surface;
err = hwc_create_work_list(NUMA(test_sprites));
if (err)
return 0;
create_sprites();
uint32_t flipCount = 0;
for (;;)
{
hwc_layer_t& ll = gHwcList->hwLayers[0];
update_sprites();
HwcLayerCount layerCounts;
err = hwc_prepare_list(&layerCounts);
if (err)
return 0;
#ifdef NOODLE_DUMP_HWC_LIST
LOGE("HWC state: %d", flipCount);
LOGE("Num OV: %d", layerCounts.NumOVLayers);
LOGE("Num FB: %d", layerCounts.NumFBLayers);
LOGE(" numHwLayers=%u, flags=0x%08x", gHwcList->numHwLayers, gHwcList->flags);
LOGE(" type | handle | hints | flags | tr | blend | format | source crop | frame name");
LOGE("----------+----------+----------+----------+----+-------+----------+---------------------------+--------------------------------");
uint32_t format = PIXEL_FORMAT_RGBA_8888;
for (size_t n = 0; n < gHwcList->numHwLayers; n++) {
const hwc_layer_t& l = gHwcList->hwLayers[n];
LOGE(" %8s | %08x | %08x | %08x | %02x | %05x | %08x | [%5d,%5d,%5d,%5d] | [%5d,%5d,%5d,%5d] %s",
l.compositionType ? "OVERLAY" : "FB",
intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, format,
l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom,
l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
"buffer");
}
if (gHwc->common.version >= 1 && gHwc->dump) {
gHwc->dump(gHwc, tempbuffer, SIZE);
LOGE("%s", tempbuffer);
}
#endif
#ifdef NOODLE_DEBUG_CLEAR
if (flipCount & 0x1) {
glClearColor(1,0,0,0);
} else {
glClearColor(0,1,0,0);
}
#else
glClearColor(0,0,0,0);
#endif
glClear(GL_COLOR_BUFFER_BIT);
gNativeWindow->compositionComplete();
err = hwc_commit(); // Flip
if (err) {
LOGE("hwc commit failed: %s", strerror(-err));
return 0;
}
flipCount += 1;
}
return 0;
}
