screen_window_t create_bg_window(const char *group, int dims[2])
{
/* Start by creating the application window and window group. */
screen_window_t screen_win;
screen_create_window(&screen_win, screen_ctx);
screen_create_window_group(screen_win, group);
int vis = 1;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_VISIBLE, &vis);
int color = 0xffffff00;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_COLOR, &color);
int zorder = 0;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &zorder);
int rect[4] = { 0, 0, 1, 1 };
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, rect+2);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SOURCE_SIZE, dims);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, dims);
int pos[2] = { -dims[0], -dims[1] };
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SOURCE_POSITION, pos);
screen_buffer_t screen_buf;
screen_create_window_buffers(screen_win, 1);
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)&screen_buf);
screen_post_window(screen_win, screen_buf, 1, rect, 0);
return screen_win;
}
void BlackberryMain::startDisplays() {
int num_configs;
EGLint attrib_list[]= {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE};
const EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
screen_get_context_property_iv(screen_cxt, SCREEN_PROPERTY_DISPLAY_COUNT, &ndisplays);
egl_disp = (EGLDisplay*)calloc(ndisplays, sizeof(EGLDisplay));
egl_surf = (EGLSurface*)calloc(ndisplays, sizeof(EGLSurface));
displays = (dispdata_t*)calloc(ndisplays, sizeof(dispdata_t));
screen_win = (screen_window_t *)calloc(ndisplays, sizeof(screen_window_t ));
screen_dpy = (screen_display_t*)calloc(ndisplays, sizeof(screen_display_t));
screen_get_context_property_pv(screen_cxt, SCREEN_PROPERTY_DISPLAYS, (void **)screen_dpy);
// Common data
int usage = SCREEN_USAGE_ROTATION | SCREEN_USAGE_OPENGL_ES2;
int format = SCREEN_FORMAT_RGBX8888;
int sensitivity = SCREEN_SENSITIVITY_ALWAYS;
// Initialise every display
for (int i = 0; i < ndisplays; i++) {
screen_get_display_property_iv(screen_dpy[i], SCREEN_PROPERTY_TYPE, &(displays[i].type));
screen_get_display_property_iv(screen_dpy[i], SCREEN_PROPERTY_ATTACHED, &(displays[i].attached));
screen_create_window(&screen_win[i], screen_cxt);
screen_set_window_property_iv(screen_win[i], SCREEN_PROPERTY_FORMAT, &format);
screen_set_window_property_iv(screen_win[i], SCREEN_PROPERTY_USAGE, &usage);
screen_set_window_property_iv(screen_win[i], SCREEN_PROPERTY_SENSITIVITY, &sensitivity);
screen_set_window_property_pv(screen_win[i], SCREEN_PROPERTY_DISPLAY, (void **)&screen_dpy[i]);
egl_disp[i] = eglGetDisplay((EGLNativeDisplayType)i);
eglInitialize(egl_disp[i], NULL, NULL);
if (egl_cont == EGL_NO_CONTEXT) {
eglChooseConfig(egl_disp[0], attrib_list, &egl_conf, 1, &num_configs);
egl_cont = eglCreateContext(egl_disp[0], egl_conf, EGL_NO_CONTEXT, attributes);
}
fprintf(stderr, "Display %i: %s, %s\n", i, displayTypeString(displays[i].type), displays[i].attached ? "Attached" : "Detached");
if (displays[i].attached)
realiseDisplay(i);
}
#ifdef ARM
screen_get_display_property_iv(screen_dpy[0], SCREEN_PROPERTY_DPI, &dpi); // Only internal display has DPI
// We only use dpi to calculate the width. Smaller aspect ratios have giant text despite high DPI.
dpi = dpi * (((float)displays[0].width/(float)displays[0].height) / (16.0/9.0)); // Adjust to 16:9
#else
dpi = 340.0f;
#endif
g_dpi_scale = 210.0f / dpi;
switchDisplay(screen_ui);
}
int
main(int argc, char **argv)
{
const int usage = SCREEN_USAGE_NATIVE;
screen_window_t screen_win;
screen_buffer_t screen_buf = NULL;
int rect[4] = { 0, 0, 0, 0 };
// create an application window which will just act as a background
screen_create_context(&screen_ctx, 0);
screen_create_window(&screen_win, screen_ctx);
screen_create_window_group(screen_win, vf_group);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_create_window_buffers(screen_win, 1);
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)&screen_buf);
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, rect+2);
// fill the window with black
int attribs[] = { SCREEN_BLIT_COLOR, 0x00000000, SCREEN_BLIT_END };
screen_fill(screen_ctx, screen_buf, attribs);
screen_post_window(screen_win, screen_buf, 1, rect, 0);
// position the window at an arbitrary z-order
int i = APP_ZORDER;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &i);
// Signal bps library that navigator and screen events will be requested
bps_initialize();
screen_request_events(screen_ctx);
navigator_request_events(0);
// open camera and configure viewfinder
if (init_camera() == EOK) {
// our main loop just runs a state machine and handles input
while (!shutdown) {
run_state_machine();
// Handle user input
handle_event();
}
if (state == STATE_VIEWFINDER) {
// clean up camera
camera_stop_photo_viewfinder(handle);
camera_close(handle);
}
}
// Clean up
screen_stop_events(screen_ctx);
bps_shutdown();
screen_destroy_window(screen_win);
screen_destroy_context(screen_ctx);
return 0;
}
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
int rc;
int nbuffers = fbconfig->doublebuffer ? 2 : 1;
int format = SCREEN_FORMAT_RGBX8888; // TODO: check fbconfig
int usage = SCREEN_USAGE_OPENGL_ES2|SCREEN_USAGE_OVERLAY; // TODO: check context config
int size[2] = { wndconfig->width, wndconfig->height };
int pos[2] = { 0, 0 };
int interval = 1;
if (!_glfwCreateContext(window, ctxconfig, fbconfig))
return GL_FALSE;
rc = screen_create_window(&window->screen.window, _glfw.screen.context);
if (rc)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"screen: Error creating window %s", strerror(errno));
return GL_FALSE;
}
if (wndconfig->monitor)
{
rc = screen_set_window_property_pv(window->screen.window, SCREEN_PROPERTY_DISPLAY, (void**)&wndconfig->monitor->screen.display);
if (rc)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"screen: Error set window property %s", strerror(errno));
return GL_FALSE;
}
}
rc = screen_set_window_property_iv(window->screen.window, SCREEN_PROPERTY_FORMAT, &format);
if (rc) { _glfwInputError(GLFW_PLATFORM_ERROR, "screen: Failed to set format property: %s", strerror(errno)); return GL_FALSE; }
rc = screen_set_window_property_iv(window->screen.window, SCREEN_PROPERTY_USAGE, &usage);
if (rc) { _glfwInputError(GLFW_PLATFORM_ERROR, "screen: Failed to set usage property: %s", strerror(errno)); return GL_FALSE; }
rc = screen_set_window_property_iv(window->screen.window, SCREEN_PROPERTY_SWAP_INTERVAL, &interval);
if (rc) { _glfwInputError(GLFW_PLATFORM_ERROR, "screen: Failed to set swap interval property: %s", strerror(errno)); return GL_FALSE; }
rc = screen_set_window_property_iv(window->screen.window, SCREEN_PROPERTY_SIZE, size);
if (rc) { _glfwInputError(GLFW_PLATFORM_ERROR, "screen: Failed to set size property: %s", strerror(errno)); return GL_FALSE; }
rc = screen_set_window_property_iv(window->screen.window, SCREEN_PROPERTY_POSITION, pos);
if (rc) { _glfwInputError(GLFW_PLATFORM_ERROR, "screen: Failed to set position property: %s", strerror(errno)); return GL_FALSE; }
rc = screen_create_window_buffers(window->screen.window, nbuffers);
if (rc) { _glfwInputError(GLFW_PLATFORM_ERROR, "screen: Failed to create window buffers: %s", strerror(errno)); return GL_FALSE; }
return GL_TRUE;
}
int setup_screen()
{
/*
* Create the window.
*/
if (screen_create_context(&screen_context, SCREEN_APPLICATION_CONTEXT) != 0)
return EXIT_FAILURE;
if (screen_create_window(&screen_window, screen_context) != 0) {
screen_destroy_context(screen_context);
return EXIT_FAILURE;
}
if (screen_create_window_group(screen_window, WINDOW_GROUP_NAME) != 0)
return EXIT_FAILURE;
int format = SCREEN_FORMAT_RGBA8888;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_FORMAT, &format) != 0)
return EXIT_FAILURE;
int usage = SCREEN_USAGE_NATIVE;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_USAGE, &usage) != 0)
return EXIT_FAILURE;
if (screen_create_window_buffers(screen_window, 1) != 0)
return EXIT_FAILURE;
// Get the render buffer
screen_buffer_t temp_buffer[1];
if (screen_get_window_property_pv( screen_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)temp_buffer) != 0)
return EXIT_FAILURE;
// Fill the buffer with a solid color (green)
int fill_attributes[3] = {SCREEN_BLIT_COLOR, 0x00C000, SCREEN_BLIT_END};
if (screen_fill(screen_context, temp_buffer[0], fill_attributes) != 0)
return EXIT_FAILURE;
// Make the window visible
if (screen_get_window_property_iv(screen_window, SCREEN_PROPERTY_SIZE, screen_size) != 0)
return EXIT_FAILURE;
int temp_rectangle[4] = {0,0,screen_size[0],screen_size[1]};
if (screen_post_window(screen_window, temp_buffer[0], 1, temp_rectangle, 0) != 0)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
/**
* Set up a basic screen, so that the navigator will
* send window state events when the window state changes.
*
* @return @c EXIT_SUCCESS or @c EXIT_FAILURE
*/
int
setup_screen()
{
if (screen_create_context(&screen_ctx, SCREEN_APPLICATION_CONTEXT) != 0) {
return EXIT_FAILURE;
}
if (screen_create_window(&screen_win, screen_ctx) != 0) {
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
int usage = SCREEN_USAGE_NATIVE;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage) != 0) goto fail;
if (screen_create_window_buffers(screen_win, 1) != 0) goto fail;
if (screen_create_window_group(screen_win, get_window_group_id()) != 0) goto fail;
screen_buffer_t buff;
if (screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void*)&buff) != 0) goto fail;
int buffer_size[2];
if (screen_get_buffer_property_iv(buff, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size) != 0) goto fail;
int attribs[1] = {SCREEN_BLIT_END};
if (screen_fill(screen_ctx, buff, attribs) != 0) goto fail;
int dirty_rects[4] = {0, 0, buffer_size[0], buffer_size[1]};
if (screen_post_window(screen_win, buff, 1, (const int*)dirty_rects, 0) != 0) goto fail;
return EXIT_SUCCESS;
fail:
screen_destroy_window(screen_win);
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
bool Game::InitDisplay()
{
/*
* Here specify the attributes of the desired configuration.
* Below, we select an EGLConfig with at least 8 bits per color
* component compatible with on-screen windows
*/
const EGLint attribs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_DEPTH_SIZE, 24,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, //Maybe EGL_CONFORMANT for windows and Android?
EGL_NONE
};
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, 0,
EGL_NONE};
EGLint w, h, format;
EGLint numConfigs;
EGLConfig config[64];
EGLSurface surface;
EGLContext context;
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
int maj;
int min;
eglInitialize(display, &maj, &min);
Log::Debug("EGLInitialise", "EGL Major:%d Minor:%d", maj, min);
/* Here, the application chooses the configuration it desires. In this
* sample, we have a very simplified selection process, where we pick
* the first EGLConfig that matches our criteria */
eglChooseConfig(display, attribs, &config[0], 64, &numConfigs);
for(int i = 0; i < numConfigs; i++)
{
int val[1];
eglGetConfigAttrib(display, config[i], EGL_CONFORMANT, &val[0]);
Log::Debug("EGLInitialise", "EGL_CONFORMANT: %d", val[0]);
Log::Debug("EGLInitialise", "GL2: %d", val[0] & EGL_OPENGL_ES2_BIT);
Log::Debug("EGLInitialise", "GL1: %d", val[0] & EGL_OPENGL_ES_BIT);
}
if(numConfigs == 0)
{
Log::Error("EGLInitialise", "No EGL configs were returned.");
return true;
}
/* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
* guaranteed to be accepted by ANativeWindow_setBuffersGeometry().
* As soon as we picked a EGLConfig, we can safely reconfigure the
* ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */
eglGetConfigAttrib(display, config[0], EGL_NATIVE_VISUAL_ID, &format);
#ifdef ANDROID
ANativeWindow_setBuffersGeometry(mDisplay.app->window, 0, 0, format); //TODO!
surface = eglCreateWindowSurface(display, config[0], mDisplay.app->window, NULL);
#endif
#ifdef _WIN32
mDisplay.WindowHandle = create_window(mDisplay.Width, mDisplay.Height);
surface = EGL_CHECK(eglCreateWindowSurface(display, config[0], (EGLNativeWindowType)mDisplay.WindowHandle, NULL));
#endif
#ifdef __QNX__
int screen_format = SCREEN_FORMAT_RGBX8888;
int usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
int screen_resolution[2];
screen_display_mode_t screen_mode;
int size[2];
int angle = std::atoi(std::getenv("ORIENTATION"));
screen_create_window(&mDisplay.qnx_screen_win, mDisplay.qnx_screen_context);
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_FORMAT, &screen_format);
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_get_window_property_pv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&mDisplay.qnx_screen_disp);
screen_get_display_property_iv(mDisplay.qnx_screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution);
screen_get_display_property_pv(mDisplay.qnx_screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
screen_get_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
int buffer_size[2] = {size[0], size[1]};
if ((angle == 0) || (angle == 180)) {
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else if ((angle == 90) || (angle == 270)){
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else {
return true;
}
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_ROTATION, &angle);
screen_create_window_buffers(mDisplay.qnx_screen_win, 2);
surface = EGL_CHECK(eglCreateWindowSurface(display, config[0], (EGLNativeWindowType)mDisplay.qnx_screen_win, NULL));
#endif
if(surface == EGL_NO_SURFACE) {
Log::Error("EGLInitialise", "EGL Surface creation failed.");
return true;
}
const EGLint attribs2[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
context = eglCreateContext(display, config[0], NULL, attribs2);
if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
Log::Error("EGLInitialise", "Unable to eglMakeCurrent");
return true;
}
#ifdef __QNX__
eglSwapInterval(display, 1);
#endif
eglQuerySurface(display, surface, EGL_WIDTH, &w);
eglQuerySurface(display, surface, EGL_HEIGHT, &h);
mDisplay.Display = display;
mDisplay.Context = context;
mDisplay.Surface = surface;
mDisplay.Width = w;
mDisplay.Height = h;
mTP->camera->SetResolution(Vector2f((float)mDisplay.Width, (float)mDisplay.Height));
// Initialize GL state.
GL_CHECK(glViewport(0, 0, w, h));
GL_CHECK(glEnable(GL_DEPTH_TEST));
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GL_CHECK(glEnable(GL_BLEND));
GL_CHECK(glEnable(GL_ALPHA));
Effect::CacheTick(*mTP, EffectClearLevel::Initialise);
Texture::CacheTick(*mTP, TextureClearLevel::Initialise);
Font::CacheTick(*mTP, FontClearLevel::Initialise);
//Initialise graphics
for(std::vector<GameObject*>::iterator it = mGO.begin(); it != mGO.end(); ++it)
{
(*it)->InitialiseGraphics(*mTP);
}
return false;
}
int
bbutil_init_egl(screen_context_t ctx, enum RENDERING_API api) {
int usage;
int format = SCREEN_FORMAT_RGBX8888;
EGLint interval = 1;
int rc, num_configs;
EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE};
if (api == GL_ES_1) {
usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
} else if (api == GL_ES_2) {
attrib_list[11] = EGL_OPENGL_ES2_BIT;
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
} else if (api == VG) {
attrib_list[11] = EGL_OPENVG_BIT;
usage = SCREEN_USAGE_OPENVG | SCREEN_USAGE_ROTATION;
} else {
fprintf(stderr, "invalid api setting\n");
return EXIT_FAILURE;
}
//Simple egl initialization
screen_ctx = ctx;
egl_disp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (egl_disp == EGL_NO_DISPLAY) {
bbutil_egl_perror("eglGetDisplay");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = eglInitialize(egl_disp, NULL, NULL);
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglInitialize");
bbutil_terminate();
return EXIT_FAILURE;
}
if ((api == GL_ES_1) || (api == GL_ES_2)) {
rc = eglBindAPI(EGL_OPENGL_ES_API);
} else if (api == VG) {
rc = eglBindAPI(EGL_OPENVG_API);
}
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglBindApi");
bbutil_terminate();
return EXIT_FAILURE;
}
if(!eglChooseConfig(egl_disp, attrib_list, &egl_conf, 1, &num_configs)) {
bbutil_terminate();
return EXIT_FAILURE;
}
if (api == GL_ES_2) {
egl_ctx = eglCreateContext(egl_disp, egl_conf, EGL_NO_CONTEXT, attributes);
} else {
egl_ctx = eglCreateContext(egl_disp, egl_conf, EGL_NO_CONTEXT, NULL);
}
if (egl_ctx == EGL_NO_CONTEXT) {
bbutil_egl_perror("eglCreateContext");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_create_window(&screen_win, screen_ctx);
if (rc) {
perror("screen_create_window");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp);
if (rc) {
perror("screen_get_window_property_pv");
bbutil_terminate();
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc) {
perror("screen_get_display_property_pv");
bbutil_terminate();
return EXIT_FAILURE;
}
int size[2];
rc = screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc) {
perror("screen_get_window_property_iv");
bbutil_terminate();
return EXIT_FAILURE;
}
int buffer_size[2] = {size[0], size[1]};
if ((angle == 0) || (angle == 180)) {
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else if ((angle == 90) || (angle == 270)){
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else {
fprintf(stderr, "Navigator returned an unexpected orientation angle.\n");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
if (rc) {
perror("screen_set_window_property_iv");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle);
if (rc) {
perror("screen_set_window_property_iv");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_create_window_buffers(screen_win, nbuffers);
if (rc) {
perror("screen_create_window_buffers");
bbutil_terminate();
return EXIT_FAILURE;
}
egl_surf = eglCreateWindowSurface(egl_disp, egl_conf, screen_win, NULL);
if (egl_surf == EGL_NO_SURFACE) {
bbutil_egl_perror("eglCreateWindowSurface");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = eglMakeCurrent(egl_disp, egl_surf, egl_surf, egl_ctx);
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglMakeCurrent");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = eglSwapInterval(egl_disp, interval);
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglSwapInterval");
bbutil_terminate();
return EXIT_FAILURE;
}
initialized = 1;
return EXIT_SUCCESS;
}
// Video
int init_GLES2(screen_context_t ctx) {
int usage = SCREEN_USAGE_ROTATION | SCREEN_USAGE_OPENGL_ES2;
int format = SCREEN_FORMAT_RGBX8888;
int num_configs;
EGLint attrib_list[]= {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE};
const EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
const EGLint egl_surfaceAttr[] = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE };
screen_ctx = ctx;
screen_create_window(&screen_win, screen_ctx);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp);
// This must be landscape.
int screen_resolution[2];
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution);
int angle = atoi(getenv("ORIENTATION"));
pixel_xres = screen_resolution[0]; pixel_yres = screen_resolution[1];
screen_display_mode_t screen_mode;
screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
int size[2];
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
int buffer_size[2] = {size[0], size[1]};
if ((angle == 0) || (angle == 180)) {
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
pixel_yres = screen_resolution[0];
pixel_xres = screen_resolution[1];
}
} else if ((angle == 90) || (angle == 270)){
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
pixel_yres = screen_resolution[0];
pixel_xres = screen_resolution[1];
}
}
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle);
screen_create_window_buffers(screen_win, 2); // Double buffered
egl_disp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(egl_disp, NULL, NULL);
eglChooseConfig(egl_disp, attrib_list, &egl_conf, 1, &num_configs);
egl_ctx = eglCreateContext(egl_disp, egl_conf, EGL_NO_CONTEXT, attributes);
egl_surf = eglCreateWindowSurface(egl_disp, egl_conf, screen_win, egl_surfaceAttr);
eglMakeCurrent(egl_disp, egl_surf, egl_surf, egl_ctx);
eglSwapInterval(egl_disp, 1);
return 0;
}
int main(int argc, char *argv[]) {
char windowGroupId[64] = {0};
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt, 0);
// Get the application's window group id so that it can be passed the identity library in cases
// where a user may need to be interacted with on the application's behalf.
screen_create_window(&screen_wnd, screen_cxt);
screen_create_window_group( screen_wnd, NULL );
screen_get_window_property_cv( screen_wnd, SCREEN_PROPERTY_GROUP, sizeof( windowGroupId ), windowGroupId );
//Initialize BPS library
bps_initialize();
//Use utility code to initialize EGL for rendering with GL ES 1.1
if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt)) {
fprintf(stderr, "bbutil_init_egl failed\n");
bbutil_terminate();
screen_destroy_window(screen_wnd);
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize application logic
if (EXIT_SUCCESS != initialize()) {
fprintf(stderr, "initialize failed\n");
bbutil_terminate();
screen_destroy_window(screen_wnd);
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator and screen events will be requested
if (BPS_SUCCESS != screen_request_events(screen_cxt)) {
fprintf(stderr, "screen_request_events failed\n");
bbutil_terminate();
screen_destroy_window(screen_wnd);
screen_destroy_context(screen_cxt);
return 0;
}
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "navigator_request_events failed\n");
bbutil_terminate();
screen_destroy_window(screen_wnd);
screen_destroy_context(screen_cxt);
return 0;
}
if( EXIT_SUCCESS != identity_initialize( windowGroupId ) ) {
fprintf(stderr, "Initialization of IDS Library failed\n");
bbutil_terminate();
screen_destroy_window(screen_wnd);
screen_destroy_context(screen_cxt);
return 0;
}
identity_trigger_get_username();
// ENTER APPLICATION EVENT LOOP
while (!shutdown) {
// Handle bps events, includes input and fd changes
handle_events();
}
identity_shutdown();
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Use utility code to terminate EGL setup
bbutil_terminate();
//Shut down BPS library for this process
bps_shutdown();
screen_destroy_window(screen_wnd);
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
bool CCEGLView::initGL()
{
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
#ifdef __X86__
int screenUsage = SCREEN_USAGE_OPENGL_ES2;
#else
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2; // Physical device copy directly into physical display
#endif
// int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
int angle = atoi(getenv("ORIENTATION"));
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
EGLConfig config;
// Hard-coded to 32-bit/OpenGL ES 2.0.
const EGLint eglConfigAttrs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&m_screenContext, 0);
if (rc)
{
perror("screen_create_context");
return false;
}
// Create the screen window.
rc = screen_create_window(&m_screenWindow, m_screenContext);
if (rc)
{
perror("screen_create_window");
return false;
}
// Set/get any window prooperties.
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return false;
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
return false;
}
char *width_str = getenv("WIDTH");
char *height_str = getenv("HEIGHT");
if (width_str && height_str)
{
int screen_res[2];
screen_res[0] = atoi(width_str);
screen_res[1] = atoi(height_str);
int rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, screen_res);
if (rc)
{
fprintf(stderr, "screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
return false;
}
}
else
{
screen_display_t screen_display;
rc = screen_get_window_property_pv(m_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
return false;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
return false;
}
int size[2];
rc = screen_get_window_property_iv(m_screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
return false;
}
int buffer_size[2] = { size[0], size[1] };
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
return false;
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
return false;
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
return false;
}
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
return false;
}
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
return false;
}
// Double buffered.
rc = screen_create_window_buffers(m_screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
return false;
}
// Create screen event object.
rc = screen_create_event(&m_screenEvent);
if (rc)
{
perror("screen_create_event");
return false;
}
// Request screen events.
screen_request_events(m_screenContext);
// Get the EGL display and initialize.
m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (m_eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
return false;
}
if (eglInitialize(m_eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
return false;
}
if (eglChooseConfig(m_eglDisplay, eglConfigAttrs, &config, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
checkErrorEGL("eglChooseConfig");
return false;
}
m_eglContext = eglCreateContext(m_eglDisplay, config, EGL_NO_CONTEXT, eglContextAttrs);
if (m_eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
return false;
}
m_eglSurface = eglCreateWindowSurface(m_eglDisplay, config, m_screenWindow, eglSurfaceAttrs);
if (m_eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
return false;
}
if (eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
return false;
}
EGLint width, height;
if ((m_eglDisplay == EGL_NO_DISPLAY) || (m_eglSurface == EGL_NO_SURFACE) )
return EXIT_FAILURE;
eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &width);
eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_HEIGHT, &height);
m_obScreenSize.width = width;
m_obScreenSize.height = height;
// Set vsync.
// eglSwapInterval(m_eglDisplay, screenSwapInterval);
return true;
}
int OpenGLView::initGL()
{
int numberDisplays;
int numberModes;
int returnCode;
EGLBoolean status;
int type;
EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE};
// try this first as it will fail if an HDMI display is not attached
if (m_api == GL_ES_2) {
m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, attributes);
} else {
m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, NULL);
}
if (m_egl_ctx == EGL_NO_CONTEXT) {
perror("eglCreateContext");
return EXIT_FAILURE;
}
screen_get_context_property_iv(m_screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &numberDisplays);
m_screen_dpy = (screen_display_t *)calloc(numberDisplays, sizeof(screen_display_t));
screen_get_context_property_pv(m_screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)m_screen_dpy);
for (int index = 0; index < numberDisplays; index++) {
int displayID;
returnCode = screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_ID, (int *)&displayID);
if (returnCode) {
perror("display ID");
return EXIT_FAILURE;
} else {
if (displayID == m_display) {
screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_create_window(&m_screen_win, m_screen_ctx);
if (returnCode) {
perror("screen_create_window");
return EXIT_FAILURE;
}
} else {
returnCode = screen_create_window_type(&m_screen_win, m_screen_ctx, SCREEN_CHILD_WINDOW);
if (returnCode) {
perror("screen_create_window (child window)");
return EXIT_FAILURE;
}
}
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_set_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&(m_screen_dpy[index]));
if (returnCode) {
perror("window display");
return EXIT_FAILURE;
}
}
}
}
}
qDebug() << "OpenGLView::initialize: "<< m_screen_ctx << ":" << m_egl_disp << ":" << m_egl_conf << ":" << m_egl_ctx << ":" << m_screen_win;
int format = SCREEN_FORMAT_RGBA8888;
returnCode = screen_set_window_property_iv(m_screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (returnCode) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return EXIT_FAILURE;
}
if (m_transparency > 0) {
returnCode = setWindowTransparency(m_transparency);
if (returnCode) {
perror("transparency");
return EXIT_FAILURE;
}
}
returnCode = screen_get_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&m_screen_disp);
if (returnCode) {
perror("screen_get_window_property_pv");
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_get_display_property_iv(m_screen_disp, SCREEN_PROPERTY_MODE_COUNT, &numberModes);
m_screen_modes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t));
returnCode = screen_get_display_property_pv(m_screen_disp, SCREEN_PROPERTY_MODE, (void**)m_screen_modes);
if (returnCode) {
perror("screen modes");
return EXIT_FAILURE;
}
int dpi = calculateDPI();
if (dpi == EXIT_FAILURE) {
fprintf(stderr, "Unable to calculate dpi\n");
return EXIT_FAILURE;
}
returnCode = setWindowPosition(m_x, m_y);
if (returnCode) {
perror("window position");
return EXIT_FAILURE;
}
returnCode = setWindowSize(m_width, m_height);
if (returnCode) {
perror("window size");
return EXIT_FAILURE;
}
returnCode = setWindowZ(m_z);
if (returnCode) {
perror("z order");
return EXIT_FAILURE;
}
returnCode = setWindowBufferSize(m_width, m_height);
if (returnCode) {
perror("buffer size");
return EXIT_FAILURE;
}
returnCode = setWindowAngle(m_angle);
if (returnCode) {
perror("angle");
return EXIT_FAILURE;
}
returnCode = screen_create_window_buffers(m_screen_win, m_nbuffers);
if (returnCode) {
perror("screen_create_window_buffers");
return EXIT_FAILURE;
}
if (m_api == GL_ES_1) {
m_usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
} else if (m_api == GL_ES_2) {
attrib_list[9] = EGL_OPENGL_ES2_BIT;
m_usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
} else if (m_api == VG) {
attrib_list[9] = EGL_OPENVG_BIT;
m_usage = SCREEN_USAGE_OPENVG | SCREEN_USAGE_ROTATION;
} else {
fprintf(stderr, "invalid api setting\n");
return EXIT_FAILURE;
}
returnCode = setWindowUsage(m_usage);
if (returnCode) {
perror("screen_set_window_property_iv(window usage)");
return EXIT_FAILURE;
}
qDebug() << "OpenGLView::initGL:eglCreateContext "<< m_egl_ctx;
m_egl_surf = eglCreateWindowSurface(m_egl_disp, m_egl_conf, m_screen_win, NULL);
if (m_egl_surf == EGL_NO_SURFACE) {
OpenGLThread::eglPrintError("eglCreateWindowSurface");
return EXIT_FAILURE;
}
getGLContext();
EGLint interval = 1;
status = eglSwapInterval(m_egl_disp, interval);
if (status != EGL_TRUE) {
OpenGLThread::eglPrintError("eglSwapInterval");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_WIDTH, &m_surface_width);
if (status != EGL_TRUE) {
perror("query surface width");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_HEIGHT, &m_surface_height);
if (status != EGL_TRUE) {
perror("query surface height");
return EXIT_FAILURE;
}
returnCode = joinWindowGroup(m_group);
if (returnCode) {
perror("window group");
return EXIT_FAILURE;
}
returnCode = setScreenWindowID(m_id);
if (returnCode) {
perror("window ID");
return EXIT_FAILURE;
}
qDebug() << "OpenGLView::initGL: "<< angle << ":" << numberModes << ":" << m_screen_modes[0].width << ":" << m_screen_modes[0].height << ":" << m_egl_disp << ":" << dpi;
setInitialized(true);
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
int card = -1;
int dev = 0;
snd_pcm_t *pcm_handle;
FILE *file;
wave_hdr wav_header;
int samples;
int sample_rate;
int sample_channels;
int sample_bits;
char *sample_buffer;
int fragsize = -1;
int verbose = 0;
int rtn;
int final_return_code = -1;
snd_pcm_channel_info_t pi;
snd_mixer_t *mixer_handle;
snd_mixer_group_t group;
snd_pcm_channel_params_t pp;
snd_pcm_channel_setup_t setup;
int bsize, bytes_read, total_written = 0;
fd_set rfds, wfds;
uint32_t voice_mask[] = { 0, 0, 0, 0 };
snd_pcm_voice_conversion_t voice_conversion;
int voice_override = 0;
int num_frags = -1;
char input_file[PATH_MAX];
char cwd[PATH_MAX];
screen_context_t screen_cxt;
screen_window_t screen_win;
screen_buffer_t screen_buf;
int screen_fill_attribs[] = { SCREEN_BLIT_COLOR, COLOR_PURPLE, SCREEN_BLIT_END };
int screen_dirty[4] = { 0, 0, 1024, 600 }; //start with sane default values
int idle_mode = SCREEN_IDLE_MODE_KEEP_AWAKE;
int usage = SCREEN_USAGE_NATIVE;
if (screen_create_context(&screen_cxt, 0) != 0)
{
return err("failed to create context");
}
if (screen_create_window(&screen_win, screen_cxt) != 0)
{
err("failed to create window");
goto fail1;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage) != 0)
{
err("failed to set native usage mode");
goto fail2;
}
if (screen_create_window_buffers(screen_win, 1) != 0)
{
err("failed to set native usage mode");
goto fail2;
}
if(screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)&screen_buf) != 0)
{
err("failed to get screen buffer");
goto fail2;
}
if (screen_fill(screen_cxt, screen_buf, screen_fill_attribs) != 0) {
err("failed to fill the screen");
goto fail3;
}
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, screen_dirty+2) != 0) {
err("failed to get window size");
goto fail3;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_IDLE_MODE, &idle_mode) != 0)
{
err("failed to set idle mode");
goto fail3;
}
if (screen_post_window(screen_win, screen_buf, 1, screen_dirty, 0) != 0) {
err("failed to post the window");
goto fail3;
}
if ((rtn = snd_pcm_open_preferred (&pcm_handle, &card, &dev, SND_PCM_OPEN_PLAYBACK)) < 0)
{
err ("device open");
goto fail3;
}
getcwd(cwd, PATH_MAX);
rtn = snprintf(input_file, PATH_MAX, "%s%s", cwd, WAV_RELATIVE_PATH);
if (rtn > PATH_MAX - 1)
{
err ("File name and path too long");
goto fail4;
}
if ((file = fopen (input_file, "r")) == 0)
{
err ("File open failed");
goto fail4;
}
if (check_hdr (file) == -1) {
err ("check_hdr failed");
goto fail5;
}
samples = find_tag (file, "fmt ");
fread (&wav_header, sizeof (wav_header), 1, file);
fseek (file, (samples - sizeof (wave_hdr)), SEEK_CUR);
sample_rate = ENDIAN_LE32 (wav_header.samples_per_sec);
sample_channels = ENDIAN_LE16 (wav_header.channels);
sample_bits = ENDIAN_LE16 (wav_header.bits_per_sample);
printf ("SampleRate = %d, channels = %d, SampleBits = %d\n", sample_rate, sample_channels,
sample_bits);
/* disabling mmap is not actually required in this example but it is included to
* demonstrate how it is used when it is required.
*/
if ((rtn = snd_pcm_plugin_set_disable (pcm_handle, PLUGIN_DISABLE_MMAP)) < 0)
{
fprintf (stderr, "snd_pcm_plugin_set_disable failed: %s\n", snd_strerror (rtn));
goto fail5;
}
memset (&pi, 0, sizeof (pi));
pi.channel = SND_PCM_CHANNEL_PLAYBACK;
if ((rtn = snd_pcm_plugin_info (pcm_handle, &pi)) < 0)
{
fprintf (stderr, "snd_pcm_plugin_info failed: %s\n", snd_strerror (rtn));
goto fail5;
}
memset (&pp, 0, sizeof (pp));
pp.mode = SND_PCM_MODE_BLOCK;
pp.channel = SND_PCM_CHANNEL_PLAYBACK;
pp.start_mode = SND_PCM_START_FULL;
pp.stop_mode = SND_PCM_STOP_STOP;
pp.buf.block.frag_size = pi.max_fragment_size;
if (fragsize != -1)
{
pp.buf.block.frag_size = fragsize;
}
pp.buf.block.frags_max = num_frags;
pp.buf.block.frags_min = 1;
pp.format.interleave = 1;
pp.format.rate = sample_rate;
pp.format.voices = sample_channels;
if (ENDIAN_LE16 (wav_header.format_tag) == 6)
pp.format.format = SND_PCM_SFMT_A_LAW;
else if (ENDIAN_LE16 (wav_header.format_tag) == 7)
pp.format.format = SND_PCM_SFMT_MU_LAW;
else if (sample_bits == 8)
pp.format.format = SND_PCM_SFMT_U8;
else if (sample_bits == 24)
pp.format.format = SND_PCM_SFMT_S24;
else
pp.format.format = SND_PCM_SFMT_S16_LE;
strcpy (pp.sw_mixer_subchn_name, "Wave playback channel");
if ((rtn = snd_pcm_plugin_params (pcm_handle, &pp)) < 0)
{
fprintf (stderr, "snd_pcm_plugin_params failed: %s\n", snd_strerror (rtn));
goto fail5;
}
if ((rtn = snd_pcm_plugin_prepare (pcm_handle, SND_PCM_CHANNEL_PLAYBACK)) < 0) {
fprintf (stderr, "snd_pcm_plugin_prepare failed: %s\n", snd_strerror (rtn));
goto fail5;
}
if (voice_override)
{
snd_pcm_plugin_get_voice_conversion (pcm_handle, SND_PCM_CHANNEL_PLAYBACK,
&voice_conversion);
voice_conversion.matrix[0] = voice_mask[0];
voice_conversion.matrix[1] = voice_mask[1];
voice_conversion.matrix[2] = voice_mask[2];
voice_conversion.matrix[3] = voice_mask[3];
snd_pcm_plugin_set_voice_conversion (pcm_handle, SND_PCM_CHANNEL_PLAYBACK,
&voice_conversion);
}
memset (&setup, 0, sizeof (setup));
memset (&group, 0, sizeof (group));
setup.channel = SND_PCM_CHANNEL_PLAYBACK;
setup.mixer_gid = &group.gid;
if ((rtn = snd_pcm_plugin_setup (pcm_handle, &setup)) < 0)
{
fprintf (stderr, "snd_pcm_plugin_setup failed: %s\n", snd_strerror (rtn));
goto fail5;
}
printf ("Format %s \n", snd_pcm_get_format_name (setup.format.format));
printf ("Frag Size %d \n", setup.buf.block.frag_size);
printf ("Total Frags %d \n", setup.buf.block.frags);
printf ("Rate %d \n", setup.format.rate);
printf ("Voices %d \n", setup.format.voices);
bsize = setup.buf.block.frag_size;
if (group.gid.name[0] == 0)
{
fprintf (stderr, "Mixer Pcm Group [%s] Not Set \n", group.gid.name);
goto fail5;
}
printf ("Mixer Pcm Group [%s]\n", group.gid.name);
if ((rtn = snd_mixer_open (&mixer_handle, card, setup.mixer_device)) < 0)
{
fprintf (stderr, "snd_mixer_open failed: %s\n", snd_strerror (rtn));
goto fail5;
}
samples = find_tag (file, "data");
sample_buffer = malloc (bsize);
FD_ZERO (&rfds);
FD_ZERO (&wfds);
bytes_read = 1;
while (total_written < samples && bytes_read > 0)
{
if (tcgetpgrp (0) == getpid ())
FD_SET (STDIN_FILENO, &rfds);
FD_SET (snd_mixer_file_descriptor (mixer_handle), &rfds);
FD_SET (snd_pcm_file_descriptor (pcm_handle, SND_PCM_CHANNEL_PLAYBACK), &wfds);
rtn = max (snd_mixer_file_descriptor (mixer_handle),
snd_pcm_file_descriptor (pcm_handle, SND_PCM_CHANNEL_PLAYBACK));
if (select (rtn + 1, &rfds, &wfds, NULL, NULL) == -1)
{
err ("select");
goto fail6;
}
if (FD_ISSET (snd_pcm_file_descriptor (pcm_handle, SND_PCM_CHANNEL_PLAYBACK), &wfds))
{
snd_pcm_channel_status_t status;
int written = 0;
if ((bytes_read = fread (sample_buffer, 1, min (samples - total_written, bsize), file)) <= 0)
continue;
written = snd_pcm_plugin_write (pcm_handle, sample_buffer, bytes_read);
if (verbose)
printf ("bytes written = %d \n", written);
if (written < bytes_read)
{
memset (&status, 0, sizeof (status));
status.channel = SND_PCM_CHANNEL_PLAYBACK;
if (snd_pcm_plugin_status (pcm_handle, &status) < 0)
{
fprintf (stderr, "underrun: playback channel status error\n");
goto fail6;
}
if (status.status == SND_PCM_STATUS_READY ||
status.status == SND_PCM_STATUS_UNDERRUN)
{
if (snd_pcm_plugin_prepare (pcm_handle, SND_PCM_CHANNEL_PLAYBACK) < 0)
{
fprintf (stderr, "underrun: playback channel prepare error\n");
goto fail6;
}
}
if (written < 0)
written = 0;
written += snd_pcm_plugin_write (pcm_handle, sample_buffer + written, bytes_read - written);
}
total_written += written;
}
}
bytes_read = snd_pcm_plugin_flush (pcm_handle, SND_PCM_CHANNEL_PLAYBACK);
final_return_code = 0;
fail6:
rtn = snd_mixer_close (mixer_handle);
fail5:
fclose (file);
fail4:
rtn = snd_pcm_close (pcm_handle);
fail3:
screen_destroy_buffer(screen_buf);
fail2:
screen_destroy_window(screen_win);
fail1:
screen_destroy_context(screen_cxt);
return final_return_code;
}
int
initialize_egl_window(screen_context_t ctx, char * window_group_name) {
int usage = SCREEN_USAGE_OPENGL_ES1;
int format = SCREEN_FORMAT_RGBA8888;
int sensitivity = SCREEN_SENSITIVITY_ALWAYS;
int rc, num_configs;
// must be 2 for RGBA8888
const int num_window_buffers = 2;
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE};
// Simple egl initialization
g_screen_ctx = ctx;
g_egl_disp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (g_egl_disp == EGL_NO_DISPLAY) {
egl_perror("eglGetDisplay");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = eglInitialize(g_egl_disp, NULL, NULL);
if (rc != EGL_TRUE) {
egl_perror("eglInitialize");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = eglBindAPI(EGL_OPENGL_ES_API);
if (rc != EGL_TRUE) {
egl_perror("eglBindApi");
terminate_egl_window();
return EXIT_FAILURE;
}
if(!eglChooseConfig(g_egl_disp, attrib_list, &g_egl_conf, 1, &num_configs)) {
terminate_egl_window();
fprintf(stderr, "eglChooseConfig failed\n");
return EXIT_FAILURE;
}
g_egl_ctx = eglCreateContext(g_egl_disp, g_egl_conf, EGL_NO_CONTEXT, NULL);
if (g_egl_ctx == EGL_NO_CONTEXT) {
egl_perror("eglCreateContext");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = screen_create_window(&g_screen_win, g_screen_ctx);
if (rc) {
perror("screen_create_window");
terminate_egl_window();
return EXIT_FAILURE;
}
/* Create the window group for our window, this is important, as we pass
* the group name to MMR which uses it to 'parent' it's CHILD_WINDOW
* which contains the video.
*/
if (screen_create_window_group(g_screen_win, window_group_name) != 0) {
perror("screen_create_window_group");
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(g_screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(g_screen_win, SCREEN_PROPERTY_USAGE, &usage);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(g_screen_win, SCREEN_PROPERTY_SENSITIVITY, &sensitivity);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_SENSITIVITY)");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = screen_get_window_property_pv(g_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&g_screen_disp);
if (rc) {
perror("screen_get_window_property_pv");
terminate_egl_window();
return EXIT_FAILURE;
}
const char *env = getenv("WIDTH");
if (0 == env) {
perror("failed getenv for WIDTH");
terminate_egl_window();
return EXIT_FAILURE;
}
int width = atoi(env);
env = getenv("HEIGHT");
if (0 == env) {
perror("failed getenv for HEIGHT");
terminate_egl_window();
return EXIT_FAILURE;
}
int height = atoi(env);
int size[2] = { width, height };
rc = screen_set_window_property_iv(g_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc) {
perror("screen_set_window_property_iv");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = screen_create_window_buffers(g_screen_win, num_window_buffers);
if (rc) {
perror("screen_create_window_buffers");
terminate_egl_window();
return EXIT_FAILURE;
}
g_egl_surf = eglCreateWindowSurface(g_egl_disp, g_egl_conf, g_screen_win, NULL);
if (g_egl_surf == EGL_NO_SURFACE) {
egl_perror("eglCreateWindowSurface");
terminate_egl_window();
return EXIT_FAILURE;
}
rc = eglMakeCurrent(g_egl_disp, g_egl_surf, g_egl_surf, g_egl_ctx);
if (rc != EGL_TRUE) {
egl_perror("eglMakeCurrent");
terminate_egl_window();
return EXIT_FAILURE;
}
// Set the clear color to be transparent
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
return EXIT_SUCCESS;
}
QT_BEGIN_NAMESPACE
/*!
\class QQnxWindow
\brief The QQnxWindow is the base class of the various classes used as instances of
QPlatformWindow in the QNX QPA plugin.
The standard properties and methods available in Qt are not a perfect match for the
features provided by the QNX screen service. While for the majority of applications
the default behavior suffices, some circumstances require greater control over the
interaction with screen.
\section1 Window Types
The QNX QPA plugin can operate in two modes, with or without a root window. The
selection of mode is made via the \e rootwindow and \e no-rootwindow options to the
plugin. The default mode is rootwindow for BlackBerry builds and no-rootwindow for
non-BlackBerry builds.
Windows with parents are always created as child windows, the difference in the modes
is in the treatment of parentless windows. In no-rootwindow mode, these windows are
created as application windows while in rootwindow mode, the first window on a screen
is created as an application window while subsequent windows are created as child
windows. The only exception to this is any window of type Qt::Desktop or Qt::CoverWindow;
these are created as application windows, but will never become the root window,
even if they are the first window created.
It is also possible to create a parentless child window. These may be useful to
create windows that are parented by windows from other processes. To do this, you
attach a dynamic property \e qnxInitialWindowGroup to the QWindow though this must be done
prior to the platform window class (this class) being created which typically happens
when the window is made visible. When the window is created in QML, it is acceptable
to have the \e visible property hardcoded to true so long as the qnxInitialWindowGroup
is also set.
\section1 Joining Window Groups
Window groups may be joined in a number of ways, some are automatic based on
predefined rules though an application is also able to provide explicit control.
A QWindow that has a parent will join its parent's window group. When rootwindow mode
is in effect, all but the first parentless window on a screen will be child windows
and join the window group of the first parentless window, the root window.
If a QWindow has a valid dynamic property called \e qnxInitialWindowGroup at the time the
QQnxWindow is created, the window will be created as a child window and, if the
qnxInitialWindowGroup property is a non-empty string, an attempt will be made to join that
window group. This has an effect only when the QQnxWindow is created, subsequent
changes to this property are ignored. Setting the property to an empty string
provides a means to create 'top level' child windows without automatically joining
any group. Typically when this property is used \e qnxWindowId should be used as well
so that the process that owns the window group being joined has some means to
identify the window.
At any point following the creation of the QQnxWindow object, an application can
change the window group it has joined. This is done by using the \e
setWindowProperty function of the native interface to set the \e qnxWindowGroup property
to the desired value, for example:
\code
QQuickView *view = new QQuickView(parent);
view->create();
QGuiApplication::platformNativeInterface()->setWindowProperty(view->handle(), "qnxWindowGroup",
group);
\endcode
To leave the current window group, one passes a null value for the property value,
for example:
\code
QQuickView *view = new QQuickView(parent);
view->create();
QGuiApplication::platformNativeInterface()->setWindowProperty(view->handle(), "qnxWindowGroup",
QVariant());
\endcode
\section1 Window Id
The screen window id string property can be set on a window by assigning the desired
value to a dynamic property \e qnxWindowId on the QWindow prior to the QQnxWindow having
been created. This is often wanted when one joins a window group belonging to a
different process.
*/
QQnxWindow::QQnxWindow(QWindow *window, screen_context_t context, bool needRootWindow)
: QPlatformWindow(window),
m_screenContext(context),
m_window(0),
m_screen(0),
m_parentWindow(0),
m_visible(false),
m_exposed(true),
m_windowState(Qt::WindowNoState),
m_mmRendererWindow(0)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window << ", size =" << window->size();
QQnxScreen *platformScreen = static_cast<QQnxScreen *>(window->screen()->handle());
// If a qnxInitialWindowGroup property is set on the window we'll take this as an
// indication that we want to create a child window and join that window group.
const QVariant windowGroup = window->property("qnxInitialWindowGroup");
if (window->type() == Qt::CoverWindow) {
// Cover windows have to be top level to be accessible to window delegate (i.e. navigator)
// Desktop windows also need to be toplevel because they are not
// supposed to be part of the window hierarchy tree
m_isTopLevel = true;
} else if (parent() || windowGroup.isValid()) {
// If we have a parent we are a child window. Sometimes we have to be a child even if we
// don't have a parent e.g. our parent might be in a different process.
m_isTopLevel = false;
} else {
// We're parentless. If we're not using a root window, we'll always be a top-level window
// otherwise only the first window is.
m_isTopLevel = !needRootWindow || !platformScreen->rootWindow();
}
if (window->type() == Qt::Desktop) // A desktop widget does not need a libscreen window
return;
if (m_isTopLevel) {
Q_SCREEN_CRITICALERROR(screen_create_window(&m_window, m_screenContext),
"Could not create top level window"); // Creates an application window
if (window->type() != Qt::CoverWindow) {
if (needRootWindow)
platformScreen->setRootWindow(this);
}
} else {
Q_SCREEN_CHECKERROR(
screen_create_window_type(&m_window, m_screenContext, SCREEN_CHILD_WINDOW),
"Could not create child window");
}
createWindowGroup();
// If the window has a qnxWindowId property, set this as the string id property. This generally
// needs to be done prior to joining any group as it might be used by the owner of the
// group to identify the window.
const QVariant windowId = window->property("qnxWindowId");
if (windowId.isValid() && windowId.canConvert<QByteArray>()) {
QByteArray id = windowId.toByteArray();
Q_SCREEN_CHECKERROR(screen_set_window_property_cv(m_window, SCREEN_PROPERTY_ID_STRING,
id.size(), id), "Failed to set id");
}
// If a window group has been provided join it now. If it's an empty string that's OK too,
// it'll cause us not to join a group (the app will presumably join at some future time).
if (windowGroup.isValid() && windowGroup.canConvert<QByteArray>())
joinWindowGroup(windowGroup.toByteArray());
}
static void *gfx_ctx_qnx_init(video_frame_info_t *video_info, void *video_driver)
{
EGLint n;
EGLint major, minor;
EGLint context_attributes[] = {
#ifdef HAVE_OPENGLES2
EGL_CONTEXT_CLIENT_VERSION, 2,
#elif HAVE_OPENGLES3
EGL_CONTEXT_CLIENT_VERSION, 3,
#endif
EGL_NONE
};
const EGLint attribs[] = {
#ifdef HAVE_OPENGLES2
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#elif HAVE_OPENGLES3
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
#endif
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
qnx_ctx_data_t *qnx = (qnx_ctx_data_t*)calloc(1, sizeof(*qnx));
if (!qnx)
goto screen_error;
/* Create a screen context that will be used to
* create an EGL surface to receive libscreen events */
RARCH_LOG("Initializing screen context...\n");
if (!screen_ctx)
{
screen_create_context(&screen_ctx, 0);
if (screen_request_events(screen_ctx) != BPS_SUCCESS)
{
RARCH_ERR("screen_request_events failed.\n");
goto screen_error;
}
if (navigator_request_events(0) != BPS_SUCCESS)
{
RARCH_ERR("navigator_request_events failed.\n");
goto screen_error;
}
if (navigator_rotation_lock(false) != BPS_SUCCESS)
{
RARCH_ERR("navigator_location_lock failed.\n");
goto screen_error;
}
}
#ifdef HAVE_EGL
if (!egl_init_context(&qnx->egl, EGL_NONE, EGL_DEFAULT_DISPLAY, &major, &minor,
&n, attribs))
{
egl_report_error();
goto error;
}
if (!egl_create_context(&qnx->egl, context_attributes))
{
egl_report_error();
goto error;
}
#endif
if(!screen_win)
{
if (screen_create_window(&screen_win, screen_ctx))
{
RARCH_ERR("screen_create_window failed:.\n");
goto error;
}
}
int format = SCREEN_FORMAT_RGBX8888;
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_FORMAT, &format))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_FORMAT] failed.\n");
goto error;
}
int usage;
#ifdef HAVE_OPENGLES2
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
#elif HAVE_OPENGLES3
usage = SCREEN_USAGE_OPENGL_ES3 | SCREEN_USAGE_ROTATION;
#endif
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_USAGE, &usage))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_USAGE] failed.\n");
goto error;
}
if (screen_get_window_property_pv(screen_win,
SCREEN_PROPERTY_DISPLAY, (void **)&qnx->screen_disp))
{
RARCH_ERR("screen_get_window_property_pv [SCREEN_PROPERTY_DISPLAY] failed.\n");
goto error;
}
int screen_resolution[2];
if (screen_get_display_property_iv(qnx->screen_disp,
SCREEN_PROPERTY_SIZE, screen_resolution))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_SIZE] failed.\n");
goto error;
}
#ifndef HAVE_BB10
int angle, size[2];
angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(qnx->screen_disp,
SCREEN_PROPERTY_MODE, (void**)&screen_mode))
{
RARCH_ERR("screen_get_display_property_pv [SCREEN_PROPERTY_MODE] failed.\n");
goto error;
}
if (screen_get_window_property_iv(screen_win,
SCREEN_PROPERTY_BUFFER_SIZE, size))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
int buffer_size[2] = {size[0], size[1]};
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
}
else
{
RARCH_ERR("Navigator returned an unexpected orientation angle.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_BUFFER_SIZE, buffer_size))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_ROTATION, &angle))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_ROTATION] failed.\n");
goto error;
}
#endif
if (screen_create_window_buffers(screen_win, WINDOW_BUFFERS))
{
RARCH_ERR("screen_create_window_buffers failed.\n");
goto error;
}
if (!egl_create_surface(&qnx->egl, screen_win))
goto error;
return qnx;
error:
RARCH_ERR("EGL error: %d.\n", eglGetError());
gfx_ctx_qnx_destroy(video_driver);
screen_error:
screen_stop_events(screen_ctx);
return NULL;
}
int
setup_screen()
{
if (screen_create_context(&screen_ctx, SCREEN_APPLICATION_CONTEXT) != 0) {
return EXIT_FAILURE;
}
//Signal BPS library that navigator orientation is to be locked
if (BPS_SUCCESS != navigator_rotation_lock(true)) {
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
if (screen_create_window(&screen_win, screen_ctx) != 0) {
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
if (screen_create_window_group(screen_win, get_window_group_id()) != 0) goto fail;
int usage = SCREEN_USAGE_NATIVE;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage) != 0) goto fail;
int size[2];
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size) != 0) goto fail;
screen_display_t screen_disp;
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp);
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode) != 0) goto fail;
int buffer_size[2] = {size[0], size[1]};
int angle = atoi(getenv("ORIENTATION"));
if ((angle == 0) || (angle == 180)) {
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else if ((angle == 90) || (angle == 270)){
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else {
goto fail;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size) != 0) goto fail;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle) != 0) goto fail;
if (screen_create_window_buffers(screen_win, 1) != 0) goto fail;
screen_buffer_t buff;
if (screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void*)&buff) != 0) goto fail;
int attribs[1] = {SCREEN_BLIT_END};
if (screen_fill(screen_ctx, buff, attribs) != 0) goto fail;
int dirty_rects[4] = {0, 0, buffer_size[0], buffer_size[1]};
if (screen_post_window(screen_win, buff, 1, (const int*)dirty_rects, 0) != 0) goto fail;
return EXIT_SUCCESS;
fail:
perror(NULL);
cleanup_screen();
return EXIT_FAILURE;
}
int InitQNX(const char *Title,int Width,int Height)
{
/* Initialize variables */
AppTitle = Title;
XSize = Width;
YSize = Height;
TimerON = 0;
TimerReady = 0;
JoyState = 0;
LastKey = 0;
KeyModes = 0;
FrameCount = 0;
FrameRate = 0;
/* Get initial timestamp */
gettimeofday(&TimeStamp,0);
screen_create_context(&ctxt, SCREEN_APPLICATION_CONTEXT);
int dispCount;
screen_get_context_property_iv(ctxt, SCREEN_PROPERTY_DISPLAY_COUNT, &dispCount);
screen_display_t* displays = new screen_display_t[dispCount];
screen_get_context_property_pv(ctxt, SCREEN_PROPERTY_DISPLAYS, (void**)displays);
int resolution[2] = { 0, 0 };
screen_get_display_property_iv(displays[0], SCREEN_PROPERTY_SIZE, resolution);
delete[] displays;
actualSize_x = resolution[0];
actualSize_y = resolution[1];
double scaleY;
if (isPhysicalKeyboardDevice)
scaleY = ((double)resolution[1]) / 600.0;
else
scaleY = ((double)resolution[1]) / 1024.0;
double scaleX = ((double)resolution[0]) / 600.0;
scaleTouchMap(scaleX, scaleY);
if (BPS_SUCCESS != screen_request_events(ctxt))
{
screen_destroy_context(ctxt);
return 0;
}
#ifdef __BBTEN__
screen_create_window_type(&window, ctxt, SCREEN_CHILD_WINDOW);
screen_join_window_group(window, windowGroup);
screen_set_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, windowIdLength, "AlmostTIAppID");
int vis = 1;
screen_set_window_property_iv(window, SCREEN_PROPERTY_VISIBLE, &vis);
int z = -5;
screen_set_window_property_iv(window, SCREEN_PROPERTY_ZORDER, &z);
if (isPhysicalKeyboardDevice)
virtualkeyboard_request_events(0);
#else
screen_create_window(&window, ctxt);
int usage = SCREEN_USAGE_WRITE | SCREEN_USAGE_NATIVE;
screen_set_window_property_iv(window, SCREEN_PROPERTY_USAGE, &usage);
#endif
screen_create_window_buffers(window, 1);
screen_get_window_property_iv(window, SCREEN_PROPERTY_BUFFER_SIZE, rect+2);
/* Done */
return(1);
}
Platform* Platform::create(Game* game, void* attachToWindow)
{
FileSystem::setResourcePath("./app/native/");
Platform* platform = new Platform(game);
// Query game config
int samples = 0;
Properties* config = Game::getInstance()->getConfig()->getNamespace("window", true);
if (config)
{
samples = std::max(config->getInt("samples"), 0);
}
__gestureSet = gestures_set_alloc();
swipe_gesture_alloc(NULL, gesture_callback, __gestureSet);
pinch_gesture_alloc(NULL, gesture_callback, __gestureSet);
tap_gesture_alloc(NULL, gesture_callback, __gestureSet);
bps_initialize();
// Initialize navigator and orientation
static const int SENSOR_RATE = 25000;
sensor_set_rate(SENSOR_TYPE_AZIMUTH_PITCH_ROLL, SENSOR_RATE);
sensor_set_skip_duplicates(SENSOR_TYPE_AZIMUTH_PITCH_ROLL, true);
sensor_request_events(SENSOR_TYPE_AZIMUTH_PITCH_ROLL);
navigator_request_events(0);
navigator_rotation_lock(true);
__orientationAngle = atoi(getenv("ORIENTATION"));
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
#ifdef __X86__
int screenUsage = SCREEN_USAGE_OPENGL_ES2;
#else
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2; // Physical device copy directly into physical display
#endif
int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
char *width_str = getenv("WIDTH");
char *height_str = getenv("HEIGHT");
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
// Hard-coded to 32-bit/OpenGL ES 2.0.
// NOTE: EGL_SAMPLE_BUFFERS and EGL_SAMPLES MUST remain at the beginning of the attribute list
// since they are expected to be at indices 0-3 in config fallback code later.
EGLint eglConfigAttrs[] =
{
EGL_SAMPLE_BUFFERS, samples > 0 ? 1 : 0,
EGL_SAMPLES, samples,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&__screenContext, 0);
if (rc)
{
perror("screen_create_context");
goto error;
}
// Create the screen window.
rc = screen_create_window(&__screenWindow, __screenContext);
if (rc)
{
perror("screen_create_window");
goto error;
}
// Set/get any window properties.
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
goto error;
}
if (width_str && height_str)
{
__screenWindowSize[0] = atoi(width_str);
__screenWindowSize[1] = atoi(height_str);
}
else
{
screen_display_t screen_display;
rc = screen_get_window_property_pv(__screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
goto error;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
goto error;
}
int size[2];
rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
__screenWindowSize[0] = size[0];
__screenWindowSize[1] = size[1];
if ((__orientationAngle == 0) || (__orientationAngle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else if ((__orientationAngle == 90) || (__orientationAngle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &__orientationAngle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
goto error;
}
// Double buffered.
rc = screen_create_window_buffers(__screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
goto error;
}
// Create screen event object.
rc = screen_create_event(&__screenEvent);
if (rc)
{
perror("screen_create_event");
goto error;
}
// Request screen events.
screen_request_events(__screenContext);
// Get the EGL display and initialize.
__eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (__eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
goto error;
}
if (eglInitialize(__eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
goto error;
}
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
bool success = false;
while (samples)
{
// Try lowering the MSAA sample count until we find a supported config
GP_WARN("Failed to find a valid EGL configuration with EGL samples=%d. Trying samples=%d instead.", samples, samples/2);
samples /= 2;
eglConfigAttrs[1] = samples > 0 ? 1 : 0;
eglConfigAttrs[3] = samples;
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) == EGL_TRUE && eglConfigCount > 0)
{
success = true;
break;
}
}
if (!success)
{
checkErrorEGL("eglChooseConfig");
goto error;
}
}
__eglContext = eglCreateContext(__eglDisplay, __eglConfig, EGL_NO_CONTEXT, eglContextAttrs);
if (__eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
goto error;
}
__eglSurface = eglCreateWindowSurface(__eglDisplay, __eglConfig, __screenWindow, eglSurfaceAttrs);
if (__eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
goto error;
}
if (eglMakeCurrent(__eglDisplay, __eglSurface, __eglSurface, __eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
goto error;
}
// Set vsync.
eglSwapInterval(__eglDisplay, screenSwapInterval);
// Initialize OpenGL ES extensions.
__glExtensions = (const char*)glGetString(GL_EXTENSIONS);
if (strstr(__glExtensions, "GL_OES_vertex_array_object") || strstr(__glExtensions, "GL_ARB_vertex_array_object"))
{
glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArraysOES");
glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES");
glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES");
}
return platform;
error:
// TODO: cleanup
return NULL;
}
int NativeWindow::initialize(bool _createFullWindow)
{
int returnCode;
int numberModes;
screen_display_mode_t* screenModes;
int type;
if (_createFullWindow) {
returnCode = screen_create_window(&_screenWindow, _screenContext);
qDebug() << "NativeWindow::initialize: _screenWindow (full window): " << ":" << _screenWindow << ":" << _screenContext << ":" << returnCode;
if (returnCode) {
perror("screen_create_window");
return EXIT_FAILURE;
}
} else {
returnCode = screen_create_window_type(&_screenWindow, _screenContext, SCREEN_CHILD_WINDOW);
qDebug() << "NativeWindow::initialize: _screenWindow (child window): " << _screenWindow << ":" << returnCode;
if (returnCode) {
perror("screen_create_window (child window)");
return EXIT_FAILURE;
}
}
_displaysMutex.lock();
if (_screenDisplays) {
free (_screenDisplays);
}
// try this first as it will fail if an HDMI display is not attached
screen_get_context_property_iv(_screenContext, SCREEN_PROPERTY_DISPLAY_COUNT, &_numberDisplays);
_screenDisplays = (screen_display_t *)calloc(_numberDisplays, sizeof(screen_display_t));
screen_get_context_property_pv(_screenContext, SCREEN_PROPERTY_DISPLAYS, (void **)_screenDisplays);
for (int index = 0; index < _numberDisplays; index++) {
int displayID;
returnCode = screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_ID, (int *)&displayID);
qDebug() << "NativeWindow::initialize: display: " << ":" << index << ":" << displayID << ":" << _display << ":" << _screenDisplays[index];
if (returnCode) {
perror("display ID");
return EXIT_FAILURE;
} else {
if (displayID == _display) {
screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_set_window_property_pv(_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&(_screenDisplays[index]));
if (returnCode) {
perror("window display");
return EXIT_FAILURE;
}
}
}
}
}
_displaysMutex.unlock();
qDebug() << "NativeWindow::initialize: "<< _screenContext << ":" << _screenWindow;
returnCode = setWindowFormat(_format);
if (returnCode) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return EXIT_FAILURE;
}
returnCode = setWindowTransparency(_transparency);
if (returnCode) {
perror("transparency");
return EXIT_FAILURE;
}
returnCode = screen_get_window_property_pv(_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&_screenDisplay);
if (returnCode) {
perror("screenDisplay");
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_get_display_property_iv(_screenDisplay, SCREEN_PROPERTY_MODE_COUNT, &numberModes);
screenModes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t));
returnCode = screen_get_display_property_pv(_screenDisplay, SCREEN_PROPERTY_MODE, (void**)screenModes);
if (returnCode) {
perror("screen modes");
return EXIT_FAILURE;
}
int dpi = calculateDPI();
if (dpi == EXIT_FAILURE) {
fprintf(stderr, "Unable to calculate dpi\n");
return EXIT_FAILURE;
}
returnCode = setWindowPosition(_x, _y);
if (returnCode) {
perror("window position");
return EXIT_FAILURE;
}
returnCode = setWindowSize(_width, _height);
if (returnCode) {
perror("window size");
return EXIT_FAILURE;
}
returnCode = setWindowZ(_z);
if (returnCode) {
perror("z order");
return EXIT_FAILURE;
}
if (_sourceWidth > 0) {
returnCode = setWindowSourcePosition(_sourceX, _sourceY);
if (returnCode) {
perror("source size");
return EXIT_FAILURE;
}
returnCode = setWindowSourceSize(_sourceWidth, _sourceHeight);
if (returnCode) {
perror("source size");
return EXIT_FAILURE;
}
}
if (_bufferWidth > 0) {
returnCode = setWindowBufferSize(_bufferWidth, _bufferHeight);
if (returnCode) {
perror("buffer size");
return EXIT_FAILURE;
}
}
returnCode = setWindowAngle(_angle);
if (returnCode) {
perror("angle");
return EXIT_FAILURE;
}
returnCode = screen_create_window_buffers(_screenWindow, _nbuffers);
if (returnCode) {
perror("screen_create_window_buffers");
return EXIT_FAILURE;
}
_usage = Graphics::getNativeWindowUsage();
// enable this in case we need any native API access to this window
_usage |= SCREEN_USAGE_NATIVE;
returnCode = setWindowUsage(_usage);
if (returnCode) {
perror("screen_set_window_property_iv(window usage)");
return EXIT_FAILURE;
}
returnCode = joinWindowGroup(_group);
if (returnCode) {
perror("window group");
return EXIT_FAILURE;
}
returnCode = setScreenWindowID(_id);
if (returnCode) {
perror("window ID");
return EXIT_FAILURE;
}
qDebug() << "NativeWindow::initialize: "<< angle << ":" << numberModes << ":" << screenModes[0].width << ":" << screenModes[0].height << ":" << dpi;
if (screenModes != NULL) {
free(screenModes);
}
return EXIT_SUCCESS;
}
QQnxRootWindow::QQnxRootWindow(const QQnxScreen *screen)
: m_screen(screen),
m_window(0),
m_windowGroupName(),
m_translucent(false)
{
qRootWindowDebug() << Q_FUNC_INFO;
// Create one top-level QNX window to act as a container for child windows
// since navigator only supports one application window
errno = 0;
int result = screen_create_window(&m_window, m_screen->nativeContext());
int val[2];
if (result != 0)
qFatal("QQnxRootWindow: failed to create window, errno=%d", errno);
// Move window to proper display
errno = 0;
screen_display_t display = m_screen->nativeDisplay();
result = screen_set_window_property_pv(m_window, SCREEN_PROPERTY_DISPLAY, (void **)&display);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window display, errno=%d", errno);
// Make sure window is above navigator but below keyboard if running as root
// since navigator won't automatically set our z-order in this case
if (getuid() == 0) {
errno = 0;
val[0] = MAGIC_ZORDER_FOR_NO_NAV;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_ZORDER, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window z-order, errno=%d", errno);
}
// Window won't be visible unless it has some buffers so make one dummy buffer that is 1x1
errno = 0;
val[0] = SCREEN_USAGE_NATIVE;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_USAGE, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window buffer usage, errno=%d", errno);
errno = 0;
val[0] = m_screen->nativeFormat();
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_FORMAT, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window pixel format, errno=%d", errno);
errno = 0;
val[0] = 1;
val[1] = 1;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_BUFFER_SIZE, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window buffer size, errno=%d", errno);
errno = 0;
result = screen_create_window_buffers(m_window, 1);
if (result != 0)
qFatal("QQNX: failed to create window buffer, errno=%d", errno);
// Window is always the size of the display
errno = 0;
QRect geometry = m_screen->geometry();
val[0] = geometry.width();
val[1] = geometry.height();
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SIZE, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window size, errno=%d", errno);
// Fill the window with solid black. Note that the LSB of the pixel value
// 0x00000000 just happens to be 0x00, so if and when this root window's
// alpha blending mode is changed from None to Source-Over, it will then
// be interpreted as transparent.
errno = 0;
val[0] = 0;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_COLOR, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window colour, errno=%d", errno);
// Make the window opaque
errno = 0;
val[0] = SCREEN_TRANSPARENCY_NONE;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_TRANSPARENCY, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window transparency, errno=%d", errno);
// Set the swap interval to 1
errno = 0;
val[0] = 1;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SWAP_INTERVAL, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window swap interval, errno=%d", errno);
// Set viewport size equal to window size but move outside buffer so the fill colour is used exclusively
errno = 0;
val[0] = geometry.width();
val[1] = geometry.height();
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SOURCE_SIZE, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window source size, errno=%d", errno);
errno = 0;
val[0] = 0;
val[1] = 0;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SOURCE_POSITION, val);
if (result != 0)
qFatal("QQnxRootWindow: failed to set window source position, errno=%d", errno);
// Optionally disable the screen power save
bool ok = false;
const int disablePowerSave = qgetenv("QQNX_DISABLE_POWER_SAVE").toInt(&ok);
if (ok && disablePowerSave) {
const int mode = SCREEN_IDLE_MODE_KEEP_AWAKE;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_IDLE_MODE, &mode);
if (result != 0)
qWarning("QQnxRootWindow: failed to disable power saving mode");
}
createWindowGroup();
// Don't post yet. This will be lazily done from QQnxScreen upon first posting of
// a child window. Doing it now pre-emptively would create a flicker if one of
// the QWindow's about to be created sets its Qt::WA_TranslucentBackground flag
// and immediately triggers the buffer re-creation in makeTranslucent().
}
gceSTATUS
gcoOS_CreateWindow(
IN HALNativeDisplayType Display,
IN gctINT X,
IN gctINT Y,
IN gctINT Width,
IN gctINT Height,
OUT HALNativeWindowType * Window
)
{
gctINT pos[2];
gctINT size[2];
gctINT screen_format = SCREEN_FORMAT_RGBX8888;
gctINT screen_transparency = SCREEN_TRANSPARENCY_NONE;
gctINT screen_usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_OPENVG
;
/* Use 0 for no-vsync, and 1 for vsync limited. */
gctINT screen_swap_interval = 0;
gctINT rc;
gceSTATUS status = gcvSTATUS_OK;
gcmHEADER_ARG("Display=0x%x X=%d Y=%d Width=%d Height=%d", Display, X, Y, Width, Height);
/* Create window strcture. */
rc = screen_create_window((struct _screen_window **)Window, screen_ctx);
if (rc)
{
fprintf(stderr, "screen_create_window failed with error %d (0x%08x)\n", errno, errno);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Set window pximap format. */
rc = screen_set_window_property_iv(*Window, SCREEN_PROPERTY_FORMAT, &screen_format);
if (rc)
{
fprintf(stderr, "screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Set window usage. */
rc = screen_set_window_property_iv(*Window, SCREEN_PROPERTY_USAGE, &screen_usage);
if (rc)
{
fprintf(stderr, "screen_set_window_property_iv(SCREEN_PROPERTY_USAGE) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Get fullscreen window size. */
rc = screen_get_window_property_iv(*Window, SCREEN_PROPERTY_SIZE, size);
if (rc)
{
fprintf(stderr, "screen_get_window_property_iv(SCREEN_PROPERTY_SIZE) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Disable transparency. Due to a bug in Screen, this must be set after format. */
rc = screen_set_window_property_iv(*Window, SCREEN_PROPERTY_TRANSPARENCY, &screen_transparency);
if (rc)
{
fprintf(stderr, "screen_get_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Set swap interval. */
rc = screen_set_window_property_iv(*Window, SCREEN_PROPERTY_SWAP_INTERVAL, &screen_swap_interval);
if (rc)
{
fprintf(stderr, "screen_get_window_property_iv(SCREEN_PROPERTY_SWAP_INTERVAL) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Test for zero width. */
if (Width == 0)
{
Width = size[0];
}
/* Test for zero height. */
if (Height == 0)
{
Height = size[1];
}
/* Test for auto-center X coordinate. */
if (X == -1)
{
X = (size[0] - Width) / 2;
}
/* Test for auto-center X coordinate. */
if (Y == -1)
{
Y = (size[1] - Height) / 2;
}
/* Resize the window. */
size[0] = Width;
size[1] = Height;
rc = screen_set_window_property_iv(*Window, SCREEN_PROPERTY_SIZE, size);
if (rc)
{
fprintf(stderr, "screen_set_window_property_iv(SCREEN_PROPERTY_SIZE) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Create window buffer. */
/* Second argument is the number of back buffers to be used. */
rc = screen_create_window_buffers(*Window, gcdDISPLAY_BACK_BUFFERS);
if (rc)
{
fprintf(stderr, "screen_create_window_buffers failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
/* Move window position. */
pos[0] = X;
pos[1] = Y;
rc = screen_set_window_property_iv(*Window, SCREEN_PROPERTY_POSITION, pos);
if (rc) {
fprintf(stderr, "screen_set_window_property_iv(SCREEN_PROPERTY_POSITION) failed with error %d (0x%08x)\n", errno, errno);
screen_destroy_window(*Window);
status = gcvSTATUS_OUT_OF_RESOURCES;
gcmFOOTER();
return status;
}
gcmFOOTER_ARG("*Window=0x%x", *Window);
return status;
}
int QNX_InitGL(void)
{
int usage = SCREEN_USAGE_OPENGL_ES1;
int transp = SCREEN_TRANSPARENCY_NONE;
EGLint interval = 1;
int size[2] = { -1, -1 };
int pos[2] = { 0, 0 };
int nbuffers = 2;
int format;
EGLConfig config;
EGLint err;
config = choose_config(eglDisplay, "rgb565");
if (config == (EGLConfig)0) {
Com_Printf( "Demo Thread Init: failed to find config!" );
return FALSE;
}
// Create EGL rendering context
eglContext = eglCreateContext( eglDisplay, config, EGL_NO_CONTEXT, NULL );
err = eglGetError( );
if ( eglContext == EGL_NO_CONTEXT ) {
Com_Printf( "Demo Thread Init: can't create gles2 context!" );
PrintEglError( err );
return FALSE;
}
err = screen_create_context(&screen_ctx, 0);
if (err) {
Com_Printf("screen_create_context");
return FALSE;
}
err = screen_create_window(&screen_win, screen_ctx);
if (err) {
Com_Printf("screen_create_window");
return FALSE;
}
format = choose_format(eglDisplay, config);
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return FALSE;
}
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
return FALSE;
}
size[0]=1024;
size[1]=768;
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (err) {
Com_Printf("screen_set_window_property_iv(screen_set_window_property_iv)");
return FALSE;
}
if (size[0] > 0 && size[1] > 0) {
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_SIZE)");
return FALSE;
}
} else {
err = screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if (err) {
Com_Printf("screen_get_window_property_iv(SCREEN_PROPERTY_SIZE)");
return FALSE;
}
}
glConfig.vidWidth = size[0];
glConfig.vidHeight = size[1];
InitControls();
bz[0] = size[0];
bz[1] = size[1];
if (pos[0] != 0 || pos[1] != 0) {
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_POSITION, pos);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
return FALSE;
}
}
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_TRANSPARENCY, &transp);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
return FALSE;
}
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SWAP_INTERVAL, &interval);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_SWAP_INTERVAL)");
return FALSE;
}
err = screen_create_window_buffers(screen_win, nbuffers);
if (err) {
Com_Printf("screen_create_window_buffers");
return FALSE;
}
size[0] = 1024;
size[1] = 600;
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_SIZE)");
return FALSE;
}
err = screen_create_event(&screen_ev);
if (err) {
Com_Printf("screen_create_event");
return FALSE;
}
eglSurface = eglCreateWindowSurface(eglDisplay, config, screen_win, NULL);
if (eglSurface == EGL_NO_SURFACE) {
Com_Printf( "Demo Thread Init: can't create surface!" );
PrintEglError( err );
return FALSE;
}
err = eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
if (err != EGL_TRUE) {
Com_Printf( "Demo Thread Init: can't make current!" );
return FALSE;
}
pps_decoder_init(&decoder, NULL, 0);
ppsfd = open("/pps/services/navigator/control", O_RDWR);
if (ppsfd == -1) {
Com_Printf("warning: failed to open PPS\n");
}
return TRUE;
}
void ScreenWindow::init()
{
int rc;
rc = screen_create_context(&m_context, 0);
// if (rc) fprintf(stderr, "Fail at %d: %s\n", __LINE__, strerror(errno));
rc = screen_create_window(&m_appWindow, m_context);
char groupName[256];
snprintf(groupName, 256, "screen-%d", getpid());
rc = screen_create_window_group(m_appWindow, groupName);
int sizeOfWindow[2] = {1024, 600};
rc = screen_set_window_property_iv(m_appWindow, SCREEN_PROPERTY_SIZE, sizeOfWindow);
int sizeOfBuffer[2] = {1024, 600};
rc = screen_set_window_property_iv(m_appWindow, SCREEN_PROPERTY_BUFFER_SIZE, sizeOfBuffer);
int format = SCREEN_FORMAT_RGBX8888;
rc = screen_set_window_property_iv(m_appWindow, SCREEN_PROPERTY_FORMAT, &format);
int usage = SCREEN_USAGE_NATIVE | SCREEN_USAGE_READ | SCREEN_USAGE_WRITE;
rc = screen_set_window_property_iv(m_appWindow, SCREEN_PROPERTY_USAGE, &usage);
int angle = 0;
char *orientation = getenv("ORIENTATION");
if (orientation) {
angle = atoi(orientation);
}
rc = screen_set_window_property_iv(m_appWindow, SCREEN_PROPERTY_ROTATION, &angle);
rc = screen_create_window_buffers(m_appWindow, 1);
screen_buffer_t windowBuffer[1];
rc = screen_get_window_property_pv(m_appWindow,
SCREEN_PROPERTY_RENDER_BUFFERS, (void**)&windowBuffer);
int attribs[] = {SCREEN_BLIT_DESTINATION_X, 0,
SCREEN_BLIT_DESTINATION_Y, 0,
SCREEN_BLIT_DESTINATION_WIDTH, 1024,
SCREEN_BLIT_DESTINATION_HEIGHT, 600,
SCREEN_BLIT_COLOR, 0xff30ffff,
SCREEN_BLIT_END};
rc = screen_fill(m_context, windowBuffer[0], attribs);
rc = screen_get_window_property_pv(m_appWindow,
SCREEN_PROPERTY_RENDER_BUFFERS, (void**)&windowBuffer);
int rect[4] = {0, 0, 1024, 600};
rc = screen_post_window(m_appWindow, windowBuffer[0], 1, rect, 0);
screen_request_events(m_context);
navigator_request_events(0);
}
static bool gfx_ctx_qnx_init(void *data)
{
/* Create a screen context that will be used to
* create an EGL surface to receive libscreen events */
RARCH_LOG("Initializing screen context...\n");
if (!screen_ctx)
{
screen_create_context(&screen_ctx, 0);
if (screen_request_events(screen_ctx) != BPS_SUCCESS)
{
RARCH_ERR("screen_request_events failed.\n");
goto screen_error;
}
if (navigator_request_events(0) != BPS_SUCCESS)
{
RARCH_ERR("navigator_request_events failed.\n");
goto screen_error;
}
if (navigator_rotation_lock(false) != BPS_SUCCESS)
{
RARCH_ERR("navigator_location_lock failed.\n");
goto screen_error;
}
}
const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
int format = SCREEN_FORMAT_RGBX8888;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
int usage;
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
RARCH_LOG("Initializing context\n");
if ((g_egl_dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY)
{
RARCH_ERR("eglGetDisplay failed.\n");
goto error;
}
if (!eglInitialize(g_egl_dpy, &egl_version_major, &egl_version_minor))
{
RARCH_ERR("eglInitialize failed.\n");
goto error;
}
if (!eglBindAPI(EGL_OPENGL_ES_API))
{
RARCH_ERR("eglBindAPI failed.\n");
goto error;
}
RARCH_LOG("[BLACKBERRY QNX/EGL]: EGL version: %d.%d\n", egl_version_major, egl_version_minor);
if (!eglChooseConfig(g_egl_dpy, attribs, &egl_config, 1, &num_config))
{
RARCH_ERR("eglChooseConfig failed.\n");
goto error;
}
if ((g_egl_ctx = eglCreateContext(g_egl_dpy, egl_config, 0, context_attributes)) == EGL_NO_CONTEXT)
{
RARCH_ERR("eglCreateContext failed.\n");
goto error;
}
if(!screen_win)
{
if (screen_create_window(&screen_win, screen_ctx))
{
RARCH_ERR("screen_create_window failed:.\n");
goto error;
}
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_FORMAT] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_USAGE] failed.\n");
goto error;
}
if (screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp))
{
RARCH_ERR("screen_get_window_property_pv [SCREEN_PROPERTY_DISPLAY] failed.\n");
goto error;
}
int screen_resolution[2];
if (screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_SIZE] failed.\n");
goto error;
}
#ifndef HAVE_BB10
int angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode))
{
RARCH_ERR("screen_get_display_property_pv [SCREEN_PROPERTY_MODE] failed.\n");
goto error;
}
int size[2];
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
int buffer_size[2] = {size[0], size[1]};
if ((angle == 0) || (angle == 180)) {
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else if ((angle == 90) || (angle == 270)){
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1]))) {
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else {
RARCH_ERR("Navigator returned an unexpected orientation angle.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_ROTATION] failed.\n");
goto error;
}
#endif
if (screen_create_window_buffers(screen_win, WINDOW_BUFFERS))
{
RARCH_ERR("screen_create_window_buffers failed.\n");
goto error;
}
if (!(g_egl_surf = eglCreateWindowSurface(g_egl_dpy, egl_config, screen_win, 0)))
{
RARCH_ERR("eglCreateWindowSurface failed.\n");
goto error;
}
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
{
RARCH_ERR("eglMakeCurrent failed.\n");
goto error;
}
return true;
error:
RARCH_ERR("EGL error: %d.\n", eglGetError());
gfx_ctx_qnx_destroy(data);
screen_error:
screen_stop_events(screen_ctx);
return false;
}
bool CIrrDeviceBB10::createWindow()
{
if ( Close )
return false;
int rc = screen_create_window(&bspScreenWindow, bspScreenCtx);
if(rc)
{
os::Printer::log("Screen create window failed!");
return false;
}
if(video::EDT_OGLES1 != CreationParams.DriverType && video::EDT_OGLES2 !=CreationParams.DriverType)
return false;
bspformat = SCREEN_FORMAT_RGBX8888;
if(CreationParams.Bits==16)
bspformat = SCREEN_FORMAT_RGBX4444;
bspUsage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
if(video::EDT_OGLES2 ==CreationParams.DriverType)
bspUsage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
//window properties
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_FORMAT, &bspformat);
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_USAGE, &bspUsage);
screen_display_t screenDisplay;
rc = screen_get_window_property_pv(bspScreenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screenDisplay);
int screenResolution[2];
rc = screen_get_display_property_iv(screenDisplay, SCREEN_PROPERTY_SIZE, screenResolution);
int angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screenDisplayMode;
rc = screen_get_display_property_pv(screenDisplay, SCREEN_PROPERTY_MODE, (void**)&screenDisplayMode);
int bufferSize[2];
rc = screen_get_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_BUFFER_SIZE, bufferSize);
int newBufferSize[2] = {bufferSize[0], bufferSize[1]};
if ((angle == 0) || (angle == 180))
{
if (((screenDisplayMode.width > screenDisplayMode.height) && (bufferSize[0] < bufferSize[1]))
|| ((screenDisplayMode.width < screenDisplayMode.height) && (bufferSize[0] > bufferSize[1])))
{
newBufferSize[1] = bufferSize[0];
newBufferSize[0] = bufferSize[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screenDisplayMode.width > screenDisplayMode.height) && (bufferSize[0] > bufferSize[1]))
|| ((screenDisplayMode.width < screenDisplayMode.height && bufferSize[0] < bufferSize[1])))
{
newBufferSize[1] = bufferSize[0];
newBufferSize[0] = bufferSize[1];
}
}
else
{
os::Printer::log("Navigator returned an unexpected orientation angle.\n");
return false;
}
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_BUFFER_SIZE, newBufferSize);
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_ROTATION, &angle);
rc = screen_create_window_buffers(bspScreenWindow, 2);
return true;
}
int main(int argc, char *argv[])
{
int rc;
int exit_application = 0;
// Screen variables
screen_context_t screen_context = 0;
screen_window_t screen_window = 0;
int screen_size[2] = {0,0};
// Renderer variables
mmr_connection_t* mmr_connection = 0;
mmr_context_t* mmr_context = 0;
strm_dict_t* dict = NULL;
// I/O variables
int video_device_output_id = -1;
int audio_device_output_id = -1;
bps_initialize();
/*
* Create the window used for video output.
*/
if (screen_create_context(&screen_context, SCREEN_APPLICATION_CONTEXT) != 0) {
return EXIT_FAILURE;
}
if (screen_create_window(&screen_window, screen_context) != 0) {
screen_destroy_context(screen_context);
return EXIT_FAILURE;
}
if (screen_create_window_group(screen_window, window_group_name) != 0) {
return EXIT_FAILURE;
}
int format = SCREEN_FORMAT_RGBA8888;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_FORMAT, &format) != 0) {
return EXIT_FAILURE;
}
int usage = SCREEN_USAGE_NATIVE;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_USAGE, &usage) != 0) {
return EXIT_FAILURE;
}
if (screen_create_window_buffers(screen_window, 1) != 0) {
return EXIT_FAILURE;
}
/*
* Configure mm-renderer.
*/
mmr_connection = mmr_connect(NULL);
if (mmr_connection == NULL) {
return EXIT_FAILURE;
}
mmr_context = mmr_context_create(mmr_connection, video_context_name, 0, S_IRWXU|S_IRWXG|S_IRWXO);
if (mmr_context == NULL) {
return EXIT_FAILURE;
}
/*
* Configure video and audio output.
*/
video_device_output_id = mmr_output_attach(mmr_context, video_device_url, "video");
if (video_device_output_id == -1) {
return EXIT_FAILURE;
}
audio_device_output_id = mmr_output_attach(mmr_context, audio_device_url, "audio");
if (audio_device_output_id == -1) {
return EXIT_FAILURE;
}
// Get the render buffer
screen_buffer_t temp_buffer[1];
if (screen_get_window_property_pv( screen_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)temp_buffer) != 0) {
return EXIT_FAILURE;
}
// Fill the buffer with a solid color (black)
int fill_attributes[3] = {SCREEN_BLIT_COLOR, 0x0, SCREEN_BLIT_END};
if (screen_fill(screen_context, temp_buffer[0], fill_attributes) != 0) {
return EXIT_FAILURE;
}
// Make the window visible
if (screen_get_window_property_iv(screen_window, SCREEN_PROPERTY_SIZE, screen_size) != 0) {
return EXIT_FAILURE;
}
int temp_rectangle[4] = {0, 0, screen_size[0], screen_size[1]};
if (screen_post_window(screen_window, temp_buffer[0], 1, temp_rectangle, 0) != 0) {
return EXIT_FAILURE;
}
// Prevent the backlight from going off
int idle_mode = SCREEN_IDLE_MODE_KEEP_AWAKE;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_IDLE_MODE, &idle_mode) != 0) {
return EXIT_FAILURE;
}
// Build up the path where our bundled resource is.
char cwd[PATH_MAX];
char media_file[PATH_MAX];
getcwd(cwd,PATH_MAX);
rc = snprintf(media_file, PATH_MAX, "file://%s/app/native/pb_sample.mp4", cwd);
if ((rc == -1) || (rc >= PATH_MAX)) {
return EXIT_FAILURE;
}
/*
* Start the playback.
*/
if (mmr_input_attach(mmr_context, media_file, "track") != 0) {
return EXIT_FAILURE;
}
if (mmr_play(mmr_context) != 0) {
return EXIT_FAILURE;
}
/* Do some work to make the aspect ratio correct.
*/
dict = calculate_rect(screen_size[0], screen_size[1]);
if (NULL == dict) {
return EXIT_FAILURE;
}
if (mmr_output_parameters(mmr_context, video_device_output_id, dict) != 0) {
return EXIT_FAILURE;
}
/* Note that we allocated memory for the dictionary, but the call to
* mmr_output_parameters() deallocates that memory even on failure.
*/
dict = NULL;
screen_request_events(screen_context);
navigator_request_events(0);
/*
* Handle keyboard events and stop playback upon user request.
*/
for (;;) {
bps_event_t *event = NULL;
if (bps_get_event(&event, -1) != BPS_SUCCESS) {
return EXIT_FAILURE;
}
if (event) {
if (bps_event_get_domain(event) == navigator_get_domain() &&
bps_event_get_code(event) == NAVIGATOR_EXIT) {
exit_application = 1;
}
if (exit_application) {
break;
}
}
}
screen_stop_events(screen_context);
if (mmr_stop(mmr_context) != 0) {
return EXIT_FAILURE;
}
if (mmr_output_detach(mmr_context, audio_device_output_id) != 0) {
return EXIT_FAILURE;
}
if (mmr_output_detach(mmr_context, video_device_output_id) != 0) {
return EXIT_FAILURE;
}
if (mmr_context_destroy(mmr_context) != 0) {
return EXIT_FAILURE;
}
mmr_context = 0;
video_device_output_id = -1;
audio_device_output_id = -1;
mmr_disconnect(mmr_connection);
mmr_connection = 0;
bps_shutdown();
if (screen_destroy_window(screen_window) != 0) {
return EXIT_FAILURE;
}
if (screen_destroy_context(screen_context) != 0) {
return EXIT_FAILURE;
}
screen_context = 0;
screen_window = 0;
return EXIT_SUCCESS;
}
Platform* Platform::create(Game* game)
{
FileSystem::setResourcePath("./app/native/");
Platform* platform = new Platform(game);
bps_initialize();
accelerometer_set_update_frequency(FREQ_40_HZ);
navigator_request_events(0);
navigator_rotation_lock(true);
// Determine initial orientation angle.
orientation_direction_t direction;
orientation_get(&direction, &__orientationAngle);
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2;
int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
int angle = atoi(getenv("ORIENTATION"));
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
// Hard-coded to 32-bit/OpenGL ES 2.0.
const EGLint eglConfigAttrs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&__screenContext, 0);
if (rc)
{
perror("screen_create_context");
goto error;
}
// Create the screen window.
rc = screen_create_window(&__screenWindow, __screenContext);
if (rc)
{
perror("screen_create_window");
goto error;
}
// Set/get any window prooperties.
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
goto error;
}
screen_display_t screen_display;
rc = screen_get_window_property_pv(__screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
goto error;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
goto error;
}
int size[2];
rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
__screenWindowSize[0] = size[0];
__screenWindowSize[1] = size[1];
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
goto error;
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
goto error;
}
// Double buffered.
rc = screen_create_window_buffers(__screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
goto error;
}
// Create screen event object.
rc = screen_create_event(&__screenEvent);
if (rc)
{
perror("screen_create_event");
goto error;
}
// Request screen events.
screen_request_events(__screenContext);
// Get the EGL display and initialize.
__eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (__eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
goto error;
}
if (eglInitialize(__eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
goto error;
}
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
checkErrorEGL("eglChooseConfig");
goto error;
}
__eglContext = eglCreateContext(__eglDisplay, __eglConfig, EGL_NO_CONTEXT, eglContextAttrs);
if (__eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
goto error;
}
__eglSurface = eglCreateWindowSurface(__eglDisplay, __eglConfig, __screenWindow, eglSurfaceAttrs);
if (__eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
goto error;
}
if (eglMakeCurrent(__eglDisplay, __eglSurface, __eglSurface, __eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
goto error;
}
// Set vsync.
eglSwapInterval(__eglDisplay, screenSwapInterval);
// Initialize OpenGL ES extensions.
__glExtensions = (const char*)glGetString(GL_EXTENSIONS);
if (strstr(__glExtensions, "GL_OES_vertex_array_object") || strstr(__glExtensions, "GL_ARB_vertex_array_object"))
{
// Disable VAO extension for now.
glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArrays");
glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES");
glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES");
}
return platform;
error:
// TODO: cleanup
//
return NULL;
}
