On Sat, Feb 01, 2014 at 12:43:48AM +0530, [email protected] wrote: > From: Sagar Kamble <[email protected]> > > This test will verify the 180 degree rotation of sprite and crtc planes. > It will allow user to control rotation separately for crtc and sprite > planes. > > Signed-off-by: Sagar Kamble <[email protected]>
What I actually want for upstreaming is a fully automated testcase as part of our i-g-t testsuite which uses the CRC support. Having testing tools for developers is neat, but if it's not automated it's essentially untested. I don't mind merging this if there's someone else who'll ack it though. -Daniel > --- > demos/Makefile.am | 1 + > demos/intel_plane_rotate.c | 929 > +++++++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 930 insertions(+) > create mode 100644 demos/intel_plane_rotate.c > > diff --git a/demos/Makefile.am b/demos/Makefile.am > index 49804d7..1cee2b6 100644 > --- a/demos/Makefile.am > +++ b/demos/Makefile.am > @@ -1,5 +1,6 @@ > bin_PROGRAMS = \ > intel_sprite_on \ > + intel_plane_rotate \ > $(NULL) > > AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib > diff --git a/demos/intel_plane_rotate.c b/demos/intel_plane_rotate.c > new file mode 100644 > index 0000000..b203d75 > --- /dev/null > +++ b/demos/intel_plane_rotate.c > @@ -0,0 +1,929 @@ > +/* > + * Copyright © 2014 Intel 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. > + * > + * > + * Author: > + * Sagar Kamble <[email protected]> > + */ > + > +/* > + * Most of the functions are reused from intel_sprite_on test by Armeen Reese > + * <[email protected]> > + * This program is intended for testing CRTC and plane rotation > functionality. > + */ > +#include <assert.h> > +#include <errno.h> > +#include <math.h> > +#include <stdint.h> > +#include <stdio.h> > +#include <stdlib.h> > +#include <string.h> > +#include <unistd.h> > +#include <termios.h> > +#include <sys/time.h> > +#include <sys/poll.h> > +#include <sys/time.h> > +#include <sys/mman.h> > +#include <sys/ioctl.h> > + > +#include "i915_drm.h" > +#include "drmtest.h" > +#include "igt_kms.h" > + > +#if defined(DRM_IOCTL_MODE_ADDFB2) && defined(DRM_I915_SET_SPRITE_COLORKEY) > +#define TEST_PLANES 1 > +#include "drm_fourcc.h" > +#endif > + > +#define DRM_ROTATE_0 0 > +#define DRM_ROTATE_90 1 > +#define DRM_ROTATE_180 2 > +#define DRM_ROTATE_270 3 > +#define DRM_REFLECT_X 4 > +#define DRM_REFLECT_Y 5 > + > +#define BIT(x) (1 << x) > + > +/* > + * Mode setting with the kernel interfaces is a bit of a chore. > + * First you have to find the connector in question and make sure the > + * requested mode is available. > + * Then you need to find the encoder attached to that connector so you > + * can bind it with a free crtc. > + */ > +struct connector { > + uint32_t id; > + int mode_valid; > + drmModeModeInfo mode; > + drmModeEncoder *encoder; > + drmModeConnector *connector; > + int crtc; > + int pipe; > +}; > + > +static void dump_mode(drmModeModeInfo *mode) > +{ > + printf(" %s %d %d %d %d %d %d %d %d %d 0x%x 0x%x %d\n", > + mode->name, > + mode->vrefresh, > + mode->hdisplay, > + mode->hsync_start, > + mode->hsync_end, > + mode->htotal, > + mode->vdisplay, > + mode->vsync_start, > + mode->vsync_end, > + mode->vtotal, > + mode->flags, > + mode->type, > + mode->clock); > +} > + > +static void dump_connectors(int gfx_fd, drmModeRes *resources) > +{ > + int i, j; > + > + printf("Connectors:\n"); > + printf("id\tencoder\tstatus\t\ttype\tsize (mm)\tmodes\n"); > + for (i = 0; i < resources->count_connectors; i++) { > + drmModeConnector *connector; > + > + connector = drmModeGetConnector(gfx_fd, > resources->connectors[i]); > + if (!connector) { > + printf("could not get connector %i: %s\n", > + resources->connectors[i], > strerror(errno)); > + continue; > + } > + > + printf("%d\t%d\t%s\t%s\t%dx%d\t\t%d\n", > + connector->connector_id, > + connector->encoder_id, > + kmstest_connector_status_str(connector->connection), > + kmstest_connector_type_str(connector->connector_type), > + connector->mmWidth, connector->mmHeight, > + connector->count_modes); > + > + if (!connector->count_modes) > + continue; > + > + printf(" modes:\n"); > + printf(" name refresh (Hz) hdisp hss hse htot vdisp vss vse > vtot flags type clock\n"); > + for (j = 0; j < connector->count_modes; j++) > + dump_mode(&connector->modes[j]); > + > + drmModeFreeConnector(connector); > + } > + printf("\n"); > +} > + > +static void dump_crtcs(int gfx_fd, drmModeRes *resources) > +{ > + int i; > + > + printf("CRTCs:\n"); > + printf("id\tfb\tpos\tsize\n"); > + for (i = 0; i < resources->count_crtcs; i++) { > + drmModeCrtc *crtc; > + > + crtc = drmModeGetCrtc(gfx_fd, resources->crtcs[i]); > + if (!crtc) { > + printf("could not get crtc %i: %s\n", > + resources->crtcs[i], > + strerror(errno)); > + continue; > + } > + printf("%d\t%d\t(%d,%d)\t(%dx%d)\n", > + crtc->crtc_id, > + crtc->buffer_id, > + crtc->x, crtc->y, > + crtc->width, crtc->height); > + dump_mode(&crtc->mode); > + > + drmModeFreeCrtc(crtc); > + } > + printf("\n"); > +} > + > +static void dump_planes(int gfx_fd, drmModeRes *resources) > +{ > + drmModePlaneRes *plane_resources; > + drmModePlane *ovr; > + int i; > + > + plane_resources = drmModeGetPlaneResources(gfx_fd); > + if (!plane_resources) { > + printf("drmModeGetPlaneResources failed: %s\n", > + strerror(errno)); > + return; > + } > + > + printf("Planes:\n"); > + printf("id\tcrtc\tfb\tCRTC x,y\tx,y\tgamma size\n"); > + for (i = 0; i < plane_resources->count_planes; i++) { > + ovr = drmModeGetPlane(gfx_fd, plane_resources->planes[i]); > + if (!ovr) { > + printf("drmModeGetPlane failed: %s\n", > + strerror(errno)); > + continue; > + } > + > + printf("%d\t%d\t%d\t%d,%d\t\t%d,%d\t%d\n", > + ovr->plane_id, ovr->crtc_id, ovr->fb_id, > + ovr->crtc_x, ovr->crtc_y, ovr->x, ovr->y, > + ovr->gamma_size); > + > + drmModeFreePlane(ovr); > + } > + printf("\n"); > + > + return; > +} > + > +static void connector_find_preferred_mode(int gfx_fd, > + drmModeRes *gfx_resources, > + struct connector *c) > +{ > + drmModeConnector *connector; > + drmModeEncoder *encoder = NULL; > + int i, j; > + > + /* First, find the connector & mode */ > + c->mode_valid = 0; > + connector = drmModeGetConnector(gfx_fd, c->id); > + if (!connector) { > + printf("could not get connector %d: %s\n", > + c->id, > + strerror(errno)); > + drmModeFreeConnector(connector); > + return; > + } > + > + if (connector->connection != DRM_MODE_CONNECTED) { > + drmModeFreeConnector(connector); > + return; > + } > + > + if (!connector->count_modes) { > + printf("connector %d has no modes\n", > + c->id); > + drmModeFreeConnector(connector); > + return; > + } > + > + if (connector->connector_id != c->id) { > + printf("connector id doesn't match (%d != %d)\n", > + connector->connector_id, > + c->id); > + drmModeFreeConnector(connector); > + return; > + } > + > + for (j = 0; j < connector->count_modes; j++) { > + c->mode = connector->modes[j]; > + if (c->mode.type & DRM_MODE_TYPE_PREFERRED) { > + c->mode_valid = 1; > + break; > + } > + } > + > + if (!c->mode_valid) { > + if (connector->count_modes > 0) { > + /* use the first mode as test mode */ > + c->mode = connector->modes[0]; > + c->mode_valid = 1; > + } else { > + printf("failed to find any modes on connector %d\n", > + c->id); > + return; > + } > + } > + > + /* Now get the encoder */ > + for (i = 0; i < connector->count_encoders; i++) { > + encoder = drmModeGetEncoder(gfx_fd, connector->encoders[i]); > + > + if (!encoder) { > + printf("could not get encoder %i: %s\n", > + gfx_resources->encoders[i], > + strerror(errno)); > + drmModeFreeEncoder(encoder); > + continue; > + } > + > + break; > + } > + > + c->encoder = encoder; > + > + if (i == gfx_resources->count_encoders) { > + printf("failed to find encoder\n"); > + c->mode_valid = 0; > + return; > + } > + > + /* Find first CRTC not in use */ > + for (i = 0; i < gfx_resources->count_crtcs; i++) { > + if (gfx_resources->crtcs[i] && (c->encoder->possible_crtcs & > (1<<i))) > + break; > + } > + c->crtc = gfx_resources->crtcs[i]; > + c->pipe = i; > + > + gfx_resources->crtcs[i] = 0; > + > + c->connector = connector; > +} > + > +static int connector_find_plane(int gfx_fd, struct connector *c) > +{ > + drmModePlaneRes *plane_resources; > + drmModePlane *ovr; > + uint32_t id = 0; > + int i; > + > + plane_resources = drmModeGetPlaneResources(gfx_fd); > + if (!plane_resources) { > + printf("drmModeGetPlaneResources failed: %s\n", > + strerror(errno)); > + return 0; > + } > + > + for (i = 0; i < plane_resources->count_planes; i++) { > + ovr = drmModeGetPlane(gfx_fd, plane_resources->planes[i]); > + if (!ovr) { > + printf("drmModeGetPlane failed: %s\n", > + strerror(errno)); > + continue; > + } > + > + if (ovr->possible_crtcs & (1 << c->pipe)) { > + id = ovr->plane_id; > + drmModeFreePlane(ovr); > + break; > + } > + drmModeFreePlane(ovr); > + } > + > + return id; > +} > + > + > +static int prepare_primary_surface(int fd, int prim_width, int prim_height, > + uint32_t *prim_handle, uint32_t *prim_stride, > + uint32_t *prim_size, int tiled) > +{ > + uint32_t bytes_per_pixel = sizeof(uint32_t); > + uint32_t *prim_fb_ptr, *stripe_ptr; > + int stripe_size; > + > + if (bytes_per_pixel != sizeof(uint32_t)) { > + printf("Bad bytes_per_pixel for primary surface: %d\n", > + bytes_per_pixel); > + return -EINVAL; > + } > + > + if (tiled) { > + int v; > + > + /* Round the tiling up to the next power-of-two and the > + * region up to the next pot fence size so that this works > + * on all generations. > + * > + * This can still fail if the framebuffer is too large to > + * be tiled. But then that failure is expected. > + */ > + > + v = prim_width * bytes_per_pixel; > + for (*prim_stride = 512; *prim_stride < v; *prim_stride *= 2) > + ; > + > + v = *prim_stride * prim_height; > + for (*prim_size = 1024*1024; *prim_size < v; *prim_size *= 2) > + ; > + } else { > + /* Scan-out has a 64 byte alignment restriction */ > + *prim_stride = (prim_width * bytes_per_pixel + 63) & ~63; > + *prim_size = *prim_stride * prim_height; > + } > + > + *prim_handle = gem_create(fd, *prim_size); > + > + if (tiled) > + gem_set_tiling(fd, *prim_handle, I915_TILING_X, *prim_stride); > + > + prim_fb_ptr = gem_mmap(fd, *prim_handle, *prim_size, PROT_READ | > PROT_WRITE); > + > + if (prim_fb_ptr != NULL) { > + // Write primary surface with stripe of shades from black to > white > + > + stripe_ptr = prim_fb_ptr; > + stripe_size = *prim_size / 4; > + for (int i = 0; i < 4; i++) > + { > + memset(stripe_ptr, i*0x32, stripe_size); //Setting > shades for stripes > + stripe_ptr+=(stripe_size/4); > + } > + munmap(prim_fb_ptr, *prim_size); > + } > + return 0; > +} > + > +static void fill_sprite(int sprite_width, int sprite_height, int > sprite_stride, > + void *sprite_fb_ptr) > +{ > + __u32 *pLinePat0, > + *pLinePat1, > + *pLinePtr; > + int i, > + line; > + int stripe_width; > + > + stripe_width = sprite_height/2; > + > + // Note: sprite_stride is in bytes. pLinePat0 and pLinePat1 > + // are both __u32 pointers > + pLinePat0 = sprite_fb_ptr; > + pLinePat1 = pLinePat0 + (stripe_width * (sprite_stride / > sizeof(*pLinePat0))); > + > + for (i = 0; i < sprite_width; i++) { > + *(pLinePat0 + i) = 0xff; //Blue Stripe > + *(pLinePat1 + i) = 0xff0000; //Red Stripe > + } > + > + for (line = 1; line < sprite_height; line++) { > + if (line == stripe_width) { > + continue; > + } > + > + pLinePtr = ((line / stripe_width) & 0x1) ? pLinePat1 : > pLinePat0; > + memcpy( pLinePat0 + ((sprite_stride / sizeof(*pLinePat0)) * > line), > + pLinePtr, > + sprite_width * sizeof(*pLinePat0)); > + } > + > + return; > +} > + > +static int prepare_sprite_surfaces(int fd, int sprite_width, int > sprite_height, > + uint32_t *sprite_handle, uint32_t > *sprite_stride, uint32_t *sprite_size, > + int tiled) > +{ > + uint32_t bytes_per_pixel = sizeof(uint32_t); > + uint32_t *sprite_fb_ptr; > + > + if (bytes_per_pixel != sizeof(uint32_t)) { > + printf("Bad bytes_per_pixel for sprite: %d\n", bytes_per_pixel); > + return -EINVAL; > + } > + > + if (tiled) { > + int v; > + > + /* Round the tiling up to the next power-of-two and the > + * region up to the next pot fence size so that this works > + * on all generations. > + * > + * This can still fail if the framebuffer is too large to > + * be tiled. But then that failure is expected. > + */ > + > + v = sprite_width * bytes_per_pixel; > + for (*sprite_stride = 512; *sprite_stride < v; *sprite_stride > *= 2) > + ; > + > + v = *sprite_stride * sprite_height; > + for (*sprite_size = 1024*1024; *sprite_size < v; *sprite_size > *= 2) > + ; > + } else { > + /* Scan-out has a 64 byte alignment restriction */ > + *sprite_stride = (sprite_width * bytes_per_pixel + 63) & ~63; > + *sprite_size = *sprite_stride * sprite_height; > + } > + > + // Create the sprite surface > + *sprite_handle = gem_create(fd, *sprite_size); > + > + if (tiled) > + gem_set_tiling(fd, *sprite_handle, I915_TILING_X, > *sprite_stride); > + > + // Get pointer to the surface > + sprite_fb_ptr = gem_mmap(fd, > + *sprite_handle, *sprite_size, > + PROT_READ | PROT_WRITE); > + > + if (sprite_fb_ptr != NULL) { > + // Fill with stripes of colors > + fill_sprite(sprite_width, sprite_height, *sprite_stride, > sprite_fb_ptr); > + > + munmap(sprite_fb_ptr, *sprite_size); > + } else { > + gem_close(fd, *sprite_handle); > + printf("\nFailed to mmap gem object for sprite"); > + } > + > + return 0; > +} > + > +void set_plane_rotation(int drm_fd, bool sprite, uint32_t plane_id, uint64_t > rotation) > +{ > + int i = 0, j = 0, ret = 0; > + drmModeObjectPropertiesPtr props = NULL; > + > + props = drmModeObjectGetProperties(drm_fd, plane_id, > + sprite ? DRM_MODE_OBJECT_PLANE : > DRM_MODE_OBJECT_CRTC); > + printf("\nPlane id: 0x%x, Count_props=%d ", plane_id, > props->count_props); > + > + for (i = 0; i < props->count_props; i++) > + { > + drmModePropertyPtr prop = drmModeGetProperty(drm_fd, > props->props[i]); > + printf("\nProp->name=%s ", prop->name); > + > + if (strcmp(prop->name, "rotation") == 0) > + { > + igt_assert(prop->flags & DRM_MODE_PROP_BITMASK); > + printf("\nRotation property enum count %d", > prop->count_enums); > + printf("\nRotation type\tValue"); > + for (j = 0; j < prop->count_enums; j++) > + printf("\n%s: 0x%x", prop->enums[j].name, > prop->enums[j].value); > + > + ret = drmModeObjectSetProperty(drm_fd, plane_id, sprite > ? DRM_MODE_OBJECT_PLANE : DRM_MODE_OBJECT_CRTC, > + > (uint32_t)prop->prop_id, rotation); > + if (ret) > + { > + printf("\nRotation setting\(0x%x\) failed !!!", > rotation); > + printf("\nMappings: Bit-0:0, Bit-1:90, > Bit-2:180, Bit-3:270, Bit-4:X-Reflection, Bit-5:Y-Reflection\n"); > + return; > + } > + else > + printf("\nPlane with id 0x%x is rotated with > setting 0x%x", plane_id, rotation); > + } > + drmModeFreeProperty(prop); > + } > + drmModeFreeObjectProperties(props); > +} > + > +static void rotate(int tiled, int sprite_w, int sprite_h, > + int out_w, int out_h, int dump_info) > +{ > + int ret; > + int gfx_fd; > + int keep_moving; > + uint32_t sprite_handle; > + uint32_t sprite_fb_id; > + int sprite_x; > + int sprite_y; > + uint32_t sprite_stride; > + uint32_t sprite_size; > + uint32_t handles[4], > + pitches[4], > + offsets[4]; /* we only use [0] */ > + uint32_t prim_width, > + prim_height, > + prim_handle, > + prim_stride, > + prim_size, > + prim_fb_id; > + struct drm_intel_sprite_colorkey set; > + struct connector curr_connector; > + drmModeRes *gfx_resources; > + struct termios orig_term, > + curr_term; > + int c_index; > + unsigned int sprite_plane_id; > + uint32_t plane_flags = 0; > + char key; > + bool rotate_crtc = false; > + bool rotate_sprite = false; > + uint64_t rotation_crtc = BIT(DRM_ROTATE_0), > + rotation_sprite = BIT(DRM_ROTATE_0); > + > + // Open up I915 graphics device > + gfx_fd = drmOpen("i915", "pci:0000:00:02.0"); > + if (gfx_fd < 0) { > + printf("Failed to load i915 driver: %s\n", strerror(errno)); > + return; > + } > + > + // Obtain pointer to struct containing graphics resources > + gfx_resources = drmModeGetResources(gfx_fd); > + if (!gfx_resources) { > + printf("drmModeGetResources failed: %s\n", strerror(errno)); > + return; > + } > + > + if (dump_info != 0) { > + dump_connectors(gfx_fd, gfx_resources); > + dump_crtcs(gfx_fd, gfx_resources); > + dump_planes(gfx_fd, gfx_resources); > + } > + > + // Save previous terminal settings > + if (tcgetattr( 0, &orig_term) != 0) { > + printf("tcgetattr failure: %s\n", > + strerror(errno)); > + return; > + } > + > + // Set up input to return characters immediately > + curr_term = orig_term; > + curr_term.c_lflag &= ~(ICANON | ECHO | ECHONL); > + curr_term.c_cc[VMIN] = 0; // No minimum number of characters > + curr_term.c_cc[VTIME] = 0 ; // Return immediately, even if > + // nothing has been entered. > + if (tcsetattr( 0, TCSANOW, &curr_term) != 0) { > + printf("tcgetattr failure: %s\n", strerror(errno)); > + return; > + } > + > + // Cycle through all connectors and display the flying sprite > + // where there are displays attached and the hardware will support it. > + for (c_index = 0; c_index < gfx_resources->count_connectors; c_index++) > { > + curr_connector.id = gfx_resources->connectors[c_index]; > + > + // Find the native (preferred) display mode > + connector_find_preferred_mode(gfx_fd, gfx_resources, > &curr_connector); > + if (curr_connector.mode_valid == 0) { > + printf("No valid preferred mode detected\n"); > + goto out; > + } > + > + // Determine if sprite hardware is available on pipe > + // associated with this connector. > + sprite_plane_id = connector_find_plane(gfx_fd, &curr_connector); > + if (!sprite_plane_id) { > + printf("Failed to find sprite plane on crtc\n"); > + goto out; > + } > + > + // Width and height of preferred mode > + prim_width = curr_connector.mode.hdisplay; > + prim_height = curr_connector.mode.vdisplay; > + > + // Allocate and fill memory for primary surface > + ret = prepare_primary_surface( > + gfx_fd, > + prim_width, > + prim_height, > + &prim_handle, > + &prim_stride, > + &prim_size, > + tiled); > + if (ret != 0) { > + printf("Failed to add primary fb (%dx%d): %s\n", > + prim_width, prim_height, strerror(errno)); > + goto out; > + } > + > + // Add the primary surface framebuffer > + ret = drmModeAddFB(gfx_fd, prim_width, prim_height, 24, 32, > + prim_stride, prim_handle, &prim_fb_id); > + gem_close(gfx_fd, prim_handle); > + > + if (ret != 0) { > + printf("Failed to add primary fb (%dx%d): %s\n", > + prim_width, prim_height, > strerror(errno)); > + goto out; > + } > + > + // Allocate and fill sprite surfaces > + ret = prepare_sprite_surfaces(gfx_fd, sprite_w, sprite_h, > &sprite_handle, > + &sprite_stride, &sprite_size, > + tiled); > + if (ret != 0) { > + printf("Preparation of sprite surfaces failed %dx%d\n", > + sprite_w, sprite_h); > + goto out; > + } > + > + // Add the sprite framebuffers > + handles[0] = sprite_handle; > + handles[1] = handles[0]; > + handles[2] = handles[0]; > + handles[3] = handles[0]; > + pitches[0] = sprite_stride; > + pitches[1] = sprite_stride; > + pitches[2] = sprite_stride; > + pitches[3] = sprite_stride; > + memset(offsets, 0, sizeof(offsets)); > + > + ret = drmModeAddFB2(gfx_fd, sprite_w, sprite_h, > + DRM_FORMAT_XRGB8888, > + handles, pitches, offsets, > + &sprite_fb_id, plane_flags); > + gem_close(gfx_fd, sprite_handle); > + > + if (ret) { > + printf("Failed to add sprite fb (%dx%d): %s\n", > + sprite_w, sprite_h, strerror(errno)); > + > + drmModeRmFB(gfx_fd, sprite_fb_id); > + goto out; > + } > + > + if (dump_info != 0) { > + printf("Displayed Mode Connector struct:\n" > + " .id = %d\n" > + " .mode_valid = %d\n" > + " .crtc = %d\n" > + " .pipe = %d\n" > + " drmModeModeInfo ...\n" > + " .name = %s\n" > + " .type = %d\n" > + " .flags = %08x\n" > + " drmModeEncoder ...\n" > + " .encoder_id = %d\n" > + " .encoder_type = %d (%s)\n" > + " .crtc_id = %d\n" > + " .possible_crtcs = %d\n" > + " .possible_clones = %d\n" > + " drmModeConnector ...\n" > + " .connector_id = %d\n" > + " .encoder_id = %d\n" > + " .connector_type = %d (%s)\n" > + " .connector_type_id = %d\n\n", > + curr_connector.id, > + curr_connector.mode_valid, > + curr_connector.crtc, > + curr_connector.pipe, > + curr_connector.mode.name, > + curr_connector.mode.type, > + curr_connector.mode.flags, > + curr_connector.encoder->encoder_id, > + curr_connector.encoder->encoder_type, > + > kmstest_encoder_type_str(curr_connector.encoder->encoder_type), > + curr_connector.encoder->crtc_id, > + curr_connector.encoder->possible_crtcs, > + curr_connector.encoder->possible_clones, > + curr_connector.connector->connector_id, > + curr_connector.connector->encoder_id, > + curr_connector.connector->connector_type, > + > kmstest_connector_type_str(curr_connector.connector->connector_type), > + curr_connector.connector->connector_type_id); > + > + printf("Sprite surface dimensions = %dx%d\n" > + "Sprite output dimensions = %dx%d\n" > + "Press any key to continue >\n", > + sprite_w, sprite_h, out_w, out_h); > + > + // Wait for a key-press > + while( read(0, &key, 1) == 0); > + // Purge unread characters > + tcflush(0, TCIFLUSH); > + } > + > + // Set up the primary display mode > + ret = drmModeSetCrtc(gfx_fd, curr_connector.crtc, prim_fb_id, > + 0, 0, &curr_connector.id, 1, > &curr_connector.mode); > + if (ret != 0) { > + printf("Failed to set mode (%dx%d@%dHz): %s\n", > + prim_width, prim_height, > curr_connector.mode.vrefresh, > + strerror(errno)); > + continue; > + } > + > + // Set the sprite colorkey state > + set.plane_id = sprite_plane_id; > + set.min_value = 0; > + set.max_value = 0; > + set.flags = I915_SET_COLORKEY_NONE; > + ret = drmCommandWrite(gfx_fd, DRM_I915_SET_SPRITE_COLORKEY, > &set, sizeof(set)); > + assert(ret == 0); > + > + // Set up sprite output dimensions, initial position, etc. > + if (out_w > prim_width / 2) > + out_w = prim_width / 2; > + if (out_h > prim_height / 2) > + out_h = prim_height / 2; > + > + sprite_x = (prim_width / 2) - (out_w / 2); > + sprite_y = (prim_height / 2) - (out_h / 2); > + > + keep_moving = 1; > + > + // Bounce sprite off the walls > + while (keep_moving) { > + > + // Move the sprite on the screen and flip > + // the surface if the index has changed > + // NB: sprite_w and sprite_h must be 16.16 fixed point, > herego << 16 > + if (drmModeSetPlane(gfx_fd, sprite_plane_id, > curr_connector.crtc, > + sprite_fb_id, plane_flags, > + sprite_x, sprite_y, > + out_w, out_h, > + 0, 0, > + sprite_w << 16, sprite_h << 16)) > + printf("Failed to enable sprite plane: %s\n", > strerror(errno)); > + > + if (rotate_crtc) > + set_plane_rotation(gfx_fd, false, > curr_connector.crtc, rotation_crtc); > + if (rotate_sprite) > + set_plane_rotation(gfx_fd, true, > sprite_plane_id, rotation_sprite); > + > + // Fetch a key from input (non-blocking) > + if (read(0, &key, 1) == 1) { > + switch (key) { > + case 'q': // Kill the program > + case 'Q': > + goto out; > + break; > + case '0': > + rotation_crtc = BIT(DRM_ROTATE_0); > + rotation_sprite = rotation_crtc; > + break; > + case '1': > + rotation_crtc = BIT(DRM_ROTATE_90); > + rotation_sprite = rotation_crtc; > + break; > + case '2': > + rotation_crtc = BIT(DRM_ROTATE_180); > + rotation_sprite = rotation_crtc; > + break; > + case '3': > + rotation_crtc = BIT(DRM_ROTATE_270); > + rotation_sprite = rotation_crtc; > + break; > + case '4': > + rotation_crtc = BIT(DRM_REFLECT_X); > + rotation_sprite = rotation_crtc; > + break; > + case '5': > + rotation_crtc = BIT(DRM_REFLECT_Y); > + rotation_sprite = rotation_crtc; > + break; > + case 'c': > + rotate_crtc = true; > + rotation_crtc = BIT(DRM_ROTATE_0); > + break; > + case 'C': > + rotate_crtc = false; > + break; > + case 's': > + rotate_sprite = true; > + rotation_sprite = BIT(DRM_ROTATE_0); > + break; > + case 'S': > + rotate_sprite = false; > + break; > + case 'n': // Next connector > + case 'N': > + keep_moving = 0; > + break; > + default: > + break; > + } > + > + // Purge unread characters > + tcflush(0, TCIFLUSH); > + } > + > + usleep(500000); > + } > + } > + > +out: > + // Purge unread characters > + tcflush(0, TCIFLUSH); > + // Restore previous terminal settings > + if (tcsetattr( 0, TCSANOW, &orig_term) != 0) { > + printf("tcgetattr failure: %s\n", strerror(errno)); > + return; > + } > + > + drmModeFreeResources(gfx_resources); > +} > + > +static void usage(char *name) > +{ > + printf("usage: %s -s <plane width>x<plane height> [-dhto]\n" > + "\t-d\t[optional] dump mode information\n" > + "\t-h\t[optional] output help message\n" > + "\t-t\t[optional] enable tiling\n" > + "\t-o\t[optional] <output rect width>x<output rect height>\n\n" > + "Keyboard control for sprite and crtc rotation ...\n" > + "\t'q' or 'Q' - Quit the program\n" > + "\t'n' or 'N' - Switch to next display\n" > + "\t'c' - Enable/Disable Crtc Rotation\n" > + "\t's' - Enable/Disable Sprite Rotation\n" > + "\t'0' - 0 degree Rotation\n" > + "\t'1' - 90 degree Rotation\n" > + "\t'2' - 180 degree Rotation\n" > + "\t'3' - 270 degree Rotation\n" > + "\t'4' - X Reflection\n" > + "\t'5' - Y Reflection\n", > + name); > +} > + > +int main(int argc, char **argv) > +{ > + int c; > + int test_overlay = 0, > + enable_tiling = 0, > + dump_info = 0; > + int plane_width = 0, > + plane_height = 0, > + out_width = 0, > + out_height = 0; > + static char optstr[] = "ds:o:th"; > + > + opterr = 0; > + while ((c = getopt(argc, argv, optstr)) != -1) { > + switch (c) { > + case 'd': // Dump information > + dump_info = 1; > + break; > + case 't': // Tiling enable > + enable_tiling = 1; > + break; > + case 's': // Surface dimensions > + if (sscanf(optarg, "%dx%d", &plane_width, > &plane_height) != 2) > + usage(argv[0]); > + test_overlay = 1; > + break; > + case 'o': // Output dimensions > + if (sscanf(optarg, "%dx%d", &out_width, &out_height) != > 2) > + usage(argv[0]); > + break; > + default: > + printf("unknown option %c\n", c); > + /* fall through */ > + case 'h': // Help! > + usage(argv[0]); > + goto out; > + } > + } > + > + if (test_overlay) { > + if (out_width < (plane_width / 2)) > + out_width = plane_width; > + > + if (out_height < (plane_height / 2)) > + out_height = plane_height; > + > + rotate(enable_tiling, plane_width, plane_height, out_width, > out_height, dump_info); > + } else { > + printf("Sprite dimensions are required:\n"); > + usage(argv[0]); > + } > + > +out: > + exit(0); > +} > -- > 1.8.5 > > _______________________________________________ > Intel-gfx mailing list > [email protected] > http://lists.freedesktop.org/mailman/listinfo/intel-gfx -- Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
