Help with Codec Negotiation (406 Error)

[DeborahSilliS]

Hello everyone, how are you?

I'm new to SIPSorcery and would appreciate some guidance on how to select the best codec for a call. At the moment, I can only negotiate and select PCMU and PCMA codecs.

I ran a test by dialing into my application using MicroSIP, where I configured it to use G722. On my application, I forced the use of G722 as well, but the call never even reached my application. However, when I added support for G711 (PCM), the call did reach my application, but I received a "406 Not Acceptable" error due to incompatible audio codecs.

Could anyone guide me on how to properly handle codec negotiation and resolve this issue?

Thank you!

[sipsorcery]

Here's an example of how you can restrict codecs offered and accepted.

[DeborahSilliS]

This is my RTPFactory class:

using System;
using SIPSorcery.Media;
using SIPSorceryMedia.Abstractions;
using SIPSorceryMedia.Windows;

public static class RTPFactory
{
    public static VoIPMediaSession CreateRtpSession(int outputDeviceIndex)
    {
        var audioEncoder = new AudioEncoder();
        var winAudio = new WindowsAudioEndPoint(audioEncoder, outputDeviceIndex);

        winAudio.RestrictFormats(x => x.Codec == AudioCodecsEnum.G722);

        var rtpAudioSession = new VoIPMediaSession(winAudio.ToMediaEndPoints());
        rtpAudioSession.AcceptRtpFromAny = true;

        rtpAudioSession.OnAudioFormatsNegotiated += (audioFormats) =>
        {
            Console.WriteLine($"Negotiated {audioFormats.Count} audio formats.");
            foreach (var format in audioFormats)
            {
                Console.WriteLine($"- Codec: {format.Codec}, ClockRate: {format.ClockRate}");
            }

            var selectedFormat = audioFormats.First();
            Console.WriteLine($"Selected codec: {selectedFormat.Codec}, ClockRate: {selectedFormat.ClockRate}");
        };

        rtpAudioSession.OnTimeout += (mediaType) =>
        {
            Console.WriteLine($"RTP timeout detected. Ending call.");
        };

        return rtpAudioSession;
    }
}

Here are the screenshots of the issue I’m encountering:

In MicroSIP, I configured it to use G722, and in my application, I forced the use of G722 by applying RestrictFormats. However, the call doesn’t even reach my application and results in a "Not Acceptable Here" error. When I added G711 (PCM) to my application, the call successfully reached it, but then I received a "406 Not Acceptable" error due to incompatible audio codecs.

[DeborahSilliS]

Just to clarify, I’m not adding G711 to my application but to MicroSIP. When I configure MicroSIP to use G711, the call does reach my application, but then I get a "406 Not Acceptable" error due to incompatible audio codecs.

[sipsorcery]

Are you sure your SIP UAS code is using your RTPFactory? Can you post the code where it gets used. If you don't get the order right the UAS does not know which codecs you're supporting at the RTP level and you'll get the error response you're seeing.

[DeborahSilliS]

Sorry for the delay in responding! I implemented the setup following the example provided. Here's the code I'm using for my SIP UAS implementation. It utilizes RTPFactory through the VoIPMediaSession object in combination with WindowsAudioEndPoint. Specifically, the codecs are restricted to PCMA as shown below:

var audioSession = new WindowsAudioEndPoint(new AudioEncoder());
audioSession.RestrictFormats(x => x.Codec == AudioCodecsEnum.G722);

var rtpSession = new VoIPMediaSession(audioSession.ToMediaEndPoints());

The incoming call is handled like this:

userAgent.OnIncomingCall += async (ua, req) =>
{
    var uas = userAgent.AcceptCall(req);

    await Task.Delay(500);

    await userAgent.Answer(uas, rtpSession);

    if (userAgent.IsCallActive)
    {
        await rtpSession.Start();
    }
};

Below is the full block of code that I'm currently using to learn and experiment with SIP UAS implementation:

using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Console;
using SIPSorcery.Media;
using SIPSorcery.Net;
using SIPSorcery.SIP;
using SIPSorcery.SIP.App;
using SIPSorceryMedia.Abstractions;
using SIPSorceryMedia.Windows;

namespace SipMultiThread
{
    class Program
    {
        private static Microsoft.Extensions.Logging.ILogger Log = null!;

