jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

xorg: added tests

Browse Source
This commit is contained in:
Jay Sorg 2012-02-11 11:44:13 -08:00
parent a19fa88e4e
commit a866b7b330
11 changed files with 2927 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
xorg/tests/client.sh Executable file
View File

@ -0,0 +1,13 @@
#!/bin/sh
xhost +
if ! [ -d .nx ]
then
mkdir .nx
fi
export LD_LIBRARY_PATH=$PWD
./nxproxy -S nx/nx,session=session,id=jay,root=.nx,connect=127.0.0.1:10,delta=1,stream=1,data=1

12
xorg/tests/server.sh Executable file
View File

@ -0,0 +1,12 @@
#!/bin/sh
export LD_LIBRARY_PATH=$PWD
#./nxagent -R -bs -dpi 96 -geometry 1024x768 -noshpix -display nx/nx,link=adsl,delta=1,stream=1,data=1,a8taint=0,cache=4M:9 :9
# with cache
#./nxagent -D -bs -ac -dpi 96 -geometry 1024x768 -noshpix -display nx/nx,link=adsl,delta=1,stream=1,data=1,cache=4M:9 :9
# without cache
./nxagent -D -bs -ac -dpi 96 -geometry 1024x768 -noshpix -display nx/nx,link=adsl,delta=1,stream=1,data=1,cache=0M:9 :9

80
xorg/tests/tcp_proxy/arch.h Normal file
View File

@ -0,0 +1,80 @@
/*
Copyright (c) 2004-2007 Jay Sorg
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.
*/
#if !defined(ARCH_H)
#define ARCH_H
/* check endianess */
#if defined(__sparc__) || defined(__PPC__) || defined(__ppc__)
#define B_ENDIAN
#elif __BYTE_ORDER == __LITTLE_ENDIAN
#define L_ENDIAN
#elif __BYTE_ORDER == __BIG_ENDIAN
#define B_ENDIAN
#endif
/* check if we need to align data */
#if defined(__sparc__) || defined(__alpha__) || defined(__hppa__) || \
defined(__AIX__) || defined(__PPC__) || defined(__mips__) || \
defined(__ia64__) || defined(__ppc__)
#define NEED_ALIGN
#endif
/* defines for thread creation factory functions */
#if defined(_WIN32)
#define THREAD_RV unsigned long
#define THREAD_CC __stdcall
#else
#define THREAD_RV void*
#define THREAD_CC
#endif
#if defined(__BORLANDC__) || defined(_WIN32)
#define APP_CC __fastcall
#define DEFAULT_CC __cdecl
#else
#define APP_CC
#define DEFAULT_CC
#endif
#if defined(_WIN32)
#if defined(__BORLANDC__)
#define EXPORT_CC _export __cdecl
#else
#define EXPORT_CC
#endif
#else
#define EXPORT_CC
#endif
typedef char ti8;
typedef unsigned char tui8;
typedef signed char tsi8;
typedef short ti16;
typedef unsigned short tui16;
typedef signed short tsi16;
typedef int ti32;
typedef unsigned int tui32;
typedef signed int tsi32;
typedef long tbus;
#endif

265
xorg/tests/tcp_proxy/main.c Normal file
View File

