RTSP转WebSocket实现H5实时播放

服务端使用C++/CLR包装EasyRTSPClient实现RTSP播放。播放不产生画面，而是转换成JPEG图像通过WEBSOCKET发送到浏览器端。

服务端（C++ & C#）：

浏览器端（实时性不错！）：

内存使用情况：播放一路视频时占用39M内存。空闲时(无客户端)时自动关闭RTSP播放后内存占用为18MB.

关于WebSocket通讯，服务端向浏览器发送二进制帧，每一帧为一张JPEG图像。

 可以看出Websocket播放的帧率为12帧。源码流也是12帧（使用海康威视相机H264子码流）.每帧71KB.改变JPEG压缩质量可以更小，但更模糊。当前使用的压缩质量为0.6

服务端WebSocket代码(使用WebSocketSharp)，C#：

    public class WebSocketPlayBehavior : WebSocketBehavior, IClient {

        static List<WebSocketPlayBehavior> client = new List<WebSocketPlayBehavior>();
        public static int[] InPlayChannel() {
            return client.Select(x => x.ChannelId)
                .Distinct()
                .ToArray();
        }

        public int ChannelId {
            get;
            private set;
        }
        private string clientEP = null;
        public PlayServiceWork Service = null;
        public WebSocketPlayBehavior() {
            this.OriginValidator = (p) => {
                System.Diagnostics.Debug.Print("OriginValidator:{0}", p);
                return true;
            };
        }
        protected override void OnOpen() {
            base.OnOpen();
            #region 获取参数（this.ChannelId）
            {
                var PARAM = this.Context.RequestUri.PathAndQuery.Split('?')
                     .LastOrDefault()
                     .Split('&')
                     .Select(x => x.Split('='))
                     .Where(x => x.Length > 1)
                     .ToDictionary(x => x[0].ToLower(), x => System.Net.WebUtility.UrlDecode(x[1])); //WebSocketSharp.Ext.UrlDecode

                int tempid = 1;
                if (PARAM.TryGetValue("channel", out var value)) {
                    if (Regex.IsMatch(value, "^\d+$"))
                        tempid = Convert.ToInt32(value);
                    else {
                        var index = RtpConfig.Get().Items.FindIndex(x => string.Equals(x.Name, value));
                        if (index > -1) tempid = index + 1;
                    }
                }
                this.ChannelId = Math.Max(1, tempid);
            }
            #endregion
            Service.PlayOneIfNotExist(this.ChannelId - 1);

            clientEP = this.Context.UserEndPoint.ToString();
            LEI.NLog.Logger.i("建立WS连接	播放客户端[{0}] <--> [通道:{1}]", clientEP, ChannelId);
            client.Add(this);
            RPlayer.AddClient(this);
        }
        protected override void OnClose(CloseEventArgs e) {
            LEI.NLog.Logger.i("关闭WS连接	播放客户端[{0}] <--> [通道:{1}]", clientEP, ChannelId);
            base.OnClose(e);
            RPlayer.DelClient(this);
            client.Remove(this);
        }


        public int GetChannelId() => ChannelId;
        private bool insend = false;
        private object lck = new object();
        public void SendImage(byte[] bufferImage) {
            lock (lck) {
                if (insend)
                    return;
                insend = true;
            }

            try {
                this.SendAsync(bufferImage, (completed) => {
                    insend = false;
                });
            } catch (Exception e) {
                insend = false;
                LEI.NLog.Logger.e("发送图片失败：{0}", e.Message);
                //if (this.State == WebSocketState.Closed)
                //    this.OnClose(null);
            }
        }


    }

服务端YUV帧图像转JPEG图像代码（JPEG为转换后的图像）,C++：

