服务器未收到所有消息

Question

I have 2 computers: I would call them Comp A, Comp B;

I have to:

1. send a sound file of PCM format from Comp А to the Comp B;
2. verify how precisely this file was transmitted;
3. play what I sent to the Comp B on the Comp B.

To send the file I use the function

socket.SendTo(packet,0,count,SocketFlags.None,remoteEP);

from System.Net.Sockets .

As a result I concluded that the file was being transmitted precisely. I monitor it using Wireshark on Comp A and Comp B. However packets of bytes coming to the Comp B, don't coincide at all with the file being transmitted.

The program which sends data of the file, opens this file in a right way. Then it passes right bytes of the source PCM file to the function Socket.SendTo(...) . But Wireshark of Comp A (output) displays absolutely incorrect bytes ie Comp A sends incorrect bytes.

What could be the problem?

---

I figured out that function socket.SendTo(packet,0,count,SocketFlags.None,remoteEP); sends correct bytes if I send them with a delay. I mean I can send 400 bytes (without loops) and my program sends 400 absolutely precise, correct bytes.

But I have a big PCM file. Its size is about 50 Mb. Its duration is 1 minute. I have to send this file during a minute so that this file would be transmitted evenly, uniformly. It means about 800 Kb needs to be transmitted per a second.
So here is my program code. I send every 800 Kb per second using timer function being called 2 times per second.

private void m_pTimer_Tick(object sender,EventArgs e)  
{  
    uint sent_data = 0;

    while ((sent_data <= (BUFFERSIZE / 120)) && ((num * RAW_PACKET) + sent_data  < BUFFERSIZE))
    {
        uint bytes_count = ((BUFFERSIZE - (RAW_PACKET * num)) > RAW_PACKET) ? RAW_PACKET : (BUFFERSIZE - (RAW_PACKET * num));
        byte[] buffer = new byte[bytes_count];
        Array.Copy(ReadBuffer, num * RAW_PACKET, buffer, 0, bytes_count);
        num++;

        // Send and read next.
        m_pUdpServer.SendPacket(buffer, 0, Convert.ToInt32(bytes_count), m_pTargetEP);
        sent_data += bytes_count;
    }

    if ((num * RAW_PACKET) + sent_data == BUFFERSIZE)
    {
        m_pTimer.Enabled = false;
    }
    m_pPacketsReceived.Text = m_pUdpServer.PacketsReceived.ToString();
    m_pBytesReceived.Text   = m_pUdpServer.BytesReceived.ToString();
    m_pPacketsSent.Text     = m_pUdpServer.PacketsSent.ToString();
    m_pBytesSent.Text       = m_pUdpServer.BytesSent.ToString();
}

If I call a function m_pUdpServer.SendPacket(buffer, 0, Convert.ToInt32(bytes_count), m_pTargetEP); without a timer or any loops(while, etc.) I see correct result on output.

Well here 120 - a number of file parts that are being transmitted for a period of every timer function call. The timer function is called 2 times per second.

• BUFFERSIZE is a total file size.
• ReadBuffer is an array that contains all PCM file data.
• RAW PACKET = 400 bytes.
• sent_data is a total byte count being sent within every timer function call.
• num is a total count of sent packets.

I suppose there is too many packets(bytes) to be sent within a timer function call. Therefore I see incorrect values on output.

So what is a solution of this problem?

I think I can make up a RTP packet (to add a sequence number to every sent packet). It will help me to identify received packets and to make up a correct sequence of received packets. It can help me if received packets have a correct byte sequence. Because if received packets have a mixed byte order(sequence) I don't understand how to restore a correct byte sequence in every received packet.

I was advised to refuse the timer call and to send packets evenly, uniformly using a synchronization by time. Actually I don't know how to do it. Maybe I should use threads, pool of threads or something like that. What do you think?

Answer 1

The only guarantee UDP gives you is that the entire message is delivered. However, if you send piece 1,2,3,4 in order they may be received in any order, for instance 4132. That is, UDP do not guarantee ordering.

You MUST include a sequence number to be able to store the PCM correctly.

UDP do not guarantee delivery either. If the server receive piece #4 but not #5 within X seconds it should probably request that piece again.

Or you'll just switch to TCP. Much easier. All you need is some way to tell the length of the file and then just transfer it.