@ -0,0 +1,265 @@
#include "os_calls.h"
int g_loc_io_count = 0; // bytes read from local port
int g_rem_io_count = 0; // bytes read from remote port
static int g_terminated = 0;
static char g_buf[1024 * 32];
/*****************************************************************************/
static int
main_loop(char* local_port, char* remote_ip, char* remote_port, int hexdump)
{
int lis_sck;
int acc_sck;
int con_sck;
int sel;
int count;
int sent;
int error;
int i;
int acc_to_con;
int con_to_acc;
acc_to_con = 0;
con_to_acc = 0;
acc_sck = 0;
/* create the listening socket and setup options */
lis_sck = g_tcp_socket();
g_tcp_set_non_blocking(lis_sck);
error = g_tcp_bind(lis_sck, local_port);
if (error != 0)
{
g_writeln("bind failed");
}
/* listen for an incomming connection */
if (error == 0)
{
error = g_tcp_listen(lis_sck);
if (error == 0)
{
g_writeln("listening for connection");
}
}
/* accept an incomming connection */
if (error == 0)
{
while ((!g_terminated) && (error == 0))
{
acc_sck = g_tcp_accept(lis_sck);
if ((acc_sck == -1) && g_tcp_last_error_would_block(lis_sck))
{
g_sleep(100);
}
else if (acc_sck == -1)
{
error = 1;
}
else
{
break;
}
}
if (error == 0)
{
error = g_terminated;
}
/* stop listening */
g_tcp_close(lis_sck);
lis_sck = 0;
if (error == 0)
{
g_writeln("got connection");
}
}
/* connect outgoing socket */
con_sck = 0;
if (error == 0)
{
con_sck = g_tcp_socket();
g_tcp_set_non_blocking(con_sck);
error = g_tcp_connect(con_sck, remote_ip, remote_port);
if ((error == -1) && g_tcp_last_error_would_block(con_sck))
{
error = 0;
i = 0;
while ((!g_tcp_can_send(con_sck, 100)) && (!g_terminated) && (i < 100))
{
g_sleep(100);
i++;
}
if (i > 99)
{
g_writeln("timout connecting");
error = 1;
}
if (g_terminated)
{
error = 1;
}
}
if ((error != 0) && (!g_terminated))
{
g_writeln("error connecting to remote\r\n");
}
}
while ((!g_terminated) && (error == 0))
{
sel = g_tcp_select(con_sck, acc_sck);
if (sel == 0)
{
g_sleep(10);
continue;
}
if (sel & 1)
{
// can read from con_sck w/o blocking
count = g_tcp_recv(con_sck, g_buf, 1024 * 16, 0);
error = count < 1;
if (error == 0)
{
g_loc_io_count += count;
con_to_acc += count;
if (hexdump)
{
g_writeln("from remove, the socket from connect");
g_hexdump(g_buf, count);
}
#if 0
g_writeln("local_io_count: %d\tremote_io_count: %d",
g_loc_io_count, g_rem_io_count);
#endif
sent = 0;
while ((sent < count) && (error == 0) && (!g_terminated))
{
i = g_tcp_send(acc_sck, g_buf + sent, count - sent, 0);
if ((i == -1) && g_tcp_last_error_would_block(acc_sck))
{
g_tcp_can_send(acc_sck, 1000);
}
else if (i < 1)
{
error = 1;
}
else
{
sent += i;
}
}
}
}
if (sel & 2)
{
// can read from acc_sck w/o blocking
count = g_tcp_recv(acc_sck, g_buf, 1024 * 16, 0);
error = count < 1;
if (error == 0)
{
g_rem_io_count += count;
acc_to_con += count;
if (hexdump)
{
g_writeln("from accepted, the socket from accept");
g_hexdump(g_buf, count);
}
#if 0
g_writeln("local_io_count: %d\tremote_io_count: %d",
g_loc_io_count, g_rem_io_count);
#endif
sent = 0;
while ((sent < count) && (error == 0) && (!g_terminated))
{
i = g_tcp_send(con_sck, g_buf + sent, count - sent, 0);
if ((i == -1) && g_tcp_last_error_would_block(con_sck))
{
g_tcp_can_send(con_sck, 1000);
}
else if (i < 1)
{
error = 1;
}
else
{
sent += i;
}
}
}
}
}
g_tcp_close(lis_sck);
g_tcp_close(con_sck);
g_tcp_close(acc_sck);
g_writeln("acc_to_con %d", acc_to_con);
g_writeln("con_to_acc %d", con_to_acc);
return 0;
}
/*****************************************************************************/
static int
usage(void)
{
g_writeln("tcp_proxy <local-port> <remote-ip> <remote-port> [dump]");
return 0;
}
/*****************************************************************************/
void
proxy_shutdown(int sig)
{
g_writeln("shutting down");
g_terminated = 1;
}
void
clear_counters(int sig)
{
g_writeln("cleared counters at: local_io_count: %d remote_io_count: %d",
g_loc_io_count, g_rem_io_count);
g_loc_io_count = 0;
g_rem_io_count = 0;
}
/*****************************************************************************/
int
main(int argc, char** argv)
{
int dump;
if (argc < 4)
{
usage();
return 0;
}
g_init();
g_signal(2, proxy_shutdown); /* SIGINT */
g_signal(9, proxy_shutdown); /* SIGKILL */
g_signal(10, clear_counters);/* SIGUSR1*/
g_signal(15, proxy_shutdown);/* SIGTERM */
if (argc < 5)
{
while (!g_terminated)
{
g_loc_io_count = 0;
g_rem_io_count = 0;
main_loop(argv[1], argv[2], argv[3], 0);
}
}
else
{
dump = g_strcasecmp(argv[4], "dump") == 0;
while (!g_terminated)
{
main_loop(argv[1], argv[2], argv[3], dump);
}
}
g_deinit();
return 0;
}

1449
xorg/tests/tcp_proxy/os_calls.c Normal file
View File

File diff suppressed because it is too large Load Diff

208
xorg/tests/tcp_proxy/os_calls.h Normal file
View File

