void WindowGrabber::updateFrameSize()
{
int size[2] = { m_screenBufferWidth, m_screenBufferHeight };
screen_set_pixmap_property_iv(m_screenPixmaps[0], SCREEN_PROPERTY_BUFFER_SIZE, size);
if (eglImageSupported())
screen_set_pixmap_property_iv(m_screenPixmaps[1], SCREEN_PROPERTY_BUFFER_SIZE, size);
int result = screen_create_pixmap_buffer(m_screenPixmaps[0]);
if (eglImageSupported())
result |= screen_create_pixmap_buffer(m_screenPixmaps[1]);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot create pixmap buffer:" << strerror(errno);
return;
} else {
m_screenPixmapBuffersInitialized = true;
}
result = screen_get_pixmap_property_pv(m_screenPixmaps[0], SCREEN_PROPERTY_RENDER_BUFFERS,
(void**)&m_screenPixmapBuffers[0]);
if (eglImageSupported()) {
result |= screen_get_pixmap_property_pv(m_screenPixmaps[1], SCREEN_PROPERTY_RENDER_BUFFERS,
(void**)&m_screenPixmapBuffers[1]);
}
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get pixmap buffer:" << strerror(errno);
return;
}
result = screen_get_buffer_property_pv(m_screenPixmapBuffers[0], SCREEN_PROPERTY_POINTER,
(void**)&m_screenBuffers[0]);
if (eglImageSupported()) {
result |= screen_get_buffer_property_pv(m_screenPixmapBuffers[1], SCREEN_PROPERTY_POINTER,
(void**)&m_screenBuffers[1]);
}
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get pixmap buffer pointer:" << strerror(errno);
return;
}
result = screen_get_buffer_property_iv(m_screenPixmapBuffers[0], SCREEN_PROPERTY_STRIDE,
&m_screenBufferStride);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get pixmap buffer stride:" << strerror(errno);
return;
}
}
QQnxBuffer::QQnxBuffer(screen_buffer_t buffer)
: m_buffer(buffer)
{
qBufferDebug() << Q_FUNC_INFO << "normal";
// Get size of buffer
int size[2];
Q_SCREEN_CRITICALERROR(screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_BUFFER_SIZE, size),
"Failed to query buffer size");
// Get stride of buffer
int stride;
Q_SCREEN_CHECKERROR(screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_STRIDE, &stride),
"Failed to query buffer stride");
// Get access to buffer's data
errno = 0;
uchar *dataPtr = 0;
Q_SCREEN_CRITICALERROR(
screen_get_buffer_property_pv(buffer, SCREEN_PROPERTY_POINTER, (void **)&dataPtr),
"Failed to query buffer pointer");
if (dataPtr == 0)
qFatal("QQNX: buffer pointer is NULL, errno=%d", errno);
// Get format of buffer
int screenFormat;
Q_SCREEN_CHECKERROR(
screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_FORMAT, &screenFormat),
"Failed to query buffer format");
// Convert screen format to QImage format
QImage::Format imageFormat = QImage::Format_Invalid;
switch (screenFormat) {
case SCREEN_FORMAT_RGBX4444:
imageFormat = QImage::Format_RGB444;
break;
case SCREEN_FORMAT_RGBA4444:
imageFormat = QImage::Format_ARGB4444_Premultiplied;
break;
case SCREEN_FORMAT_RGBX5551:
imageFormat = QImage::Format_RGB555;
break;
case SCREEN_FORMAT_RGB565:
imageFormat = QImage::Format_RGB16;
break;
case SCREEN_FORMAT_RGBX8888:
imageFormat = QImage::Format_RGB32;
break;
case SCREEN_FORMAT_RGBA8888:
imageFormat = QImage::Format_ARGB32_Premultiplied;
break;
default:
qFatal("QQNX: unsupported buffer format, format=%d", screenFormat);
}
// wrap buffer in an image
m_image = QImage(dataPtr, size[0], size[1], stride, imageFormat);
}
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);
}
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 *qnxscreen_search_index(struct qnxscreen_api *q, uint32_t index)
{
void *tmpbuf_dat;
int ret;
if (index > q->count || index > QNXSCREEN_MAX_INDEX)
return NULL;
ret = screen_get_buffer_property_pv(q->buf[index], SCREEN_PROPERTY_POINTER,
(void **)&tmpbuf_dat);
if (ret)
return NULL;
return tmpbuf_dat;
}
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);
}
}
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;
}
uint32_t qnxscreen_search_buffer(struct qnxscreen_api *q, void *buffer)
{
uint32_t index = QNXSCREEN_INVALID_INDEX;
for (index = 0; index < q->count; index++) {
void *tmpbuf_dat;
int ret;
ret = screen_get_buffer_property_pv(q->buf[index],
SCREEN_PROPERTY_POINTER,
(void **)&tmpbuf_dat);
if (ret)
return QNXSCREEN_INVALID_INDEX;
if (tmpbuf_dat == buffer)
return index;
}
if (index >= q->count)
index = QNXSCREEN_INVALID_INDEX;
return index;
}
gceSTATUS
gcoOS_GetPixmapInfo(
IN HALNativeDisplayType Display,
IN HALNativePixmapType Pixmap,
OUT gctINT * Width,
OUT gctINT * Height,
OUT gctINT * BitsPerPixel,
OUT gctINT * Stride,
OUT gctPOINTER * Bits
)
{
gctINT rc, size[2], format;
screen_buffer_t buf[2];
gceSTATUS status = gcvSTATUS_OK;
gcmHEADER_ARG("Display=0x%x Pixmap=0x%x", Display, Pixmap);
if (Pixmap == gcvNULL)
{
/* Pixmap is not a valid pixmap data structure pointer. */
goto OnError;
}
if ((Width != gcvNULL) || (Height != gcvNULL))
{
rc = screen_get_pixmap_property_iv(Pixmap, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
goto OnError;
}
if (Width != gcvNULL)
{
*Width = size[0];
}
if (Height != gcvNULL)
{
*Height = size[1];
}
}
if (BitsPerPixel != gcvNULL)
{
rc = screen_get_pixmap_property_iv(Pixmap, SCREEN_PROPERTY_FORMAT, &format);
if (rc)
{
goto OnError;
}
_ConvertWindowFormat(format, BitsPerPixel, gcvNULL);
}
rc = screen_get_pixmap_property_pv(Pixmap, SCREEN_PROPERTY_RENDER_BUFFERS, (void **) &buf);
if (rc)
{
goto OnError;
}
if (Stride != NULL)
{
rc = screen_get_buffer_property_iv(buf[0], SCREEN_PROPERTY_STRIDE, (int *) Stride);
if (rc)
{
goto OnError;
}
}
if (Bits != NULL)
{
rc = screen_get_buffer_property_pv(buf[0], SCREEN_PROPERTY_POINTER, (void **) Bits);
if (rc)
{
goto OnError;
}
}
gcmFOOTER_NO();
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
gceSTATUS
gcoOS_GetDisplayInfoEx(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
IN gctUINT DisplayInfoSize,
OUT halDISPLAY_INFO * DisplayInfo
)
{
gceSTATUS status = gcvSTATUS_OK;
screen_buffer_t buf[gcdDISPLAY_BACK_BUFFERS];
gctPOINTER pointer;
off64_t paddr;
gctINT rc, stride;
gctINT size[2];
gcmHEADER_ARG("Display=0x%x Window=0x%x DisplayInfoSize=%u", Display, Window, DisplayInfoSize);
/* Valid Window? and structure size? */
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;
}
/* For QNX, the Width and Height are size of the framebuffer. */
rc = screen_get_buffer_property_iv(buf[0], SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
goto OnError;
}
DisplayInfo->width = size[0];
DisplayInfo->height = size[1];
/* The stride of the window. */
rc = screen_get_buffer_property_iv(buf[0], SCREEN_PROPERTY_STRIDE, &stride);
if (rc)
{
goto OnError;
}
DisplayInfo->stride = stride;
/* The logical address of the window. */
rc = screen_get_buffer_property_pv(buf[0], SCREEN_PROPERTY_POINTER, &pointer);
if (rc)
{
goto OnError;
}
DisplayInfo->logical = pointer;
/* The physical address of the window. */
rc = screen_get_buffer_property_llv(buf[0], SCREEN_PROPERTY_PHYSICAL_ADDRESS, &paddr);
if (rc)
{
goto OnError;
}
DisplayInfo->physical = paddr;
/* Flip. */
DisplayInfo->flip = 1;
/* Success. */
gcmFOOTER_ARG("*DisplayInfo=0x%x", *DisplayInfo);
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
void WindowGrabber::start()
{
int result = 0;
#ifdef Q_OS_BLACKBERRY_TABLET
// HACK: On the Playbook, screen_read_window() will fail for invisible windows.
// To workaround this, make the window visible again, but set a global
// alpha of less than 255. The global alpha makes the window completely invisible
// (due to a bug?), but screen_read_window() will work again.
errno = 0;
int val = 200; // anything less than 255
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_GLOBAL_ALPHA, &val);
if (result != 0) {
qWarning() << "WindowGrabber: unable to set global alpha:" << strerror(errno);
return;
}
errno = 0;
val = 1;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &val);
if (result != 0) {
qWarning() << "WindowGrabber: unable to make window visible:" << strerror(errno);
return;
}
#endif
result = screen_create_context(&m_screenContext, SCREEN_APPLICATION_CONTEXT);
if (result != 0) {
qWarning() << "WindowGrabber: cannot create screen context:" << strerror(errno);
return;
} else {
m_screenContextInitialized = true;
}
result = screen_create_pixmap(&m_screenPixmap, m_screenContext);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot create pixmap:" << strerror(errno);
return;
} else {
m_screenPixmapInitialized = true;
}
const int usage = SCREEN_USAGE_READ | SCREEN_USAGE_NATIVE;
result = screen_set_pixmap_property_iv(m_screenPixmap, SCREEN_PROPERTY_USAGE, &usage);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot set pixmap usage:" << strerror(errno);
return;
}
const int format = SCREEN_FORMAT_RGBA8888;
result = screen_set_pixmap_property_iv(m_screenPixmap, SCREEN_PROPERTY_FORMAT, &format);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot set pixmap format:" << strerror(errno);
return;
}
int size[2] = { 0, 0 };
result = screen_get_window_property_iv(m_window, SCREEN_PROPERTY_SIZE, size);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get window size:" << strerror(errno);
return;
}
m_screenBufferWidth = size[0];
m_screenBufferHeight = size[1];
result = screen_set_pixmap_property_iv(m_screenPixmap, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot set pixmap size:" << strerror(errno);
return;
}
result = screen_create_pixmap_buffer(m_screenPixmap);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot create pixmap buffer:" << strerror(errno);
return;
}
result = screen_get_pixmap_property_pv(m_screenPixmap, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)&m_screenPixmapBuffer);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get pixmap buffer:" << strerror(errno);
return;
} else {
m_screenPixmapBufferInitialized = true;
}
result = screen_get_buffer_property_pv(m_screenPixmapBuffer, SCREEN_PROPERTY_POINTER, (void**)&m_screenBuffer);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get pixmap buffer pointer:" << strerror(errno);
return;
}
result = screen_get_buffer_property_iv(m_screenPixmapBuffer, SCREEN_PROPERTY_STRIDE, &m_screenBufferStride);
if (result != 0) {
cleanup();
qWarning() << "WindowGrabber: cannot get pixmap buffer stride:" << strerror(errno);
return;
}
m_timer.start();
m_active = true;
}
bool_e qnxscreen_allocate(struct qnxscreen_api *q,
uint32_t width, uint32_t height,
uint32_t count, fourcc_t color)
{
bool_e ret = false_e;
int size[2] = {(int)width, (int)height};
int bsize[2] = {(int)width, (int)height};
int i;
int pformat = 0;
int err;
int zOrder = 50;
int dispCount = 0;
int formatCount = 0;
int sensitivity = SCREEN_SENSITIVITY_NEVER;
int tranparency = SCREEN_TRANSPARENCY_NONE;
int idleMode = SCREEN_IDLE_MODE_KEEP_AWAKE;
screen_display_t *displays;
screen_display_t display;
int formats[SCREEN_FORMAT_NFORMATS];
bool_e configured = false_e;
const int usage = SCREEN_USAGE_WRITE | SCREEN_USAGE_NATIVE | SCREEN_USAGE_CAPTURE;
mutex_lock(&q->m_lock);
err = screen_create_window_type(&q->win, q->ctx, SCREEN_APPLICATION_WINDOW);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR,
"(%s) Failure on screen_create_window_type: (%d)\n",
__func__, errno);
goto leave;
}
err = screen_get_context_property_iv(q->ctx, SCREEN_PROPERTY_DISPLAY_COUNT, (void *)&dispCount);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR, "Failed to query the number of displays! err=%d\n",err);
goto leave2;
}
DVP_PRINT(DVP_ZONE_VIDEO, "There are %u displays\n", dispCount);
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_ZORDER, &zOrder);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR,
"(%s) Failure on screen_create_window_type: (%d)\n",
__func__, errno);
goto leave2;
}
// this tells the window to not receive input events
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_SENSITIVITY, &sensitivity);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR, "Failed to set window sensitivity to zero (%d)\n", err);
goto leave2;
}
// this is not the same as global alpha.
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_TRANSPARENCY, &tranparency);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR, "Failed to set window transparency to none (%d)\n", err);
goto leave2;
}
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_USAGE, &usage);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR,
"(%s) Failure setting USAGE window property: (%d)\n",
__func__, errno);
goto leave2;
}
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_IDLE_MODE, &idleMode);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR, "Failed to set window idle mode to keep awake (%d)\n", err);
goto leave2;
}
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_SIZE, size);
if (err)
goto leave2;
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_SOURCE_SIZE, bsize);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR,
"(%s) Failure setting SOURCE_SIZE window property: (%d)\n",
__func__, errno);
goto leave2;
}
if (width % OMX_CAMERA_ALIGNMENT)
bsize[0] = ( (width / OMX_CAMERA_ALIGNMENT) + 1) * OMX_CAMERA_ALIGNMENT;
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_BUFFER_SIZE, bsize);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR,
"(%s) Failure setting BUFFER_SIZE window property: (%d)\n",
__func__, errno);
goto leave2;
}
for (i = 0; i < numCodes; i++) {
if (color == codes[i].fourcc)
pformat = codes[i].qnxscreen_fmt;
}
if (pformat == 0)
{
DVP_PRINT(DVP_ZONE_ERROR, "Unknown FOURCC 0x%x\n", color);
goto leave2;
}
else
{
DVP_PRINT(DVP_ZONE_VIDEO, "Configuring display for fmt:%d\n", pformat);
}
screen_get_window_property_pv(q->win, SCREEN_PROPERTY_DISPLAY, (void *)&display);
screen_get_display_property_iv(display, SCREEN_PROPERTY_FORMAT_COUNT, (void *)&formatCount);
screen_get_display_property_iv(display, SCREEN_PROPERTY_FORMATS, (void *)formats);
for (i = 0; i < formatCount; i++)
{
DVP_PRINT(DVP_ZONE_VIDEO, "Display %p supports format %d\n", display, formats[i]);
}
configured = false_e;
for (i = 0; i < formatCount; i++)
{
if (formats[i] == pformat)
{
err = screen_set_window_property_iv(q->win, SCREEN_PROPERTY_FORMAT, &pformat);
if (err)
{
DVP_PRINT(DVP_ZONE_ERROR, "screen_set_window_property_iv() returned %d when setting format %d\n", err, pformat);
goto leave2;
}
else
configured = true_e;
}
}
if (configured == false_e)
{
DVP_PRINT(DVP_ZONE_ERROR, "Display %p does not support format %d\n", display, pformat);
goto leave2;
}
err = screen_create_window_buffers(q->win, (int)count);
if (err) {
DVP_PRINT(DVP_ZONE_ERROR, "screen_create_window_buffers() returned %d when requesting %u buffers\n", err, count);
goto leave2;
}
err = screen_get_window_property_pv(q->win, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)q->buf);
if (err) {
perror("screen_get_window_property(SCREEN_PROPERTY_RENDER_BUFFERS)");
goto leave2;
}
q->count = count;
q->pfmt = pformat;
q->metrics.left = 0;
q->metrics.top = 0;
q->metrics.width = size[0];
q->metrics.height = size[1];
bitfield_init(&q->used, q->count);
DVP_PRINT(DVP_ZONE_VIDEO, "QNX Screen Configuring %u images for %ux%u fmt:%d\n",
count, size[0], size[1], pformat);
for (i = 0; i < q->count; i++)
{
void *ptr = NULL;
screen_get_buffer_property_pv(q->buf[i], SCREEN_PROPERTY_POINTER, &ptr);
DVP_PRINT(DVP_ZONE_VIDEO, "\t[%u] ptr=%p\n", i, ptr);
}
ret = true_e;
leave:
mutex_unlock(&q->m_lock);
return ret;
leave2:
screen_destroy_window(q->win);
mutex_unlock(&q->m_lock);
return ret;
}
QBBBuffer::QBBBuffer(screen_buffer_t buffer)
: mBuffer(buffer)
{
#if defined(QBBBUFFER_DEBUG)
qDebug() << "QBBBuffer::QBBBuffer - normal";
#endif
// get size of buffer
errno = 0;
int size[2];
int result = screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (result != 0) {
qFatal("QBB: failed to query buffer size, errno=%d", errno);
}
// get stride of buffer
errno = 0;
int stride;
result = screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_STRIDE, &stride);
if (result != 0) {
qFatal("QBB: failed to query buffer stride, errno=%d", errno);
}
// get access to buffer's data
errno = 0;
uchar* dataPtr = NULL;
result = screen_get_buffer_property_pv(buffer, SCREEN_PROPERTY_POINTER, (void **)&dataPtr);
if (result != 0) {
qFatal("QBB: failed to query buffer pointer, errno=%d", errno);
}
if (dataPtr == NULL) {
qFatal("QBB: buffer pointer is NULL, errno=%d", errno);
}
// get format of buffer
errno = 0;
int screenFormat;
result = screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (result != 0) {
qFatal("QBB: failed to query buffer format, errno=%d", errno);
}
// convert screen format to QImage format
QImage::Format imageFormat = QImage::Format_Invalid;
switch (screenFormat) {
case SCREEN_FORMAT_RGBX4444:
imageFormat = QImage::Format_RGB444;
break;
case SCREEN_FORMAT_RGBA4444:
imageFormat = QImage::Format_ARGB4444_Premultiplied;
break;
case SCREEN_FORMAT_RGBX5551:
imageFormat = QImage::Format_RGB555;
break;
case SCREEN_FORMAT_RGB565:
imageFormat = QImage::Format_RGB16;
break;
case SCREEN_FORMAT_RGBX8888:
imageFormat = QImage::Format_RGB32;
break;
case SCREEN_FORMAT_RGBA8888:
imageFormat = QImage::Format_ARGB32_Premultiplied;
break;
default:
qFatal("QBB: unsupported buffer format, format=%d", screenFormat);
}
// wrap buffer in an image
mImage = QImage(dataPtr, size[0], size[1], stride, imageFormat);
}
