chan_unistim: Unlock mutex in rare OOM condition.
[asterisk/asterisk.git] / channels / console_gui.c
index 1f6c4eb..916c408 100644 (file)
@@ -7,34 +7,81 @@
 /*
  * 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.
+For the GUI we use SDL to create a large surface (gui->screen) with 4 areas:
+remote video on the left, local video on the right, keypad with all controls
+and text windows in the center, and source device thumbnails on the top.
+The top row is not displayed if no devices are specified in the config file.
+
+     ________________________________________________________________
+    |  ______   ______   ______   ______   ______   ______   ______  |
+    | | tn.1 | | tn.2 | | tn.3 | | tn.4 | | tn.5 | | tn.6 | | tn.7 | |
+    | |______| |______| |______| |______| |______| |______| |______| |
+    |  ______   ______   ______   ______   ______   ______   ______  |
+    | |______| |______| |______| |______| |______| |______| |______| |
+    |  _________________    __________________    _________________  |
+    | |                 |  |                  |  |                 | |
+    | |                 |  |                  |  |                 | |
+    | |                 |  |                  |  |                 | |
+    | |   remote video  |  |                  |  |   local video   | |
+    | |                 |  |                  |  |          ______ | |
+    | |                 |  |      keypad      |  |         |  PIP || |
+    | |                 |  |                  |  |         |______|| |
+    | |_________________|  |                  |  |_________________| |
+    |                      |                  |                      |
+    |                      |                  |                      |
+    |                      |__________________|                      |
+    |________________________________________________________________|
+
+
+The central section is built using an image (jpg, png, maybe gif too)
+for the skin, and other GUI elements.  Comments embedded in the image
+indicate to what function each area is mapped to.
+Another image (png with transparency) is used for the font.
 
 Mouse and keyboard events are detected on the whole surface, and
 handled differently according to their location:
-
+- center/right click on the local/remote window are used to resize
+  the corresponding window;
+- clicks on the thumbnail start/stop sources and select them as
+  primary or secondary video sources;
 - 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
+  area (in the case of X11 grabber) or the picture-in-picture position;
+- keystrokes on the keypad are mapped to the corresponding key;
+  keystrokes are used as keypad functions, or as text input
   if we are in text-input mode.
+- drag on some keypad areas (sliders etc.) are mapped to the
+  corresponding functions (mute/unmute audio and video,
+  enable/disable Picture-in-Picture, freeze the incoming video,
+  dial numbers, pick up or hang up a call, ...)
 
 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)
+    keypad = /tmp/kpad2.jpg    ; the skin
+    keypad_font = /tmp/font.png        ; the font to use for output
+
+For future implementation, intresting features can be the following:
+- save of the whole SDL window as a picture
+- audio output device switching
+
+The audio switching feature should allow changing the device
+or switching to a recorded message for audio sent to remote party.
+The selection of the device should happen clicking on a marker in the layout.
+For this reason above the thumbnails row in the layout we would like a new row,
+the elements composing the row could be message boards, reporting the name of the
+device or the path of the message to be played.
+
+For video input freeze and entire window capture, we define 2 new key types,
+those should be activated pressing the buttons on the keypad, associated with
+new regions inside the keypad pictureas comments
+
 
  *
  */
 
+/*** MODULEINFO
+       <support_level>extended</support_level>
+ ***/
+
 #include "asterisk.h"
 #include "console_video.h"
 #include "asterisk/lock.h"
@@ -42,13 +89,15 @@ Configuration options control the appeareance of the gui:
 #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 };
