在来自 SO 的一些好人的帮助下，我慢慢地构建了一个小型 P2P 应用程序，可以发送和接收每张约 4kb 的图像流。

在 127.0.0.1 上，接收跟上发送，但是当我在远程机器上尝试时，在我看来接收跟不上，我可能发送了 6 张图像，但接收者到目前为止只收到了一张。 .. 随着时间的推移，差异越来越大，直到你在另一个屏幕上看到整整一分钟前的自己。值得注意的是，我希望它能在另一个国家/地区的大约 64kbps-100kbps 的连接上正常工作，那里的 ping 时间可能非常长，如 250 毫秒或更长。

我有哪些同步选项？

我的兄弟告诉我一个简单的解决方案，即实现 1:1 发送/接收。所以我只在收到图像时发送图像。

由于我是网络编程的初学者，欢迎任何其他提示，这是我的完整代码:

namespace MyPrivateChat
{
    using System;
    using System.Drawing;
    using System.Windows.Forms;
    using AForge.Video;
    using AForge.Video.DirectShow;
    using System.Drawing.Imaging;
    using System.IO;
    using System.Net;
    using System.Text.RegularExpressions;
    using System.Net.Sockets;
    using System.Diagnostics;
    using AForge.Imaging.Filters;

    public partial class fChat : Form
    {
        public fChat()
        {
            InitializeComponent();
        }
        private void fChat_Load(object sender, EventArgs e)
        {
            // get ip
            _ownExternalIp = GetPublicIP();
            Text = "My Private Chat - IP: " + _ownExternalIp;

            // get video cam
            var _videoDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
            if (_videoDevices.Count != 0)
            {
                _videoDevice = new VideoCaptureDevice(_videoDevices[0].MonikerString);
                btnStart.Enabled = true;
            }

            // fire up listener
            listeningThread.RunWorkerAsync();
        }
        public string GetPublicIP()
        {
            string ip = "";
            using (WebClient wc = new WebClient())
            {
                Match m = Regex.Match(wc.DownloadString("http://checkip.dyndns.org/"), @"(?<IP>\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3})");
                if (m.Success)
                {
                    ip = m.Groups["IP"].Value;
                }
            }
            return ip;
        }
        private void mnuPasteOwnIP_Click(object sender, EventArgs e)
        {
            txtPartnerIP.Text = _ownExternalIp;
        }
        private void btnStart_Click(object sender, EventArgs e)
        {
            if (_tcpOut == null)
            {
                // tcp server setup
                _tcpOut = new TcpClient();
                _tcpOut.Connect(txtPartnerIP.Text, 54321);
                tmrLive.Enabled = true;
            }
            else
            {
                tmrLive.Enabled = false;
                _tcpOut.Client.Disconnect(true);
                _tcpOut.Close();
                _tcpOut = null;
            }

            if (!_videoDevice.IsRunning)
            {
                _videoDevice.NewFrame += new NewFrameEventHandler(NewFrameReceived);
                _videoDevice.DesiredFrameSize = new Size(640, 480);
                _videoDevice.DesiredFrameRate = 100;
                _videoDevice.Start();
                btnStart.Text = "Stop";
            }
            else
            {
                _videoDevice.SignalToStop();
                btnStart.Text = "Start";
            }
        }
        private void NewFrameReceived(object sender, NewFrameEventArgs e)
        {
            Bitmap img = (Bitmap)e.Frame.Clone();
            byte[] imgBytes = EncodeToJpeg(img, 25).ToArray();

            if (_tcpOut.Connected)
            {
                NetworkStream ns = _tcpOut.GetStream();
                if (ns.CanWrite)
                {
                    ns.Write(BitConverter.GetBytes(imgBytes.Length), 0, 4);
                    ns.Write(imgBytes, 0, imgBytes.Length);
                    _totalFramesSent++;
                }
            }
        }
        private void listeningThread_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            _tcpIn = new TcpListener(IPAddress.Any, 54321);
            _tcpIn.Start();

