Click here to Skip to main content
12,555,044 members (54,587 online)
Click here to Skip to main content
Add your own
alternative version


95 bookmarked

Using the Asterisk IAXClient library in C#

, 13 Nov 2006 CPOL
Rate this:
Please Sign up or sign in to vote.
A C# wrapper for the Asterisk IAXClient library.



Asterisk is a complete open source PBX software, originally written by Marl Spencer of Digium, Inc., and tested and improved by open-source coders around the world. The Inter-Asterisk eXchange (IAX) protocol, used in Asterisk, enables VoIP connections between Asterisk servers and clients.

To interact with the IAX protocol, you can use a C++ portable client library called IAXClient that enables anyone who wants to communicate to Asterisk servers calling exported functions. These functions handle the telephony operations including call handling, network protocols, and audio encoding/decoding. The library is designed to be built in multiple platforms using CygWin shell and, to use it in Win32, you must create a DLL file using the GCC compiler and some CygWin tools. In this article, I'll show:

  • The main functions and structures used in IAXClient.
  • How to use it in C# using P/Invoke.
  • How to compile it.

IAXFunctions class


To use IAXClient functions in C#, we need to use the Platform Invoke (P/Invoke) service. This service enables managed code calls to unmanaged functions in DLLs, and in C#, we need to create a static class that holds the main IAXClient functions.

Simple parameters

The IAXFunction class has the most important functions converted to C# types. Some functions have primitive types, and can be converted directly. For example, the function iaxc_initialize accepts two integer parameters and returns an integer value:

EXPORT int iaxc_initialize(int audType, int nCalls);

In C#, we use the [DLLImport] attribute (DllImportName is a constant having the DLL path):

[DllImport(DllImportName, CallingConvention = CallingConvention.StdCall)]
public static extern int iaxc_initialize(int audType, int calls);

Other functions have character parameters that must be converted to C# types. For example, the function iaxc_register accepts two char pointer parameters and returns an integer value:

EXPORT int iaxc_register(char *user, char *pass, char *host);

In C#, this kind of a parameter can be converted to string but you need to set the MarshalAs attribute:

public static extern int iaxc_register(
[MarshalAs(UnmanagedType.LPStr)] string user, 
[MarshalAs(UnmanagedType.LPStr)] string pass,
[MarshalAs(UnmanagedType.LPStr)] string host);

The MarshalAs tells C# how to marshal the data to the unmanaged function, and you need to set it according to the parameter type. In this case, the UnmanagedType enumeration used is LPStr, indicating that we have a null-terminated ANSI character string from unmanaged code.

Struct parameters

You can pass and receive structure parameters using the MarshalAs attribute with the UnmanagedType.LPStruct enumeration, but in the function iaxc_audio_devices_get, we need special care. Look at the function signature:

EXPORT int iaxc_audio_devices_get(struct iaxc_audio_device **devs, 
       int *nDevs, int *input, int *output, int *ring);

The function needs a pointer to a pointer parameter (indicated by **). C# doesn't have a UnmanagedType option to use with this kind of a parameter, and we need a workaround here:

[DllImport(DllImportName, CallingConvention = CallingConvention.StdCall)]
public static extern int iaxc_audio_devices_get(
    ref IntPtr devs, 
    ref int nDevs, 
    ref int input, 
    ref int output, 
    ref int ring);

The IntPtr type is a specific type that represents a pointer, and we can use it to represent the 'a pointer' part of the parameter. The first part, 'a pointer to' can be achieved using the ref parameter attribute, specifying that the parameter is a reference parameter used normally in C# code. So, ref IntPtr means a pointer (ref) to a pointer (IntPtr).

MarshalEx class


Even using the ref IntPtr, we cannot access the structure values because the IntPtr has only a handle to it. To access it, we need to use the PtrToStructure method from the .NET Marshal class. This method takes an IntPtr parameter and a structure type parameter, and returns (casts) the structure object:

//----- Initialize!
IntPtr pdevs = IntPtr.Zero;
int nDevs = 0;
int input = 0;
int output = 0;
int ring = 0;

//----- Call function!
if (IAXFunctions.iaxc_audio_devices_get(ref pdevs, 
    ref nDevs, ref input, ref output, ref ring) != 0)
        throw new IAXMethodException("Initialize error!");

//----- Cast the pointer!
iaxc_audio_device devs = (iaxc_audio_device) 
   Marshal.PtrToStructure(pdevs, typeof(iaxc_audio_device));

In this code, we initialize the IntPtr parameters with IntPtr.Zero and call the function. The pdevs parameter has the pointer to the iaxc_audio_device value, and using the PtrToStructure method, we can cast the pointer to the structure. So far so good.

But, the function has a nDevs parameter that indicates the number of devices pointed in the pdevs parameter. If the nDevs parameter returns 2, the pdevs parameter points to two iaxc_audio_device structures. Remember that the pdevs parameter is a pointer to a pointer, and in this case, it's pointing to the first structure. The next structures returned are pointed using an array (something like iaxc_audio_device[]).

To loop through all the devices, we need to use the MarshalEx class, calling the PtrToStructureArray method that walks in the pdevs parameter:

public class MarshalEx

    public static object[] PtrToStructureArray(IntPtr pointer, 
                           Type structureType, int len)

        //----- Creates the array!
        object[] array = new object[len];
        for (int i = 0; i < len; i++)
            //----- Get the structure pointed from pointer parameter address!
            array[i] = Marshal.PtrToStructure(pointer, structureType);
            //----- Add to the pointer parameter address the size of structure!
            //----- After that, pointer parameter
            //----- points to another structure in memory!
            pointer = (IntPtr) (pointer.ToInt32() + Marshal.SizeOf(array[i]));

        return array;



The trick here is to walk in the pointer parameter address memory using the size of the structure. The code gets the first structure value, and puts it in the array. After that, the code adds the structure size to the address memory of pointer. Now, pointer points to the next structure value in memory. The process is repeated until all structures, indicated by the len parameter, are saved in the array.

Using this method, we can now loop through all the devices:

//----- Initialize!
IntPtr pdevs = IntPtr.Zero;
int nDevs = 0;
int input = 0;
int output = 0;
int ring = 0;

//----- Call function!
if (IAXFunctions.iaxc_audio_devices_get(ref pdevs, ref nDevs, 
                       ref input, ref output, ref ring) != 0)
    throw new IAXMethodException("Initialize error!");

//----- Get the structure array!
object[] devs = MarshalEx.PtrToStructureArray(pdevs, 
                typeof(iaxc_audio_device), nDevs);

foreach (object o in devs)
    iaxc_audio_device d = (iaxc_audio_device) o;

IAX events

The IAXClient has a message mechanism to fire events using Windows procedures. To receive events, you need to call the iaxc_set_event_callpost function, passing the window handle that will be used inside IAXClient to post event messages and the message ID that will be used in the window procedure to indicate that the message comes from IAXClient:

EXPORT int iaxc_set_event_callpost(void *handle, int id);

In C# we use the IntPtr type to pass the window handle:

public static extern int iaxc_set_event_callpost(
    IntPtr handle, 
    int id);

NativeWindowEx class


To receive the message events, you need to create a message procedure from a custom window. You could do it using the Windows API CreateWindowEx, DefWindowProc, CallWindowProc, etc. Instead, you can use the .NET NativeWindow class which creates the window, keeps the window handle, and creates a overridable window procedure in which you can receive messages. So, we can inherit the NativeWindow class and override the WndProc method:

public class NativeWindowEx : NativeWindow

    #region Fields

    //----- MessageEvent delegate!
    private event OnMessageDelegate FOnMessageEvent;
    //----- Pinned Handle!
    private GCHandle FPinnedHandle;


    #region Constructor

    public NativeWindowEx(CreateParams createParam, bool pinned)
        //----- Create the windows with the parameters!
        if (pinned)
            //----- If need to pin create the GCHandle from window handle!
            FPinnedHandle = GCHandle.Alloc(this.Handle, GCHandleType.Pinned);


    public NativeWindowEx(IntPtr handle, bool pinned)
        //----- Assign the handle to the class!

        if (pinned)
            //----- If need to pin create the GCHandle from window handle!
            FPinnedHandle = GCHandle.Alloc(handle, GCHandleType.Pinned);


    #region Methods

    protected override void WndProc(ref Message m)

        base.WndProc(ref m);

        //----- Call the MessageEvent!
        if (FOnMessageEvent != null)
            FOnMessageEvent(ref m);


    #region Properties

    public GCHandle PinnedHandle
            return FPinnedHandle;

    public event OnMessageDelegate OnMessage

            FOnMessageEvent += value;
            FOnMessageEvent -= value;




Using the NativeWindowEx class, we can now pass the window handle to the iaxc_set_event_callpost:


//----- Message Event!

//----- Magic number!
FMessageId = 123456; 

FWindow = new NativeWindowEx(new CreateParams(), true);
FWindow.OnMessage += new OnMessageDelegate(FWindow_OnMessage);

if (IAXFunctions.iaxc_set_event_callpost(FWindow.Handle, FMessageId) != 0)
    throw new IAXMethodException("Event handler initialize error!");

if (IAXFunctions.iaxc_start_processing_thread() != 0)
    throw new IAXMethodException("Event handler start error!");


In this code, we first assign the message ID that will be passed to Windows message. After that, we create the NativeWindowEx class and pass the handle from this class to the iaxc_set_event_callpost function. When the iaxc_start_processing_thread function is called, the messages will begin to come in FWindow_OnMessage.

GCHandle and pinned

Note the GCHandle class used in NativeWindowEx. This class is needed because every time you need to pass a managed object to the unmanaged world, you need to pin the class. Remember that when Garbage Collector runs, it tries to reach the objects. If an object is not reached, the object is collected by GC, and, to remove the free space from the collected objects, it moves reached objects to the free spaces, removing heap gaps and invalidating memory address. Using pinned objects, you can prevent the GC to move the object in the heap while the unmanaged application holds the reference to it. Without the pinned object, the object's memory can be moved in managed heap, making the object's address invalid in the unmanaged code. You can read more about GC here.

Event structures


IAXClient sends information events using the following structure:

typedef struct iaxc_event_struct {
    struct iaxc_event_struct *next;
    int type;
    union {
        struct iaxc_ev_levels       levels;
        struct iaxc_ev_text         text;
        struct iaxc_ev_call_state   call;
        struct iaxc_ev_netstats     netstats;
        struct iaxc_ev_url          url;
        struct iaxc_ev_video        video;
        struct iaxc_ev_registration reg;
    } ev;
} iaxc_event;

The union clause is used in the structure indicating that the ev field value depends on the type field. So, if you receive a etIAXC_EVENT_LEVELS value in the type field, the ev field points to it. To convert this structure to C#, we use the FieldOffset attribute (only the main structures converted):

internal struct iaxc_event

    public IntPtr next;
    public EventType type;

    public iaxc_ev_levels level;

    public iaxc_ev_text text;

    public iaxc_ev_call_state callState;

    public iaxc_ev_registration registration;


FieldOffset is used with the StructLayout(LayoutKind.Explicit) clause to indicate the fields's offset in the structure. Using StructLayout(LayoutKind.Explicit), all fields must have a FieldOffset attribute and, to simulate the union clause, we need to put those fields in the same offset. In this case, we're using [FieldOffset(8)] in the union fields because the next and type fields use four bytes each in the structure's memory.


After converting the iaxc_event structure and running the application, the following TypeLoadException is thrown:

System.TypeLoadException was unhandled
  Message="Could not load type 'ALAZ.TelephonyEx.Voip.IAX.iaxc_event' 
    from assembly 'ALAZ.TelephonyEx, Version=, 
    Culture=neutral, PublicKeyToken=null'
    because it contains an object field at offset 8 that 
    is incorrectly aligned or overlapped by a non-object field."

The exception is thrown because C# doesn't handle value and reference types using the same FieldOffset attribute. The following iaxc_ev_text structure is used in iaxc_event:

#define IAXC_EVENT_BUFSIZ    256
struct iaxc_ev_text {
    int type;
    int callNo;
    char message[IAXC_EVENT_BUFSIZ];

To convert it to C#, we use the MarshalAs attribute, indicating the correct UnmanagedType enumeration:

internal struct iaxc_ev_text
    public TextType type;
    public int callNo;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
    public string message;

The UnmanagedType.ByValTStr enumeration is used to represent the char array, and the size is defined with the SizeConst clause. As we are using the string type in the message field, C# cannot handle the structure, and throws the exception. If the structures used in the same FieldOffset attribute have only value types, the exception isn't thrown.

Event message callback


To solve the TypeLoadException problem, we need to use the .NET Marshal class and make some changes in the iaxc_event structure:

internal struct iaxc_event
    public IntPtr next;
    public EventType type;

In the new iaxc_event structure, the union field is removed and is referenced in NativeWindowEx's message callback procedure:

private void FWindow_OnMessage(ref System.Windows.Forms.Message m)

    if (!Disposed)

        //----- Check messageId!
        if (m.Msg == FMessageId)

            //----- Get event data!
            iaxc_event e = (iaxc_event)
              Marshal.PtrToStructure(m.LParam, typeof(iaxc_event));
            //----- Walks through the LParam memory
            //----- address to find event data field!
            IntPtr eventPointer = new IntPtr(m.LParam.ToInt32() + 8);

            switch (e.type)

                case EventType.etIAXC_EVENT_LEVELS:
                        //----- Meter Level!
                        iaxc_ev_levels ev = (iaxc_ev_levels)

                case EventType.etIAXC_EVENT_REGISTRATION:
                        //----- Registration!
                        iaxc_ev_registration ev = (iaxc_ev_registration)

                case EventType.etIAXC_EVENT_STATE:

                        //----- Call State!
                        iaxc_ev_call_state ev = (iaxc_ev_call_state)

                case EventType.etIAXC_EVENT_TEXT:
                        //----- Text!
                        iaxc_ev_text ev = (iaxc_ev_text)


            eventPointer = IntPtr.Zero;


The FWindow_OnMessage event receives a System.Windows.Forms.Message posted by the IAXClient library. After checking if the message is a FMessageId, we need to cast the message's LParam property to the iaxc_event structure using the Marshal.PtrToStructure method. At this point, e.type points to the EventType enumeration, but, where's the event data? The event data is there, but we need to walk through the LParam address to find it. Remember that the event data field is the third field in the IAXClient structure. So, we create a new IntPtr object pointing to 8 bytes (or two 32 bit fields) after the LParam memory address. The new IntPtr object now points to the event data field in the memory address, and now it can be cast to the respective event structure using a simple case statement. After using the event structure, we need to call the iaxc_free_event function to free the event data.

The IAXClientClass


The IAXClientClass is the main class to work with the IAXClient library. The IAXClientClass constructor initializes the the IAXClient library with the AudioType and the number of lines used, and gets the audio devices available:

public IAXClientClass(AudioType audioType, int lines)

    FCallerIdName = "SharpIAX";
    FCallerIdNumber = "(Not Specified)";

    FAudioType = audioType;

    FLinesList = new List<IAXLine>();
    FLinesCollection = new IAXLines(FLinesList, this);

    FAudioDevicesList = new List<IAXAudioDevice>();
    FAudioDevicesCollection = new IAXAudioDevices(FAudioDevicesList);

    FSilenceThreshold = -99;
    FRegistrationRequired = true;
    FLines = lines;

