[svn-commits] rizzo: branch rizzo/video_console r125091 - /team/rizzo/video_console/channels/
SVN commits to the Digium repositories
svn-commits at lists.digium.com
Wed Jun 25 11:57:19 CDT 2008
Author: rizzo
Date: Wed Jun 25 11:57:18 2008
New Revision: 125091
URL: http://svn.digium.com/view/asterisk?view=rev&rev=125091
Log:
This code, written by one of our students, Daniele Giannetti,
(disclaimer is on the way) implements support for up to 9 video
sources (e.g. webcams, or X11 grabbers, etc.) active at once,
displaying thumbnails for each of them in the main GUI window, and
with the ability to switch between them on the fly during a
conversation.
The code also implements a 'Picture in Picture' feature,
allowing you to select any source as primary or secondary,
and move the PiP window by just dragging it with the mouse.
The window looks like this:
________________________________________________________________
| ______ ______ ______ ______ ______ ______ ______ |
| | tn.1 | | tn.2 | | tn.3 | | tn.4 | | tn.5 | | tn.6 | | tn.7 | |
| |______| |______| |______| |______| |______| |______| |______| |
| ______ ______ ______ ______ ______ ______ ______ |
| |______| |______| |______| |______| |______| |______| |______| |
| _________________ __________________ _________________ |
| | | | | | | |
| | | | | | | |
| | | | | | | |
| | remote video | | | | local video | |
| | | | | | ______ | |
| | | | keypad | | | PIP || |
| | | | | | |______|| |
| |_________________| | | |_________________| |
| | | |
| | | |
| |__________________| |
|________________________________________________________________|
Modified:
team/rizzo/video_console/channels/console_gui.c
team/rizzo/video_console/channels/console_video.c
team/rizzo/video_console/channels/console_video.h
team/rizzo/video_console/channels/vcodecs.c
Modified: team/rizzo/video_console/channels/console_gui.c
URL: http://svn.digium.com/view/asterisk/team/rizzo/video_console/channels/console_gui.c?view=diff&rev=125091&r1=125090&r2=125091
==============================================================================
--- team/rizzo/video_console/channels/console_gui.c (original)
+++ team/rizzo/video_console/channels/console_gui.c Wed Jun 25 11:57:18 2008
@@ -8,9 +8,12 @@
* 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.
+containing four sections: remote video on the left, local video
+on the right, the keypad with all controls and text windows
+in the center, and above these three sections, the source windows section
+(including the relative message boards).
+The fourth section may even not be displayed if no devices are specified
+in the configuration file oss.conf
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.
@@ -32,6 +35,29 @@
keypad = /tmp/phone.jpg ; the skin
keypad_font = /tmp/font.ttf ; the font to use for output (XXX deprecated)
+with raw chunky graphics, the situation of the GUI can be represented as follows
+ ____________________________________________________________________________
+| ______ ______ ______ ______ ______ ______ ______ |
+| | | | | | | | | | | | | | | |
+| |______| |______| |______| |______| |______| |______| |______| |
+| ______ ______ ______ ______ ______ ______ ______ |
+| |______| |______| |______| |______| |______| |______| |______| |
+| _______________________ __________________ _______________________ |
+| | | | | | | |
+| | | | | | | |
+| | | | | | | |
+| | remote video | | | | local video | |
+| | | | | | | |
+| | | | keypad | | | |
+| | | | | | | |
+| |_______________________| | | |_______________________| |
+| | | |
+| | | |
+| | | |
+| | | |
+| |__________________| |
+|____________________________________________________________________________|
+
*
*/
@@ -42,8 +68,10 @@
#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) {}
@@ -65,6 +93,9 @@
#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 */
@@ -92,7 +123,7 @@
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
*/
@@ -104,6 +135,13 @@
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
+ */
+ SDL_Rect *rect_srcs_msg;
+ struct board **bd_srcs_msg;
/* variable-size array mapping keypad regions to functions */
int kp_size, kp_used;
@@ -142,11 +180,28 @@
SDL_FreeYUVOverlay(gui->win[i].bmp);
}
bzero(gui, sizeof(gui));
+ if (gui->rect_srcs_msg)
+ ast_free(gui->rect_srcs_msg);
+ if (gui->bd_srcs_msg)
+ ast_free(gui->bd_srcs_msg);
ast_free(gui);
SDL_Quit();
return NULL;
}
+/* messages to be displayed in the sources message boards
+ * below the source windows
+ */
+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 +226,7 @@
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 +239,14 @@
b_out = &env->rem_dpy;
p_in = (AVPicture *)env->in->d_frame;
- }
+ } else {
+ int i = out-3;
+ 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 +298,12 @@
KEY_DIALED = 203, /* area for dialed numbers */
KEY_EDIT = 204, /* area for editing user input */
+ /* video source switching key(s) */
+ KEY_PIP = 230,
+ /*indexes between 231 and 239 have been reserved for the "keys"
+ associated with the little windows below the keypad, 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,
@@ -243,6 +311,7 @@
KEY_RESET = 253, /* the 'reset' keyword */
KEY_NONE = 254, /* invalid area */
KEY_DIGIT_BACKGROUND = 255, /* other areas within the keypad */
+
};
/*
@@ -267,18 +336,24 @@
/* function used to toggle on/off the status of some variables */
static char *keypad_toggle(struct video_desc *env, int index)
{
+ static int audio_state = 1; // variable used to mute or unmute audio
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;
+ 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
+ if (audio_state)
+ ast_cli_command(env->gui->outfd, "console mute");
+ else
+ ast_cli_command(env->gui->outfd, "console unmute");
+ audio_state = !audio_state;
+ break;
#ifdef notyet
- case KEY_MUTE: {
- struct chan_oss_pvt *o = find_desc(oss_active);
- o->mute = !o->mute;
- }
- break;
case KEY_AUTOANSWER: {
struct chan_oss_pvt *o = find_desc(oss_active);
o->autoanswer = !o->autoanswer;
@@ -357,6 +432,137 @@
drag->drag_window = win;
}
+/*! \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,
+ * concording with the parameter "secondary":
+ * the secondary device is changed if secondary = 1;
+ * the primary device is changed if secondary = 0;
+ *
+ * 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 secondary = integer value, working as described above
+ *
+ * returns 0 on success,
+ * returns 1 on error
+ */
+static int switch_video_out(struct video_desc *env, int index, int secondary)
+{
+ int* p = &env->out.device_primary; //pointer to the index of the primary device
+ p += secondary; //pointer to the index to change (primary or 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
+ env->out.devices[*p].status_index -= 1+secondary;
+ reset_board(env->gui->bd_srcs_msg[*p]);
+ print_message(env->gui->bd_srcs_msg[*p],
+ src_msgs[env->out.devices[*p].status_index]);
+ // 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
+ env->out.devices[index].status_index += 1+secondary;
+ reset_board(env->gui->bd_srcs_msg[index]);
+ print_message(env->gui->bd_srcs_msg[index],
+ src_msgs[env->out.devices[index].status_index]);
+ return 0;
+ }
+ // device is off, just do nothing
+ ast_log(LOG_WARNING, "device is down\n");
+ return 1;
+}
+
+/*! \brief Calls switch_video_out() with the correct parameters
+ * This functions controls if the device is in the table,
+ * and calls the switch_video_out function with the correct parameters depending on the
+ * button of the mouse that was clicked
+ *
+ * \param index = index of the device the caller wants to use
+ * \param env = pointer to the video environment descriptor
+ * \param button = button clicked on the mouse
+ *
+ * returns 0 on success,
+ * returns 1 on error
+*/
+static int switch_video_caller(int index, struct video_desc *env, Uint8 button) {
+ int secondary = 1; //default switching of the secondary source
+ //device not found
+ if(index >= env->out.device_num) {
+ ast_log(LOG_WARNING, "no devices\n");
+ return 1;
+ }
+ // we have to switch the primary source if the left button is clicked
+ if(button == SDL_BUTTON_LEFT)
+ secondary = 0;
+ //to the switching function
+ return switch_video_out(env, index, secondary);
+}
+
+/*! \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){
+ if (!env->out.devices[index].grabber) { // device off
+ void *g_data; // container for the result of the open function on the grabber
+ struct grab_desc *g; // sequentially we try all the defined types of grabber
+ int i; // integer variable used as iterator
+ for (i = 0; (g = console_grabbers[i]); i++) {
+ if(g == NULL)
+ break;
+ // the grabber is opened and the informations saved in the device table
+ g_data = g->open(env->out.devices[index].name,
+ &env->out.loc_src_geometry, env->out.fps);
+ if (!g_data)
+ continue;
+ env->out.devices[index].grabber = g;
+ env->out.devices[index].grabber_data = g_data;
+ // update the status of the source
+ env->out.devices[index].status_index += 4;
+ // print the new message in the message board
+ reset_board(env->gui->bd_srcs_msg[index]);
+ print_message(env->gui->bd_srcs_msg[index],
+ src_msgs[env->out.devices[index].status_index]);
+ return 1; // open succeded
+ }
+ return 0; // falure
+ } else {
+ // the grabber must be closed
+ env->out.devices[index].grabber_data =
+ env->out.devices[index].grabber->close(env->out.devices[index].grabber_data);
+ env->out.devices[index].grabber = NULL;
+ fbuf_free(env->out.devices[index].dev_buf);
+ env->out.devices[index].dev_buf = NULL;
+ // update the status of the source
+ env->out.devices[index].status_index -= 4;
+ // print the new message in the message board
+ reset_board(env->gui->bd_srcs_msg[index]);
+ print_message(env->gui->bd_srcs_msg[index],
+ src_msgs[env->out.devices[index].status_index]);
+ return 2; // closed
+ }
+}
+
/*
* Handle SDL_MOUSEBUTTONDOWN type, finding the palette
* index value and calling the right callback.
@@ -367,29 +573,83 @@
{
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
+
+ // cumulative total width of additional source windows
+ int src_wins_tot_w = env->out.device_num*(SRC_WIN_W+BORDER)+BORDER;
+
+ //from middle keypad to left border
+ 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;
+ if (button.y >= (env->out.devices ? 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.devices ? 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 {
+ x = x0 - src_wins_tot_w/2 + BORDER;
+ //in the area of the small device windows
+ 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 +657,32 @@
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_caller(index, env, 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;
+ }
+ }
+
switch (index) {
/* answer/close function */
case KEY_PICK_UP:
@@ -407,9 +693,10 @@
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;
@@ -427,8 +714,26 @@
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 = (float)env->out.pip_x/env->enc_in.w * env->loc_dpy.w;
+ int pip_loc_y = (float)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.devices ? 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.devices ? 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,11 +742,24 @@
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++) {
+ reset_board(gui->bd_srcs_msg[i]);
+ print_message(gui->bd_srcs_msg[i],
+ src_msgs[env->out.devices[i].status_index]);
+ }
+ /* 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:
- break;
-
+ ast_log(LOG_WARNING, "nothing clicked, coordinates: %d, %d\n", button.x, button.y);
+ break;
case KEY_DIGIT_BACKGROUND:
break;
default:
@@ -523,7 +841,7 @@
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)
@@ -536,6 +854,34 @@
#undef POLARITY
*start = end;
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
+ * of the containing buffer.
+ *
+ * \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;
}
/*
@@ -592,11 +938,24 @@
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONUP:
- if (drag->drag_window == DRAG_LOCAL) {
+ if (drag->drag_window == DRAG_LOCAL && env->out.devices) {
/* 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 = (float)dx*env->enc_in.w/env->loc_dpy.w;
+ dy = (float)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,6 +1167,14 @@
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; /* x coordinate of the center of the keypad */
+ int y0; /* y coordinate of the top of keypad, remote and local window */
+ int src_wins_tot_w; /* total width of thumbnails for sources */
+ int i;
+ int x; // useful for the creation of the source windows;
+ int maxw_half1, maxw_half2; /* support in calculating the size of the parent window */
+
#ifdef HAVE_X11
const char *e = getenv("SDL_WINDOWID");
@@ -829,6 +1196,8 @@
* 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
@@ -868,12 +1237,22 @@
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 */
+ maxw_half1 = MAX(env->rem_dpy.w+kp_w/2+2*BORDER, src_wins_tot_w/2);
+
+ /* from center of the keypad to right border */
+ maxw_half2 = MAX(env->loc_dpy.w+kp_w/2+2*BORDER, src_wins_tot_w/2);
+
+ /* total width of the SDL window to create */
+ maxw = maxw_half1+maxw_half2;
+
+ /* total height of the SDL window to create */
+ maxh = MAX( MAX(env->rem_dpy.h, env->loc_dpy.h), kp_h)+2*BORDER;
+ maxh += env->out.devices ? (2*BORDER+SRC_WIN_H+SRC_MSG_BD_H) : 0;
gui->screen = SDL_SetVideoMode(maxw, maxh, depth, 0);
if (!gui->screen) {
@@ -973,24 +1352,73 @@
}
} while (0);
#endif /* HAVE_X11 */
+
+ x0 = maxw_half1;
+ y0 = env->out.devices ? (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;
+ /* if necessary, allocate memory space for rects that will contain messages
+ relative to the state of every single source */
+ if (!gui->rect_srcs_msg) {
+ gui->rect_srcs_msg = (struct SDL_Rect*)
+ ast_calloc(env->out.device_num, sizeof(struct SDL_Rect));
+ if (!gui->rect_srcs_msg) {
+ ast_log(LOG_ERROR, "no memory for source boards\n");
+ goto no_sdl;
+ }
+ }
+ /* if necessary, allocate memory space for the array of pointers to the message boards of the
+ additional sources */
+ if (!gui->bd_srcs_msg) {
+ gui->bd_srcs_msg = (struct board**)ast_calloc(env->out.device_num, sizeof(struct board*));
+ if (!gui->bd_srcs_msg) {
+ ast_log(LOG_ERROR, "no memory for source boards\n");
+ goto no_sdl;
+ }
+ }
+
+ /* initialize device_num additional src windows 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++){
+ if (set_win(gui->screen, &gui->win[i+3], 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
+ gui->rect_srcs_msg[i].w = SRC_WIN_W;
+ gui->rect_srcs_msg[i].h = SRC_MSG_BD_H;
+ gui->rect_srcs_msg[i].x = x+i*(BORDER+SRC_WIN_W);
+ gui->rect_srcs_msg[i].y = 2*BORDER+SRC_WIN_H;
+ // the white color is used as background
+ SDL_FillRect(gui->screen, &gui->rect_srcs_msg[i],
+ SDL_MapRGB(gui->screen->format, 255, 255, 255));
+ // if necessary, initialize boards for the sources
+ if (!gui->bd_srcs_msg[i])
+ gui->bd_srcs_msg[i] =
+ board_setup(gui->screen, &gui->rect_srcs_msg[i],
+ gui->font, gui->font_rects);
+ }
+ // update new rects
+ SDL_UpdateRects(gui->screen, env->out.device_num, gui->rect_srcs_msg);
+
/* 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);
@@ -998,6 +1426,7 @@
init_board(gui, &gui->bd_dialed, gui->kp_dialed, dest->x, dest->y);
SDL_UpdateRects(gui->screen, 1, dest);
}
+
return;
no_sdl:
@@ -1027,7 +1456,7 @@
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);
@@ -1042,6 +1471,7 @@
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 },
Modified: team/rizzo/video_console/channels/console_video.c
URL: http://svn.digium.com/view/asterisk/team/rizzo/video_console/channels/console_video.c?view=diff&rev=125091&r1=125090&r2=125091
==============================================================================
--- team/rizzo/video_console/channels/console_video.c (original)
+++ team/rizzo/video_console/channels/console_video.c Wed Jun 25 11:57:18 2008
@@ -145,8 +145,24 @@
+/* function to scale and encode buffers */
static void my_scale(struct fbuf_t *in, AVPicture *p_in,
struct fbuf_t *out, AVPicture *p_out);
+
+/*
+ * this structure will be an entry in the table containing
+ * every device specified in the file oss.conf, it contains various infomation
+ * about the device
+ */
+struct video_device {
+ char *name; //name of the device
+ struct grab_desc *grabber; //the grabber for the device type
+ void *grabber_data; //device's private data structure
+ struct fbuf_t *dev_buf; //buffer for incoming data
+ struct timeval last_frame; //when we read the last frame ?
+ int status_index; //what is the status of the device (source) [from 0 to 7]
+ //status_index is the index of the status message in the src_msgs array in console_gui.c
+};
struct video_codec_desc; /* forward declaration */
/*
@@ -157,7 +173,8 @@
* + the encoding and RTP info, including timestamps to generate
* frames at the correct rate;
* + source-specific info, i.e. fd for /dev/video, dpy-image for x11, etc,
- * filled in by grabber_open
+ * filled in by grabber_open, part of source_specific information are in
+ * the device table (devices member), others are shared;
* NOTE: loc_src.data == NULL means the rest of the struct is invalid, and
* the video source is not available.
*/
@@ -168,7 +185,6 @@
* If we are successful, webcam_bufsize > 0 and we can read.
*/
/* all the following is config file info copied from the parent */
- char videodevice[64];
int fps;
int bitrate;
int qmin;
@@ -184,10 +200,18 @@
AVFrame *enc_in_frame; /* enc_in mapped into avcodec format. */
/* The initial part of AVFrame is an AVPicture */
int mtu;
- struct timeval last_frame; /* when we read the last frame ? */
-
- struct grab_desc *grabber;
- void *grabber_data;
+
+ struct video_device *devices; /*table of devices built from the oss.config file */
+ int device_num; /*number of devices in table*/
+ int device_primary; /*index of the actual primary device in the table*/
+ int device_secondary; /*index of the actual secondary device in the table*/
+
+ int picture_in_picture; /*Is the PiP mode activated? 0 = NO | 1 = YES*/
+
+ /* these are the coordinates of the picture inside the picture (visible if PiP mode is active)
+ these coordinates are valid considering the containing buffer with cif geometry*/
+ int pip_x;
+ int pip_y;
};
/*
@@ -216,7 +240,11 @@
struct fbuf_t rem_dpy; /* display remote video, no buffer (it is in win[WIN_REMOTE].bmp) */
struct fbuf_t loc_dpy; /* display local source, no buffer (managed by SDL in bmp[1]) */
-
+ /*display for sources in additional windows,
+ ideally infinite additional sources could be present
+ pratically we assume a maximum of 9 sources to show*/
+ struct fbuf_t* src_dpy;
+
/* local information for grabbers, codecs, gui */
struct gui_info *gui;
struct video_dec_desc *in; /* remote video descriptor */
@@ -241,51 +269,83 @@
#include "vcodecs.c"
#include "console_gui.c"
-/*! \brief Try to open a video source, return 0 on success, 1 on error */
+/*! \brief Try to open video sources, return 0 on success, 1 on error
+ * opens all video sources found in the oss.conf configuration files.
+ * Saves the grabber and the datas in the device table (in the devices field
+ * of the descriptor referenced by v).
+ * Initializes the device_primary and device_secondary
+ * fields of v with the first devices that was
+ * successfully opened.
+ *
+ * \param v = video out environment descriptor
+ *
+ * returns 0 on success, 1 on error
+*/
static int grabber_open(struct video_out_desc *v)
{
struct grab_desc *g;
void *g_data;
- int i;
-
- for (i = 0; (g = console_grabbers[i]); i++) {
- g_data = g->open(v->videodevice, &v->loc_src_geometry, v->fps);
- if (g_data) {
- v->grabber = g;
- v->grabber_data = g_data;
- return 0;
- }
- }
- return 1; /* no source found */
-}
-
-/*! \brief complete a buffer from the local video source.
+ int i, j;
+
+ //for each device in the device table...
+ for(i = 0; i < v->device_num; i++) {
+ //device already open
+ if(v->devices[i].grabber)
+ continue;
+ //for each type of grabber supported...
+ for (j = 0; (g = console_grabbers[j]); j++) {
+ if(g == NULL)
+ break;
+ //the grabber is opened and the informations saved in the device table
+ g_data = g->open(v->devices[i].name, &v->loc_src_geometry, v->fps);
+ if (!g_data)
+ continue;
+ v->devices[i].grabber = g;
+ v->devices[i].grabber_data = g_data;
+ v->devices[i].status_index += 4;
+ }
+ }
+ //the first working device is selected as the primary one and the secondary one
+ for(i = 0; i < v->device_num; i++) {
+ if(!v->devices[i].grabber)
+ continue;
+ v->device_primary = i;
+ v->device_secondary = i;
+ return 0; //source found
+ }
+ return 1; // no source found
+}
+
+
+/*! \brief complete a buffer from the specified local video source.
* Called by get_video_frames(), in turn called by the video thread.
*/
-static struct fbuf_t *grabber_read(struct video_out_desc *v)
+static struct fbuf_t *grabber_read(struct video_device *dev, struct video_out_desc *v)
{
struct timeval now = ast_tvnow();
- if (v->grabber == NULL) /* not initialized */
- return 0;
-
+ if (dev->grabber == NULL) /* not initialized */
+ return NULL;
+
+ /* the last_frame field in this row of the device table (dev)
+ is always initialized, it is set during the parsing of the config
+ file, and never unset, function fill_device_table(). */
/* check if it is time to read */
- if (ast_tvzero(v->last_frame))
- v->last_frame = now;
- if (ast_tvdiff_ms(now, v->last_frame) < 1000/v->fps)
- return 0; /* too early */
- v->last_frame = now; /* XXX actually, should correct for drift */
- return v->grabber->read(v->grabber_data);
-}
+ if (ast_tvdiff_ms(now, dev->last_frame) < 1000/v->fps)
+ return NULL; /* too early */
+ dev->last_frame = now; /* XXX actually, should correct for drift */
+ return dev->grabber->read(dev->grabber_data);
+}
+
/*! \brief handler run when dragging with the left button on
* the local source window - the effect is to move the offset
* of the captured area.
*/
-static void grabber_move(struct video_out_desc *v, int dx, int dy)
-{
- if (v->grabber && v->grabber->move)
- v->grabber->move(v->grabber_data, dx, dy);
+static void grabber_move(struct video_device *dev, int dx, int dy)
+{
+ if (dev->grabber && dev->grabber->move)
+ dev->grabber->move(dev->grabber_data, dx, dy);
}
/*
@@ -313,7 +373,8 @@
static int video_out_uninit(struct video_desc *env)
{
struct video_out_desc *v = &env->out;
-
+ int i; // integer variable used as iterator
+
/* XXX this should be a codec callback */
if (v->enc_ctx) {
AVCodecContext *enc_ctx = (AVCodecContext *)v->enc_ctx;
@@ -329,11 +390,18 @@
/* release the buffers */
fbuf_free(&env->enc_in);
fbuf_free(&v->enc_out);
- /* close the grabber */
- if (v->grabber) {
- v->grabber_data = v->grabber->close(v->grabber_data);
- v->grabber = NULL;
- }
+ /* close the grabbers */
+ for (i = 0; i < v->device_num; i++) {
+ if(v->devices[i].grabber){
+ v->devices[i].grabber_data=
+ v->devices[i].grabber->close(v->devices[i].grabber_data);
+ v->devices[i].grabber=NULL;
+ fbuf_free(v->devices[i].dev_buf);
+ v->devices[i].dev_buf = NULL;
+ }
+ v->devices[i].status_index = 0;
+ }
+ v->picture_in_picture = 0;
return -1;
}
@@ -462,7 +530,8 @@
}
/*! fill an AVPicture from our fbuf info, as it is required by
- * the image conversion routines in ffmpeg.
+ * the image conversion routines in ffmpeg. Note that the pointers
+ * are recalculated if the fbuf has an offset (and so represents a picture in picture)
* XXX This depends on the format.
*/
static AVPicture *fill_pict(struct fbuf_t *b, AVPicture *p)
@@ -471,23 +540,26 @@
int l4 = b->w * b->h/4; /* size of U or V frame */
int len = b->w; /* Y linesize, bytes */
int luv = b->w/2; /* U/V linesize, bytes */
-
+ int sample_size = 1;
+
bzero(p, sizeof(*p));
switch (b->pix_fmt) {
case PIX_FMT_RGB555:
case PIX_FMT_RGB565:
- len *= 2;
+ sample_size = 2;
luv = 0;
break;
case PIX_FMT_RGBA32:
- len *= 4;
+ sample_size = 4;
luv = 0;
break;
case PIX_FMT_YUYV422: /* Packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr */
- len *= 2; /* all data in first plane, probably */
+ sample_size = 2; /* all data in first plane, probably */
luv = 0;
break;
}
+ len *= sample_size;
+
p->data[0] = b->data;
p->linesize[0] = len;
/* these are only valid for component images */
@@ -495,6 +567,14 @@
p->data[2] = luv ? b->data + 5*l4 : b->data+len;
p->linesize[1] = luv;
p->linesize[2] = luv;
+
[... 454 lines stripped ...]
More information about the svn-commits
mailing list