Merged revisions 136062 via svnmerge from
[asterisk/asterisk.git] / channels / vcodecs.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright 2007-2008, Sergio Fadda, Luigi Rizzo
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*
18  * Video codecs support for console_video.c
19  * $Revision$
20  */
21
22 #include "asterisk.h"
23 #include "console_video.h"
24 #include "asterisk/frame.h"
25 #include "asterisk/utils.h"     /* ast_calloc() */
26
27 struct video_out_desc;
28 struct video_dec_desc;
29 struct fbuf_t;
30
31 /*
32  * Each codec is defined by a number of callbacks
33  */
34 /*! \brief initialize the encoder */
35 typedef int (*encoder_init_f)(AVCodecContext *v);
36
37 /*! \brief actually call the encoder */
38 typedef int (*encoder_encode_f)(struct video_out_desc *v);
39
40 /*! \brief encapsulate the bistream in RTP frames */
41 typedef struct ast_frame *(*encoder_encap_f)(struct fbuf_t *, int mtu,
42                 struct ast_frame **tail);
43
44 /*! \brief inizialize the decoder */
45 typedef int (*decoder_init_f)(AVCodecContext *enc_ctx);
46
47 /*! \brief extract the bitstream from RTP frames and store in the fbuf.
48  * return 0 if ok, 1 on error
49  */
50 typedef int (*decoder_decap_f)(struct fbuf_t *b, uint8_t *data, int len);
51
52 /*! \brief actually call the decoder */
53 typedef int (*decoder_decode_f)(struct video_dec_desc *v, struct fbuf_t *b);
54
55 struct video_codec_desc {
56         const char              *name;          /* format name */
57         int                     format;         /* AST_FORMAT_* */
58         encoder_init_f          enc_init;
59         encoder_encap_f         enc_encap;
60         encoder_encode_f        enc_run;
61         decoder_init_f          dec_init;
62         decoder_decap_f         dec_decap;
63         decoder_decode_f        dec_run;
64 };
65
66 /*
67  * Descriptor for the incoming stream, with multiple buffers for the bitstream
68  * extracted from the RTP packets, RTP reassembly info, and a frame buffer
69  * for the decoded frame (buf).
70  * The descriptor is allocated as the first frame comes in.
71  *
72  * Incoming payload is stored in one of the dec_in[] buffers, which are
73  * emptied by the video thread. These buffers are organized in a circular
74  * queue, with dec_in_cur being the buffer in use by the incoming stream,
75  * and dec_in_dpy is the one being displayed. When the pointers need to
76  * be changed, we synchronize the access to them with dec_lock.
77  * When the list is full dec_in_cur = NULL (we cannot store new data),
78  * when the list is empty dec_in_dpy = NULL (we cannot display frames).
79  */
80 struct video_dec_desc {
81         struct video_codec_desc *d_callbacks;   /* decoder callbacks */
82         AVCodecContext          *dec_ctx;       /* information about the codec in the stream */
83         AVCodec                 *codec;         /* reference to the codec */
84         AVFrame                 *d_frame;       /* place to store the decoded frame */
85         AVCodecParserContext    *parser;
86         uint16_t                next_seq;       /* must be 16 bit */
87         int                     discard;        /* flag for discard status */
88 #define N_DEC_IN        3       /* number of incoming buffers */
89         struct fbuf_t           *dec_in_cur;    /* buffer being filled in */
90         struct fbuf_t           *dec_in_dpy;    /* buffer to display */
91         struct fbuf_t dec_in[N_DEC_IN]; /* incoming bitstream, allocated/extended in fbuf_append() */
92         struct fbuf_t dec_out;  /* decoded frame, no buffer (data is in AVFrame) */
93 };
94
95 #ifdef debugging_only
96
97 /* some debugging code to check the bitstream:
98  * declare a bit buffer, initialize it, and fetch data from it.
99  */
100 struct bitbuf {
101         const uint8_t *base;
102         int     bitsize;        /* total size in bits */
103         int     ofs;    /* next bit to read */
104 };
105
106 static struct bitbuf bitbuf_init(const uint8_t *base, int bitsize, int start_ofs)
107 {
108         struct bitbuf a;
109         a.base = base;
110         a.bitsize = bitsize;
111         a.ofs = start_ofs;
112         return a;
113 }
114
115 static int bitbuf_left(struct bitbuf *b)
116 {
117         return b->bitsize - b->ofs;
118 }
119
120 static uint32_t getbits(struct bitbuf *b, int n)
121 {
122         int i, ofs;
123         const uint8_t *d;
124         uint8_t mask;
125         uint32_t retval = 0;
126         if (n> 31) {
127                 ast_log(LOG_WARNING, "too many bits %d, max 32\n", n);
128                 return 0;
129         }
130         if (n + b->ofs > b->bitsize) {
131                 ast_log(LOG_WARNING, "bitbuf overflow %d of %d\n", n + b->ofs, b->bitsize);
132                 n = b->bitsize - b->ofs;
133         }
134         ofs = 7 - b->ofs % 8;   /* start from msb */
135         mask = 1 << ofs;
136         d = b->base + b->ofs / 8;       /* current byte */
137         for (i=0 ; i < n; i++) {
138                 retval += retval + (*d & mask ? 1 : 0); /* shift in new byte */
139                 b->ofs++;
140                 mask >>= 1;
141                 if (mask == 0) {
142                         d++;
143                         mask = 0x80;
144                 }
145         }
146         return retval;
147 }
148
149 static void check_h261(struct fbuf_t *b)
150 {
151         struct bitbuf a = bitbuf_init(b->data, b->used * 8, 0);
152         uint32_t x, y;
153         
154         x = getbits(&a, 20);    /* PSC, 0000 0000 0000 0001 0000 */
155         if (x != 0x10) {
156                 ast_log(LOG_WARNING, "bad PSC 0x%x\n", x);
157                 return;
158         }
159         x = getbits(&a, 5);     /* temporal reference */
160         y = getbits(&a, 6);     /* ptype */
161         if (0)
162         ast_log(LOG_WARNING, "size %d TR %d PTY spl %d doc %d freeze %d %sCIF hi %d\n",
163                 b->used,
164                 x,
165                 (y & 0x20) ? 1 : 0,
166                 (y & 0x10) ? 1 : 0,
167                 (y & 0x8) ? 1 : 0,
168                 (y & 0x4) ? "" : "Q",
169                 (y & 0x2) ? 1:0);
170         while ( (x = getbits(&a, 1)) == 1)
171                 ast_log(LOG_WARNING, "PSPARE 0x%x\n", getbits(&a, 8));
172         // ast_log(LOG_WARNING, "PSPARE 0 - start GOB LAYER\n");
173         while ( (x = bitbuf_left(&a)) > 0) {
174                 // ast_log(LOG_WARNING, "GBSC %d bits left\n", x);
175                 x = getbits(&a, 16); /* GBSC 0000 0000 0000 0001 */
176                 if (x != 0x1) {
177                         ast_log(LOG_WARNING, "bad GBSC 0x%x\n", x);
178                         break;
179                 }
180                 x = getbits(&a, 4);     /* group number */
181                 y = getbits(&a, 5);     /* gquant */
182                 if (x == 0) {
183                         ast_log(LOG_WARNING, "  bad GN %d\n", x);
184                         break;
185                 }
186                 while ( (x = getbits(&a, 1)) == 1)
187                         ast_log(LOG_WARNING, "GSPARE 0x%x\n", getbits(&a, 8));
188                 while ( (x = bitbuf_left(&a)) > 0) { /* MB layer */
189                         break;
190                 }
191         }
192 }
193
194 void dump_buf(struct fbuf_t *b);
195 void dump_buf(struct fbuf_t *b)
196 {
197         int i, x, last2lines;
198         char buf[80];
199
200         last2lines = (b->used - 16) & ~0xf;
201         ast_log(LOG_WARNING, "buf size %d of %d\n", b->used, b->size);
202         for (i = 0; i < b->used; i++) {
203                 x = i & 0xf;
204                 if ( x == 0) {  /* new line */
205                         if (i != 0)
206                                 ast_log(LOG_WARNING, "%s\n", buf);
207                         bzero(buf, sizeof(buf));
208                         sprintf(buf, "%04x: ", i);
209                 }
210                 sprintf(buf + 6 + x*3, "%02x ", b->data[i]);
211                 if (i > 31 && i < last2lines)
212                         i = last2lines - 1;
213         }
214         if (buf[0])
215                 ast_log(LOG_WARNING, "%s\n", buf);
216 }
217 #endif /* debugging_only */
218
219 /*!
220  * Build an ast_frame for a given chunk of data, and link it into
221  * the queue, with possibly 'head' bytes at the beginning to
222  * fill in some fields later.
223  */
224 static struct ast_frame *create_video_frame(uint8_t *start, uint8_t *end,
225                        int format, int head, struct ast_frame *prev)
226 {
227         int len = end-start;
228         uint8_t *data;
229         struct ast_frame *f;
230
231         data = ast_calloc(1, len+head);
232         f = ast_calloc(1, sizeof(*f));
233         if (f == NULL || data == NULL) {
234                 ast_log(LOG_WARNING, "--- frame error f %p data %p len %d format %d\n",
235                                 f, data, len, format);
236                 if (f)
237                         ast_free(f);
238                 if (data)
239                         ast_free(data);
240                 return NULL;
241         }
242         memcpy(data+head, start, len);
243         f->data.ptr = data;
244         f->mallocd = AST_MALLOCD_DATA | AST_MALLOCD_HDR;
245         //f->has_timing_info = 1;
246         //f->ts = ast_tvdiff_ms(ast_tvnow(), out->ts);
247         f->datalen = len+head;
248         f->frametype = AST_FRAME_VIDEO;
249         f->subclass = format;
250         f->samples = 0;
251         f->offset = 0;
252         f->src = "Console";
253         f->delivery.tv_sec = 0;
254         f->delivery.tv_usec = 0;
255         f->seqno = 0;
256         AST_LIST_NEXT(f, frame_list) = NULL;
257
258         if (prev)
259                 AST_LIST_NEXT(prev, frame_list) = f;
260
261         return f;
262 }
263
264
265 /*
266  * Append a chunk of data to a buffer taking care of bit alignment
267  * Return 0 on success, != 0 on failure
268  */
269 static int fbuf_append(struct fbuf_t *b, uint8_t *src, int len,
270         int sbit, int ebit)
271 {
272         /*
273          * Allocate buffer. ffmpeg wants an extra FF_INPUT_BUFFER_PADDING_SIZE,
274          * and also wants 0 as a buffer terminator to prevent trouble.
275          */
276         int need = len + FF_INPUT_BUFFER_PADDING_SIZE;
277         int i;
278         uint8_t *dst, mask;
279
280         if (b->data == NULL) {
281                 b->size = need;
282                 b->used = 0;
283                 b->ebit = 0;
284                 b->data = ast_calloc(1, b->size);
285         } else if (b->used + need > b->size) {
286                 b->size = b->used + need;
287                 b->data = ast_realloc(b->data, b->size);
288         }
289         if (b->data == NULL) {
290                 ast_log(LOG_WARNING, "alloc failure for %d, discard\n",
291                         b->size);
292                 return 1;
293         }
294         if (b->used == 0 && b->ebit != 0) {
295                 ast_log(LOG_WARNING, "ebit not reset at start\n");
296                 b->ebit = 0;
297         }
298         dst = b->data + b->used;
299         i = b->ebit + sbit;     /* bits to ignore around */
300         if (i == 0) {   /* easy case, just append */
301                 /* do everything in the common block */
302         } else if (i == 8) { /* easy too, just handle the overlap byte */
303                 mask = (1 << b->ebit) - 1;
304                 /* update the last byte in the buffer */
305                 dst[-1] &= ~mask;       /* clear bits to ignore */
306                 dst[-1] |= (*src & mask);       /* append new bits */
307                 src += 1;       /* skip and prepare for common block */
308                 len --;
309         } else {        /* must shift the new block, not done yet */
310                 ast_log(LOG_WARNING, "must handle shift %d %d at %d\n",
311                         b->ebit, sbit, b->used);
312                 return 1;
313         }
314         memcpy(dst, src, len);
315         b->used += len;
316         b->ebit = ebit;
317         b->data[b->used] = 0;   /* padding */
318         return 0;
319 }
320
321 /*
322  * Here starts the glue code for the various supported video codecs.
323  * For each of them, we need to provide routines for initialization,
324  * calling the encoder, encapsulating the bitstream in ast_frames,
325  * extracting payload from ast_frames, and calling the decoder.
326  */
327
328 /*--- h263+ support --- */
329
330 /*! \brief initialization of h263p */
331 static int h263p_enc_init(AVCodecContext *enc_ctx)
332 {
333         /* modes supported are
334         - Unrestricted Motion Vector (annex D)
335         - Advanced Prediction (annex F)
336         - Advanced Intra Coding (annex I)
337         - Deblocking Filter (annex J)
338         - Slice Structure (annex K)
339         - Alternative Inter VLC (annex S)
340         - Modified Quantization (annex T)
341         */
342         enc_ctx->flags |=CODEC_FLAG_H263P_UMV; /* annex D */
343         enc_ctx->flags |=CODEC_FLAG_AC_PRED; /* annex f ? */
344         enc_ctx->flags |=CODEC_FLAG_H263P_SLICE_STRUCT; /* annex k */
345         enc_ctx->flags |= CODEC_FLAG_H263P_AIC; /* annex I */
346
347         return 0;
348 }
349
350
351 /*
352  * Create RTP/H.263 fragments to avoid IP fragmentation. We fragment on a
353  * PSC or a GBSC, but if we don't find a suitable place just break somewhere.
354  * Everything is byte-aligned.
355  */
356 static struct ast_frame *h263p_encap(struct fbuf_t *b, int mtu,
357         struct ast_frame **tail)
358 {
359         struct ast_frame *cur = NULL, *first = NULL;
360         uint8_t *d = b->data;
361         int len = b->used;
362         int l = len; /* size of the current fragment. If 0, must look for a psc */
363
364         for (;len > 0; len -= l, d += l) {
365                 uint8_t *data;
366                 struct ast_frame *f;
367                 int i, h;
368
369                 if (len >= 3 && d[0] == 0 && d[1] == 0 && d[2] >= 0x80) {
370                         /* we are starting a new block, so look for a PSC. */
371                         for (i = 3; i < len - 3; i++) {
372                                 if (d[i] == 0 && d[i+1] == 0 && d[i+2] >= 0x80) {
373                                         l = i;
374                                         break;
375                                 }
376                         }
377                 }
378                 if (l > mtu || l > len) { /* psc not found, split */
379                         l = MIN(len, mtu);
380                 }
381                 if (l < 1 || l > mtu) {
382                         ast_log(LOG_WARNING, "--- frame error l %d\n", l);
383                         break;
384                 }
385                 
386                 if (d[0] == 0 && d[1] == 0) { /* we start with a psc */
387                         h = 0;
388                 } else { /* no psc, create a header */
389                         h = 2;
390                 }
391
392                 f = create_video_frame(d, d+l, AST_FORMAT_H263_PLUS, h, cur);
393                 if (!f)
394                         break;
395
396                 data = f->data.ptr;
397                 if (h == 0) {   /* we start with a psc */
398                         data[0] |= 0x04;        // set P == 1, and we are done
399                 } else {        /* no psc, create a header */
400                         data[0] = data[1] = 0;  // P == 0
401                 }
402
403                 if (!cur)
404                         first = f;
405                 cur = f;
406         }
407
408         if (cur)
409                 cur->subclass |= 1; // RTP Marker
410
411         *tail = cur;    /* end of the list */
412         return first;
413 }
414
415 /*! \brief extract the bitstreem from the RTP payload.
416  * This is format dependent.
417  * For h263+, the format is defined in RFC 2429
418  * and basically has a fixed 2-byte header as follows:
419  * 5 bits       RR      reserved, shall be 0
420  * 1 bit        P       indicate a start/end condition,
421  *                      in which case the payload should be prepended
422  *                      by two zero-valued bytes.
423  * 1 bit        V       there is an additional VRC header after this header
424  * 6 bits       PLEN    length in bytes of extra picture header
425  * 3 bits       PEBIT   how many bits to be ignored in the last byte
426  *
427  * XXX the code below is not complete.
428  */
429 static int h263p_decap(struct fbuf_t *b, uint8_t *data, int len)
430 {
431         int PLEN;
432
433         if (len < 2) {
434                 ast_log(LOG_WARNING, "invalid framesize %d\n", len);
435                 return 1;
436         }
437         PLEN = ( (data[0] & 1) << 5 ) | ( (data[1] & 0xf8) >> 3);
438
439         if (PLEN > 0) {
440                 data += PLEN;
441                 len -= PLEN;
442         }
443         if (data[0] & 4)        /* bit P */
444                 data[0] = data[1] = 0;
445         else {
446                 data += 2;
447                 len -= 2;
448         }
449         return fbuf_append(b, data, len, 0, 0); /* ignore trail bits */
450 }
451
452
453 /*
454  * generic encoder, used by the various protocols supported here.
455  * We assume that the buffer is empty at the beginning.
456  */
457 static int ffmpeg_encode(struct video_out_desc *v)
458 {
459         struct fbuf_t *b = &v->enc_out;
460         int i;
461
462         b->used = avcodec_encode_video(v->enc_ctx, b->data, b->size, v->enc_in_frame);
463         i = avcodec_encode_video(v->enc_ctx, b->data + b->used, b->size - b->used, NULL); /* delayed frames ? */
464         if (i > 0) {
465                 ast_log(LOG_WARNING, "have %d more bytes\n", i);
466                 b->used += i;
467         }
468         return 0;
469 }
470
471 /*
472  * Generic decoder, which is used by h263p, h263 and h261 as it simply
473  * invokes ffmpeg's decoder.
474  * av_parser_parse should merge a randomly chopped up stream into
475  * proper frames. After that, if we have a valid frame, we decode it
476  * until the entire frame is processed.
477  */
478 static int ffmpeg_decode(struct video_dec_desc *v, struct fbuf_t *b)
479 {
480         uint8_t *src = b->data;
481         int srclen = b->used;
482         int full_frame = 0;
483
484         if (srclen == 0)        /* no data */
485                 return 0;
486         while (srclen) {
487                 uint8_t *data;
488                 int datalen, ret;
489                 int len = av_parser_parse(v->parser, v->dec_ctx, &data, &datalen, src, srclen, 0, 0);
490
491                 src += len;
492                 srclen -= len;
493                 /* The parser might return something it cannot decode, so it skips
494                  * the block returning no data
495                  */
496                 if (data == NULL || datalen == 0)
497                         continue;
498                 ret = avcodec_decode_video(v->dec_ctx, v->d_frame, &full_frame, data, datalen);
499                 if (full_frame == 1)    /* full frame */
500                         break;
501                 if (ret < 0) {
502                         ast_log(LOG_NOTICE, "Error decoding\n");
503                         break;
504                 }
505         }
506         if (srclen != 0)        /* update b with leftover data */
507                 bcopy(src, b->data, srclen);
508         b->used = srclen;
509         b->ebit = 0;
510         return full_frame;
511 }
512
513 static struct video_codec_desc h263p_codec = {
514         .name = "h263p",
515         .format = AST_FORMAT_H263_PLUS,
516         .enc_init = h263p_enc_init,
517         .enc_encap = h263p_encap,
518         .enc_run = ffmpeg_encode,
519         .dec_init = NULL,
520         .dec_decap = h263p_decap,
521         .dec_run = ffmpeg_decode
522 };
523
524 /*--- Plain h263 support --------*/
525
526 static int h263_enc_init(AVCodecContext *enc_ctx)
527 {
528         /* XXX check whether these are supported */
529         enc_ctx->flags |= CODEC_FLAG_H263P_UMV;
530         enc_ctx->flags |= CODEC_FLAG_H263P_AIC;
531         enc_ctx->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
532         enc_ctx->flags |= CODEC_FLAG_AC_PRED;
533
534         return 0;
535 }
536
537 /*
538  * h263 encapsulation is specified in RFC2190. There are three modes
539  * defined (A, B, C), with 4, 8 and 12 bytes of header, respectively.
540  * The header is made as follows
541  *     0.....................|.......................|.............|....31
542  *      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
543  * FP = 0- mode A, (only one word of header)
544  * FP = 10 mode B, and also means this is an I or P frame
545  * FP = 11 mode C, and also means this is a PB frame.
546  * SBIT, EBIT nuber of bits to ignore at beginning (msbits) and end (lsbits)
547  * SRC  bits 6,7,8 from the h263 PTYPE field
548  * I = 0 intra-coded, 1 = inter-coded (bit 9 from PTYPE)
549  * U = 1 for Unrestricted Motion Vector (bit 10 from PTYPE)
550  * S = 1 for Syntax Based Arith coding (bit 11 from PTYPE)
551  * A = 1 for Advanced Prediction (bit 12 from PTYPE)
552  * R = reserved, must be 0
553  * DBQ = differential quantization, DBQUANT from h263, 0 unless we are using
554  *      PB frames
555  * TRB = temporal reference for bframes, also 0 unless this is a PB frame
556  * TR = temporal reference for P frames, also 0 unless PB frame.
557  *
558  * Mode B and mode C description omitted.
559  *
560  * An RTP frame can start with a PSC 0000 0000 0000 0000 1000 0
561  * or with a GBSC, which also has the first 17 bits as a PSC.
562  * Note - PSC are byte-aligned, GOB not necessarily. PSC start with
563  *      PSC:22 0000 0000 0000 0000 1000 00      picture start code
564  *      TR:8   .... ....                        temporal reference
565  *      PTYPE:13 or more                        ptype...
566  * If we don't fragment a GOB SBIT and EBIT = 0.
567  * reference, 8 bit) 
568  * 
569  * The assumption below is that we start with a PSC.
570  */
571 static struct ast_frame *h263_encap(struct fbuf_t *b, int mtu,
572                 struct ast_frame **tail)
573 {
574         uint8_t *d = b->data;
575         int start = 0, i, len = b->used;
576         struct ast_frame *f, *cur = NULL, *first = NULL;
577         const int pheader_len = 4;      /* Use RFC-2190 Mode A */
578         uint8_t h263_hdr[12];   /* worst case, room for a type c header */
579         uint8_t *h = h263_hdr;  /* shorthand */
580
581 #define H263_MIN_LEN    6
582         if (len < H263_MIN_LEN) /* unreasonably small */
583                 return NULL;
584
585         bzero(h263_hdr, sizeof(h263_hdr));
586         /* Now set the header bytes. Only type A by now,
587          * and h[0] = h[2] = h[3] = 0 by default.
588          * PTYPE starts 30 bits in the picture, so the first useful
589          * bit for us is bit 36 i.e. within d[4] (0 is the msbit).
590          * SRC = d[4] & 0x1c goes into data[1] & 0xe0
591          * I   = d[4] & 0x02 goes into data[1] & 0x10
592          * U   = d[4] & 0x01 goes into data[1] & 0x08
593          * S   = d[5] & 0x80 goes into data[1] & 0x04
594          * A   = d[5] & 0x40 goes into data[1] & 0x02
595          * R   = 0           goes into data[1] & 0x01
596          * Optimizing it, we have
597          */
598         h[1] = ( (d[4] & 0x1f) << 3 ) | /* SRC, I, U */
599                 ( (d[5] & 0xc0) >> 5 );         /* S, A, R */
600
601         /* now look for the next PSC or GOB header. First try to hit
602          * a '0' byte then look around for the 0000 0000 0000 0000 1 pattern
603          * which is both in the PSC and the GBSC.
604          */
605         for (i = H263_MIN_LEN, start = 0; start < len; start = i, i += 3) {
606                 //ast_log(LOG_WARNING, "search at %d of %d/%d\n", i, start, len);
607                 for (; i < len ; i++) {
608                         uint8_t x, rpos, lpos;
609                         int rpos_i;     /* index corresponding to rpos */
610                         if (d[i] != 0)          /* cannot be in a GBSC */
611                                 continue;
612                         if (i > len - 1)
613                                 break;
614                         x = d[i+1];
615                         if (x == 0)     /* next is equally good */
616                                 continue;
617                         /* see if around us we can make 16 '0' bits for the GBSC.
618                          * Look for the first bit set on the right, and then
619                          * see if we have enough 0 on the left.
620                          * We are guaranteed to end before rpos == 0
621                          */
622                         for (rpos = 0x80, rpos_i = 8; rpos; rpos >>= 1, rpos_i--)
623                                 if (x & rpos)   /* found the '1' bit in GBSC */
624                                         break;
625                         x = d[i-1];             /* now look behind */
626                         for (lpos = rpos; lpos ; lpos >>= 1)
627                                 if (x & lpos)   /* too early, not a GBSC */
628                                         break;
629                         if (lpos)               /* as i said... */
630                                 continue;
631                         /* now we have a GBSC starting somewhere in d[i-1],
632                          * but it might be not byte-aligned
633                          */
634                         if (rpos == 0x80) {     /* lucky case */
635                                 i = i - 1;
636                         } else {        /* XXX to be completed */
637                                 ast_log(LOG_WARNING, "unaligned GBSC 0x%x %d\n",
638                                         rpos, rpos_i);
639                         }
640                         break;
641                 }
642                 /* This frame is up to offset i (not inclusive).
643                  * We do not split it yet even if larger than MTU.
644                  */
645                 f = create_video_frame(d + start, d+i, AST_FORMAT_H263,
646                                 pheader_len, cur);
647
648                 if (!f)
649                         break;
650                 bcopy(h, f->data.ptr, 4);       /* copy the h263 header */
651                 /* XXX to do: if not aligned, fix sbit and ebit,
652                  * then move i back by 1 for the next frame
653                  */
654                 if (!cur)
655                         first = f;
656                 cur = f;
657         }
658
659         if (cur)
660                 cur->subclass |= 1;     // RTP Marker
661
662         *tail = cur;
663         return first;
664 }
665
666 /* XXX We only drop the header here, but maybe we need more. */
667 static int h263_decap(struct fbuf_t *b, uint8_t *data, int len)
668 {
669         if (len < 4) {
670                 ast_log(LOG_WARNING, "invalid framesize %d\n", len);
671                 return 1;       /* error */
672         }
673
674         if ( (data[0] & 0x80) == 0) {
675                 len -= 4;
676                 data += 4;
677         } else {
678                 ast_log(LOG_WARNING, "unsupported mode 0x%x\n",
679                         data[0]);
680                 return 1;
681         }
682         return fbuf_append(b, data, len, 0, 0); /* XXX no bit alignment support yet */
683 }
684
685 static struct video_codec_desc h263_codec = {
686         .name = "h263",
687         .format = AST_FORMAT_H263,
688         .enc_init = h263_enc_init,
689         .enc_encap = h263_encap,
690         .enc_run = ffmpeg_encode,
691         .dec_init = NULL,
692         .dec_decap = h263_decap,
693         .dec_run = ffmpeg_decode
694                                                 
695 };
696
697 /*---- h261 support -----*/
698 static int h261_enc_init(AVCodecContext *enc_ctx)
699 {
700         /* It is important to set rtp_payload_size = 0, otherwise
701          * ffmpeg in h261 mode will produce output that it cannot parse.
702          * Also try to send I frames more frequently than with other codecs.
703          */
704         enc_ctx->rtp_payload_size = 0; /* important - ffmpeg fails otherwise */
705
706         return 0;
707 }
708
709 /*
710  * The encapsulation of H261 is defined in RFC4587 which obsoletes RFC2032
711  * The bitstream is preceded by a 32-bit header word:
712  *  SBIT:3 EBIT:3 I:1 V:1 GOBN:4 MBAP:5 QUANT:5 HMVD:5 VMVD:5
713  * SBIT and EBIT are the bits to be ignored at beginning and end,
714  * I=1 if the stream has only INTRA frames - cannot change during the stream.
715  * V=0 if motion vector is not used. Cannot change.
716  * GOBN is the GOB number in effect at the start of packet, 0 if we
717  *      start with a GOB header
718  * QUANT is the quantizer in effect, 0 if we start with GOB header
719  * HMVD  reference horizontal motion vector. 10000 is forbidden
720  * VMVD  reference vertical motion vector, as above.
721  * Packetization should occur at GOB boundaries, and if not possible
722  * with MacroBlock fragmentation. However it is likely that blocks
723  * are not bit-aligned so we must take care of this.
724  */
725 static struct ast_frame *h261_encap(struct fbuf_t *b, int mtu,
726                 struct ast_frame **tail)
727 {
728         uint8_t *d = b->data;
729         int start = 0, i, len = b->used;
730         struct ast_frame *f, *cur = NULL, *first = NULL;
731         const int pheader_len = 4;
732         uint8_t h261_hdr[4];
733         uint8_t *h = h261_hdr;  /* shorthand */
734         int sbit = 0, ebit = 0;
735
736 #define H261_MIN_LEN 10
737         if (len < H261_MIN_LEN) /* unreasonably small */
738                 return NULL;
739
740         bzero(h261_hdr, sizeof(h261_hdr));
741
742         /* Similar to the code in h263_encap, but the marker there is longer.
743          * Start a few bytes within the bitstream to avoid hitting the marker
744          * twice. Note we might access the buffer at len, but this is ok because
745          * the caller has it oversized.
746          */
747         for (i = H261_MIN_LEN, start = 0; start < len - 1; start = i, i += 4) {
748 #if 0   /* test - disable packetization */
749                 i = len;        /* wrong... */
750 #else
751                 int found = 0, found_ebit = 0;  /* last GBSC position found */
752                 for (; i < len ; i++) {
753                         uint8_t x, rpos, lpos;
754                         if (d[i] != 0)          /* cannot be in a GBSC */
755                                 continue;
756                         x = d[i+1];
757                         if (x == 0)     /* next is equally good */
758                                 continue;
759                         /* See if around us we find 15 '0' bits for the GBSC.
760                          * Look for the first bit set on the right, and then
761                          * see if we have enough 0 on the left.
762                          * We are guaranteed to end before rpos == 0
763                          */
764                         for (rpos = 0x80, ebit = 7; rpos; ebit--, rpos >>= 1)
765                                 if (x & rpos)   /* found the '1' bit in GBSC */
766                                         break;
767                         x = d[i-1];             /* now look behind */
768                         for (lpos = (rpos >> 1); lpos ; lpos >>= 1)
769                                 if (x & lpos)   /* too early, not a GBSC */
770                                         break;
771                         if (lpos)               /* as i said... */
772                                 continue;
773                         /* now we have a GBSC starting somewhere in d[i-1],
774                          * but it might be not byte-aligned. Just remember it.
775                          */
776                         if (i - start > mtu) /* too large, stop now */
777                                 break;
778                         found_ebit = ebit;
779                         found = i;
780                         i += 4; /* continue forward */
781                 }
782                 if (i >= len) { /* trim if we went too forward */
783                         i = len;
784                         ebit = 0;       /* hopefully... should ask the bitstream ? */
785                 }
786                 if (i - start > mtu && found) {
787                         /* use the previous GBSC, hope is within the mtu */
788                         i = found;
789                         ebit = found_ebit;
790                 }
791 #endif /* test */
792                 if (i - start < 4)      /* XXX too short ? */
793                         continue;
794                 /* This frame is up to offset i (not inclusive).
795                  * We do not split it yet even if larger than MTU.
796                  */
797                 f = create_video_frame(d + start, d+i, AST_FORMAT_H261,
798                                 pheader_len, cur);
799
800                 if (!f)
801                         break;
802                 /* recompute header with I=0, V=1 */
803                 h[0] = ( (sbit & 7) << 5 ) | ( (ebit & 7) << 2 ) | 1;
804                 bcopy(h, f->data.ptr, 4);       /* copy the h261 header */
805                 if (ebit)       /* not aligned, restart from previous byte */
806                         i--;
807                 sbit = (8 - ebit) & 7;
808                 ebit = 0;
809                 if (!cur)
810                         first = f;
811                 cur = f;
812         }
813         if (cur)
814                 cur->subclass |= 1;     // RTP Marker
815
816         *tail = cur;
817         return first;
818 }
819
820 /*
821  * Pieces might be unaligned so we really need to put them together.
822  */
823 static int h261_decap(struct fbuf_t *b, uint8_t *data, int len)
824 {
825         int ebit, sbit;
826
827         if (len < 8) {
828                 ast_log(LOG_WARNING, "invalid framesize %d\n", len);
829                 return 1;
830         }
831         sbit = (data[0] >> 5) & 7;
832         ebit = (data[0] >> 2) & 7;
833         len -= 4;
834         data += 4;
835         return fbuf_append(b, data, len, sbit, ebit);
836 }
837
838 static struct video_codec_desc h261_codec = {
839         .name = "h261",
840         .format = AST_FORMAT_H261,
841         .enc_init = h261_enc_init,
842         .enc_encap = h261_encap,
843         .enc_run = ffmpeg_encode,
844         .dec_init = NULL,
845         .dec_decap = h261_decap,
846         .dec_run = ffmpeg_decode
847 };
848
849 /* mpeg4 support */
850 static int mpeg4_enc_init(AVCodecContext *enc_ctx)
851 {
852 #if 0
853         //enc_ctx->flags |= CODEC_FLAG_LOW_DELAY; /*don't use b frames ?*/
854         enc_ctx->flags |= CODEC_FLAG_AC_PRED;
855         enc_ctx->flags |= CODEC_FLAG_H263P_UMV;
856         enc_ctx->flags |= CODEC_FLAG_QPEL;
857         enc_ctx->flags |= CODEC_FLAG_4MV;
858         enc_ctx->flags |= CODEC_FLAG_GMC;
859         enc_ctx->flags |= CODEC_FLAG_LOOP_FILTER;
860         enc_ctx->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
861 #endif
862         enc_ctx->rtp_payload_size = 0; /* important - ffmpeg fails otherwise */
863         return 0;
864 }
865
866 /* simplistic encapsulation - just split frames in mtu-size units */
867 static struct ast_frame *mpeg4_encap(struct fbuf_t *b, int mtu,
868         struct ast_frame **tail)
869 {
870         struct ast_frame *f, *cur = NULL, *first = NULL;
871         uint8_t *d = b->data;
872         uint8_t *end = d + b->used;
873         int len;
874
875         for (;d < end; d += len, cur = f) {
876                 len = MIN(mtu, end - d);
877                 f = create_video_frame(d, d + len, AST_FORMAT_MP4_VIDEO, 0, cur);
878                 if (!f)
879                         break;
880                 if (!first)
881                         first = f;
882         }
883         if (cur)
884                 cur->subclass |= 1;
885         *tail = cur;
886         return first;
887 }
888
889 static int mpeg4_decap(struct fbuf_t *b, uint8_t *data, int len)
890 {
891         return fbuf_append(b, data, len, 0, 0);
892 }
893
894 static int mpeg4_decode(struct video_dec_desc *v, struct fbuf_t *b)
895 {
896         int full_frame = 0, datalen = b->used;
897         int ret = avcodec_decode_video(v->dec_ctx, v->d_frame, &full_frame,
898                 b->data, datalen);
899         if (ret < 0) {
900                 ast_log(LOG_NOTICE, "Error decoding\n");
901                 ret = datalen; /* assume we used everything. */
902         }
903         datalen -= ret;
904         if (datalen > 0)        /* update b with leftover bytes */
905                 bcopy(b->data + ret, b->data, datalen);
906         b->used = datalen;
907         b->ebit = 0;
908         return full_frame;
909 }
910
911 static struct video_codec_desc mpeg4_codec = {
912         .name = "mpeg4",
913         .format = AST_FORMAT_MP4_VIDEO,
914         .enc_init = mpeg4_enc_init,
915         .enc_encap = mpeg4_encap,
916         .enc_run = ffmpeg_encode,
917         .dec_init = NULL,
918         .dec_decap = mpeg4_decap,
919         .dec_run = mpeg4_decode
920 };
921
922 static int h264_enc_init(AVCodecContext *enc_ctx)
923 {
924         enc_ctx->flags |= CODEC_FLAG_TRUNCATED;
925         //enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
926         //enc_ctx->flags2 |= CODEC_FLAG2_FASTPSKIP;
927         /* TODO: Maybe we need to add some other flags */
928         enc_ctx->rtp_mode = 0;
929         enc_ctx->rtp_payload_size = 0;
930         enc_ctx->bit_rate_tolerance = enc_ctx->bit_rate;
931         return 0;
932 }
933
934 static int h264_dec_init(AVCodecContext *dec_ctx)
935 {
936         dec_ctx->flags |= CODEC_FLAG_TRUNCATED;
937
938         return 0;
939 }
940
941 /*
942  * The structure of a generic H.264 stream is:
943  * - 0..n 0-byte(s), unused, optional. one zero-byte is always present
944  *   in the first NAL before the start code prefix.
945  * - start code prefix (3 bytes): 0x000001
946  *   (the first bytestream has a 
947  *   like these 0x00000001!)
948  * - NAL header byte ( F[1] | NRI[2] | Type[5] ) where type != 0
949  * - byte-stream
950  * - 0..n 0-byte(s) (padding, unused).
951  * Segmentation in RTP only needs to be done on start code prefixes.
952  * If fragments are too long... we don't support it yet.
953  * - encapsulate (or fragment) the byte-stream (with NAL header included)
954  */
955 static struct ast_frame *h264_encap(struct fbuf_t *b, int mtu,
956         struct ast_frame **tail)
957 {
958         struct ast_frame *f = NULL, *cur = NULL, *first = NULL;
959         uint8_t *d, *start = b->data;
960         uint8_t *end = start + b->used;
961
962         /* Search the first start code prefix - ITU-T H.264 sec. B.2,
963          * and move start right after that, on the NAL header byte.
964          */
965 #define HAVE_NAL(x) (x[-4] == 0 && x[-3] == 0 && x[-2] == 0 && x[-1] == 1)
966         for (start += 4; start < end; start++) {
967                 int ty = start[0] & 0x1f;
968                 if (HAVE_NAL(start) && ty != 0 && ty != 31)
969                         break;
970         }
971         /* if not found, or too short, we just skip the next loop and are done. */
972
973         /* Here follows the main loop to create frames. Search subsequent start
974          * codes, and then possibly fragment the unit into smaller fragments.
975          */
976    for (;start < end - 4; start = d) {
977         int size;               /* size of current block */
978         uint8_t hdr[2];         /* add-on header when fragmenting */
979         int ty = 0;
980
981         /* now search next nal */
982         for (d = start + 4; d < end; d++) {
983                 ty = d[0] & 0x1f;
984                 if (HAVE_NAL(d))
985                         break;  /* found NAL */
986         }
987         /* have a block to send. d past the start code unless we overflow */
988         if (d >= end) { /* NAL not found */
989                 d = end + 4;
990         } else if (ty == 0 || ty == 31) { /* found but invalid type, skip */
991                 ast_log(LOG_WARNING, "skip invalid nal type %d at %d of %d\n",
992                         ty, d - (uint8_t *)b->data, b->used);
993                 continue;
994         }
995
996         size = d - start - 4;   /* don't count the end */
997
998         if (size < mtu) {       // test - don't fragment
999                 // Single NAL Unit
1000                 f = create_video_frame(start, d - 4, AST_FORMAT_H264, 0, cur);
1001                 if (!f)
1002                         break;
1003                 if (!first)
1004                         first = f;
1005
1006                 cur = f;
1007                 continue;
1008         }
1009
1010         // Fragmented Unit (Mode A: no DON, very weak)
1011         hdr[0] = (*start & 0xe0) | 28;  /* mark as a fragmentation unit */
1012         hdr[1] = (*start++ & 0x1f) | 0x80 ;     /* keep type and set START bit */
1013         size--;         /* skip the NAL header */
1014         while (size) {
1015                 uint8_t *data;
1016                 int frag_size = MIN(size, mtu);
1017
1018                 f = create_video_frame(start, start+frag_size, AST_FORMAT_H264, 2, cur);
1019                 if (!f)
1020                         break;
1021                 size -= frag_size;      /* skip this data block */
1022                 start += frag_size;
1023
1024                 data = f->data.ptr;
1025                 data[0] = hdr[0];
1026                 data[1] = hdr[1] | (size == 0 ? 0x40 : 0);      /* end bit if we are done */
1027                 hdr[1] &= ~0x80;        /* clear start bit for subsequent frames */
1028                 if (!first)
1029                         first = f;
1030                 cur = f;
1031         }
1032     }
1033
1034         if (cur)
1035                 cur->subclass |= 1;     // RTP Marker
1036
1037         *tail = cur;
1038
1039         return first;
1040 }
1041
1042 static int h264_decap(struct fbuf_t *b, uint8_t *data, int len)
1043 {
1044         /* Start Code Prefix (Annex B in specification) */
1045         uint8_t scp[] = { 0x00, 0x00, 0x00, 0x01 };
1046         int retval = 0;
1047         int type, ofs = 0;
1048
1049         if (len < 2) {
1050                 ast_log(LOG_WARNING, "--- invalid len %d\n", len);
1051                 return 1;
1052         }
1053         /* first of all, check if the packet has F == 0 */
1054         if (data[0] & 0x80) {
1055                 ast_log(LOG_WARNING, "--- forbidden packet; nal: %02x\n",
1056                         data[0]);
1057                 return 1;
1058         }
1059
1060         type = data[0] & 0x1f;
1061         switch (type) {
1062         case 0:
1063         case 31:
1064                 ast_log(LOG_WARNING, "--- invalid type: %d\n", type);
1065                 return 1;
1066         case 24:
1067         case 25:
1068         case 26:
1069         case 27:
1070         case 29:
1071                 ast_log(LOG_WARNING, "--- encapsulation not supported : %d\n", type);
1072                 return 1;
1073         case 28:        /* FU-A Unit */
1074                 if (data[1] & 0x80) { // S == 1, import F and NRI from next
1075                         data[1] &= 0x1f;        /* preserve type */
1076                         data[1] |= (data[0] & 0xe0);    /* import F & NRI */
1077                         retval = fbuf_append(b, scp, sizeof(scp), 0, 0);
1078                         ofs = 1;
1079                 } else {
1080                         ofs = 2;
1081                 }
1082                 break;
1083         default:        /* From 1 to 23 (Single NAL Unit) */
1084                 retval = fbuf_append(b, scp, sizeof(scp), 0, 0);
1085         }
1086         if (!retval)
1087                 retval = fbuf_append(b, data + ofs, len - ofs, 0, 0);
1088         if (retval)
1089                 ast_log(LOG_WARNING, "result %d\n", retval);
1090         return retval;
1091 }
1092
1093 static struct video_codec_desc h264_codec = {
1094         .name = "h264",
1095         .format = AST_FORMAT_H264,
1096         .enc_init = h264_enc_init,
1097         .enc_encap = h264_encap,
1098         .enc_run = ffmpeg_encode,
1099         .dec_init = h264_dec_init,
1100         .dec_decap = h264_decap,
1101         .dec_run = ffmpeg_decode
1102 };
1103
1104 /*
1105  * Table of translation between asterisk and ffmpeg formats.
1106  * We need also a field for read and write (encoding and decoding), because
1107  * e.g. H263+ uses different codec IDs in ffmpeg when encoding or decoding.
1108  */
1109 struct _cm {    /* map ffmpeg codec types to asterisk formats */
1110         uint32_t        ast_format;     /* 0 is a terminator */
1111         enum CodecID    codec;
1112         enum { CM_RD = 1, CM_WR = 2, CM_RDWR = 3 } rw;  /* read or write or both ? */
1113         //struct video_codec_desc *codec_desc;
1114 };
1115
1116 static struct _cm video_formats[] = {
1117         { AST_FORMAT_H263_PLUS, CODEC_ID_H263,  CM_RD }, /* incoming H263P ? */
1118         { AST_FORMAT_H263_PLUS, CODEC_ID_H263P, CM_WR },
1119         { AST_FORMAT_H263,      CODEC_ID_H263,  CM_RD },
1120         { AST_FORMAT_H263,      CODEC_ID_H263,  CM_WR },
1121         { AST_FORMAT_H261,      CODEC_ID_H261,  CM_RDWR },
1122         { AST_FORMAT_H264,      CODEC_ID_H264,  CM_RDWR },
1123         { AST_FORMAT_MP4_VIDEO, CODEC_ID_MPEG4, CM_RDWR },
1124         { 0,                    0, 0 },
1125 };
1126                 
1127
1128 /*! \brief map an asterisk format into an ffmpeg one */
1129 static enum CodecID map_video_format(uint32_t ast_format, int rw)
1130 {
1131         struct _cm *i;
1132
1133         for (i = video_formats; i->ast_format != 0; i++)
1134                 if (ast_format & i->ast_format && rw & i->rw && rw & i->rw)
1135                         return i->codec;
1136         return CODEC_ID_NONE;
1137 }
1138
1139 /* pointers to supported codecs. We assume the first one to be non null. */
1140 static struct video_codec_desc *supported_codecs[] = {
1141         &h263p_codec,
1142         &h264_codec,
1143         &h263_codec,
1144         &h261_codec,
1145         &mpeg4_codec,
1146         NULL
1147 };
1148
1149 /*
1150  * Map the AST_FORMAT to the library. If not recognised, fail.
1151  * This is useful in the input path where we get frames.
1152  */
1153 static struct video_codec_desc *map_video_codec(int fmt)
1154 {
1155         int i;
1156
1157         for (i = 0; supported_codecs[i]; i++)
1158                 if (fmt == supported_codecs[i]->format) {
1159                         ast_log(LOG_WARNING, "using %s for format 0x%x\n",
1160                                 supported_codecs[i]->name, fmt);
1161                         return supported_codecs[i];
1162                 }
1163         return NULL;
1164 }
1165
1166 /*! \brief uninitialize the descriptor for remote video stream */
1167 static struct video_dec_desc *dec_uninit(struct video_dec_desc *v)
1168 {
1169         int i;
1170
1171         if (v == NULL)          /* not initialized yet */
1172                 return NULL;
1173         if (v->parser) {
1174                 av_parser_close(v->parser);
1175                 v->parser = NULL;
1176         }
1177         if (v->dec_ctx) {
1178                 avcodec_close(v->dec_ctx);
1179                 av_free(v->dec_ctx);
1180                 v->dec_ctx = NULL;
1181         }
1182         if (v->d_frame) {
1183                 av_free(v->d_frame);
1184                 v->d_frame = NULL;
1185         }
1186         v->codec = NULL;        /* only a reference */
1187         v->d_callbacks = NULL;          /* forget the decoder */
1188         v->discard = 1;         /* start in discard mode */
1189         for (i = 0; i < N_DEC_IN; i++)
1190                 fbuf_free(&v->dec_in[i]);
1191         fbuf_free(&v->dec_out);
1192         ast_free(v);
1193         return NULL;    /* error, in case someone cares */
1194 }
1195
1196 /*
1197  * initialize ffmpeg resources used for decoding frames from the network.
1198  */
1199 static struct video_dec_desc *dec_init(uint32_t the_ast_format)
1200 {
1201         enum CodecID codec;
1202         struct video_dec_desc *v = ast_calloc(1, sizeof(*v));
1203         if (v == NULL)
1204                 return NULL;
1205
1206         v->discard = 1;
1207
1208         v->d_callbacks = map_video_codec(the_ast_format);
1209         if (v->d_callbacks == NULL) {
1210                 ast_log(LOG_WARNING, "cannot find video codec, drop input 0x%x\n", the_ast_format);
1211                 return dec_uninit(v);
1212         }
1213
1214         codec = map_video_format(v->d_callbacks->format, CM_RD);
1215
1216         v->codec = avcodec_find_decoder(codec);
1217         if (!v->codec) {
1218                 ast_log(LOG_WARNING, "Unable to find the decoder for format %d\n", codec);
1219                 return dec_uninit(v);
1220         }
1221         /*
1222          * Initialize the codec context.
1223          */
1224         v->dec_ctx = avcodec_alloc_context();
1225         if (!v->dec_ctx) {
1226                 ast_log(LOG_WARNING, "Cannot allocate the decoder context\n");
1227                 return dec_uninit(v);
1228         }
1229         /* XXX call dec_init() ? */
1230         if (avcodec_open(v->dec_ctx, v->codec) < 0) {
1231                 ast_log(LOG_WARNING, "Cannot open the decoder context\n");
1232                 av_free(v->dec_ctx);
1233                 v->dec_ctx = NULL;
1234                 return dec_uninit(v);
1235         }
1236
1237         v->parser = av_parser_init(codec);
1238         if (!v->parser) {
1239                 ast_log(LOG_WARNING, "Cannot initialize the decoder parser\n");
1240                 return dec_uninit(v);
1241         }
1242
1243         v->d_frame = avcodec_alloc_frame();
1244         if (!v->d_frame) {
1245                 ast_log(LOG_WARNING, "Cannot allocate decoding video frame\n");
1246                 return dec_uninit(v);
1247         }
1248         v->dec_in_cur = &v->dec_in[0];  /* buffer for incoming frames */
1249         v->dec_in_dpy = NULL;      /* nothing to display */
1250
1251         return v;       /* ok */
1252 }
1253 /*------ end codec specific code -----*/