ButtonMap::ButtonMap(screen_context_t screen_ctx, QString groupId, int coid)
{
this->screen_cxt = screen_ctx;
this->groupId = groupId;
this->coid = coid;
const int usage = SCREEN_USAGE_NATIVE | SCREEN_USAGE_WRITE | SCREEN_USAGE_READ;
int rc;
if(screen_create_window_type(&screen_win, screen_cxt, SCREEN_CHILD_WINDOW))
{
RARCH_ERR("ButtonMap: screen_create_window_type failed.\n");
}
screen_join_window_group(screen_win, (const char *)groupId.toAscii().constData());
int format = SCREEN_FORMAT_RGBA8888;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_display_t screen_disp;
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");
}
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");
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, screen_resolution);
if (rc) {
perror("screen_set_window_property_iv");
}
int z = -10;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &z) != 0) {
return;
}
rc = screen_create_window_buffers(screen_win, 1);
if (rc) {
perror("screen_create_window_buffers");
}
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)&screen_buf);
int bg[] = { SCREEN_BLIT_COLOR, 0x00000000,
SCREEN_BLIT_GLOBAL_ALPHA, 0x80,
SCREEN_BLIT_END };
screen_fill(screen_cxt, screen_buf, bg);
screen_post_window(screen_win, screen_buf, 1, screen_resolution, 0);
buttonDataModel = new ArrayDataModel();
refreshButtonMap(0);
}
screen_window_t create_bar_window(const char *group, const char *id, int dims[2])
{
screen_window_t screen_win;
screen_create_window_type(&screen_win, screen_ctx, SCREEN_CHILD_WINDOW);
screen_join_window_group(screen_win, group);
screen_set_window_property_cv(screen_win, SCREEN_PROPERTY_ID_STRING, strlen(id), id);
int vis = 1;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_VISIBLE, &vis);
int zorder = 1;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &zorder);
int color = 0xff0000ff;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_COLOR, &color);
int rect[4] = { 0, 0, 1, 1 };
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, rect+2);
int pos[2] = { -rect[2], -rect[3] };
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SOURCE_POSITION, pos);
pos[0] = pos[1] = 0;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_POSITION, pos);
int size[2] = {barwidth,dims[1]};
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
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;
}
gceSTATUS
gcoOS_DisplayBufferRegions(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
IN gctINT NumRects,
IN gctINT_PTR Rects
)
{
screen_buffer_t buf[gcdDISPLAY_BACK_BUFFERS];
int rc;
gceSTATUS status = gcvSTATUS_OK;
gcmHEADER_ARG("Display=0x%x Window=0x%x NumRects=%d", Display, Window, NumRects);
rc = screen_get_window_property_pv((screen_window_t)Window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)buf);
if (rc) {
goto OnError;
}
rc = screen_post_window((screen_window_t)Window, buf[0], NumRects, Rects, 0);
if (rc) {
goto OnError;
}
gcmFOOTER_NO();
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
QQnxBuffer &QQnxRasterWindow::renderBuffer()
{
qRasterWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Check if render buffer is invalid
if (m_currentBufferIndex == -1) {
// Get all buffers available for rendering
screen_buffer_t buffers[MAX_BUFFER_COUNT];
const int result = screen_get_window_property_pv(nativeHandle(), SCREEN_PROPERTY_RENDER_BUFFERS,
(void **)buffers);
Q_SCREEN_CRITICALERROR(result, "Failed to query window buffers");
// Wrap each buffer and clear
for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
m_buffers[i] = QQnxBuffer(buffers[i]);
// Clear Buffer
int bg[] = { SCREEN_BLIT_COLOR, 0x00000000, SCREEN_BLIT_END };
Q_SCREEN_CHECKERROR(screen_fill(screen()->nativeContext(), buffers[i], bg),
"Failed to clear window buffer");
}
Q_SCREEN_CHECKERROR(screen_flush_blits(screen()->nativeContext(), 0),
"Failed to flush blits");
// Use the first available render buffer
m_currentBufferIndex = 0;
m_previousBufferIndex = -1;
}
return m_buffers[m_currentBufferIndex];
}
QQnxBuffer &QQnxWindow::renderBuffer()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Check if render buffer is invalid
if (m_currentBufferIndex == -1) {
// Get all buffers available for rendering
errno = 0;
screen_buffer_t buffers[MAX_BUFFER_COUNT];
const int result = screen_get_window_property_pv(m_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)buffers);
if (result != 0)
qFatal("QQnxWindow: failed to query window buffers, errno=%d", errno);
// Wrap each buffer
for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
m_buffers[i] = QQnxBuffer(buffers[i]);
}
// Use the first available render buffer
m_currentBufferIndex = 0;
m_previousBufferIndex = -1;
}
return m_buffers[m_currentBufferIndex];
}
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;
}
screen_buffer_t NativeWindow::screenBuffer(int index)
{
if (_screenWindow != NULL) {
screen_get_window_property_pv(_screenWindow, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)_screenBuffers);
}
return _screenBuffers[index];
}
void ScreenWindow::flip()
{
int rect[4] = {0, 0, 1024, 600};
screen_buffer_t windowBuffer[1];
screen_get_window_property_pv(m_window,
SCREEN_PROPERTY_RENDER_BUFFERS, (void**)&windowBuffer);
screen_post_window(m_window, windowBuffer[0], 1, rect, 0);
}
void display_frame(ffdec_context *ffd_context, AVFrame *frame)
{
ffdec_reserved *ffd_reserved = (ffdec_reserved*) ffd_context->reserved;
ffdec_view *view = ffd_reserved->view;
if (!view) return;
screen_window_t screen_window = view->screen_window;
screen_buffer_t screen_pixel_buffer = view->screen_pixel_buffer;
screen_context_t screen_context = view->screen_context;
int stride = view->stride;
unsigned char *ptr = NULL;
screen_get_buffer_property_pv(screen_pixel_buffer, SCREEN_PROPERTY_POINTER, (void**) &ptr);
int width = frame->width;
int height = frame->height;
uint8_t *srcy = frame->data[0];
uint8_t *srcu = frame->data[1];
uint8_t *srcv = frame->data[2];
unsigned char *y = ptr;
unsigned char *u = y + (height * stride);
unsigned char *v = u + (height * stride) / 4;
for (int i = 0; i < height; i++)
{
int doff = i * stride;
int soff = i * frame->linesize[0];
memcpy(&y[doff], &srcy[soff], frame->width);
}
for (int i = 0; i < height / 2; i++)
{
int doff = i * stride / 2;
int soff = i * frame->linesize[1];
memcpy(&u[doff], &srcu[soff], frame->width / 2);
}
for (int i = 0; i < height / 2; i++)
{
int doff = i * stride / 2;
int soff = i * frame->linesize[2];
memcpy(&v[doff], &srcv[soff], frame->width / 2);
}
screen_buffer_t screen_buffer;
screen_get_window_property_pv(screen_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**) &screen_buffer);
int attribs[] = { SCREEN_BLIT_SOURCE_WIDTH, width, SCREEN_BLIT_SOURCE_HEIGHT, height, SCREEN_BLIT_END };
screen_blit(screen_context, screen_buffer, screen_pixel_buffer, attribs);
int dirty_rects[] = { 0, 0, width, height };
screen_post_window(screen_window, screen_buffer, 1, dirty_rects, 0);
}
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;
}
screen_window_t create_hg_window(const char *group, const char *id, int dims[2])
{
int i, j;
screen_window_t screen_win;
screen_create_window_type(&screen_win, screen_ctx, SCREEN_CHILD_WINDOW);
screen_join_window_group(screen_win, group);
screen_set_window_property_cv(screen_win, SCREEN_PROPERTY_ID_STRING, strlen(id), id);
int flag = 1;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_STATIC, &flag);
int vis = 1;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_VISIBLE, &vis);
int zorder = 2;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &zorder);
int format = SCREEN_FORMAT_RGBA8888;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
int usage = SCREEN_USAGE_WRITE;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
int transparency = SCREEN_TRANSPARENCY_SOURCE_OVER;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_TRANSPARENCY, &transparency);
int rect[4] = { 0, 0, 100, 100 };
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, rect+2);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, &rect[2]);
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);
char *ptr = NULL;
screen_get_buffer_property_pv(screen_buf, SCREEN_PROPERTY_POINTER, (void **)&ptr);
int stride = 0;
screen_get_buffer_property_iv(screen_buf, SCREEN_PROPERTY_STRIDE, &stride);
for (i = 0; i < rect[3]; i++, ptr += stride) {
for (j = 0; j < rect[2]; j++) {
ptr[j*4] = 0xa0;
ptr[j*4+1] = 0xa0;
ptr[j*4+2] = 0xa0;
ptr[j*4+3] = ((j >= i && j <= rect[3]-i) || (j <= i && j >= rect[3]-i)) ? 0xff : 0;
}
}
screen_post_window(screen_win, screen_buf, 1, rect, 0);
return screen_win;
}
void QQnxRootWindow::post() const
{
qRootWindowDebug() << Q_FUNC_INFO;
errno = 0;
screen_buffer_t buffer;
int result = screen_get_window_property_pv(m_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)&buffer);
if (result != 0)
qFatal("QQnxRootWindow: failed to query window buffer, errno=%d", errno);
errno = 0;
int dirtyRect[] = {0, 0, 1, 1};
result = screen_post_window(m_window, buffer, 1, dirtyRect, 0);
if (result != 0)
qFatal("QQNX: failed to post window buffer, errno=%d", errno);
}
gceSTATUS
gcoOS_SetDisplayVirtual(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
IN gctUINT Offset,
IN gctINT X,
IN gctINT Y
)
{
screen_buffer_t buf[gcdDISPLAY_BACK_BUFFERS];
int rc;
int rects[4];
gceSTATUS status = gcvSTATUS_OK;
gcmHEADER_ARG("Display=0x%x Window=0x%x Offset=%u X=%d Y=%d", Display, Window, Offset, X, Y);
rects[0] = 0;
rects[1] = 0;
rc = screen_get_window_property_pv((screen_window_t)Window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)buf);
if (rc)
{
goto OnError;
}
rc = screen_get_window_property_iv((screen_window_t)Window, SCREEN_PROPERTY_BUFFER_SIZE, &rects[2]);
if (rc)
{
goto OnError;
}
rc = screen_post_window((screen_window_t)Window, buf[0], 1, rects, 0);
if (rc)
{
goto OnError;
}
_ReleaseWindowInfoNode(Window);
gcmFOOTER_NO();
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
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;
}
void QBBScreen::newWindowCreated(screen_window_t window)
{
Q_ASSERT(thread() == QThread::currentThread());
screen_display_t display = 0;
if (screen_get_window_property_pv(window, SCREEN_PROPERTY_DISPLAY, (void**)&display) != 0) {
qWarning("QBBScreen: Failed to get screen for window, errno=%d", errno);
return;
}
if (display == nativeDisplay()) {
// A window was created on this screen. If we don't know about this window yet, it means
// it was not created by Qt, but by some foreign library like the multimedia renderer, which
// creates an overlay window when playing a video.
// Treat all foreign windows as overlays here.
if (!findWindow(window))
addOverlayWindow(window);
}
}
static void bb10display_fillWindowBuffer(BB10Display *d, MSPicture *yuvbuf) {
uint8_t *ptr = NULL;
screen_get_buffer_property_pv(d->pixmap_buffer, SCREEN_PROPERTY_POINTER, (void **)&ptr);
if (ptr) {
uint8_t *dest_planes[3];
int dest_strides[3];
MSVideoSize roi = {0};
uint8_t *y = ptr;
uint8_t *u = y + (d->vsize.height * d->stride);
uint8_t *v = u + (d->vsize.height * d->stride) / 4;
dest_planes[0] = y;
dest_planes[1] = u;
dest_planes[2] = v;
dest_strides[0] = d->stride;
dest_strides[1] = d->stride / 2;
dest_strides[2] = d->stride / 2;
roi.width = yuvbuf->w;
roi.height = yuvbuf->h;
ms_yuv_buf_copy(yuvbuf->planes, yuvbuf->strides, dest_planes, dest_strides, roi);
screen_buffer_t buffer;
screen_get_window_property_pv(d->window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**) &buffer);
MSRect rect;
ms_layout_center_rectangle(d->wsize, d->vsize, &rect);
int attributes[] = {
SCREEN_BLIT_SOURCE_WIDTH, d->vsize.width, SCREEN_BLIT_SOURCE_HEIGHT, d->vsize.height,
SCREEN_BLIT_DESTINATION_X, rect.x, SCREEN_BLIT_DESTINATION_Y, rect.y,
SCREEN_BLIT_DESTINATION_WIDTH, rect.w, SCREEN_BLIT_DESTINATION_HEIGHT, rect.h,
SCREEN_BLIT_END
};
screen_blit(d->context, buffer, d->pixmap_buffer, attributes);
int dirty_rect[4] = { 0, 0, d->wsize.width, d->wsize.height };
screen_post_window(d->window, buffer, 1, dirty_rect, 0);
}
}
gceSTATUS
gcoOS_GetNextDisplayInfoEx(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
IN gctUINT DisplayInfoSize,
OUT halDISPLAY_INFO * DisplayInfo
)
{
int rc;
gceSTATUS status = gcvSTATUS_OK;
screen_buffer_t buf[gcdDISPLAY_BACK_BUFFERS];
gcmHEADER_ARG("Display=0x%x Window=0x%x DisplayInfoSize=%u", Display, Window, DisplayInfoSize);
if ((Window == gcvNULL) || (DisplayInfoSize != sizeof(halDISPLAY_INFO)))
{
goto OnError;
}
rc = screen_get_window_property_pv((screen_window_t)Window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)buf);
if (rc)
{
goto OnError;
}
rc = screen_post_window((screen_window_t)Window, buf[0], 0, NULL, 0);
if (rc)
{
goto OnError;
}
status = gcoOS_GetDisplayInfoEx(Display, Window, DisplayInfoSize, DisplayInfo);
gcmFOOTER_ARG("*DisplayInfo=0x%x", *DisplayInfo);
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
/**
* 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;
}
void ScreenWindow::fillRect(Rect *rect, unsigned int color)
{
screen_buffer_t windowBuffer[1];
screen_get_window_property_pv(m_window,
SCREEN_PROPERTY_RENDER_BUFFERS, (void**)&windowBuffer);
if (rect) {
int attribs[] = {SCREEN_BLIT_DESTINATION_X, rect->x,
SCREEN_BLIT_DESTINATION_Y, rect->y,
SCREEN_BLIT_DESTINATION_WIDTH, rect->w,
SCREEN_BLIT_DESTINATION_HEIGHT, rect->h,
SCREEN_BLIT_COLOR, color,
SCREEN_BLIT_END};
screen_fill(m_context, windowBuffer[0], attribs);
} else {
int attribs[] = {SCREEN_BLIT_DESTINATION_X, 0,
SCREEN_BLIT_DESTINATION_Y, 0,
SCREEN_BLIT_DESTINATION_WIDTH, m_width,
SCREEN_BLIT_DESTINATION_HEIGHT, m_height,
SCREEN_BLIT_COLOR, color,
SCREEN_BLIT_END};
screen_fill(m_context, windowBuffer[0], attribs);
}
}
int PLAYBOOK_FlipHWSurface(SDL_VideoDevice *device, SDL_Surface *surface)
{
// FIXME: device doesn't work properly yet. It flashes black, I think the new render buffers are wrong.
static int fullRect[] = {0, 0, 1024, 600};
//screen_flush_blits(device->hidden->screenContext, 0);
int result = screen_post_window(device->hidden->screenWindow, surface->hwdata->front, 1, fullRect, 0);
screen_buffer_t windowBuffer[2];
int rc = screen_get_window_property_pv(device->hidden->screenWindow, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)&windowBuffer);
if (rc) {
SDL_SetError("Cannot get window render buffers: %s", strerror(errno));
return NULL;
}
rc = screen_get_buffer_property_pv(windowBuffer[0], SCREEN_PROPERTY_POINTER, &device->hidden->pixels);
if (rc) {
SDL_SetError("Cannot get buffer pointer: %s", strerror(errno));
return NULL;
}
surface->hwdata->front = windowBuffer[0];
surface->pixels = device->hidden->pixels;
return 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;
}
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 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;
}
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;
}
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;
}
// 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
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;
}
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 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;
}
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);
}