// 抓图函数实现
int take_snapshot(int w, int h, uint8_t *buffer, AVPixelFormat Format,PBYTE JPEG)
{
     
    //MessageLog("take_snapshot");
    char              *fileext = NULL;
    enum AVCodecID     codecid = AV_CODEC_ID_NONE;
    struct SwsContext *sws_ctx = NULL;
    AVPixelFormat      swsofmt = AV_PIX_FMT_NONE;
    AVFrame            picture = {};
    int                ret     = -1;

    AVFormatContext   *fmt_ctxt   = NULL;
    AVOutputFormat    *out_fmt    = NULL;
    AVStream          *stream     = NULL;
    AVCodecContext    *codec_ctxt = NULL;
    AVCodec           *codec      = NULL;
    AVPacket           packet     = {};
    int                retry      = 8;
    int                got        = 0;

    // init ffmpeg
    av_register_all();

    //fileext = file + strlen(file) - 3;
    //if (_stricmp(fileext, "png") == 0) {
    //    codecid = AV_CODEC_ID_APNG;
    //    swsofmt = AV_PIX_FMT_RGB24;
    //}
    //else 
    {
        codecid = AV_CODEC_ID_MJPEG;
        swsofmt = AV_PIX_FMT_YUVJ420P;
    }

    AVFrame video;
    int numBytesIn;
    numBytesIn = av_image_get_buffer_size(Format, w, h, 1);
    av_image_fill_arrays(video.data, video.linesize, buffer, Format, w, h, 1);
    video.width = w;
    video.height = h;
    video.format = Format;

    // alloc picture
    picture.format = swsofmt;
    picture.width  = w > 0 ? w : video.width;
    picture.height = h > 0 ? h : video.height;

    int numBytes = av_image_get_buffer_size(swsofmt, picture.width, picture.height , 1);

    buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));

    av_image_fill_arrays(picture.data, picture.linesize, buffer, swsofmt, picture.width, picture.height, 1);

    // scale picture
    sws_ctx = sws_getContext(video.width, video.height, (AVPixelFormat)Format/*video->format*/,
        picture.width, picture.height, swsofmt, SWS_FAST_BILINEAR, NULL, NULL, NULL);
    if (!sws_ctx) {
        //MessageLog("could not initialize the conversion context jpg");
        ////av_log(NULL, AV_LOG_ERROR, "could not initialize the conversion context jpg
");
        goto done;
    }
    sws_scale(sws_ctx, video.data, video.linesize, 0, video.height, picture.data, picture.linesize);

    // do encoding
    fmt_ctxt = avformat_alloc_context();
    out_fmt  = av_guess_format("mjpeg", NULL, NULL);
    fmt_ctxt->oformat = out_fmt;
    if (!out_fmt) { 
        goto done;
    }

    
    if (
        avio_open_dyn_buf(&fmt_ctxt->pb)
        //avio_open(&fmt_ctxt->pb, file, AVIO_FLAG_READ_WRITE)
        < 0) { 
        goto done;//MessageLog("failed to open output fi");
    }

    stream = avformat_new_stream(fmt_ctxt, 0);
    if (!stream) { 
        goto done;    //MessageLog("failed to create a new stream ");
    }

    codec_ctxt                = stream->codec;
    codec_ctxt->codec_id      = out_fmt->video_codec;
    codec_ctxt->codec_type    = AVMEDIA_TYPE_VIDEO;
    codec_ctxt->pix_fmt       = swsofmt;
    codec_ctxt->width         = picture.width;
    codec_ctxt->height        = picture.height;
    codec_ctxt->time_base.num = 1;
    codec_ctxt->time_base.den = 25;
    codec_ctxt->qcompress = CChannelManager::JPEG_LEVEL;//压缩质量
    codec_ctxt->qmin = 2;
    codec_ctxt->qmax = 31;
    codec_ctxt->max_qdiff = 15;

    codec = avcodec_find_encoder(codec_ctxt->codec_id);
    if (!codec)  
        goto done;    //MessageLog("failed to find encoder"); 

    if (avcodec_open2(codec_ctxt, codec, NULL) < 0)  
        goto done;//MessageLog("failed to open encoder"); 


    while (retry-- && !got) {
        if (avcodec_encode_video2(codec_ctxt, &packet, &picture, &got) < 0) { 
            goto done;//MessageLog("failed to do picture encoding");
        }

        if (got) {
            ret = avformat_write_header(fmt_ctxt, NULL);
            if (ret < 0) { 
                goto done;    //MessageLog("error occurred when opening output file");
            }
            av_write_frame(fmt_ctxt, &packet);
            av_write_trailer(fmt_ctxt);
        }
    }

    // ok
    ret = 0;

done: 
    avcodec_close(codec_ctxt);
    if (fmt_ctxt) {
        //avio_close(fmt_ctxt->pb);
        PUCHAR output; 
        ret = avio_close_dyn_buf(fmt_ctxt->pb, &output); 
        if (ret > 0) {
            memcpy_s(JPEG, ret, output, ret);
            av_freep(&output);
        }
        avformat_free_context(fmt_ctxt);
    }
    av_packet_unref(&packet);
    sws_freeContext(sws_ctx);
    av_free(buffer);

    return ret;
}

EasyRTSPClient的代码就不展示了，网上很多！