diff options
Diffstat (limited to 'channels/console_gui.c')
| -rw-r--r-- | channels/console_gui.c | 580 |
1 files changed, 517 insertions, 63 deletions
diff --git a/channels/console_gui.c b/channels/console_gui.c index 699e6b1fa..a228c3ce7 100644 --- a/channels/console_gui.c +++ b/channels/console_gui.c @@ -7,30 +7,72 @@ /* * 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; + 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; -- keystrokes are used as keypad functions, or as text input - if we are in text-input mode. Configuration options control the appeareance of the gui: - keypad = /tmp/phone.jpg ; the skin - keypad_font = /tmp/font.ttf ; the font to use for output (XXX deprecated) + 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: +- freeze of the video coming from our remote party +- save of the whole SDL window as a picture +- oudio 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 + * */ @@ -42,13 +84,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 +109,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 +122,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 +146,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 +161,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 +177,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; @@ -142,11 +204,43 @@ static struct gui_info *cleanup_sdl(struct gui_info *gui) SDL_FreeYUVOverlay(gui->win[i].bmp); } bzero(gui, 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 +265,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,7 +278,14 @@ 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 */ @@ -236,6 +337,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 */ + + KEY_FREEZE = 220, /* freeze the incoming video */ + KEY_CAPTURE = 221, /* capture the whole SDL window as a picture */ +#endif + /* video source switching key(s) */ + 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 +386,16 @@ 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; +#ifdef notyet case KEY_AUTOANSWER: { struct chan_oss_pvt *o = find_desc(oss_active); o->autoanswer = !o->autoanswer; @@ -357,6 +474,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 +608,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 +692,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 +733,10 @@ 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 */ keypad_toggle(env, index); break; @@ -418,6 +745,13 @@ static void handle_mousedown(struct video_desc *env, SDL_MouseButtonEvent button case KEY_REMOTEVIDEO: break; +#ifdef notyet /* XXX for future implementations */ + case KEY_FREEZE: + break + 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 +761,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,9 +789,21 @@ 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: @@ -524,7 +888,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) @@ -539,6 +903,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 @@ -593,11 +984,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); @@ -808,7 +1212,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"); @@ -830,6 +1242,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 @@ -869,13 +1283,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"); @@ -974,24 +1398,53 @@ 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; 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); @@ -1003,7 +1456,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); } /* @@ -1043,6 +1496,7 @@ 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[] = { + {"PIP", KEY_PIP}, {"PICK_UP", KEY_PICK_UP }, {"PICKUP", KEY_PICK_UP }, {"HANG_UP", KEY_HANG_UP }, |