+/* We use a maximum of 12 'windows' in the GUI */
+enum { WIN_LOCAL, WIN_REMOTE, WIN_KEYPAD, WIN_SRC1,
+       WIN_SRC2, WIN_SRC3, WIN_SRC4, WIN_SRC5,
+       WIN_SRC6, WIN_SRC7, WIN_SRC8, WIN_SRC9, 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 struct gui_info *cleanup_sdl(struct gui_info* g, int n) { 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; }
 
@@ -65,6 +114,9 @@ static int keypad_cfg_read(struct gui_info *gui, const char *val)    { return 0; }
 #include <X11/Xlib.h>
 #endif
 
+#define BORDER 5               /* border around our windows */
+#define SRC_MSG_BD_H 20                /* height of the message board below those windows */
+
 enum kp_type { KP_NONE, KP_RECT, KP_CIRCLE };
 struct keypad_entry {
         int c;  /* corresponding character */
@@ -75,11 +127,18 @@ struct keypad_entry {
 /* our representation of a displayed window. SDL can only do one main
  * window so we map everything within that one
  */
-struct display_window   {   
+struct display_window {
        SDL_Overlay     *bmp;
        SDL_Rect        rect;   /* location of the window */
 };
 
+/* each thumbnail message board has a rectangle associated for the geometry,
+ * and a board structure, we include these two elements in a singole structure */
+struct thumb_bd {
+       SDL_Rect                rect;           /* the rect for geometry and background */
+       struct board            *board;         /* the board */
+};
+
 struct gui_info {
        enum kb_output          kb_output;      /* where the keyboard output goes */
        struct drag_info        drag;           /* info on the window are we dragging */
@@ -92,9 +151,11 @@ struct gui_info {
        SDL_Surface             *font;          /* font to be used */ 
        SDL_Rect                font_rects[96]; /* only printable chars */
 
-       /* each board has two rectangles,
+       /* each of the following board has two rectangles,
         * [0] is the geometry relative to the keypad,
         * [1] is the geometry relative to the whole screen
+        * we do not use the thumb_bd for these boards because here we need
+        * 2 rectangles for geometry
         */
        SDL_Rect                kp_msg[2];              /* incoming msg, relative to kpad */
        struct board            *bd_msg;
@@ -105,6 +166,12 @@ struct gui_info {
        SDL_Rect                kp_dialed[2];   /* dialed number */
        struct board            *bd_dialed;
 
+       /* other boards are one associated with the source windows
+        * above the keypad in the layout, we only have the geometry
+        * relative to the whole screen
+        */
+       struct thumb_bd         thumb_bd_array[MAX_VIDEO_SOURCES];
+
        /* variable-size array mapping keypad regions to functions */
        int kp_size, kp_used;
        struct keypad_entry *kp;
@@ -115,7 +182,7 @@ struct gui_info {
 /*! \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)
+static struct gui_info *cleanup_sdl(struct gui_info *gui, int device_num)
 {
        int i;
 
@@ -141,12 +208,44 @@ static struct gui_info *cleanup_sdl(struct gui_info *gui)
                if (gui->win[i].bmp)
                        SDL_FreeYUVOverlay(gui->win[i].bmp);
        }
-       bzero(gui, sizeof(gui));
+       memset(gui, '\0', sizeof(gui));
+
+       /* deallocates the space allocated for the keypad message boards */
+       if (gui->bd_dialed)
+               delete_board(gui->bd_dialed);
+       if (gui->bd_msg)
+               delete_board(gui->bd_msg);
+
+       /* deallocates the space allocated for the thumbnail message boards */
+       for (i = 0; i < device_num; i++) {
+               if (gui->thumb_bd_array[i].board) /* may be useless */
+                       delete_board(gui->thumb_bd_array[i].board);
+       }
+       
        ast_free(gui);
        SDL_Quit();
        return NULL;
 }
 
+/* messages to be displayed in the sources message boards
+ * below the source windows
+ */
+
+/* costants defined to describe status of devices */
+#define IS_PRIMARY 1
+#define IS_SECONDARY 2
+#define IS_ON 4
+
+char* src_msgs[] = {
+       "    OFF",
+       "1   OFF",
+       "  2 OFF",
+       "1+2 OFF",
+       "    ON",
+       "1   ON",
+       "  2 ON",
+       "1+2 ON",
+};
 /*
  * 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
@@ -171,7 +270,7 @@ static void show_frame(struct video_desc *env, int out)
                b_in = &env->enc_in;
                b_out = &env->loc_dpy;
                p_in = NULL;
-       } else {
+       } else if (out == WIN_REMOTE) {
                /* copy input format from the decoding context */
                AVCodecContext *c;
                if (env->in == NULL)    /* XXX should not happen - decoder not ready */
@@ -184,11 +283,18 @@ static void show_frame(struct video_desc *env, int out)
 
                b_out = &env->rem_dpy;
                p_in = (AVPicture *)env->in->d_frame;
-       }
+       } else {
+               int i = out-WIN_SRC1;
+               b_in = env->out.devices[i].dev_buf;
+               if (b_in == NULL)
+                       return;
+               p_in = NULL;
+               b_out = &env->src_dpy[i];
+       }               
        bmp = gui->win[out].bmp;
        SDL_LockYUVOverlay(bmp);
        /* output picture info - this is sdl, YUV420P */
-       bzero(&p_out, sizeof(p_out));
+       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];
@@ -236,6 +342,21 @@ enum skin_area {
        KEY_DIALED = 203,       /* area for dialed numbers */
        KEY_EDIT = 204,         /* area for editing user input */
 
+#ifdef notyet /* XXX for future implementation */
+       KEY_AUDIO_SRCS = 210,
+       /*indexes between 210 and 219 (or more) have been reserved for the "keys"
+       associated with the audio device markers, clicking on these markers
+       will change the source device for audio output */
+
+#endif
+       /* Keys related to video sources */
+       KEY_FREEZE = 220,       /* freeze the incoming video */
+       KEY_CAPTURE = 221,      /* capture the whole SDL window as a picture */
+       KEY_PIP = 230,
+       /*indexes between 231 and 239 have been reserved for the "keys"
+       associated with the device thumbnails, clicking on these pictures
+       will change the source device for primary or secondary (PiP) video output*/
+       KEY_SRCS_WIN = 231, /* till 239 */
        /* areas outside the keypad - simulated */
        KEY_OUT_OF_KEYPAD = 241,
        KEY_REM_DPY = 242,
@@ -270,15 +391,23 @@ 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:
+       case KEY_SENDVIDEO: /* send or do not send video */
                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;
-               }
+
+       case KEY_PIP: /* enable or disable Picture in Picture */
+               env->out.picture_in_picture = !env->out.picture_in_picture;
+               break;
+
+       case KEY_MUTE: /* send or do not send audio */
+               ast_cli_command(env->gui->outfd, "console mute toggle");
+               break;
+
+       case KEY_FREEZE: /* freeze/unfreeze the incoming frames */
+               env->frame_freeze = !env->frame_freeze;
                break;
+
+#ifdef notyet
        case KEY_AUTOANSWER: {
                struct chan_oss_pvt *o = find_desc(oss_active);
                o->autoanswer = !o->autoanswer;
@@ -357,6 +486,130 @@ static void set_drag(struct drag_info *drag, int x, int y, enum drag_window win)
        drag->drag_window = win;
 }
 
+static int update_device_info(struct video_desc *env, int i)
+{
+       reset_board(env->gui->thumb_bd_array[i].board);
+       print_message(env->gui->thumb_bd_array[i].board,
+               src_msgs[env->out.devices[i].status_index]);
+       return 0;
+}
+
+/*! \brief Changes the video output (local video) source, controlling if
+ * it is already using that video device, 
+ * and switching the correct fields of env->out.
+ * grabbers are always open and saved in the device table.
+ * The secondary or the primary device can be changed,
+ * according to the "button" parameter:
+ * the primary device is changed if button = SDL_BUTTON_LEFT;
+ * the secondary device is changed if button = not SDL_BUTTON_LEFT;
+ * 
+ * the correct message boards of the sources are also updated
+ * with the new status
+ * 
+ * \param env = pointer to the video environment descriptor
+ * \param index = index of the device the caller wants to use are primary or secondary device
+ * \param button = button clicked on the mouse
+ *
+ * returns 0 on success,
+ * returns 1 on error 
+ */
+static int switch_video_out(struct video_desc *env, int index, Uint8 button)
+{
+       int *p; /* pointer to the index of the device to select */
+
+       if (index >= env->out.device_num) {
+               ast_log(LOG_WARNING, "no devices\n");
+               return 1;
+       }
+       /* select primary or secondary */
+       p = (button == SDL_BUTTON_LEFT) ? &env->out.device_primary :
+               &env->out.device_secondary;
+       /* controls if the device is already selected */
+       if (index == *p) {
+               ast_log(LOG_WARNING, "device %s already selected\n", env->out.devices[index].name);
+               return 0;
+       }
+       ast_log(LOG_WARNING, "switching to %s...\n", env->out.devices[index].name);
+       /* already open */
+       if (env->out.devices[index].grabber) {
+               /* we also have to update the messages in the source 
+               message boards below the source windows */
+               /* first we update the board of the previous source */
+               if (p == &env->out.device_primary)
+                       env->out.devices[*p].status_index &= ~IS_PRIMARY;
+               else
+                       env->out.devices[*p].status_index &= ~IS_SECONDARY;
+               update_device_info(env, *p);
+               /* update the index used as primary or secondary */
+               *p = index;
+               ast_log(LOG_WARNING, "done\n");
+               /* then we update the board of the new primary or secondary source */
+               if (p == &env->out.device_primary)
+                       env->out.devices[*p].status_index |= IS_PRIMARY;
+               else
+                       env->out.devices[*p].status_index |= IS_SECONDARY;
+               update_device_info(env, *p);
+               return 0;
+       }
+       /* device is off, just do nothing */
+       ast_log(LOG_WARNING, "device is down\n");
+       return 1;
+}
+
+/*! \brief tries to switch the state of a device from on to off or off to on
+ * we also have to update the status of the device and the correct message board
+ *
+ * \param index = the device that must be turned on or off
+ * \param env = pointer to the video environment descriptor
+ *
+ * returns:
+ * - 0 on falure switching from off to on
+ * - 1 on success in switching from off to on
+ * - 2 on success in switching from on to off
+*/
+static int turn_on_off(int index, struct video_desc *env)
+{
+       struct video_device *p = &env->out.devices[index];
+
+       if (index >= env->out.device_num) {
+               ast_log(LOG_WARNING, "no devices\n");
+               return 0;
+       }
+
+       if (!p->grabber) { /* device off */
+               void *g_data; /* result of grabber_open() */
+               struct grab_desc *g;
+               int i;
+
+               /* see if the device can be used by one of the existing drivers */
+               for (i = 0; (g = console_grabbers[i]); i++) {
+                       /* try open the device */
+                       g_data = g->open(p->name, &env->out.loc_src_geometry, env->out.fps);
+                       if (!g_data)    /* no luck, try the next driver */
+                               continue;
+                       p->grabber = g;
+                       p->grabber_data = g_data;
+                       /* update the status of the source */
+                       p->status_index |= IS_ON;
+                       /* print the new message in the message board */
+                       update_device_info(env, index);
+                       return 1; /* open succeded */
+               }
+               return 0; /* failure */
+       } else {
+               /* the grabber must be closed */
+               p->grabber_data = p->grabber->close(p->grabber_data);
+               p->grabber = NULL;
+               /* dev_buf is already freed by grabber->close() */
+               p->dev_buf = NULL;
+               /* update the status of the source */
+               p->status_index &= ~IS_ON;
+               /* print the new message in the message board */
+               update_device_info(env, index);
+               return 2; /* closed */
+       }       
+}
+
 /*
  * Handle SDL_MOUSEBUTTONDOWN type, finding the palette
  * index value and calling the right callback.
@@ -367,29 +620,83 @@ 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;
+               
+       int i; /* integer variable used as iterator */
+
+       int x; /* integer variable usable as a container */
+       
+       /* total width of source device thumbnails */
+       int src_wins_tot_w = env->out.device_num*(SRC_WIN_W+BORDER)+BORDER;
 
+       /* x coordinate of the center of the keypad */
+       int x0 = MAX(env->rem_dpy.w+gui->keypad->w/2+2*BORDER, src_wins_tot_w/2);
+       
 #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;
+       /* XXX this should be extended for clicks on different audio device markers */
+       if (button.y >= (env->out.device_num ? SRC_WIN_H+2*BORDER+SRC_MSG_BD_H : 0)) {
+               /* if control reaches this point this means that the clicked point is
+               below the row of the additional sources windows*/
+               /* adjust the y coordinate as if additional devices windows were not present */
+               button.y -= (env->out.device_num ? SRC_WIN_H+2*BORDER+SRC_MSG_BD_H : 0);
+               if (button.y < BORDER)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.y >= MAX(MAX(env->rem_dpy.h, env->loc_dpy.h), gui->keypad->h))
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.x < x0 - gui->keypad->w/2 - BORDER - env->rem_dpy.w)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.x < x0 - gui->keypad->w/2 - BORDER)
+                       index = KEY_REM_DPY;
+               else if (button.x < x0 - gui->keypad->w/2)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.x >= x0 + gui->keypad->w/2 + BORDER + env->loc_dpy.w)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.x >= x0 + gui->keypad->w/2 + BORDER)
+                       index = KEY_LOC_DPY;
+               else if (button.x >= x0 + gui->keypad->w/2)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (gui->kp) {
+                       /* we have to calculate the first coordinate 
+                       inside the keypad before calling the kp_match_area*/
+                       int x_keypad = button.x - (x0 - gui->keypad->w/2);
+                       /* find the key clicked (if one was clicked) */
+                       for (i = 0; i < gui->kp_used; i++) {
+                               if (kp_match_area(&gui->kp[i],x_keypad, button.y - BORDER)) {
+                                       index = gui->kp[i].c;
+                                       break;
+                               }
                        }
                }