    //----- Initialize!
    if (IAXFunctions.iaxc_initialize((int)FAudioType, FLines) != 0)
        throw new IAXMethodException("Initialize error!");

    //----- Devices
    IntPtr pdevs = IntPtr.Zero;
    int nDevs = 0;
    int input = 0;
    int output = 0;
    int ring = 0;

    if (IAXFunctions.iaxc_audio_devices_get(ref pdevs, ref nDevs, 
                     ref input, ref output, ref ring) != 0)
        throw new IAXMethodException("Initialize error!");

    FAudioDevicesCollection.SelectedInputAudioDevice = input;
    FAudioDevicesCollection.SelectedOutputAudioDevice = output;
    FAudioDevicesCollection.SelectedRingAudioDevice = ring;

    object[] devs = MarshalEx.PtrToStructureArray(pdevs, 
                    typeof(iaxc_audio_device), nDevs);

    foreach (object o in devs)
        iaxc_audio_device d = (iaxc_audio_device)o;
        IAXAudioDevice iaxd = new IAXAudioDevice(d.devID, 
                        , d.capabilities);

The Initialize method sets the caller ID, silence threshold, audio formats, and initializes the message event process. The method adds to the IAXLines collection the number of IAXLine items requested and, if registration is required, it begins the registration procedure:

public void Initialize(string user, string password, 
                       string server, bool register)

    if (!Disposed)
        //----- Account!
        FUser = user;
        FPass = password;
        FServer = server;
        FRegistrationRequired = register;

        //---- Caller Id!
        IAXFunctions.iaxc_set_callerid(FCallerIdName, FCallerIdNumber);

        //----- Silence Threshold !

        //----- Formats!
        FPreferredFormat = AudioFormat.afIAXC_FORMAT_GSM;
        FAllowedFormats = FPreferredFormat;


        //----- Message Event!

        //----- Magic number!
        FMessageId = 123456;

        FWindow = new NativeWindowEx(new CreateParams(), true);
        FWindow.OnMessage += new OnMessageDelegate(FWindow_OnMessage);

        if (IAXFunctions.iaxc_set_event_callpost(FWindow.Handle, FMessageId) != 0)
            throw new IAXMethodException("Event handler initialize error!");

        if (IAXFunctions.iaxc_start_processing_thread() != 0)
            throw new IAXMethodException("Event handler start error!");

        for (int i = 1; i <= FLines; i++)
            FLinesList.Add(new IAXLine(FLinesCollection, i - 1));


        if (FRegistrationRequired)

The Shutdown method terminates all active calls, unregisters the user, and stops the message event process:

public void ShutDown()

    if (!Disposed)


        if (FRegistrationId > 0)

        if (IAXFunctions.iaxc_stop_processing_thread() != 0)
            throw new IAXMethodException("Event handler stop error!");


Playing sounds

IAXClient library has some sounds functions called iaxc_play_sound and iaxc_stop_sound. iaxc_play_sound plays a raw wave buffer and returns a sound ticket. The ticket is used in iaxc_stop_sound to stop the sound playing. The iaxc_sound structure must be filled in order to play the sound.


The main fields in iaxc_sound is data and len. data is the raw wav buffer array to play and len defines the buffer array length. This structure is used in PlaySound method:

private void PlaySound(string resourceName, int repeat, ref int Id)
    Stream fs = 
    fs.Position = 44;

    byte[] arr = new byte[fs.Length - fs.Position];

    fs.Read(arr, 0, arr.Length);

    GCHandle h = GCHandle.Alloc(arr, GCHandleType.Pinned);

    iaxc_sound s = new iaxc_sound();

    s.len = arr.Length / 2; = h.AddrOfPinnedObject();
    s.malloced = 0; = 0;
    s.repeat = repeat;

