Set peer context and exten values so MACRO_EXTEN and MACRO_CONTEXT will be set
[asterisk/asterisk.git] / channels / vgrabbers.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright 2007, Luigi Rizzo 
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*
18  * Video grabbers used in console_video.
19  *
20  * $Revision$
21  *
22  * Each grabber is implemented through open/read/close calls,
23  * plus an additional move() function used e.g. to change origin
24  * for the X grabber (this may be extended in the future to support
25  * more controls e.g. resolution changes etc.).
26  *
27  * open() should try to open and initialize the grabber, returning NULL on error.
28  * On success it allocates a descriptor for its private data (including
29  * a buffer for the video) and returns a pointer to the descriptor.
30  * read() will return NULL on failure, or a pointer to a buffer with data
31  * on success.
32  * close() should release resources.
33  * move() is optional.
34  * For more details look at the X11 grabber below.
35  *
36  * NOTE: at the moment we expect uncompressed video frames in YUV format,
37  * because this is what current sources supply and also is a convenient
38  * format for display. It is conceivable that one might want to support
39  * an already compressed stream, in which case we should redesign the
40  * pipeline used for the local source, which at the moment is
41  *
42  *                        .->--[loc_dpy]
43  *   [src]-->--[enc_in]--+
44  *                        `->--[enc_out]
45  */
46
47 #include "asterisk.h"
48 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
49 #include <sys/ioctl.h>
50 #include "asterisk/file.h"
51 #include "asterisk/utils.h"     /* ast_calloc */
52
53 #include "console_video.h"
54
55 #if defined(HAVE_VIDEO_CONSOLE)
56
57 #ifdef HAVE_X11
58
59 /* A simple X11 grabber, supporting only truecolor formats */
60
61 #include <X11/Xlib.h>
62
63 /*! \brief internal info used by the X11 grabber */
64 struct grab_x11_desc {
65         Display         *dpy;
66         XImage          *image;
67         int             screen_width;   /* width of X screen */
68         int             screen_height;  /* height of X screen */
69         struct fbuf_t   b;              /* geometry and pointer into the XImage */
70 };
71
72 static void *grab_x11_close(void *desc);        /* forward declaration */
73
74 /*! \brief open the grabber.
75  * We use the special name 'X11' to indicate this grabber.
76  */
77 static void *grab_x11_open(const char *name, struct fbuf_t *geom, int fps)
78 {
79         XImage *im;
80         int screen_num;
81         struct grab_x11_desc *v;
82         struct fbuf_t *b;
83
84         /* all names starting with X11 identify this grabber */
85         if (strncasecmp(name, "X11", 3))
86                 return NULL;    /* not us */
87         v = ast_calloc(1, sizeof(*v));
88         if (v == NULL)
89                 return NULL;    /* no memory */
90
91         /* init the connection with the X server */
92         v->dpy = XOpenDisplay(NULL);
93         if (v->dpy == NULL) {
94                 ast_log(LOG_WARNING, "error opening display\n");
95                 goto error;
96         }
97
98         v->b = *geom;   /* copy geometry */
99         b = &v->b;      /* shorthand */
100         /* find width and height of the screen */
101         screen_num = DefaultScreen(v->dpy);
102         v->screen_width = DisplayWidth(v->dpy, screen_num);
103         v->screen_height = DisplayHeight(v->dpy, screen_num);
104
105         v->image = im = XGetImage(v->dpy,
106                 RootWindow(v->dpy, DefaultScreen(v->dpy)),
107                 b->x, b->y, b->w, b->h, AllPlanes, ZPixmap);
108         if (v->image == NULL) {
109                 ast_log(LOG_WARNING, "error creating Ximage\n");
110                 goto error;
111         }
112         switch (im->bits_per_pixel) {
113         case 32:
114                 b->pix_fmt = PIX_FMT_RGBA32;
115                 break;
116         case 16:
117                 b->pix_fmt = (im->green_mask == 0x7e0) ? PIX_FMT_RGB565 : PIX_FMT_RGB555;
118                 break;
119         }
120
121         ast_log(LOG_NOTICE, "image: data %p %d bpp fmt %d, mask 0x%lx 0x%lx 0x%lx\n",
122                 im->data,
123                 im->bits_per_pixel,
124                 b->pix_fmt,
125                 im->red_mask, im->green_mask, im->blue_mask);
126
127         /* set the pointer but not the size as this is not malloc'ed */
128         b->data = (uint8_t *)im->data;
129         return v;
130
131 error:
132         return grab_x11_close(v);
133 }
134
135 static struct fbuf_t *grab_x11_read(void *desc)
136 {
137         /* read frame from X11 */
138         struct grab_x11_desc *v = desc;
139         struct fbuf_t *b = &v->b;
140
141         XGetSubImage(v->dpy,
142                 RootWindow(v->dpy, DefaultScreen(v->dpy)),
143                         b->x, b->y, b->w, b->h, AllPlanes, ZPixmap, v->image, 0, 0);
144
145         b->data = (uint8_t *)v->image->data;
146         return b;
147 }
148
149 static int boundary_checks(int x, int limit)
150 {
151         return (x <= 0) ? 0 : (x > limit ? limit : x);
152 }
153
154 /*! \brief move the origin for the grabbed area, making sure we do not
155  * overflow the screen.
156  */
157 static void grab_x11_move(void *desc, int dx, int dy)
158 {
159         struct grab_x11_desc *v = desc;
160
161         v->b.x = boundary_checks(v->b.x + dx, v->screen_width - v->b.w);
162         v->b.y = boundary_checks(v->b.y + dy, v->screen_height - v->b.h);
163 }
164
165 /*! \brief disconnect from the server and release memory */
166 static void *grab_x11_close(void *desc)
167 {
168         struct grab_x11_desc *v = desc;
169
170         if (v->dpy)
171                 XCloseDisplay(v->dpy);
172         v->dpy = NULL;
173         v->image = NULL;
174         ast_free(v);
175         return NULL;
176 }
177
178 static struct grab_desc grab_x11_desc = {
179         .name = "X11",
180         .open = grab_x11_open,
181         .read = grab_x11_read,
182         .move = grab_x11_move,
183         .close = grab_x11_close,
184 };
185 #endif  /* HAVE_X11 */
186
187 #ifdef HAVE_VIDEODEV_H
188 #include <linux/videodev.h>     /* Video4Linux stuff is only used in grab_v4l1_open() */
189
190 struct grab_v4l1_desc {
191         int fd;                 /* device handle */
192         struct fbuf_t   b;      /* buffer (allocated) with grabbed image */
193 };
194
195 /*! \brief
196  * Open the local video source and allocate a buffer
197  * for storing the image.
198  */
199 static void *grab_v4l1_open(const char *dev, struct fbuf_t *geom, int fps)
200 {
201         struct video_window vw = { 0 }; /* camera attributes */
202         struct video_picture vp;
203         int fd, i;
204         struct grab_v4l1_desc *v;
205         struct fbuf_t *b;
206
207         /* name should be something under /dev/ */
208         if (strncmp(dev, "/dev/", 5)) 
209                 return NULL;
210         fd = open(dev, O_RDONLY | O_NONBLOCK);
211         if (fd < 0) {
212                 ast_log(LOG_WARNING, "error opening camera %s\n", dev);
213                 return NULL;
214         }
215
216         v = ast_calloc(1, sizeof(*v));
217         if (v == NULL) {
218                 ast_log(LOG_WARNING, "no memory for camera %s\n", dev);
219                 close(fd);
220                 return NULL;    /* no memory */
221         }
222         v->fd = fd;
223         v->b = *geom;
224         b = &v->b;      /* shorthand */
225
226         i = fcntl(fd, F_GETFL);
227         if (-1 == fcntl(fd, F_SETFL, i | O_NONBLOCK)) {
228                 /* non fatal, just emit a warning */
229                 ast_log(LOG_WARNING, "error F_SETFL for %s [%s]\n",
230                         dev, strerror(errno));
231         }
232         /* set format for the camera.
233          * In principle we could retry with a different format if the
234          * one we are asking for is not supported.
235          */
236         vw.width = b->w;
237         vw.height = b->h;
238         vw.flags = fps << 16;
239         if (ioctl(fd, VIDIOCSWIN, &vw) == -1) {
240                 ast_log(LOG_WARNING, "error setting format for %s [%s]\n",
241                         dev, strerror(errno));
242                 goto error;
243         }
244         if (ioctl(fd, VIDIOCGPICT, &vp) == -1) {
245                 ast_log(LOG_WARNING, "error reading picture info\n");
246                 goto error;
247         }
248         ast_log(LOG_WARNING,
249                 "contrast %d bright %d colour %d hue %d white %d palette %d\n",
250                 vp.contrast, vp.brightness,
251                 vp.colour, vp.hue,
252                 vp.whiteness, vp.palette);
253         /* set the video format. Here again, we don't necessary have to
254          * fail if the required format is not supported, but try to use
255          * what the camera gives us.
256          */
257         b->pix_fmt = vp.palette;
258         vp.palette = VIDEO_PALETTE_YUV420P;
259         if (ioctl(v->fd, VIDIOCSPICT, &vp) == -1) {
260                 ast_log(LOG_WARNING, "error setting palette, using %d\n",
261                         b->pix_fmt);
262         } else
263                 b->pix_fmt = vp.palette;
264         /* allocate the source buffer.
265          * XXX, the code here only handles yuv411, for other formats
266          * we need to look at pix_fmt and set size accordingly
267          */
268         b->size = (b->w * b->h * 3)/2;  /* yuv411 */
269         ast_log(LOG_WARNING, "videodev %s opened, size %dx%d %d\n",
270                 dev, b->w, b->h, b->size);
271         b->data = ast_calloc(1, b->size);
272         if (!b->data) {
273                 ast_log(LOG_WARNING, "error allocating buffer %d bytes\n",
274                         b->size);
275                 goto error;
276         }
277         ast_log(LOG_WARNING, "success opening camera\n");
278         return v;
279
280 error:
281         close(v->fd);
282         fbuf_free(b);
283         ast_free(v);
284         return NULL;
285 }
286
287 /*! \brief read until error, no data or buffer full.
288  * This might be blocking but no big deal since we are in the
289  * display thread.
290  */
291 static struct fbuf_t *grab_v4l1_read(void *desc)
292 {
293         struct grab_v4l1_desc *v = desc;
294         struct fbuf_t *b = &v->b;
295         for (;;) {
296                 int r, l = b->size - b->used;
297                 r = read(v->fd, b->data + b->used, l);
298                 // ast_log(LOG_WARNING, "read %d of %d bytes from webcam\n", r, l);
299                 if (r < 0)      /* read error */
300                         break;
301                 if (r == 0)     /* no data */
302                         break;
303                 b->used += r;
304                 if (r == l) {
305                         b->used = 0; /* prepare for next frame */
306                         return b;
307                 }
308         }
309         return NULL;
310 }
311
312 static void *grab_v4l1_close(void *desc)
313 {
314         struct grab_v4l1_desc *v = desc;
315
316         close(v->fd);
317         v->fd = -1;
318         fbuf_free(&v->b);
319         ast_free(v);
320         return NULL;
321 }
322
323 /*! \brief our descriptor. We don't have .move */
324 static struct grab_desc grab_v4l1_desc = {
325         .name = "v4l1",
326         .open = grab_v4l1_open,
327         .read = grab_v4l1_read,
328         .close = grab_v4l1_close,
329 };
330 #endif /* HAVE_VIDEODEV_H */
331
332 /*
333  * Here you can add more grabbers, e.g. V4L2, firewire,
334  * a file, a still image...
335  */
336
337 /*! \brief The list of grabbers supported, with a NULL at the end */
338 struct grab_desc *console_grabbers[] = {
339 #ifdef HAVE_X11
340         &grab_x11_desc,
341 #endif
342 #ifdef HAVE_VIDEODEV_H
343         &grab_v4l1_desc,
344 #endif
345         NULL
346 };
347
348 #endif /* HAVE_VIDEO_CONSOLE */