+       } else if (button.y < BORDER) {
+               index = KEY_OUT_OF_KEYPAD;
+       } else {  /* we are in the thumbnail area */
+               x = x0 - src_wins_tot_w/2 + BORDER;
+               if (button.y >= BORDER + SRC_WIN_H)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.x < x)
+                       index = KEY_OUT_OF_KEYPAD;
+               else if (button.x < x + src_wins_tot_w - BORDER) {
+                       /* note that the additional device windows 
+                       are numbered from left to right
+                       starting from 0, with a maximum of 8, the index associated on a click is:
+                       KEY_SRCS_WIN + number_of_the_window */
+                       for (i = 1; i <= env->out.device_num; i++) {
+                               if (button.x < x+i*(SRC_WIN_W+BORDER)-BORDER) {
+                                       index = KEY_SRCS_WIN+i-1;
+                                       break;
+                               } else if (button.x < x+i*(SRC_WIN_W+BORDER)) {
+                                       index = KEY_OUT_OF_KEYPAD;
+                                       break;
+                               }
+                       }
+               } else
+                       index = KEY_OUT_OF_KEYPAD;
        }
 
        /* exec the function */
@@ -397,6 +704,37 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button
                keypad_digit(env, index);
                return;
        }
+
+       else if (index >= KEY_SRCS_WIN && index < KEY_SRCS_WIN+env->out.device_num) {
+               index -= KEY_SRCS_WIN; /* index of the window, equal to the device index in the table */
+               /* if one of the additional device windows is clicked with
+               left or right mouse button, we have to switch to that device */
+               if (button.button == SDL_BUTTON_RIGHT || button.button == SDL_BUTTON_LEFT) {
+                       switch_video_out(env, index, button.button);
+                       return;
+               }
+               /* turn on or off the devices selectively with other mouse buttons */
+               else {
+                       int ret = turn_on_off(index, env);
+                       /* print a message according to what happened */
+                       if (!ret)
+                               ast_log(LOG_WARNING, "unable to turn on device %s\n",
+                                       env->out.devices[index].name);
+                       else if (ret == 1)
+                               ast_log(LOG_WARNING, "device %s changed state to on\n",
+                                       env->out.devices[index].name);
+                       else if (ret == 2)
+                               ast_log(LOG_WARNING, "device %s changed state to off\n",
+                                       env->out.devices[index].name);
+                       return;
+               }
+       }
+
+       /* XXX for future implementation
+       else if (click on audio source marker)
+               change audio source device
+       */
+
        switch (index) {
        /* answer/close function */
        case KEY_PICK_UP:
@@ -407,9 +745,11 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button
                break;
 
        /* other functions */
-       case KEY_MUTE:
+       case KEY_MUTE: /* send or not send the audio */
        case KEY_AUTOANSWER:
-       case KEY_SENDVIDEO:
+       case KEY_SENDVIDEO: /* send or not send the video */
+       case KEY_PIP: /* activate/deactivate picture in picture mode */
+       case KEY_FREEZE: /* freeze/unfreeze the incoming video */
                keypad_toggle(env, index);
                break;
 
@@ -418,6 +758,11 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button
        case KEY_REMOTEVIDEO:
                break;
 
+#ifdef notyet /* XXX for future implementations */
+       case KEY_CAPTURE:
+               break;
+#endif
+
        case KEY_MESSAGEBOARD:
                if (button.button == SDL_BUTTON_LEFT)
                        set_drag(&gui->drag, button.x, button.y, DRAG_MESSAGE);
@@ -427,8 +772,26 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button
        case KEY_LOC_DPY:
        case KEY_REM_DPY:
                if (button.button == SDL_BUTTON_LEFT) {
-                       if (index == KEY_LOC_DPY)
+                       /* values used to find the position of the picture in picture (if present) */
+                       int pip_loc_x = (double)env->out.pip_x/env->enc_in.w * env->loc_dpy.w;
+                       int pip_loc_y = (double)env->out.pip_y/env->enc_in.h * env->loc_dpy.h;
+                       /* check if picture in picture is active and the click was on it */
+                       if (index == KEY_LOC_DPY && env->out.picture_in_picture &&
+                         button.x >= x0+gui->keypad->w/2+BORDER+pip_loc_x &&
+                         button.x < x0+gui->keypad->w/2+BORDER+pip_loc_x+env->loc_dpy.w/3 &&
+                         button.y >= BORDER+pip_loc_y && 
+                         button.y < BORDER+pip_loc_y+env->loc_dpy.h/3) {
+                               /* set the y cordinate to his previous value */
+                               button.y += (env->out.device_num ? SRC_WIN_H+2*BORDER+SRC_MSG_BD_H : 0);
+                               /* starts dragging the picture inside the picture */
+                               set_drag(&gui->drag, button.x, button.y, DRAG_PIP);
+                       }
+                       else if (index == KEY_LOC_DPY) {
+                               /* set the y cordinate to his previous value */
+                               button.y += (env->out.device_num ? SRC_WIN_H+2*BORDER+SRC_MSG_BD_H : 0);
+                               /* click in the local display, but not on the PiP */
                                set_drag(&gui->drag, button.x, button.y, DRAG_LOCAL);
+                       }
                        break;
                } else {
                        char buf[128];
@@ -437,13 +800,26 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button
                                fb->w, fb->h);
                        video_geom(fb, buf);
                        sdl_setup(env);
+                       /* writes messages in the source boards, those can be 
+                       modified during the execution, because of the events 
+                       this must be done here, otherwise the status of sources will not be
+                       shown after sdl_setup */
+                       for (i = 0; i < env->out.device_num; i++) {
+                               update_device_info(env, i);
+                       }
+                       /* we also have to refresh other boards, 
+                       to avoid messages to disappear after video resize */
+                       print_message(gui->bd_msg, " \b");
+                       print_message(gui->bd_dialed, " \b");
                }
                break;
        case KEY_OUT_OF_KEYPAD:
+               ast_log(LOG_WARNING, "nothing clicked, coordinates: %d, %d\n", button.x, button.y);
                break;
 
        case KEY_DIGIT_BACKGROUND:
                break;
+
        default:
                ast_log(LOG_WARNING, "function not yet defined %i\n", index);
        }
@@ -460,7 +836,7 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button
  * use a translation table, below - one line per entry,
  * plain, shift, ctrl, ... using the first char as key.
  */
-static const char *us_kbd_map[] = {
+static const char * const us_kbd_map[] = {
        "`~", "1!", "2@", "3#", "4$", "5%", "6^",
        "7&", "8*", "9(", "0)", "-_", "=+", "[{",
        "]}", "\\|", ";:", "'\"", ",<", ".>", "/?",
@@ -523,7 +899,7 @@ static void handle_keyboard_input(struct video_desc *env, SDL_keysym *ks)
        return;
 }
 
-static void grabber_move(struct video_out_desc *, int dx, int dy);
+static void grabber_move(struct video_device *, int dx, int dy);
 
 int compute_drag(int *start, int end, int magnifier);
 int compute_drag(int *start, int end, int magnifier)
@@ -538,6 +914,33 @@ int compute_drag(int *start, int end, int magnifier)
        return delta;
 }
 
+/*! \brief This function moves the picture in picture,
+ * controlling the limits of the containing buffer
+ * to avoid problems deriving from going through the limits.
+ *
+ * \param env = pointer to the descriptor of the video environment
+ * \param dx = the variation of the x position
+ * \param dy = the variation of the y position
+*/
+static void pip_move(struct video_desc* env, int dx, int dy) {
+       int new_pip_x = env->out.pip_x+dx;
+       int new_pip_y = env->out.pip_y+dy;
+       /* going beyond the left borders */
+       if (new_pip_x < 0)
+               new_pip_x = 0;
+       /* going beyond the right borders */
+       else if (new_pip_x > env->enc_in.w - env->enc_in.w/3)
+               new_pip_x = env->enc_in.w - env->enc_in.w/3;
+       /* going beyond the top borders */
+       if (new_pip_y < 0)
+               new_pip_y = 0;
+       /* going beyond the bottom borders */
+       else if (new_pip_y > env->enc_in.h - env->enc_in.h/3)
+               new_pip_y = env->enc_in.h - env->enc_in.h/3;
+       env->out.pip_x = new_pip_x;
+       env->out.pip_y = new_pip_y;
+}
+
 /*
  * I am seeing some kind of deadlock or stall around
  * SDL_PumpEvents() while moving the window on a remote X server
@@ -575,10 +978,12 @@ static void eventhandler(struct video_desc *env, const char *caption)
                                break;
 
                        case SDL_ACTIVEEVENT:
+#if 0 /* do not react, we don't want to die because the window is minimized */
                                if (ev[i].active.gain == 0 && ev[i].active.state & SDL_APPACTIVE) {
-                                       ast_log(LOG_WARNING, "/* somebody has killed us ? */");
+                                       ast_log(LOG_WARNING, "/* somebody has killed us ? */\n");
                                        ast_cli_command(gui->outfd, "stop now");
                                }