@ -0,0 +1,208 @@
/*
Copyright (c) 2004-2007 Jay Sorg
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.
generic operating system calls
*/
#if !defined(OS_CALLS_H)
#define OS_CALLS_H
#include "arch.h"
void APP_CC
g_init(void);
void APP_CC
g_deinit(void);
void* APP_CC
g_malloc(int size, int zero);
void APP_CC
g_free(void* ptr);
void DEFAULT_CC
g_printf(const char *format, ...);
void DEFAULT_CC
g_sprintf(char* dest, const char* format, ...);
void DEFAULT_CC
g_snprintf(char* dest, int len, const char* format, ...);
void DEFAULT_CC
g_writeln(const char* format, ...);
void DEFAULT_CC
g_write(const char* format, ...);
void APP_CC
g_hexdump(char* p, int len);
void APP_CC
g_memset(void* ptr, int val, int size);
void APP_CC
g_memcpy(void* d_ptr, const void* s_ptr, int size);
int APP_CC
g_getchar(void);
int APP_CC
g_tcp_set_no_delay(int sck);
int APP_CC
g_tcp_socket(void);
int APP_CC
g_tcp_local_socket(void);
void APP_CC
g_tcp_close(int sck);
int APP_CC
g_tcp_connect(int sck, const char* address, const char* port);
int APP_CC
g_tcp_force_send(int sck, char* data, int len);
int APP_CC
g_tcp_force_recv(int sck, char* data, int len);
int APP_CC
g_tcp_set_non_blocking(int sck);
int APP_CC
g_tcp_bind(int sck, char* port);
int APP_CC
g_tcp_local_bind(int sck, char* port);
int APP_CC
g_tcp_listen(int sck);
int APP_CC
g_tcp_accept(int sck);
int APP_CC
g_tcp_recv(int sck, void* ptr, int len, int flags);
int APP_CC
g_tcp_send(int sck, const void* ptr, int len, int flags);
int APP_CC
g_tcp_last_error_would_block(int sck);
int APP_CC
g_tcp_can_send(int sck, int millis);
int APP_CC
g_tcp_can_recv(int sck, int millis);
int APP_CC
g_tcp_select(int sck1, int sck2);
void APP_CC
g_sleep(int msecs);
void APP_CC
g_random(char* data, int len);
int APP_CC
g_abs(int i);
int APP_CC
g_memcmp(const void* s1, const void* s2, int len);
int APP_CC
g_file_open(const char* file_name);
int APP_CC
g_file_close(int fd);
int APP_CC
g_file_read(int fd, char* ptr, int len);
int APP_CC
g_file_write(int fd, char* ptr, int len);
int APP_CC
g_file_seek(int fd, int offset);
int APP_CC
g_file_lock(int fd, int start, int len);
int APP_CC
g_set_file_rights(const char* filename, int read, int write);
int APP_CC
g_chmod_hex(const char* filename, int flags);
int APP_CC
g_mkdir(const char* dirname);
char* APP_CC
g_get_current_dir(char* dirname, int maxlen);
int APP_CC
g_set_current_dir(char* dirname);
int APP_CC
g_file_exist(const char* filename);
int APP_CC
g_directory_exist(const char* dirname);
int APP_CC
g_create_dir(const char* dirname);
int APP_CC
g_remove_dir(const char* dirname);
int APP_CC
g_file_delete(const char* filename);
int APP_CC
g_strlen(const char* text);
char* APP_CC
g_strcpy(char* dest, const char* src);
char* APP_CC
g_strncpy(char* dest, const char* src, int len);
char* APP_CC
g_strcat(char* dest, const char* src);
char* APP_CC
g_strdup(const char* in);
int APP_CC
g_strcmp(const char* c1, const char* c2);
int APP_CC
g_strncmp(const char* c1, const char* c2, int len);
int APP_CC
g_strcasecmp(const char* c1, const char* c2);
int APP_CC
g_strncasecmp(const char* c1, const char* c2, int len);
int APP_CC
g_atoi(char* str);
int APP_CC
g_pos(char* str, const char* to_find);
long APP_CC
g_load_library(char* in);
int APP_CC
g_free_library(long lib);
void* APP_CC
g_get_proc_address(long lib, const char* name);
int APP_CC
g_system(char* aexec);
char* APP_CC
g_get_strerror(void);
int APP_CC
g_execvp(const char* p1, char* args[]);
int APP_CC
g_execlp3(const char* a1, const char* a2, const char* a3);
void APP_CC
g_signal(int sig_num, void (*func)(int));
void APP_CC
g_signal_child_stop(void (*func)(int));
void APP_CC
g_unset_signals(void);
int APP_CC
g_fork(void);
int APP_CC
g_setgid(int pid);
int APP_CC
g_initgroups(const char* user, int gid);
int APP_CC
g_setuid(int pid);
int APP_CC
g_waitchild(void);
int APP_CC
g_waitpid(int pid);
void APP_CC
g_clearenv(void);
int APP_CC
g_setenv(const char* name, const char* value, int rewrite);
char* APP_CC
g_getenv(const char* name);
int APP_CC
g_exit(int exit_code);
int APP_CC
g_getpid(void);
int APP_CC
g_sigterm(int pid);
int APP_CC
g_getuser_info(const char* username, int* gid, int* uid, char* shell,
char* dir, char* gecos);
int APP_CC
g_getgroup_info(const char* groupname, int* gid);
int APP_CC
g_check_user_in_group(const char* username, int gid, int* ok);
int APP_CC
g_time1(void);
#endif

