channels/console_gui.c

   1 /*
   2  * GUI for console video.
   3  * The routines here are in charge of loading the keypad and handling events.
   4  * $Revision$
   5  */
   6
   7 /*
   8  * GUI layout, structure and management
   9
  10 For the GUI we use SDL to create a large surface (gui->screen)
  11 containing tree sections: remote video on the left, local video
  12 on the right, and the keypad with all controls and text windows
  13 in the center.
  14 The central section is built using an image for the skin, fonts and
  15 other GUI elements.  Comments embedded in the image to indicate to
  16 what function each area is mapped to.
  17
  18 Mouse and keyboard events are detected on the whole surface, and
  19 handled differently according to their location:
  20
  21 - drag on the local video window are used to move the captured
  22   area (in the case of X11 grabber) or the picture-in-picture
  23   location (in case of camera included on the X11 grab).
  24 - click on the keypad are mapped to the corresponding key;
  25 - drag on some keypad areas (sliders etc.) are mapped to the
  26   corresponding functions;
  27 - keystrokes are used as keypad functions, or as text input
  28   if we are in text-input mode.
  29
  30 Configuration options control the appeareance of the gui:
  31
  32     keypad = /tmp/phone.jpg     ; the skin
  33     keypad_font = /tmp/font.ttf ; the font to use for output (XXX deprecated)
  34
  35  *
  36  */
  37
  38 #include "asterisk.h"
  39 #include "console_video.h"
  40 #include "asterisk/lock.h"
  41 #include "asterisk/frame.h"
  42 #include "asterisk/utils.h"     /* ast_calloc and ast_realloc */
  43 #include <math.h>               /* sqrt */
  44
  45 /* We use 3 'windows' in the GUI */
  46 enum { WIN_LOCAL, WIN_REMOTE, WIN_KEYPAD, WIN_MAX };
  47
  48 #ifndef HAVE_SDL        /* stubs if we don't have any sdl */
  49 static void show_frame(struct video_desc *env, int out) {}
  50 static void sdl_setup(struct video_desc *env)           {}
  51 static struct gui_info *cleanup_sdl(struct gui_info *gui)       { return NULL; }
  52 static void eventhandler(struct video_desc *env, const char *caption)   {}
  53 static int keypad_cfg_read(struct gui_info *gui, const char *val)       { return 0; }
  54
  55 #else /* HAVE_SDL, the real rendering code */
  56
  57 #include <SDL/SDL.h>
  58 #include <SDL/SDL_syswm.h>
  59 #ifdef HAVE_SDL_IMAGE
  60 #include <SDL/SDL_image.h>      /* for loading images */
  61 #endif
  62
  63 #ifdef HAVE_X11
  64 /* Need to hook into X for SDL_WINDOWID handling */
  65 #include <X11/Xlib.h>
  66 #endif
  67
  68 enum kp_type { KP_NONE, KP_RECT, KP_CIRCLE };
  69 struct keypad_entry {
  70         int c;  /* corresponding character */
  71         int x0, y0, x1, y1, h;  /* arguments */
  72         enum kp_type type;
  73 };
  74
  75 /* our representation of a displayed window. SDL can only do one main
  76  * window so we map everything within that one
  77  */
  78 struct display_window   {
  79         SDL_Overlay     *bmp;
  80         SDL_Rect        rect;   /* location of the window */
  81 };
  82
  83 struct gui_info {
  84         enum kb_output          kb_output;      /* where the keyboard output goes */
  85         struct drag_info        drag;           /* info on the window are we dragging */
  86         /* support for display. */
  87         SDL_Surface             *screen;        /* the main window */
  88
  89         int                     outfd;          /* fd for output */
  90         SDL_Surface             *keypad;        /* the skin for the keypad */
  91         SDL_Rect                kp_rect;        /* portion of the skin to display - default all */
  92         SDL_Surface             *font;          /* font to be used */
  93         SDL_Rect                font_rects[96]; /* only printable chars */
  94
  95         /* each board has two rectangles,
  96          * [0] is the geometry relative to the keypad,
  97          * [1] is the geometry relative to the whole screen
  98          */
  99         SDL_Rect                kp_msg[2];              /* incoming msg, relative to kpad */
 100         struct board            *bd_msg;
 101
 102         SDL_Rect                kp_edit[2];     /* edit user input */
 103         struct board            *bd_edit;
 104
 105         SDL_Rect                kp_dialed[2];   /* dialed number */
 106         struct board            *bd_dialed;
 107
 108         /* variable-size array mapping keypad regions to functions */
 109         int kp_size, kp_used;
 110         struct keypad_entry *kp;
 111
 112         struct display_window   win[WIN_MAX];
 113 };
 114
 115 /*! \brief free the resources in struct gui_info and the descriptor itself.
 116  *  Return NULL so we can assign the value back to the descriptor in case.
 117  */
 118 static struct gui_info *cleanup_sdl(struct gui_info *gui)
 119 {
 120         int i;
 121
 122         if (gui == NULL)
 123                 return NULL;
 124
 125         /* unload font file */
 126         if (gui->font) {
 127                 SDL_FreeSurface(gui->font);
 128                 gui->font = NULL;
 129         }
 130
 131         if (gui->outfd > -1)
 132                 close(gui->outfd);
 133         if (gui->keypad)
 134                 SDL_FreeSurface(gui->keypad);
 135         gui->keypad = NULL;
 136         if (gui->kp)
 137                 ast_free(gui->kp);
 138
 139         /* uninitialize the SDL environment */
 140         for (i = 0; i < WIN_MAX; i++) {
 141                 if (gui->win[i].bmp)
 142                         SDL_FreeYUVOverlay(gui->win[i].bmp);
 143         }
 144         bzero(gui, sizeof(gui));
 145         ast_free(gui);
 146         SDL_Quit();
 147         return NULL;
 148 }
 149
 150 /*
 151  * Display video frames (from local or remote stream) using the SDL library.
 152  * - Set the video mode to use the resolution specified by the codec context
 153  * - Create a YUV Overlay to copy the frame into it;
 154  * - After the frame is copied into the overlay, display it
 155  *
 156  * The size is taken from the configuration.
 157  *
 158  * 'out' is 0 for remote video, 1 for the local video
 159  */
 160 static void show_frame(struct video_desc *env, int out)
 161 {
 162         AVPicture *p_in, p_out;
 163         struct fbuf_t *b_in, *b_out;
 164         SDL_Overlay *bmp;
 165         struct gui_info *gui = env->gui;
 166
 167         if (!gui)
 168                 return;
 169
 170         if (out == WIN_LOCAL) { /* webcam/x11 to sdl */
 171                 b_in = &env->enc_in;
 172                 b_out = &env->loc_dpy;
 173                 p_in = NULL;
 174         } else {
 175                 /* copy input format from the decoding context */
 176                 AVCodecContext *c;
 177                 if (env->in == NULL)    /* XXX should not happen - decoder not ready */
 178                         return;
 179                 c = env->in->dec_ctx;
 180                 b_in = &env->in->dec_out;
 181                 b_in->pix_fmt = c->pix_fmt;
 182                 b_in->w = c->width;
 183                 b_in->h = c->height;
 184
 185                 b_out = &env->rem_dpy;
 186                 p_in = (AVPicture *)env->in->d_frame;
 187         }
 188         bmp = gui->win[out].bmp;
 189         SDL_LockYUVOverlay(bmp);
 190         /* output picture info - this is sdl, YUV420P */
 191         bzero(&p_out, sizeof(p_out));
 192         p_out.data[0] = bmp->pixels[0];
 193         p_out.data[1] = bmp->pixels[1];
 194         p_out.data[2] = bmp->pixels[2];
 195         p_out.linesize[0] = bmp->pitches[0];
 196         p_out.linesize[1] = bmp->pitches[1];
 197         p_out.linesize[2] = bmp->pitches[2];
 198
 199         my_scale(b_in, p_in, b_out, &p_out);
 200
 201         /* lock to protect access to Xlib by different threads. */
 202         SDL_DisplayYUVOverlay(bmp, &gui->win[out].rect);
 203         SDL_UnlockYUVOverlay(bmp);
 204 }
 205
 206 /*
 207  * Identifiers for regions of the main window.
 208  * Values between 0 and 127 correspond to ASCII characters.
 209  * The corresponding strings to be used in the skin comment section
 210  * are defined in gui_key_map.
 211  */
 212 enum skin_area {
 213         /* answer/close functions */
 214         KEY_PICK_UP = 128,
 215         KEY_HANG_UP = 129,
 216
 217         KEY_MUTE = 130,
 218         KEY_AUTOANSWER = 131,
 219         KEY_SENDVIDEO = 132,
 220         KEY_LOCALVIDEO = 133,
 221         KEY_REMOTEVIDEO = 134,
 222         KEY_FLASH = 136,
 223
 224         /* sensitive areas for the various text windows */
 225         KEY_MESSAGEBOARD = 140,
 226         KEY_DIALEDBOARD = 141,
 227         KEY_EDITBOARD = 142,
 228
 229         KEY_GUI_CLOSE = 199,            /* close gui */
 230         /* regions of the skin - displayed area, fonts, etc.
 231          * XXX NOTE these are not sensitive areas.
 232          */
 233         KEY_KEYPAD = 200,               /* the keypad - default to the whole image */
 234         KEY_FONT = 201,         /* the font. Maybe not really useful */
 235         KEY_MESSAGE = 202,      /* area for incoming messages */
 236         KEY_DIALED = 203,       /* area for dialed numbers */
 237         KEY_EDIT = 204,         /* area for editing user input */
 238
 239         /* areas outside the keypad - simulated */
 240         KEY_OUT_OF_KEYPAD = 241,
 241         KEY_REM_DPY = 242,
 242         KEY_LOC_DPY = 243,
 243         KEY_RESET = 253,                /* the 'reset' keyword */
 244         KEY_NONE = 254,                 /* invalid area */
 245         KEY_DIGIT_BACKGROUND = 255,     /* other areas within the keypad */
 246 };
 247
 248 /*
 249  * Handlers for the various keypad functions
 250  */
 251
 252 /* accumulate digits, possibly call dial if in connected mode */
 253 static void keypad_digit(struct video_desc *env, int digit)
 254 {
 255         if (env->owner) {               /* we have a call, send the digit */
 256                 struct ast_frame f = { AST_FRAME_DTMF, 0 };
 257
 258                 f.subclass = digit;
 259                 ast_queue_frame(env->owner, &f);
 260         } else {                /* no call, accumulate digits */
 261                 char buf[2] = { digit, '\0' };
 262                 if (env->gui->bd_msg) /* XXX not strictly necessary ... */
 263                         print_message(env->gui->bd_msg, buf);
 264         }
 265 }
 266
 267 /* function used to toggle on/off the status of some variables */
 268 static char *keypad_toggle(struct video_desc *env, int index)
 269 {
 270         ast_log(LOG_WARNING, "keypad_toggle(%i) called\n", index);
 271
 272         switch (index) {
 273         case KEY_SENDVIDEO:
 274                 env->out.sendvideo = !env->out.sendvideo;
 275                 break;
 276 #ifdef notyet
 277         case KEY_MUTE: {
 278                 struct chan_oss_pvt *o = find_desc(oss_active);
 279                 o->mute = !o->mute;
 280                 }
 281                 break;
 282         case KEY_AUTOANSWER: {
 283                 struct chan_oss_pvt *o = find_desc(oss_active);
 284                 o->autoanswer = !o->autoanswer;
 285                 }
 286                 break;
 287 #endif
 288         }
 289         return NULL;
 290 }
 291
 292 char *console_do_answer(int fd);
 293 /*
 294  * Function called when the pick up button is pressed
 295  * perform actions according the channel status:
 296  *
 297  *  - if no one is calling us and no digits was pressed,
 298  *    the operation have no effects,
 299  *  - if someone is calling us we answer to the call.
 300  *  - if we have no call in progress and we pressed some
 301  *    digit, send the digit to the console.
 302  */
 303 static void keypad_pick_up(struct video_desc *env)
 304 {
 305         struct gui_info *gui = env->gui;
 306
 307         ast_log(LOG_WARNING, "keypad_pick_up called\n");
 308
 309         if (env->owner) { /* someone is calling us, just answer */
 310                 ast_cli_command(gui->outfd, "console answer");
 311         } else { /* we have someone to call */
 312                 char buf[160];
 313                 const char *who = ast_skip_blanks(read_message(gui->bd_msg));
 314                 buf[sizeof(buf) - 1] = '\0';
 315                 snprintf(buf, sizeof(buf), "console dial %s", who);
 316                 ast_log(LOG_WARNING, "doing <%s>\n", buf);
 317                 print_message(gui->bd_dialed, "\n");
 318                 print_message(gui->bd_dialed, who);
 319                 reset_board(gui->bd_msg);
 320                 ast_cli_command(gui->outfd, buf);
 321         }
 322 }
 323
 324 #if 0 /* still unused */
 325 /*
 326  * As an alternative to SDL_TTF, we can simply load the font from
 327  * an image and blit characters on the background of the GUI.
 328  *
 329  * To generate a font we can use the 'fly' command with the
 330  * following script (3 lines with 32 chars each)
 331
 332 size 320,64
 333 name font.png
 334 transparent 0,0,0
 335 string 255,255,255,  0, 0,giant, !"#$%&'()*+,-./0123456789:;<=>?
 336 string 255,255,255,  0,20,giant,@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
 337 string 255,255,255,  0,40,giant,`abcdefghijklmnopqrstuvwxyz{|}~
 338 end
 339
 340  */
 341
 342 /* Print given text on the gui */
 343 static int gui_output(struct video_desc *env, const char *text)
 344 {
 345         return 1;       /* error, not supported */
 346 }
 347 #endif
 348
 349 static int video_geom(struct fbuf_t *b, const char *s);
 350 static void sdl_setup(struct video_desc *env);
 351 static int kp_match_area(const struct keypad_entry *e, int x, int y);
 352
 353 static void set_drag(struct drag_info *drag, int x, int y, enum drag_window win)
 354 {
 355         drag->x_start = x;
 356         drag->y_start = y;
 357         drag->drag_window = win;
 358 }
 359
 360 /*
 361  * Handle SDL_MOUSEBUTTONDOWN type, finding the palette
 362  * index value and calling the right callback.
 363  *
 364  * x, y are referred to the upper left corner of the main SDL window.
 365  */
 366 static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button)
 367 {
 368         uint8_t index = KEY_OUT_OF_KEYPAD;      /* the key or region of the display we clicked on */
 369         struct gui_info *gui = env->gui;
 370
 371 #if 0
 372         ast_log(LOG_WARNING, "event %d %d have %d/%d regions at %p\n",
 373                 button.x, button.y, gui->kp_used, gui->kp_size, gui->kp);
 374 #endif
 375         /* for each mousedown we end previous drag */
 376         gui->drag.drag_window = DRAG_NONE;
 377
 378         /* define keypad boundary */
 379         if (button.x < env->rem_dpy.w)
 380                 index = KEY_REM_DPY; /* click on remote video */
 381         else if (button.x > env->rem_dpy.w + gui->keypad->w)
 382                 index = KEY_LOC_DPY; /* click on local video */
 383         else if (button.y > gui->keypad->h)
 384                 index = KEY_OUT_OF_KEYPAD; /* click outside the keypad */
 385         else if (gui->kp) {
 386                 int i;
 387                 for (i = 0; i < gui->kp_used; i++) {
 388                         if (kp_match_area(&gui->kp[i], button.x - env->rem_dpy.w, button.y)) {
 389                                 index = gui->kp[i].c;
 390                                 break;
 391                         }
 392                 }
 393         }
 394
 395         /* exec the function */
 396         if (index < 128) {      /* surely clicked on the keypad, don't care which key */
 397                 keypad_digit(env, index);
 398                 return;
 399         }
 400         switch (index) {
 401         /* answer/close function */
 402         case KEY_PICK_UP:
 403                 keypad_pick_up(env);
 404                 break;
 405         case KEY_HANG_UP:
 406                 ast_cli_command(gui->outfd, "console hangup");
 407                 break;
 408
 409         /* other functions */
 410         case KEY_MUTE:
 411         case KEY_AUTOANSWER:
 412         case KEY_SENDVIDEO:
 413                 keypad_toggle(env, index);
 414                 break;
 415
 416         case KEY_LOCALVIDEO:
 417                 break;
 418         case KEY_REMOTEVIDEO:
 419                 break;
 420
 421         case KEY_MESSAGEBOARD:
 422                 if (button.button == SDL_BUTTON_LEFT)
 423                         set_drag(&gui->drag, button.x, button.y, DRAG_MESSAGE);
 424                 break;
 425
 426         /* press outside the keypad. right increases size, center decreases, left drags */
 427         case KEY_LOC_DPY:
 428         case KEY_REM_DPY:
 429                 if (button.button == SDL_BUTTON_LEFT) {
 430                         if (index == KEY_LOC_DPY)
 431                                 set_drag(&gui->drag, button.x, button.y, DRAG_LOCAL);
 432                         break;
 433                 } else {
 434                         char buf[128];
 435                         struct fbuf_t *fb = index == KEY_LOC_DPY ? &env->loc_dpy : &env->rem_dpy;
 436                         sprintf(buf, "%c%dx%d", button.button == SDL_BUTTON_RIGHT ? '>' : '<',
 437                                 fb->w, fb->h);
 438                         video_geom(fb, buf);
 439                         sdl_setup(env);
 440                 }
 441                 break;
 442         case KEY_OUT_OF_KEYPAD:
 443                 break;
 444
 445         case KEY_DIGIT_BACKGROUND:
 446                 break;
 447         default:
 448                 ast_log(LOG_WARNING, "function not yet defined %i\n", index);
 449         }
 450 }
 451
 452 /*
 453  * Handle SDL_KEYDOWN type event, put the key pressed
 454  * in the dial buffer or in the text-message buffer,
 455  * depending on the text_mode variable value.
 456  *
 457  * key is the SDLKey structure corresponding to the key pressed.
 458  * Note that SDL returns modifiers (ctrl, shift, alt) as independent
 459  * information so the key itself is not enough and we need to
 460  * use a translation table, below - one line per entry,
 461  * plain, shift, ctrl, ... using the first char as key.
 462  */
 463 static const char *us_kbd_map[] = {
 464         "`~", "1!", "2@", "3#", "4$", "5%", "6^",
 465         "7&", "8*", "9(", "0)", "-_", "=+", "[{",
 466         "]}", "\\|", ";:", "'\"", ",<", ".>", "/?",
 467         "jJ\n",
 468         NULL
 469 };
 470
 471 static char map_key(SDL_keysym *ks)
 472 {
 473         const char *s, **p = us_kbd_map;
 474         int c = ks->sym;
 475
 476         if (c == '\r')  /* map cr into lf */
 477                 c = '\n';
 478         if (c >= SDLK_NUMLOCK && c <= SDLK_COMPOSE)
 479                 return 0;       /* only a modifier */
 480         if (ks->mod == 0)
 481                 return c;
 482         while ((s = *p) && s[0] != c)
 483                 p++;
 484         if (s) { /* see if we have a modifier and a chance to use it */
 485                 int l = strlen(s), mod = 0;
 486                 if (l > 1)
 487                         mod |= (ks->mod & KMOD_SHIFT) ? 1 : 0;
 488                 if (l > 2 + mod)
 489                         mod |= (ks->mod & KMOD_CTRL) ? 2 : 0;
 490                 if (l > 4 + mod)
 491                         mod |= (ks->mod & KMOD_ALT) ? 4 : 0;
 492                 c = s[mod];
 493         }
 494         if (ks->mod & (KMOD_CAPS|KMOD_SHIFT) && c >= 'a' && c <='z')
 495                 c += 'A' - 'a';
 496         return c;
 497 }
 498
 499 static void handle_keyboard_input(struct video_desc *env, SDL_keysym *ks)
 500 {
 501         char buf[2] = { map_key(ks), '\0' };
 502         struct gui_info *gui = env->gui;
 503         if (buf[0] == 0)        /* modifier ? */
 504                 return;
 505         switch (gui->kb_output) {
 506         default:
 507                 break;
 508         case KO_INPUT:  /* to be completed */
 509                 break;
 510         case KO_MESSAGE:
 511                 if (gui->bd_msg) {
 512                         print_message(gui->bd_msg, buf);
 513                         if (buf[0] == '\r' || buf[0] == '\n') {
 514                                 keypad_pick_up(env);
 515                         }
 516                 }
 517                 break;
 518
 519         case KO_DIALED: /* to be completed */
 520                 break;
 521         }
 522
 523         return;
 524 }
 525
 526 static void grabber_move(struct video_out_desc *, int dx, int dy);
 527
 528 int compute_drag(int *start, int end, int magnifier);
 529 int compute_drag(int *start, int end, int magnifier)
 530 {
 531         int delta = end - *start;
 532 #define POLARITY -1
 533         /* add a small quadratic term */
 534         delta += delta * delta * (delta > 0 ? 1 : -1 )/100;
 535         delta *= POLARITY * magnifier;
 536 #undef POLARITY
 537         *start = end;
 538         return delta;
 539 }
 540
 541 /*
 542  * I am seeing some kind of deadlock or stall around
 543  * SDL_PumpEvents() while moving the window on a remote X server
 544  * (both xfree-4.4.0 and xorg 7.2)
 545  * and windowmaker. It is unclear what causes it.
 546  */
 547
 548 /*! \brief refresh the screen, and also grab a bunch of events.
 549  */
 550 static void eventhandler(struct video_desc *env, const char *caption)
 551 {
 552         struct gui_info *gui = env->gui;
 553         struct drag_info *drag;
 554 #define N_EVENTS        32
 555         int i, n;
 556         SDL_Event ev[N_EVENTS];
 557
 558         if (!gui)
 559                 return;
 560         drag = &gui->drag;
 561         if (caption)
 562                 SDL_WM_SetCaption(caption, NULL);
 563
 564 #define MY_EV (SDL_MOUSEBUTTONDOWN|SDL_KEYDOWN)
 565         while ( (n = SDL_PeepEvents(ev, N_EVENTS, SDL_GETEVENT, SDL_ALLEVENTS)) > 0) {
 566                 for (i = 0; i < n; i++) {
 567 #if 0
 568                         ast_log(LOG_WARNING, "------ event %d at %d %d\n",
 569                                 ev[i].type,  ev[i].button.x,  ev[i].button.y);
 570 #endif
 571                         switch (ev[i].type) {
 572                         default:
 573                                 ast_log(LOG_WARNING, "------ event %d at %d %d\n",
 574                                         ev[i].type,  ev[i].button.x,  ev[i].button.y);
 575                                 break;
 576
 577                         case SDL_ACTIVEEVENT:
 578                                 if (ev[i].active.gain == 0 && ev[i].active.state & SDL_APPACTIVE) {
 579                                         ast_log(LOG_WARNING, "/* somebody has killed us ? */");
 580                                         ast_cli_command(gui->outfd, "stop now");
 581                                 }
 582                                 break;
 583
 584                         case SDL_KEYUP: /* ignore, for the time being */
 585                                 break;
 586
 587                         case SDL_KEYDOWN:
 588                                 handle_keyboard_input(env, &ev[i].key.keysym);
 589                                 break;
 590
 591                         case SDL_MOUSEMOTION:
 592                         case SDL_MOUSEBUTTONUP:
 593                                 if (drag->drag_window == DRAG_LOCAL) {
 594                                         /* move the capture source */
 595                                         int dx = compute_drag(&drag->x_start, ev[i].motion.x, 3);
 596                                         int dy = compute_drag(&drag->y_start, ev[i].motion.y, 3);
 597                                         grabber_move(&env->out, dx, dy);
 598                                 } else if (drag->drag_window == DRAG_MESSAGE) {
 599                                         /* scroll up/down the window */
 600                                         int dy = compute_drag(&drag->y_start, ev[i].motion.y, 1);
 601                                         move_message_board(gui->bd_msg, dy);
 602                                 }
 603                                 if (ev[i].type == SDL_MOUSEBUTTONUP)
 604                                         drag->drag_window = DRAG_NONE;
 605                                 break;
 606                         case SDL_MOUSEBUTTONDOWN:
 607                                 handle_mousedown(env, ev[i].button);
 608                                 break;
 609                         }
 610                 }
 611         }
 612         if (1) {
 613                 struct timeval b, a = ast_tvnow();
 614                 int i;
 615                 //SDL_Lock_EventThread();
 616                 SDL_PumpEvents();
 617                 b = ast_tvnow();
 618                 i = ast_tvdiff_ms(b, a);
 619                 if (i > 3)
 620                         fprintf(stderr, "-------- SDL_PumpEvents took %dms\n", i);
 621                 //SDL_Unlock_EventThread();
 622         }
 623 }
 624
 625 static SDL_Surface *load_image(const char *file)
 626 {
 627         SDL_Surface *temp;
 628
 629 #ifdef HAVE_SDL_IMAGE
 630         temp = IMG_Load(file);
 631 #else
 632         temp = SDL_LoadBMP(file);
 633 #endif
 634         if (temp == NULL)
 635                 fprintf(stderr, "Unable to load image %s: %s\n",
 636                         file, SDL_GetError());
 637         return temp;
 638 }
 639
 640 static void keypad_setup(struct gui_info *gui, const char *kp_file);
 641
 642 /* TODO: consistency checks, check for bpp, widht and height */
 643 /* Init the mask image used to grab the action. */
 644 static struct gui_info *gui_init(const char *keypad_file, const char *font)
 645 {
 646         struct gui_info *gui = ast_calloc(1, sizeof(*gui));
 647
 648         if (gui == NULL)
 649                 return NULL;
 650         /* initialize keypad status */
 651         gui->kb_output = KO_MESSAGE;    /* XXX temp */
 652         gui->drag.drag_window = DRAG_NONE;
 653         gui->outfd = -1;
 654
 655         keypad_setup(gui, keypad_file);
 656         if (gui->keypad == NULL)        /* no keypad, we are done */
 657                 return gui;
 658         /* XXX load image */
 659         if (!ast_strlen_zero(font)) {
 660                 int i;
 661                 SDL_Rect *r;
 662
 663                 gui->font = load_image(font);
 664                 if (!gui->font) {
 665                         ast_log(LOG_WARNING, "Unable to load font %s, no output available\n", font);
 666                         goto error;
 667                 }
 668                 ast_log(LOG_WARNING, "Loaded font %s\n", font);
 669                 /* XXX hardwired constants - 3 rows of 32 chars */
 670                 r = gui->font_rects;
 671 #define FONT_H 20
 672 #define FONT_W 9
 673                 for (i = 0; i < 96; r++, i++) {
 674                         r->x = (i % 32 ) * FONT_W;
 675                         r->y = (i / 32 ) * FONT_H;
 676                         r->w = FONT_W;
 677                         r->h = FONT_H;
 678                 }
 679         }
 680
 681         gui->outfd = open ("/dev/null", O_WRONLY);      /* discard output, temporary */
 682         if (gui->outfd < 0) {
 683                 ast_log(LOG_WARNING, "Unable output fd\n");
 684                 goto error;
 685         }
 686         return gui;
 687
 688 error:
 689         ast_free(gui);
 690         return NULL;
 691 }
 692
 693 /* setup an sdl overlay and associated info, return 0 on success, != 0 on error */
 694 static int set_win(SDL_Surface *screen, struct display_window *win, int fmt,
 695         int w, int h, int x, int y)
 696 {
 697         win->bmp = SDL_CreateYUVOverlay(w, h, fmt, screen);
 698         if (win->bmp == NULL)
 699                 return -1;      /* error */
 700         win->rect.x = x;
 701         win->rect.y = y;
 702         win->rect.w = w;
 703         win->rect.h = h;
 704         return 0;
 705 }
 706
 707 static int keypad_cfg_read(struct gui_info *gui, const char *val);
 708
 709 static void keypad_setup(struct gui_info *gui, const char *kp_file)
 710 {
 711         FILE *fd;
 712         char buf[1024];
 713         const char region[] = "region";
 714         int reg_len = strlen(region);
 715         int in_comment = 0;
 716
 717         if (gui->keypad)
 718                 return;
 719         gui->keypad = load_image(kp_file);
 720         if (!gui->keypad)
 721                 return;
 722         /* now try to read the keymap from the file. */
 723         fd = fopen(kp_file, "r");
 724         if (fd == NULL) {
 725                 ast_log(LOG_WARNING, "fail to open %s\n", kp_file);
 726                 return;
 727         }
 728         /*
 729          * If the keypad image has a comment field, try to read
 730          * the button location from there. The block must start with
 731          * a comment (or empty) line, and continue with entries like:
 732          *      region = token shape x0 y0 x1 y1 h
 733          *      ...
 734          * (basically, lines have the same format as config file entries).
 735          * You can add it to a jpeg file using wrjpgcom
 736          */
 737         while (fgets(buf, sizeof(buf), fd)) {
 738                 char *s;
 739
 740                 if (!strstr(buf, region)) { /* no keyword yet */
 741                         if (!in_comment)        /* still waiting for initial comment block */
 742                                 continue;
 743                         else
 744                                 break;
 745                 }
 746                 if (!in_comment) {      /* first keyword, reset previous entries */
 747                         keypad_cfg_read(gui, "reset");
 748                         in_comment = 1;
 749                 }
 750                 s = ast_skip_blanks(buf);
 751                 ast_trim_blanks(s);
 752                 if (memcmp(s, region, reg_len))
 753                         break;  /* keyword not found */
 754                 s = ast_skip_blanks(s + reg_len); /* space between token and '=' */
 755                 if (*s++ != '=')        /* missing separator */
 756                         break;
 757                 if (*s == '>')  /* skip '>' if present */
 758                         s++;
 759                 keypad_cfg_read(gui, ast_skip_blanks(s));
 760         }
 761         fclose(fd);
 762 }
 763
 764 struct board *board_setup(SDL_Surface *screen, SDL_Rect *dest,
 765         SDL_Surface *font, SDL_Rect *font_rects);
 766
 767 /*! \brief initialize the boards we have in the keypad */
 768 static void init_board(struct gui_info *gui, struct board **dst, SDL_Rect *r, int dx, int dy)
 769 {
 770         if (r[0].w == 0 || r[0].h == 0)
 771                 return; /* not available */
 772         r[1] = r[0];    /* copy geometry */
 773         r[1].x += dx;   /* add offset of main window */
 774         r[1].y += dy;
 775         if (*dst == NULL) {     /* initial call */
 776                 *dst = board_setup(gui->screen, &r[1], gui->font, gui->font_rects);
 777         } else {
 778                 /* call a refresh */
 779         }
 780 }
 781
 782 #ifdef HAVE_X11
 783 /*
 784  * SDL is not very robust on error handling, so we need to trap ourselves
 785  * at least the most obvious failure conditions, e.g. a bad SDL_WINDOWID.
 786  * As of sdl-1.2.13, SDL_SetVideoMode crashes with bad parameters, so
 787  * we need to do the explicit X calls to make sure the window is correct.
 788  * And around these calls, we must trap X errors.
 789  */
 790 static int my_x_handler(Display *d, XErrorEvent *e)
 791 {
 792         ast_log(LOG_WARNING, "%s error_code %d\n", __FUNCTION__, e->error_code);
 793         return 0;
 794 }
 795 #endif /* HAVE_X11 */
 796
 797 /*! \brief [re]set the main sdl window, useful in case of resize.
 798  * We can tell the first from subsequent calls from the value of
 799  * env->gui, which is NULL the first time.
 800  */
 801 static void sdl_setup(struct video_desc *env)
 802 {
 803         int dpy_fmt = SDL_IYUV_OVERLAY; /* YV12 causes flicker in SDL */
 804         int depth, maxw, maxh;
 805         const SDL_VideoInfo *info;
 806         int kp_w = 0, kp_h = 0; /* keypad width and height */
 807         struct gui_info *gui = env->gui;
 808
 809 #ifdef HAVE_X11
 810         const char *e = getenv("SDL_WINDOWID");
 811
 812         if (!ast_strlen_zero(e)) {
 813                 XWindowAttributes a;
 814                 int (*old_x_handler)(Display *d, XErrorEvent *e) = XSetErrorHandler(my_x_handler);
 815                 Display *d = XOpenDisplay(getenv("DISPLAY"));
 816                 long w = atol(e);
 817                 int success = w ? XGetWindowAttributes(d, w, &a) : 0;
 818
 819                 XSetErrorHandler(old_x_handler);
 820                 if (!success) {
 821                         ast_log(LOG_WARNING, "%s error in window\n", __FUNCTION__);
 822                         return;
 823                 }
 824         }
 825 #endif
 826         /*
 827          * initialize the SDL environment. We have one large window
 828          * with local and remote video, and a keypad.
 829          * At the moment we arrange them statically, as follows:
 830          * - on the left, the remote video;
 831          * - on the center, the keypad
 832          * - on the right, the local video
 833          * We need to read in the skin for the keypad before creating the main
 834          * SDL window, because the size is only known here.
 835          */
 836
 837         if (gui == NULL && SDL_Init(SDL_INIT_VIDEO)) {
 838                 ast_log(LOG_WARNING, "Could not initialize SDL - %s\n",
 839                         SDL_GetError());
 840                 /* again not fatal, just we won't display anything */
 841                 return;
 842         }
 843         info = SDL_GetVideoInfo();
 844         /* We want at least 16bpp to support YUV overlays.
 845          * E.g with SDL_VIDEODRIVER = aalib the default is 8
 846          */
 847         if (!info || !info->vfmt) {
 848                 ast_log(LOG_WARNING, "Bad SDL_GetVideoInfo - %s\n",
 849                         SDL_GetError());
 850                 return;
 851         }
 852         depth = info->vfmt->BitsPerPixel;
 853         if (depth < 16)
 854                 depth = 16;
 855         if (!gui)
 856                 env->gui = gui = gui_init(env->keypad_file, env->keypad_font);
 857         if (!gui)
 858                 goto no_sdl;
 859
 860         if (gui->keypad) {
 861                 if (gui->kp_rect.w > 0 && gui->kp_rect.h > 0) {
 862                         kp_w = gui->kp_rect.w;
 863                         kp_h = gui->kp_rect.h;
 864                 } else {
 865                         kp_w = gui->keypad->w;
 866                         kp_h = gui->keypad->h;
 867                 }
 868         }
 869         /* XXX same for other boards */
 870 #define BORDER  5       /* border around our windows */
 871         maxw = env->rem_dpy.w + env->loc_dpy.w + kp_w;
 872         maxh = MAX( MAX(env->rem_dpy.h, env->loc_dpy.h), kp_h);
 873         maxw += 4 * BORDER;
 874         maxh += 2 * BORDER;
 875
 876         gui->screen = SDL_SetVideoMode(maxw, maxh, depth, 0);
 877         if (!gui->screen) {
 878                 ast_log(LOG_ERROR, "SDL: could not set video mode - exiting\n");
 879                 goto no_sdl;
 880         }
 881
 882 #ifdef HAVE_X11
 883         /*
 884          * Annoying as it may be, if SDL_WINDOWID is set, SDL does
 885          * not grab keyboard/mouse events or expose or other stuff,
 886          * and it does not handle resize either.
 887          * So we need to implement workarounds here.
 888          */
 889     do {
 890         /* First, handle the event mask */
 891         XWindowAttributes attr;
 892         long want;
 893         SDL_SysWMinfo info;
 894         Display *SDL_Display;
 895         Window win;
 896
 897         const char *e = getenv("SDL_WINDOWID");
 898         if (ast_strlen_zero(e))  /* no external window, don't bother doing this */
 899                 break;
 900         SDL_VERSION(&info.version); /* it is important to set the version */
 901         if (SDL_GetWMInfo(&info) != 1) {
 902                 fprintf(stderr, "no wm info\n");
 903                 break;
 904         }
 905         SDL_Display = info.info.x11.display;
 906         if (SDL_Display == NULL)
 907                 break;
 908         win = info.info.x11.window;
 909
 910         /*
 911          * A list of events we want.
 912          * Leave ResizeRedirectMask to the parent.
 913          */
 914         want = KeyPressMask | KeyReleaseMask | ButtonPressMask |
 915                            ButtonReleaseMask | EnterWindowMask |
 916                            LeaveWindowMask | PointerMotionMask |
 917                            Button1MotionMask |
 918                            Button2MotionMask | Button3MotionMask |
 919                            Button4MotionMask | Button5MotionMask |
 920                            ButtonMotionMask | KeymapStateMask |
 921                            ExposureMask | VisibilityChangeMask |
 922                            StructureNotifyMask | /* ResizeRedirectMask | */
 923                            SubstructureNotifyMask | SubstructureRedirectMask |
 924                            FocusChangeMask | PropertyChangeMask |
 925                            ColormapChangeMask | OwnerGrabButtonMask;
 926
 927         bzero(&attr, sizeof(attr));
 928         XGetWindowAttributes(SDL_Display, win, &attr);
 929
 930         /* the following events can be delivered only to one client.
 931          * So check which ones are going to someone else, and drop
 932          * them from our request.
 933          */
 934         {
 935         /* ev are the events for a single recipient */
 936         long ev = ButtonPressMask | ResizeRedirectMask |
 937                         SubstructureRedirectMask;
 938         ev &= (attr.all_event_masks & ~attr.your_event_mask);
 939         /* now ev contains 1 for single-recipient events owned by others.
 940          * We must clear those bits in 'want'
 941          * and then add the bits in 'attr.your_event_mask' to 'want'
 942          */
 943         want &= ~ev;
 944         want |= attr.your_event_mask;
 945         }
 946         XSelectInput(SDL_Display, win, want);
 947
 948         /* Second, handle resize.
 949          * We do part of the things that X11Resize does,
 950          * but also generate a ConfigureNotify event so
 951          * the owner of the window has a chance to do something
 952          * with it.
 953          */
 954         XResizeWindow(SDL_Display, win, maxw, maxh);
 955         {
 956         XConfigureEvent ce = {
 957                 .type = ConfigureNotify,
 958                 .serial = 0,
 959                 .send_event = 1,        /* TRUE */
 960                 .display = SDL_Display,
 961                 .event = win,
 962                 .window = win,
 963                 .x = 0,
 964                 .y = 0,
 965                 .width = maxw,
 966                 .height = maxh,
 967                 .border_width = 0,
 968                 .above = 0,
 969                 .override_redirect = 0 };
 970         XSendEvent(SDL_Display, win, 1 /* TRUE */, StructureNotifyMask, (XEvent *)&ce);
 971         }
 972     } while (0);
 973 #endif /* HAVE_X11 */
 974         SDL_WM_SetCaption("Asterisk console Video Output", NULL);
 975         if (set_win(gui->screen, &gui->win[WIN_REMOTE], dpy_fmt,
 976                         env->rem_dpy.w, env->rem_dpy.h, BORDER, BORDER))
 977                 goto no_sdl;
 978         if (set_win(gui->screen, &gui->win[WIN_LOCAL], dpy_fmt,
 979                         env->loc_dpy.w, env->loc_dpy.h,
 980                         3*BORDER+env->rem_dpy.w + kp_w, BORDER))
 981                 goto no_sdl;
 982
 983         /* display the skin, but do not free it as we need it later to
 984          * restore text areas and maybe sliders too.
 985          */
 986         if (gui->keypad) {
 987                 struct SDL_Rect *dest = &gui->win[WIN_KEYPAD].rect;
 988                 struct SDL_Rect *src = (gui->kp_rect.w > 0 && gui->kp_rect.h > 0) ? & gui->kp_rect : NULL;
 989                 /* set the coordinates of the keypad relative to the main screen */
 990                 dest->x = 2*BORDER + env->rem_dpy.w;
 991                 dest->y = BORDER;
 992                 dest->w = kp_w;
 993                 dest->h = kp_h;
 994                 SDL_BlitSurface(gui->keypad, src, gui->screen, dest);
 995                 init_board(gui, &gui->bd_msg, gui->kp_msg, dest->x, dest->y);
 996                 init_board(gui, &gui->bd_dialed, gui->kp_dialed, dest->x, dest->y);
 997                 SDL_UpdateRects(gui->screen, 1, dest);
 998         }
 999         return;
1000
1001 no_sdl:
1002         /* free resources in case of errors */
1003         env->gui = cleanup_sdl(gui);
1004 }
1005
1006 /*
1007  * Functions to determine if a point is within a region. Return 1 if success.
1008  * First rotate the point, with
1009  *      x' =  (x - x0) * cos A + (y - y0) * sin A
1010  *      y' = -(x - x0) * sin A + (y - y0) * cos A
1011  * where cos A = (x1-x0)/l, sin A = (y1 - y0)/l, and
1012  *      l = sqrt( (x1-x0)^2 + (y1-y0)^2
1013  * Then determine inclusion by simple comparisons i.e.:
1014  *      rectangle: x >= 0 && x < l && y >= 0 && y < h
1015  *      ellipse: (x-xc)^2/l^2 + (y-yc)^2/h2 < 1
1016  */
1017 static int kp_match_area(const struct keypad_entry *e, int x, int y)
1018 {
1019         double xp, dx = (e->x1 - e->x0);
1020         double yp, dy = (e->y1 - e->y0);
1021         double l = sqrt(dx*dx + dy*dy);
1022         int ret = 0;
1023
1024         if (l > 1) { /* large enough */
1025                 xp = ((x - e->x0)*dx + (y - e->y0)*dy)/l;
1026                 yp = (-(x - e->x0)*dy + (y - e->y0)*dx)/l;
1027                 if (e->type == KP_RECT) {
1028                         ret = (xp >= 0 && xp < l && yp >=0 && yp < l);
1029                 } else if (e->type == KP_CIRCLE) {
1030                         dx = xp*xp/(l*l) + yp*yp/(e->h*e->h);
1031                         ret = (dx < 1);
1032                 }
1033         }
1034 #if 0
1035         ast_log(LOG_WARNING, "result %d [%d] for match %d,%d in type %d p0 %d,%d p1 %d,%d h %d\n",
1036                 ret, e->c, x, y, e->type, e->x0, e->y0, e->x1, e->y1, e->h);
1037 #endif
1038         return ret;
1039 }
1040
1041 struct _s_k { const char *s; int k; };
1042 static struct _s_k gui_key_map[] = {
1043         {"PICK_UP",     KEY_PICK_UP },
1044         {"PICKUP",      KEY_PICK_UP },
1045         {"HANG_UP",     KEY_HANG_UP },
1046         {"HANGUP",      KEY_HANG_UP },
1047         {"MUTE",        KEY_MUTE },
1048         {"FLASH",       KEY_FLASH },
1049         {"AUTOANSWER",  KEY_AUTOANSWER },
1050         {"SENDVIDEO",   KEY_SENDVIDEO },
1051         {"LOCALVIDEO",  KEY_LOCALVIDEO },
1052         {"REMOTEVIDEO", KEY_REMOTEVIDEO },
1053         {"GUI_CLOSE",   KEY_GUI_CLOSE },
1054         {"MESSAGEBOARD",        KEY_MESSAGEBOARD },
1055         {"DIALEDBOARD", KEY_DIALEDBOARD },
1056         {"EDITBOARD",   KEY_EDITBOARD },
1057         {"KEYPAD",      KEY_KEYPAD },   /* x0 y0 w h - active area of the keypad */
1058         {"MESSAGE",     KEY_MESSAGE },  /* x0 y0 w h - incoming messages */
1059         {"DIALED",      KEY_DIALED },   /* x0 y0 w h - dialed number */
1060         {"EDIT",        KEY_EDIT },     /* x0 y0 w h - edit user input */
1061         {"FONT",        KEY_FONT },     /* x0 yo w h rows cols - location and format of the font */
1062         {NULL, 0 } };
1063
1064 static int gui_map_token(const char *s)
1065 {
1066         /* map the string into token to be returned */
1067         int i = atoi(s);
1068         struct _s_k *p;
1069         if (i > 0 || s[1] == '\0')      /* numbers or single characters */
1070                 return (i > 9) ? i : s[0];
1071         for (p = gui_key_map; p->s; p++) {
1072                 if (!strcasecmp(p->s, s))
1073                         return p->k;
1074         }
1075         return KEY_NONE;        /* not found */
1076 }
1077
1078 /*! \brief read a keypad entry line in the format
1079  *      reset
1080  *      token circle xc yc diameter
1081  *      token circle xc yc x1 y1 h      # ellipse, main diameter and height
1082  *      token rect x0 y0 x1 y1 h        # rectangle with main side and eight
1083  * token is the token to be returned, either a character or a symbol
1084  * as KEY_* above
1085  * Return 1 on success, 0 on error.
1086  */
1087 static int keypad_cfg_read(struct gui_info *gui, const char *val)
1088 {
1089         struct keypad_entry e;
1090         SDL_Rect *r = NULL;
1091         char s1[16], s2[16];
1092         int i, ret = 0; /* default, error */
1093
1094         if (gui == NULL || val == NULL)
1095                 return 0;
1096
1097         s1[0] = s2[0] = '\0';
1098         bzero(&e, sizeof(e));
1099         i = sscanf(val, "%14s %14s %d %d %d %d %d",
1100                 s1, s2, &e.x0, &e.y0, &e.x1, &e.y1, &e.h);
1101
1102         e.c = gui_map_token(s1);
1103         if (e.c == KEY_NONE)
1104                 return 0;       /* nothing found */
1105         switch (i) {
1106         default:
1107                 break;
1108         case 1: /* only "reset" is allowed */
1109                 if (e.c != KEY_RESET)
1110                         break;
1111                 if (gui->kp)
1112                         gui->kp_used = 0;
1113                 break;
1114         case 5:
1115                 if (e.c == KEY_KEYPAD)  /* active keypad area */
1116                         r = &gui->kp_rect;
1117                 else if (e.c == KEY_MESSAGE)
1118                         r = gui->kp_msg;
1119                 else if (e.c == KEY_DIALED)
1120                         r = gui->kp_dialed;
1121                 else if (e.c == KEY_EDIT)
1122                         r = gui->kp_edit;
1123                 if (r) {
1124                         r->x = atoi(s2);
1125                         r->y = e.x0;
1126                         r->w = e.y0;
1127                         r->h = e.x1;
1128                         break;
1129                 }
1130                 if (strcasecmp(s2, "circle"))   /* invalid */
1131                         break;
1132                 /* token circle xc yc diameter */
1133                 e.h = e.x1;
1134                 e.y1 = e.y0;    /* map radius in x1 y1 */
1135                 e.x1 = e.x0 + e.h;      /* map radius in x1 y1 */
1136                 e.x0 = e.x0 - e.h;      /* map radius in x1 y1 */
1137                 /* fallthrough */
1138
1139         case 7:
1140                 if (e.c == KEY_FONT) {  /* font - x0 y0 w h rows cols */
1141                         ast_log(LOG_WARNING, "font not supported yet\n");
1142                         break;
1143                 }
1144                 /* token circle|rect x0 y0 x1 y1 h */
1145                 if (e.x1 < e.x0 || e.h <= 0) {
1146                         ast_log(LOG_WARNING, "error in coordinates\n");
1147                         e.type = 0;
1148                         break;
1149                 }
1150                 if (!strcasecmp(s2, "circle")) {
1151                         /* for a circle we specify the diameter but store center and radii */
1152                         e.type = KP_CIRCLE;
1153                         e.x0 = (e.x1 + e.x0) / 2;
1154                         e.y0 = (e.y1 + e.y0) / 2;
1155                         e.h = e.h / 2;
1156                 } else if (!strcasecmp(s2, "rect")) {
1157                         e.type = KP_RECT;
1158                 } else
1159                         break;
1160                 ret = 1;
1161         }
1162         // ast_log(LOG_WARNING, "reading [%s] returns %d %d\n", val, i, ret);
1163         if (ret == 0)
1164                 return 0;
1165         if (gui->kp_size == 0) {
1166                 gui->kp = ast_calloc(10, sizeof(e));
1167                 if (gui->kp == NULL) {
1168                         ast_log(LOG_WARNING, "cannot allocate kp");
1169                         return 0;
1170                 }
1171                 gui->kp_size = 10;
1172         }
1173         if (gui->kp_size == gui->kp_used) { /* must allocate */
1174                 struct keypad_entry *a = ast_realloc(gui->kp, sizeof(e)*(gui->kp_size+10));
1175                 if (a == NULL) {
1176                         ast_log(LOG_WARNING, "cannot reallocate kp");
1177                         return 0;
1178                 }
1179                 gui->kp = a;
1180                 gui->kp_size += 10;
1181         }
1182         if (gui->kp_size == gui->kp_used)
1183                 return 0;
1184         gui->kp[gui->kp_used++] = e;
1185         // ast_log(LOG_WARNING, "now %d regions\n", gui->kp_used);
1186         return 1;
1187 }
1188 #endif  /* HAVE_SDL */