27 #include "console_video.h"
31 struct video_out_desc;
39 typedef int (*encoder_init_f)(AVCodecContext *v);
42 typedef int (*encoder_encode_f)(
struct video_out_desc *v);
49 typedef int (*decoder_init_f)(AVCodecContext *enc_ctx);
54 typedef int (*decoder_decap_f)(
struct fbuf_t *b, uint8_t *data,
int len);
62 encoder_init_f enc_init;
63 encoder_encap_f enc_encap;
64 encoder_encode_f enc_run;
65 decoder_init_f dec_init;
66 decoder_decap_f dec_decap;
67 decoder_decode_f dec_run;
86 AVCodecContext *dec_ctx;
89 AVCodecParserContext *parser;
95 struct fbuf_t dec_in[N_DEC_IN];
110 static struct bitbuf bitbuf_init(const uint8_t *base,
int bitsize,
int start_ofs)
119 static int bitbuf_left(
struct bitbuf *b)
121 return b->bitsize - b->ofs;
124 static uint32_t getbits(
struct bitbuf *b,
int n)
131 ast_log(LOG_WARNING,
"too many bits %d, max 32\n", n);
134 if (n + b->ofs > b->bitsize) {
135 ast_log(LOG_WARNING,
"bitbuf overflow %d of %d\n", n + b->ofs, b->bitsize);
136 n = b->bitsize - b->ofs;
138 ofs = 7 - b->ofs % 8;
140 d = b->base + b->ofs / 8;
141 for (i=0 ; i < n; i++) {
142 retval += retval + (*d & mask ? 1 : 0);
153 static void check_h261(
struct fbuf_t *b)
155 struct bitbuf a = bitbuf_init(b->data, b->used * 8, 0);
160 ast_log(LOG_WARNING,
"bad PSC 0x%x\n", x);
166 ast_log(LOG_WARNING,
"size %d TR %d PTY spl %d doc %d freeze %d %sCIF hi %d\n",
172 (y & 0x4) ?
"" :
"Q",
174 while ( (x = getbits(&a, 1)) == 1)
175 ast_log(LOG_WARNING,
"PSPARE 0x%x\n", getbits(&a, 8));
177 while ( (x = bitbuf_left(&a)) > 0) {
181 ast_log(LOG_WARNING,
"bad GBSC 0x%x\n", x);
187 ast_log(LOG_WARNING,
" bad GN %d\n", x);
190 while ( (x = getbits(&a, 1)) == 1)
191 ast_log(LOG_WARNING,
"GSPARE 0x%x\n", getbits(&a, 8));
192 while ( (x = bitbuf_left(&a)) > 0) {
198 void dump_buf(
struct fbuf_t *b);
199 void dump_buf(
struct fbuf_t *b)
201 int i, x, last2lines;
204 last2lines = (b->used - 16) & ~0xf;
205 ast_log(LOG_WARNING,
"buf size %d of %d\n", b->used, b->size);
206 for (i = 0; i < b->used; i++) {
210 ast_log(LOG_WARNING,
"%s\n", buf);
211 memset(buf,
'\0',
sizeof(buf));
212 sprintf(buf,
"%04x: ", (
unsigned)i);
214 sprintf(buf + 6 + x*3,
"%02hhx ", b->data[i]);
215 if (i > 31 && i < last2lines)
219 ast_log(LOG_WARNING,
"%s\n", buf);
228 static struct ast_frame *create_video_frame(uint8_t *start, uint8_t *end,
229 int format,
int head,
struct ast_frame *prev)
237 if (f == NULL || data == NULL) {
238 ast_log(LOG_WARNING,
"--- frame error f %p data %p len %d format %d\n",
239 f, data, len, format);
246 memcpy(data+head, start, len);
273 static int fbuf_append(
struct fbuf_t *b, uint8_t *
src,
int len,
280 int need = len + FF_INPUT_BUFFER_PADDING_SIZE;
284 if (b->data == NULL) {
289 }
else if (b->used + need > b->size) {
290 b->size = b->used + need;
293 if (b->data == NULL) {
294 ast_log(LOG_WARNING,
"alloc failure for %d, discard\n",
298 if (b->used == 0 && b->ebit != 0) {
299 ast_log(LOG_WARNING,
"ebit not reset at start\n");
302 dst = b->data + b->used;
307 mask = (1 << b->ebit) - 1;
310 dst[-1] |= (*src & mask);
314 ast_log(LOG_WARNING,
"must handle shift %d %d at %d\n",
315 b->ebit, sbit, b->used);
318 memcpy(dst, src, len);
321 b->data[b->used] = 0;
335 static int h263p_enc_init(AVCodecContext *enc_ctx)
346 enc_ctx->flags |=CODEC_FLAG_H263P_UMV;
347 enc_ctx->flags |=CODEC_FLAG_AC_PRED;
348 enc_ctx->flags |=CODEC_FLAG_H263P_SLICE_STRUCT;
349 enc_ctx->flags |= CODEC_FLAG_H263P_AIC;
363 struct ast_frame *cur = NULL, *first = NULL;
364 uint8_t *d = b->data;
368 for (;len > 0; len -= l, d += l) {
373 if (len >= 3 && d[0] == 0 && d[1] == 0 && d[2] >= 0x80) {
375 for (i = 3; i < len - 3; i++) {
376 if (d[i] == 0 && d[i+1] == 0 && d[i+2] >= 0x80) {
382 if (l > mtu || l > len) {
385 if (l < 1 || l > mtu) {
386 ast_log(LOG_WARNING,
"--- frame error l %d\n", l);
390 if (d[0] == 0 && d[1] == 0) {
396 f = create_video_frame(d, d+l, AST_FORMAT_H263_PLUS, h, cur);
404 data[0] = data[1] = 0;
433 static int h263p_decap(
struct fbuf_t *b, uint8_t *data,
int len)
438 ast_log(LOG_WARNING,
"invalid framesize %d\n", len);
441 PLEN = ( (data[0] & 1) << 5 ) | ( (data[1] & 0xf8) >> 3);
448 data[0] = data[1] = 0;
453 return fbuf_append(b, data, len, 0, 0);
461 static int ffmpeg_encode(
struct video_out_desc *v)
463 struct fbuf_t *b = &v->enc_out;
466 b->used = avcodec_encode_video(v->enc_ctx, b->data, b->size, v->enc_in_frame);
467 i = avcodec_encode_video(v->enc_ctx, b->data + b->used, b->size - b->used, NULL);
469 ast_log(LOG_WARNING,
"have %d more bytes\n", i);
484 uint8_t *src = b->data;
485 int srclen = b->used;
493 int len = av_parser_parse(v->parser, v->dec_ctx, &data, &datalen, src, srclen, 0, 0);
500 if (data == NULL || datalen == 0)
502 ret = avcodec_decode_video(v->dec_ctx, v->d_frame, &full_frame, data, datalen);
506 ast_log(LOG_NOTICE,
"Error decoding\n");
511 memmove(b->data, src, srclen);
519 .format = AST_FORMAT_H263_PLUS,
520 .enc_init = h263p_enc_init,
521 .enc_encap = h263p_encap,
522 .enc_run = ffmpeg_encode,
524 .dec_decap = h263p_decap,
525 .dec_run = ffmpeg_decode
530 static int h263_enc_init(AVCodecContext *enc_ctx)
533 enc_ctx->flags |= CODEC_FLAG_H263P_UMV;
534 enc_ctx->flags |= CODEC_FLAG_H263P_AIC;
535 enc_ctx->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
536 enc_ctx->flags |= CODEC_FLAG_AC_PRED;
578 uint8_t *d = b->data;
579 int start = 0, i, len = b->used;
580 struct ast_frame *f, *cur = NULL, *first = NULL;
581 const int pheader_len = 4;
582 uint8_t h263_hdr[12];
583 uint8_t *h = h263_hdr;
585 #define H263_MIN_LEN 6
586 if (len < H263_MIN_LEN)
589 memset(h263_hdr,
'\0',
sizeof(h263_hdr));
602 h[1] = ( (d[4] & 0x1f) << 3 ) |
603 ( (d[5] & 0xc0) >> 5 );
609 for (i = H263_MIN_LEN, start = 0; start <
len; start = i, i += 3) {
611 for (; i <
len ; i++) {
612 uint8_t x, rpos, lpos;
626 for (rpos = 0x80, rpos_i = 8; rpos; rpos >>= 1, rpos_i--)
630 for (lpos = rpos; lpos ; lpos >>= 1)
641 ast_log(LOG_WARNING,
"unaligned GBSC 0x%x %d\n",
654 memmove(f->
data.ptr, h, 4);
671 static int h263_decap(
struct fbuf_t *b, uint8_t *data,
int len)
674 ast_log(LOG_WARNING,
"invalid framesize %d\n", len);
678 if ( (data[0] & 0x80) == 0) {
682 ast_log(LOG_WARNING,
"unsupported mode 0x%x\n",
686 return fbuf_append(b, data, len, 0, 0);
692 .enc_init = h263_enc_init,
693 .enc_encap = h263_encap,
694 .enc_run = ffmpeg_encode,
696 .dec_decap = h263_decap,
697 .dec_run = ffmpeg_decode
702 static int h261_enc_init(AVCodecContext *enc_ctx)
708 enc_ctx->rtp_payload_size = 0;
732 uint8_t *d = b->data;
733 int start = 0, i, len = b->used;
734 struct ast_frame *f, *cur = NULL, *first = NULL;
735 const int pheader_len = 4;
737 uint8_t *h = h261_hdr;
738 int sbit = 0, ebit = 0;
740 #define H261_MIN_LEN 10
741 if (len < H261_MIN_LEN)
744 memset(h261_hdr,
'\0',
sizeof(h261_hdr));
751 for (i = H261_MIN_LEN, start = 0; start < len - 1; start = i, i += 4) {
755 int found = 0, found_ebit = 0;
756 for (; i <
len ; i++) {
757 uint8_t x, rpos, lpos;
768 for (rpos = 0x80, ebit = 7; rpos; ebit--, rpos >>= 1)
772 for (lpos = (rpos >> 1); lpos ; lpos >>= 1)
790 if (i - start > mtu && found) {
807 h[0] = ( (sbit & 7) << 5 ) | ( (ebit & 7) << 2 ) | 1;
808 memmove(f->
data.ptr, h, 4);
811 sbit = (8 - ebit) & 7;
827 static int h261_decap(
struct fbuf_t *b, uint8_t *data,
int len)
832 ast_log(LOG_WARNING,
"invalid framesize %d\n", len);
835 sbit = (data[0] >> 5) & 7;
836 ebit = (data[0] >> 2) & 7;
839 return fbuf_append(b, data, len, sbit, ebit);
845 .enc_init = h261_enc_init,
846 .enc_encap = h261_encap,
847 .enc_run = ffmpeg_encode,
849 .dec_decap = h261_decap,
850 .dec_run = ffmpeg_decode
854 static int mpeg4_enc_init(AVCodecContext *enc_ctx)
858 enc_ctx->flags |= CODEC_FLAG_AC_PRED;
859 enc_ctx->flags |= CODEC_FLAG_H263P_UMV;
860 enc_ctx->flags |= CODEC_FLAG_QPEL;
861 enc_ctx->flags |= CODEC_FLAG_4MV;
862 enc_ctx->flags |= CODEC_FLAG_GMC;
863 enc_ctx->flags |= CODEC_FLAG_LOOP_FILTER;
864 enc_ctx->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
866 enc_ctx->rtp_payload_size = 0;
874 struct ast_frame *f, *cur = NULL, *first = NULL;
875 uint8_t *d = b->data;
876 uint8_t *end = d + b->used;
879 for (;d < end; d +=
len, cur = f) {
880 len = MIN(mtu, end - d);
881 f = create_video_frame(d, d + len, AST_FORMAT_MP4_VIDEO, 0, cur);
893 static int mpeg4_decap(
struct fbuf_t *b, uint8_t *data,
int len)
895 return fbuf_append(b, data, len, 0, 0);
900 int full_frame = 0, datalen = b->used;
901 int ret = avcodec_decode_video(v->dec_ctx, v->d_frame, &full_frame,
904 ast_log(LOG_NOTICE,
"Error decoding\n");
909 memmove(b->data, b->data + ret, datalen);
917 .format = AST_FORMAT_MP4_VIDEO,
918 .enc_init = mpeg4_enc_init,
919 .enc_encap = mpeg4_encap,
920 .enc_run = ffmpeg_encode,
922 .dec_decap = mpeg4_decap,
923 .dec_run = mpeg4_decode
926 static int h264_enc_init(AVCodecContext *enc_ctx)
928 enc_ctx->flags |= CODEC_FLAG_TRUNCATED;
932 enc_ctx->rtp_mode = 0;
933 enc_ctx->rtp_payload_size = 0;
934 enc_ctx->bit_rate_tolerance = enc_ctx->bit_rate;
938 static int h264_dec_init(AVCodecContext *dec_ctx)
940 dec_ctx->flags |= CODEC_FLAG_TRUNCATED;
962 struct ast_frame *f = NULL, *cur = NULL, *first = NULL;
963 uint8_t *d, *start = b->data;
964 uint8_t *end = start + b->used;
969 #define HAVE_NAL(x) (x[-4] == 0 && x[-3] == 0 && x[-2] == 0 && x[-1] == 1)
970 for (start += 4; start < end; start++) {
971 int ty = start[0] & 0x1f;
972 if (HAVE_NAL(start) && ty != 0 && ty != 31)
980 for (;start < end - 4; start = d) {
986 for (d = start + 4; d < end; d++) {
994 }
else if (ty == 0 || ty == 31) {
995 ast_log(LOG_WARNING,
"skip invalid nal type %d at %d of %d\n",
996 ty, d - (uint8_t *)b->data, b->used);
1000 size = d - start - 4;
1015 hdr[0] = (*start & 0xe0) | 28;
1016 hdr[1] = (*start++ & 0x1f) | 0x80 ;
1020 int frag_size = MIN(size, mtu);
1022 f = create_video_frame(start, start+frag_size,
AST_FORMAT_H264, 2, cur);
1030 data[1] = hdr[1] | (size == 0 ? 0x40 : 0);
1046 static int h264_decap(
struct fbuf_t *b, uint8_t *data,
int len)
1049 uint8_t scp[] = { 0x00, 0x00, 0x00, 0x01 };
1054 ast_log(LOG_WARNING,
"--- invalid len %d\n", len);
1058 if (data[0] & 0x80) {
1059 ast_log(LOG_WARNING,
"--- forbidden packet; nal: %02hhx\n",
1064 type = data[0] & 0x1f;
1068 ast_log(LOG_WARNING,
"--- invalid type: %d\n", type);
1075 ast_log(LOG_WARNING,
"--- encapsulation not supported : %d\n", type);
1078 if (data[1] & 0x80) {
1080 data[1] |= (data[0] & 0xe0);
1081 retval = fbuf_append(b, scp,
sizeof(scp), 0, 0);
1088 retval = fbuf_append(b, scp,
sizeof(scp), 0, 0);
1091 retval = fbuf_append(b, data + ofs, len - ofs, 0, 0);
1093 ast_log(LOG_WARNING,
"result %d\n", retval);
1100 .enc_init = h264_enc_init,
1101 .enc_encap = h264_encap,
1102 .enc_run = ffmpeg_encode,
1103 .dec_init = h264_dec_init,
1104 .dec_decap = h264_decap,
1105 .dec_run = ffmpeg_decode
1116 enum { CM_RD = 1, CM_WR = 2, CM_RDWR = 3 } rw;
1120 static const struct _cm video_formats[] = {
1121 { AST_FORMAT_H263_PLUS, CODEC_ID_H263, CM_RD },
1122 { AST_FORMAT_H263_PLUS, CODEC_ID_H263P, CM_WR },
1127 { AST_FORMAT_MP4_VIDEO, CODEC_ID_MPEG4, CM_RDWR },
1133 static enum CodecID map_video_format(uint32_t
ast_format,
int rw)
1137 for (i = video_formats; i->ast_format != 0; i++)
1138 if (ast_format & i->ast_format && rw & i->rw) {
1141 return CODEC_ID_NONE;
1162 for (i = 0; supported_codecs[i]; i++)
1163 if (fmt == supported_codecs[i]->format) {
1164 ast_log(LOG_WARNING,
"using %s for format 0x%x\n",
1165 supported_codecs[i]->name, fmt);
1166 return supported_codecs[i];
1179 av_parser_close(v->parser);
1183 avcodec_close(v->dec_ctx);
1184 av_free(v->dec_ctx);
1188 av_free(v->d_frame);
1192 v->d_callbacks = NULL;
1194 for (i = 0; i < N_DEC_IN; i++)
1195 fbuf_free(&v->dec_in[i]);
1196 fbuf_free(&v->dec_out);
1213 v->d_callbacks = map_video_codec(the_ast_format);
1214 if (v->d_callbacks == NULL) {
1215 ast_log(LOG_WARNING,
"cannot find video codec, drop input 0x%x\n", the_ast_format);
1216 return dec_uninit(v);
1219 codec = map_video_format(v->d_callbacks->format, CM_RD);
1221 v->codec = avcodec_find_decoder(codec);
1223 ast_log(LOG_WARNING,
"Unable to find the decoder for format %d\n", codec);
1224 return dec_uninit(v);
1229 v->dec_ctx = avcodec_alloc_context();
1231 ast_log(LOG_WARNING,
"Cannot allocate the decoder context\n");
1232 return dec_uninit(v);
1235 if (avcodec_open(v->dec_ctx, v->codec) < 0) {
1236 ast_log(LOG_WARNING,
"Cannot open the decoder context\n");
1237 av_free(v->dec_ctx);
1239 return dec_uninit(v);
1242 v->parser = av_parser_init(codec);
1244 ast_log(LOG_WARNING,
"Cannot initialize the decoder parser\n");
1245 return dec_uninit(v);
1248 v->d_frame = avcodec_alloc_frame();
1250 ast_log(LOG_WARNING,
"Cannot allocate decoding video frame\n");
1251 return dec_uninit(v);
1253 v->dec_in_cur = &v->dec_in[0];
1254 v->dec_in_dpy = NULL;
Asterisk main include file. File version handling, generic pbx functions.
#define ast_realloc(p, len)
A wrapper for realloc()
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
struct ast_frame_subclass subclass
Asterisk internal frame definitions.
union ast_frame::@224 data
#define ast_calloc(num, len)
A wrapper for calloc()
Data structure associated with a single frame of data.
enum ast_frame_type frametype