+#endif
                                break;
 
                        case SDL_KEYUP: /* ignore, for the time being */
@@ -590,11 +995,24 @@ static void eventhandler(struct video_desc *env, const char *caption)
 
                        case SDL_MOUSEMOTION:
                        case SDL_MOUSEBUTTONUP:
-                               if (drag->drag_window == DRAG_LOCAL) {
+                               if (drag->drag_window == DRAG_LOCAL && env->out.device_num) {
                                        /* 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);
+                                       grabber_move(&env->out.devices[env->out.device_primary], dx, dy);
+                               } else if (drag->drag_window == DRAG_PIP) {
+                                       /* move the PiP image inside the frames of the enc_in buffers */
+                                       int dx = ev[i].motion.x - drag->x_start;
+                                       int dy = ev[i].motion.y - drag->y_start;
+                                       /* dx and dy value are directly applied to env->out.pip_x and
+                                       env->out.pip_y, so they must work as if the format was cif */
+                                       dx = (double)dx*env->enc_in.w/env->loc_dpy.w;
+                                       dy = (double)dy*env->enc_in.h/env->loc_dpy.h;
+                                       /* sets starts to a new value */
+                                       drag->x_start = ev[i].motion.x;
+                                       drag->y_start = ev[i].motion.y;
+                                       /* ast_log(LOG_WARNING, "moving: %d, %d\n", dx, dy); */
+                                       pip_move(env, 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);
@@ -805,7 +1223,15 @@ static void sdl_setup(struct video_desc *env)
        const SDL_VideoInfo *info;
        int kp_w = 0, kp_h = 0; /* keypad width and height */
        struct gui_info *gui = env->gui;
-
+       
+       /* Some helper variables used for filling the SDL window */
+       int x0; /* the x coordinate of the center of the keypad */
+       int x1; /* userful for calculating of the size of the parent window */
+       int y0; /* y coordinate of the keypad, the remote window and the local window */
+       int src_wins_tot_w; /* total width of the source windows */
+       int i;
+       int x; /* useful for the creation of the source windows; */
+       
 #ifdef HAVE_X11
        const char *e = getenv("SDL_WINDOWID");
 
@@ -827,6 +1253,8 @@ static void sdl_setup(struct video_desc *env)
         * 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:
+        * - top row: thumbnails for local video sources;
+        * - next row: message boards for local video sources
         * - on the left, the remote video;
         * - on the center, the keypad
         * - on the right, the local video
@@ -866,13 +1294,23 @@ static void sdl_setup(struct video_desc *env)
                        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;
-
+       
+       /* total width of the thumbnails */
+       src_wins_tot_w = env->out.device_num*(SRC_WIN_W+BORDER)+BORDER;
+       
+       /* x coordinate of the center of the keypad */
+       x0 = MAX(env->rem_dpy.w+kp_w/2+2*BORDER, src_wins_tot_w/2);
+       
+       /* from center of the keypad to right border */
+       x1 = MAX(env->loc_dpy.w+kp_w/2+2*BORDER, src_wins_tot_w/2);
+       
+       /* total width of the SDL window to create */
+       maxw = x0+x1;
+       
+       /* total height of the mother window to create */
+       maxh = MAX( MAX(env->rem_dpy.h, env->loc_dpy.h), kp_h)+2*BORDER;
+       maxh += env->out.device_num ? (2*BORDER+SRC_WIN_H+SRC_MSG_BD_H) : 0;
+       
        gui->screen = SDL_SetVideoMode(maxw, maxh, depth, 0);
        if (!gui->screen) {
                ast_log(LOG_ERROR, "SDL: could not set video mode - exiting\n");
@@ -924,7 +1362,7 @@ static void sdl_setup(struct video_desc *env)
                            FocusChangeMask | PropertyChangeMask |
                            ColormapChangeMask | OwnerGrabButtonMask;
 
-        bzero(&attr, sizeof(attr));
+        memset(&attr, '\0', sizeof(attr));
        XGetWindowAttributes(SDL_Display, win, &attr);
 
        /* the following events can be delivered only to one client.
@@ -971,24 +1409,56 @@ static void sdl_setup(struct video_desc *env)
        }
     } while (0);
 #endif /* HAVE_X11 */
+
+       y0 = env->out.device_num ? (3*BORDER+SRC_WIN_H+SRC_MSG_BD_H) : BORDER;
+       
        SDL_WM_SetCaption("Asterisk console Video Output", NULL);
+       
+       /* intialize the windows for local and remote video */
        if (set_win(gui->screen, &gui->win[WIN_REMOTE], dpy_fmt,
-                       env->rem_dpy.w, env->rem_dpy.h, BORDER, BORDER))
+                       env->rem_dpy.w, env->rem_dpy.h, x0-kp_w/2-BORDER-env->rem_dpy.w, y0))
                goto no_sdl;
+       /* unfreeze incoming frames if set (to avoid showing nothing) */
+       env->frame_freeze = 0;
+
        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))