        static void Main(string[] args)
        {
            Console.WriteLine("SIP Multi-threaded Example");

            Log = AddConsoleLogger();

            var sipAccounts = LoadSipAccounts("config.json");

            Console.WriteLine(sipAccounts.Count);

            if (sipAccounts == null || sipAccounts.Count == 0)
            {
                Log.LogError("No SIP accounts found in the configuration file.");
                return;
            }

            var threads = new List<Thread>();

            foreach (var account in sipAccounts)
            {
                var thread = new Thread(() => RunSipClient(account, Log));
                thread.Start();
                threads.Add(thread);
            }

            while (true)
            {
                bool allThreadsFinished = true;
                foreach (var thread in threads)
                {
                    if (thread.IsAlive)
                    {
                        allThreadsFinished = false;
                    }
                }

                if (allThreadsFinished)
                {
                    Console.WriteLine("Todas as threads finalizaram. Encerrando aplicação.");
                    break;
                }

                Thread.Sleep(1000);
            }
        }

        private static List<SipAccount> LoadSipAccounts(string filePath)
        {
            try
            {
                var json = File.ReadAllText(filePath);
                return JsonSerializer.Deserialize<List<SipAccount>>(json) ?? new List<SipAccount>();
            }
            catch (Exception ex)
            {
                Log?.LogError($"Error reading configuration file: {ex.Message}");
                return new List<SipAccount>();
            }
        }

        private static void RunSipClient(SipAccount account, Microsoft.Extensions.Logging.ILogger Log)
        {
            Console.WriteLine($"Starting SIP client for {account.SIPUsername}");
            var sipTransport = new SIPTransport();

            try
            {
                sipTransport.AddSIPChannel(new SIPUDPChannel(new System.Net.IPEndPoint(System.Net.IPAddress.Any, account.ListenPort)));
                sipTransport.EnableTraceLogs();

                var regUserAgent = new SIPRegistrationUserAgent(sipTransport, account.SIPUsername, account.SIPPassword, "192.168.120.209", account.RegistrationExpiry);
                regUserAgent.Start();

                var audioSession = new WindowsAudioEndPoint(new AudioEncoder());
                audioSession.RestrictFormats(x => x.Codec == AudioCodecsEnum.G722);

                var rtpSession = new VoIPMediaSession(audioSession.ToMediaEndPoints());

                var userAgent = new SIPUserAgent(sipTransport, null);

                userAgent.OnIncomingCall += async (ua, req) =>
                {
                    Log.LogInformation($"Incoming call for {account.SIPUsername} from {req.Header.From.FromURI}");

                    var uas = userAgent.AcceptCall(req);

                    await Task.Delay(500);

                    await userAgent.Answer(uas, rtpSession);

                    if (userAgent.IsCallActive)
                    {
                        Console.WriteLine($"[{account.SIPUsername}] Chamada atendida. Aguardando desligamento...");
                        await rtpSession.Start();
                    }
                };

                var exitEvent = new ManualResetEvent(false);
                Console.CancelKeyPress += (sender, e) =>
                {
                    e.Cancel = true;
                    Console.WriteLine($"[{account.SIPUsername}] Encerrando...");
                    exitEvent.Set();
                };

                exitEvent.WaitOne();

                regUserAgent.Stop();
                sipTransport.Shutdown();
            }
            catch (Exception ex)
            {
                Log.LogError($"Error for account {account.SIPUsername}: {ex.Message}");
            }
            finally
            {
                sipTransport.Shutdown();
            }
        }

        private static Microsoft.Extensions.Logging.ILogger AddConsoleLogger()
        {
            var loggerFactory = LoggerFactory.Create(builder =>
            {
                builder.AddConsole();
            });

            return loggerFactory.CreateLogger<Program>();
        }

        public class SipAccount
        {
            public string SIPServer { get; set; } = string.Empty;
            public string SIPUsername { get; set; } = string.Empty;
            public string SIPPassword { get; set; } = string.Empty;
            public int ListenPort { get; set; } = 5060;
            public int RegistrationExpiry { get; set; } = 120;
            public int AudioOutputDeviceIndex { get; set; } = 0;
        }
    }
}

[sipsorcery]

If you want to restrict the codecs to only PCMA you need to set it as the only allowed codec. In your example you're restricting support to G722.

audioSession.RestrictFormats(format => format.Codec == AudioCodecsEnum.PCMA);