3
xorg/tests/xdemo/README.txt Normal file
View File

@ -0,0 +1,3 @@
this is a project to develope a program to test xwindows

204
xorg/tests/xdemo/bmp_parser.c Normal file
View File

@ -0,0 +1,204 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include "common.h"
// multi byte values are stored in little endian
struct bmp_magic
{
char magic[2];
};
struct bmp_hdr
{
uint32_t size; // file size in bytes
uint16_t reserved1;
uint16_t reserved2;
uint32_t offset; // offset to image data, in bytes
};
struct dib_hdr
{
uint32_t hdr_size;
int32_t width;
int32_t height;
uint16_t nplanes;
uint16_t bpp;
uint32_t compress_type;
uint32_t image_size;
int32_t hres;
int32_t vres;
uint32_t ncolors;
uint32_t nimpcolors;
};
// forward declarations
int parse_bmp(char *filename, struct pic_info *pic_info);
int parse_bmp_24(struct bmp_hdr *bmp_hdr, struct dib_hdr *dib_hdr, int fd, struct pic_info *pic_info);
int parse_bmp(char *filename, struct pic_info *pic_info)
{
int got_magic;
int fd;
int rval;
struct bmp_magic magic;
struct bmp_hdr bmp_hdr;
struct dib_hdr dib_hdr;
if ((fd = open(filename, O_RDONLY)) < 0) {
printf("error opeing %s\n", filename);
return -1;
}
// read BMP magic...
if ((rval = read(fd, magic.magic, 2)) != 2) {
fprintf(stderr, "error reading BMP signature from file %s\n", filename);
return -1;
}
got_magic = 0;
// ...and confirm that this is indeed a BMP file
if ((magic.magic[0] == 'B') && (magic.magic[1] == 'M')) {
// BM – Windows 3.1x, 95, NT, ... etc
got_magic = 1;
}
else if ((magic.magic[0] == 'B') && (magic.magic[1] == 'A')) {
// BA – OS/2 struct Bitmap Array
got_magic = 1;
}
else if ((magic.magic[0] == 'C') && (magic.magic[1] == 'I')) {
// CI – OS/2 struct Color Icon
got_magic = 1;
}
else if ((magic.magic[0] == 'C') && (magic.magic[1] == 'P')) {
// CP – OS/2 const Color Pointer
got_magic = 1;
}
else if ((magic.magic[0] == 'I') && (magic.magic[1] == 'C')) {
// IC – OS/2 struct Icon
got_magic = 1;
}
else if ((magic.magic[0] == 'P') && (magic.magic[1] == 'T')) {
// PT – OS/2 Pointer
got_magic = 1;
}
if (!got_magic) {
fprintf(stderr, "%s is not a valid BMP file\n", filename);
return -1;
}
// read BMP header
if ((rval = read(fd, &bmp_hdr, sizeof(bmp_hdr))) < sizeof(bmp_hdr)) {
fprintf(stderr, "error BMP header from file %s\n", filename);
return -1;
}
// read DIB header
if ((rval = read(fd, &dib_hdr, sizeof(dib_hdr))) < sizeof(dib_hdr)) {
fprintf(stderr, "error reading DIB header from file %s\n", filename);
return -1;
}
#if 0
printf("header size: %d\n", dib_hdr.hdr_size);
printf("width: %d\n", dib_hdr.width);
printf("height: %d\n", dib_hdr.height);
printf("num planes: %d\n", dib_hdr.nplanes);
printf("bpp: %d\n", dib_hdr.bpp);
printf("comp type: %d\n", dib_hdr.compress_type);
printf("image size: %d\n", dib_hdr.image_size);
printf("hres: %d\n", dib_hdr.hres);
printf("vres: %d\n", dib_hdr.vres);
printf("ncolors: %d\n", dib_hdr.ncolors);
printf("nimpcolors: %d\n", dib_hdr.nimpcolors);
#endif
if (dib_hdr.compress_type) {
printf("TODO: compressed images not yet supported\n");
return -1;
}
pic_info->width = dib_hdr.width;
pic_info->height = dib_hdr.height;
if (dib_hdr.bpp == 24) {
rval = parse_bmp_24(&bmp_hdr, &dib_hdr, fd, pic_info);
}
close(fd);
return rval;
}
/**
* extract 24bit BMP data from image file
*
* @return 0 on success
* @return -1 on failure
*/
int parse_bmp_24(
struct bmp_hdr *bmp_hdr,
struct dib_hdr *dib_hdr,
int fd,
struct pic_info *pic_info
)
{
char *file_data;
char *ptr_file_data;
char *mem_data;
char *ptr_mem_data;
char *cptr;
int w = dib_hdr->width; // picture width
int h = dib_hdr->height; // picture height
int bpl; // bytes per line
int bytes;
int i;
int j;
// bytes per image line = width x bytes_per_pixel + padding
i = (w * 3) % 4;
j = (i == 0) ? 0 : 4 - i;
bpl = w * 3 + j;
// 24 bit depth, no alpha channel
file_data = (char *) malloc(h * bpl);
// point to first line in image data, which is stored in reverse order
ptr_file_data = (file_data + dib_hdr->image_size) - bpl;
// 24 bit depth, with alpha channel
mem_data = (char *) malloc(w * h * 4);
ptr_mem_data = mem_data;
pic_info->pixel_data = ptr_mem_data;
// seek to beginning of pixel data
lseek(fd, bmp_hdr->offset, SEEK_SET);
// read all pixel data
bytes = read(fd, file_data, dib_hdr->image_size);
// convert 24bit to 24 bit with alpha and store in reverse
for (i = 0; i < h; i ++)
{
cptr = ptr_file_data;
for (j = 0; j < w; j++)
{
*ptr_mem_data++ = *cptr++; // blue value
*ptr_mem_data++ = *cptr++; // green value
*ptr_mem_data++ = *cptr++; // red value
*ptr_mem_data++ = 0; // alpha channel
}
ptr_file_data -= bpl;
}
free(file_data);
return 0;
}