+                       x0+kp_w/2+BORDER, y0))
                goto no_sdl;
+       
+       /* initialize device_num source windows (thumbnails) and boards
+       (for a maximum of 9 additional windows and boards) */
+       x = x0 - src_wins_tot_w/2 + BORDER;
+       for (i = 0; i < env->out.device_num; i++){
+               struct thumb_bd *p = &gui->thumb_bd_array[i];
+               if (set_win(gui->screen, &gui->win[i+WIN_SRC1], dpy_fmt,
+                       SRC_WIN_W, SRC_WIN_H, x+i*(BORDER+SRC_WIN_W), BORDER))
+                       goto no_sdl;
+               /* set geometry for the rect for the message board of the device */
+               p->rect.w = SRC_WIN_W;
+               p->rect.h = SRC_MSG_BD_H;
+               p->rect.x = x+i*(BORDER+SRC_WIN_W);
+               p->rect.y = 2*BORDER+SRC_WIN_H;
+               /* the white color is used as background */
+               SDL_FillRect(gui->screen, &p->rect,
+                       SDL_MapRGB(gui->screen->format, 255, 255, 255));
+               /* if necessary, initialize boards for the sources */
+               if (!p->board)
+                       p->board =
+                               board_setup(gui->screen, &p->rect,
+                               gui->font, gui->font_rects);
+               /* update board rect */
+               SDL_UpdateRect(gui->screen, p->rect.x, p->rect.y, p->rect.w, p->rect.h);
+       }
 
        /* display the skin, but do not free it as we need it later to
-        * restore text areas and maybe sliders too.
-        */
+       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->x = x0-kp_w/2;
+               dest->y = y0;
                dest->w = kp_w;
                dest->h = kp_h;
                SDL_BlitSurface(gui->keypad, src, gui->screen, dest);
