mirror of https://github.com/asterisk/asterisk
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1037 lines
29 KiB
1037 lines
29 KiB
/*
|
|
* GUI for console video.
|
|
* The routines here are in charge of loading the keypad and handling events.
|
|
* $Revision$
|
|
*/
|
|
|
|
/*
|
|
* GUI layout, structure and management
|
|
|
|
For the GUI we use SDL to create a large surface (gui->screen)
|
|
containing tree sections: remote video on the left, local video
|
|
on the right, and the keypad with all controls and text windows
|
|
in the center.
|
|
The central section is built using an image for the skin, fonts and
|
|
other GUI elements. Comments embedded in the image to indicate to
|
|
what function each area is mapped to.
|
|
|
|
Mouse and keyboard events are detected on the whole surface, and
|
|
handled differently according to their location:
|
|
|
|
- drag on the local video window are used to move the captured
|
|
area (in the case of X11 grabber) or the picture-in-picture
|
|
location (in case of camera included on the X11 grab).
|
|
- click on the keypad are mapped to the corresponding key;
|
|
- drag on some keypad areas (sliders etc.) are mapped to the
|
|
corresponding functions;
|
|
- keystrokes are used as keypad functions, or as text input
|
|
if we are in text-input mode.
|
|
|
|
Configuration options control the appeareance of the gui:
|
|
|
|
keypad = /tmp/phone.jpg ; the skin
|
|
keypad_font = /tmp/font.ttf ; the font to use for output (XXX deprecated)
|
|
|
|
*
|
|
*/
|
|
|
|
#include "asterisk.h"
|
|
#include "console_video.h"
|
|
#include "asterisk/lock.h"
|
|
#include "asterisk/frame.h"
|
|
#include "asterisk/utils.h" /* ast_calloc and ast_realloc */
|
|
#include <math.h> /* sqrt */
|
|
|
|
/* We use 3 'windows' in the GUI */
|
|
enum { WIN_LOCAL, WIN_REMOTE, WIN_KEYPAD, WIN_MAX };
|
|
|
|
#ifndef HAVE_SDL /* stubs if we don't have any sdl */
|
|
static void show_frame(struct video_desc *env, int out) {}
|
|
static void sdl_setup(struct video_desc *env) {}
|
|
static struct gui_info *cleanup_sdl(struct gui_info *gui) { return NULL; }
|
|
static void eventhandler(struct video_desc *env, const char *caption) {}
|
|
static int keypad_cfg_read(struct gui_info *gui, const char *val) { return 0; }
|
|
|
|
#else /* HAVE_SDL, the real rendering code */
|
|
|
|
#include <SDL/SDL.h>
|
|
#ifdef HAVE_SDL_IMAGE
|
|
#include <SDL/SDL_image.h> /* for loading images */
|
|
#endif
|
|
|
|
enum kp_type { KP_NONE, KP_RECT, KP_CIRCLE };
|
|
struct keypad_entry {
|
|
int c; /* corresponding character */
|
|
int x0, y0, x1, y1, h; /* arguments */
|
|
enum kp_type type;
|
|
};
|
|
|
|
/* our representation of a displayed window. SDL can only do one main
|
|
* window so we map everything within that one
|
|
*/
|
|
struct display_window {
|
|
SDL_Overlay *bmp;
|
|
SDL_Rect rect; /* location of the window */
|
|
};
|
|
|
|
struct gui_info {
|
|
enum kb_output kb_output; /* where the keyboard output goes */
|
|
struct drag_info drag; /* info on the window are we dragging */
|
|
/* support for display. */
|
|
SDL_Surface *screen; /* the main window */
|
|
|
|
int outfd; /* fd for output */
|
|
SDL_Surface *keypad; /* the skin for the keypad */
|
|
SDL_Rect kp_rect; /* portion of the skin to display - default all */
|
|
SDL_Surface *font; /* font to be used */
|
|
SDL_Rect font_rects[96]; /* only printable chars */
|
|
|
|
/* each board has two rectangles,
|
|
* [0] is the geometry relative to the keypad,
|
|
* [1] is the geometry relative to the whole screen
|
|
*/
|
|
SDL_Rect kp_msg[2]; /* incoming msg, relative to kpad */
|
|
struct board *bd_msg;
|
|
|
|
SDL_Rect kp_edit[2]; /* edit user input */
|
|
struct board *bd_edit;
|
|
|
|
SDL_Rect kp_dialed[2]; /* dialed number */
|
|
struct board *bd_dialed;
|
|
|
|
/* variable-size array mapping keypad regions to functions */
|
|
int kp_size, kp_used;
|
|
struct keypad_entry *kp;
|
|
|
|
struct display_window win[WIN_MAX];
|
|
};
|
|
|
|
/*! \brief free the resources in struct gui_info and the descriptor itself.
|
|
* Return NULL so we can assign the value back to the descriptor in case.
|
|
*/
|
|
static struct gui_info *cleanup_sdl(struct gui_info *gui)
|
|
{
|
|
int i;
|
|
|
|
if (gui == NULL)
|
|
return NULL;
|
|
|
|
/* unload font file */
|
|
if (gui->font) {
|
|
SDL_FreeSurface(gui->font);
|
|
gui->font = NULL;
|
|
}
|
|
|
|
if (gui->outfd > -1)
|
|
close(gui->outfd);
|
|
if (gui->keypad)
|
|
SDL_FreeSurface(gui->keypad);
|
|
gui->keypad = NULL;
|
|
if (gui->kp)
|
|
ast_free(gui->kp);
|
|
|
|
/* uninitialize the SDL environment */
|
|
for (i = 0; i < WIN_MAX; i++) {
|
|
if (gui->win[i].bmp)
|
|
SDL_FreeYUVOverlay(gui->win[i].bmp);
|
|
}
|
|
memset(gui, '\0', sizeof(gui));
|
|
ast_free(gui);
|
|
SDL_Quit();
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Display video frames (from local or remote stream) using the SDL library.
|
|
* - Set the video mode to use the resolution specified by the codec context
|
|
* - Create a YUV Overlay to copy the frame into it;
|
|
* - After the frame is copied into the overlay, display it
|
|
*
|
|
* The size is taken from the configuration.
|
|
*
|
|
* 'out' is 0 for remote video, 1 for the local video
|
|
*/
|
|
static void show_frame(struct video_desc *env, int out)
|
|
{
|
|
AVPicture *p_in, p_out;
|
|
struct fbuf_t *b_in, *b_out;
|
|
SDL_Overlay *bmp;
|
|
struct gui_info *gui = env->gui;
|
|
|
|
if (!gui)
|
|
return;
|
|
|
|
if (out == WIN_LOCAL) { /* webcam/x11 to sdl */
|
|
b_in = &env->enc_in;
|
|
b_out = &env->loc_dpy;
|
|
p_in = NULL;
|
|
} else {
|
|
/* copy input format from the decoding context */
|
|
AVCodecContext *c;
|
|
if (env->in == NULL) /* XXX should not happen - decoder not ready */
|
|
return;
|
|
c = env->in->dec_ctx;
|
|
b_in = &env->in->dec_out;
|
|
b_in->pix_fmt = c->pix_fmt;
|
|
b_in->w = c->width;
|
|
b_in->h = c->height;
|
|
|
|
b_out = &env->rem_dpy;
|
|
p_in = (AVPicture *)env->in->d_frame;
|
|
}
|
|
bmp = gui->win[out].bmp;
|
|
SDL_LockYUVOverlay(bmp);
|
|
/* output picture info - this is sdl, YUV420P */
|
|
memset(&p_out, '\0', sizeof(p_out));
|
|
p_out.data[0] = bmp->pixels[0];
|
|
p_out.data[1] = bmp->pixels[1];
|
|
p_out.data[2] = bmp->pixels[2];
|
|
p_out.linesize[0] = bmp->pitches[0];
|
|
p_out.linesize[1] = bmp->pitches[1];
|
|
p_out.linesize[2] = bmp->pitches[2];
|
|
|
|
my_scale(b_in, p_in, b_out, &p_out);
|
|
|
|
/* lock to protect access to Xlib by different threads. */
|
|
SDL_DisplayYUVOverlay(bmp, &gui->win[out].rect);
|
|
SDL_UnlockYUVOverlay(bmp);
|
|
}
|
|
|
|
/*
|
|
* Identifiers for regions of the main window.
|
|
* Values between 0 and 127 correspond to ASCII characters.
|
|
* The corresponding strings to be used in the skin comment section
|
|
* are defined in gui_key_map.
|
|
*/
|
|
enum skin_area {
|
|
/* answer/close functions */
|
|
KEY_PICK_UP = 128,
|
|
KEY_HANG_UP = 129,
|
|
|
|
KEY_MUTE = 130,
|
|
KEY_AUTOANSWER = 131,
|
|
KEY_SENDVIDEO = 132,
|
|
KEY_LOCALVIDEO = 133,
|
|
KEY_REMOTEVIDEO = 134,
|
|
KEY_FLASH = 136,
|
|
|
|
/* sensitive areas for the various text windows */
|
|
KEY_MESSAGEBOARD = 140,
|
|
KEY_DIALEDBOARD = 141,
|
|
KEY_EDITBOARD = 142,
|
|
|
|
KEY_GUI_CLOSE = 199, /* close gui */
|
|
/* regions of the skin - displayed area, fonts, etc.
|
|
* XXX NOTE these are not sensitive areas.
|
|
*/
|
|
KEY_KEYPAD = 200, /* the keypad - default to the whole image */
|
|
KEY_FONT = 201, /* the font. Maybe not really useful */
|
|
KEY_MESSAGE = 202, /* area for incoming messages */
|
|
KEY_DIALED = 203, /* area for dialed numbers */
|
|
KEY_EDIT = 204, /* area for editing user input */
|
|
|
|
/* areas outside the keypad - simulated */
|
|
KEY_OUT_OF_KEYPAD = 241,
|
|
KEY_REM_DPY = 242,
|
|
KEY_LOC_DPY = 243,
|
|
KEY_RESET = 253, /* the 'reset' keyword */
|
|
KEY_NONE = 254, /* invalid area */
|
|
KEY_DIGIT_BACKGROUND = 255, /* other areas within the keypad */
|
|
};
|
|
|
|
/*
|
|
* Handlers for the various keypad functions
|
|
*/
|
|
|
|
/* accumulate digits, possibly call dial if in connected mode */
|
|
static void keypad_digit(struct video_desc *env, int digit)
|
|
{
|
|
if (env->owner) { /* we have a call, send the digit */
|
|
struct ast_frame f = { AST_FRAME_DTMF, 0 };
|
|
|
|
f.subclass = digit;
|
|
ast_queue_frame(env->owner, &f);
|
|
} else { /* no call, accumulate digits */
|
|
char buf[2] = { digit, '\0' };
|
|
if (env->gui->bd_msg) /* XXX not strictly necessary ... */
|
|
print_message(env->gui->bd_msg, buf);
|
|
}
|
|
}
|
|
|
|
/* function used to toggle on/off the status of some variables */
|
|
static char *keypad_toggle(struct video_desc *env, int index)
|
|
{
|
|
ast_log(LOG_WARNING, "keypad_toggle(%i) called\n", index);
|
|
|
|
switch (index) {
|
|
case KEY_SENDVIDEO:
|
|
env->out.sendvideo = !env->out.sendvideo;
|
|
break;
|
|
#ifdef notyet
|
|
case KEY_MUTE: {
|
|
struct chan_oss_pvt *o = find_desc(oss_active);
|
|
o->mute = !o->mute;
|
|
}
|
|
break;
|
|
case KEY_AUTOANSWER: {
|
|
struct chan_oss_pvt *o = find_desc(oss_active);
|
|
o->autoanswer = !o->autoanswer;
|
|
}
|
|
break;
|
|
#endif
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
char *console_do_answer(int fd);
|
|
/*
|
|
* Function called when the pick up button is pressed
|
|
* perform actions according the channel status:
|
|
*
|
|
* - if no one is calling us and no digits was pressed,
|
|
* the operation have no effects,
|
|
* - if someone is calling us we answer to the call.
|
|
* - if we have no call in progress and we pressed some
|
|
* digit, send the digit to the console.
|
|
*/
|
|
static void keypad_pick_up(struct video_desc *env)
|
|
{
|
|
struct gui_info *gui = env->gui;
|
|
|
|
ast_log(LOG_WARNING, "keypad_pick_up called\n");
|
|
|
|
if (env->owner) { /* someone is calling us, just answer */
|
|
ast_cli_command(gui->outfd, "console answer");
|
|
} else { /* we have someone to call */
|
|
char buf[160];
|
|
const char *who = ast_skip_blanks(read_message(gui->bd_msg));
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
snprintf(buf, sizeof(buf), "console dial %s", who);
|
|
ast_log(LOG_WARNING, "doing <%s>\n", buf);
|
|
print_message(gui->bd_dialed, "\n");
|
|
print_message(gui->bd_dialed, who);
|
|
reset_board(gui->bd_msg);
|
|
ast_cli_command(gui->outfd, buf);
|
|
}
|
|
}
|
|
|
|
#if 0 /* still unused */
|
|
/*
|
|
* As an alternative to SDL_TTF, we can simply load the font from
|
|
* an image and blit characters on the background of the GUI.
|
|
*
|
|
* To generate a font we can use the 'fly' command with the
|
|
* following script (3 lines with 32 chars each)
|
|
|
|
size 320,64
|
|
name font.png
|
|
transparent 0,0,0
|
|
string 255,255,255, 0, 0,giant, !"#$%&'()*+,-./0123456789:;<=>?
|
|
string 255,255,255, 0,20,giant,@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
|
|
string 255,255,255, 0,40,giant,`abcdefghijklmnopqrstuvwxyz{|}~
|
|
end
|
|
|
|
*/
|
|
|
|
/* Print given text on the gui */
|
|
static int gui_output(struct video_desc *env, const char *text)
|
|
{
|
|
return 1; /* error, not supported */
|
|
}
|
|
#endif
|
|
|
|
static int video_geom(struct fbuf_t *b, const char *s);
|
|
static void sdl_setup(struct video_desc *env);
|
|
static int kp_match_area(const struct keypad_entry *e, int x, int y);
|
|
|
|
static void set_drag(struct drag_info *drag, int x, int y, enum drag_window win)
|
|
{
|
|
drag->x_start = x;
|
|
drag->y_start = y;
|
|
drag->drag_window = win;
|
|
}
|
|
|
|
/*
|
|
* Handle SDL_MOUSEBUTTONDOWN type, finding the palette
|
|
* index value and calling the right callback.
|
|
*
|
|
* x, y are referred to the upper left corner of the main SDL window.
|
|
*/
|
|
static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button)
|
|
{
|
|
uint8_t index = KEY_OUT_OF_KEYPAD; /* the key or region of the display we clicked on */
|
|
struct gui_info *gui = env->gui;
|
|
|
|
#if 0
|
|
ast_log(LOG_WARNING, "event %d %d have %d/%d regions at %p\n",
|
|
button.x, button.y, gui->kp_used, gui->kp_size, gui->kp);
|
|
#endif
|
|
/* for each mousedown we end previous drag */
|
|
gui->drag.drag_window = DRAG_NONE;
|
|
|
|
/* define keypad boundary */
|
|
if (button.x < env->rem_dpy.w)
|
|
index = KEY_REM_DPY; /* click on remote video */
|
|
else if (button.x > env->rem_dpy.w + gui->keypad->w)
|
|
index = KEY_LOC_DPY; /* click on local video */
|
|
else if (button.y > gui->keypad->h)
|
|
index = KEY_OUT_OF_KEYPAD; /* click outside the keypad */
|
|
else if (gui->kp) {
|
|
int i;
|
|
for (i = 0; i < gui->kp_used; i++) {
|
|
if (kp_match_area(&gui->kp[i], button.x - env->rem_dpy.w, button.y)) {
|
|
index = gui->kp[i].c;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* exec the function */
|
|
if (index < 128) { /* surely clicked on the keypad, don't care which key */
|
|
keypad_digit(env, index);
|
|
return;
|
|
}
|
|
switch (index) {
|
|
/* answer/close function */
|
|
case KEY_PICK_UP:
|
|
keypad_pick_up(env);
|
|
break;
|
|
case KEY_HANG_UP:
|
|
ast_cli_command(gui->outfd, "console hangup");
|
|
break;
|
|
|
|
/* other functions */
|
|
case KEY_MUTE:
|
|
case KEY_AUTOANSWER:
|
|
case KEY_SENDVIDEO:
|
|
keypad_toggle(env, index);
|
|
break;
|
|
|
|
case KEY_LOCALVIDEO:
|
|
break;
|
|
case KEY_REMOTEVIDEO:
|
|
break;
|
|
|
|
case KEY_MESSAGEBOARD:
|
|
if (button.button == SDL_BUTTON_LEFT)
|
|
set_drag(&gui->drag, button.x, button.y, DRAG_MESSAGE);
|
|
break;
|
|
|
|
/* press outside the keypad. right increases size, center decreases, left drags */
|
|
case KEY_LOC_DPY:
|
|
case KEY_REM_DPY:
|
|
if (button.button == SDL_BUTTON_LEFT) {
|
|
if (index == KEY_LOC_DPY)
|
|
set_drag(&gui->drag, button.x, button.y, DRAG_LOCAL);
|
|
break;
|
|
} else {
|
|
char buf[128];
|
|
struct fbuf_t *fb = index == KEY_LOC_DPY ? &env->loc_dpy : &env->rem_dpy;
|
|
sprintf(buf, "%c%dx%d", button.button == SDL_BUTTON_RIGHT ? '>' : '<',
|
|
fb->w, fb->h);
|
|
video_geom(fb, buf);
|
|
sdl_setup(env);
|
|
}
|
|
break;
|
|
case KEY_OUT_OF_KEYPAD:
|
|
break;
|
|
|
|
case KEY_DIGIT_BACKGROUND:
|
|
break;
|
|
default:
|
|
ast_log(LOG_WARNING, "function not yet defined %i\n", index);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Handle SDL_KEYDOWN type event, put the key pressed
|
|
* in the dial buffer or in the text-message buffer,
|
|
* depending on the text_mode variable value.
|
|
*
|
|
* key is the SDLKey structure corresponding to the key pressed.
|
|
* Note that SDL returns modifiers (ctrl, shift, alt) as independent
|
|
* information so the key itself is not enough and we need to
|
|
* use a translation table, below - one line per entry,
|
|
* plain, shift, ctrl, ... using the first char as key.
|
|
*/
|
|
static const char *us_kbd_map[] = {
|
|
"`~", "1!", "2@", "3#", "4$", "5%", "6^",
|
|
"7&", "8*", "9(", "0)", "-_", "=+", "[{",
|
|
"]}", "\\|", ";:", "'\"", ",<", ".>", "/?",
|
|
"jJ\n",
|
|
NULL
|
|
};
|
|
|
|
static char map_key(SDL_keysym *ks)
|
|
{
|
|
const char *s, **p = us_kbd_map;
|
|
int c = ks->sym;
|
|
|
|
if (c == '\r') /* map cr into lf */
|
|
c = '\n';
|
|
if (c >= SDLK_NUMLOCK && c <= SDLK_COMPOSE)
|
|
return 0; /* only a modifier */
|
|
if (ks->mod == 0)
|
|
return c;
|
|
while ((s = *p) && s[0] != c)
|
|
p++;
|
|
if (s) { /* see if we have a modifier and a chance to use it */
|
|
int l = strlen(s), mod = 0;
|
|
if (l > 1)
|
|
mod |= (ks->mod & KMOD_SHIFT) ? 1 : 0;
|
|
if (l > 2 + mod)
|
|
mod |= (ks->mod & KMOD_CTRL) ? 2 : 0;
|
|
if (l > 4 + mod)
|
|
mod |= (ks->mod & KMOD_ALT) ? 4 : 0;
|
|
c = s[mod];
|
|
}
|
|
if (ks->mod & (KMOD_CAPS|KMOD_SHIFT) && c >= 'a' && c <='z')
|
|
c += 'A' - 'a';
|
|
return c;
|
|
}
|
|
|
|
static void handle_keyboard_input(struct video_desc *env, SDL_keysym *ks)
|
|
{
|
|
char buf[2] = { map_key(ks), '\0' };
|
|
struct gui_info *gui = env->gui;
|
|
if (buf[0] == 0) /* modifier ? */
|
|
return;
|
|
switch (gui->kb_output) {
|
|
default:
|
|
break;
|
|
case KO_INPUT: /* to be completed */
|
|
break;
|
|
case KO_MESSAGE:
|
|
if (gui->bd_msg) {
|
|
print_message(gui->bd_msg, buf);
|
|
if (buf[0] == '\r' || buf[0] == '\n') {
|
|
keypad_pick_up(env);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KO_DIALED: /* to be completed */
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static void grabber_move(struct video_out_desc *, int dx, int dy);
|
|
|
|
int compute_drag(int *start, int end, int magnifier);
|
|
int compute_drag(int *start, int end, int magnifier)
|
|
{
|
|
int delta = end - *start;
|
|
#define POLARITY -1
|
|
/* add a small quadratic term */
|
|
delta += delta * delta * (delta > 0 ? 1 : -1 )/100;
|
|
delta *= POLARITY * magnifier;
|
|
#undef POLARITY
|
|
*start = end;
|
|
return delta;
|
|
}
|
|
|
|
/*
|
|
* I am seeing some kind of deadlock or stall around
|
|
* SDL_PumpEvents() while moving the window on a remote X server
|
|
* (both xfree-4.4.0 and xorg 7.2)
|
|
* and windowmaker. It is unclear what causes it.
|
|
*/
|
|
|
|
/*! \brief refresh the screen, and also grab a bunch of events.
|
|
*/
|
|
static void eventhandler(struct video_desc *env, const char *caption)
|
|
{
|
|
struct gui_info *gui = env->gui;
|
|
struct drag_info *drag;
|
|
#define N_EVENTS 32
|
|
int i, n;
|
|
SDL_Event ev[N_EVENTS];
|
|
|
|
if (!gui)
|
|
return;
|
|
drag = &gui->drag;
|
|
if (caption)
|
|
SDL_WM_SetCaption(caption, NULL);
|
|
|
|
#define MY_EV (SDL_MOUSEBUTTONDOWN|SDL_KEYDOWN)
|
|
while ( (n = SDL_PeepEvents(ev, N_EVENTS, SDL_GETEVENT, SDL_ALLEVENTS)) > 0) {
|
|
for (i = 0; i < n; i++) {
|
|
#if 0
|
|
ast_log(LOG_WARNING, "------ event %d at %d %d\n",
|
|
ev[i].type, ev[i].button.x, ev[i].button.y);
|
|
#endif
|
|
switch (ev[i].type) {
|
|
case SDL_KEYDOWN:
|
|
handle_keyboard_input(env, &ev[i].key.keysym);
|
|
break;
|
|
case SDL_MOUSEMOTION:
|
|
case SDL_MOUSEBUTTONUP:
|
|
if (drag->drag_window == DRAG_LOCAL) {
|
|
/* move the capture source */
|
|
int dx = compute_drag(&drag->x_start, ev[i].motion.x, 3);
|
|
int dy = compute_drag(&drag->y_start, ev[i].motion.y, 3);
|
|
grabber_move(&env->out, dx, dy);
|
|
} else if (drag->drag_window == DRAG_MESSAGE) {
|
|
/* scroll up/down the window */
|
|
int dy = compute_drag(&drag->y_start, ev[i].motion.y, 1);
|
|
move_message_board(gui->bd_msg, dy);
|
|
}
|
|
if (ev[i].type == SDL_MOUSEBUTTONUP)
|
|
drag->drag_window = DRAG_NONE;
|
|
break;
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
handle_mousedown(env, ev[i].button);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (1) {
|
|
struct timeval b, a = ast_tvnow();
|
|
int i;
|
|
//SDL_Lock_EventThread();
|
|
SDL_PumpEvents();
|
|
b = ast_tvnow();
|
|
i = ast_tvdiff_ms(b, a);
|
|
if (i > 3)
|
|
fprintf(stderr, "-------- SDL_PumpEvents took %dms\n", i);
|
|
//SDL_Unlock_EventThread();
|
|
}
|
|
}
|
|
|
|
static SDL_Surface *load_image(const char *file)
|
|
{
|
|
SDL_Surface *temp;
|
|
|
|
#ifdef HAVE_SDL_IMAGE
|
|
temp = IMG_Load(file);
|
|
#else
|
|
temp = SDL_LoadBMP(file);
|
|
#endif
|
|
if (temp == NULL)
|
|
fprintf(stderr, "Unable to load image %s: %s\n",
|
|
file, SDL_GetError());
|
|
return temp;
|
|
}
|
|
|
|
static void keypad_setup(struct gui_info *gui, const char *kp_file);
|
|
|
|
/* TODO: consistency checks, check for bpp, widht and height */
|
|
/* Init the mask image used to grab the action. */
|
|
static struct gui_info *gui_init(const char *keypad_file, const char *font)
|
|
{
|
|
struct gui_info *gui = ast_calloc(1, sizeof(*gui));
|
|
|
|
if (gui == NULL)
|
|
return NULL;
|
|
/* initialize keypad status */
|
|
gui->kb_output = KO_MESSAGE; /* XXX temp */
|
|
gui->drag.drag_window = DRAG_NONE;
|
|
gui->outfd = -1;
|
|
|
|
keypad_setup(gui, keypad_file);
|
|
if (gui->keypad == NULL) /* no keypad, we are done */
|
|
return gui;
|
|
/* XXX load image */
|
|
if (!ast_strlen_zero(font)) {
|
|
int i;
|
|
SDL_Rect *r;
|
|
|
|
gui->font = load_image(font);
|
|
if (!gui->font) {
|
|
ast_log(LOG_WARNING, "Unable to load font %s, no output available\n", font);
|
|
goto error;
|
|
}
|
|
ast_log(LOG_WARNING, "Loaded font %s\n", font);
|
|
/* XXX hardwired constants - 3 rows of 32 chars */
|
|
r = gui->font_rects;
|
|
#define FONT_H 20
|
|
#define FONT_W 9
|
|
for (i = 0; i < 96; r++, i++) {
|
|
r->x = (i % 32 ) * FONT_W;
|
|
r->y = (i / 32 ) * FONT_H;
|
|
r->w = FONT_W;
|
|
r->h = FONT_H;
|
|
}
|
|
}
|
|
|
|
gui->outfd = open ("/dev/null", O_WRONLY); /* discard output, temporary */
|
|
if (gui->outfd < 0) {
|
|
ast_log(LOG_WARNING, "Unable output fd\n");
|
|
goto error;
|
|
}
|
|
return gui;
|
|
|
|
error:
|
|
ast_free(gui);
|
|
return NULL;
|
|
}
|
|
|
|
/* setup an sdl overlay and associated info, return 0 on success, != 0 on error */
|
|
static int set_win(SDL_Surface *screen, struct display_window *win, int fmt,
|
|
int w, int h, int x, int y)
|
|
{
|
|
win->bmp = SDL_CreateYUVOverlay(w, h, fmt, screen);
|
|
if (win->bmp == NULL)
|
|
return -1; /* error */
|
|
win->rect.x = x;
|
|
win->rect.y = y;
|
|
win->rect.w = w;
|
|
win->rect.h = h;
|
|
return 0;
|
|
}
|
|
|
|
static int keypad_cfg_read(struct gui_info *gui, const char *val);
|
|
|
|
static void keypad_setup(struct gui_info *gui, const char *kp_file)
|
|
{
|
|
FILE *fd;
|
|
char buf[1024];
|
|
const char region[] = "region";
|
|
int reg_len = strlen(region);
|
|
int in_comment = 0;
|
|
|
|
if (gui->keypad)
|
|
return;
|
|
gui->keypad = load_image(kp_file);
|
|
if (!gui->keypad)
|
|
return;
|
|
/* now try to read the keymap from the file. */
|
|
fd = fopen(kp_file, "r");
|
|
if (fd == NULL) {
|
|
ast_log(LOG_WARNING, "fail to open %s\n", kp_file);
|
|
return;
|
|
}
|
|
/*
|
|
* If the keypad image has a comment field, try to read
|
|
* the button location from there. The block must start with
|
|
* a comment (or empty) line, and continue with entries like:
|
|
* region = token shape x0 y0 x1 y1 h
|
|
* ...
|
|
* (basically, lines have the same format as config file entries).
|
|
* You can add it to a jpeg file using wrjpgcom
|
|
*/
|
|
while (fgets(buf, sizeof(buf), fd)) {
|
|
char *s;
|
|
|
|
if (!strstr(buf, region)) { /* no keyword yet */
|
|
if (!in_comment) /* still waiting for initial comment block */
|
|
continue;
|
|
else
|
|
break;
|
|
}
|
|
if (!in_comment) { /* first keyword, reset previous entries */
|
|
keypad_cfg_read(gui, "reset");
|
|
in_comment = 1;
|
|
}
|
|
s = ast_skip_blanks(buf);
|
|
ast_trim_blanks(s);
|
|
if (memcmp(s, region, reg_len))
|
|
break; /* keyword not found */
|
|
s = ast_skip_blanks(s + reg_len); /* space between token and '=' */
|
|
if (*s++ != '=') /* missing separator */
|
|
break;
|
|
if (*s == '>') /* skip '>' if present */
|
|
s++;
|
|
keypad_cfg_read(gui, ast_skip_blanks(s));
|
|
}
|
|
fclose(fd);
|
|
}
|
|
|
|
struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
|
|
SDL_Surface *font, SDL_Rect *font_rects);
|
|
|
|
/*! \brief initialize the boards we have in the keypad */
|
|
static void init_board(struct gui_info *gui, struct board **dst, SDL_Rect *r, int dx, int dy)
|
|
{
|
|
if (r[0].w == 0 || r[0].h == 0)
|
|
return; /* not available */
|
|
r[1] = r[0]; /* copy geometry */
|
|
r[1].x += dx; /* add offset of main window */
|
|
r[1].y += dy;
|
|
if (*dst == NULL) { /* initial call */
|
|
*dst = board_setup(gui->screen, &r[1], gui->font, gui->font_rects);
|
|
} else {
|
|
/* call a refresh */
|
|
}
|
|
}
|
|
|
|
/*! \brief [re]set the main sdl window, useful in case of resize.
|
|
* We can tell the first from subsequent calls from the value of
|
|
* env->gui, which is NULL the first time.
|
|
*/
|
|
static void sdl_setup(struct video_desc *env)
|
|
{
|
|
int dpy_fmt = SDL_IYUV_OVERLAY; /* YV12 causes flicker in SDL */
|
|
int depth, maxw, maxh;
|
|
const SDL_VideoInfo *info;
|
|
int kp_w = 0, kp_h = 0; /* keypad width and height */
|
|
struct gui_info *gui = env->gui;
|
|
|
|
/*
|
|
* initialize the SDL environment. We have one large window
|
|
* with local and remote video, and a keypad.
|
|
* At the moment we arrange them statically, as follows:
|
|
* - on the left, the remote video;
|
|
* - on the center, the keypad
|
|
* - on the right, the local video
|
|
* We need to read in the skin for the keypad before creating the main
|
|
* SDL window, because the size is only known here.
|
|
*/
|
|
|
|
if (gui == NULL && SDL_Init(SDL_INIT_VIDEO)) {
|
|
ast_log(LOG_WARNING, "Could not initialize SDL - %s\n",
|
|
SDL_GetError());
|
|
/* again not fatal, just we won't display anything */
|
|
return;
|
|
}
|
|
info = SDL_GetVideoInfo();
|
|
/* We want at least 16bpp to support YUV overlays.
|
|
* E.g with SDL_VIDEODRIVER = aalib the default is 8
|
|
*/
|
|
depth = info->vfmt->BitsPerPixel;
|
|
if (depth < 16)
|
|
depth = 16;
|
|
if (!gui)
|
|
env->gui = gui = gui_init(env->keypad_file, env->keypad_font);
|
|
if (!gui)
|
|
goto no_sdl;
|
|
|
|
if (gui->keypad) {
|
|
if (gui->kp_rect.w > 0 && gui->kp_rect.h > 0) {
|
|
kp_w = gui->kp_rect.w;
|
|
kp_h = gui->kp_rect.h;
|
|
} else {
|
|
kp_w = gui->keypad->w;
|
|
kp_h = gui->keypad->h;
|
|
}
|
|
}
|
|
/* XXX same for other boards */
|
|
#define BORDER 5 /* border around our windows */
|
|
maxw = env->rem_dpy.w + env->loc_dpy.w + kp_w;
|
|
maxh = MAX( MAX(env->rem_dpy.h, env->loc_dpy.h), kp_h);
|
|
maxw += 4 * BORDER;
|
|
maxh += 2 * BORDER;
|
|
gui->screen = SDL_SetVideoMode(maxw, maxh, depth, 0);
|
|
if (!gui->screen) {
|
|
ast_log(LOG_ERROR, "SDL: could not set video mode - exiting\n");
|
|
goto no_sdl;
|
|
}
|
|
|
|
SDL_WM_SetCaption("Asterisk console Video Output", NULL);
|
|
if (set_win(gui->screen, &gui->win[WIN_REMOTE], dpy_fmt,
|
|
env->rem_dpy.w, env->rem_dpy.h, BORDER, BORDER))
|
|
goto no_sdl;
|
|
if (set_win(gui->screen, &gui->win[WIN_LOCAL], dpy_fmt,
|
|
env->loc_dpy.w, env->loc_dpy.h,
|
|
3*BORDER+env->rem_dpy.w + kp_w, BORDER))
|
|
goto no_sdl;
|
|
|
|
/* display the skin, but do not free it as we need it later to
|
|
* restore text areas and maybe sliders too.
|
|
*/
|
|
if (gui->keypad) {
|
|
struct SDL_Rect *dest = &gui->win[WIN_KEYPAD].rect;
|
|
struct SDL_Rect *src = (gui->kp_rect.w > 0 && gui->kp_rect.h > 0) ? & gui->kp_rect : NULL;
|
|
/* set the coordinates of the keypad relative to the main screen */
|
|
dest->x = 2*BORDER + env->rem_dpy.w;
|
|
dest->y = BORDER;
|
|
dest->w = kp_w;
|
|
dest->h = kp_h;
|
|
SDL_BlitSurface(gui->keypad, src, gui->screen, dest);
|
|
init_board(gui, &gui->bd_msg, gui->kp_msg, dest->x, dest->y);
|
|
init_board(gui, &gui->bd_dialed, gui->kp_dialed, dest->x, dest->y);
|
|
SDL_UpdateRects(gui->screen, 1, dest);
|
|
}
|
|
return;
|
|
|
|
no_sdl:
|
|
/* free resources in case of errors */
|
|
env->gui = cleanup_sdl(gui);
|
|
}
|
|
|
|
/*
|
|
* Functions to determine if a point is within a region. Return 1 if success.
|
|
* First rotate the point, with
|
|
* x' = (x - x0) * cos A + (y - y0) * sin A
|
|
* y' = -(x - x0) * sin A + (y - y0) * cos A
|
|
* where cos A = (x1-x0)/l, sin A = (y1 - y0)/l, and
|
|
* l = sqrt( (x1-x0)^2 + (y1-y0)^2
|
|
* Then determine inclusion by simple comparisons i.e.:
|
|
* rectangle: x >= 0 && x < l && y >= 0 && y < h
|
|
* ellipse: (x-xc)^2/l^2 + (y-yc)^2/h2 < 1
|
|
*/
|
|
static int kp_match_area(const struct keypad_entry *e, int x, int y)
|
|
{
|
|
double xp, dx = (e->x1 - e->x0);
|
|
double yp, dy = (e->y1 - e->y0);
|
|
double l = sqrt(dx*dx + dy*dy);
|
|
int ret = 0;
|
|
|
|
if (l > 1) { /* large enough */
|
|
xp = ((x - e->x0)*dx + (y - e->y0)*dy)/l;
|
|
yp = (-(x - e->x0)*dy + (y - e->y0)*dx)/l;
|
|
if (e->type == KP_RECT) {
|
|
ret = (xp >= 0 && xp < l && yp >=0 && yp < l);
|
|
} else if (e->type == KP_CIRCLE) {
|
|
dx = xp*xp/(l*l) + yp*yp/(e->h*e->h);
|
|
ret = (dx < 1);
|
|
}
|
|
}
|
|
#if 0
|
|
ast_log(LOG_WARNING, "result %d [%d] for match %d,%d in type %d p0 %d,%d p1 %d,%d h %d\n",
|
|
ret, e->c, x, y, e->type, e->x0, e->y0, e->x1, e->y1, e->h);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
struct _s_k { const char *s; int k; };
|
|
static struct _s_k gui_key_map[] = {
|
|
{"PICK_UP", KEY_PICK_UP },
|
|
{"PICKUP", KEY_PICK_UP },
|
|
{"HANG_UP", KEY_HANG_UP },
|
|
{"HANGUP", KEY_HANG_UP },
|
|
{"MUTE", KEY_MUTE },
|
|
{"FLASH", KEY_FLASH },
|
|
{"AUTOANSWER", KEY_AUTOANSWER },
|
|
{"SENDVIDEO", KEY_SENDVIDEO },
|
|
{"LOCALVIDEO", KEY_LOCALVIDEO },
|
|
{"REMOTEVIDEO", KEY_REMOTEVIDEO },
|
|
{"GUI_CLOSE", KEY_GUI_CLOSE },
|
|
{"MESSAGEBOARD", KEY_MESSAGEBOARD },
|
|
{"DIALEDBOARD", KEY_DIALEDBOARD },
|
|
{"EDITBOARD", KEY_EDITBOARD },
|
|
{"KEYPAD", KEY_KEYPAD }, /* x0 y0 w h - active area of the keypad */
|
|
{"MESSAGE", KEY_MESSAGE }, /* x0 y0 w h - incoming messages */
|
|
{"DIALED", KEY_DIALED }, /* x0 y0 w h - dialed number */
|
|
{"EDIT", KEY_EDIT }, /* x0 y0 w h - edit user input */
|
|
{"FONT", KEY_FONT }, /* x0 yo w h rows cols - location and format of the font */
|
|
{NULL, 0 } };
|
|
|
|
static int gui_map_token(const char *s)
|
|
{
|
|
/* map the string into token to be returned */
|
|
int i = atoi(s);
|
|
struct _s_k *p;
|
|
if (i > 0 || s[1] == '\0') /* numbers or single characters */
|
|
return (i > 9) ? i : s[0];
|
|
for (p = gui_key_map; p->s; p++) {
|
|
if (!strcasecmp(p->s, s))
|
|
return p->k;
|
|
}
|
|
return KEY_NONE; /* not found */
|
|
}
|
|
|
|
/*! \brief read a keypad entry line in the format
|
|
* reset
|
|
* token circle xc yc diameter
|
|
* token circle xc yc x1 y1 h # ellipse, main diameter and height
|
|
* token rect x0 y0 x1 y1 h # rectangle with main side and eight
|
|
* token is the token to be returned, either a character or a symbol
|
|
* as KEY_* above
|
|
* Return 1 on success, 0 on error.
|
|
*/
|
|
static int keypad_cfg_read(struct gui_info *gui, const char *val)
|
|
{
|
|
struct keypad_entry e;
|
|
SDL_Rect *r = NULL;
|
|
char s1[16], s2[16];
|
|
int i, ret = 0; /* default, error */
|
|
|
|
if (gui == NULL || val == NULL)
|
|
return 0;
|
|
|
|
s1[0] = s2[0] = '\0';
|
|
memset(&e, '\0', sizeof(e));
|
|
i = sscanf(val, "%14s %14s %d %d %d %d %d",
|
|
s1, s2, &e.x0, &e.y0, &e.x1, &e.y1, &e.h);
|
|
|
|
e.c = gui_map_token(s1);
|
|
if (e.c == KEY_NONE)
|
|
return 0; /* nothing found */
|
|
switch (i) {
|
|
default:
|
|
break;
|
|
case 1: /* only "reset" is allowed */
|
|
if (e.c != KEY_RESET)
|
|
break;
|
|
if (gui->kp)
|
|
gui->kp_used = 0;
|
|
break;
|
|
case 5:
|
|
if (e.c == KEY_KEYPAD) /* active keypad area */
|
|
r = &gui->kp_rect;
|
|
else if (e.c == KEY_MESSAGE)
|
|
r = gui->kp_msg;
|
|
else if (e.c == KEY_DIALED)
|
|
r = gui->kp_dialed;
|
|
else if (e.c == KEY_EDIT)
|
|
r = gui->kp_edit;
|
|
if (r) {
|
|
r->x = atoi(s2);
|
|
r->y = e.x0;
|
|
r->w = e.y0;
|
|
r->h = e.x1;
|
|
break;
|
|
}
|
|
if (strcasecmp(s2, "circle")) /* invalid */
|
|
break;
|
|
/* token circle xc yc diameter */
|
|
e.h = e.x1;
|
|
e.y1 = e.y0; /* map radius in x1 y1 */
|
|
e.x1 = e.x0 + e.h; /* map radius in x1 y1 */
|
|
e.x0 = e.x0 - e.h; /* map radius in x1 y1 */
|
|
/* fallthrough */
|
|
|
|
case 7:
|
|
if (e.c == KEY_FONT) { /* font - x0 y0 w h rows cols */
|
|
ast_log(LOG_WARNING, "font not supported yet\n");
|
|
break;
|
|
}
|
|
/* token circle|rect x0 y0 x1 y1 h */
|
|
if (e.x1 < e.x0 || e.h <= 0) {
|
|
ast_log(LOG_WARNING, "error in coordinates\n");
|
|
e.type = 0;
|
|
break;
|
|
}
|
|
if (!strcasecmp(s2, "circle")) {
|
|
/* for a circle we specify the diameter but store center and radii */
|
|
e.type = KP_CIRCLE;
|
|
e.x0 = (e.x1 + e.x0) / 2;
|
|
e.y0 = (e.y1 + e.y0) / 2;
|
|
e.h = e.h / 2;
|
|
} else if (!strcasecmp(s2, "rect")) {
|
|
e.type = KP_RECT;
|
|
} else
|
|
break;
|
|
ret = 1;
|
|
}
|
|
// ast_log(LOG_WARNING, "reading [%s] returns %d %d\n", val, i, ret);
|
|
if (ret == 0)
|
|
return 0;
|
|
if (gui->kp_size == 0) {
|
|
gui->kp = ast_calloc(10, sizeof(e));
|
|
if (gui->kp == NULL) {
|
|
ast_log(LOG_WARNING, "cannot allocate kp");
|
|
return 0;
|
|
}
|
|
gui->kp_size = 10;
|
|
}
|
|
if (gui->kp_size == gui->kp_used) { /* must allocate */
|
|
struct keypad_entry *a = ast_realloc(gui->kp, sizeof(e)*(gui->kp_size+10));
|
|
if (a == NULL) {
|
|
ast_log(LOG_WARNING, "cannot reallocate kp");
|
|
return 0;
|
|
}
|
|
gui->kp = a;
|
|
gui->kp_size += 10;
|
|
}
|
|
if (gui->kp_size == gui->kp_used)
|
|
return 0;
|
|
gui->kp[gui->kp_used++] = e;
|
|
// ast_log(LOG_WARNING, "now %d regions\n", gui->kp_used);
|
|
return 1;
|
|
}
|
|
#endif /* HAVE_SDL */
|