IABSD.fr/xenocara/lib/libdrm/tests/modetest/cursor.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : jsg
  Date : 2018-09-13 11:55:15
  Hash : a81d3f52
  Message : Import libdrm 2.4.94

• lib/libdrm/tests/modetest/cursor.c

• /*
   * DRM based mode setting test program
   * Copyright (C) 2013 Red Hat
   * Author: Rob Clark <robdclark@gmail.com>
   *
   * 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 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 <assert.h>
  #include <errno.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <stdint.h>
  #include <string.h>
  #include <signal.h>
  #include <sys/time.h>
  #include <pthread.h>
  #include <unistd.h>
  
  #include "xf86drm.h"
  #include "xf86drmMode.h"
  
  #include "util/common.h"
  
  #include "buffers.h"
  #include "cursor.h"
  
  struct cursor {
  	int fd;
  	uint32_t bo_handle;
  	uint32_t crtc_id;
  	uint32_t crtc_w, crtc_h;
  	uint32_t w, h;
  
  	/* current state */
  	uint32_t enabled, x, y;
  	int32_t dx, dy;
  };
  
  #define MAX_CURSORS 8
  static struct cursor cursors[MAX_CURSORS];
  static int ncursors;
  
  static pthread_t cursor_thread;
  static int cursor_running;
  
  /*
   * Timer driven program loops through these steps to move/enable/disable
   * the cursor
   */
  
  struct cursor_step {
  	void (*run)(struct cursor *cursor, const struct cursor_step *step);
  	uint32_t msec;
  	uint32_t repeat;
  	int arg;
  };
  
  static uint32_t indx, count;
  
  static void set_cursor(struct cursor *cursor, const struct cursor_step *step)
  {
  	int enabled = (step->arg ^ count) & 0x1;
  	uint32_t handle = 0;
  
  	if (enabled)
  		handle = cursor->bo_handle;
  
  	cursor->enabled = enabled;
  
  	drmModeSetCursor(cursor->fd, cursor->crtc_id, handle, cursor->w, cursor->h);
  }
  
  static void move_cursor(struct cursor *cursor, const struct cursor_step *step)
  {
  	int x = cursor->x;
  	int y = cursor->y;
  
  	if (!cursor->enabled)
  		drmModeSetCursor(cursor->fd, cursor->crtc_id,
  				cursor->bo_handle, cursor->w, cursor->h);
  
  	/* calculate new cursor position: */
  	x += cursor->dx * step->arg;
  	y += cursor->dy * step->arg;
  
  	if (x < 0) {
  		x = 0;
  		cursor->dx = 1;
  	} else if (x > (int)cursor->crtc_w) {
  		x = cursor->crtc_w - 1;
  		cursor->dx = -1;
  	}
  
  	if (y < 0) {
  		y = 0;
  		cursor->dy = 1;
  	} else if (y > (int)cursor->crtc_h) {
  		y = cursor->crtc_h - 1;
  		cursor->dy = -1;
  	}
  
  	cursor->x = x;
  	cursor->y = y;
  
  	drmModeMoveCursor(cursor->fd, cursor->crtc_id, x, y);
  }
  
  static const struct cursor_step steps[] = {
  		{  set_cursor, 10,   0,  1 },  /* enable */
  		{ move_cursor,  1, 100,  1 },
  		{ move_cursor,  1,  10, 10 },
  		{  set_cursor,  1, 100,  0 },  /* disable/enable loop */
  		{ move_cursor,  1,  10, 10 },
  		{ move_cursor,  9, 100,  1 },
  		{ move_cursor, 11, 100,  5 },
  		{  set_cursor, 17,  10,  0 },  /* disable/enable loop */
  		{ move_cursor,  9, 100,  1 },
  		{  set_cursor, 13,  10,  0 },  /* disable/enable loop */
  		{ move_cursor,  9, 100,  1 },
  		{  set_cursor, 13,  10,  0 },  /* disable/enable loop */
  		{  set_cursor, 10,   0,  0 },  /* disable */
  };
  
  static void *cursor_thread_func(void *data)
  {
  	while (cursor_running) {
  		const struct cursor_step *step = &steps[indx % ARRAY_SIZE(steps)];
  		int i;
  
  		for (i = 0; i < ncursors; i++) {
  			struct cursor *cursor = &cursors[i];
  			step->run(cursor, step);
  		}
  
  		/* iterate to next count/step: */
  		if (count < step->repeat) {
  			count++;
  		} else {
  			count = 0;
  			indx++;
  		}
  
  		usleep(1000 * step->msec);
  	}
  
  	return NULL;
  }
  
  int cursor_init(int fd, uint32_t bo_handle, uint32_t crtc_id,
  		uint32_t crtc_w, uint32_t crtc_h, uint32_t w, uint32_t h)
  {
  	struct cursor *cursor = &cursors[ncursors];
  
  	assert(ncursors < MAX_CURSORS);
  
  	cursor->fd = fd;
  	cursor->bo_handle = bo_handle;
  	cursor->crtc_id = crtc_id;
  	cursor->crtc_w = crtc_w;
  	cursor->crtc_h = crtc_h;
  	cursor->w = w;
  	cursor->h = h;
  
  	cursor->enabled = 0;
  	cursor->x = w/2;
  	cursor->y = h/2;
  	cursor->dx = 1;
  	cursor->dy = 1;
  
  	ncursors++;
  
  	return 0;
  }
  
  int cursor_start(void)
  {
  	cursor_running = 1;
  	pthread_create(&cursor_thread, NULL, cursor_thread_func, NULL);
  	printf("starting cursor\n");
  	return 0;
  }
  
  int cursor_stop(void)
  {
  	cursor_running = 0;
  	pthread_join(cursor_thread, NULL);
  	printf("cursor stopped\n");
  	return 0;
  }