@@ -1000,7 +1470,7 @@ static void sdl_setup(struct video_desc *env)
 
 no_sdl:
        /* free resources in case of errors */
-       env->gui = cleanup_sdl(gui);
+       env->gui = cleanup_sdl(gui, env->out.device_num);
 }
 
 /*
@@ -1025,7 +1495,7 @@ static int kp_match_area(const struct keypad_entry *e, int x, int y)
                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);
+                       ret = (xp >= 0 && xp < l && yp >=0 && yp < e->h);
                } else if (e->type == KP_CIRCLE) {
                        dx = xp*xp/(l*l) + yp*yp/(e->h*e->h);
                        ret = (dx < 1);
@@ -1039,7 +1509,9 @@ static int kp_match_area(const struct keypad_entry *e, int x, int y)
 }
 
 struct _s_k { const char *s; int k; };
-static struct _s_k gui_key_map[] = {
+static const struct _s_k gui_key_map[] = {
+       {"FREEZE",      KEY_FREEZE},
+       {"PIP",         KEY_PIP},
        {"PICK_UP",     KEY_PICK_UP },
        {"PICKUP",      KEY_PICK_UP },
         {"HANG_UP",    KEY_HANG_UP },
@@ -1080,6 +1552,8 @@ static int gui_map_token(const char *s)
  *     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 x0 y0 w h                 # horizontal rectangle (short format)
+ *                                     # this is used e.g. for message boards
  * token is the token to be returned, either a character or a symbol
  * as KEY_* above
  * Return 1 on success, 0 on error.
@@ -1095,7 +1569,7 @@ static int keypad_cfg_read(struct gui_info *gui, const char *val)
                return 0;
 
        s1[0] = s2[0] = '\0';
-       bzero(&e, sizeof(e));
+       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);
 
@@ -1121,10 +1595,10 @@ static int keypad_cfg_read(struct gui_info *gui, const char *val)
                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;
+                       r->x = atoi(s2);        /* this becomes x0 */
+                       r->y = e.x0;            /* this becomes y0 */
+                       r->w = e.y0;            /* this becomes w  */
+                       r->h = e.x1;            /* this becomes h  */
                        break;
                }
                if (strcasecmp(s2, "circle"))   /* invalid */
@@ -1165,7 +1639,7 @@ static int keypad_cfg_read(struct gui_info *gui, const char *val)
        if (gui->kp_size == 0) {
                gui->kp = ast_calloc(10, sizeof(e));
                if (gui->kp == NULL) {
-                       ast_log(LOG_WARNING, "cannot allocate kp");
+                       ast_log(LOG_WARNING, "cannot allocate kp\n");
                        return 0;
                }
                gui->kp_size = 10;
@@ -1173,7 +1647,7 @@ static int keypad_cfg_read(struct gui_info *gui, const char *val)
        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");
+                       ast_log(LOG_WARNING, "cannot reallocate kp\n");
                        return 0;
                }
                gui->kp = a;