The fixes in this commit are mainly to allow compiling of trunk with --enable-dev...
[asterisk/asterisk.git] / channels / console_video.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright 2007-2008, Marta Carbone, Sergio Fadda, 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  * Experimental support for video sessions. We use SDL for rendering, ffmpeg
19  * as the codec library for encoding and decoding, and Video4Linux and X11
20  * to generate the local video stream.
21  *
22  * If one of these pieces is not available, either at compile time or at
23  * runtime, we do our best to run without it. Of course, no codec library
24  * means we can only deal with raw data, no SDL means we cannot do rendering,
25  * no V4L or X11 means we cannot generate data (but in principle we could
26  * stream from or record to a file).
27  *
28  * We need a recent (2007.07.12 or newer) version of ffmpeg to avoid warnings.
29  * Older versions might give 'deprecated' messages during compilation,
30  * thus not compiling in AST_DEVMODE, or don't have swscale, in which case
31  * you can try to compile #defining OLD_FFMPEG here.
32  *
33  * $Revision$
34  */
35
36 //#define DROP_PACKETS 5       /* if set, drop this % of video packets */
37 //#define OLD_FFMPEG    1       /* set for old ffmpeg with no swscale */
38
39 #include "asterisk.h"
40 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
41 #include <sys/ioctl.h>
42 #include "asterisk/cli.h"
43 #include "asterisk/file.h"
44 #include "asterisk/channel.h"
45
46 #include "console_video.h"
47
48 /*
49 The code is structured as follows.
50
51 When a new console channel is created, we call console_video_start()
52 to initialize SDL, the source, and the encoder/ decoder for the
53 formats in use (XXX the latter two should be done later, once the
54 codec negotiation is complete).  Also, a thread is created to handle
55 the video source and generate frames.
56
57 While communication is on, the local source is generated by the
58 video thread, which wakes up periodically, generates frames and
59 enqueues them in chan->readq.  Incoming rtp frames are passed to
60 console_write_video(), decoded and passed to SDL for display.
61
62 For as unfortunate and confusing as it can be, we need to deal with a
63 number of different video representations (size, codec/pixel format,
64 codec parameters), as follows:
65
66  loc_src        is the data coming from the camera/X11/etc.
67         The format is typically constrained by the video source.
68
69  enc_in         is the input required by the encoder.
70         Typically constrained in size by the encoder type.
71
72  enc_out        is the bitstream transmitted over RTP.
73         Typically negotiated while the call is established.
74
75  loc_dpy        is the format used to display the local video source.
76         Depending on user preferences this can have the same size as
77         loc_src_fmt, or enc_in_fmt, or thumbnail size (e.g. PiP output)
78
79  dec_in         is the incoming RTP bitstream. Negotiated
80         during call establishment, it is not necessarily the same as
81         enc_in_fmt
82
83  dec_out        the output of the decoder.
84         The format is whatever the other side sends, and the
85         buffer is allocated by avcodec_decode_... so we only
86         copy the data here.
87
88  rem_dpy        the format used to display the remote stream
89
90 We store the format info together with the buffer storing the data.
91 As a future optimization, a format/buffer may reference another one
92 if the formats are equivalent. This will save some unnecessary format
93 conversion.
94
95
96 In order to handle video you need to add to sip.conf (and presumably
97 iax.conf too) the following:
98
99         [general](+)
100                 videosupport=yes
101                 allow=h263      ; this or other video formats
102                 allow=h263p     ; this or other video formats
103
104  */
105
106 /*
107  * Codecs are absolutely necessary or we cannot do anything.
108  * SDL is optional (used for rendering only), so that we can still
109  * stream video withouth displaying it.
110  */
111 #if !defined(HAVE_VIDEO_CONSOLE) || !defined(HAVE_FFMPEG)
112 /* stubs if required pieces are missing */
113 int console_write_video(struct ast_channel *chan, struct ast_frame *f)
114 {
115         return 0;       /* writing video not supported */
116 }
117
118 int console_video_cli(struct video_desc *env, const char *var, int fd)
119 {
120         return 1;       /* nothing matched */
121 }
122
123 int console_video_config(struct video_desc **penv, const char *var, const char *val)
124 {
125         return 1;       /* no configuration */
126 }
127
128 void console_video_start(struct video_desc *env, struct ast_channel *owner)
129 {
130         ast_log(LOG_NOTICE, "voice only, console video support not present\n");
131 }
132
133 void console_video_uninit(struct video_desc *env)
134 {
135 }
136
137 int console_video_formats = 0;
138
139 #else /* defined(HAVE_FFMPEG) && defined(HAVE_SDL) */
140
141 /*! The list of video formats we support. */
142 int console_video_formats = 
143         AST_FORMAT_H263_PLUS | AST_FORMAT_H263 |
144         AST_FORMAT_MP4_VIDEO | AST_FORMAT_H264 | AST_FORMAT_H261 ;
145
146
147
148 static void my_scale(struct fbuf_t *in, AVPicture *p_in,
149         struct fbuf_t *out, AVPicture *p_out);
150
151 struct video_codec_desc;        /* forward declaration */
152 /*
153  * Descriptor of the local source, made of the following pieces:
154  *  + configuration info (geometry, device name, fps...). These are read
155  *    from the config file and copied here before calling video_out_init();
156  *  + the frame buffer (buf) and source pixel format, allocated at init time;
157  *  + the encoding and RTP info, including timestamps to generate
158  *    frames at the correct rate;
159  *  + source-specific info, i.e. fd for /dev/video, dpy-image for x11, etc,
160  *    filled in by grabber_open
161  * NOTE: loc_src.data == NULL means the rest of the struct is invalid, and
162  *      the video source is not available.
163  */
164 struct video_out_desc {
165         /* video device support.
166          * videodevice and geometry are read from the config file.
167          * At the right time we try to open it and allocate a buffer.
168          * If we are successful, webcam_bufsize > 0 and we can read.
169          */
170         /* all the following is config file info copied from the parent */
171         char            videodevice[64];
172         int             fps;
173         int             bitrate;
174         int             qmin;
175
176         int sendvideo;
177
178         struct fbuf_t   loc_src_geometry;       /* local source geometry only (from config file) */
179         struct fbuf_t   enc_out;        /* encoder output buffer, allocated in video_out_init() */
180
181         struct video_codec_desc *enc;   /* encoder */
182         void            *enc_ctx;       /* encoding context */
183         AVCodec         *codec;
184         AVFrame         *enc_in_frame;  /* enc_in mapped into avcodec format. */
185                                         /* The initial part of AVFrame is an AVPicture */
186         int             mtu;
187         struct timeval  last_frame;     /* when we read the last frame ? */
188
189         struct grab_desc *grabber;
190         void            *grabber_data;
191 };
192
193 /*
194  * The overall descriptor, with room for config info, video source and
195  * received data descriptors, SDL info, etc.
196  * This should be globally visible to all modules (grabber, vcodecs, gui)
197  * and contain all configurtion info.
198  */
199 struct video_desc {
200         char                    codec_name[64]; /* the codec we use */
201
202         int                     stayopen;       /* set if gui starts manually */
203         pthread_t               vthread;        /* video thread */
204         ast_mutex_t             dec_lock;       /* sync decoder and video thread */
205         int                     shutdown;       /* set to shutdown vthread */
206         struct ast_channel      *owner;         /* owner channel */
207
208
209         struct fbuf_t   enc_in;         /* encoder input buffer, allocated in video_out_init() */
210
211         char                    keypad_file[256];       /* image for the keypad */
212         char                    keypad_font[256];       /* font for the keypad */
213
214         char                    sdl_videodriver[256];
215
216         struct fbuf_t           rem_dpy;        /* display remote video, no buffer (it is in win[WIN_REMOTE].bmp) */
217         struct fbuf_t           loc_dpy;        /* display local source, no buffer (managed by SDL in bmp[1]) */
218
219
220         /* local information for grabbers, codecs, gui */
221         struct gui_info         *gui;
222         struct video_dec_desc   *in;            /* remote video descriptor */
223         struct video_out_desc   out;            /* local video descriptor */
224 };
225
226 static AVPicture *fill_pict(struct fbuf_t *b, AVPicture *p);
227
228 void fbuf_free(struct fbuf_t *b)
229 {
230         struct fbuf_t x = *b;
231
232         if (b->data && b->size)
233                 ast_free(b->data);
234         bzero(b, sizeof(*b));
235         /* restore some fields */
236         b->w = x.w;
237         b->h = x.h;
238         b->pix_fmt = x.pix_fmt;
239 }
240
241 #include "vcodecs.c"
242 #include "console_gui.c"
243
244 /*! \brief Try to open a video source, return 0 on success, 1 on error */
245 static int grabber_open(struct video_out_desc *v)
246 {
247         struct grab_desc *g;
248         void *g_data;
249         int i;
250
251         for (i = 0; (g = console_grabbers[i]); i++) {
252                 g_data = g->open(v->videodevice, &v->loc_src_geometry, v->fps);
253                 if (g_data) {
254                         v->grabber = g;
255                         v->grabber_data = g_data;
256                         return 0;
257                 }
258         }
259         return 1; /* no source found */
260 }
261
262 /*! \brief complete a buffer from the local video source.
263  * Called by get_video_frames(), in turn called by the video thread.
264  */
265 static struct fbuf_t *grabber_read(struct video_out_desc *v)
266 {
267         struct timeval now = ast_tvnow();
268
269         if (v->grabber == NULL) /* not initialized */
270                 return 0;
271
272         /* check if it is time to read */
273         if (ast_tvzero(v->last_frame))
274                 v->last_frame = now;
275         if (ast_tvdiff_ms(now, v->last_frame) < 1000/v->fps)
276                 return 0;       /* too early */
277         v->last_frame = now; /* XXX actually, should correct for drift */
278         return v->grabber->read(v->grabber_data);
279 }
280
281 /*! \brief handler run when dragging with the left button on
282  * the local source window - the effect is to move the offset
283  * of the captured area.
284  */
285 static void grabber_move(struct video_out_desc *v, int dx, int dy)
286 {
287         if (v->grabber && v->grabber->move)
288                 v->grabber->move(v->grabber_data, dx, dy);
289 }
290
291 /*
292  * Map the codec name to the library. If not recognised, use a default.
293  * This is useful in the output path where we decide by name, presumably.
294  */
295 static struct video_codec_desc *map_config_video_format(char *name)
296 {
297         int i;
298
299         for (i = 0; supported_codecs[i]; i++)
300                 if (!strcasecmp(name, supported_codecs[i]->name))
301                         break;
302         if (supported_codecs[i] == NULL) {
303                 ast_log(LOG_WARNING, "Cannot find codec for '%s'\n", name);
304                 i = 0;
305                 strcpy(name, supported_codecs[i]->name);
306         }
307         ast_log(LOG_WARNING, "Using codec '%s'\n", name);
308         return supported_codecs[i];
309 }
310
311
312 /*! \brief uninitialize the descriptor for local video stream */
313 static int video_out_uninit(struct video_desc *env)
314 {
315         struct video_out_desc *v = &env->out;
316
317         /* XXX this should be a codec callback */
318         if (v->enc_ctx) {
319                 AVCodecContext *enc_ctx = (AVCodecContext *)v->enc_ctx;
320                 avcodec_close(enc_ctx);
321                 av_free(enc_ctx);
322                 v->enc_ctx = NULL;
323         }
324         if (v->enc_in_frame) {
325                 av_free(v->enc_in_frame);
326                 v->enc_in_frame = NULL;
327         }
328         v->codec = NULL;        /* nothing to free, this is only a reference */
329         /* release the buffers */
330         fbuf_free(&env->enc_in);
331         fbuf_free(&v->enc_out);
332         /* close the grabber */
333         if (v->grabber) {
334                 v->grabber_data = v->grabber->close(v->grabber_data);
335                 v->grabber = NULL;
336         }
337         return -1;
338 }
339
340 /*
341  * Initialize the encoder for the local source:
342  * - enc_ctx, codec, enc_in_frame are used by ffmpeg for encoding;
343  * - enc_out is used to store the encoded frame (to be sent)
344  * - mtu is used to determine the max size of video fragment
345  * NOTE: we enter here with the video source already open.
346  */
347 static int video_out_init(struct video_desc *env)
348 {
349         int codec;
350         int size;
351         struct fbuf_t *enc_in;
352         struct video_out_desc *v = &env->out;
353
354         v->enc_ctx              = NULL;
355         v->codec                = NULL;
356         v->enc_in_frame         = NULL;
357         v->enc_out.data         = NULL;
358
359         codec = map_video_format(v->enc->format, CM_WR);
360         v->codec = avcodec_find_encoder(codec);
361         if (!v->codec) {
362                 ast_log(LOG_WARNING, "Cannot find the encoder for format %d\n",
363                         codec);
364                 return -1;      /* error, but nothing to undo yet */
365         }
366
367         v->mtu = 1400;  /* set it early so the encoder can use it */
368
369         /* allocate the input buffer for encoding.
370          * ffmpeg only supports PIX_FMT_YUV420P for the encoding.
371          */
372         enc_in = &env->enc_in;
373         enc_in->pix_fmt = PIX_FMT_YUV420P;
374         enc_in->size = (enc_in->w * enc_in->h * 3)/2;
375         enc_in->data = ast_calloc(1, enc_in->size);
376         if (!enc_in->data) {
377                 ast_log(LOG_WARNING, "Cannot allocate encoder input buffer\n");
378                 return video_out_uninit(env);
379         }
380         /* construct an AVFrame that points into buf_in */
381         v->enc_in_frame = avcodec_alloc_frame();
382         if (!v->enc_in_frame) {
383                 ast_log(LOG_WARNING, "Unable to allocate the encoding video frame\n");
384                 return video_out_uninit(env);
385         }
386
387         /* parameters for PIX_FMT_YUV420P */
388         size = enc_in->w * enc_in->h;
389         v->enc_in_frame->data[0] = enc_in->data;
390         v->enc_in_frame->data[1] = v->enc_in_frame->data[0] + size;
391         v->enc_in_frame->data[2] = v->enc_in_frame->data[1] + size/4;
392         v->enc_in_frame->linesize[0] = enc_in->w;
393         v->enc_in_frame->linesize[1] = enc_in->w/2;
394         v->enc_in_frame->linesize[2] = enc_in->w/2;
395
396         /* now setup the parameters for the encoder.
397          * XXX should be codec-specific
398          */
399     {
400         AVCodecContext *enc_ctx = avcodec_alloc_context();
401         v->enc_ctx = enc_ctx;
402         enc_ctx->pix_fmt = enc_in->pix_fmt;
403         enc_ctx->width = enc_in->w;
404         enc_ctx->height = enc_in->h;
405         /* XXX rtp_callback ?
406          * rtp_mode so ffmpeg inserts as many start codes as possible.
407          */
408         enc_ctx->rtp_mode = 1;
409         enc_ctx->rtp_payload_size = v->mtu / 2; // mtu/2
410         enc_ctx->bit_rate = v->bitrate;
411         enc_ctx->bit_rate_tolerance = enc_ctx->bit_rate/2;
412         enc_ctx->qmin = v->qmin;        /* should be configured */
413         enc_ctx->time_base = (AVRational){1, v->fps};
414         enc_ctx->gop_size = v->fps*5; // emit I frame every 5 seconds
415
416         v->enc->enc_init(v->enc_ctx);
417  
418         if (avcodec_open(enc_ctx, v->codec) < 0) {
419                 ast_log(LOG_WARNING, "Unable to initialize the encoder %d\n",
420                         codec);
421                 av_free(enc_ctx);
422                 v->enc_ctx = NULL;
423                 return video_out_uninit(env);
424         }
425     }
426         /*
427          * Allocate enough for the encoded bitstream. As we are compressing,
428          * we hope that the output is never larger than the input size.
429          */
430         v->enc_out.data = ast_calloc(1, enc_in->size);
431         v->enc_out.size = enc_in->size;
432         v->enc_out.used = 0;
433
434         return 0;
435 }
436
437 /*! \brief possibly uninitialize the video console.
438  * Called at the end of a call, should reset the 'owner' field,
439  * then possibly terminate the video thread if the gui has
440  * not been started manually.
441  * In practice, signal the thread and give it a bit of time to
442  * complete, giving up if it gets stuck. Because uninit
443  * is called from hangup with the channel locked, and the thread
444  * uses the chan lock, we need to unlock here. This is unsafe,
445  * and we should really use refcounts for the channels.
446  */
447 void console_video_uninit(struct video_desc *env)
448 {
449         int i, t = 100; /* initial wait is shorter, than make it longer */
450         if (env->stayopen == 0) {       /* in a call */
451                 env->shutdown = 1;
452                 for (i=0; env->shutdown && i < 10; i++) {
453                         if (env->owner)
454                                 ast_channel_unlock(env->owner);
455                         usleep(t);
456                         t = 1000000;
457                         if (env->owner)
458                                 ast_channel_lock(env->owner);
459                 }
460         }
461         env->owner = NULL;      /* this is unconditional */
462 }
463
464 /*! fill an AVPicture from our fbuf info, as it is required by
465  * the image conversion routines in ffmpeg.
466  * XXX This depends on the format.
467  */
468 static AVPicture *fill_pict(struct fbuf_t *b, AVPicture *p)
469 {
470         /* provide defaults for commonly used formats */
471         int l4 = b->w * b->h/4; /* size of U or V frame */
472         int len = b->w;         /* Y linesize, bytes */
473         int luv = b->w/2;       /* U/V linesize, bytes */
474
475         bzero(p, sizeof(*p));
476         switch (b->pix_fmt) {
477         case PIX_FMT_RGB555:
478         case PIX_FMT_RGB565:
479                 len *= 2;
480                 luv = 0;
481                 break;
482         case PIX_FMT_RGBA32:
483                 len *= 4;
484                 luv = 0;
485                 break;
486         case PIX_FMT_YUYV422:   /* Packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr */
487                 len *= 2;       /* all data in first plane, probably */
488                 luv = 0;
489                 break;
490         }
491         p->data[0] = b->data;
492         p->linesize[0] = len;
493         /* these are only valid for component images */
494         p->data[1] = luv ? b->data + 4*l4 : b->data+len;
495         p->data[2] = luv ? b->data + 5*l4 : b->data+len;
496         p->linesize[1] = luv;
497         p->linesize[2] = luv;
498         return p;
499 }
500
501 /*! convert/scale between an input and an output format.
502  * Old version of ffmpeg only have img_convert, which does not rescale.
503  * New versions use sws_scale which does both.
504  */
505 static void my_scale(struct fbuf_t *in, AVPicture *p_in,
506         struct fbuf_t *out, AVPicture *p_out)
507 {
508         AVPicture my_p_in, my_p_out;
509
510         if (p_in == NULL)
511                 p_in = fill_pict(in, &my_p_in);
512         if (p_out == NULL)
513                 p_out = fill_pict(out, &my_p_out);
514
515 #ifdef OLD_FFMPEG
516         /* XXX img_convert is deprecated, and does not do rescaling */
517         img_convert(p_out, out->pix_fmt,
518                 p_in, in->pix_fmt, in->w, in->h);
519 #else /* XXX replacement */
520     {
521         struct SwsContext *convert_ctx;
522
523         convert_ctx = sws_getContext(in->w, in->h, in->pix_fmt,
524                 out->w, out->h, out->pix_fmt,
525                 SWS_BICUBIC, NULL, NULL, NULL);
526         if (convert_ctx == NULL) {
527                 ast_log(LOG_ERROR, "FFMPEG::convert_cmodel : swscale context initialization failed");
528                 return;
529         }
530         if (0)
531                 ast_log(LOG_WARNING, "in %d %dx%d out %d %dx%d\n",
532                         in->pix_fmt, in->w, in->h, out->pix_fmt, out->w, out->h);
533         sws_scale(convert_ctx,
534                 p_in->data, p_in->linesize,
535                 in->w, in->h, /* src slice */
536                 p_out->data, p_out->linesize);
537
538         sws_freeContext(convert_ctx);
539     }
540 #endif /* XXX replacement */
541 }
542
543 struct video_desc *get_video_desc(struct ast_channel *c);
544
545 /*
546  * This function is called (by asterisk) for each video packet
547  * coming from the network (the 'in' path) that needs to be processed.
548  * We need to reconstruct the entire video frame before we can decode it.
549  * After a video packet is received we have to:
550  * - extract the bitstream with pre_process_data()
551  * - append the bitstream to a buffer
552  * - if the fragment is the last (RTP Marker) we decode it with decode_video()
553  * - after the decoding is completed we display the decoded frame with show_frame()
554  */
555 int console_write_video(struct ast_channel *chan, struct ast_frame *f);
556 int console_write_video(struct ast_channel *chan, struct ast_frame *f)
557 {
558         struct video_desc *env = get_video_desc(chan);
559         struct video_dec_desc *v = env->in;
560
561         if (!env->gui)  /* no gui, no rendering */
562                 return 0;
563         if (v == NULL)
564                 env->in = v = dec_init(f->subclass & ~1);
565         if (v == NULL) {
566                 /* This is not fatal, but we won't have incoming video */
567                 ast_log(LOG_WARNING, "Cannot initialize input decoder\n");
568                 return 0;
569         }
570
571         if (v->dec_in_cur == NULL)      /* no buffer for incoming frames, drop */
572                 return 0;
573 #if defined(DROP_PACKETS) && DROP_PACKETS > 0
574         /* Simulate lost packets */
575         if ((random() % 10000) <= 100*DROP_PACKETS) {
576                 ast_log(LOG_NOTICE, "Packet lost [%d]\n", f->seqno);
577                 return 0;
578         }
579 #endif
580         if (v->discard) {
581                 /*
582                  * In discard mode, drop packets until we find one with
583                  * the RTP marker set (which is the end of frame).
584                  * Note that the RTP marker flag is sent as the LSB of the
585                  * subclass, which is a  bitmask of formats. The low bit is
586                  * normally used for audio so there is no interference.
587                  */
588                 if (f->subclass & 0x01) {
589                         v->dec_in_cur->used = 0;
590                         v->dec_in_cur->ebit = 0;
591                         v->next_seq = f->seqno + 1;     /* wrap at 16 bit */
592                         v->discard = 0;
593                         ast_log(LOG_WARNING, "out of discard mode, frame %d\n", f->seqno);
594                 }
595                 return 0;
596         }
597
598         /*
599          * Only in-order fragments will be accepted. Remember seqno
600          * has 16 bit so there is wraparound. Also, ideally we could
601          * accept a bit of reordering, but at the moment we don't.
602          */
603         if (v->next_seq != f->seqno) {
604                 ast_log(LOG_WARNING, "discarding frame out of order, %d %d\n",
605                         v->next_seq, f->seqno);
606                 v->discard = 1;
607                 return 0;
608         }
609         v->next_seq++;
610
611         if (f->data == NULL || f->datalen < 2) {
612                 ast_log(LOG_WARNING, "empty video frame, discard\n");
613                 return 0;
614         }
615         if (v->d_callbacks->dec_decap(v->dec_in_cur, f->data, f->datalen)) {
616                 ast_log(LOG_WARNING, "error in dec_decap, enter discard\n");
617                 v->discard = 1;
618         }
619         if (f->subclass & 0x01) {       // RTP Marker
620                 /* prepare to decode: advance the buffer so the video thread knows. */
621                 struct fbuf_t *tmp = v->dec_in_cur;     /* store current pointer */
622                 ast_mutex_lock(&env->dec_lock);
623                 if (++v->dec_in_cur == &v->dec_in[N_DEC_IN])    /* advance to next, circular */
624                         v->dec_in_cur = &v->dec_in[0];
625                 if (v->dec_in_dpy == NULL) {    /* were not displaying anything, so set it */
626                         v->dec_in_dpy = tmp;
627                 } else if (v->dec_in_dpy == v->dec_in_cur) { /* current slot is busy */
628                         v->dec_in_cur = NULL;
629                 }
630                 ast_mutex_unlock(&env->dec_lock);
631         }
632         return 0;
633 }
634
635
636 /*! \brief read a frame from webcam or X11 through grabber_read(),
637  * display it,  then encode and split it.
638  * Return a list of ast_frame representing the video fragments.
639  * The head pointer is returned by the function, the tail pointer
640  * is returned as an argument.
641  */
642 static struct ast_frame *get_video_frames(struct video_desc *env, struct ast_frame **tail)
643 {
644         struct video_out_desc *v = &env->out;
645         struct ast_frame *dummy;
646         struct fbuf_t *loc_src = grabber_read(v);
647
648         if (!loc_src)
649                 return NULL;    /* can happen, e.g. we are reading too early */
650
651         if (tail == NULL)
652                 tail = &dummy;
653         *tail = NULL;
654         /* Scale the video for the encoder, then use it for local rendering
655          * so we will see the same as the remote party.
656          */
657         my_scale(loc_src, NULL, &env->enc_in, NULL);
658         show_frame(env, WIN_LOCAL);
659         if (!v->sendvideo)
660                 return NULL;
661         if (v->enc_out.data == NULL) {
662                 static volatile int a = 0;
663                 if (a++ < 2)
664                         ast_log(LOG_WARNING, "fail, no encoder output buffer\n");
665                 return NULL;
666         }
667         v->enc->enc_run(v);
668         return v->enc->enc_encap(&v->enc_out, v->mtu, tail);
669 }
670
671 /*
672  * Helper thread to periodically poll the video source and enqueue the
673  * generated frames to the channel's queue.
674  * Using a separate thread also helps because the encoding can be
675  * computationally expensive so we don't want to starve the main thread.
676  */
677 static void *video_thread(void *arg)
678 {
679         struct video_desc *env = arg;
680         int count = 0;
681         char save_display[128] = "";
682
683         /* if sdl_videodriver is set, override the environment. Also,
684          * if it contains 'console' override DISPLAY around the call to SDL_Init
685          * so we use the console as opposed to the x11 version of aalib
686          */
687         if (!ast_strlen_zero(env->sdl_videodriver)) { /* override */
688                 const char *s = getenv("DISPLAY");
689                 setenv("SDL_VIDEODRIVER", env->sdl_videodriver, 1);
690                 if (s && !strcasecmp(env->sdl_videodriver, "aalib-console")) {
691                         ast_copy_string(save_display, s, sizeof(save_display));
692                         unsetenv("DISPLAY");
693                 }
694         }
695         sdl_setup(env);
696         if (!ast_strlen_zero(save_display))
697                 setenv("DISPLAY", save_display, 1);
698
699         /* initialize grab coordinates */
700         env->out.loc_src_geometry.x = 0;
701         env->out.loc_src_geometry.y = 0;
702
703         ast_mutex_init(&env->dec_lock); /* used to sync decoder and renderer */
704
705         if (grabber_open(&env->out)) {
706                 ast_log(LOG_WARNING, "cannot open local video source\n");
707         } else {
708 #if 0
709                 /* In principle, try to register the fd.
710                  * In practice, many webcam drivers do not support select/poll,
711                  * so don't bother and instead read periodically from the
712                  * video thread.
713                  */
714                 if (env->out.fd >= 0)
715                         ast_channel_set_fd(env->owner, 1, env->out.fd);
716 #endif
717                 video_out_init(env);
718         }
719
720         for (;;) {
721                 struct timeval t = { 0, 50000 };        /* XXX 20 times/sec */
722                 struct ast_frame *p, *f;
723                 struct ast_channel *chan;
724                 int fd;
725                 char *caption = NULL, buf[160];
726
727                 /* determine if video format changed */
728                 if (count++ % 10 == 0) {
729                         if (env->out.sendvideo)
730                             sprintf(buf, "%s %s %dx%d @@ %dfps %dkbps",
731                                 env->out.videodevice, env->codec_name,
732                                 env->enc_in.w, env->enc_in.h,
733                                 env->out.fps, env->out.bitrate/1000);
734                         else
735                             sprintf(buf, "hold");
736                         caption = buf;
737                 }
738
739                 /* manage keypad events */
740                 /* XXX here we should always check for events,
741                 * otherwise the drag will not work */ 
742                 if (env->gui)
743                         eventhandler(env, caption);
744  
745                 /* sleep for a while */
746                 ast_select(0, NULL, NULL, NULL, &t);
747
748             if (env->in) {
749                 struct video_dec_desc *v = env->in;
750                 
751                 /*
752                  * While there is something to display, call the decoder and free
753                  * the buffer, possibly enabling the receiver to store new data.
754                  */
755                 while (v->dec_in_dpy) {
756                         struct fbuf_t *tmp = v->dec_in_dpy;     /* store current pointer */
757
758                         if (v->d_callbacks->dec_run(v, tmp))
759                                 show_frame(env, WIN_REMOTE);
760                         tmp->used = 0;  /* mark buffer as free */
761                         tmp->ebit = 0;
762                         ast_mutex_lock(&env->dec_lock);
763                         if (++v->dec_in_dpy == &v->dec_in[N_DEC_IN])    /* advance to next, circular */
764                                 v->dec_in_dpy = &v->dec_in[0];
765
766                         if (v->dec_in_cur == NULL)      /* receiver was idle, enable it... */
767                                 v->dec_in_cur = tmp;    /* using the slot just freed */
768                         else if (v->dec_in_dpy == v->dec_in_cur) /* this was the last slot */
769                                 v->dec_in_dpy = NULL;   /* nothing more to display */
770                         ast_mutex_unlock(&env->dec_lock);
771                 }
772             }
773
774                 if (env->shutdown)
775                         break;
776                 f = get_video_frames(env, &p);  /* read and display */
777                 if (!f)
778                         continue;
779                 chan = env->owner;
780                 if (chan == NULL)
781                         continue;
782                 fd = chan->alertpipe[1];
783                 ast_channel_lock(chan);
784
785                 /* AST_LIST_INSERT_TAIL is only good for one frame, cannot use here */
786                 if (chan->readq.first == NULL) {
787                         chan->readq.first = f;
788                 } else {
789                         chan->readq.last->frame_list.next = f;
790                 }
791                 chan->readq.last = p;
792                 /*
793                  * more or less same as ast_queue_frame, but extra
794                  * write on the alertpipe to signal frames.
795                  */
796                 if (fd > -1) {
797                         int blah = 1, l = sizeof(blah);
798                         for (p = f; p; p = AST_LIST_NEXT(p, frame_list)) {
799                                 if (write(fd, &blah, l) != l)
800                                         ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d: %s!\n",
801                                             chan->name, f->frametype, f->subclass, strerror(errno));
802                         }
803                 }
804                 ast_channel_unlock(chan);
805         }
806         /* thread terminating, here could call the uninit */
807         /* uninitialize the local and remote video environments */
808         env->in = dec_uninit(env->in);
809         video_out_uninit(env);
810
811         if (env->gui)
812                 env->gui = cleanup_sdl(env->gui);
813         ast_mutex_destroy(&env->dec_lock);
814         env->shutdown = 0;
815         return NULL;
816 }
817
818 static void copy_geometry(struct fbuf_t *src, struct fbuf_t *dst)
819 {
820         if (dst->w == 0)
821                 dst->w = src->w;
822         if (dst->h == 0)
823                 dst->h = src->h;
824 }
825
826 /*! initialize the video environment.
827  * Apart from the formats (constant) used by sdl and the codec,
828  * we use enc_in as the basic geometry.
829  */
830 static void init_env(struct video_desc *env)
831 {
832         struct fbuf_t *c = &(env->out.loc_src_geometry);                /* local source */
833         struct fbuf_t *ei = &(env->enc_in);             /* encoder input */
834         struct fbuf_t *ld = &(env->loc_dpy);    /* local display */
835         struct fbuf_t *rd = &(env->rem_dpy);            /* remote display */
836
837         c->pix_fmt = PIX_FMT_YUV420P;   /* default - camera format */
838         ei->pix_fmt = PIX_FMT_YUV420P;  /* encoder input */
839         if (ei->w == 0 || ei->h == 0) {
840                 ei->w = 352;
841                 ei->h = 288;
842         }
843         ld->pix_fmt = rd->pix_fmt = PIX_FMT_YUV420P; /* sdl format */
844         /* inherit defaults */
845         copy_geometry(ei, c);   /* camera inherits from encoder input */
846         copy_geometry(ei, rd);  /* remote display inherits from encoder input */
847         copy_geometry(rd, ld);  /* local display inherits from remote display */
848 }
849
850 /*!
851  * The first call to the video code, called by oss_new() or similar.
852  * Here we initialize the various components we use, namely SDL for display,
853  * ffmpeg for encoding/decoding, and a local video source.
854  * We do our best to progress even if some of the components are not
855  * available.
856  */
857 void console_video_start(struct video_desc *env, struct ast_channel *owner)
858 {
859         ast_log(LOG_WARNING, "env %p chan %p\n", env, owner);
860         if (env == NULL)        /* video not initialized */
861                 return;
862         env->owner = owner;     /* work even if no owner is specified */
863         if (env->stayopen)
864                 return;         /* already initialized, nothing to do */
865         init_env(env);
866         env->out.enc = map_config_video_format(env->codec_name);
867
868         ast_log(LOG_WARNING, "start video out %s %dx%d\n",
869                 env->codec_name, env->enc_in.w,  env->enc_in.h);
870         /*
871          * Register all codecs supported by the ffmpeg library.
872          * We only need to do it once, but probably doesn't
873          * harm to do it multiple times.
874          */
875         avcodec_init();
876         avcodec_register_all();
877         av_log_set_level(AV_LOG_ERROR); /* only report errors */
878
879         if (env->out.fps == 0) {
880                 env->out.fps = 15;
881                 ast_log(LOG_WARNING, "fps unset, forcing to %d\n", env->out.fps);
882         }
883         if (env->out.bitrate == 0) {
884                 env->out.bitrate = 65000;
885                 ast_log(LOG_WARNING, "bitrate unset, forcing to %d\n", env->out.bitrate);
886         }
887         ast_pthread_create_background(&env->vthread, NULL, video_thread, env);
888         if (env->owner == NULL)
889                 env->stayopen = 1;      /* manually opened so don't close on hangup */
890 }
891
892 /*
893  * Parse a geometry string, accepting also common names for the formats.
894  * Trick: if we have a leading > or < and a numeric geometry,
895  * return the larger or smaller one.
896  * E.g. <352x288 gives the smaller one, 320x240
897  */
898 static int video_geom(struct fbuf_t *b, const char *s)
899 {
900         int w = 0, h = 0;
901
902         static struct {
903                 const char *s; int w; int h;
904         } *fp, formats[] = {
905                 {"16cif",       1408, 1152 },
906                 {"xga",         1024, 768 },
907                 {"4cif",        704, 576 },
908                 {"vga",         640, 480 },
909                 {"cif",         352, 288 },
910                 {"qvga",        320, 240 },
911                 {"qcif",        176, 144 },
912                 {"sqcif",       128, 96 },
913                 {NULL,          0, 0 },
914         };
915         if (*s == '<' || *s == '>')
916                 sscanf(s+1,"%dx%d", &w, &h);
917         for (fp = formats; fp->s; fp++) {
918                 if (*s == '>') {        /* look for a larger one */
919                         if (fp->w <= w) {
920                                 if (fp > formats)
921                                         fp--; /* back one step if possible */
922                                 break;
923                         }
924                 } else if (*s == '<') { /* look for a smaller one */
925                         if (fp->w < w)
926                                 break;
927                 } else if (!strcasecmp(s, fp->s)) { /* look for a string */
928                         break;
929                 }
930         }
931         if (*s == '<' && fp->s == NULL) /* smallest */
932                 fp--;
933         if (fp->s) {
934                 b->w = fp->w;
935                 b->h = fp->h;
936         } else if (sscanf(s, "%dx%d", &b->w, &b->h) != 2) {
937                 ast_log(LOG_WARNING, "Invalid video_size %s, using 352x288\n", s);
938                 b->w = 352;
939                 b->h = 288;
940         }
941         return 0;
942 }
943
944 /* extend ast_cli with video commands. Called by console_video_config */
945 int console_video_cli(struct video_desc *env, const char *var, int fd)
946 {
947         if (env == NULL)
948                 return 1;       /* unrecognised */
949
950         if (!strcasecmp(var, "videodevice")) {
951                 ast_cli(fd, "videodevice is [%s]\n", env->out.videodevice);
952         } else if (!strcasecmp(var, "videocodec")) {
953                 ast_cli(fd, "videocodec is [%s]\n", env->codec_name);
954         } else if (!strcasecmp(var, "sendvideo")) {
955                 ast_cli(fd, "sendvideo is [%s]\n", env->out.sendvideo ? "on" : "off");
956         } else if (!strcasecmp(var, "video_size")) {
957                 int in_w = 0, in_h = 0;
958                 if (env->in) {
959                         in_w = env->in->dec_out.w;
960                         in_h = env->in->dec_out.h;
961                 }
962                 ast_cli(fd, "sizes: video %dx%d camera %dx%d local %dx%d remote %dx%d in %dx%d\n",
963                         env->enc_in.w, env->enc_in.h,
964                         env->out.loc_src_geometry.w, env->out.loc_src_geometry.h,
965                         env->loc_dpy.w, env->loc_dpy.h,
966                         env->rem_dpy.w, env->rem_dpy.h,
967                         in_w, in_h);
968         } else if (!strcasecmp(var, "bitrate")) {
969                 ast_cli(fd, "bitrate is [%d]\n", env->out.bitrate);
970         } else if (!strcasecmp(var, "qmin")) {
971                 ast_cli(fd, "qmin is [%d]\n", env->out.qmin);
972         } else if (!strcasecmp(var, "fps")) {
973                 ast_cli(fd, "fps is [%d]\n", env->out.fps);
974         } else if (!strcasecmp(var, "startgui")) {
975                 console_video_start(env, NULL);
976         } else if (!strcasecmp(var, "stopgui") && env->stayopen != 0) {
977                 env->stayopen = 0;
978                 if (env->gui && env->owner)
979                         ast_cli_command(-1, "console hangup");
980                 else /* not in a call */
981                         console_video_uninit(env);
982         } else {
983                 return 1;       /* unrecognised */
984         }
985         return 0;       /* recognised */
986 }
987
988 /*! parse config command for video support. */
989 int console_video_config(struct video_desc **penv,
990         const char *var, const char *val)
991 {
992         struct video_desc *env;
993
994         if (penv == NULL) {
995                 ast_log(LOG_WARNING, "bad argument penv=NULL\n");
996                 return 1;       /* error */
997         }
998         /* allocate the video descriptor first time we get here */
999         env = *penv;
1000         if (env == NULL) {
1001                 env = *penv = ast_calloc(1, sizeof(struct video_desc));
1002                 if (env == NULL) {
1003                         ast_log(LOG_WARNING, "fail to allocate video_desc\n");
1004                         return 1;       /* error */
1005                 
1006                 }
1007                 /* set default values */
1008                 ast_copy_string(env->out.videodevice, "X11", sizeof(env->out.videodevice));
1009                 env->out.fps = 5;
1010                 env->out.bitrate = 65000;
1011                 env->out.sendvideo = 1;
1012                 env->out.qmin = 3;
1013         }
1014         CV_START(var, val);
1015         CV_STR("videodevice", env->out.videodevice);
1016         CV_BOOL("sendvideo", env->out.sendvideo);
1017         CV_F("video_size", video_geom(&env->enc_in, val));
1018         CV_F("camera_size", video_geom(&env->out.loc_src_geometry, val));
1019         CV_F("local_size", video_geom(&env->loc_dpy, val));
1020         CV_F("remote_size", video_geom(&env->rem_dpy, val));
1021         CV_STR("keypad", env->keypad_file);
1022         CV_F("region", keypad_cfg_read(env->gui, val));
1023         CV_STR("keypad_font", env->keypad_font);
1024         CV_STR("sdl_videodriver", env->sdl_videodriver);
1025         CV_UINT("fps", env->out.fps);
1026         CV_UINT("bitrate", env->out.bitrate);
1027         CV_UINT("qmin", env->out.qmin);
1028         CV_STR("videocodec", env->codec_name);
1029         return 1;       /* nothing found */
1030
1031         CV_END;         /* the 'nothing found' case */
1032         return 0;               /* found something */
1033 }
1034
1035 #endif  /* video support */