19
xorg/tests/xdemo/common.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef __XDEMO_H
#define __XDEMO_H
#define DEBUG
#ifdef DEBUG
#define dprint(x...) printf(x)
#else
#define dprint(x...)
#endif
struct pic_info
{
int width;
int height;
char *pixel_data;
};
#endif

674
xorg/tests/xdemo/xdemo.c Normal file
View File

@ -0,0 +1,674 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <signal.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "common.h"
// LK_TODO
// http://tronche.com/gui/x/xlib/GC/convenience-functions/fill-tile-and-stipple.html
// fill stipple
// drawfonts: XDrawString, XDrawImageString XDrawText XLoadFont XTextExtents
// http://www.ac3.edu.au/SGI_Developer/books/XLib_PG/sgi_html/apa.html
// http://www.ac3.edu.au/SGI_Developer/books/XLib_PG/sgi_html/index.html
// use jpg lib to convert bmp to jpg and vice versa
#define MAX_COLORS 5
#define SCROLL_JUMP 1 // scroll in increments of g_winHeight
#define SCROLL_SMOOTH1 2 // scroll using XPutImage + XCopyArea
#define SCROLL_SMOOTH2 3 // scroll using XPutImage only
int parse_bmp(char *filename, struct pic_info *);
int drawBMP(char *filename, int scroll_type);
int signal_tcp_proxy(char *proxy_app);
// globals
Display *g_disp;
Window g_win;
XColor g_colors[MAX_COLORS];
GC g_gc;
int g_winWidth;
int g_winHeight;
int g_delay_dur;
void start_timer(struct timeval *tv)
{
gettimeofday(tv, NULL);
}
uint32_t time_elapsed_ms(struct timeval tv)
{
struct timeval tv_now;
uint32_t dur;
gettimeofday(&tv_now, NULL);
dur = ((tv_now.tv_sec - tv.tv_sec) * 1000) + ((tv_now.tv_usec - tv.tv_usec) / 1000);
return dur;
}
uint32_t time_elapsed_us(struct timeval tv)
{
struct timeval tv_now;
uint32_t dur;
gettimeofday(&tv_now, NULL);
dur = ((tv_now.tv_sec - tv.tv_sec) * 1000000) + (tv_now.tv_usec - tv.tv_usec);
return dur;
}
int drawLines(int count)
{
int x1;
int y1;
int x2;
int y2;
int i;
int index;
if (count <= 0) {
return 0; // nothing to do
}
srandom(time(NULL));
XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);
for (i = 0, index = 0; i < count; i++)
{
x1 = random() % g_winWidth;
y1 = random() % g_winHeight;
x2 = random() % g_winWidth;
y2 = random() % g_winHeight;
XSetForeground(g_disp, g_gc, g_colors[index++].pixel);
if (index == MAX_COLORS) {
index = 0;
}
// from-to
XDrawLine(g_disp, g_win, g_gc, x1, y1, x2, y2);
XFlush(g_disp);
usleep(g_delay_dur);
}
return 0;
}
// LK_TODO support user defined w and h
int drawRectangles(int count)
{
int x1;
int y1;
int w;
int h;
int i;
int index;
if (count <= 0) {
return 0; // nothing to do
}
srandom(time(NULL));
XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);
for (i = 0, index = 0; i < count; i++)
{
x1 = random() % g_winWidth;
y1 = random() % g_winHeight;
w = 160;
h = 140;
XSetForeground(g_disp, g_gc, g_colors[index++].pixel);
if (index == MAX_COLORS) {
index = 0;
}
//XDrawRectangle(g_disp, g_win, g_gc, x1, y1, w, h);
XFillRectangle(g_disp, g_win, g_gc, x1, y1, w, h);
XFlush(g_disp);
usleep(g_delay_dur);
}
return 0;
}
int drawFont(int count, char *msg)
{
int x1;
int y1;
int i;
int index;
#ifdef CHANGE_FONT_SIZE
int w;
int h;
int actual_count;
char **font_list;
#endif
if (count <= 0) {
return 0; // nothing to do
}
srandom(time(NULL));
XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);
#ifdef CHANGE_FONT_SIZE
font_list = XListFonts(g_disp, "−*−courier−*−*−*−*−0−0−*−*−*−0−*−*", 2000, &actual_count);
if (!font_list) {
printf("actual_count=%d\n", actual_count);
for (i = 0; i < actual_count; i++)
{
printf("%s\n", font_list[i]);
}
XFreeFontNames(font_list);
}
else {
printf("XListFonts() reted NULL\n");
}
#endif
srandom(time(NULL));
for (i = 0, index = 0; i < count; i++)
{
x1 = random() % g_winWidth;
y1 = random() % g_winHeight;
XSetForeground(g_disp, g_gc, g_colors[index++].pixel);
if (index == MAX_COLORS) {
index = 0;
}
XDrawString(g_disp, g_win, g_gc, x1, y1, msg, strlen(msg));
XFlush(g_disp);
usleep(g_delay_dur);
}
return 0; // nothing to do
}
/**
* display a usage message
*/
void
usage()
{
printf("usage: xdemo [-l] [-r] [-s] [-f <string>] [-i <image file>] [-g <WxH>] [-c <count>] [-o <scroll type>] [-d <delay>] -z\n");
printf(" -l draw lines\n");
printf(" -r draw fill rectangles\n");
printf(" -s draw stipple rectangles\n");
printf(" -f <string> draw string using fonts\n");
printf(" -i <image file> draw image\n");
printf(" -g <WxH> geometry, default is 640x480\n");
printf(" -c <count> iteration count, default is 5000\n");
printf(" -d <delay> loop delay in micro seconds, default 1000\n");
printf(" -o <jump|smooth1|smooth2> define scrolling method\n");
printf(" -z <proxy_app> zero proxy counters for specified application\n\n");
}
int main(int argc, char **argv)
{
XEvent evt;
Colormap colormap;
struct timeval tv;
int screenNumber;
long eventMask;
unsigned long white;
unsigned long black;
Status rc;
int iters;
int opt;
int draw_lines;
int draw_rects;
int draw_stipples;
int draw_fonts;
int draw_image;
int zero_counters;
int scroll_type;
char image_file[256];
char proxy_app[256];
char msg[4096];
// set some defaults
g_winWidth = 640;
g_winHeight = 480;
iters = 5000;
draw_lines = 1;
draw_rects = 1;
draw_stipples = 1;
draw_fonts = 1;
draw_image = 1;
g_delay_dur = 1000;
scroll_type = SCROLL_SMOOTH1;
zero_counters = 0;
strcpy(image_file, "yosemite.bmp");
strcpy(msg, "To be or not to be!");
// process cmd line args
opterr = 0;
while ((opt = getopt(argc, argv, "lrsg:c:f:i:d:o:z:")) != -1)
{
switch (opt)
{
case 'g':
if (sscanf(optarg, "%dx%d", &g_winWidth, &g_winHeight) != 2) {
fprintf(stderr, "\nerror: invalid geometry specified\n\n");
usage();
return -1;
}
break;
case 'c':
if (sscanf(optarg, "%d", &iters) != 1) {
fprintf(stderr, "\nerror: invalid count specified\n\n");
usage();
return -1;
}
break;
case 'l':
draw_lines = 1;
draw_rects = 0;
draw_stipples = 0;
draw_fonts = 0;
draw_image = 0;
break;
case 'r':
draw_rects = 1;
draw_lines = 0;
draw_stipples = 0;
draw_fonts = 0;
draw_image = 0;
break;
case 's':
draw_stipples = 1;
draw_lines = 0;
draw_rects = 0;
draw_fonts = 0;
draw_image = 0;
break;
case 'f':
if (strlen(optarg) <= 0) {
fprintf(stderr, "\nerror: -f option requires an argument\n\n");
usage();
return -1;
}
draw_fonts = 1;
strncpy(msg, optarg, 4096);
draw_lines = 0;
draw_rects = 0;
draw_stipples = 0;
draw_image = 0;
break;
case 'i':
if (strlen(optarg) <= 0) {
fprintf(stderr, "\nerror: -i option requires an argument\n\n");
usage();
return -1;
}
draw_image = 1;
strncpy(image_file, optarg, 255);
draw_lines = 0;
draw_rects = 0;
draw_stipples = 0;
draw_fonts = 0;
break;
case 'h':
usage();
return 0;
break;
case 'v':
printf("xdemo Ver 1.0\n");
return 0;
break;
case 'd':
if (sscanf(optarg, "%d", &g_delay_dur) != 1) {
fprintf(stderr, "\nerror: -d option requires an argument\n\n");
usage();
return -1;
}
break;
case 'z':
if (strlen(optarg) <= 0) {
fprintf(stderr, "\nerror: invalid proxy application specified\n\n");
usage();
return -1;
}
strcpy(proxy_app, optarg);
printf("##### LK_TODO: proxy_app=%s\n", proxy_app);
zero_counters = 1;
break;
case 'o':
if (strcmp(optarg, "jump") == 0) {
scroll_type = SCROLL_JUMP;
}
else if (strcmp(optarg, "smooth1") == 0) {
scroll_type = SCROLL_SMOOTH1;
}
else if (strcmp(optarg, "smooth2") == 0) {
scroll_type = SCROLL_SMOOTH2;
}
else {
fprintf(stderr, "\ninvalid scroll type specified\n\n");
usage();
return -1;
}
break;
default:
usage();
return -1;
}
}
// must have at least one operation
if ((!draw_lines) && (!draw_rects) && (!draw_stipples) &&
(!draw_fonts) && (!draw_image)) {
usage();
return -1;
}
g_disp = XOpenDisplay(NULL);
if (!g_disp) {
dprint("error opening X display\n");
exit(-1);
}
screenNumber = DefaultScreen(g_disp);
white = WhitePixel(g_disp, screenNumber);
black = BlackPixel(g_disp, screenNumber);
g_win = XCreateSimpleWindow(g_disp,
DefaultRootWindow(g_disp),
50, 50, // origin
g_winWidth, g_winHeight, // size
0, black, // border
white ); // backgd
XMapWindow(g_disp, g_win);
//eventMask = StructureNotifyMask | MapNotify | VisibilityChangeMask;
eventMask = StructureNotifyMask | VisibilityChangeMask;
XSelectInput(g_disp, g_win, eventMask);
g_gc = XCreateGC(g_disp, g_win,
0, // mask of values
NULL ); // array of values
#if 0
do
{
dprint("about to call XNextEvent(...)\n");
XNextEvent(g_disp, &evt);// calls XFlush
dprint("returned from XNextEvent(...)\n");
}
//while(evt.type != MapNotify);
while(evt.type != VisibilityNotify);
#endif
// get access to the screen's color map
colormap = DefaultColormap(g_disp, screenNumber);
// alloc red color
rc = XAllocNamedColor(g_disp, colormap, "red", &g_colors[0], &g_colors[0]);
if (rc == 0) {
printf("XAllocNamedColor - failed to allocated 'red' color.\n");
exit(1);
}
rc = XAllocNamedColor(g_disp, colormap, "green", &g_colors[1], &g_colors[1]);
if (rc == 0) {
printf("XAllocNamedColor - failed to allocated 'green' color.\n");
exit(1);
}
rc = XAllocNamedColor(g_disp, colormap, "blue", &g_colors[2], &g_colors[2]);
if (rc == 0) {
printf("XAllocNamedColor - failed to allocated 'blue' color.\n");
exit(1);
}
rc = XAllocNamedColor(g_disp, colormap, "yellow", &g_colors[3], &g_colors[3]);
if (rc == 0) {
printf("XAllocNamedColor - failed to allocated 'yellow' color.\n");
exit(1);
}
rc = XAllocNamedColor(g_disp, colormap, "orange", &g_colors[4], &g_colors[4]);
if (rc == 0) {
printf("XAllocNamedColor - failed to allocated 'orange' color.\n");
exit(1);
}
if (zero_counters) {
signal_tcp_proxy(proxy_app);
}
if (draw_lines) {
start_timer(&tv);
drawLines(iters);
printf("drew %d lines in %d ms\n", iters, time_elapsed_ms(tv));
}
if (draw_rects) {
start_timer(&tv);
drawRectangles(iters);
printf("drew %d rects in %d ms\n", iters, time_elapsed_ms(tv));
}
if (draw_stipples) {
start_timer(&tv);
// LK_TODO
}
if (draw_fonts) {
start_timer(&tv);
drawFont(iters, msg);
printf("drew %d strings in %d ms\n", iters, time_elapsed_ms(tv));
}
if (draw_image) {
start_timer(&tv);
drawBMP(image_file, scroll_type);
printf("drew BMP in %d ms\n", time_elapsed_ms(tv));
}
if (zero_counters) {
signal_tcp_proxy(proxy_app);
}
eventMask = ButtonPressMask|ButtonReleaseMask;
XSelectInput(g_disp, g_win, eventMask);
do
{
XNextEvent(g_disp, &evt); // calls XFlush()
}
while(evt.type != ButtonRelease);
XDestroyWindow(g_disp, g_win);
XCloseDisplay(g_disp);
return 0;
}
int drawBMP(char *filename, int scroll_type)
{
struct pic_info pic_info;
XImage *image;
Visual *visual;
Pixmap pixmap;
int depth;
int i;
int j;
if (parse_bmp(filename, &pic_info) < 0) {
exit(-1);
}
XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);
depth = DefaultDepth(g_disp, DefaultScreen(g_disp));
visual = DefaultVisual(g_disp, DefaultScreen(g_disp));
// create empty pixmap
pixmap = XCreatePixmap(g_disp, g_win, pic_info.width, pic_info.height, depth);
// create an image from pixel data
image = XCreateImage(g_disp, visual, depth, ZPixmap, 0, pic_info.pixel_data,
pic_info.width, pic_info.height, 32, 0);
if (pic_info.height <= g_winHeight) {
// image is too small to scroll
XFlush(g_disp);
XPutImage(g_disp, g_win, g_gc, image, 0, 0, 0, 0, pic_info.width, pic_info.height);
XFlush(g_disp);
return 0;
}
if (scroll_type == SCROLL_JUMP) {
// copy image to pixelmap
XPutImage(g_disp, pixmap, g_gc, image, 0, 0, 0, 0, pic_info.width, pic_info.height);
if (pic_info.height <= g_winHeight) {
// image too small - no scrolling required
XFlush(g_disp);
XCopyArea(g_disp, // connection to X server
pixmap, // source drawable
g_win, // dest drawable
g_gc, // graphics context
0, 0, // source x,y
pic_info.width, // width
pic_info.height, // height
0, 0); // dest x,y
XFlush(g_disp);
return 0;
}
j = pic_info.height / g_winHeight;
if (pic_info.height % g_winHeight != 0) {
// need to include the last part of the image
j++;
}
XFlush(g_disp);
for (i = 0; i < j; i++)
{
XCopyArea(g_disp, // connection to X server
pixmap, // source drawable
g_win, // dest drawable
g_gc, // graphics context
0, i * g_winHeight, // source x,y
pic_info.width, // width
pic_info.height, // height
0, 0); // dest x,y
XFlush(g_disp);
sleep(3);
}
}
/*
** smooth scroll the image
*/
// number of lines to be scrolled
j = pic_info.height - g_winHeight;
if (scroll_type == SCROLL_SMOOTH1) {
XFlush(g_disp);
XPutImage(g_disp, g_win, g_gc, image, 0, 0, 0, 0, pic_info.width, pic_info.height);
XFlush(g_disp);
usleep(10000);
for (i = 0; i < j; i++)
{
XCopyArea(g_disp, g_win, g_win, g_gc, 0, 1, g_winWidth, g_winHeight - 1, 0, 0);
XPutImage(g_disp, g_win, g_gc, image, 0, g_winHeight + i, 0, g_winHeight -1 , pic_info.width, 1);
XFlush(g_disp);
usleep(10000);
}
return 0;
}
if (scroll_type == SCROLL_SMOOTH2) {
XFlush(g_disp);
for (i = 0; i < j; i++)
{
XPutImage(g_disp, g_win, g_gc, image, 0, i, 0, 0, pic_info.width, pic_info.height - i);
XFlush(g_disp);
usleep(10000);
}
}
return 0;
}
int process_bmp_event()
{
XEvent ev;
long event_mask;
event_mask = ExposureMask|ButtonPressMask|ButtonReleaseMask|StructureNotifyMask;
XSelectInput(g_disp, g_win, event_mask);
XNextEvent(g_disp, &ev);
switch(ev.type)
{
case Expose:
printf("got expose event\n");
break;
default:
printf("did not get expose event\n");
break;
}
return 0;
}
/**
* send a SIGUSR1 to process tcp_proxy, causing it to clear counters
*
* @return 0 on success, -1 on failure
*/
int signal_tcp_proxy(char *proc_name)
{
FILE *fp;
char *cptr;
char buf[2048];
int pids[10];
int status = 0;
int num_procs;
int i;
sprintf(buf, "pidof %s", proc_name);
if ((fp = popen(buf, "r")) == NULL ) {
printf("xdemo: popen() failed\n");
return -1;
}
cptr = fgets(buf, 2047, fp);
if (cptr == NULL) {
pclose(fp);
return -1;
}
num_procs = sscanf(buf, "%d %d %d %d %d %d %d %d %d %d",
&pids[0], &pids[1], &pids[2], &pids[3], &pids[4],
&pids[5], &pids[6], &pids[7], &pids[8], &pids[9]);
if (num_procs > 0) {
for (i = 0; i < num_procs; i++) {
kill(pids[i], SIGUSR1);
printf("sent SIGUSR1 to process %d\n", pids[i]);
}
}
pclose(fp);
return status;
}

BIN
xorg/tests/xdemo/yosemite.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.8 MiB