drm/tests/kms/kms-universal-planes.c

358 lines
7.5 KiB
C

/*
* Copyright © 2014 NVIDIA Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include <fcntl.h>
#include <getopt.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#include <drm_fourcc.h>
#include "xf86drm.h"
#include "util/common.h"
#include "libkms-test.h"
static const uint32_t formats[] = {
DRM_FORMAT_XRGB8888,
DRM_FORMAT_XBGR8888,
DRM_FORMAT_RGBA8888,
};
static uint32_t choose_format(struct kms_plane *plane)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(formats); i++)
if (kms_plane_supports_format(plane, formats[i]))
return formats[i];
return 0;
}
static void prepare_framebuffer(struct kms_framebuffer *fb, bool invert)
{
const unsigned int block_size = 16;
uint32_t colors[2];
unsigned int i, j;
uint32_t *buf;
void *ptr;
int err;
switch (fb->format) {
case DRM_FORMAT_XRGB8888:
printf("using XRGB8888 format\n");
/* XXRRGGBB */
colors[0] = 0xffff0000;
colors[1] = 0xff0000ff;
break;
case DRM_FORMAT_XBGR8888:
printf("using XBGR8888 format\n");
/* XXBBGGRR */
colors[0] = 0xff0000ff;
colors[1] = 0xffff0000;
break;
case DRM_FORMAT_RGBA8888:
printf("using RGBA8888 format\n");
/* RRGGBBAA */
colors[0] = 0xff0000ff;
colors[1] = 0x0000ffff;
break;
default:
colors[0] = 0xffffffff;
colors[1] = 0xffffffff;
break;
}
err = kms_framebuffer_map(fb, &ptr);
if (err < 0) {
fprintf(stderr, "kms_framebuffer_map() failed: %s\n",
strerror(-err));
return;
}
buf = ptr;
for (j = 0; j < fb->height; j++) {
for (i = 0; i < fb->width; i++) {
unsigned int color = (j / block_size) ^
(i / block_size);
if (invert)
color ^= color;
*buf++ = colors[color & 1];
}
}
kms_framebuffer_unmap(fb);
}
int main(int argc, char *argv[])
{
static const char opts[] = "chopv";
static struct option options[] = {
{ "cursor", 0, 0, 'c' },
{ "help", 0, 0, 'h' },
{ "overlay", 0, 0, 'o' },
{ "primary", 0, 0, 'p' },
{ "verbose", 0, 0, 'v' },
{ 0, 0, 0, 0 },
};
struct kms_framebuffer *cursor = NULL;
struct kms_framebuffer *root = NULL;
struct kms_framebuffer *fb = NULL;
struct kms_device *device;
bool use_overlay = false;
bool use_primary = false;
struct kms_plane *plane;
bool use_cursor = false;
bool verbose = false;
unsigned int i;
int opt, idx;
int fd, err;
while ((opt = getopt_long(argc, argv, opts, options, &idx)) != -1) {
switch (opt) {
case 'c':
use_cursor = true;
break;
case 'h':
break;
case 'o':
use_overlay = true;
break;
case 'p':
use_primary = true;
break;
case 'v':
verbose = true;
break;
default:
printf("unknown option \"%c\"\n", opt);
return 1;
}
}
if (optind >= argc) {
fprintf(stderr, "usage: %s [options] DEVICE\n", argv[0]);
return 1;
}
fd = open(argv[optind], O_RDWR);
if (fd < 0) {
fprintf(stderr, "open() failed: %m\n");
return 1;
}
err = drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
if (err < 0) {
fprintf(stderr, "drmSetClientCap() failed: %d\n", err);
return 1;
}
device = kms_device_open(fd);
if (!device)
return 1;
if (verbose) {
printf("Screens: %u\n", device->num_screens);
for (i = 0; i < device->num_screens; i++) {
struct kms_screen *screen = device->screens[i];
const char *status = "disconnected";
if (screen->connected)
status = "connected";
printf(" %u: %x\n", i, screen->id);
printf(" Status: %s\n", status);
printf(" Name: %s\n", screen->name);
printf(" Resolution: %ux%u\n", screen->width,
screen->height);
}
printf("Planes: %u\n", device->num_planes);
for (i = 0; i < device->num_planes; i++) {
const char *type = NULL;
plane = device->planes[i];
switch (plane->type) {
case DRM_PLANE_TYPE_OVERLAY:
type = "overlay";
break;
case DRM_PLANE_TYPE_PRIMARY:
type = "primary";
break;
case DRM_PLANE_TYPE_CURSOR:
type = "cursor";
break;
}
printf(" %u: %p\n", i, plane);
printf(" ID: %x\n", plane->id);
printf(" CRTC: %x\n", plane->crtc->id);
printf(" Type: %x (%s)\n", plane->type, type);
}
}
if (use_cursor) {
unsigned int x, y;
uint32_t format;
plane = kms_device_find_plane_by_type(device,
DRM_PLANE_TYPE_CURSOR,
0);
if (!plane) {
fprintf(stderr, "no cursor plane found\n");
return 1;
}
format = choose_format(plane);
if (!format) {
fprintf(stderr, "no matching format found\n");
return 1;
}
cursor = kms_framebuffer_create(device, 32, 32, format);
if (!cursor) {
fprintf(stderr, "failed to create cursor buffer\n");
return 1;
}
prepare_framebuffer(cursor, false);
x = (device->screens[0]->width - cursor->width) / 2;
y = (device->screens[0]->height - cursor->height) / 2;
kms_plane_set(plane, cursor, x, y);
}
if (use_overlay) {
uint32_t format;
plane = kms_device_find_plane_by_type(device,
DRM_PLANE_TYPE_OVERLAY,
0);
if (!plane) {
fprintf(stderr, "no overlay plane found\n");
return 1;
}
format = choose_format(plane);
if (!format) {
fprintf(stderr, "no matching format found\n");
return 1;
}
fb = kms_framebuffer_create(device, 320, 240, format);
if (!fb)
return 1;
prepare_framebuffer(fb, false);
kms_plane_set(plane, fb, 0, 0);
}
if (use_primary) {
unsigned int x, y;
uint32_t format;
plane = kms_device_find_plane_by_type(device,
DRM_PLANE_TYPE_PRIMARY,
0);
if (!plane) {
fprintf(stderr, "no primary plane found\n");
return 1;
}
format = choose_format(plane);
if (!format) {
fprintf(stderr, "no matching format found\n");
return 1;
}
root = kms_framebuffer_create(device, 640, 480, format);
if (!root)
return 1;
prepare_framebuffer(root, true);
x = (device->screens[0]->width - root->width) / 2;
y = (device->screens[0]->height - root->height) / 2;
kms_plane_set(plane, root, x, y);
}
while (1) {
struct timeval timeout = { 1, 0 };
fd_set fds;
FD_ZERO(&fds);
FD_SET(STDIN_FILENO, &fds);
err = select(STDIN_FILENO + 1, &fds, NULL, NULL, &timeout);
if (err < 0) {
fprintf(stderr, "select() failed: %m\n");
break;
}
/* timeout */
if (err == 0)
continue;
if (FD_ISSET(STDIN_FILENO, &fds))
break;
}
if (cursor)
kms_framebuffer_free(cursor);
if (root)
kms_framebuffer_free(root);
if (fb)
kms_framebuffer_free(fb);
kms_device_close(device);
close(fd);
return 0;
}