3281 lines
94 KiB
C
3281 lines
94 KiB
C
|
/*
|
||
|
* Experimental support for video sessions. We use SDL for rendering, ffmpeg
|
||
|
* as the codec library for encoding and decoding, and Video4Linux and X11
|
||
|
* to generate the local video stream.
|
||
|
*
|
||
|
* If one of these pieces is not available, either at compile time or at
|
||
|
* runtime, we do our best to run without it. Of course, no codec library
|
||
|
* means we can only deal with raw data, no SDL means we cannot do rendering,
|
||
|
* no V4L or X11 means we cannot generate data (but in principle we could
|
||
|
* stream from or record to a file).
|
||
|
*
|
||
|
* We need a recent (2007.07.12 or newer) version of ffmpeg to avoid warnings.
|
||
|
* Older versions might give 'deprecated' messages during compilation,
|
||
|
* thus not compiling in AST_DEVMODE, or don't have swscale, in which case
|
||
|
* you can try to compile #defining OLD_FFMPEG here.
|
||
|
*
|
||
|
* $Revision$
|
||
|
*/
|
||
|
|
||
|
//#define DROP_PACKETS 5 /* if set, drop this % of video packets */
|
||
|
//#define OLD_FFMPEG 1 /* set for old ffmpeg with no swscale */
|
||
|
|
||
|
|
||
|
/*
|
||
|
The code is structured as follows.
|
||
|
|
||
|
When a new console channel is created, we call console_video_start()
|
||
|
to initialize SDL, the source, and the encoder/ decoder for the
|
||
|
formats in use (XXX the latter two should be done later, once the
|
||
|
codec negotiation is complete). Also, a thread is created to handle
|
||
|
the video source and generate frames.
|
||
|
|
||
|
While communication is on, the local source is generated by the
|
||
|
video thread, which wakes up periodically, generates frames and
|
||
|
enqueues them in chan->readq. Incoming rtp frames are passed to
|
||
|
console_write_video(), decoded and passed to SDL for display.
|
||
|
|
||
|
For as unfortunate and confusing as it can be, we need to deal with a
|
||
|
number of different video representations (size, codec/pixel format,
|
||
|
codec parameters), as follows:
|
||
|
|
||
|
loc_src is the data coming from the camera/X11/etc.
|
||
|
The format is typically constrained by the video source.
|
||
|
|
||
|
enc_in is the input required by the encoder.
|
||
|
Typically constrained in size by the encoder type.
|
||
|
|
||
|
enc_out is the bitstream transmitted over RTP.
|
||
|
Typically negotiated while the call is established.
|
||
|
|
||
|
loc_dpy is the format used to display the local video source.
|
||
|
Depending on user preferences this can have the same size as
|
||
|
loc_src_fmt, or enc_in_fmt, or thumbnail size (e.g. PiP output)
|
||
|
|
||
|
dec_in is the incoming RTP bitstream. Negotiated
|
||
|
during call establishment, it is not necessarily the same as
|
||
|
enc_in_fmt
|
||
|
|
||
|
dec_out the output of the decoder.
|
||
|
The format is whatever the other side sends, and the
|
||
|
buffer is allocated by avcodec_decode_... so we only
|
||
|
copy the data here.
|
||
|
|
||
|
rem_dpy the format used to display the remote stream
|
||
|
|
||
|
We store the format info together with the buffer storing the data.
|
||
|
As a future optimization, a format/buffer may reference another one
|
||
|
if the formats are equivalent. This will save some unnecessary format
|
||
|
conversion.
|
||
|
|
||
|
|
||
|
In order to handle video you need to add to sip.conf (and presumably
|
||
|
iax.conf too) the following:
|
||
|
|
||
|
[general](+)
|
||
|
videosupport=yes
|
||
|
allow=h263 ; this or other video formats
|
||
|
allow=h263p ; this or other video formats
|
||
|
|
||
|
*/
|
||
|
|
||
|
/*
|
||
|
* Codecs are absolutely necessary or we cannot do anything.
|
||
|
* In principle SDL is optional too (used for rendering only, but we
|
||
|
* could still source data withouth it), however at the moment it is required.
|
||
|
*/
|
||
|
#if defined(HAVE_FFMPEG) && defined(HAVE_SDL)
|
||
|
|
||
|
#ifdef HAVE_X11
|
||
|
#include <X11/Xlib.h> /* this should be conditional */
|
||
|
#endif
|
||
|
|
||
|
#include <ffmpeg/avcodec.h>
|
||
|
#ifndef OLD_FFMPEG
|
||
|
#include <ffmpeg/swscale.h> /* requires a recent ffmpeg */
|
||
|
#endif
|
||
|
|
||
|
#include <SDL/SDL.h>
|
||
|
#ifdef HAVE_SDL_IMAGE
|
||
|
#include <SDL/SDL_image.h> /* for loading images */
|
||
|
#endif
|
||
|
#ifdef HAVE_SDL_TTF
|
||
|
#include <SDL/SDL_ttf.h> /* render text on sdl surfaces */
|
||
|
#endif
|
||
|
|
||
|
/*
|
||
|
* In many places we use buffers to store the raw frames (but not only),
|
||
|
* so here is a structure to keep all the info. data = NULL means the
|
||
|
* structure is not initialized, so the other fields are invalid.
|
||
|
* size = 0 means the buffer is not malloc'ed so we don't have to free it.
|
||
|
*/
|
||
|
struct fbuf_t { /* frame buffers, dynamically allocated */
|
||
|
uint8_t *data; /* memory, malloced if size > 0, just reference
|
||
|
* otherwise */
|
||
|
int size; /* total size in bytes */
|
||
|
int used; /* space used so far */
|
||
|
int ebit; /* bits to ignore at the end */
|
||
|
int x; /* origin, if necessary */
|
||
|
int y;
|
||
|
int w; /* size */
|
||
|
int h;
|
||
|
int pix_fmt;
|
||
|
};
|
||
|
|
||
|
struct video_codec_desc; /* forward declaration */
|
||
|
/*
|
||
|
* Descriptor of the local source, made of the following pieces:
|
||
|
* + configuration info (geometry, device name, fps...). These are read
|
||
|
* from the config file and copied here before calling video_out_init();
|
||
|
* + the frame buffer (buf) and source pixel format, allocated at init time;
|
||
|
* + 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 video_open
|
||
|
* NOTE: loc_src.data == NULL means the rest of the struct is invalid, and
|
||
|
* the video source is not available.
|
||
|
*/
|
||
|
struct video_out_desc {
|
||
|
/* video device support.
|
||
|
* videodevice and geometry are read from the config file.
|
||
|
* At the right time we try to open it and allocate a buffer.
|
||
|
* 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;
|
||
|
|
||
|
int sendvideo;
|
||
|
|
||
|
struct fbuf_t loc_src; /* local source buffer, allocated in video_open() */
|
||
|
struct fbuf_t enc_in; /* encoder input buffer, allocated in video_out_init() */
|
||
|
struct fbuf_t enc_out; /* encoder output buffer, allocated in video_out_init() */
|
||
|
struct fbuf_t loc_dpy; /* display source buffer, no buffer (managed by SDL in bmp[1]) */
|
||
|
struct fbuf_t keypad_dpy; /* keypad source buffer, XXX */
|
||
|
|
||
|
struct video_codec_desc *enc; /* encoder */
|
||
|
AVCodecContext *enc_ctx; /* encoding context */
|
||
|
AVCodec *codec;
|
||
|
AVFrame *frame; /* The initial part is an AVPicture */
|
||
|
int mtu;
|
||
|
struct timeval last_frame; /* when we read the last frame ? */
|
||
|
|
||
|
/* device specific info */
|
||
|
int fd; /* file descriptor, for webcam */
|
||
|
#ifdef HAVE_X11
|
||
|
Display *dpy; /* x11 grabber info */
|
||
|
XImage *image;
|
||
|
int screen_width; /* width of X screen */
|
||
|
int screen_height; /* height of X screen */
|
||
|
#endif
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* Descriptor for the incoming stream, with a buffer for the bitstream
|
||
|
* extracted by the RTP packets, RTP reassembly info, and a frame buffer
|
||
|
* for the decoded frame (buf).
|
||
|
* and store the result in a suitable frame buffer for later display.
|
||
|
* NOTE: dec_ctx == NULL means the rest is invalid (e.g. because no
|
||
|
* codec, no memory, etc.) and we must drop all incoming frames.
|
||
|
*
|
||
|
* Incoming payload is stored in one of the dec_in[] buffers, which are
|
||
|
* emptied by the video thread. These buffers are organized in a circular
|
||
|
* queue, with dec_in_cur being the buffer in use by the incoming stream,
|
||
|
* and dec_in_dpy is the one being displayed. When the pointers need to
|
||
|
* be changed, we synchronize the access to them with dec_in_lock.
|
||
|
* When the list is full dec_in_cur = NULL (we cannot store new data),
|
||
|
* when the list is empty dec_in_dpy is NULL (we cannot display frames).
|
||
|
*/
|
||
|
struct video_in_desc {
|
||
|
struct video_codec_desc *dec; /* decoder */
|
||
|
AVCodecContext *dec_ctx; /* information about the codec in the stream */
|
||
|
AVCodec *codec; /* reference to the codec */
|
||
|
AVFrame *d_frame; /* place to store the decoded frame */
|
||
|
AVCodecParserContext *parser;
|
||
|
uint16_t next_seq; /* must be 16 bit */
|
||
|
int discard; /* flag for discard status */
|
||
|
#define N_DEC_IN 3 /* number of incoming buffers */
|
||
|
struct fbuf_t *dec_in_cur; /* buffer being filled in */
|
||
|
struct fbuf_t *dec_in_dpy; /* buffer to display */
|
||
|
ast_mutex_t dec_in_lock;
|
||
|
struct fbuf_t dec_in[N_DEC_IN]; /* incoming bitstream, allocated/extended in fbuf_append() */
|
||
|
struct fbuf_t dec_out; /* decoded frame, no buffer (data is in AVFrame) */
|
||
|
struct fbuf_t rem_dpy; /* display remote image, no buffer (it is in win[WIN_REMOTE].bmp) */
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* Each codec is defined by a number of callbacks
|
||
|
*/
|
||
|
/*! \brief initialize the encoder */
|
||
|
typedef int (*encoder_init_f)(struct video_out_desc *v);
|
||
|
|
||
|
/*! \brief actually call the encoder */
|
||
|
typedef int (*encoder_encode_f)(struct video_out_desc *v);
|
||
|
|
||
|
/*! \brief encapsulate the bistream in RTP frames */
|
||
|
typedef struct ast_frame *(*encoder_encap_f)(struct video_out_desc *out,
|
||
|
struct ast_frame **tail);
|
||
|
|
||
|
/*! \brief inizialize the decoder */
|
||
|
typedef int (*decoder_init_f)(struct video_in_desc *v);
|
||
|
|
||
|
/*! \brief extract the bitstream from RTP frames and store in the fbuf.
|
||
|
* return 0 if ok, 1 on error
|
||
|
*/
|
||
|
typedef int (*decoder_decap_f)(struct fbuf_t *b, uint8_t *data, int len);
|
||
|
|
||
|
/*! \brief actually call the decoder */
|
||
|
typedef int (*decoder_decode_f)(struct video_in_desc *v, struct fbuf_t *b);
|
||
|
|
||
|
struct video_codec_desc {
|
||
|
const char *name; /* format name */
|
||
|
int format; /* AST_FORMAT_* */
|
||
|
encoder_init_f enc_init;
|
||
|
encoder_encap_f enc_encap;
|
||
|
encoder_encode_f enc_run;
|
||
|
decoder_init_f dec_init;
|
||
|
decoder_decap_f dec_decap;
|
||
|
decoder_decode_f dec_run;
|
||
|
};
|
||
|
|
||
|
/* our representation of a displayed window. SDL can only do one main
|
||
|
* window so we map everything within that one
|
||
|
*/
|
||
|
enum { WIN_LOCAL, WIN_REMOTE, WIN_KEYPAD, WIN_MAX };
|
||
|
|
||
|
struct display_window {
|
||
|
SDL_Overlay *bmp;
|
||
|
SDL_Rect rect; /* loc. of images */
|
||
|
};
|
||
|
|
||
|
#define GUI_BUFFER_LEN 256 /* buffer lenght used for input buffers */
|
||
|
|
||
|
enum kp_type { KP_NONE, KP_RECT, KP_CIRCLE };
|
||
|
struct keypad_entry {
|
||
|
int c; /* corresponding character */
|
||
|
int x0, y0, x1, y1, h; /* arguments */
|
||
|
enum kp_type type;
|
||
|
};
|
||
|
|
||
|
/*! \brief info related to the gui: button status, mouse coords, etc. */
|
||
|
struct gui_info {
|
||
|
char inbuf[GUI_BUFFER_LEN]; /* buffer for to-dial buffer */
|
||
|
int inbuf_pos; /* next free position in inbuf */
|
||
|
char msgbuf[GUI_BUFFER_LEN]; /* buffer for text-message buffer */
|
||
|
int msgbuf_pos; /* next free position in msgbuf */
|
||
|
int text_mode; /* switch to-dial and text-message mode */
|
||
|
int drag_mode; /* switch phone and drag-source mode */
|
||
|
int x_drag; /* x coordinate where the drag starts */
|
||
|
int y_drag; /* y coordinate where the drag starts */
|
||
|
#ifdef HAVE_SDL_TTF
|
||
|
TTF_Font *font; /* font to be used */
|
||
|
#endif
|
||
|
int outfd; /* fd for output */
|
||
|
SDL_Surface *keypad; /* the pixmap for the keypad */
|
||
|
int kp_size, kp_used;
|
||
|
struct keypad_entry *kp;
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* The overall descriptor, with room for config info, video source and
|
||
|
* received data descriptors, SDL info, etc.
|
||
|
*/
|
||
|
struct video_desc {
|
||
|
char codec_name[64]; /* the codec we use */
|
||
|
|
||
|
pthread_t vthread; /* video thread */
|
||
|
int shutdown; /* set to shutdown vthread */
|
||
|
struct ast_channel *owner; /* owner channel */
|
||
|
|
||
|
struct video_in_desc in; /* remote video descriptor */
|
||
|
struct video_out_desc out; /* local video descriptor */
|
||
|
|
||
|
struct gui_info gui;
|
||
|
|
||
|
/* support for display. */
|
||
|
int sdl_ok;
|
||
|
int gui_ok;
|
||
|
SDL_Surface *screen; /* the main window */
|
||
|
char keypad_file[256]; /* image for the keypad */
|
||
|
char keypad_mask[256]; /* background for the keypad */
|
||
|
char keypad_font[256]; /* font for the keypad */
|
||
|
struct display_window win[WIN_MAX];
|
||
|
};
|
||
|
|
||
|
/*! The list of video formats we support. */
|
||
|
#define CONSOLE_FORMAT_VIDEO ( \
|
||
|
AST_FORMAT_H263_PLUS | AST_FORMAT_H263 | \
|
||
|
AST_FORMAT_MP4_VIDEO | \
|
||
|
AST_FORMAT_H264 | AST_FORMAT_H261)
|
||
|
|
||
|
static AVPicture *fill_pict(struct fbuf_t *b, AVPicture *p);
|
||
|
|
||
|
static void fbuf_free(struct fbuf_t *b)
|
||
|
{
|
||
|
struct fbuf_t x = *b;
|
||
|
|
||
|
if (b->data && b->size)
|
||
|
ast_free(b->data);
|
||
|
bzero(b, sizeof(*b));
|
||
|
/* restore some fields */
|
||
|
b->w = x.w;
|
||
|
b->h = x.h;
|
||
|
b->pix_fmt = x.pix_fmt;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Append a chunk of data to a buffer taking care of bit alignment
|
||
|
* Return 0 on success, != 0 on failure
|
||
|
*/
|
||
|
static int fbuf_append(struct fbuf_t *b, uint8_t *src, int len,
|
||
|
int sbit, int ebit)
|
||
|
{
|
||
|
/*
|
||
|
* Allocate buffer. ffmpeg wants an extra FF_INPUT_BUFFER_PADDING_SIZE,
|
||
|
* and also wants 0 as a buffer terminator to prevent trouble.
|
||
|
*/
|
||
|
int need = len + FF_INPUT_BUFFER_PADDING_SIZE;
|
||
|
int i;
|
||
|
uint8_t *dst, mask;
|
||
|
|
||
|
if (b->data == NULL) {
|
||
|
b->size = need;
|
||
|
b->used = 0;
|
||
|
b->ebit = 0;
|
||
|
b->data = ast_calloc(1, b->size);
|
||
|
} else if (b->used + need > b->size) {
|
||
|
b->size = b->used + need;
|
||
|
b->data = ast_realloc(b->data, b->size);
|
||
|
}
|
||
|
if (b->data == NULL) {
|
||
|
ast_log(LOG_WARNING, "alloc failure for %d, discard\n",
|
||
|
b->size);
|
||
|
return 1;
|
||
|
}
|
||
|
if (b->used == 0 && b->ebit != 0) {
|
||
|
ast_log(LOG_WARNING, "ebit not reset at start\n");
|
||
|
b->ebit = 0;
|
||
|
}
|
||
|
dst = b->data + b->used;
|
||
|
i = b->ebit + sbit; /* bits to ignore around */
|
||
|
if (i == 0) { /* easy case, just append */
|
||
|
/* do everything in the common block */
|
||
|
} else if (i == 8) { /* easy too, just handle the overlap byte */
|
||
|
mask = (1 << b->ebit) - 1;
|
||
|
/* update the last byte in the buffer */
|
||
|
dst[-1] &= ~mask; /* clear bits to ignore */
|
||
|
dst[-1] |= (*src & mask); /* append new bits */
|
||
|
src += 1; /* skip and prepare for common block */
|
||
|
len --;
|
||
|
} else { /* must shift the new block, not done yet */
|
||
|
ast_log(LOG_WARNING, "must handle shift %d %d at %d\n",
|
||
|
b->ebit, sbit, b->used);
|
||
|
return 1;
|
||
|
}
|
||
|
memcpy(dst, src, len);
|
||
|
b->used += len;
|
||
|
b->ebit = ebit;
|
||
|
b->data[b->used] = 0; /* padding */
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
* Build an ast_frame for a given chunk of data, and link it into
|
||
|
* the queue, with possibly 'head' bytes at the beginning to
|
||
|
* fill in some fields later.
|
||
|
*/
|
||
|
static struct ast_frame *create_video_frame(uint8_t *start, uint8_t *end,
|
||
|
int format, int head, struct ast_frame *prev)
|
||
|
{
|
||
|
int len = end-start;
|
||
|
uint8_t *data;
|
||
|
struct ast_frame *f;
|
||
|
|
||
|
data = ast_calloc(1, len+head);
|
||
|
f = ast_calloc(1, sizeof(*f));
|
||
|
if (f == NULL || data == NULL) {
|
||
|
ast_log(LOG_WARNING, "--- frame error f %p data %p len %d format %d\n",
|
||
|
f, data, len, format);
|
||
|
if (f)
|
||
|
ast_free(f);
|
||
|
if (data)
|
||
|
ast_free(data);
|
||
|
return NULL;
|
||
|
}
|
||
|
memcpy(data+head, start, len);
|
||
|
f->data = data;
|
||
|
f->mallocd = AST_MALLOCD_DATA | AST_MALLOCD_HDR;
|
||
|
//f->has_timing_info = 1;
|
||
|
//f->ts = ast_tvdiff_ms(ast_tvnow(), out->ts);
|
||
|
f->datalen = len+head;
|
||
|
f->frametype = AST_FRAME_VIDEO;
|
||
|
f->subclass = format;
|
||
|
f->samples = 0;
|
||
|
f->offset = 0;
|
||
|
f->src = "Console";
|
||
|
f->delivery.tv_sec = 0;
|
||
|
f->delivery.tv_usec = 0;
|
||
|
f->seqno = 0;
|
||
|
AST_LIST_NEXT(f, frame_list) = NULL;
|
||
|
|
||
|
if (prev)
|
||
|
AST_LIST_NEXT(prev, frame_list) = f;
|
||
|
|
||
|
return f;
|
||
|
}
|
||
|
|
||
|
/* some debugging code to check the bitstream:
|
||
|
* declare a bit buffer, initialize it, and fetch data from it.
|
||
|
*/
|
||
|
struct bitbuf {
|
||
|
const uint8_t *base;
|
||
|
int bitsize; /* total size in bits */
|
||
|
int ofs; /* next bit to read */
|
||
|
};
|
||
|
|
||
|
static struct bitbuf bitbuf_init(const uint8_t *base, int bitsize, int start_ofs)
|
||
|
{
|
||
|
struct bitbuf a;
|
||
|
a.base = base;
|
||
|
a.bitsize = bitsize;
|
||
|
a.ofs = start_ofs;
|
||
|
return a;
|
||
|
}
|
||
|
|
||
|
static int bitbuf_left(struct bitbuf *b)
|
||
|
{
|
||
|
return b->bitsize - b->ofs;
|
||
|
}
|
||
|
|
||
|
static uint32_t getbits(struct bitbuf *b, int n)
|
||
|
{
|
||
|
int i, ofs;
|
||
|
const uint8_t *d;
|
||
|
uint8_t mask;
|
||
|
uint32_t retval = 0;
|
||
|
if (n> 31) {
|
||
|
ast_log(LOG_WARNING, "too many bits %d, max 32\n", n);
|
||
|
return 0;
|
||
|
}
|
||
|
if (n + b->ofs > b->bitsize) {
|
||
|
ast_log(LOG_WARNING, "bitbuf overflow %d of %d\n", n + b->ofs, b->bitsize);
|
||
|
n = b->bitsize - b->ofs;
|
||
|
}
|
||
|
ofs = 7 - b->ofs % 8; /* start from msb */
|
||
|
mask = 1 << ofs;
|
||
|
d = b->base + b->ofs / 8; /* current byte */
|
||
|
for (i=0 ; i < n; i++) {
|
||
|
retval += retval + (*d & mask ? 1 : 0); /* shift in new byte */
|
||
|
b->ofs++;
|
||
|
mask >>= 1;
|
||
|
if (mask == 0) {
|
||
|
d++;
|
||
|
mask = 0x80;
|
||
|
}
|
||
|
}
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
static void check_h261(struct fbuf_t *b)
|
||
|
{
|
||
|
struct bitbuf a = bitbuf_init(b->data, b->used * 8, 0);
|
||
|
uint32_t x, y;
|
||
|
|
||
|
x = getbits(&a, 20); /* PSC, 0000 0000 0000 0001 0000 */
|
||
|
if (x != 0x10) {
|
||
|
ast_log(LOG_WARNING, "bad PSC 0x%x\n", x);
|
||
|
return;
|
||
|
}
|
||
|
x = getbits(&a, 5); /* temporal reference */
|
||
|
y = getbits(&a, 6); /* ptype */
|
||
|
if (0)
|
||
|
ast_log(LOG_WARNING, "size %d TR %d PTY spl %d doc %d freeze %d %sCIF hi %d\n",
|
||
|
b->used,
|
||
|
x,
|
||
|
(y & 0x20) ? 1 : 0,
|
||
|
(y & 0x10) ? 1 : 0,
|
||
|
(y & 0x8) ? 1 : 0,
|
||
|
(y & 0x4) ? "" : "Q",
|
||
|
(y & 0x2) ? 1:0);
|
||
|
while ( (x = getbits(&a, 1)) == 1)
|
||
|
ast_log(LOG_WARNING, "PSPARE 0x%x\n", getbits(&a, 8));
|
||
|
// ast_log(LOG_WARNING, "PSPARE 0 - start GOB LAYER\n");
|
||
|
while ( (x = bitbuf_left(&a)) > 0) {
|
||
|
// ast_log(LOG_WARNING, "GBSC %d bits left\n", x);
|
||
|
x = getbits(&a, 16); /* GBSC 0000 0000 0000 0001 */
|
||
|
if (x != 0x1) {
|
||
|
ast_log(LOG_WARNING, "bad GBSC 0x%x\n", x);
|
||
|
break;
|
||
|
}
|
||
|
x = getbits(&a, 4); /* group number */
|
||
|
y = getbits(&a, 5); /* gquant */
|
||
|
if (x == 0) {
|
||
|
ast_log(LOG_WARNING, " bad GN %d\n", x);
|
||
|
break;
|
||
|
}
|
||
|
while ( (x = getbits(&a, 1)) == 1)
|
||
|
ast_log(LOG_WARNING, "GSPARE 0x%x\n", getbits(&a, 8));
|
||
|
while ( (x = bitbuf_left(&a)) > 0) { /* MB layer */
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void dump_buf(struct fbuf_t *b);
|
||
|
void dump_buf(struct fbuf_t *b)
|
||
|
{
|
||
|
int i, x, last2lines;
|
||
|
char buf[80];
|
||
|
|
||
|
last2lines = (b->used - 16) & ~0xf;
|
||
|
ast_log(LOG_WARNING, "buf size %d of %d\n", b->used, b->size);
|
||
|
for (i = 0; i < b->used; i++) {
|
||
|
x = i & 0xf;
|
||
|
if ( x == 0) { /* new line */
|
||
|
if (i != 0)
|
||
|
ast_log(LOG_WARNING, "%s\n", buf);
|
||
|
bzero(buf, sizeof(buf));
|
||
|
sprintf(buf, "%04x: ", i);
|
||
|
}
|
||
|
sprintf(buf + 6 + x*3, "%02x ", b->data[i]);
|
||
|
if (i > 31 && i < last2lines)
|
||
|
i = last2lines - 1;
|
||
|
}
|
||
|
if (buf[0])
|
||
|
ast_log(LOG_WARNING, "%s\n", buf);
|
||
|
}
|
||
|
/*
|
||
|
* Here starts the glue code for the various supported video codecs.
|
||
|
* For each of them, we need to provide routines for initialization,
|
||
|
* calling the encoder, encapsulating the bitstream in ast_frames,
|
||
|
* extracting payload from ast_frames, and calling the decoder.
|
||
|
*/
|
||
|
|
||
|
/*--- h263+ support --- */
|
||
|
|
||
|
/*! \brief initialization of h263p */
|
||
|
static int h263p_enc_init(struct video_out_desc *v)
|
||
|
{
|
||
|
/* modes supported are
|
||
|
- Unrestricted Motion Vector (annex D)
|
||
|
- Advanced Prediction (annex F)
|
||
|
- Advanced Intra Coding (annex I)
|
||
|
- Deblocking Filter (annex J)
|
||
|
- Slice Structure (annex K)
|
||
|
- Alternative Inter VLC (annex S)
|
||
|
- Modified Quantization (annex T)
|
||
|
*/
|
||
|
v->enc_ctx->flags |=CODEC_FLAG_H263P_UMV; /* annex D */
|
||
|
v->enc_ctx->flags |=CODEC_FLAG_AC_PRED; /* annex f ? */
|
||
|
v->enc_ctx->flags |=CODEC_FLAG_H263P_SLICE_STRUCT; /* annex k */
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_H263P_AIC; /* annex I */
|
||
|
|
||
|
v->enc_ctx->gop_size = v->fps*5; // emit I frame every 5 seconds
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*
|
||
|
* Create RTP/H.263 fragments to avoid IP fragmentation. We fragment on a
|
||
|
* PSC or a GBSC, but if we don't find a suitable place just break somewhere.
|
||
|
* Everything is byte-aligned.
|
||
|
*/
|
||
|
static struct ast_frame *h263p_encap(struct video_out_desc *out,
|
||
|
struct ast_frame **tail)
|
||
|
{
|
||
|
struct ast_frame *cur = NULL, *first = NULL;
|
||
|
uint8_t *d = out->enc_out.data;
|
||
|
int len = out->enc_out.used;
|
||
|
int l = len; /* size of the current fragment. If 0, must look for a psc */
|
||
|
|
||
|
for (;len > 0; len -= l, d += l) {
|
||
|
uint8_t *data;
|
||
|
struct ast_frame *f;
|
||
|
int i, h;
|
||
|
|
||
|
if (len >= 3 && d[0] == 0 && d[1] == 0 && d[2] >= 0x80) {
|
||
|
/* we are starting a new block, so look for a PSC. */
|
||
|
for (i = 3; i < len - 3; i++) {
|
||
|
if (d[i] == 0 && d[i+1] == 0 && d[i+2] >= 0x80) {
|
||
|
l = i;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (l > out->mtu || l > len) { /* psc not found, split */
|
||
|
l = MIN(len, out->mtu);
|
||
|
}
|
||
|
if (l < 1 || l > out->mtu) {
|
||
|
ast_log(LOG_WARNING, "--- frame error l %d\n", l);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (d[0] == 0 && d[1] == 0) { /* we start with a psc */
|
||
|
h = 0;
|
||
|
} else { /* no psc, create a header */
|
||
|
h = 2;
|
||
|
}
|
||
|
|
||
|
f = create_video_frame(d, d+l, AST_FORMAT_H263_PLUS, h, cur);
|
||
|
if (!f)
|
||
|
break;
|
||
|
|
||
|
data = f->data;
|
||
|
if (h == 0) { /* we start with a psc */
|
||
|
data[0] |= 0x04; // set P == 1, and we are done
|
||
|
} else { /* no psc, create a header */
|
||
|
data[0] = data[1] = 0; // P == 0
|
||
|
}
|
||
|
|
||
|
if (!cur)
|
||
|
first = f;
|
||
|
cur = f;
|
||
|
}
|
||
|
|
||
|
if (cur)
|
||
|
cur->subclass |= 1; // RTP Marker
|
||
|
|
||
|
*tail = cur; /* end of the list */
|
||
|
return first;
|
||
|
}
|
||
|
|
||
|
/*! \brief extract the bitstreem from the RTP payload.
|
||
|
* This is format dependent.
|
||
|
* For h263+, the format is defined in RFC 2429
|
||
|
* and basically has a fixed 2-byte header as follows:
|
||
|
* 5 bits RR reserved, shall be 0
|
||
|
* 1 bit P indicate a start/end condition,
|
||
|
* in which case the payload should be prepended
|
||
|
* by two zero-valued bytes.
|
||
|
* 1 bit V there is an additional VRC header after this header
|
||
|
* 6 bits PLEN length in bytes of extra picture header
|
||
|
* 3 bits PEBIT how many bits to be ignored in the last byte
|
||
|
*
|
||
|
* XXX the code below is not complete.
|
||
|
*/
|
||
|
static int h263p_decap(struct fbuf_t *b, uint8_t *data, int len)
|
||
|
{
|
||
|
int PLEN;
|
||
|
|
||
|
if (len < 2) {
|
||
|
ast_log(LOG_WARNING, "invalid framesize %d\n", len);
|
||
|
return 1;
|
||
|
}
|
||
|
PLEN = ( (data[0] & 1) << 5 ) | ( (data[1] & 0xf8) >> 3);
|
||
|
|
||
|
if (PLEN > 0) {
|
||
|
data += PLEN;
|
||
|
len -= PLEN;
|
||
|
}
|
||
|
if (data[0] & 4) /* bit P */
|
||
|
data[0] = data[1] = 0;
|
||
|
else {
|
||
|
data += 2;
|
||
|
len -= 2;
|
||
|
}
|
||
|
return fbuf_append(b, data, len, 0, 0); /* ignore trail bits */
|
||
|
}
|
||
|
|
||
|
|
||
|
/*
|
||
|
* generic encoder, used by the various protocols supported here.
|
||
|
* We assume that the buffer is empty at the beginning.
|
||
|
*/
|
||
|
static int ffmpeg_encode(struct video_out_desc *v)
|
||
|
{
|
||
|
struct fbuf_t *b = &v->enc_out;
|
||
|
int i;
|
||
|
|
||
|
b->used = avcodec_encode_video(v->enc_ctx, b->data, b->size, v->frame);
|
||
|
i = avcodec_encode_video(v->enc_ctx, b->data + b->used, b->size - b->used, NULL); /* delayed frames ? */
|
||
|
if (i > 0) {
|
||
|
ast_log(LOG_WARNING, "have %d more bytes\n", i);
|
||
|
b->used += i;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Generic decoder, which is used by h263p, h263 and h261 as it simply
|
||
|
* invokes ffmpeg's decoder.
|
||
|
* av_parser_parse should merge a randomly chopped up stream into
|
||
|
* proper frames. After that, if we have a valid frame, we decode it
|
||
|
* until the entire frame is processed.
|
||
|
*/
|
||
|
static int ffmpeg_decode(struct video_in_desc *v, struct fbuf_t *b)
|
||
|
{
|
||
|
uint8_t *src = b->data;
|
||
|
int srclen = b->used;
|
||
|
int full_frame = 0;
|
||
|
|
||
|
if (srclen == 0) /* no data */
|
||
|
return 0;
|
||
|
if (0)
|
||
|
check_h261(b);
|
||
|
// ast_log(LOG_WARNING, "rx size %d\n", srclen);
|
||
|
while (srclen) {
|
||
|
uint8_t *data;
|
||
|
int datalen, ret;
|
||
|
int len = av_parser_parse(v->parser, v->dec_ctx, &data, &datalen, src, srclen, 0, 0);
|
||
|
|
||
|
src += len;
|
||
|
srclen -= len;
|
||
|
/* The parser might return something it cannot decode, so it skips
|
||
|
* the block returning no data
|
||
|
*/
|
||
|
if (data == NULL || datalen == 0)
|
||
|
continue;
|
||
|
ret = avcodec_decode_video(v->dec_ctx, v->d_frame, &full_frame, data, datalen);
|
||
|
if (full_frame == 1) /* full frame */
|
||
|
break;
|
||
|
if (ret < 0) {
|
||
|
ast_log(LOG_NOTICE, "Error decoding\n");
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (srclen != 0) /* update b with leftover data */
|
||
|
bcopy(src, b->data, srclen);
|
||
|
b->used = srclen;
|
||
|
b->ebit = 0;
|
||
|
return full_frame;
|
||
|
}
|
||
|
|
||
|
static struct video_codec_desc h263p_codec = {
|
||
|
.name = "h263p",
|
||
|
.format = AST_FORMAT_H263_PLUS,
|
||
|
.enc_init = h263p_enc_init,
|
||
|
.enc_encap = h263p_encap,
|
||
|
.enc_run = ffmpeg_encode,
|
||
|
.dec_init = NULL,
|
||
|
.dec_decap = h263p_decap,
|
||
|
.dec_run = ffmpeg_decode
|
||
|
};
|
||
|
|
||
|
/*--- Plain h263 support --------*/
|
||
|
|
||
|
static int h263_enc_init(struct video_out_desc *v)
|
||
|
{
|
||
|
/* XXX check whether these are supported */
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_H263P_UMV;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_H263P_AIC;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_AC_PRED;
|
||
|
|
||
|
v->enc_ctx->gop_size = v->fps*5;
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* h263 encapsulation is specified in RFC2190. There are three modes
|
||
|
* defined (A, B, C), with 4, 8 and 12 bytes of header, respectively.
|
||
|
* The header is made as follows
|
||
|
* 0.....................|.......................|.............|....31
|
||
|
* F:1 P:1 SBIT:3 EBIT:3 SRC:3 I:1 U:1 S:1 A:1 R:4 DBQ:2 TRB:3 TR:8
|
||
|
* FP = 0- mode A, (only one word of header)
|
||
|
* FP = 10 mode B, and also means this is an I or P frame
|
||
|
* FP = 11 mode C, and also means this is a PB frame.
|
||
|
* SBIT, EBIT nuber of bits to ignore at beginning (msbits) and end (lsbits)
|
||
|
* SRC bits 6,7,8 from the h263 PTYPE field
|
||
|
* I = 0 intra-coded, 1 = inter-coded (bit 9 from PTYPE)
|
||
|
* U = 1 for Unrestricted Motion Vector (bit 10 from PTYPE)
|
||
|
* S = 1 for Syntax Based Arith coding (bit 11 from PTYPE)
|
||
|
* A = 1 for Advanced Prediction (bit 12 from PTYPE)
|
||
|
* R = reserved, must be 0
|
||
|
* DBQ = differential quantization, DBQUANT from h263, 0 unless we are using
|
||
|
* PB frames
|
||
|
* TRB = temporal reference for bframes, also 0 unless this is a PB frame
|
||
|
* TR = temporal reference for P frames, also 0 unless PB frame.
|
||
|
*
|
||
|
* Mode B and mode C description omitted.
|
||
|
*
|
||
|
* An RTP frame can start with a PSC 0000 0000 0000 0000 1000 0
|
||
|
* or with a GBSC, which also has the first 17 bits as a PSC.
|
||
|
* Note - PSC are byte-aligned, GOB not necessarily. PSC start with
|
||
|
* PSC:22 0000 0000 0000 0000 1000 00 picture start code
|
||
|
* TR:8 .... .... temporal reference
|
||
|
* PTYPE:13 or more ptype...
|
||
|
* If we don't fragment a GOB SBIT and EBIT = 0.
|
||
|
* reference, 8 bit)
|
||
|
*
|
||
|
* The assumption below is that we start with a PSC.
|
||
|
*/
|
||
|
static struct ast_frame *h263_encap(struct video_out_desc *out,
|
||
|
struct ast_frame **tail)
|
||
|
{
|
||
|
uint8_t *d = out->enc_out.data;
|
||
|
int start = 0, i, len = out->enc_out.used;
|
||
|
struct ast_frame *f, *cur = NULL, *first = NULL;
|
||
|
const int pheader_len = 4; /* Use RFC-2190 Mode A */
|
||
|
uint8_t h263_hdr[12]; /* worst case, room for a type c header */
|
||
|
uint8_t *h = h263_hdr; /* shorthand */
|
||
|
|
||
|
#define H263_MIN_LEN 6
|
||
|
if (len < H263_MIN_LEN) /* unreasonably small */
|
||
|
return NULL;
|
||
|
|
||
|
bzero(h263_hdr, sizeof(h263_hdr));
|
||
|
/* Now set the header bytes. Only type A by now,
|
||
|
* and h[0] = h[2] = h[3] = 0 by default.
|
||
|
* PTYPE starts 30 bits in the picture, so the first useful
|
||
|
* bit for us is bit 36 i.e. within d[4] (0 is the msbit).
|
||
|
* SRC = d[4] & 0x1c goes into data[1] & 0xe0
|
||
|
* I = d[4] & 0x02 goes into data[1] & 0x10
|
||
|
* U = d[4] & 0x01 goes into data[1] & 0x08
|
||
|
* S = d[5] & 0x80 goes into data[1] & 0x04
|
||
|
* A = d[5] & 0x40 goes into data[1] & 0x02
|
||
|
* R = 0 goes into data[1] & 0x01
|
||
|
* Optimizing it, we have
|
||
|
*/
|
||
|
h[1] = ( (d[4] & 0x1f) << 3 ) | /* SRC, I, U */
|
||
|
( (d[5] & 0xc0) >> 5 ); /* S, A, R */
|
||
|
|
||
|
/* now look for the next PSC or GOB header. First try to hit
|
||
|
* a '0' byte then look around for the 0000 0000 0000 0000 1 pattern
|
||
|
* which is both in the PSC and the GBSC.
|
||
|
*/
|
||
|
for (i = H263_MIN_LEN, start = 0; start < len; start = i, i += 3) {
|
||
|
//ast_log(LOG_WARNING, "search at %d of %d/%d\n", i, start, len);
|
||
|
for (; i < len ; i++) {
|
||
|
uint8_t x, rpos, lpos;
|
||
|
int rpos_i; /* index corresponding to rpos */
|
||
|
if (d[i] != 0) /* cannot be in a GBSC */
|
||
|
continue;
|
||
|
if (i > len - 1)
|
||
|
break;
|
||
|
x = d[i+1];
|
||
|
if (x == 0) /* next is equally good */
|
||
|
continue;
|
||
|
/* see if around us we can make 16 '0' bits for the GBSC.
|
||
|
* Look for the first bit set on the right, and then
|
||
|
* see if we have enough 0 on the left.
|
||
|
* We are guaranteed to end before rpos == 0
|
||
|
*/
|
||
|
for (rpos = 0x80, rpos_i = 8; rpos; rpos >>= 1, rpos_i--)
|
||
|
if (x & rpos) /* found the '1' bit in GBSC */
|
||
|
break;
|
||
|
x = d[i-1]; /* now look behind */
|
||
|
for (lpos = rpos; lpos ; lpos >>= 1)
|
||
|
if (x & lpos) /* too early, not a GBSC */
|
||
|
break;
|
||
|
if (lpos) /* as i said... */
|
||
|
continue;
|
||
|
/* now we have a GBSC starting somewhere in d[i-1],
|
||
|
* but it might be not byte-aligned
|
||
|
*/
|
||
|
if (rpos == 0x80) { /* lucky case */
|
||
|
i = i - 1;
|
||
|
} else { /* XXX to be completed */
|
||
|
ast_log(LOG_WARNING, "unaligned GBSC 0x%x %d\n",
|
||
|
rpos, rpos_i);
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
/* This frame is up to offset i (not inclusive).
|
||
|
* We do not split it yet even if larger than MTU.
|
||
|
*/
|
||
|
f = create_video_frame(d + start, d+i, AST_FORMAT_H263,
|
||
|
pheader_len, cur);
|
||
|
|
||
|
if (!f)
|
||
|
break;
|
||
|
bcopy(h, f->data, 4); /* copy the h263 header */
|
||
|
/* XXX to do: if not aligned, fix sbit and ebit,
|
||
|
* then move i back by 1 for the next frame
|
||
|
*/
|
||
|
if (!cur)
|
||
|
first = f;
|
||
|
cur = f;
|
||
|
}
|
||
|
|
||
|
if (cur)
|
||
|
cur->subclass |= 1; // RTP Marker
|
||
|
|
||
|
*tail = cur;
|
||
|
return first;
|
||
|
}
|
||
|
|
||
|
/* XXX We only drop the header here, but maybe we need more. */
|
||
|
static int h263_decap(struct fbuf_t *b, uint8_t *data, int len)
|
||
|
{
|
||
|
if (len < 4) {
|
||
|
ast_log(LOG_WARNING, "invalid framesize %d\n", len);
|
||
|
return 1; /* error */
|
||
|
}
|
||
|
|
||
|
if ( (data[0] & 0x80) == 0) {
|
||
|
len -= 4;
|
||
|
data += 4;
|
||
|
} else {
|
||
|
ast_log(LOG_WARNING, "unsupported mode 0x%x\n",
|
||
|
data[0]);
|
||
|
return 1;
|
||
|
}
|
||
|
return fbuf_append(b, data, len, 0, 0); /* XXX no bit alignment support yet */
|
||
|
}
|
||
|
|
||
|
static struct video_codec_desc h263_codec = {
|
||
|
.name = "h263",
|
||
|
.format = AST_FORMAT_H263,
|
||
|
.enc_init = h263_enc_init,
|
||
|
.enc_encap = h263_encap,
|
||
|
.enc_run = ffmpeg_encode,
|
||
|
.dec_init = NULL,
|
||
|
.dec_decap = h263_decap,
|
||
|
.dec_run = ffmpeg_decode
|
||
|
|
||
|
};
|
||
|
|
||
|
/*---- h261 support -----*/
|
||
|
static int h261_enc_init(struct video_out_desc *v)
|
||
|
{
|
||
|
/* It is important to set rtp_payload_size = 0, otherwise
|
||
|
* ffmpeg in h261 mode will produce output that it cannot parse.
|
||
|
* Also try to send I frames more frequently than with other codecs.
|
||
|
*/
|
||
|
v->enc_ctx->rtp_payload_size = 0; /* important - ffmpeg fails otherwise */
|
||
|
v->enc_ctx->gop_size = v->fps*2; /* be more responsive */
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* The encapsulation of H261 is defined in RFC4587 which obsoletes RFC2032
|
||
|
* The bitstream is preceded by a 32-bit header word:
|
||
|
* SBIT:3 EBIT:3 I:1 V:1 GOBN:4 MBAP:5 QUANT:5 HMVD:5 VMVD:5
|
||
|
* SBIT and EBIT are the bits to be ignored at beginning and end,
|
||
|
* I=1 if the stream has only INTRA frames - cannot change during the stream.
|
||
|
* V=0 if motion vector is not used. Cannot change.
|
||
|
* GOBN is the GOB number in effect at the start of packet, 0 if we
|
||
|
* start with a GOB header
|
||
|
* QUANT is the quantizer in effect, 0 if we start with GOB header
|
||
|
* HMVD reference horizontal motion vector. 10000 is forbidden
|
||
|
* VMVD reference vertical motion vector, as above.
|
||
|
* Packetization should occur at GOB boundaries, and if not possible
|
||
|
* with MacroBlock fragmentation. However it is likely that blocks
|
||
|
* are not bit-aligned so we must take care of this.
|
||
|
*/
|
||
|
static struct ast_frame *h261_encap(struct video_out_desc *out,
|
||
|
struct ast_frame **tail)
|
||
|
{
|
||
|
uint8_t *d = out->enc_out.data;
|
||
|
int start = 0, i, len = out->enc_out.used;
|
||
|
struct ast_frame *f, *cur = NULL, *first = NULL;
|
||
|
const int pheader_len = 4;
|
||
|
uint8_t h261_hdr[4];
|
||
|
uint8_t *h = h261_hdr; /* shorthand */
|
||
|
int sbit = 0, ebit = 0;
|
||
|
|
||
|
#define H261_MIN_LEN 10
|
||
|
if (len < H261_MIN_LEN) /* unreasonably small */
|
||
|
return NULL;
|
||
|
|
||
|
bzero(h261_hdr, sizeof(h261_hdr));
|
||
|
|
||
|
/* Similar to the code in h263_encap, but the marker there is longer.
|
||
|
* Start a few bytes within the bitstream to avoid hitting the marker
|
||
|
* twice. Note we might access the buffer at len, but this is ok because
|
||
|
* the caller has it oversized.
|
||
|
*/
|
||
|
for (i = H261_MIN_LEN, start = 0; start < len - 1; start = i, i += 4) {
|
||
|
#if 0 /* test - disable packetization */
|
||
|
i = len; /* wrong... */
|
||
|
#else
|
||
|
int found = 0, found_ebit = 0; /* last GBSC position found */
|
||
|
for (; i < len ; i++) {
|
||
|
uint8_t x, rpos, lpos;
|
||
|
if (d[i] != 0) /* cannot be in a GBSC */
|
||
|
continue;
|
||
|
x = d[i+1];
|
||
|
if (x == 0) /* next is equally good */
|
||
|
continue;
|
||
|
/* See if around us we find 15 '0' bits for the GBSC.
|
||
|
* Look for the first bit set on the right, and then
|
||
|
* see if we have enough 0 on the left.
|
||
|
* We are guaranteed to end before rpos == 0
|
||
|
*/
|
||
|
for (rpos = 0x80, ebit = 7; rpos; ebit--, rpos >>= 1)
|
||
|
if (x & rpos) /* found the '1' bit in GBSC */
|
||
|
break;
|
||
|
x = d[i-1]; /* now look behind */
|
||
|
for (lpos = (rpos >> 1); lpos ; lpos >>= 1)
|
||
|
if (x & lpos) /* too early, not a GBSC */
|
||
|
break;
|
||
|
if (lpos) /* as i said... */
|
||
|
continue;
|
||
|
/* now we have a GBSC starting somewhere in d[i-1],
|
||
|
* but it might be not byte-aligned. Just remember it.
|
||
|
*/
|
||
|
if (i - start > out->mtu) /* too large, stop now */
|
||
|
break;
|
||
|
found_ebit = ebit;
|
||
|
found = i;
|
||
|
i += 4; /* continue forward */
|
||
|
}
|
||
|
if (i >= len) { /* trim if we went too forward */
|
||
|
i = len;
|
||
|
ebit = 0; /* hopefully... should ask the bitstream ? */
|
||
|
}
|
||
|
if (i - start > out->mtu && found) {
|
||
|
/* use the previous GBSC, hope is within the mtu */
|
||
|
i = found;
|
||
|
ebit = found_ebit;
|
||
|
}
|
||
|
#endif /* test */
|
||
|
if (i - start < 4) /* XXX too short ? */
|
||
|
continue;
|
||
|
/* This frame is up to offset i (not inclusive).
|
||
|
* We do not split it yet even if larger than MTU.
|
||
|
*/
|
||
|
f = create_video_frame(d + start, d+i, AST_FORMAT_H261,
|
||
|
pheader_len, cur);
|
||
|
|
||
|
if (!f)
|
||
|
break;
|
||
|
/* recompute header with I=0, V=1 */
|
||
|
h[0] = ( (sbit & 7) << 5 ) | ( (ebit & 7) << 2 ) | 1;
|
||
|
bcopy(h, f->data, 4); /* copy the h261 header */
|
||
|
if (ebit) /* not aligned, restart from previous byte */
|
||
|
i--;
|
||
|
sbit = (8 - ebit) & 7;
|
||
|
ebit = 0;
|
||
|
if (!cur)
|
||
|
first = f;
|
||
|
cur = f;
|
||
|
}
|
||
|
if (cur)
|
||
|
cur->subclass |= 1; // RTP Marker
|
||
|
|
||
|
*tail = cur;
|
||
|
return first;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Pieces might be unaligned so we really need to put them together.
|
||
|
*/
|
||
|
static int h261_decap(struct fbuf_t *b, uint8_t *data, int len)
|
||
|
{
|
||
|
int ebit, sbit;
|
||
|
|
||
|
if (len < 8) {
|
||
|
ast_log(LOG_WARNING, "invalid framesize %d\n", len);
|
||
|
return 1;
|
||
|
}
|
||
|
sbit = (data[0] >> 5) & 7;
|
||
|
ebit = (data[0] >> 2) & 7;
|
||
|
len -= 4;
|
||
|
data += 4;
|
||
|
return fbuf_append(b, data, len, sbit, ebit);
|
||
|
}
|
||
|
|
||
|
static struct video_codec_desc h261_codec = {
|
||
|
.name = "h261",
|
||
|
.format = AST_FORMAT_H261,
|
||
|
.enc_init = h261_enc_init,
|
||
|
.enc_encap = h261_encap,
|
||
|
.enc_run = ffmpeg_encode,
|
||
|
.dec_init = NULL,
|
||
|
.dec_decap = h261_decap,
|
||
|
.dec_run = ffmpeg_decode
|
||
|
};
|
||
|
|
||
|
/* mpeg4 support */
|
||
|
static int mpeg4_enc_init(struct video_out_desc *v)
|
||
|
{
|
||
|
#if 0
|
||
|
//v->enc_ctx->flags |= CODEC_FLAG_LOW_DELAY; /*don't use b frames ?*/
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_AC_PRED;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_H263P_UMV;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_QPEL;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_4MV;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_GMC;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_LOOP_FILTER;
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
|
||
|
#endif
|
||
|
v->enc_ctx->gop_size = v->fps*5;
|
||
|
v->enc_ctx->rtp_payload_size = 0; /* important - ffmpeg fails otherwise */
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/* simplistic encapsulation - just split frames in mtu-size units */
|
||
|
static struct ast_frame *mpeg4_encap(struct video_out_desc *out,
|
||
|
struct ast_frame **tail)
|
||
|
{
|
||
|
struct ast_frame *f, *cur = NULL, *first = NULL;
|
||
|
uint8_t *d = out->enc_out.data;
|
||
|
uint8_t *end = d+out->enc_out.used;
|
||
|
int len;
|
||
|
|
||
|
for (;d < end; d += len, cur = f) {
|
||
|
len = MIN(out->mtu, end-d);
|
||
|
f = create_video_frame(d, d+len, AST_FORMAT_MP4_VIDEO, 0, cur);
|
||
|
if (!f)
|
||
|
break;
|
||
|
if (!first)
|
||
|
first = f;
|
||
|
}
|
||
|
if (cur)
|
||
|
cur->subclass |= 1;
|
||
|
*tail = cur;
|
||
|
return first;
|
||
|
}
|
||
|
|
||
|
static int mpeg4_decap(struct fbuf_t *b, uint8_t *data, int len)
|
||
|
{
|
||
|
return fbuf_append(b, data, len, 0, 0);
|
||
|
}
|
||
|
|
||
|
static int mpeg4_decode(struct video_in_desc *v, struct fbuf_t *b)
|
||
|
{
|
||
|
int full_frame = 0, datalen = b->used;
|
||
|
int ret = avcodec_decode_video(v->dec_ctx, v->d_frame, &full_frame,
|
||
|
b->data, datalen);
|
||
|
if (ret < 0) {
|
||
|
ast_log(LOG_NOTICE, "Error decoding\n");
|
||
|
ret = datalen; /* assume we used everything. */
|
||
|
}
|
||
|
datalen -= ret;
|
||
|
if (datalen > 0) /* update b with leftover bytes */
|
||
|
bcopy(b->data + ret, b->data, datalen);
|
||
|
b->used = datalen;
|
||
|
b->ebit = 0;
|
||
|
return full_frame;
|
||
|
}
|
||
|
|
||
|
static struct video_codec_desc mpeg4_codec = {
|
||
|
.name = "mpeg4",
|
||
|
.format = AST_FORMAT_MP4_VIDEO,
|
||
|
.enc_init = mpeg4_enc_init,
|
||
|
.enc_encap = mpeg4_encap,
|
||
|
.enc_run = ffmpeg_encode,
|
||
|
.dec_init = NULL,
|
||
|
.dec_decap = mpeg4_decap,
|
||
|
.dec_run = mpeg4_decode
|
||
|
};
|
||
|
|
||
|
static int h264_enc_init(struct video_out_desc *v)
|
||
|
{
|
||
|
v->enc_ctx->flags |= CODEC_FLAG_TRUNCATED;
|
||
|
//v->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
|
||
|
//v->enc_ctx->flags2 |= CODEC_FLAG2_FASTPSKIP;
|
||
|
/* TODO: Maybe we need to add some other flags */
|
||
|
v->enc_ctx->gop_size = v->fps*5; // emit I frame every 5 seconds
|
||
|
v->enc_ctx->rtp_mode = 0;
|
||
|
v->enc_ctx->rtp_payload_size = 0;
|
||
|
v->enc_ctx->bit_rate_tolerance = v->enc_ctx->bit_rate;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static int h264_dec_init(struct video_in_desc *v)
|
||
|
{
|
||
|
v->dec_ctx->flags |= CODEC_FLAG_TRUNCATED;
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* The structure of a generic H.264 stream is:
|
||
|
* - 0..n 0-byte(s), unused, optional. one zero-byte is always present
|
||
|
* in the first NAL before the start code prefix.
|
||
|
* - start code prefix (3 bytes): 0x000001
|
||
|
* (the first bytestream has a
|
||
|
* like these 0x00000001!)
|
||
|
* - NAL header byte ( F[1] | NRI[2] | Type[5] ) where type != 0
|
||
|
* - byte-stream
|
||
|
* - 0..n 0-byte(s) (padding, unused).
|
||
|
* Segmentation in RTP only needs to be done on start code prefixes.
|
||
|
* If fragments are too long... we don't support it yet.
|
||
|
* - encapsulate (or fragment) the byte-stream (with NAL header included)
|
||
|
*/
|
||
|
static struct ast_frame *h264_encap(struct video_out_desc *out,
|
||
|
struct ast_frame **tail)
|
||
|
{
|
||
|
struct ast_frame *f = NULL, *cur = NULL, *first = NULL;
|
||
|
uint8_t *d, *start = out->enc_out.data;
|
||
|
uint8_t *end = start + out->enc_out.used;
|
||
|
|
||
|
/* Search the first start code prefix - ITU-T H.264 sec. B.2,
|
||
|
* and move start right after that, on the NAL header byte.
|
||
|
*/
|
||
|
#define HAVE_NAL(x) (x[-4] == 0 && x[-3] == 0 && x[-2] == 0 && x[-1] == 1)
|
||
|
for (start += 4; start < end; start++) {
|
||
|
int ty = start[0] & 0x1f;
|
||
|
if (HAVE_NAL(start) && ty != 0 && ty != 31)
|
||
|
break;
|
||
|
}
|
||
|
/* if not found, or too short, we just skip the next loop and are done. */
|
||
|
|
||
|
/* Here follows the main loop to create frames. Search subsequent start
|
||
|
* codes, and then possibly fragment the unit into smaller fragments.
|
||
|
*/
|
||
|
for (;start < end - 4; start = d) {
|
||
|
int size; /* size of current block */
|
||
|
uint8_t hdr[2]; /* add-on header when fragmenting */
|
||
|
int ty = 0;
|
||
|
|
||
|
/* now search next nal */
|
||
|
for (d = start + 4; d < end; d++) {
|
||
|
ty = d[0] & 0x1f;
|
||
|
if (HAVE_NAL(d))
|
||
|
break; /* found NAL */
|
||
|
}
|
||
|
/* have a block to send. d past the start code unless we overflow */
|
||
|
if (d >= end) { /* NAL not found */
|
||
|
d = end + 4;
|
||
|
} else if (ty == 0 || ty == 31) { /* found but invalid type, skip */
|
||
|
ast_log(LOG_WARNING, "skip invalid nal type %d at %d of %d\n",
|
||
|
ty, d - out->enc_out.data, out->enc_out.used);
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
size = d - start - 4; /* don't count the end */
|
||
|
|
||
|
if (size < out->mtu) { // test - don't fragment
|
||
|
// Single NAL Unit
|
||
|
f = create_video_frame(start, d - 4, AST_FORMAT_H264, 0, cur);
|
||
|
if (!f)
|
||
|
break;
|
||
|
if (!first)
|
||
|
first = f;
|
||
|
|
||
|
cur = f;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
// Fragmented Unit (Mode A: no DON, very weak)
|
||
|
hdr[0] = (*start & 0xe0) | 28; /* mark as a fragmentation unit */
|
||
|
hdr[1] = (*start++ & 0x1f) | 0x80 ; /* keep type and set START bit */
|
||
|
size--; /* skip the NAL header */
|
||
|
while (size) {
|
||
|
uint8_t *data;
|
||
|
int frag_size = MIN(size, out->mtu);
|
||
|
|
||
|
f = create_video_frame(start, start+frag_size, AST_FORMAT_H264, 2, cur);
|
||
|
if (!f)
|
||
|
break;
|
||
|
size -= frag_size; /* skip this data block */
|
||
|
start += frag_size;
|
||
|
|
||
|
data = f->data;
|
||
|
data[0] = hdr[0];
|
||
|
data[1] = hdr[1] | (size == 0 ? 0x40 : 0); /* end bit if we are done */
|
||
|
hdr[1] &= ~0x80; /* clear start bit for subsequent frames */
|
||
|
if (!first)
|
||
|
first = f;
|
||
|
cur = f;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (cur)
|
||
|
cur->subclass |= 1; // RTP Marker
|
||
|
|
||
|
*tail = cur;
|
||
|
|
||
|
return first;
|
||
|
}
|
||
|
|
||
|
static int h264_decap(struct fbuf_t *b, uint8_t *data, int len)
|
||
|
{
|
||
|
/* Start Code Prefix (Annex B in specification) */
|
||
|
uint8_t scp[] = { 0x00, 0x00, 0x00, 0x01 };
|
||
|
int retval = 0;
|
||
|
int type, ofs = 0;
|
||
|
|
||
|
if (len < 2) {
|
||
|
ast_log(LOG_WARNING, "--- invalid len %d\n", len);
|
||
|
return 1;
|
||
|
}
|
||
|
/* first of all, check if the packet has F == 0 */
|
||
|
if (data[0] & 0x80) {
|
||
|
ast_log(LOG_WARNING, "--- forbidden packet; nal: %02x\n",
|
||
|
data[0]);
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
type = data[0] & 0x1f;
|
||
|
switch (type) {
|
||
|
case 0:
|
||
|
case 31:
|
||
|
ast_log(LOG_WARNING, "--- invalid type: %d\n", type);
|
||
|
return 1;
|
||
|
case 24:
|
||
|
case 25:
|
||
|
case 26:
|
||
|
case 27:
|
||
|
case 29:
|
||
|
ast_log(LOG_WARNING, "--- encapsulation not supported : %d\n", type);
|
||
|
return 1;
|
||
|
case 28: /* FU-A Unit */
|
||
|
if (data[1] & 0x80) { // S == 1, import F and NRI from next
|
||
|
data[1] &= 0x1f; /* preserve type */
|
||
|
data[1] |= (data[0] & 0xe0); /* import F & NRI */
|
||
|
retval = fbuf_append(b, scp, sizeof(scp), 0, 0);
|
||
|
ofs = 1;
|
||
|
} else {
|
||
|
ofs = 2;
|
||
|
}
|
||
|
break;
|
||
|
default: /* From 1 to 23 (Single NAL Unit) */
|
||
|
retval = fbuf_append(b, scp, sizeof(scp), 0, 0);
|
||
|
}
|
||
|
if (!retval)
|
||
|
retval = fbuf_append(b, data + ofs, len - ofs, 0, 0);
|
||
|
if (retval)
|
||
|
ast_log(LOG_WARNING, "result %d\n", retval);
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
static struct video_codec_desc h264_codec = {
|
||
|
.name = "h264",
|
||
|
.format = AST_FORMAT_H264,
|
||
|
.enc_init = h264_enc_init,
|
||
|
.enc_encap = h264_encap,
|
||
|
.enc_run = ffmpeg_encode,
|
||
|
.dec_init = h264_dec_init,
|
||
|
.dec_decap = h264_decap,
|
||
|
.dec_run = ffmpeg_decode
|
||
|
};
|
||
|
|
||
|
/*------ end codec specific code -----*/
|
||
|
|
||
|
|
||
|
/* Video4Linux stuff is only used in video_open() */
|
||
|
#ifdef HAVE_VIDEODEV_H
|
||
|
#include <linux/videodev.h>
|
||
|
#endif
|
||
|
|
||
|
/*!
|
||
|
* Open the local video source and allocate a buffer
|
||
|
* for storing the image. Return 0 on success, -1 on error
|
||
|
*/
|
||
|
static int video_open(struct video_out_desc *v)
|
||
|
{
|
||
|
struct fbuf_t *b = &v->loc_src;
|
||
|
if (b->data) /* buffer allocated means device already open */
|
||
|
return v->fd;
|
||
|
v->fd = -1;
|
||
|
/*
|
||
|
* if the device is "X11", then open the x11 grabber
|
||
|
*/
|
||
|
if (!strcasecmp(v->videodevice, "X11")) {
|
||
|
XImage *im;
|
||
|
int screen_num;
|
||
|
|
||
|
/* init the connection with the X server */
|
||
|
v->dpy = XOpenDisplay(NULL);
|
||
|
if (v->dpy == NULL) {
|
||
|
ast_log(LOG_WARNING, "error opening display\n");
|
||
|
goto error;
|
||
|
}
|
||
|
|
||
|
/* find width and height of the screen */
|
||
|
screen_num = DefaultScreen(v->dpy);
|
||
|
v->screen_width = DisplayWidth(v->dpy, screen_num);
|
||
|
v->screen_height = DisplayHeight(v->dpy, screen_num);
|
||
|
|
||
|
v->image = im = XGetImage(v->dpy,
|
||
|
RootWindow(v->dpy, DefaultScreen(v->dpy)),
|
||
|
b->x, b->y, b->w, b->h, AllPlanes, ZPixmap);
|
||
|
if (v->image == NULL) {
|
||
|
ast_log(LOG_WARNING, "error creating Ximage\n");
|
||
|
goto error;
|
||
|
}
|
||
|
switch (im->bits_per_pixel) {
|
||
|
case 32:
|
||
|
b->pix_fmt = PIX_FMT_RGBA32;
|
||
|
break;
|
||
|
case 16:
|
||
|
b->pix_fmt = (im->green_mask == 0x7e0) ? PIX_FMT_RGB565 : PIX_FMT_RGB555;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
ast_log(LOG_NOTICE, "image: data %p %d bpp fmt %d, mask 0x%lx 0x%lx 0x%lx\n",
|
||
|
im->data,
|
||
|
im->bits_per_pixel,
|
||
|
b->pix_fmt,
|
||
|
im->red_mask, im->green_mask, im->blue_mask);
|
||
|
|
||
|
/* set the pointer but not the size as this is not malloc'ed */
|
||
|
b->data = (uint8_t *)im->data;
|
||
|
v->fd = -2;
|
||
|
}
|
||
|
#ifdef HAVE_VIDEODEV_H
|
||
|
else {
|
||
|
/* V4L specific */
|
||
|
struct video_window vw = { 0 }; /* camera attributes */
|
||
|
struct video_picture vp;
|
||
|
int i;
|
||
|
const char *dev = v->videodevice;
|
||
|
|
||
|
v->fd = open(dev, O_RDONLY | O_NONBLOCK);
|
||
|
if (v->fd < 0) {
|
||
|
ast_log(LOG_WARNING, "error opening camera %s\n", v->videodevice);
|
||
|
return v->fd;
|
||
|
}
|
||
|
|
||
|
i = fcntl(v->fd, F_GETFL);
|
||
|
if (-1 == fcntl(v->fd, F_SETFL, i | O_NONBLOCK)) {
|
||
|
/* non fatal, just emit a warning */
|
||
|
ast_log(LOG_WARNING, "error F_SETFL for %s [%s]\n",
|
||
|
dev, strerror(errno));
|
||
|
}
|
||
|
/* set format for the camera.
|
||
|
* In principle we could retry with a different format if the
|
||
|
* one we are asking for is not supported.
|
||
|
*/
|
||
|
vw.width = v->loc_src.w;
|
||
|
vw.height = v->loc_src.h;
|
||
|
vw.flags = v->fps << 16;
|
||
|
if (ioctl(v->fd, VIDIOCSWIN, &vw) == -1) {
|
||
|
ast_log(LOG_WARNING, "error setting format for %s [%s]\n",
|
||
|
dev, strerror(errno));
|
||
|
goto error;
|
||
|
}
|
||
|
if (ioctl(v->fd, VIDIOCGPICT, &vp) == -1) {
|
||
|
ast_log(LOG_WARNING, "error reading picture info\n");
|
||
|
goto error;
|
||
|
}
|
||
|
ast_log(LOG_WARNING,
|
||
|
"contrast %d bright %d colour %d hue %d white %d palette %d\n",
|
||
|
vp.contrast, vp.brightness,
|
||
|
vp.colour, vp.hue,
|
||
|
vp.whiteness, vp.palette);
|
||
|
/* set the video format. Here again, we don't necessary have to
|
||
|
* fail if the required format is not supported, but try to use
|
||
|
* what the camera gives us.
|
||
|
*/
|
||
|
b->pix_fmt = vp.palette;
|
||
|
vp.palette = VIDEO_PALETTE_YUV420P;
|
||
|
if (ioctl(v->fd, VIDIOCSPICT, &vp) == -1) {
|
||
|
ast_log(LOG_WARNING, "error setting palette, using %d\n",
|
||
|
b->pix_fmt);
|
||
|
} else
|
||
|
b->pix_fmt = vp.palette;
|
||
|
/* allocate the source buffer.
|
||
|
* XXX, the code here only handles yuv411, for other formats
|
||
|
* we need to look at pix_fmt and set size accordingly
|
||
|
*/
|
||
|
b->size = (b->w * b->h * 3)/2; /* yuv411 */
|
||
|
ast_log(LOG_WARNING, "videodev %s opened, size %dx%d %d\n",
|
||
|
dev, b->w, b->h, b->size);
|
||
|
v->loc_src.data = ast_calloc(1, b->size);
|
||
|
if (!b->data) {
|
||
|
ast_log(LOG_WARNING, "error allocating buffer %d bytes\n",
|
||
|
b->size);
|
||
|
goto error;
|
||
|
}
|
||
|
ast_log(LOG_WARNING, "success opening camera\n");
|
||
|
}
|
||
|
#endif /* HAVE_VIDEODEV_H */
|
||
|
|
||
|
if (v->image == NULL && v->fd < 0)
|
||
|
goto error;
|
||
|
b->used = 0;
|
||
|
return 0;
|
||
|
|
||
|
error:
|
||
|
ast_log(LOG_WARNING, "fd %d dpy %p img %p data %p\n",
|
||
|
v->fd, v->dpy, v->image, v->loc_src.data);
|
||
|
/* XXX maybe XDestroy (v->image) ? */
|
||
|
if (v->dpy)
|
||
|
XCloseDisplay(v->dpy);
|
||
|
v->dpy = NULL;
|
||
|
if (v->fd >= 0)
|
||
|
close(v->fd);
|
||
|
v->fd = -1;
|
||
|
fbuf_free(&v->loc_src);
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/*! \brief complete a buffer from the local video source.
|
||
|
* Called by get_video_frames(), in turn called by the video thread.
|
||
|
*/
|
||
|
static int video_read(struct video_out_desc *v)
|
||
|
{
|
||
|
struct timeval now = ast_tvnow();
|
||
|
struct fbuf_t *b = &v->loc_src;
|
||
|
|
||
|
if (b->data == NULL) /* not initialized */
|
||
|
return 0;
|
||
|
|
||
|
/* 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 */
|
||
|
|
||
|
#ifdef HAVE_X11
|
||
|
if (v->image) {
|
||
|
/* read frame from X11 */
|
||
|
AVPicture p;
|
||
|
XGetSubImage(v->dpy,
|
||
|
RootWindow(v->dpy, DefaultScreen(v->dpy)),
|
||
|
b->x, b->y, b->w, b->h, AllPlanes, ZPixmap, v->image, 0, 0);
|
||
|
|
||
|
b->data = (uint8_t *)v->image->data;
|
||
|
fill_pict(b, &p);
|
||
|
return p.linesize[0] * b->h;
|
||
|
}
|
||
|
#endif
|
||
|
if (v->fd < 0) /* no other source */
|
||
|
return 0;
|
||
|
for (;;) {
|
||
|
int r, l = v->loc_src.size - v->loc_src.used;
|
||
|
r = read(v->fd, v->loc_src.data + v->loc_src.used, l);
|
||
|
// ast_log(LOG_WARNING, "read %d of %d bytes from webcam\n", r, l);
|
||
|
if (r < 0) /* read error */
|
||
|
return 0;
|
||
|
if (r == 0) /* no data */
|
||
|
return 0;
|
||
|
v->loc_src.used += r;
|
||
|
if (r == l) {
|
||
|
v->loc_src.used = 0; /* prepare for next frame */
|
||
|
return v->loc_src.size;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* Helper function to process incoming video.
|
||
|
* For each incoming video call invoke ffmpeg_init() to intialize
|
||
|
* the decoding structure then incoming video frames are processed
|
||
|
* by write_video() which in turn calls pre_process_data(), to extract
|
||
|
* the bitstream; accumulates data into a buffer within video_desc. When
|
||
|
* a frame is complete (determined by the marker bit in the RTP header)
|
||
|
* call decode_video() to decoding and if it successful call show_frame()
|
||
|
* to display the frame.
|
||
|
*/
|
||
|
|
||
|
/*
|
||
|
* Table of translation between asterisk and ffmpeg formats.
|
||
|
* We need also a field for read and write (encoding and decoding), because
|
||
|
* e.g. H263+ uses different codec IDs in ffmpeg when encoding or decoding.
|
||
|
*/
|
||
|
struct _cm { /* map ffmpeg codec types to asterisk formats */
|
||
|
uint32_t ast_format; /* 0 is a terminator */
|
||
|
enum CodecID codec;
|
||
|
enum { CM_RD = 1, CM_WR = 2, CM_RDWR = 3 } rw; /* read or write or both ? */
|
||
|
struct video_codec_desc *codec_desc;
|
||
|
};
|
||
|
|
||
|
static struct _cm video_formats[] = {
|
||
|
{ AST_FORMAT_H263_PLUS, CODEC_ID_H263, CM_RD }, /* incoming H263P ? */
|
||
|
{ AST_FORMAT_H263_PLUS, CODEC_ID_H263P, CM_WR },
|
||
|
{ AST_FORMAT_H263, CODEC_ID_H263, CM_RD },
|
||
|
{ AST_FORMAT_H263, CODEC_ID_H263, CM_WR },
|
||
|
{ AST_FORMAT_H261, CODEC_ID_H261, CM_RDWR },
|
||
|
{ AST_FORMAT_H264, CODEC_ID_H264, CM_RDWR },
|
||
|
{ AST_FORMAT_MP4_VIDEO, CODEC_ID_MPEG4, CM_RDWR },
|
||
|
{ 0, 0, 0 },
|
||
|
};
|
||
|
|
||
|
|
||
|
/*! \brief map an asterisk format into an ffmpeg one */
|
||
|
static enum CodecID map_video_format(uint32_t ast_format, int rw)
|
||
|
{
|
||
|
struct _cm *i;
|
||
|
|
||
|
for (i = video_formats; i->ast_format != 0; i++)
|
||
|
if (ast_format & i->ast_format && rw & i->rw && rw & i->rw)
|
||
|
return i->codec;
|
||
|
return CODEC_ID_NONE;
|
||
|
}
|
||
|
|
||
|
/* pointers to supported codecs. We assume the first one to be non null. */
|
||
|
static struct video_codec_desc *supported_codecs[] = {
|
||
|
&h263p_codec,
|
||
|
&h264_codec,
|
||
|
&h263_codec,
|
||
|
&h261_codec,
|
||
|
&mpeg4_codec,
|
||
|
NULL
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* Map the AST_FORMAT to the library. If not recognised, fail.
|
||
|
* This is useful in the input path where we get frames.
|
||
|
*/
|
||
|
static struct video_codec_desc *map_video_codec(int fmt)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
for (i = 0; supported_codecs[i]; i++)
|
||
|
if (fmt == supported_codecs[i]->format) {
|
||
|
ast_log(LOG_WARNING, "using %s for format 0x%x\n",
|
||
|
supported_codecs[i]->name, fmt);
|
||
|
return supported_codecs[i];
|
||
|
}
|
||
|
return NULL;
|
||
|
}
|
||
|
;
|
||
|
/*
|
||
|
* Map the codec name to the library. If not recognised, use a default.
|
||
|
* This is useful in the output path where we decide by name, presumably.
|
||
|
*/
|
||
|
static struct video_codec_desc *map_config_video_format(char *name)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
for (i = 0; supported_codecs[i]; i++)
|
||
|
if (!strcasecmp(name, supported_codecs[i]->name))
|
||
|
break;
|
||
|
if (supported_codecs[i] == NULL) {
|
||
|
ast_log(LOG_WARNING, "Cannot find codec for '%s'\n", name);
|
||
|
i = 0;
|
||
|
strcpy(name, supported_codecs[i]->name);
|
||
|
}
|
||
|
ast_log(LOG_WARNING, "Using codec '%s'\n", name);
|
||
|
return supported_codecs[i];
|
||
|
}
|
||
|
|
||
|
/*! \brief uninitialize the descriptor for remote video stream */
|
||
|
static int video_in_uninit(struct video_in_desc *v)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
if (v->parser) {
|
||
|
av_parser_close(v->parser);
|
||
|
v->parser = NULL;
|
||
|
}
|
||
|
if (v->dec_ctx) {
|
||
|
avcodec_close(v->dec_ctx);
|
||
|
av_free(v->dec_ctx);
|
||
|
v->dec_ctx = NULL;
|
||
|
}
|
||
|
if (v->d_frame) {
|
||
|
av_free(v->d_frame);
|
||
|
v->d_frame = NULL;
|
||
|
}
|
||
|
v->codec = NULL; /* only a reference */
|
||
|
v->dec = NULL; /* forget the decoder */
|
||
|
v->discard = 1; /* start in discard mode */
|
||
|
for (i = 0; i < N_DEC_IN; i++)
|
||
|
fbuf_free(&v->dec_in[i]);
|
||
|
fbuf_free(&v->dec_out);
|
||
|
fbuf_free(&v->rem_dpy);
|
||
|
return -1; /* error, in case someone cares */
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* initialize ffmpeg resources used for decoding frames from the network.
|
||
|
*/
|
||
|
static int video_in_init(struct video_in_desc *v, uint32_t format)
|
||
|
{
|
||
|
enum CodecID codec;
|
||
|
|
||
|
/* XXX should check that these are already set */
|
||
|
v->codec = NULL;
|
||
|
v->dec_ctx = NULL;
|
||
|
v->d_frame = NULL;
|
||
|
v->parser = NULL;
|
||
|
v->discard = 1;
|
||
|
|
||
|
codec = map_video_format(format, CM_RD);
|
||
|
|
||
|
v->codec = avcodec_find_decoder(codec);
|
||
|
if (!v->codec) {
|
||
|
ast_log(LOG_WARNING, "Unable to find the decoder for format %d\n", codec);
|
||
|
return video_in_uninit(v);
|
||
|
}
|
||
|
/*
|
||
|
* Initialize the codec context.
|
||
|
*/
|
||
|
v->dec_ctx = avcodec_alloc_context();
|
||
|
if (avcodec_open(v->dec_ctx, v->codec) < 0) {
|
||
|
ast_log(LOG_WARNING, "Cannot open the codec context\n");
|
||
|
av_free(v->dec_ctx);
|
||
|
v->dec_ctx = NULL;
|
||
|
return video_in_uninit(v);
|
||
|
}
|
||
|
|
||
|
v->parser = av_parser_init(codec);
|
||
|
if (!v->parser) {
|
||
|
ast_log(LOG_WARNING, "Cannot initialize the decoder parser\n");
|
||
|
return video_in_uninit(v);
|
||
|
}
|
||
|
|
||
|
v->d_frame = avcodec_alloc_frame();
|
||
|
if (!v->d_frame) {
|
||
|
ast_log(LOG_WARNING, "Cannot allocate decoding video frame\n");
|
||
|
return video_in_uninit(v);
|
||
|
}
|
||
|
return 0; /* ok */
|
||
|
}
|
||
|
|
||
|
/*! \brief uninitialize the descriptor for local video stream */
|
||
|
static int video_out_uninit(struct video_out_desc *v)
|
||
|
{
|
||
|
if (v->enc_ctx) {
|
||
|
avcodec_close(v->enc_ctx);
|
||
|
av_free(v->enc_ctx);
|
||
|
v->enc_ctx = NULL;
|
||
|
}
|
||
|
if (v->frame) {
|
||
|
av_free(v->frame);
|
||
|
v->frame = NULL;
|
||
|
}
|
||
|
v->codec = NULL; /* only a reference */
|
||
|
|
||
|
fbuf_free(&v->loc_src);
|
||
|
fbuf_free(&v->enc_in);
|
||
|
fbuf_free(&v->enc_out);
|
||
|
fbuf_free(&v->loc_dpy);
|
||
|
if (v->image) { /* X11 grabber */
|
||
|
XCloseDisplay(v->dpy);
|
||
|
v->dpy = NULL;
|
||
|
v->image = NULL;
|
||
|
}
|
||
|
if (v->fd >= 0) {
|
||
|
close(v->fd);
|
||
|
v->fd = -1;
|
||
|
}
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Initialize the encoder for the local source:
|
||
|
* - AVCodecContext, AVCodec, AVFrame are used by ffmpeg for encoding;
|
||
|
* - encbuf is used to store the encoded frame (to be sent)
|
||
|
* - mtu is used to determine the max size of video fragment
|
||
|
* NOTE: we enter here with the video source already open.
|
||
|
*/
|
||
|
static int video_out_init(struct video_desc *env)
|
||
|
{
|
||
|
int codec;
|
||
|
int size;
|
||
|
struct fbuf_t *enc_in;
|
||
|
struct video_out_desc *v = &env->out;
|
||
|
|
||
|
v->enc_ctx = NULL;
|
||
|
v->codec = NULL;
|
||
|
v->frame = NULL;
|
||
|
v->enc_out.data = NULL;
|
||
|
|
||
|
if (v->loc_src.data == NULL) {
|
||
|
ast_log(LOG_WARNING, "No local source active\n");
|
||
|
return video_out_uninit(v);
|
||
|
}
|
||
|
codec = map_video_format(v->enc->format, CM_WR);
|
||
|
v->codec = avcodec_find_encoder(codec);
|
||
|
if (!v->codec) {
|
||
|
ast_log(LOG_WARNING, "Cannot find the encoder for format %d\n",
|
||
|
codec);
|
||
|
return video_out_uninit(v);
|
||
|
}
|
||
|
|
||
|
v->mtu = 1400; /* set it early so the encoder can use it */
|
||
|
|
||
|
/* allocate the input buffer for encoding.
|
||
|
* ffmpeg only supports PIX_FMT_YUV420P for the encoding.
|
||
|
*/
|
||
|
enc_in = &v->enc_in;
|
||
|
enc_in->pix_fmt = PIX_FMT_YUV420P;
|
||
|
enc_in->size = (enc_in->w * enc_in->h * 3)/2;
|
||
|
enc_in->data = ast_calloc(1, enc_in->size);
|
||
|
if (!enc_in->data) {
|
||
|
ast_log(LOG_WARNING, "Cannot allocate encoder input buffer\n");
|
||
|
return video_out_uninit(v);
|
||
|
}
|
||
|
v->frame = avcodec_alloc_frame();
|
||
|
if (!v->frame) {
|
||
|
ast_log(LOG_WARNING, "Unable to allocate the encoding video frame\n");
|
||
|
return video_out_uninit(v);
|
||
|
}
|
||
|
|
||
|
/* parameters for PIX_FMT_YUV420P */
|
||
|
size = enc_in->w * enc_in->h;
|
||
|
v->frame->data[0] = enc_in->data;
|
||
|
v->frame->data[1] = v->frame->data[0] + size;
|
||
|
v->frame->data[2] = v->frame->data[1] + size/4;
|
||
|
v->frame->linesize[0] = enc_in->w;
|
||
|
v->frame->linesize[1] = enc_in->w/2;
|
||
|
v->frame->linesize[2] = enc_in->w/2;
|
||
|
|
||
|
/* now setup the parameters for the encoder */
|
||
|
v->enc_ctx = avcodec_alloc_context();
|
||
|
v->enc_ctx->pix_fmt = enc_in->pix_fmt;
|
||
|
v->enc_ctx->width = enc_in->w;
|
||
|
v->enc_ctx->height = enc_in->h;
|
||
|
/* XXX rtp_callback ?
|
||
|
* rtp_mode so ffmpeg inserts as many start codes as possible.
|
||
|
*/
|
||
|
v->enc_ctx->rtp_mode = 1;
|
||
|
v->enc_ctx->rtp_payload_size = v->mtu / 2; // mtu/2
|
||
|
v->enc_ctx->bit_rate = v->bitrate;
|
||
|
v->enc_ctx->bit_rate_tolerance = v->enc_ctx->bit_rate/2;
|
||
|
v->enc_ctx->qmin = v->qmin; /* should be configured */
|
||
|
v->enc_ctx->time_base = (AVRational){1, v->fps};
|
||
|
|
||
|
v->enc->enc_init(v);
|
||
|
|
||
|
if (avcodec_open(v->enc_ctx, v->codec) < 0) {
|
||
|
ast_log(LOG_WARNING, "Unable to initialize the encoder %d\n",
|
||
|
codec);
|
||
|
av_free(v->enc_ctx);
|
||
|
v->enc_ctx = NULL;
|
||
|
return video_out_uninit(v);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Allocate enough for the encoded bitstream. As we are compressing,
|
||
|
* we hope that the output is never larger than the input size.
|
||
|
*/
|
||
|
v->enc_out.data = ast_calloc(1, enc_in->size);
|
||
|
v->enc_out.size = enc_in->size;
|
||
|
v->enc_out.used = 0;
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static void cleanup_sdl(struct video_desc *env)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
#ifdef HAVE_SDL_TTF
|
||
|
/* unload font file */
|
||
|
if (env->gui.font) {
|
||
|
TTF_CloseFont(env->gui.font);
|
||
|
env->gui.font = NULL;
|
||
|
}
|
||
|
|
||
|
/* uninitialize SDL_ttf library */
|
||
|
if ( TTF_WasInit() )
|
||
|
TTF_Quit();
|
||
|
#endif
|
||
|
|
||
|
/* uninitialize the SDL environment */
|
||
|
for (i = 0; i < WIN_MAX; i++) {
|
||
|
if (env->win[i].bmp)
|
||
|
SDL_FreeYUVOverlay(env->win[i].bmp);
|
||
|
}
|
||
|
if (env->gui.keypad)
|
||
|
SDL_FreeSurface(env->gui.keypad);
|
||
|
env->gui.keypad = NULL;
|
||
|
SDL_Quit();
|
||
|
env->screen = NULL; /* XXX check reference */
|
||
|
bzero(env->win, sizeof(env->win));
|
||
|
if (env->sdl_ok)
|
||
|
ast_mutex_destroy(&(env->in.dec_in_lock));
|
||
|
}
|
||
|
|
||
|
/*! \brief uninitialize the entire environment.
|
||
|
* In practice, signal the thread and give it a bit of time to
|
||
|
* complete, giving up if it gets stuck. Because uninit
|
||
|
* is called from hangup with the channel locked, and the thread
|
||
|
* uses the chan lock, we need to unlock here. This is unsafe,
|
||
|
* and we should really use refcounts for the channels.
|
||
|
*/
|
||
|
static void console_video_uninit(struct video_desc *env)
|
||
|
{
|
||
|
int i, t = 100; /* initial wait is shorter, than make it longer */
|
||
|
env->shutdown = 1;
|
||
|
for (i=0; env->shutdown && i < 10; i++) {
|
||
|
ast_channel_unlock(env->owner);
|
||
|
usleep(t);
|
||
|
t = 1000000;
|
||
|
ast_channel_lock(env->owner);
|
||
|
}
|
||
|
env->owner = NULL;
|
||
|
}
|
||
|
|
||
|
/*! fill an AVPicture from our fbuf info, as it is required by
|
||
|
* the image conversion routines in ffmpeg.
|
||
|
* XXX This depends on the format.
|
||
|
*/
|
||
|
static AVPicture *fill_pict(struct fbuf_t *b, AVPicture *p)
|
||
|
{
|
||
|
/* provide defaults for commonly used formats */
|
||
|
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 */
|
||
|
|
||
|
bzero(p, sizeof(*p));
|
||
|
switch (b->pix_fmt) {
|
||
|
case PIX_FMT_RGB555:
|
||
|
case PIX_FMT_RGB565:
|
||
|
len *= 2;
|
||
|
luv = 0;
|
||
|
break;
|
||
|
case PIX_FMT_RGBA32:
|
||
|
len *= 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 */
|
||
|
luv = 0;
|
||
|
break;
|
||
|
}
|
||
|
p->data[0] = b->data;
|
||
|
p->linesize[0] = len;
|
||
|
/* these are only valid for component images */
|
||
|
p->data[1] = luv ? b->data + 4*l4 : b->data+len;
|
||
|
p->data[2] = luv ? b->data + 5*l4 : b->data+len;
|
||
|
p->linesize[1] = luv;
|
||
|
p->linesize[2] = luv;
|
||
|
return p;
|
||
|
}
|
||
|
|
||
|
/*! convert/scale between an input and an output format.
|
||
|
* Old version of ffmpeg only have img_convert, which does not rescale.
|
||
|
* New versions use sws_scale which does both.
|
||
|
*/
|
||
|
static void my_scale(struct fbuf_t *in, AVPicture *p_in,
|
||
|
struct fbuf_t *out, AVPicture *p_out)
|
||
|
{
|
||
|
AVPicture my_p_in, my_p_out;
|
||
|
|
||
|
if (p_in == NULL)
|
||
|
p_in = fill_pict(in, &my_p_in);
|
||
|
if (p_out == NULL)
|
||
|
p_out = fill_pict(out, &my_p_out);
|
||
|
|
||
|
#ifdef OLD_FFMPEG
|
||
|
/* XXX img_convert is deprecated, and does not do rescaling */
|
||
|
img_convert(p_out, out->pix_fmt,
|
||
|
p_in, in->pix_fmt, in->w, in->h);
|
||
|
#else /* XXX replacement */
|
||
|
{
|
||
|
struct SwsContext *convert_ctx;
|
||
|
|
||
|
convert_ctx = sws_getContext(in->w, in->h, in->pix_fmt,
|
||
|
out->w, out->h, out->pix_fmt,
|
||
|
SWS_BICUBIC, NULL, NULL, NULL);
|
||
|
if (convert_ctx == NULL) {
|
||
|
ast_log(LOG_ERROR, "FFMPEG::convert_cmodel : swscale context initialization failed");
|
||
|
return;
|
||
|
}
|
||
|
if (0)
|
||
|
ast_log(LOG_WARNING, "in %d %dx%d out %d %dx%d\n",
|
||
|
in->pix_fmt, in->w, in->h, out->pix_fmt, out->w, out->h);
|
||
|
sws_scale(convert_ctx,
|
||
|
p_in->data, p_in->linesize,
|
||
|
in->w, in->h, /* src slice */
|
||
|
p_out->data, p_out->linesize);
|
||
|
|
||
|
sws_freeContext(convert_ctx);
|
||
|
}
|
||
|
#endif /* XXX replacement */
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* 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
|
||
|
* - Create a YUV Overlay to copy the frame into it;
|
||
|
* - After the frame is copied into the overlay, display it
|
||
|
*
|
||
|
* The size is taken from the configuration.
|
||
|
*
|
||
|
* 'out' is 0 for remote video, 1 for the local video
|
||
|
*/
|
||
|
static void show_frame(struct video_desc *env, int out)
|
||
|
{
|
||
|
AVPicture *p_in, p_out;
|
||
|
struct fbuf_t *b_in, *b_out;
|
||
|
SDL_Overlay *bmp;
|
||
|
|
||
|
if (!env->sdl_ok)
|
||
|
return;
|
||
|
|
||
|
if (out == WIN_LOCAL) { /* webcam/x11 to sdl */
|
||
|
b_in = &env->out.enc_in;
|
||
|
b_out = &env->out.loc_dpy;
|
||
|
p_in = NULL;
|
||
|
} else {
|
||
|
/* copy input format from the decoding context */
|
||
|
AVCodecContext *c = env->in.dec_ctx;
|
||
|
b_in = &env->in.dec_out;
|
||
|
b_in->pix_fmt = c->pix_fmt;
|
||
|
b_in->w = c->width;
|
||
|
b_in->h = c->height;
|
||
|
|
||
|
b_out = &env->in.rem_dpy;
|
||
|
p_in = (AVPicture *)env->in.d_frame;
|
||
|
}
|
||
|
bmp = env->win[out].bmp;
|
||
|
SDL_LockYUVOverlay(bmp);
|
||
|
/* output picture info - this is sdl, YUV420P */
|
||
|
bzero(&p_out, sizeof(p_out));
|
||
|
p_out.data[0] = bmp->pixels[0];
|
||
|
p_out.data[1] = bmp->pixels[1];
|
||
|
p_out.data[2] = bmp->pixels[2];
|
||
|
p_out.linesize[0] = bmp->pitches[0];
|
||
|
p_out.linesize[1] = bmp->pitches[1];
|
||
|
p_out.linesize[2] = bmp->pitches[2];
|
||
|
|
||
|
my_scale(b_in, p_in, b_out, &p_out);
|
||
|
|
||
|
/* lock to protect access to Xlib by different threads. */
|
||
|
SDL_DisplayYUVOverlay(bmp, &env->win[out].rect);
|
||
|
SDL_UnlockYUVOverlay(bmp);
|
||
|
}
|
||
|
|
||
|
static struct video_desc *get_video_desc(struct ast_channel *c);
|
||
|
|
||
|
/*
|
||
|
* This function is called (by asterisk) for each video packet
|
||
|
* coming from the network (the 'in' path) that needs to be processed.
|
||
|
* We need to reconstruct the entire video frame before we can decode it.
|
||
|
* After a video packet is received we have to:
|
||
|
* - extract the bitstream with pre_process_data()
|
||
|
* - append the bitstream to a buffer
|
||
|
* - if the fragment is the last (RTP Marker) we decode it with decode_video()
|
||
|
* - after the decoding is completed we display the decoded frame with show_frame()
|
||
|
*/
|
||
|
static int console_write_video(struct ast_channel *chan, struct ast_frame *f)
|
||
|
{
|
||
|
struct video_desc *env = get_video_desc(chan);
|
||
|
struct video_in_desc *v = &env->in;
|
||
|
|
||
|
if (v->dec == NULL) { /* try to get the codec */
|
||
|
v->dec = map_video_codec(f->subclass & ~1);
|
||
|
if (v->dec == NULL) {
|
||
|
ast_log(LOG_WARNING, "cannot find video codec, drop input 0x%x\n", f->subclass);
|
||
|
return 0;
|
||
|
}
|
||
|
if (video_in_init(v, v->dec->format)) {
|
||
|
/* This is not fatal, but we won't have incoming video */
|
||
|
ast_log(LOG_WARNING, "Cannot initialize input decoder\n");
|
||
|
v->dec = NULL;
|
||
|
return 0;
|
||
|
}
|
||
|
}
|
||
|
if (v->dec_ctx == NULL) {
|
||
|
ast_log(LOG_WARNING, "cannot decode, dropping frame\n");
|
||
|
return 0; /* error */
|
||
|
}
|
||
|
|
||
|
if (v->dec_in_cur == NULL) /* no buffer for incoming frames, drop */
|
||
|
return 0;
|
||
|
#if defined(DROP_PACKETS) && DROP_PACKETS > 0
|
||
|
/* Simulate lost packets */
|
||
|
if ((random() % 10000) <= 100*DROP_PACKETS) {
|
||
|
ast_log(LOG_NOTICE, "Packet lost [%d]\n", f->seqno);
|
||
|
return 0;
|
||
|
}
|
||
|
#endif
|
||
|
if (v->discard) {
|
||
|
/*
|
||
|
* In discard mode, drop packets until we find one with
|
||
|
* the RTP marker set (which is the end of frame).
|
||
|
* Note that the RTP marker flag is sent as the LSB of the
|
||
|
* subclass, which is a bitmask of formats. The low bit is
|
||
|
* normally used for audio so there is no interference.
|
||
|
*/
|
||
|
if (f->subclass & 0x01) {
|
||
|
v->dec_in_cur->used = 0;
|
||
|
v->dec_in_cur->ebit = 0;
|
||
|
v->next_seq = f->seqno + 1; /* wrap at 16 bit */
|
||
|
v->discard = 0;
|
||
|
ast_log(LOG_WARNING, "out of discard mode, frame %d\n", f->seqno);
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Only in-order fragments will be accepted. Remember seqno
|
||
|
* has 16 bit so there is wraparound. Also, ideally we could
|
||
|
* accept a bit of reordering, but at the moment we don't.
|
||
|
*/
|
||
|
if (v->next_seq != f->seqno) {
|
||
|
ast_log(LOG_WARNING, "discarding frame out of order, %d %d\n",
|
||
|
v->next_seq, f->seqno);
|
||
|
v->discard = 1;
|
||
|
return 0;
|
||
|
}
|
||
|
v->next_seq++;
|
||
|
|
||
|
if (f->data == NULL || f->datalen < 2) {
|
||
|
ast_log(LOG_WARNING, "empty video frame, discard\n");
|
||
|
return 0;
|
||
|
}
|
||
|
if (v->dec->dec_decap(v->dec_in_cur, f->data, f->datalen)) {
|
||
|
ast_log(LOG_WARNING, "error in dec_decap, enter discard\n");
|
||
|
v->discard = 1;
|
||
|
}
|
||
|
if (f->subclass & 0x01) { // RTP Marker
|
||
|
/* prepare to decode: advance the buffer so the video thread knows. */
|
||
|
struct fbuf_t *tmp = v->dec_in_cur; /* store current pointer */
|
||
|
ast_mutex_lock(&v->dec_in_lock);
|
||
|
if (++v->dec_in_cur == &v->dec_in[N_DEC_IN]) /* advance to next, circular */
|
||
|
v->dec_in_cur = &v->dec_in[0];
|
||
|
if (v->dec_in_dpy == NULL) { /* were not displaying anything, so set it */
|
||
|
v->dec_in_dpy = tmp;
|
||
|
} else if (v->dec_in_dpy == v->dec_in_cur) { /* current slot is busy */
|
||
|
v->dec_in_cur = NULL;
|
||
|
}
|
||
|
ast_mutex_unlock(&v->dec_in_lock);
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*! \brief read a frame from webcam or X11 through video_read(),
|
||
|
* display it, then encode and split it.
|
||
|
* Return a list of ast_frame representing the video fragments.
|
||
|
* The head pointer is returned by the function, the tail pointer
|
||
|
* is returned as an argument.
|
||
|
*/
|
||
|
static struct ast_frame *get_video_frames(struct video_desc *env, struct ast_frame **tail)
|
||
|
{
|
||
|
struct video_out_desc *v = &env->out;
|
||
|
struct ast_frame *dummy;
|
||
|
|
||
|
if (!v->loc_src.data) {
|
||
|
static volatile int a = 0;
|
||
|
if (a++ < 2)
|
||
|
ast_log(LOG_WARNING, "fail, no loc_src buffer\n");
|
||
|
return NULL;
|
||
|
}
|
||
|
if (!video_read(v))
|
||
|
return NULL; /* can happen, e.g. we are reading too early */
|
||
|
|
||
|
if (tail == NULL)
|
||
|
tail = &dummy;
|
||
|
*tail = NULL;
|
||
|
/* Scale the video for the encoder, then use it for local rendering
|
||
|
* so we will see the same as the remote party.
|
||
|
*/
|
||
|
my_scale(&v->loc_src, NULL, &v->enc_in, NULL);
|
||
|
show_frame(env, WIN_LOCAL);
|
||
|
if (!v->sendvideo)
|
||
|
return NULL;
|
||
|
if (v->enc_out.data == NULL) {
|
||
|
static volatile int a = 0;
|
||
|
if (a++ < 2)
|
||
|
ast_log(LOG_WARNING, "fail, no encbuf\n");
|
||
|
return NULL;
|
||
|
}
|
||
|
v->enc->enc_run(v);
|
||
|
return v->enc->enc_encap(v, tail);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* GUI layout, structure and management
|
||
|
*
|
||
|
|
||
|
For the GUI we use SDL to create a large surface (env->screen)
|
||
|
containing tree sections: remote video on the left, local video
|
||
|
on the right, and the keypad with all controls and text windows
|
||
|
in the center.
|
||
|
The central section is built using two images: one is the skin,
|
||
|
the other one is a mask where the sensitive areas of the skin
|
||
|
are colored in different grayscale levels according to their
|
||
|
functions. The mapping between colors and function is defined
|
||
|
in the 'enum pixel_value' below.
|
||
|
|
||
|
Mouse and keyboard events are detected on the whole surface, and
|
||
|
handled differently according to their location, as follows:
|
||
|
|
||
|
- drag on the local video window are used to move the captured
|
||
|
area (in the case of X11 grabber) or the picture-in-picture
|
||
|
location (in case of camera included on the X11 grab).
|
||
|
- click on the keypad are mapped to the corresponding key;
|
||
|
- drag on some keypad areas (sliders etc.) are mapped to the
|
||
|
corresponding functions;
|
||
|
- keystrokes are used as keypad functions, or as text input
|
||
|
if we are in text-input mode.
|
||
|
|
||
|
To manage these behavior we use two status variables,
|
||
|
that defines if keyboard events should be redirect to dialing functions
|
||
|
or to write message functions, and if mouse events should be used
|
||
|
to implement keypad functionalities or to drag the capture device.
|
||
|
|
||
|
Configuration options control the appeareance of the gui:
|
||
|
|
||
|
keypad = /tmp/phone.jpg ; the keypad on the screen
|
||
|
keypad_mask = /tmp/phone.png ; the grayscale mask
|
||
|
keypad_font = /tmp/font.ttf ; the font to use for output
|
||
|
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
/* enumerate for the pixel value. 0..127 correspond to ascii chars */
|
||
|
enum pixel_value {
|
||
|
/* answer/close functions */
|
||
|
KEY_PICK_UP = 128,
|
||
|
KEY_HANG_UP = 129,
|
||
|
|
||
|
/* other functions */
|
||
|
KEY_MUTE = 130,
|
||
|
KEY_AUTOANSWER = 131,
|
||
|
KEY_SENDVIDEO = 132,
|
||
|
KEY_LOCALVIDEO = 133,
|
||
|
KEY_REMOTEVIDEO = 134,
|
||
|
KEY_WRITEMESSAGE = 135,
|
||
|
KEY_GUI_CLOSE = 136, /* close gui */
|
||
|
|
||
|
/* other areas within the keypad */
|
||
|
KEY_DIGIT_BACKGROUND = 255,
|
||
|
|
||
|
/* areas outside the keypad - simulated */
|
||
|
KEY_OUT_OF_KEYPAD = 251,
|
||
|
KEY_REM_DPY = 252,
|
||
|
KEY_LOC_DPY = 253,
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* Handlers for the various keypad functions
|
||
|
*/
|
||
|
|
||
|
/*! \brief append a character, or reset if '\0' */
|
||
|
static void append_char(char *str, int *str_pos, const char c)
|
||
|
{
|
||
|
int i = *str_pos;
|
||
|
if (c == '\0')
|
||
|
i = 0;
|
||
|
else if (i < GUI_BUFFER_LEN - 1)
|
||
|
str[i++] = c;
|
||
|
else
|
||
|
i = GUI_BUFFER_LEN - 1; /* unnecessary, i think */
|
||
|
str = '\0';
|
||
|
*str_pos = i;
|
||
|
}
|
||
|
|
||
|
/* accumulate digits, possibly call dial if in connected mode */
|
||
|
static void keypad_digit(struct video_desc *env, int digit)
|
||
|
{
|
||
|
struct chan_oss_pvt *o = find_desc(oss_active);
|
||
|
|
||
|
if (o->owner) { /* we have a call, send the digit */
|
||
|
struct ast_frame f = { AST_FRAME_DTMF, 0 };
|
||
|
|
||
|
f.subclass = digit;
|
||
|
ast_queue_frame(o->owner, &f);
|
||
|
} else { /* no call, accumulate digits */
|
||
|
append_char(env->gui.inbuf, &env->gui.inbuf_pos, digit);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* this is a wrapper for actions that are available through the cli */
|
||
|
/* TODO append arg to command and send the resulting string as cli command */
|
||
|
static void keypad_send_command(struct video_desc *env, char *command)
|
||
|
{
|
||
|
ast_log(LOG_WARNING, "keypad_send_command(%s) called\n", command);
|
||
|
ast_cli_command(env->gui.outfd, command);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/* function used to toggle on/off the status of some variables */
|
||
|
static char *keypad_toggle(int index)
|
||
|
{
|
||
|
struct chan_oss_pvt *o = find_desc(oss_active);
|
||
|
ast_log(LOG_WARNING, "keypad_toggle(%i) called\n", index);
|
||
|
|
||
|
switch (index) {
|
||
|
case KEY_MUTE:
|
||
|
o->mute = !o->mute;
|
||
|
break;
|
||
|
case KEY_SENDVIDEO:
|
||
|
o->env->out.sendvideo = !o->env->out.sendvideo;
|
||
|
break;
|
||
|
case KEY_AUTOANSWER:
|
||
|
o->autoanswer = !o->autoanswer;
|
||
|
break;
|
||
|
}
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Function called when the pick up button is pressed
|
||
|
* perform actions according the channel status:
|
||
|
*
|
||
|
* - if no one is calling us and no digits was pressed,
|
||
|
* the operation have no effects,
|
||
|
* - if someone is calling us we answer to the call.
|
||
|
* - if we have no call in progress and we pressed some
|
||
|
* digit, send the digit to the console.
|
||
|
*/
|
||
|
static void keypad_pick_up(struct video_desc *env)
|
||
|
{
|
||
|
struct chan_oss_pvt *o = find_desc(oss_active);
|
||
|
ast_log(LOG_WARNING, "keypad_pick_up called\n");
|
||
|
|
||
|
if (o->owner) { /* someone is calling us, just answer */
|
||
|
struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
|
||
|
o->hookstate = 1;
|
||
|
o->cursound = -1;
|
||
|
o->nosound = 0;
|
||
|
ast_queue_frame(o->owner, &f);
|
||
|
} else if (env->gui.inbuf_pos) { /* we have someone to call */
|
||
|
ast_cli_command(env->gui.outfd, env->gui.inbuf);
|
||
|
}
|
||
|
|
||
|
append_char(env->gui.inbuf, &env->gui.inbuf_pos, '\0'); /* clear buffer */
|
||
|
}
|
||
|
|
||
|
#if 0 /* still unused */
|
||
|
/* Print given text on the gui */
|
||
|
static int gui_output(struct video_desc *env, const char *text)
|
||
|
{
|
||
|
#ifndef HAVE_SDL_TTF
|
||
|
return 1; /* error, not supported */
|
||
|
#else
|
||
|
int x = 30, y = 20; /* XXX change */
|
||
|
SDL_Surface *output = NULL;
|
||
|
SDL_Color color = {0, 0, 0}; /* text color */
|
||
|
SDL_Rect dest = {env->win[WIN_KEYPAD].rect.x + x, y};
|
||
|
|
||
|
/* clean surface each rewrite */
|
||
|
SDL_BlitSurface(env->gui.keypad, NULL, env->screen, &env->win[WIN_KEYPAD].rect);
|
||
|
|
||
|
output = TTF_RenderText_Solid(env->gui.font, text, color);
|
||
|
if (output == NULL) {
|
||
|
ast_log(LOG_WARNING, "Cannot render text on gui - %s\n", TTF_GetError());
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
SDL_BlitSurface(output, NULL, env->screen, &dest);
|
||
|
|
||
|
SDL_UpdateRects(env->gui.keypad, 1, &env->win[WIN_KEYPAD].rect);
|
||
|
SDL_FreeSurface(output);
|
||
|
return 0; /* success */
|
||
|
#endif
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
static int video_geom(struct fbuf_t *b, const char *s);
|
||
|
static void sdl_setup(struct video_desc *env);
|
||
|
static int kp_match_area(const struct keypad_entry *e, int x, int y);
|
||
|
|
||
|
/*
|
||
|
* Handle SDL_MOUSEBUTTONDOWN type, finding the palette
|
||
|
* index value and calling the right callback.
|
||
|
*
|
||
|
* x, y are referred to the upper left corner of the main SDL window.
|
||
|
*/
|
||
|
static void handle_button_event(struct video_desc *env, SDL_MouseButtonEvent button)
|
||
|
{
|
||
|
uint8_t index = KEY_OUT_OF_KEYPAD; /* the key or region of the display we clicked on */
|
||
|
|
||
|
/* for each click we come back in normal mode */
|
||
|
env->gui.text_mode = 0;
|
||
|
|
||
|
/* define keypad boundary */
|
||
|
if (button.x < env->in.rem_dpy.w)
|
||
|
index = KEY_REM_DPY; /* click on remote video */
|
||
|
else if (button.x > env->in.rem_dpy.w + env->out.keypad_dpy.w)
|
||
|
index = KEY_LOC_DPY; /* click on local video */
|
||
|
else if (button.y > env->out.keypad_dpy.h)
|
||
|
index = KEY_OUT_OF_KEYPAD; /* click outside the keypad */
|
||
|
else if (env->gui.kp) {
|
||
|
int i;
|
||
|
for (i = 0; i < env->gui.kp_used; i++) {
|
||
|
if (kp_match_area(&env->gui.kp[i], button.x - env->in.rem_dpy.w, button.y)) {
|
||
|
index = env->gui.kp[i].c;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* exec the function */
|
||
|
if (index < 128) { /* surely clicked on the keypad, don't care which key */
|
||
|
keypad_digit(env, index);
|
||
|
return;
|
||
|
}
|
||
|
switch (index) {
|
||
|
/* answer/close function */
|
||
|
case KEY_PICK_UP:
|
||
|
keypad_pick_up(env);
|
||
|
break;
|
||
|
case KEY_HANG_UP:
|
||
|
keypad_send_command(env, "console hangup");
|
||
|
break;
|
||
|
|
||
|
/* other functions */
|
||
|
case KEY_MUTE:
|
||
|
case KEY_AUTOANSWER:
|
||
|
case KEY_SENDVIDEO:
|
||
|
keypad_toggle(index);
|
||
|
break;
|
||
|
|
||
|
case KEY_LOCALVIDEO:
|
||
|
break;
|
||
|
case KEY_REMOTEVIDEO:
|
||
|
break;
|
||
|
case KEY_WRITEMESSAGE:
|
||
|
/* goes in text-mode */
|
||
|
env->gui.text_mode = 1;
|
||
|
break;
|
||
|
|
||
|
|
||
|
/* press outside the keypad. right increases size, center decreases, left drags */
|
||
|
case KEY_LOC_DPY:
|
||
|
case KEY_REM_DPY:
|
||
|
if (button.button == SDL_BUTTON_LEFT) {
|
||
|
if (index == KEY_LOC_DPY) {
|
||
|
/* store points where the drag start
|
||
|
* and switch in drag mode */
|
||
|
env->gui.x_drag = button.x;
|
||
|
env->gui.y_drag = button.y;
|
||
|
env->gui.drag_mode = 1;
|
||
|
}
|
||
|
break;
|
||
|
} else {
|
||
|
char buf[128];
|
||
|
struct fbuf_t *fb = index == KEY_LOC_DPY ? &env->out.loc_dpy : &env->in.rem_dpy;
|
||
|
sprintf(buf, "%c%dx%d", button.button == SDL_BUTTON_RIGHT ? '>' : '<',
|
||
|
fb->w, fb->h);
|
||
|
video_geom(fb, buf);
|
||
|
sdl_setup(env);
|
||
|
}
|
||
|
break;
|
||
|
case KEY_OUT_OF_KEYPAD:
|
||
|
break;
|
||
|
|
||
|
case KEY_GUI_CLOSE:
|
||
|
cleanup_sdl(env);
|
||
|
break;
|
||
|
case KEY_DIGIT_BACKGROUND:
|
||
|
break;
|
||
|
default:
|
||
|
ast_log(LOG_WARNING, "function not yet defined %i\n", index);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Handle SDL_KEYDOWN type event, put the key pressed
|
||
|
* in the dial buffer or in the text-message buffer,
|
||
|
* depending on the text_mode variable value.
|
||
|
*
|
||
|
* key is the SDLKey structure corresponding to the key pressed.
|
||
|
*/
|
||
|
static void handle_keyboard_input(struct video_desc *env, SDLKey key)
|
||
|
{
|
||
|
if (env->gui.text_mode) {
|
||
|
/* append in the text-message buffer */
|
||
|
if (key == SDLK_RETURN) {
|
||
|
/* send the text message and return in normal mode */
|
||
|
env->gui.text_mode = 0;
|
||
|
keypad_send_command(env, "send text");
|
||
|
} else {
|
||
|
/* accumulate the key in the message buffer */
|
||
|
append_char(env->gui.msgbuf, &env->gui.msgbuf_pos, key);
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
/* append in the dial buffer */
|
||
|
append_char(env->gui.inbuf, &env->gui.inbuf_pos, key);
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Check if the grab point is inside the X screen.
|
||
|
*
|
||
|
* x represent the new grab value
|
||
|
* limit represent the upper value to use
|
||
|
*/
|
||
|
static int boundary_checks(int x, int limit)
|
||
|
{
|
||
|
return (x <= 0) ? 0 : (x > limit ? limit : x);
|
||
|
}
|
||
|
|
||
|
/* implement superlinear acceleration on the movement */
|
||
|
static int move_accel(int delta)
|
||
|
{
|
||
|
int d1 = delta*delta / 100;
|
||
|
return (delta > 0) ? delta + d1 : delta - d1;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Move the source of the captured video.
|
||
|
*
|
||
|
* x_final_drag and y_final_drag are the coordinates where the drag ends,
|
||
|
* start coordinares are in the gui_info structure.
|
||
|
*/
|
||
|
static void move_capture_source(struct video_desc *env, int x_final_drag, int y_final_drag)
|
||
|
{
|
||
|
int new_x, new_y; /* new coordinates for grabbing local video */
|
||
|
int x = env->out.loc_src.x; /* old value */
|
||
|
int y = env->out.loc_src.y; /* old value */
|
||
|
|
||
|
/* move the origin */
|
||
|
#define POLARITY -1 /* +1 or -1 depending on the desired direction */
|
||
|
new_x = x + POLARITY*move_accel(x_final_drag - env->gui.x_drag) * 3;
|
||
|
new_y = y + POLARITY*move_accel(y_final_drag - env->gui.y_drag) * 3;
|
||
|
#undef POLARITY
|
||
|
env->gui.x_drag = x_final_drag; /* update origin */
|
||
|
env->gui.y_drag = y_final_drag;
|
||
|
|
||
|
/* check boundary and let the source to grab from the new points */
|
||
|
env->out.loc_src.x = boundary_checks(new_x, env->out.screen_width - env->out.loc_src.w);
|
||
|
env->out.loc_src.y = boundary_checks(new_y, env->out.screen_height - env->out.loc_src.h);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* I am seeing some kind of deadlock or stall around
|
||
|
* SDL_PumpEvents() while moving the window on a remote X server
|
||
|
* (both xfree-4.4.0 and xorg 7.2)
|
||
|
* and windowmaker. It is unclear what causes it.
|
||
|
*/
|
||
|
|
||
|
/* grab a bunch of events */
|
||
|
static void eventhandler(struct video_desc *env)
|
||
|
{
|
||
|
#define N_EVENTS 32
|
||
|
int i, n;
|
||
|
SDL_Event ev[N_EVENTS];
|
||
|
|
||
|
#define MY_EV (SDL_MOUSEBUTTONDOWN|SDL_KEYDOWN)
|
||
|
while ( (n = SDL_PeepEvents(ev, N_EVENTS, SDL_GETEVENT, SDL_ALLEVENTS)) > 0) {
|
||
|
for (i = 0; i < n; i++) {
|
||
|
#if 0
|
||
|
ast_log(LOG_WARNING, "------ event %d at %d %d\n",
|
||
|
ev[i].type, ev[i].button.x, ev[i].button.y);
|
||
|
#endif
|
||
|
switch (ev[i].type) {
|
||
|
case SDL_KEYDOWN:
|
||
|
handle_keyboard_input(env, ev[i].key.keysym.sym);
|
||
|
break;
|
||
|
case SDL_MOUSEMOTION:
|
||
|
if (env->gui.drag_mode != 0)
|
||
|
move_capture_source(env, ev[i].motion.x, ev[i].motion.y);
|
||
|
break;
|
||
|
case SDL_MOUSEBUTTONDOWN:
|
||
|
handle_button_event(env, ev[i].button);
|
||
|
break;
|
||
|
case SDL_MOUSEBUTTONUP:
|
||
|
if (env->gui.drag_mode != 0) {
|
||
|
move_capture_source(env, ev[i].button.x, ev[i].button.y);
|
||
|
env->gui.drag_mode = 0;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
}
|
||
|
if (1) {
|
||
|
struct timeval b, a = ast_tvnow();
|
||
|
int i;
|
||
|
//SDL_Lock_EventThread();
|
||
|
SDL_PumpEvents();
|
||
|
b = ast_tvnow();
|
||
|
i = ast_tvdiff_ms(b, a);
|
||
|
if (i > 3)
|
||
|
fprintf(stderr, "-------- SDL_PumpEvents took %dms\n", i);
|
||
|
//SDL_Unlock_EventThread();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static SDL_Surface *get_keypad(const char *file)
|
||
|
{
|
||
|
SDL_Surface *temp;
|
||
|
|
||
|
#ifdef HAVE_SDL_IMAGE
|
||
|
temp = IMG_Load(file);
|
||
|
#else
|
||
|
temp = SDL_LoadBMP(file);
|
||
|
#endif
|
||
|
if (temp == NULL)
|
||
|
fprintf(stderr, "Unable to load image %s: %s\n",
|
||
|
file, SDL_GetError());
|
||
|
return temp;
|
||
|
}
|
||
|
|
||
|
/* TODO: consistency checks, check for bpp, widht and height */
|
||
|
/* Init the mask image used to grab the action. */
|
||
|
static int gui_init(struct video_desc *env)
|
||
|
{
|
||
|
/* initialize keypad status */
|
||
|
env->gui.text_mode = 0;
|
||
|
env->gui.drag_mode = 0;
|
||
|
|
||
|
/* initialize grab coordinates */
|
||
|
env->out.loc_src.x = 0;
|
||
|
env->out.loc_src.y = 0;
|
||
|
|
||
|
/* initialize keyboard buffer */
|
||
|
append_char(env->gui.inbuf, &env->gui.inbuf_pos, '\0');
|
||
|
append_char(env->gui.msgbuf, &env->gui.msgbuf_pos, '\0');
|
||
|
|
||
|
#ifdef HAVE_SDL_TTF
|
||
|
/* Initialize SDL_ttf library and load font */
|
||
|
if (TTF_Init() == -1) {
|
||
|
ast_log(LOG_WARNING, "Unable to init SDL_ttf, no output available\n");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
#define GUI_FONTSIZE 28
|
||
|
env->gui.font = TTF_OpenFont( env->keypad_font, GUI_FONTSIZE);
|
||
|
if (!env->gui.font) {
|
||
|
ast_log(LOG_WARNING, "Unable to load font %s, no output available\n", env->keypad_font);
|
||
|
return -1;
|
||
|
}
|
||
|
ast_log(LOG_WARNING, "Loaded font %s\n", env->keypad_font);
|
||
|
#endif
|
||
|
|
||
|
env->gui.outfd = open ("/dev/null", O_WRONLY); /* discard output, temporary */
|
||
|
if ( env->gui.outfd < 0 ) {
|
||
|
ast_log(LOG_WARNING, "Unable output fd\n");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static void sdl_setup(struct video_desc *env);
|
||
|
|
||
|
/*
|
||
|
* Helper thread to periodically poll the video source and enqueue the
|
||
|
* generated frames to the channel's queue.
|
||
|
* Using a separate thread also helps because the encoding can be
|
||
|
* computationally expensive so we don't want to starve the main thread.
|
||
|
*/
|
||
|
static void *video_thread(void *arg)
|
||
|
{
|
||
|
struct video_desc *env = arg;
|
||
|
int count = 0;
|
||
|
|
||
|
env->screen = NULL;
|
||
|
bzero(env->win, sizeof(env->win));
|
||
|
|
||
|
if (SDL_Init(SDL_INIT_VIDEO)) {
|
||
|
ast_log(LOG_WARNING, "Could not initialize SDL - %s\n",
|
||
|
SDL_GetError());
|
||
|
/* again not fatal, just we won't display anything */
|
||
|
} else {
|
||
|
sdl_setup(env);
|
||
|
if (env->sdl_ok)
|
||
|
ast_mutex_init(&env->in.dec_in_lock);
|
||
|
/* TODO, segfault if not X display present */
|
||
|
env->gui_ok = !gui_init(env);
|
||
|
if (!env->gui_ok)
|
||
|
ast_log(LOG_WARNING, "cannot init console gui\n");
|
||
|
}
|
||
|
if (video_open(&env->out)) {
|
||
|
ast_log(LOG_WARNING, "cannot open local video source\n");
|
||
|
} else {
|
||
|
/* try to register the fd. Unfortunately, if the webcam
|
||
|
* driver does not support select/poll we are out of luck.
|
||
|
*/
|
||
|
if (env->out.fd >= 0)
|
||
|
ast_channel_set_fd(env->owner, 1, env->out.fd);
|
||
|
video_out_init(env);
|
||
|
}
|
||
|
|
||
|
for (;;) {
|
||
|
/* XXX 20 times/sec */
|
||
|
struct timeval t = { 0, 50000 };
|
||
|
struct ast_frame *p, *f;
|
||
|
struct video_in_desc *v = &env->in;
|
||
|
struct ast_channel *chan = env->owner;
|
||
|
int fd = chan->alertpipe[1];
|
||
|
|
||
|
/* determine if video format changed */
|
||
|
if (count++ % 10 == 0) {
|
||
|
char buf[160];
|
||
|
if (env->out.sendvideo)
|
||
|
sprintf(buf, "%s %s %dx%d @@ %dfps %dkbps",
|
||
|
env->out.videodevice, env->codec_name,
|
||
|
env->out.enc_in.w, env->out.enc_in.h,
|
||
|
env->out.fps, env->out.bitrate/1000);
|
||
|
else
|
||
|
sprintf(buf, "hold");
|
||
|
SDL_WM_SetCaption(buf, NULL);
|
||
|
}
|
||
|
|
||
|
/* manage keypad events */
|
||
|
/* XXX here we should always check for events,
|
||
|
* otherwise the drag will not work */
|
||
|
if (env->gui_ok)
|
||
|
eventhandler(env);
|
||
|
|
||
|
/* sleep for a while */
|
||
|
ast_select(0, NULL, NULL, NULL, &t);
|
||
|
|
||
|
SDL_UpdateRects(env->screen, 1, &env->win[WIN_KEYPAD].rect);// XXX inefficient
|
||
|
/*
|
||
|
* While there is something to display, call the decoder and free
|
||
|
* the buffer, possibly enabling the receiver to store new data.
|
||
|
*/
|
||
|
while (v->dec_in_dpy) {
|
||
|
struct fbuf_t *tmp = v->dec_in_dpy; /* store current pointer */
|
||
|
|
||
|
if (v->dec->dec_run(v, tmp))
|
||
|
show_frame(env, WIN_REMOTE);
|
||
|
tmp->used = 0; /* mark buffer as free */
|
||
|
tmp->ebit = 0;
|
||
|
ast_mutex_lock(&v->dec_in_lock);
|
||
|
if (++v->dec_in_dpy == &v->dec_in[N_DEC_IN]) /* advance to next, circular */
|
||
|
v->dec_in_dpy = &v->dec_in[0];
|
||
|
|
||
|
if (v->dec_in_cur == NULL) /* receiver was idle, enable it... */
|
||
|
v->dec_in_cur = tmp; /* using the slot just freed */
|
||
|
else if (v->dec_in_dpy == v->dec_in_cur) /* this was the last slot */
|
||
|
v->dec_in_dpy = NULL; /* nothing more to display */
|
||
|
ast_mutex_unlock(&v->dec_in_lock);
|
||
|
}
|
||
|
|
||
|
|
||
|
f = get_video_frames(env, &p); /* read and display */
|
||
|
if (!f)
|
||
|
continue;
|
||
|
if (env->shutdown)
|
||
|
break;
|
||
|
chan = env->owner;
|
||
|
ast_channel_lock(chan);
|
||
|
|
||
|
/* AST_LIST_INSERT_TAIL is only good for one frame, cannot use here */
|
||
|
if (chan->readq.first == NULL) {
|
||
|
chan->readq.first = f;
|
||
|
} else {
|
||
|
chan->readq.last->frame_list.next = f;
|
||
|
}
|
||
|
chan->readq.last = p;
|
||
|
/*
|
||
|
* more or less same as ast_queue_frame, but extra
|
||
|
* write on the alertpipe to signal frames.
|
||
|
*/
|
||
|
if (fd > -1) {
|
||
|
int blah = 1, l = sizeof(blah);
|
||
|
for (p = f; p; p = AST_LIST_NEXT(p, frame_list)) {
|
||
|
if (write(fd, &blah, l) != l)
|
||
|
ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d: %s!\n",
|
||
|
chan->name, f->frametype, f->subclass, strerror(errno));
|
||
|
}
|
||
|
}
|
||
|
ast_channel_unlock(chan);
|
||
|
}
|
||
|
/* thread terminating, here could call the uninit */
|
||
|
/* uninitialize the local and remote video environments */
|
||
|
video_in_uninit(&env->in);
|
||
|
video_out_uninit(&env->out);
|
||
|
|
||
|
if (env->sdl_ok)
|
||
|
cleanup_sdl(env);
|
||
|
|
||
|
env->shutdown = 0;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
static void copy_geometry(struct fbuf_t *src, struct fbuf_t *dst)
|
||
|
{
|
||
|
if (dst->w == 0)
|
||
|
dst->w = src->w;
|
||
|
if (dst->h == 0)
|
||
|
dst->h = src->h;
|
||
|
}
|
||
|
|
||
|
/*! initialize the video environment.
|
||
|
* Apart from the formats (constant) used by sdl and the codec,
|
||
|
* we use enc_in as the basic geometry.
|
||
|
*/
|
||
|
static void init_env(struct video_desc *env)
|
||
|
{
|
||
|
struct fbuf_t *c = &(env->out.loc_src); /* local source */
|
||
|
struct fbuf_t *ei = &(env->out.enc_in); /* encoder input */
|
||
|
struct fbuf_t *ld = &(env->out.loc_dpy); /* local display */
|
||
|
struct fbuf_t *rd = &(env->in.rem_dpy); /* remote display */
|
||
|
|
||
|
c->pix_fmt = PIX_FMT_YUV420P; /* default - camera format */
|
||
|
ei->pix_fmt = PIX_FMT_YUV420P; /* encoder input */
|
||
|
if (ei->w == 0 || ei->h == 0) {
|
||
|
ei->w = 352;
|
||
|
ei->h = 288;
|
||
|
}
|
||
|
ld->pix_fmt = rd->pix_fmt = PIX_FMT_YUV420P; /* sdl format */
|
||
|
/* inherit defaults */
|
||
|
copy_geometry(ei, c); /* camera inherits from encoder input */
|
||
|
copy_geometry(ei, rd); /* remote display inherits from encoder input */
|
||
|
copy_geometry(rd, ld); /* local display inherits from remote display */
|
||
|
}
|
||
|
|
||
|
/* setup an sdl overlay and associated info, return 0 on success, != 0 on error */
|
||
|
static int set_win(SDL_Surface *screen, struct display_window *win, int fmt,
|
||
|
int w, int h, int x, int y)
|
||
|
{
|
||
|
win->bmp = SDL_CreateYUVOverlay(w, h, fmt, screen);
|
||
|
if (win->bmp == NULL)
|
||
|
return -1; /* error */
|
||
|
win->rect.x = x;
|
||
|
win->rect.y = y;
|
||
|
win->rect.w = w;
|
||
|
win->rect.h = h;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
* The first call to the video code, called by oss_new() or similar.
|
||
|
* Here we initialize the various components we use, namely SDL for display,
|
||
|
* ffmpeg for encoding/decoding, and a local video source.
|
||
|
* We do our best to progress even if some of the components are not
|
||
|
* available.
|
||
|
*/
|
||
|
static void console_video_start(struct video_desc *env,
|
||
|
struct ast_channel *owner)
|
||
|
{
|
||
|
if (env == NULL) /* video not initialized */
|
||
|
return;
|
||
|
if (owner == NULL) /* nothing to do if we don't have a channel */
|
||
|
return;
|
||
|
env->owner = owner;
|
||
|
init_env(env);
|
||
|
env->out.enc = map_config_video_format(env->codec_name);
|
||
|
|
||
|
ast_log(LOG_WARNING, "start video out %s %dx%d\n",
|
||
|
env->codec_name, env->out.enc_in.w, env->out.enc_in.h);
|
||
|
/*
|
||
|
* Register all codecs supported by the ffmpeg library.
|
||
|
* We only need to do it once, but probably doesn't
|
||
|
* harm to do it multiple times.
|
||
|
*/
|
||
|
avcodec_init();
|
||
|
avcodec_register_all();
|
||
|
av_log_set_level(AV_LOG_ERROR); /* only report errors */
|
||
|
|
||
|
if (env->out.fps == 0) {
|
||
|
env->out.fps = 15;
|
||
|
ast_log(LOG_WARNING, "fps unset, forcing to %d\n", env->out.fps);
|
||
|
}
|
||
|
if (env->out.bitrate == 0) {
|
||
|
env->out.bitrate = 65000;
|
||
|
ast_log(LOG_WARNING, "bitrate unset, forcing to %d\n", env->out.bitrate);
|
||
|
}
|
||
|
|
||
|
ast_pthread_create_background(&env->vthread, NULL, video_thread, env);
|
||
|
}
|
||
|
|
||
|
static int keypad_cfg_read(struct gui_info *gui, const char *val);
|
||
|
/* [re]set the main sdl window, useful in case of resize */
|
||
|
static void sdl_setup(struct video_desc *env)
|
||
|
{
|
||
|
int dpy_fmt = SDL_IYUV_OVERLAY; /* YV12 causes flicker in SDL */
|
||
|
int maxw, maxh;
|
||
|
|
||
|
/*
|
||
|
* 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:
|
||
|
* - on the left, the remote video;
|
||
|
* - on the center, the keypad
|
||
|
* - on the right, the local video
|
||
|
*/
|
||
|
|
||
|
/* Fetch the keypad now, we need it to know its size */
|
||
|
if (!env->gui.keypad)
|
||
|
env->gui.keypad = get_keypad(env->keypad_file);
|
||
|
if (env->gui.keypad) {
|
||
|
int fd = -1;
|
||
|
void *p = NULL;
|
||
|
off_t l = 0;
|
||
|
|
||
|
env->out.keypad_dpy.w = env->gui.keypad->w;
|
||
|
env->out.keypad_dpy.h = env->gui.keypad->h;
|
||
|
/*
|
||
|
* If the keypad image has a comment field, try to read
|
||
|
* the button location from there. The block must be
|
||
|
* keypad_entry = token shape x0 y0 x1 y1 h
|
||
|
* ...
|
||
|
* (basically, lines have the same format as config file entries.
|
||
|
* same as the keypad_entry.
|
||
|
* You can add it to a jpeg file using wrjpgcom
|
||
|
*/
|
||
|
do { /* only once, in fact */
|
||
|
const unsigned char *s, *e;
|
||
|
|
||
|
fd = open(env->keypad_file, O_RDONLY);
|
||
|
if (fd < 0) {
|
||
|
ast_log(LOG_WARNING, "fail to open %s\n", env->keypad_file);
|
||
|
break;
|
||
|
}
|
||
|
l = lseek(fd, 0, SEEK_END);
|
||
|
if (l <= 0) {
|
||
|
ast_log(LOG_WARNING, "fail to lseek %s\n", env->keypad_file);
|
||
|
break;
|
||
|
}
|
||
|
p = mmap(NULL, l, PROT_READ, 0, fd, 0);
|
||
|
if (p == NULL) {
|
||
|
ast_log(LOG_WARNING, "fail to mmap %s size %ld\n", env->keypad_file, (long)l);
|
||
|
break;
|
||
|
}
|
||
|
e = (const unsigned char *)p + l;
|
||
|
for (s = p; s < e - 20 ; s++) {
|
||
|
if (!memcmp(s, "keypad_entry", 12)) { /* keyword found */
|
||
|
ast_log(LOG_WARNING, "found entry\n");
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
for ( ;s < e - 20; s++) {
|
||
|
char buf[256];
|
||
|
const unsigned char *s1;
|
||
|
if (index(" \t\r\n", *s)) /* ignore blanks */
|
||
|
continue;
|
||
|
if (*s > 127) /* likely end of comment */
|
||
|
break;
|
||
|
if (memcmp(s, "keypad_entry", 12)) /* keyword not found */
|
||
|
break;
|
||
|
s += 12;
|
||
|
l = MIN(sizeof(buf), e - s);
|
||
|
ast_copy_string(buf, s, l);
|
||
|
s1 = ast_skip_blanks(buf); /* between token and '=' */
|
||
|
if (*s1++ != '=') /* missing separator */
|
||
|
break;
|
||
|
if (*s1 == '>') /* skip => */
|
||
|
s1++;
|
||
|
keypad_cfg_read(&env->gui, ast_skip_blanks(s1));
|
||
|
/* now wait for a newline */
|
||
|
s1 = s;
|
||
|
while (s1 < e - 20 && !index("\r\n", *s1) && *s1 < 128)
|
||
|
s1++;
|
||
|
s = s1;
|
||
|
}
|
||
|
} while (0);
|
||
|
if (p)
|
||
|
munmap(p, l);
|
||
|
if (fd >= 0)
|
||
|
close(fd);
|
||
|
}
|
||
|
#define BORDER 5 /* border around our windows */
|
||
|
maxw = env->in.rem_dpy.w + env->out.loc_dpy.w + env->out.keypad_dpy.w;
|
||
|
maxh = MAX( MAX(env->in.rem_dpy.h, env->out.loc_dpy.h), env->out.keypad_dpy.h);
|
||
|
maxw += 4 * BORDER;
|
||
|
maxh += 2 * BORDER;
|
||
|
env->screen = SDL_SetVideoMode(maxw, maxh, 0, 0);
|
||
|
if (!env->screen) {
|
||
|
ast_log(LOG_ERROR, "SDL: could not set video mode - exiting\n");
|
||
|
goto no_sdl;
|
||
|
}
|
||
|
|
||
|
SDL_WM_SetCaption("Asterisk console Video Output", NULL);
|
||
|
if (set_win(env->screen, &env->win[WIN_REMOTE], dpy_fmt,
|
||
|
env->in.rem_dpy.w, env->in.rem_dpy.h, BORDER, BORDER))
|
||
|
goto no_sdl;
|
||
|
if (set_win(env->screen, &env->win[WIN_LOCAL], dpy_fmt,
|
||
|
env->out.loc_dpy.w, env->out.loc_dpy.h,
|
||
|
3*BORDER+env->in.rem_dpy.w + env->out.keypad_dpy.w, BORDER))
|
||
|
goto no_sdl;
|
||
|
|
||
|
/* display the skin, but do not free it as we need it later to
|
||
|
* restore text areas and maybe sliders too.
|
||
|
*/
|
||
|
if (env->gui.keypad) {
|
||
|
struct SDL_Rect *dest = &env->win[WIN_KEYPAD].rect;
|
||
|
dest->x = 2*BORDER + env->in.rem_dpy.w;
|
||
|
dest->y = BORDER;
|
||
|
dest->w = env->gui.keypad->w;
|
||
|
dest->h = env->gui.keypad->h;
|
||
|
SDL_BlitSurface(env->gui.keypad, NULL, env->screen, dest);
|
||
|
SDL_UpdateRects(env->screen, 1, dest);
|
||
|
}
|
||
|
env->in.dec_in_cur = &env->in.dec_in[0];
|
||
|
env->in.dec_in_dpy = NULL; /* nothing to display */
|
||
|
env->sdl_ok = 1;
|
||
|
|
||
|
no_sdl:
|
||
|
if (env->sdl_ok == 0) /* free resources in case of errors */
|
||
|
cleanup_sdl(env);
|
||
|
}
|
||
|
|
||
|
/* see chan_oss.c for these macros */
|
||
|
#ifndef M_START
|
||
|
#define _UNDO_M_START
|
||
|
#define M_START(var, val) \
|
||
|
const char *__s = var; const char *__val = val;
|
||
|
#define M_END(x) x;
|
||
|
#define M_F(tag, f) if (!strcasecmp((__s), tag)) { f; } else
|
||
|
#define M_BOOL(tag, dst) M_F(tag, (dst) = ast_true(__val) )
|
||
|
#define M_UINT(tag, dst) M_F(tag, (dst) = strtoul(__val, NULL, 0) )
|
||
|
#define M_STR(tag, dst) M_F(tag, ast_copy_string(dst, __val, sizeof(dst)))
|
||
|
#endif
|
||
|
|
||
|
/*
|
||
|
* Parse a geometry string, accepting also common names for the formats.
|
||
|
* Trick: if we have a leading > or < and a numeric geometry,
|
||
|
* return the larger or smaller one.
|
||
|
* E.g. <352x288 gives the smaller one, 320x240
|
||
|
*/
|
||
|
static int video_geom(struct fbuf_t *b, const char *s)
|
||
|
{
|
||
|
int w = 0, h = 0;
|
||
|
|
||
|
static struct {
|
||
|
const char *s; int w; int h;
|
||
|
} *fp, formats[] = {
|
||
|
{"vga", 640, 480 },
|
||
|
{"cif", 352, 288 },
|
||
|
{"qvga", 320, 240 },
|
||
|
{"qcif", 176, 144 },
|
||
|
{"sqcif", 128, 96 },
|
||
|
{NULL, 0, 0 },
|
||
|
};
|
||
|
if (*s == '<' || *s == '>')
|
||
|
sscanf(s+1,"%dx%d", &w, &h);
|
||
|
for (fp = formats; fp->s; fp++) {
|
||
|
if (*s == '>') { /* look for a larger one */
|
||
|
if (fp->w <= w) {
|
||
|
if (fp > formats)
|
||
|
fp--; /* back one step if possible */
|
||
|
break;
|
||
|
}
|
||
|
} else if (*s == '<') { /* look for a smaller one */
|
||
|
if (fp->w < w)
|
||
|
break;
|
||
|
} else if (!strcasecmp(s, fp->s)) { /* look for a string */
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (*s == '<' && fp->s == NULL) /* smallest */
|
||
|
fp--;
|
||
|
if (fp->s) {
|
||
|
b->w = fp->w;
|
||
|
b->h = fp->h;
|
||
|
} else if (sscanf(s, "%dx%d", &b->w, &b->h) != 2) {
|
||
|
ast_log(LOG_WARNING, "Invalid video_size %s, using 352x288\n", s);
|
||
|
b->w = 352;
|
||
|
b->h = 288;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Functions to determine if a point is within a region. Return 1 if success.
|
||
|
* First rotate the point, with
|
||
|
* x' = (x - x0) * cos A + (y - y0) * sin A
|
||
|
* y' = -(x - x0) * sin A + (y - y0) * cos A
|
||
|
* where cos A = (x1-x0)/l, sin A = (y1 - y0)/l, and
|
||
|
* l = sqrt( (x1-x0)^2 + (y1-y0)^2
|
||
|
* Then determine inclusion by simple comparisons i.e.:
|
||
|
* rectangle: x >= 0 && x < l && y >= 0 && y < h
|
||
|
* ellipse: (x-xc)^2/l^2 + (y-yc)^2/h2 < 1
|
||
|
*/
|
||
|
static int kp_match_area(const struct keypad_entry *e, int x, int y)
|
||
|
{
|
||
|
double xp, dx = (e->x1 - e->x0);
|
||
|
double yp, dy = (e->y1 - e->y0);
|
||
|
double l = sqrt(dx*dx + dy*dy);
|
||
|
int ret = 0;
|
||
|
|
||
|
if (l > 1) { /* large enough */
|
||
|
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);
|
||
|
} else if (e->type == KP_CIRCLE) {
|
||
|
dx = xp*xp/(l*l) + yp*yp/(e->h*e->h);
|
||
|
ret = (dx < 1);
|
||
|
}
|
||
|
}
|
||
|
#if 0
|
||
|
ast_log(LOG_WARNING, "result %d [%d] for match %d,%d in type %d p0 %d,%d p1 %d,%d h %d\n",
|
||
|
ret, e->c, x, y, e->type, e->x0, e->y0, e->x1, e->y1, e->h);
|
||
|
#endif
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* read a keypad entry line in the format
|
||
|
* reset
|
||
|
* token circle xc yc diameter
|
||
|
* token circle xc yc x1 y1 h # ellipse, main diameter and height
|
||
|
* token rect x0 y0 x1 y1 h # rectangle with main side and eight
|
||
|
* token is the token to be returned, either a character or a symbol
|
||
|
* as KEY_* above
|
||
|
*/
|
||
|
struct _s_k { const char *s; int k; };
|
||
|
static struct _s_k gui_key_map[] = {
|
||
|
{"PICK_UP", KEY_PICK_UP },
|
||
|
{"PICKUP", KEY_PICK_UP },
|
||
|
{"HANG_UP", KEY_HANG_UP },
|
||
|
{"HANGUP", KEY_HANG_UP },
|
||
|
{"MUTE", KEY_MUTE },
|
||
|
{"AUTOANSWER", KEY_AUTOANSWER },
|
||
|
{"SENDVIDEO", KEY_SENDVIDEO },
|
||
|
{"LOCALVIDEO", KEY_LOCALVIDEO },
|
||
|
{"REMOTEVIDEO", KEY_REMOTEVIDEO },
|
||
|
{"WRITEMESSAGE", KEY_WRITEMESSAGE },
|
||
|
{"GUI_CLOSE", KEY_GUI_CLOSE },
|
||
|
{NULL, 0 } };
|
||
|
|
||
|
static int keypad_cfg_read(struct gui_info *gui, const char *val)
|
||
|
{
|
||
|
struct keypad_entry e;
|
||
|
char s1[16], s2[16];
|
||
|
int i, ret = 0;
|
||
|
|
||
|
bzero(&e, sizeof(e));
|
||
|
i = sscanf(val, "%14s %14s %d %d %d %d %d",
|
||
|
s1, s2, &e.x0, &e.y0, &e.x1, &e.y1, &e.h);
|
||
|
|
||
|
switch (i) {
|
||
|
default:
|
||
|
break;
|
||
|
case 1: /* only "reset" is allowed */
|
||
|
if (strcasecmp(s1, "reset")) /* invalid */
|
||
|
break;
|
||
|
if (gui->kp) {
|
||
|
gui->kp_used = 0;
|
||
|
}
|
||
|
ret = 1;
|
||
|
break;
|
||
|
case 5: /* token circle xc yc diameter */
|
||
|
if (strcasecmp(s2, "circle")) /* invalid */
|
||
|
break;
|
||
|
e.h = e.x1;
|
||
|
e.y1 = e.y0; /* map radius in x1 y1 */
|
||
|
e.x1 = e.x0 + e.h; /* map radius in x1 y1 */
|
||
|
e.x0 = e.x0 - e.h; /* map radius in x1 y1 */
|
||
|
/* fallthrough */
|
||
|
|
||
|
case 7: /* token circle|rect x0 y0 x1 y1 h */
|
||
|
if (e.x1 < e.x0 || e.h <= 0) {
|
||
|
ast_log(LOG_WARNING, "error in coordinates\n");
|
||
|
e.type = 0;
|
||
|
break;
|
||
|
}
|
||
|
if (!strcasecmp(s2, "circle")) {
|
||
|
/* for a circle we specify the diameter but store center and radii */
|
||
|
e.type = KP_CIRCLE;
|
||
|
e.x0 = (e.x1 + e.x0) / 2;
|
||
|
e.y0 = (e.y1 + e.y0) / 2;
|
||
|
e.h = e.h / 2;
|
||
|
} else if (!strcasecmp(s2, "rect")) {
|
||
|
e.type = KP_RECT;
|
||
|
} else
|
||
|
break;
|
||
|
ret = 1;
|
||
|
}
|
||
|
// ast_log(LOG_WARNING, "reading [%s] returns %d %d\n", val, i, ret);
|
||
|
if (ret == 0)
|
||
|
return 0;
|
||
|
/* map the string into token to be returned */
|
||
|
i = atoi(s1);
|
||
|
if (i > 0 || s1[1] == '\0') /* numbers or single characters */
|
||
|
e.c = (i > 9) ? i : s1[0];
|
||
|
else {
|
||
|
struct _s_k *p;
|
||
|
for (p = gui_key_map; p->s; p++) {
|
||
|
if (!strcasecmp(p->s, s1)) {
|
||
|
e.c = p->k;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (e.c == 0) {
|
||
|
ast_log(LOG_WARNING, "missing token\n");
|
||
|
return 0;
|
||
|
}
|
||
|
if (gui->kp_size == 0) {
|
||
|
gui->kp = ast_calloc(10, sizeof(e));
|
||
|
if (gui->kp == NULL) {
|
||
|
ast_log(LOG_WARNING, "cannot allocate kp");
|
||
|
return 0;
|
||
|
}
|
||
|
gui->kp_size = 10;
|
||
|
}
|
||
|
if (gui->kp_size == gui->kp_used) { /* must allocate */
|
||
|
struct keypad_entry *a = ast_realloc(gui->kp, sizeof(e)*(gui->kp_size+10));
|
||
|
if (a == NULL) {
|
||
|
ast_log(LOG_WARNING, "cannot reallocate kp");
|
||
|
return 0;
|
||
|
}
|
||
|
gui->kp = a;
|
||
|
gui->kp_size += 10;
|
||
|
}
|
||
|
if (gui->kp_size == gui->kp_used)
|
||
|
return 0;
|
||
|
ast_log(LOG_WARNING, "allocated entry %d\n", gui->kp_used);
|
||
|
gui->kp[gui->kp_used++] = e;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
/* list of commands supported by the cli.
|
||
|
* For write operation we use the commands in console_video_config(),
|
||
|
* for reads we use console_video_cli(). XXX Names should be fixed.
|
||
|
*/
|
||
|
#define CONSOLE_VIDEO_CMDS \
|
||
|
"console {videodevice|videocodec|sendvideo" \
|
||
|
"|video_size|bitrate|fps|qmin" \
|
||
|
"|keypad|keypad_mask|keypad_entry" \
|
||
|
"}"
|
||
|
|
||
|
/* extend ast_cli with video commands. Called by console_video_config */
|
||
|
static int console_video_cli(struct video_desc *env, const char *var, int fd)
|
||
|
{
|
||
|
if (env == NULL)
|
||
|
return 0; /* unrecognised */
|
||
|
|
||
|
if (!strcasecmp(var, "videodevice")) {
|
||
|
ast_cli(fd, "videodevice is [%s]\n", env->out.videodevice);
|
||
|
} else if (!strcasecmp(var, "videocodec")) {
|
||
|
ast_cli(fd, "videocodec is [%s]\n", env->codec_name);
|
||
|
} else if (!strcasecmp(var, "sendvideo")) {
|
||
|
ast_cli(fd, "sendvideo is [%s]\n", env->out.sendvideo ? "on" : "off");
|
||
|
} else if (!strcasecmp(var, "video_size")) {
|
||
|
ast_cli(fd, "sizes: video %dx%d camera %dx%d local %dx%d remote %dx%d in %dx%d\n",
|
||
|
env->out.enc_in.w, env->out.enc_in.h,
|
||
|
env->out.loc_src.w, env->out.loc_src.h,
|
||
|
env->out.loc_dpy.w, env->out.loc_src.h,
|
||
|
env->in.rem_dpy.w, env->in.rem_dpy.h,
|
||
|
env->in.dec_out.w, env->in.dec_out.h);
|
||
|
} else if (!strcasecmp(var, "bitrate")) {
|
||
|
ast_cli(fd, "bitrate is [%d]\n", env->out.bitrate);
|
||
|
} else if (!strcasecmp(var, "qmin")) {
|
||
|
ast_cli(fd, "qmin is [%d]\n", env->out.qmin);
|
||
|
} else if (!strcasecmp(var, "fps")) {
|
||
|
ast_cli(fd, "fps is [%d]\n", env->out.fps);
|
||
|
} else {
|
||
|
return 0; /* unrecognised */
|
||
|
}
|
||
|
return 1; /* recognised */
|
||
|
}
|
||
|
|
||
|
/*! parse config command for video support. */
|
||
|
static int console_video_config(struct video_desc **penv,
|
||
|
const char *var, const char *val)
|
||
|
{
|
||
|
struct video_desc *env;
|
||
|
M_START(var, val);
|
||
|
|
||
|
if (penv == NULL) {
|
||
|
ast_log(LOG_WARNING, "bad argument penv=NULL\n");
|
||
|
return 1; /* error */
|
||
|
}
|
||
|
/* allocate the video descriptor first time we get here */
|
||
|
env = *penv;
|
||
|
if (env == NULL) {
|
||
|
env = *penv = ast_calloc(1, sizeof(struct video_desc));
|
||
|
if (env == NULL) {
|
||
|
ast_log(LOG_WARNING, "fail to allocate video_desc\n");
|
||
|
return 1; /* error */
|
||
|
|
||
|
}
|
||
|
/* set default values */
|
||
|
ast_copy_string(env->out.videodevice, "X11", sizeof(env->out.videodevice));
|
||
|
env->out.fps = 5;
|
||
|
env->out.bitrate = 65000;
|
||
|
env->out.sendvideo = 1;
|
||
|
env->out.qmin = 3;
|
||
|
}
|
||
|
M_STR("videodevice", env->out.videodevice)
|
||
|
M_BOOL("sendvideo", env->out.sendvideo)
|
||
|
M_F("video_size", video_geom(&env->out.enc_in, val))
|
||
|
M_F("camera_size", video_geom(&env->out.loc_src, val))
|
||
|
M_F("local_size", video_geom(&env->out.loc_dpy, val))
|
||
|
M_F("remote_size", video_geom(&env->in.rem_dpy, val))
|
||
|
M_STR("keypad", env->keypad_file)
|
||
|
M_F("keypad_entry", keypad_cfg_read(&env->gui, val))
|
||
|
M_STR("keypad_mask", env->keypad_mask)
|
||
|
M_STR("keypad_font", env->keypad_font)
|
||
|
M_UINT("fps", env->out.fps)
|
||
|
M_UINT("bitrate", env->out.bitrate)
|
||
|
M_UINT("qmin", env->out.qmin)
|
||
|
M_STR("videocodec", env->codec_name)
|
||
|
M_END(return 1;) /* the 'nothing found' case */
|
||
|
return 0; /* found something */
|
||
|
}
|
||
|
#ifdef _UNDO_M_START
|
||
|
#undef M_START
|
||
|
#undef M_END
|
||
|
#undef M_F
|
||
|
#undef M_BOOL
|
||
|
#undef M_UINT
|
||
|
#undef M_STR
|
||
|
#undef _UNDO_M_START
|
||
|
#endif
|
||
|
|
||
|
#endif /* video support */
|