            TcpClient _inClient = _tcpIn.AcceptTcpClient();
            lblStatus.Text = "Connected - Receiving Broadcast";
            tmrLive.Enabled = true;

            NetworkStream ns = _inClient.GetStream();
            while (true)
            {
                // read image size. 
                Byte[] imgSizeBytes = new Byte[4];
                int totalBytesRead = 0;
                do
                {
                    int bytesRead = ns.Read(imgSizeBytes, totalBytesRead, 4 - totalBytesRead);
                    if (bytesRead == 0)
                    {
                        break; // problem
                    }
                    totalBytesRead += bytesRead;
                } while (totalBytesRead < 4);

                // read image
                int imgSize = BitConverter.ToInt32(imgSizeBytes, 0);
                Byte[] imgBytes = new Byte[imgSize];
                totalBytesRead = 0;
                do
                {
                    int bytesRead = ns.Read(imgBytes, totalBytesRead, imgSize - totalBytesRead);
                    if (bytesRead == 0)
                    {
                        break; // problem
                    }
                    totalBytesRead += bytesRead;
                } while (totalBytesRead < imgSize);

                picVideo.Image = Image.FromStream(new MemoryStream(imgBytes));
                _totalFramesReceived++;
            }
        }
        private void CloseVideoDevice()
        {
            if (_videoDevice != null)
            {
                if (_videoDevice.IsRunning)
                {
                    _videoDevice.SignalToStop();
                }
                _videoDevice = null;
            }
        }
        private void fChat_FormClosing(object sender, FormClosingEventArgs e)
        {
            CloseVideoDevice();
        }
        private void btnClose_Click(object sender, EventArgs e)
        {
            Close();
        }
        private void tmrLive_Tick(object sender, EventArgs e)
        {
            _totalSecondsLive++;
            lblStats.Text = "S:"+_totalFramesSent + " R:" + _totalFramesReceived + " T:"+ _totalSecondsLive;
            if (_totalSecondsLive == 60)
            {
                MessageBox.Show("Total Frames : " + _totalFramesSent);
            }
        }

        #region ENCODING JPEG

        private MemoryStream EncodeToJpeg(Bitmap img, long quality)
        {
            using (EncoderParameters myEncoderParameters = new EncoderParameters(1))
            {
                MemoryStream ms = new MemoryStream();
                myEncoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, quality);
                img.Save(ms, GetEncoder(ImageFormat.Jpeg), myEncoderParameters);
                return ms;
            }
        }
        private ImageCodecInfo GetEncoder(ImageFormat format)
        {
            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
            foreach (ImageCodecInfo codec in codecs)
            {
                if (codec.FormatID == format.Guid)
                {
                    return codec;
                }
            }
            return null;
        }

        #endregion

        VideoCaptureDevice _videoDevice;
        TcpClient _tcpOut;
        TcpListener _tcpIn;
        string _ownExternalIp;
        int _totalFramesSent;
        int _totalFramesReceived;
        int _totalSecondsLive;
    }
}

最佳答案

好吧，这不是 TCP 特定的问题。你生产的速度快于你消费的速度。因此，您需要限制生产者。

在发送下一张图片之前，我会更改生产者以等待消费者的确认。在此期间，我会丢弃所有新图像。

在生产者上，您会保留一个状态标志，它允许您跟踪帧是否已发送和是否未被确认。当此标志为真时，您会在新图像出现时丢弃它们。当它为 false 时，您发送图像并将其设置为 true。当收到确认时，您将标志设置为 false。

编辑:我会将确认实现为“bool”(网络上的一个字节)，因为这比发送图像作为响应要快得多。我会定义两个“消息”:MessageType.Image 和 MessageType.Acknowledgement。然后接收方可以看到到达的消息类型，并更新屏幕或开始发送下一张图像。

编辑 2:您不需要只丢弃图像。您可以有一个变量 Image latestUnsentImage。当 cam 生成图像时，您无条件地覆盖此变量。当您需要发送图像时，您只需访问此变量即可。这将始终发送最新的可用和未发送的图像。

关于c# - TCP 发送简单的洪水控制和同步 - P2P 网络摄像头，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8848434/