    Id = IAXFunctions.iaxc_play_sound(ref s, 0);


The resourceName parameter defines the embedded resource file name. The repeat parameters defines how many times the song will be played. The Id parameter defines the ticket returned from iaxc_play_sound.

Embedded resources

You can embed resource files in Assembly simply setting the resource's Build Action property to Embedded Resource:


Wav file header

The data field from iaxc_sound structure must be filled with wave raw data and we need to know where the raw data begins inside a wave file. Well, the answer is here. Wave files are divided in chunks and data chunk (raw data) begins at 44th byte in wave files. So, PlaySound method opens the embedded resource wave file, read it beginning from 44th byte till the end of file. After that, the iaxc_sound structure is filled with the pinned pointer of the raw data array. Then the sound is played using iaxc_play_sound function.



The IAXAudioDevices is a collection of IAXAudioDevices. Each IAXAudioDevice has ID, Name, and Capabilities properties. Using IAXAudioDevices methods, you can set the correct device for input, output, and ring:

private void SetAudioDevices()

    if (IAXFunctions.iaxc_audio_devices_set(FInputDevice, 
                             FOutputDevice, FRingDevice) != 0)
        throw new IAXMethodException("Set device error!");


public void SelectInputAudioDevice(int deviceId)
    FInputDevice = deviceId;

public void SelectOutPutAudioDevice(int deviceId)
    FOutputDevice = deviceId;

public void SelectRingAudioDevice(int deviceId)
    FRingDevice = deviceId;



The IAXLines is a collection of IAXLines. The SelectLine method selects the line to work with. To get the selected line, the SelectedLine property is used.

Each IAXLine has an ID, CallTime, and local and remote call information. The CallDirection property indicates if the call is an incoming or an outgoing call. The CallStatus property indicates the status of the call in the line. The MakeCall method is used to start a call on the selected line, and the DropCall method is used to terminate the call. The AnswerCall method answers a ringing line, and TransferCall transfers the call. To send digits in an active call, you can use the SendDTMF method.

public void MakeCall(string number)
    string callMessage = String.Format(CALLFORMAT, 
           FCollection.Host.User, FCollection.Host.Password, 
           FCollection.Host.Server, number);

public void DropCall()

public void AnswerCall()

public void SendDTMF(byte digit)

public void TransferCall(string number)
    IAXFunctions.iaxc_blind_transfer_call(FLineNumber, number);

SharpIAX demo

The SharpIAX demo is a Windows Forms application that uses the IAXClientClass class. It uses two lines, and shows the call status of each line, shows IAX messages from the server, and sends DTMF digits:


In the Configuration->Network tab, you can set the server's address, username and password, caller information, and the audio formats. You can also set the audio devices used in input, output, and ring in the Configuration->Audio tab:



Compiling IAXCLient

The SharpIAX demo binaries already uses a compiled version of IAXClient library but, if you wish to compile it, you need to download it from Sourceforge.


First of all, you need to download CygWin.

Run the setup application, and choose to install from the internet.


After that, select the root directory (installation directory):


the local package directory (downloaded packages directory):


and the download site.


When the Select Packages form appears, in addition to the default packages, select the gcc-mingw, gcc-mingw-core, gcc-mingw-g++




and subversion packages located at the Devel category.


After installation, run the cygwin.bat on the CygWin installation directory to open the Cygwin shell.


Download IAXClient

To download IAXClient sources, you need to execute the svn command. Inside CygWin shell, create a new directory somewhere and, on the new directory, execute the following command (don't forget the dot at the end!):

svn co .


Compiling IAXClient

After downloading it, locate the iaxlclient/lib directory and, inside this directory, type the make command to generate the DLL:

make shared


If you get some errors, check the makefile file located in the lib directory. Otherwise, you've a new fresh iaxclient.dll.


I hope that this article helps you to get familiar with the IAXClient library and understand how P/Invoke can be utilized to work with unmanaged applications and structures. I'd like to thank Mr. Adelino Baena from Alcance Brasil for the Asterisk server installation, maintenance, support, and incentive to build this library. Any comments will be appreciated.


  • 22 Aug, 2006: Initial version.
  • 11 Nov, 2006:
    1. CygWin screenshots added.
    2. New play methods do play DTMF tones, ring and busy sounds.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Andre Azevedo
Software Developer (Senior)
Brazil Brazil
- Living in São Paulo, Brazil
- Developing since 1994 with
* Clipper (Summer '87 and 5.02)
* FoxPro (DOS, 2.6), Visual Foxpro (6, 7, 8, 9)
* Delphi (1, 2, 5, 7, 2007)
* C# (2.0, 4.0)

You may also be interested in...


Comments and Discussions

QuestionNeed help Pin
madusanka8916-Mar-15 19:15
membermadusanka8916-Mar-15 19:15 
GeneralMy vote of 5 Pin
soumyam24-Sep-14 23:08
membersoumyam24-Sep-14 23:08 
QuestionHave you got an up to date version of the wrapper with the current LIBIAXCLIENT implementation? Pin
Robson Félix8-Sep-14 7:35
memberRobson Félix8-Sep-14 7:35 
QuestionHow to make more than 2 channels with above example? Pin
Member 1029586418-Mar-14 2:02
memberMember 1029586418-Mar-14 2:02 
AnswerRe: How to make more than 2 channels with above example? Pin
mailtochandra2000@yahoo.com26-Mar-14 6:47
membermailtochandra2000@yahoo.com26-Mar-14 6:47 
Questionquestions about Using the Asterisk IAXClient library in C# Pin
mardios23-Jan-14 5:45
membermardios23-Jan-14 5:45 
QuestionAsterisk.Net Pin
luanptit28-Jan-13 5:46
memberluanptit28-Jan-13 5:46 
GeneralMy vote of 5 Pin
lovelydinasour00131-Dec-12 18:48
memberlovelydinasour00131-Dec-12 18:48 
QuestionRegistration Error Pin
mosi_khosh16-Oct-12 1:58
membermosi_khosh16-Oct-12 1:58 
QuestionNew url for svn Pin
dbllon6915-Jun-12 1:29
memberdbllon6915-Jun-12 1:29 
Questionadding g.729 codec Pin
jack_kj27-Sep-11 2:33
memberjack_kj27-Sep-11 2:33 
GeneralIAXClient and incoming call Pin
sam-soft29-Mar-11 1:34
membersam-soft29-Mar-11 1:34 
GeneralMy vote of 5 Pin
Cleber Silva9-Feb-11 5:42
memberCleber Silva9-Feb-11 5:42 
QuestionIs threre Echo Cancelation build in? Pin
ibuza27-Sep-10 8:32
memberibuza27-Sep-10 8:32 
GeneralFails to register inside VS Pin
elevenE14-Jun-10 0:19
memberelevenE14-Jun-10 0:19 
GeneralRe: Fails to register inside VS Pin
jack_kj27-Sep-11 11:07
memberjack_kj27-Sep-11 11:07 
GeneralRe: Fails to register inside VS Pin
jack_kj27-Sep-11 11:15
memberjack_kj27-Sep-11 11:15 
GeneralAudio Pin
Jorge Rocha9-Mar-10 11:49
memberJorge Rocha9-Mar-10 11:49 
QuestionCan IaxClient read the channel variables Pin
kan_hossam23-Oct-09 1:45
memberkan_hossam23-Oct-09 1:45 
Generaldtmf decoding Pin
srihari_23020-Oct-09 20:05
membersrihari_23020-Oct-09 20:05 
Questionhow to activate the dial tone Pin
rikki2337528-Oct-09 8:13
memberrikki2337528-Oct-09 8:13 
Generaldropcall() problem Pin
africansn2-Oct-09 9:19
memberafricansn2-Oct-09 9:19 
GeneralBug in PlaySound Pin
the_codeer18-Jun-09 3:52
memberthe_codeer18-Jun-09 3:52 
GeneralRe: Bug in PlaySound Pin
Andre Azevedo18-Jun-09 5:11
memberAndre Azevedo18-Jun-09 5:11 
GeneralRe: Bug in PlaySound Pin
the_codeer18-Jun-09 19:59
memberthe_codeer18-Jun-09 19:59 
GeneralRe: Bug in PlaySound Pin
Member 1182805811-Feb-16 0:09
memberMember 1182805811-Feb-16 0:09 
GeneralConnection Attempt Error Pin
salblomo12-May-09 11:41
membersalblomo12-May-09 11:41 
General[Message Deleted] Pin
it.ragester28-Mar-09 5:34
memberit.ragester28-Mar-09 5:34 
QuestionIs it possible to play a sound during the call? Pin
Matt Philmon19-Mar-09 8:38
memberMatt Philmon19-Mar-09 8:38 
Questionhow to compile IAXCLient myself? Pin
xuhongxiuxiu11-Mar-09 6:42
memberxuhongxiuxiu11-Mar-09 6:42 
Generaldtmf Pin
ctitan1-Mar-09 21:11
memberctitan1-Mar-09 21:11 
Generaliaxc_initialize mute audio Pin
bigplac4-Feb-09 23:08
memberbigplac4-Feb-09 23:08 
GeneralRe: iaxc_initialize mute audio Pin
jack_kj27-Sep-11 11:14
memberjack_kj27-Sep-11 11:14 
GeneralServidor Asterisk Pin
fermarraia31-Jan-09 6:18
memberfermarraia31-Jan-09 6:18 
GeneralRejeicao Pin
fermarraia29-Jan-09 11:48
memberfermarraia29-Jan-09 11:48 
Generaliaxclient.dll Pin
fermarraia27-Jan-09 12:05
memberfermarraia27-Jan-09 12:05 
GeneralRe: iaxclient.dll Pin
Andre Azevedo29-Jan-09 5:05
memberAndre Azevedo29-Jan-09 5:05 
QuestionAsterisk Manager Interface (AMI), IAXClient will be a replacement or what do you think? Pin
naeem.akram.malik13-Jan-09 4:52
membernaeem.akram.malik13-Jan-09 4:52 
GeneralGood stuff Pin
izmoto16-Nov-08 23:32
memberizmoto16-Nov-08 23:32 
GeneralAudioConference Pin
Nguyen Phuoc Dai23-Sep-08 18:26
memberNguyen Phuoc Dai23-Sep-08 18:26 
GeneralHold function Pin
the_codeer18-Aug-08 22:37
memberthe_codeer18-Aug-08 22:37 
GeneralRe: Hold function Pin
the_codeer19-Aug-08 23:41
memberthe_codeer19-Aug-08 23:41 
GeneralSuperb Pin
Radu Poenaru26-Apr-08 2:33
memberRadu Poenaru26-Apr-08 2:33 
GeneralSharpIAX Audio Device Problem Pin
saulat14-Apr-08 22:20
membersaulat14-Apr-08 22:20 
GeneralRegistration Error Pin
saulat8-Apr-08 23:48
membersaulat8-Apr-08 23:48 
QuestionRe: Registration Error Pin
Gokhan Mamaci12-May-08 3:33
memberGokhan Mamaci12-May-08 3:33 
GeneralRe: Registration Error Pin
rikki2337528-Oct-09 21:54
memberrikki2337528-Oct-09 21:54 
GeneralRe: Registration Error Pin
andrzej.bol7-Nov-12 23:24
memberandrzej.bol7-Nov-12 23:24 
General[Message Deleted] Pin
saulat21-Mar-08 1:29
membersaulat21-Mar-08 1:29 
GeneralRe: ALAZ Library IAX Demo Pin
Andre Azevedo21-Mar-08 15:56
memberAndre Azevedo21-Mar-08 15:56 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.161021.1 | Last Updated 13 Nov 2006
Article Copyright 2006 by Andre Azevedo
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid