Merge branch 'master' of https://github.com/Tox/toxic

build/Makefile.am

@@ -34,7 +34,8 @@ toxic_SOURCES = $(top_srcdir)/src/main.c \
 toxic_CFLAGS =                 -I$(top_srcdir) \
 				$(NCURSES_CFLAGS) \
 				$(LIBSODIUM_CFLAGS) \
-				$(LIBTOXCORE_CFLAGS)
+				$(LIBTOXCORE_CFLAGS) \
+				$(PTHREAD_CFLAGS)
 
 toxic_CPPFLAGS = '-DTOXICVER="$(TOXIC_VERSION)"'
 
@@ -43,7 +44,8 @@ toxic_LDADD =	$(LIBTOXCORE_LDFLAGS) \
 				$(NCURSES_LIBS) \
 				$(LIBTOXCORE_LIBS) \
 				$(LIBSODIUM_LIBS) \
-                $(WINSOCK2_LIBS)
+                $(WINSOCK2_LIBS) \
+                $(PTHREAD_LIBS)
 
 
 # For audio support

configure.ac

@@ -113,6 +113,8 @@ AC_CHECK_FUNCS(
     [],
     [ AC_MSG_ERROR([required library function is missing on your system])])
 
+AX_PTHREAD( [], [ AC_MSG_ERROR([pthreads not found on your system]) ])
+
 # pkg-config based tests
 PKG_PROG_PKG_CONFIG
 
@@ -438,10 +440,12 @@ if test "x$BUILD_AV" = "xyes"; then
         ], 
         [
             AC_MSG_NOTICE([No A/V library; disabling A/V support])
+            BUILD_AV="no"
         ])
     ],
     [
         AC_MSG_NOTICE([No openal library; disabling A/V support])
+        BUILD_AV="no"
     ])
 fi
 

m4/ax_pthread.m4

@@ -0,0 +1,317 @@
+# ===========================================================================
+#        http://www.gnu.org/software/autoconf-archive/ax_pthread.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+#
+# DESCRIPTION
+#
+#   This macro figures out how to build C programs using POSIX threads. It
+#   sets the PTHREAD_LIBS output variable to the threads library and linker
+#   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
+#   flags that are needed. (The user can also force certain compiler
+#   flags/libs to be tested by setting these environment variables.)
+#
+#   Also sets PTHREAD_CC to any special C compiler that is needed for
+#   multi-threaded programs (defaults to the value of CC otherwise). (This
+#   is necessary on AIX to use the special cc_r compiler alias.)
+#
+#   NOTE: You are assumed to not only compile your program with these flags,
+#   but also link it with them as well. e.g. you should link with
+#   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#
+#   If you are only building threads programs, you may wish to use these
+#   variables in your default LIBS, CFLAGS, and CC:
+#
+#     LIBS="$PTHREAD_LIBS $LIBS"
+#     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+#     CC="$PTHREAD_CC"
+#
+#   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
+#   has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name
+#   (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+#
+#   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
+#   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
+#   PTHREAD_CFLAGS.
+#
+#   ACTION-IF-FOUND is a list of shell commands to run if a threads library
+#   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
+#   is not found. If ACTION-IF-FOUND is not specified, the default action
+#   will define HAVE_PTHREAD.
+#
+#   Please let the authors know if this macro fails on any platform, or if
+#   you have any other suggestions or comments. This macro was based on work
+#   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
+#   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
+#   Alejandro Forero Cuervo to the autoconf macro repository. We are also
+#   grateful for the helpful feedback of numerous users.
+#
+#   Updated for Autoconf 2.68 by Daniel Richard G.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+#   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 20
+
+AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
+AC_DEFUN([AX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_LANG_PUSH([C])
+ax_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on True64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
+        AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes)
+        AC_MSG_RESULT($ax_pthread_ok)
+        if test x"$ax_pthread_ok" = xno; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try.  Items starting with a "-" are
+# C compiler flags, and other items are library names, except for "none"
+# which indicates that we try without any flags at all, and "pthread-config"
+# which is a program returning the flags for the Pth emulation library.
+
+ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
+# -pthreads: Solaris/gcc
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads too;
+#      also defines -D_REENTRANT)
+#      ... -mt is also the pthreads flag for HP/aCC
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case ${host_os} in
+        solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed.  (We need to link with -pthreads/-mt/
+        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
+        # a function called by this macro, so we could check for that, but
+        # who knows whether they'll stub that too in a future libc.)  So,
+        # we'll just look for -pthreads and -lpthread first:
+
+        ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"
+        ;;
+
+        darwin*)
+        ax_pthread_flags="-pthread $ax_pthread_flags"
+        ;;
+esac
+
+if test x"$ax_pthread_ok" = xno; then
+for flag in $ax_pthread_flags; do
+
+        case $flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $flag])
+                PTHREAD_CFLAGS="$flag"
+                ;;
+
+                pthread-config)
+                AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no)
+                if test x"$ax_pthread_config" = xno; then continue; fi
+                PTHREAD_CFLAGS="`pthread-config --cflags`"
+                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+                ;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$flag])
+                PTHREAD_LIBS="-l$flag"
+                ;;
+        esac
+
+        save_LIBS="$LIBS"
+        save_CFLAGS="$CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
+                        static void routine(void *a) { a = 0; }
+                        static void *start_routine(void *a) { return a; }],
+                       [pthread_t th; pthread_attr_t attr;
+                        pthread_create(&th, 0, start_routine, 0);
+                        pthread_join(th, 0);
+                        pthread_attr_init(&attr);
+                        pthread_cleanup_push(routine, 0);
+                        pthread_cleanup_pop(0) /* ; */])],
+                [ax_pthread_ok=yes],
+                [])
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        AC_MSG_RESULT($ax_pthread_ok)
+        if test "x$ax_pthread_ok" = xyes; then
+                break;
+        fi
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$ax_pthread_ok" = xyes; then
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+        AC_MSG_CHECKING([for joinable pthread attribute])
+        attr_name=unknown
+        for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+            AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
+                           [int attr = $attr; return attr /* ; */])],
+                [attr_name=$attr; break],
+                [])
+        done
+        AC_MSG_RESULT($attr_name)
+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
+            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
+                               [Define to necessary symbol if this constant
+                                uses a non-standard name on your system.])
+        fi
+
+        AC_MSG_CHECKING([if more special flags are required for pthreads])
+        flag=no
+        case ${host_os} in
+            aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";;
+            osf* | hpux*) flag="-D_REENTRANT";;
+            solaris*)
+            if test "$GCC" = "yes"; then
+                flag="-D_REENTRANT"
+            else
+                flag="-mt -D_REENTRANT"
+            fi
+            ;;
+        esac
+        AC_MSG_RESULT(${flag})
+        if test "x$flag" != xno; then
+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
+        fi
+
+        AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
+            ax_cv_PTHREAD_PRIO_INHERIT, [
+                AC_LINK_IFELSE([
+                    AC_LANG_PROGRAM([[#include <pthread.h>]], [[int i = PTHREAD_PRIO_INHERIT;]])],
+                    [ax_cv_PTHREAD_PRIO_INHERIT=yes],
+                    [ax_cv_PTHREAD_PRIO_INHERIT=no])
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],
+            AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.]))
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        # More AIX lossage: compile with *_r variant
+        if test "x$GCC" != xyes; then
+            case $host_os in
+                aix*)
+                AS_CASE(["x/$CC"],
+                  [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
+                  [#handle absolute path differently from PATH based program lookup
+                   AS_CASE(["x$CC"],
+                     [x/*],
+                     [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],
+                     [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
+                ;;
+            esac
+        fi
+fi
+
+test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
+
+AC_SUBST(PTHREAD_LIBS)
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_CC)
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test x"$ax_pthread_ok" = xyes; then
+        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
+        :
+else
+        ax_pthread_ok=no
+        $2
+fi
+AC_LANG_POP
+])dnl AX_PTHREAD

src/audio_call.c

@@ -27,16 +27,17 @@ typedef struct _DeviceIx {
     
     ALCdevice* dhndl; /* Handle of device selected/opened */
     ALCcontext* ctx; /* Device context */
-    const char* devices[MAX_DEVICES]; /* Container  */
+    const char* devices[MAX_DEVICES]; /* Container of available devices */
-    int size;
+    int size; /* Size of above container */
     int dix; /* Index of default device */
+    int index; /* Current index */
 } DeviceIx;
 
-typedef enum _devices
+typedef enum _Devices
 {
     input,
     output,
-} _devices;
+} _Devices;
 
 struct _ASettings {
     
@@ -61,9 +62,115 @@ void callback_call_canceled ( void *arg );
 void callback_call_rejected ( void *arg );
 void callback_call_ended ( void *arg );
 void callback_requ_timeout ( void *arg );
+void callback_peer_timeout ( void* arg );
 
 
+/* Opens device under current index
+ */
+int device_open (WINDOW *window, _Devices type)
+{
+    /* Do not error if no device */
+    if ( !ASettins.device[type].size ) return 0;
     
+    ALCdevice* prev_device = ASettins.device[type].dhndl;
+    
+    const char* error = NULL;
+    
+    if ( type == input ) {
+        ASettins.device[type].dhndl = alcCaptureOpenDevice(
+            ASettins.device[type].devices[ASettins.device[type].index], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16, AUDIO_FRAME_SIZE * 4);
+        
+        if (alcGetError(ASettins.device[type].dhndl) != AL_NO_ERROR) {
+            
+            /* Now check if we have previous device and act acording to it */
+            if ( !prev_device ) {
+                error = "Error starting input device!";
+                
+                ASettins.errors |= ErrorStartingCaptureDevice;
+            }
+            else {
+                error = "Could not start input device, falling back to previous";
+                
+                /* NOTE: What if device is opened? */
+                ASettins.device[type].dhndl = prev_device;
+            }
+        }
+        else 
+        {
+            /* Close previous */
+            if ( prev_device )
+                alcCaptureCloseDevice(prev_device);
+            
+            if ( window ) wprintw(window, "Input device: %s\n", ASettins.device[type].devices[ASettins.device[type].index]);
+        }
+        
+        ASettins.device[type].ctx = NULL;
+    }
+    else {
+        ASettins.device[type].dhndl = alcOpenDevice(ASettins.device[type].devices[ASettins.device[type].index]);
+        
+        if (alcGetError(ASettins.device[type].dhndl) != AL_NO_ERROR) {
+            
+            /* Now check if we have previous device and act acording to it */
+            if ( !prev_device ) {
+                error = "Error starting output device!";
+                
+                ASettins.errors |= ErrorStartingOutputDevice;
+                ASettins.device[type].ctx = NULL;
+            }
+            else {
+                error = "Could not start output device, falling back to previous";
+                
+                /* NOTE: What if device is opened? */
+                ASettins.device[type].dhndl = prev_device;
+            }
+        }
+        else {
+            
+            /* Close previous */
+            if ( prev_device ) {
+                alcCaptureCloseDevice(prev_device);                
+                alcMakeContextCurrent(NULL);
+                alcDestroyContext(ASettins.device[type].ctx);
+            }
+            
+            ASettins.device[type].ctx = alcCreateContext(ASettins.device[type].dhndl, NULL);
+            
+            if ( window ) wprintw(window, "Output device: %s\n", ASettins.device[type].devices[ASettins.device[type].index]);
+        }
+    }
+    
+    if ( error ) {
+        if ( window ) wprintw(window, "Error: %s\n", error);
+        return -1;
+    }
+    else return 0;
+}
+
+int device_close (WINDOW *window, _Devices type)
+{
+    const char* device = NULL;
+    
+    if ( ASettins.device[type].dhndl ) {
+        if (type == input) {
+            alcCaptureCloseDevice(ASettins.device[type].dhndl);
+            device = "input";
+        }
+        else {
+            alcCloseDevice(ASettins.device[type].dhndl);
+            alcMakeContextCurrent(NULL);
+            
+            if ( ASettins.device[type].ctx )
+                alcDestroyContext(ASettins.device[type].ctx);
+            
+            device = "output";
+        }
+            
+        ASettins.device[type].index = ASettins.device[type].dix;
+    }
+    
+    if ( window && device ) wprintw(window, "Closed %s device\n", device);
+}
 
 
 ToxAv* init_audio(ToxWindow* window, Tox* tox)
@@ -71,7 +178,7 @@ ToxAv* init_audio(ToxWindow* window, Tox* tox)
     ASettins.errors = NoError;
     ASettins.ttas = 0; /* Not running */
     
-    /* Capture device */
+    /* Capture devices */
     const char* stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
     ASettins.device[input].size = 0;
     
@@ -82,32 +189,14 @@ ToxAv* init_audio(ToxWindow* window, Tox* tox)
             ASettins.device[input].devices[ASettins.device[input].size] = stringed_device_list;
             
             if ( strcmp( default_device , ASettins.device[input].devices[ASettins.device[input].size] ) == 0 )
-                ASettins.device[input].dix = ASettins.device[input].size;
+                ASettins.device[input].index = ASettins.device[input].dix = ASettins.device[input].size;
             
             stringed_device_list += strlen( stringed_device_list ) + 1;
         }
     }
     
-    if ( ASettins.device[input].size ) { /* Have device */
-        ASettins.device[input].dhndl = alcCaptureOpenDevice(
-            ASettins.device[input].devices[ASettins.device[input].dix], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16, AUDIO_FRAME_SIZE * 4);
     
-        if (alcGetError(ASettins.device[input].dhndl) != AL_NO_ERROR) {
+    /* Output devices */
-            ASettins.errors |= ErrorStartingCaptureDevice;
-        }
-        
-        wprintw(window->window, "Input device: %s\n", ASettins.device[input].devices[ASettins.device[input].dix]);
-    } else { /* No device */
-        wprintw(window->window, "No input device!\n");
-        ASettins.device[input].dhndl = NULL;
-    }
-    
-    ASettins.device[input].ctx = NULL;
-    
-    
-    
-    
-    /* Output device */
     stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
     ASettins.device[output].size = 0;
     
@@ -118,65 +207,49 @@ ToxAv* init_audio(ToxWindow* window, Tox* tox)
             ASettins.device[output].devices[ASettins.device[output].size] = stringed_device_list;            
             
             if ( strcmp( default_device , ASettins.device[output].devices[ASettins.device[output].size] ) == 0 )
-                ASettins.device[output].dix = ASettins.device[output].size;
+                ASettins.device[output].index = ASettins.device[output].dix = ASettins.device[output].size;
             
             stringed_device_list += strlen( stringed_device_list ) + 1;
         }
     }
     
-    if ( ASettins.device[output].size ) { /* Have device */
+    if (!ASettins.device[input].size && !ASettins.device[output].size) {
-        ASettins.device[output].dhndl = alcOpenDevice(ASettins.device[output].devices[ASettins.device[output].dix]);
+        wprintw(window->window, "No devices: disabling audio!\n");
+        ASettins.av = NULL;
+    }
+    else {
+        /* Streaming stuff from core */
+        ASettins.av = toxav_new(tox, 0, 0);
         
-        if (alcGetError(ASettins.device[output].dhndl) != AL_NO_ERROR) {
+        if ( !ASettins.av ) {
-            ASettins.errors |= ErrorStartingOutputDevice;
+            ASettins.errors |= ErrorStartingCoreAudio;
+            return NULL;
         }    
         
-        wprintw(window->window, "Output device: %s\n", ASettins.device[output].devices[ASettins.device[output].dix]);
+        toxav_register_callstate_callback(callback_call_started, av_OnStart, window);
-        ASettins.device[output].ctx = alcCreateContext(ASettins.device[output].dhndl, NULL);
+        toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, window);
-    } else { /* No device */
+        toxav_register_callstate_callback(callback_call_rejected, av_OnReject, window);
-        wprintw(window->window, "No output device!\n");
+        toxav_register_callstate_callback(callback_call_ended, av_OnEnd, window);
-        ASettins.device[output].dhndl = NULL;
+        toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, window);
-        ASettins.device[output].ctx = NULL;
+        
+        toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, window);
+        toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, window);
+        toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, window);
+        
+        toxav_register_callstate_callback(callback_recv_error, av_OnError, window);
+        toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, window);
+        toxav_register_callstate_callback(callback_peer_timeout, av_OnPeerTimeout, window);
     }
     
-    
-    /* Streaming stuff from core */
-    ASettins.av = toxav_new(tox, 0, 0);
-    
-    if ( !ASettins.av ) {
-        ASettins.errors |= ErrorStartingCoreAudio;
-        return NULL;
-    }    
-    
-    toxav_register_callstate_callback(callback_call_started, av_OnStart, window);
-    toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, window);
-    toxav_register_callstate_callback(callback_call_rejected, av_OnReject, window);
-    toxav_register_callstate_callback(callback_call_ended, av_OnEnd, window);
-    toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, window);
-    
-    toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, window);
-    toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, window);
-    toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, window);
-    
-    toxav_register_callstate_callback(callback_recv_error, av_OnError, window);
-    toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, window);
-    
     return ASettins.av;
 }
 
 void terminate_audio()
 {
-    if ( ASettins.device[input].dhndl ) {
+    stop_transmission();
-        alcCaptureCloseDevice(ASettins.device[input].dhndl);
-    }
     
-    if ( ASettins.device[output].dhndl ) {
+    if ( ASettins.av )
-        alcCloseDevice(ASettins.device[output].dhndl);
+        toxav_kill(ASettins.av);
-        alcMakeContextCurrent(NULL);
-        alcDestroyContext(ASettins.device[output].ctx);
-    }
-    
-    toxav_kill(ASettins.av);
 }
 
 
@@ -195,6 +268,9 @@ void* transmission(void* arg)
 {
     (void)arg; /* Avoid warning */
         
+    /* Missing audio support */
+    if ( !ASettins.av ) _cbend;
+        
     ASettins.ttas = 1;
     
     /* Prepare devices */
@@ -289,17 +365,27 @@ cleanup:
         
     alDeleteSources(1, &source);
     alDeleteBuffers(openal_buffers, buffers);
-    alcMakeContextCurrent(NULL);
+    
+    device_close(NULL, input);
+    device_close(NULL, output);
     
     _cbend;
 }
 
 int start_transmission()
 {
+    if ( !ASettins.av ) return -1;
+    
     if ( !toxav_capability_supported(ASettins.av, AudioDecoding) ||
          !toxav_capability_supported(ASettins.av, AudioEncoding) )
         return -1;
     
+    /* Now open our devices */
+    if ( -1 == device_open(NULL, input) )
+        return -1;
+    if ( -1 == device_open(NULL, output))
+        return -1;
+    
     /* Don't provide support for video */
     toxav_prepare_transmission(ASettins.av, 0);
     
@@ -356,6 +442,9 @@ void callback_call_started ( void* arg )
 void callback_call_canceled ( void* arg )
 {
     CB_BODY(arg, onCancel);
+    
+    /* In case call is active */
+    stop_transmission();
 }
 void callback_call_rejected ( void* arg )
 {
@@ -369,9 +458,17 @@ void callback_call_ended ( void* arg )
 
 void callback_requ_timeout ( void* arg )
 {
-    CB_BODY(arg, onTimeout);
+    CB_BODY(arg, onRequestTimeout);
+}
+void callback_peer_timeout ( void* arg )
+{
+    CB_BODY(arg, onPeerTimeout);
+    stop_transmission();
+    /* Call is stopped manually since there might be some other
+     * actions that one can possibly take on timeout
+     */
+    toxav_stop_call(ASettins.av);
 }
-
 /* 
  * End of Callbacks 
  */
@@ -386,7 +483,7 @@ void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
     
     if (argc != 0) { error_str = "Invalid syntax!"; goto on_error; }
     
-    if ( !ASettins.av ) { error_str = "No audio supported!"; goto on_error; }
+    if ( !ASettins.av ) { error_str = "Audio not supported!"; goto on_error; }
         
     ToxAvError error = toxav_call(ASettins.av, self->num, TypeAudio, 30);
         
@@ -410,7 +507,7 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     
     if (argc != 0) { error_str = "Invalid syntax!"; goto on_error; }
     
-    if ( !ASettins.av ) { error_str = "No audio supported!"; goto on_error; }
+    if ( !ASettins.av ) { error_str = "Audio not supported!"; goto on_error; }
     
     ToxAvError error = toxav_answer(ASettins.av, TypeAudio);
     
@@ -435,7 +532,7 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     
     if (argc != 0) { error_str = "Invalid syntax!"; goto on_error; }
     
-    if ( !ASettins.av ) { error_str = "No audio supported!"; goto on_error; }
+    if ( !ASettins.av ) { error_str = "Audio not supported!"; goto on_error; }
     
     ToxAvError error = toxav_hangup(ASettins.av);
     
@@ -458,7 +555,7 @@ void cmd_cancel(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     
     if (argc != 0) { error_str = "Invalid syntax!"; goto on_error; }
     
-    if ( !ASettins.av ) { error_str = "No audio supported!"; goto on_error; }
+    if ( !ASettins.av ) { error_str = "Audio not supported!"; goto on_error; }
     
     ToxAvError error = toxav_hangup(ASettins.av);
     
@@ -488,7 +585,7 @@ void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
         goto on_error;
     }
     
-    _devices type;
+    _Devices type;
     
     if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
         type = input;
@@ -527,7 +624,7 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
         goto on_error;
     }
     
-    _devices type;
+    _Devices type;
     
     if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
         type = input;
@@ -554,45 +651,8 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
         goto on_error;
     }
 
-    /* Close default device */
+    ASettins.device[type].index = selection;
-    if ( ASettins.device[type].dhndl ) {
+    wprintw(window, "Selected: %s\n", ASettins.device[type].devices[selection]); 
-        alcCloseDevice(ASettins.device[type].dhndl);
-        
-        if ( ASettins.device[type].ctx) { /* Output device has context with it */
-            alcMakeContextCurrent(NULL);
-            alcDestroyContext(ASettins.device[type].ctx);
-        }
-    }
-    
-    /* Open new device */
-    
-    if ( type == input ) {
-        ASettins.device[input].dhndl = alcCaptureOpenDevice(
-            ASettins.device[input].devices[selection], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16, AUDIO_FRAME_SIZE * 4);
-        
-        if (alcGetError(ASettins.device[input].dhndl) != AL_NO_ERROR) {
-            error_str = "Error starting input device!";
-            ASettins.errors |= ErrorStartingCaptureDevice;
-        }
-        
-        ASettins.device[input].ctx = NULL;    
-        
-        wprintw(window, "Input device: %s\n", ASettins.device[type].devices[selection]);
-    }
-    else {
-        ASettins.device[output].dhndl = alcOpenDevice(ASettins.device[output].devices[selection]);
-        
-        if (alcGetError(ASettins.device[output].dhndl) != AL_NO_ERROR) {
-            error_str = "Error starting output device!";
-            ASettins.errors |= ErrorStartingOutputDevice;
-        }
-        
-        ASettins.device[output].ctx = alcCreateContext(ASettins.device[output].dhndl, NULL);
-        
-        wprintw(window, "Output device: %s\n", ASettins.device[type].devices[selection]);
-    }
-    
-    
     
     return;
 on_error: 

src/chat.c

@@ -443,7 +443,7 @@ void chat_onEnd (ToxWindow *self, ToxAv *av)
     
     wprintw(ctx->history, "Call ended! \n");
 }
-void chat_onTimeout (ToxWindow *self, ToxAv *av)
+void chat_onRequestTimeout (ToxWindow *self, ToxAv *av)
 {
     if (self->num != toxav_get_peer_id(av, 0))
         return;
@@ -453,6 +453,16 @@ void chat_onTimeout (ToxWindow *self, ToxAv *av)
     wprintw(ctx->history, "No answer! \n");
 }
 
+void chat_onPeerTimeout (ToxWindow *self, ToxAv *av)
+{
+    if (self->num != toxav_get_peer_id(av, 0))
+        return;
+    
+    ChatContext *ctx = self->chatwin;
+    
+    wprintw(ctx->history, "Peer disconnected; call ended! \n");
+}
+
 #endif /* _SUPPORT_AUDIO */
 
 static void send_action(ToxWindow *self, ChatContext *ctx, Tox *m, uint8_t *action) {
@@ -856,7 +866,8 @@ ToxWindow new_chat(Tox *m, int friendnum)
     ret.onCancel = &chat_onCancel;
     ret.onReject = &chat_onReject;
     ret.onEnd = &chat_onEnd;
-    ret.onTimeout = &chat_onTimeout;
+    ret.onRequestTimeout = &chat_onRequestTimeout;
+    ret.onPeerTimeout = &chat_onPeerTimeout;
 #endif /* _SUPPORT_AUDIO */
 
     uint8_t name[TOX_MAX_NAME_LENGTH] = {'\0'};

src/friendlist.c

@@ -34,7 +34,10 @@
 #include "chat.h"
 #include "friendlist.h"
 #include "misc_tools.h"
+
+#ifdef _SUPPORT_AUDIO
 #include "audio_call.h"
+#endif
 
 extern char *DATA_FILE;
 extern ToxWindow *prompt;
@@ -578,7 +581,8 @@ ToxWindow new_friendlist(void)
     ret.onCancel = &friendlist_onAv;
     ret.onReject = &friendlist_onAv;
     ret.onEnd = &friendlist_onAv;
-    ret.onTimeout = &friendlist_onAv;
+    ret.onRequestTimeout = &friendlist_onAv;
+    ret.onPeerTimeout = &friendlist_onAv;
 #endif /* _SUPPORT_AUDIO */
 
     strcpy(ret.name, "friends");

src/main.c

@@ -412,7 +412,7 @@ void exit_toxic(Tox *m)
     free(prompt->promptbuf);
     tox_kill(m);
     #ifdef _SUPPORT_AUDIO
-    terminate_audio(prompt, av);
+    terminate_audio();
     #endif /* _SUPPORT_AUDIO */
     endwin();
     exit(EXIT_SUCCESS);

src/toxic_windows.h

@@ -121,7 +121,8 @@ struct ToxWindow {
     void(*onCancel)(ToxWindow *, ToxAv *);
     void(*onReject)(ToxWindow *, ToxAv *);
     void(*onEnd)(ToxWindow *, ToxAv *);
-    void(*onTimeout)(ToxWindow *, ToxAv *);
+    void(*onRequestTimeout)(ToxWindow *, ToxAv *);
+    void(*onPeerTimeout)(ToxWindow *, ToxAv *);
     
 #endif /* _SUPPORT_AUDIO */
     

src/windows.c

@@ -393,14 +393,15 @@ void draw_active_window(Tox *m)
 
     /* Handle input */
 #ifdef HAVE_WIDECHAR
-    wget_wch(stdscr, &ch);
+    if (wget_wch(stdscr, &ch) == ERR)
 #else
-    ch = getch();
+    if ((ch = getch()) == ERR)
 #endif
+        return;
 
     if (ch == T_KEY_NEXT || ch == T_KEY_PREV) {
         set_next_window((int) ch);
-    } else if (ch != ERR) {
+    } else {
         pthread_mutex_lock(&Winthread.lock);
         a->onKey(a, m, ch);
         pthread_mutex_unlock(&Winthread.lock);