Choppy sound when converting g711 packets to wave file

Question

I'm getting packets from a SIP call using Sharppcap library. So far, so good. But, when I join those packets (G.711 Alaw packets inside a MemoryStream) and convert it with the AlawDecoder dll I got from https://www.codeproject.com/Articles/14237/Using-the-G711-standard and write the Wav file with the decoded array byte, I can listen to the record, but it sounds choppy and slow. I'm new to audio programming, so I don't have a lot of experience. Below, snippets from the code I'm writing to achieve this:

private static void Device_OnPacketArrival(object sender, CaptureEventArgs e)
    {
        var time = e.Packet.Timeval.Date.AddHours(-3);
        var len = e.Packet.Data.Length;
        


        var packet = PacketDotNet.Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
        var device = sender as ICaptureDevice;
        var tcpPacket = packet.Extract<PacketDotNet.TcpPacket>();
        var udpPacket = packet.Extract<PacketDotNet.UdpPacket>();

        if (udpPacket != null)
        {
            var ipPacket = (PacketDotNet.IPPacket)udpPacket.ParentPacket;
            System.Net.IPAddress srcIp = ipPacket.SourceAddress;
            System.Net.IPAddress dstIp = ipPacket.DestinationAddress;
            int srcPort = udpPacket.SourcePort;
            int dstPort = udpPacket.DestinationPort;
            byte[] udpHeaderData = udpPacket.HeaderData;
            byte[] udpPayloadData = udpPacket.PayloadData;
            string decodedUdpPayloadData = Encoding.UTF8.GetString(udpPayloadData);

            if (decodedUdpPayloadData.Contains("m=audio"))
            {
                FindRTPAudioPort(device, decodedUdpPayloadData);
            }
            else if (device.Filter != "udp port 5060")
            {
                RtpPacketsToWave(device, udpPayloadData);
            }
            else
            {
                Console.WriteLine("{0}:{1}:{2},{3} Len={4} {5}:{6} -> {7}:{8} UDP Packet " +
                "\n {9} \n Hex DUMP: {10} \n",
                time.Hour, time.Minute, time.Second, time.Millisecond, len,
                srcIp, srcPort, dstIp, dstPort,
                decodedUdpPayloadData,
                BitConverter.ToString(udpPayloadData));
            }
        }
        else if (tcpPacket != null)
        {
            var ipPacket = (PacketDotNet.IPPacket)tcpPacket.ParentPacket;
            System.Net.IPAddress srcIp = ipPacket.SourceAddress;
            System.Net.IPAddress dstIp = ipPacket.DestinationAddress;
            int srcPort = tcpPacket.SourcePort;
            int dstPort = tcpPacket.DestinationPort;


            Console.WriteLine("{0}:{1}:{2},{3} Len={4} {5}:{6} -> {7}:{8}",
                time.Hour, time.Minute, time.Second, time.Millisecond, len,
                srcIp, srcPort, dstIp, dstPort);
        }
        else
        {
            Console.WriteLine("\n");
        }
    }

    private static void RtpPacketsToWave(ICaptureDevice dev, byte[] payloadData)
    {
        try
        {

            MemoryStreamSingleton memoryStreamSingleton = MemoryStreamSingleton.GetInstance();
            MemoryStream memStream;
            byte[] headlessPayloadData = new byte[160];
            if (payloadData.Length == 172)
            {
                //Skips first 12 bytes containing the packet header
                headlessPayloadData = payloadData.Skip(12).ToArray();
                memStream = new MemoryStream(headlessPayloadData);
                memStream.CopyTo(memoryStreamSingleton);
            }
            Console.WriteLine("Payload length: {0}", headlessPayloadData.Length);
            Console.WriteLine(memoryStreamSingleton.Length);
            if(memoryStreamSingleton.Length > 600000)
            {
                WaveFileGenerator(memoryStreamSingleton.ToArray());
                dev.StopCapture();
            }
        }
        catch (Exception ex)
        {

            Console.WriteLine(ex.ToString());
        }
        
    }

    private static void WaveFileGenerator(byte[] buffer)
    {
        try
        {
          
            Console.WriteLine("Device closed, generating audio file..");
            WaveFormat waveFormat = new WaveFormat(8000, 16, 1);

            short[] pcm16bit = ALawDecoder.ALawDecode(buffer);
            byte[] result1 = new byte[pcm16bit.Length * sizeof(short)];
            Buffer.BlockCopy(pcm16bit, 0, result1, 0, result1.Length);
            

            var outputWave = new WaveFileWriter(@"tmp/test.wav", waveFormat);
            outputWave.Write(result1, 0, result1.Length);
            outputWave.Close();
            var waveFileProvider = new WaveFileReader(@"tmp/test.wav");
            MonoToStereoProvider16 toStereo = new MonoToStereoProvider16(waveFileProvider);
            WaveFileWriter.CreateWaveFile("test.wav", toStereo);
            waveFileProvider.Dispose();
            File.Delete(@"tmp/test.wav");
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
            File.WriteAllText("log.txt", ex.ToString());
        }
    }

I can't understand what I'm missing...

Answer 1

You may be missing packets due to excessive time spent in the receive function resulting in packets overflowing internal buffers.

Any extra processing in the receive routine, including printing, can result in packet loss in situations where there is a large number of packets being captured.

To help reduce the time spent in that routine and maximize the packet rate you can queue packets for processing in a background thread.

There is an example of how to queue and process packets via a background thread in the SharpPcap examples, you can find the example at https://github.com/chmorgan/sharppcap/blob/master/Examples/QueuingPacketsForBackgroundProcessing/Program.cs

With the queue approach the receive routine exits very quickly, enabling a very high rate of packets to be handled without loss.

In addition you could add a queue size check to confirm that the background thread is keeping up with the incoming packet rate.

One approach to reduce incoming packet rates is to use network packet filters (that run in the OS or driver layer) and only include potential SIP packets. I'm not familiar with SIP but if you have more info I can try to help. Your code appears to be using filters but it isn't clear what occurs in the case where a SIP stream is found, are you filtering to include only that port in that case?

Let me know if this helps reduce or eliminate the choppy sound.