mirror of
https://github.com/Tha14/toxic.git
synced 2024-11-22 17:23:01 +01:00
Merge pull request #146 from mannol1/master
Changed code a bit and added new features
This commit is contained in:
commit
52b7719180
@ -59,7 +59,9 @@ toxic_LDADD = $(LIBTOXCORE_LDFLAGS) \
|
||||
if BUILD_AV
|
||||
|
||||
toxic_SOURCES += $(top_srcdir)/src/audio_call.c \
|
||||
$(top_srcdir)/src/audio_call.h
|
||||
$(top_srcdir)/src/audio_call.h \
|
||||
$(top_srcdir)/src/device.c \
|
||||
$(top_srcdir)/src/device.h
|
||||
|
||||
toxic_CFLAGS += $(LIBTOXAV_CFLAGS) \
|
||||
$(OPENAL_CFLAGS) \
|
||||
|
@ -2,7 +2,7 @@
|
||||
# Process this file with autoconf to produce a configure script.
|
||||
|
||||
AC_PREREQ([2.65])
|
||||
AC_INIT([toxic], [0.4.1], [https://tox.im/])
|
||||
AC_INIT([toxic], [0.4.2], [https://tox.im/])
|
||||
AC_CONFIG_AUX_DIR(configure_aux)
|
||||
AC_CONFIG_SRCDIR([src/toxic.c])
|
||||
AC_CONFIG_HEADERS([config.h])
|
||||
@ -37,7 +37,9 @@ if test -n "$DEPSEARCH"; then
|
||||
CFLAGS="$CFLAGS -I$DEPSEARCH/include"
|
||||
CPPFLAGS="$CPPFLAGS -I$DEPSEARCH/include"
|
||||
LDFLAGS="$LDFLAGS -L$DEPSEARCH/lib"
|
||||
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$DEPSEARCH/lib/pkgconfig:/usr/local/lib/pkgconfig
|
||||
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$DEPSEARCH/lib/pkgconfig:/usr/local/lib/pkgconfig
|
||||
else
|
||||
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig
|
||||
fi
|
||||
|
||||
AC_ARG_WITH(libtoxcore-headers,
|
||||
@ -417,6 +419,8 @@ if test -n "$AV_SEARCH_DIR"; then
|
||||
CPPFLAGS="$CPPFLAGS -I$AV_SEARCH_DIR/include"
|
||||
LDFLAGS="$LDFLAGS -L$AV_SEARCH_DIR/lib"
|
||||
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$AV_SEARCH_DIR/lib/pkgconfig
|
||||
else
|
||||
export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig"
|
||||
fi
|
||||
|
||||
# Check if specified enable
|
||||
|
628
src/audio_call.c
628
src/audio_call.c
@ -27,6 +27,7 @@
|
||||
#include "toxic.h"
|
||||
#include "windows.h"
|
||||
#include "audio_call.h"
|
||||
#include "device.h"
|
||||
#include "chat_commands.h"
|
||||
#include "global_commands.h"
|
||||
#include "line_info.h"
|
||||
@ -48,31 +49,34 @@
|
||||
|
||||
#define _cbend pthread_exit(NULL)
|
||||
|
||||
#define AUDIO_FRAME_SIZE (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000)
|
||||
|
||||
#define MAX_CALLS 10
|
||||
|
||||
#define _True 1
|
||||
#define _False 0
|
||||
|
||||
typedef struct _DeviceIx {
|
||||
|
||||
ALCdevice *dhndl; /* Handle of device selected/opened */
|
||||
ALCcontext *ctx; /* Device context */
|
||||
const char *devices[MAX_DEVICES]; /* Container of available devices */
|
||||
int size; /* Size of above container */
|
||||
int dix; /* Index of default device */
|
||||
int index; /* Current index */
|
||||
} DeviceIx;
|
||||
#define frame_size (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000)
|
||||
|
||||
typedef struct _Call {
|
||||
pthread_t ttid; /* Transmission thread id */
|
||||
_Bool ttas; /* Transmission thread active status (0 - stopped, 1- running) */
|
||||
int in_idx, out_idx;
|
||||
pthread_mutex_t mutex;
|
||||
} Call;
|
||||
|
||||
struct _ASettings {
|
||||
DeviceIx device[2];
|
||||
|
||||
void set_call(Call* call, _Bool start)
|
||||
{
|
||||
call->in_idx = -1;
|
||||
call->out_idx = -1;
|
||||
|
||||
if ( start ) {
|
||||
call->ttas = _True;
|
||||
pthread_mutex_init(&call->mutex, NULL);
|
||||
}
|
||||
else {
|
||||
call->ttid = 0;
|
||||
pthread_mutex_destroy(&call->mutex);
|
||||
}
|
||||
}
|
||||
|
||||
struct _ASettings {
|
||||
AudioError errors;
|
||||
|
||||
ToxAv *av;
|
||||
@ -82,17 +86,17 @@ struct _ASettings {
|
||||
Call calls[MAX_CALLS];
|
||||
} ASettins;
|
||||
|
||||
void callback_recv_invite ( int32_t call_index, void *arg );
|
||||
void callback_recv_ringing ( int32_t call_index, void *arg );
|
||||
void callback_recv_invite ( int32_t call_index, void *arg );
|
||||
void callback_recv_ringing ( int32_t call_index, void *arg );
|
||||
void callback_recv_starting ( int32_t call_index, void *arg );
|
||||
void callback_recv_ending ( int32_t call_index, void *arg );
|
||||
void callback_recv_error ( int32_t call_index, void *arg );
|
||||
void callback_call_started ( int32_t call_index, void *arg );
|
||||
void callback_recv_ending ( int32_t call_index, void *arg );
|
||||
void callback_recv_error ( int32_t call_index, void *arg );
|
||||
void callback_call_started ( int32_t call_index, void *arg );
|
||||
void callback_call_canceled ( int32_t call_index, void *arg );
|
||||
void callback_call_rejected ( int32_t call_index, void *arg );
|
||||
void callback_call_ended ( int32_t call_index, void *arg );
|
||||
void callback_requ_timeout ( int32_t call_index, void *arg );
|
||||
void callback_peer_timeout ( int32_t call_index, void *arg );
|
||||
void callback_call_ended ( int32_t call_index, void *arg );
|
||||
void callback_requ_timeout ( int32_t call_index, void *arg );
|
||||
void callback_peer_timeout ( int32_t call_index, void *arg );
|
||||
|
||||
|
||||
static void print_err (ToxWindow *self, uint8_t *error_str)
|
||||
@ -100,228 +104,45 @@ static void print_err (ToxWindow *self, uint8_t *error_str)
|
||||
line_info_add(self, NULL, NULL, NULL, error_str, SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
/* Opens device under current index
|
||||
*/
|
||||
int device_open (ToxWindow *self, _Devices type)
|
||||
{
|
||||
WINDOW *window = self->chatwin->history;
|
||||
|
||||
/* Do not error if no device */
|
||||
if ( !ASettins.device[type].size ) return 0;
|
||||
|
||||
ALCdevice *prev_device = ASettins.device[type].dhndl;
|
||||
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
uint8_t *error = NULL;
|
||||
|
||||
if ( type == input ) {
|
||||
ASettins.device[type].dhndl = alcCaptureOpenDevice(
|
||||
ASettins.device[type].devices[ASettins.device[type].index],
|
||||
av_DefaultSettings.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 ) {
|
||||
snprintf(msg, sizeof(msg), "Input device: %s", ASettins.device[type].devices[ASettins.device[type].index]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
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 ) {
|
||||
snprintf(msg, sizeof(msg), "Output device: %s", ASettins.device[type].devices[ASettins.device[type].index]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( error ) {
|
||||
if ( window ) {
|
||||
snprintf(msg, sizeof(msg), "Error: %s", error);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
return -1;
|
||||
} else return 0;
|
||||
}
|
||||
|
||||
int device_close (ToxWindow *self, _Devices type)
|
||||
{
|
||||
/* Only close if device opened */
|
||||
if ( ASettins.device[type].dhndl ) {
|
||||
uint8_t *device = NULL;
|
||||
|
||||
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 ( device == NULL ) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ( self ) {
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
snprintf(msg, sizeof(msg), "Closed %s device", device);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int device_set(ToxWindow *self, _Devices type, long int selection)
|
||||
{
|
||||
uint8_t str[MAX_STR_SIZE];
|
||||
uint8_t *s_type = type == input ? "input" : "output";
|
||||
|
||||
if ( selection < 0 || selection >= ASettins.device[type].size ) {
|
||||
snprintf(str, sizeof(str), "Cannot set audio %s device: Invalid index: %ld", s_type, selection);
|
||||
line_info_add(self, NULL, NULL, NULL, str, SYS_MSG, 0, 0);
|
||||
return -1;
|
||||
}
|
||||
|
||||
ASettins.device[type].index = selection;
|
||||
|
||||
if ( device_open(self, type) != 0 ) {
|
||||
snprintf(str, sizeof(str), "Cannot open audio %s device index: %ld", s_type, selection);
|
||||
line_info_add(self, NULL, NULL, NULL, str, SYS_MSG, 0, 0);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
ToxAv *init_audio(ToxWindow *self, Tox *tox)
|
||||
{
|
||||
ASettins.cs = av_DefaultSettings;
|
||||
ASettins.cs.video_height = ASettins.cs.video_width = 0;
|
||||
|
||||
ASettins.errors = NoError;
|
||||
ASettins.errors = ae_None;
|
||||
|
||||
memset(ASettins.calls, 0, sizeof(Call) * 10);
|
||||
|
||||
/* Capture devices */
|
||||
const char *stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
|
||||
ASettins.device[input].size = 0;
|
||||
|
||||
/* Streaming stuff from core */
|
||||
|
||||
if ( stringed_device_list ) {
|
||||
const char *default_device = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
|
||||
ASettins.av = toxav_new(tox, MAX_CALLS);
|
||||
|
||||
for ( ; *stringed_device_list; ++ASettins.device[input].size ) {
|
||||
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].index = ASettins.device[input].dix = ASettins.device[input].size;
|
||||
|
||||
stringed_device_list += strlen( stringed_device_list ) + 1;
|
||||
}
|
||||
if ( !ASettins.av ) {
|
||||
ASettins.errors |= ae_StartingCoreAudio;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ( init_devices(ASettins.av) == de_InternalError ) {
|
||||
line_info_add(self, NULL, NULL, NULL, "Failed to init devices", SYS_MSG, 0, 0);
|
||||
toxav_kill(ASettins.av);
|
||||
return ASettins.av = NULL;
|
||||
}
|
||||
|
||||
toxav_register_callstate_callback(callback_call_started, av_OnStart, self);
|
||||
toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, self);
|
||||
toxav_register_callstate_callback(callback_call_rejected, av_OnReject, self);
|
||||
toxav_register_callstate_callback(callback_call_ended, av_OnEnd, self);
|
||||
toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, self);
|
||||
|
||||
/* Output devices */
|
||||
stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
|
||||
ASettins.device[output].size = 0;
|
||||
toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, self);
|
||||
toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, self);
|
||||
toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, self);
|
||||
|
||||
if ( stringed_device_list ) {
|
||||
const char *default_device = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
|
||||
|
||||
for ( ; *stringed_device_list; ++ASettins.device[output].size ) {
|
||||
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].index = ASettins.device[output].dix = ASettins.device[output].size;
|
||||
|
||||
stringed_device_list += strlen( stringed_device_list ) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!ASettins.device[input].size && !ASettins.device[output].size) {
|
||||
uint8_t *msg = "No devices: disabling audio!";
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
ASettins.av = NULL;
|
||||
} else {
|
||||
/* Streaming stuff from core */
|
||||
|
||||
ASettins.av = toxav_new(tox, MAX_CALLS);
|
||||
|
||||
if ( !ASettins.av ) {
|
||||
ASettins.errors |= ErrorStartingCoreAudio;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
toxav_register_callstate_callback(callback_call_started, av_OnStart, self);
|
||||
toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, self);
|
||||
toxav_register_callstate_callback(callback_call_rejected, av_OnReject, self);
|
||||
toxav_register_callstate_callback(callback_call_ended, av_OnEnd, self);
|
||||
toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, self);
|
||||
|
||||
toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, self);
|
||||
toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, self);
|
||||
toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, self);
|
||||
|
||||
toxav_register_callstate_callback(callback_recv_error, av_OnError, self);
|
||||
toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, self);
|
||||
toxav_register_callstate_callback(callback_peer_timeout, av_OnPeerTimeout, self);
|
||||
}
|
||||
toxav_register_callstate_callback(callback_recv_error, av_OnError, self);
|
||||
toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, self);
|
||||
toxav_register_callstate_callback(callback_peer_timeout, av_OnPeerTimeout, self);
|
||||
|
||||
|
||||
return ASettins.av;
|
||||
}
|
||||
@ -335,159 +156,112 @@ void terminate_audio()
|
||||
if ( ASettins.av )
|
||||
toxav_kill(ASettins.av);
|
||||
|
||||
device_close(NULL, input);
|
||||
device_close(NULL, output);
|
||||
terminate_devices();
|
||||
}
|
||||
|
||||
int errors()
|
||||
void read_device_callback (const int16_t* captured, uint32_t size, void* data)
|
||||
{
|
||||
return ASettins.errors;
|
||||
int32_t call_index = *((int32_t*)data); /* TODO: Or pass an array of call_idx's */
|
||||
|
||||
uint8_t encoded_payload[RTP_PAYLOAD_SIZE];
|
||||
int32_t payload_size = toxav_prepare_audio_frame(ASettins.av, call_index, encoded_payload, RTP_PAYLOAD_SIZE, captured, size);
|
||||
if ( payload_size <= 0 || toxav_send_audio(ASettins.av, call_index, encoded_payload, payload_size) < 0 ) {
|
||||
/*fprintf(stderr, "Could not encode audio packet\n");*/
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Transmission
|
||||
*/
|
||||
|
||||
void *transmission(void *arg)
|
||||
{
|
||||
{
|
||||
#define lock pthread_mutex_lock(&this_call->mutex)
|
||||
#define unlock pthread_mutex_unlock(&this_call->mutex)
|
||||
|
||||
ToxWindow* self = arg;
|
||||
int32_t call_index = self->call_index;
|
||||
int32_t call_index = self->call_idx;
|
||||
|
||||
/* Missing audio support */
|
||||
if ( !ASettins.av ) _cbend;
|
||||
|
||||
Call* this_call = &ASettins.calls[call_index];
|
||||
|
||||
this_call->ttas = _True;
|
||||
|
||||
/* Prepare devices */
|
||||
alcCaptureStart(ASettins.device[input].dhndl);
|
||||
alcMakeContextCurrent(ASettins.device[output].ctx);
|
||||
|
||||
int32_t dec_frame_len;
|
||||
int16_t frame[4096];
|
||||
int32_t sample = 0;
|
||||
uint32_t buffer;
|
||||
int32_t ready;
|
||||
int32_t openal_buffers = 5;
|
||||
uint32_t source, *buffers;
|
||||
uint8_t encoded_payload[RTP_PAYLOAD_SIZE];
|
||||
const int32_t frame_size = AUDIO_FRAME_SIZE;
|
||||
|
||||
/* Prepare buffers */
|
||||
buffers = calloc(sizeof(uint32_t), openal_buffers);
|
||||
alGenBuffers(openal_buffers, buffers);
|
||||
alGenSources((uint32_t)1, &source);
|
||||
alSourcei(source, AL_LOOPING, AL_FALSE);
|
||||
|
||||
uint16_t zeros[frame_size];
|
||||
memset(zeros, 0, frame_size);
|
||||
int16_t PCM[frame_size];
|
||||
|
||||
int32_t i = 0;
|
||||
|
||||
for (; i < openal_buffers; ++i) {
|
||||
alBufferData(buffers[i], AL_FORMAT_MONO16, zeros, frame_size, 48000);
|
||||
}
|
||||
|
||||
alSourceQueueBuffers(source, openal_buffers, buffers);
|
||||
alSourcePlay(source);
|
||||
|
||||
if (alGetError() != AL_NO_ERROR) {
|
||||
/* Print something? */
|
||||
/*fprintf(stderr, "Error starting audio\n");*/
|
||||
|
||||
if ( open_primary_device(input, &this_call->in_idx) != de_None ) goto cleanup;
|
||||
if ( register_device_callback(call_index, this_call->in_idx, read_device_callback, &call_index, _True) != de_None)
|
||||
/* Set VAD as true for all; TODO: Make it more dynamic */
|
||||
goto cleanup;
|
||||
|
||||
if ( open_primary_device(output, &this_call->out_idx) != de_None ) goto cleanup;
|
||||
|
||||
// goto cleanup;
|
||||
}
|
||||
|
||||
/* Start transmission */
|
||||
while (this_call->ttas) {
|
||||
|
||||
alcGetIntegerv(ASettins.device[input].dhndl, ALC_CAPTURE_SAMPLES, (int32_t) sizeof(int32_t), &sample);
|
||||
|
||||
/* RECORD AND SEND */
|
||||
if (sample >= frame_size) {
|
||||
alcCaptureSamples(ASettins.device[input].dhndl, frame, frame_size);
|
||||
|
||||
int32_t payload_size = toxav_prepare_audio_frame(ASettins.av, call_index, encoded_payload, RTP_PAYLOAD_SIZE, frame, frame_size);
|
||||
if ( payload_size <= 0 || toxav_send_audio(ASettins.av, call_index, encoded_payload, payload_size) < 0 ) {
|
||||
/*fprintf(stderr, "Could not encode audio packet\n");*/
|
||||
}
|
||||
|
||||
lock;
|
||||
|
||||
if (playback_device_ready(this_call->out_idx) == de_Busy) {
|
||||
unlock;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* PLAYBACK */
|
||||
|
||||
alGetSourcei(source, AL_BUFFERS_PROCESSED, &ready);
|
||||
|
||||
if (ready <= 0) continue;
|
||||
|
||||
|
||||
dec_frame_len = toxav_recv_audio(ASettins.av, call_index, frame_size, PCM);
|
||||
|
||||
/* Play the packet */
|
||||
if (dec_frame_len > 0) {
|
||||
alSourceUnqueueBuffers(source, 1, &buffer);
|
||||
alBufferData(buffer, AL_FORMAT_MONO16, PCM, dec_frame_len * 2 * 1, 48000);
|
||||
int32_t error = alGetError();
|
||||
|
||||
if (error != AL_NO_ERROR) {
|
||||
fprintf(stderr, "Error setting buffer %d\n", error);
|
||||
break;
|
||||
}
|
||||
|
||||
alSourceQueueBuffers(source, 1, &buffer);
|
||||
|
||||
if (alGetError() != AL_NO_ERROR) {
|
||||
fprintf(stderr, "Error: could not buffer audio\n");
|
||||
break;
|
||||
}
|
||||
|
||||
alGetSourcei(source, AL_SOURCE_STATE, &ready);
|
||||
|
||||
if (ready != AL_PLAYING) alSourcePlay(source);
|
||||
write_out(this_call->out_idx, PCM, dec_frame_len, av_DefaultSettings.audio_channels);
|
||||
}
|
||||
else {
|
||||
/* Error ignored */
|
||||
else if (dec_frame_len != 0) {
|
||||
/* >implying it'll ever get an error */
|
||||
}
|
||||
|
||||
|
||||
unlock;
|
||||
|
||||
usleep(1000);
|
||||
}
|
||||
|
||||
cleanup:
|
||||
|
||||
alDeleteSources(1, &source);
|
||||
alDeleteBuffers(openal_buffers, buffers);
|
||||
/*
|
||||
device_close(NULL, input);
|
||||
device_close(NULL, output);*/
|
||||
|
||||
if ( this_call->in_idx != -1 ) if ( close_device(input, this_call->in_idx) != de_None )
|
||||
line_info_add(self, NULL, NULL, NULL, "Failed to close input device!", SYS_MSG, 0, 0);
|
||||
|
||||
if ( this_call->out_idx != -1 ) if ( close_device(output, this_call->out_idx) != de_None )
|
||||
line_info_add(self, NULL, NULL, NULL, "Failed to close output device!", SYS_MSG, 0, 0);
|
||||
|
||||
set_call(this_call, _False);
|
||||
|
||||
_cbend;
|
||||
}
|
||||
|
||||
int start_transmission(ToxWindow *self)
|
||||
{
|
||||
if ( !ASettins.av || self->call_index == -1 ) return -1;
|
||||
if ( !ASettins.av || self->call_idx == -1 ) return -1;
|
||||
|
||||
/* Don't provide support for video */
|
||||
if ( 0 != toxav_prepare_transmission(ASettins.av, self->call_index, &ASettins.cs, 0) ) {
|
||||
if ( 0 != toxav_prepare_transmission(ASettins.av, self->call_idx, &ASettins.cs, 0) ) {
|
||||
line_info_add(self, NULL, NULL, NULL, "Could not prepare transmission", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
if ( !toxav_capability_supported(ASettins.av, self->call_index, AudioDecoding) ||
|
||||
!toxav_capability_supported(ASettins.av, self->call_index, AudioEncoding) )
|
||||
if ( !toxav_capability_supported(ASettins.av, self->call_idx, AudioDecoding) ||
|
||||
!toxav_capability_supported(ASettins.av, self->call_idx, AudioEncoding) )
|
||||
return -1;
|
||||
|
||||
if ( 0 != pthread_create(&ASettins.calls[self->call_index].ttid, NULL, transmission, self ) &&
|
||||
0 != pthread_detach(ASettins.calls[self->call_index].ttid) ) {
|
||||
set_call(&ASettins.calls[self->call_idx], _True);
|
||||
|
||||
if ( 0 != pthread_create(&ASettins.calls[self->call_idx].ttid, NULL, transmission, self ) &&
|
||||
0 != pthread_detach(ASettins.calls[self->call_idx].ttid) ) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int stop_transmission(int call_index)
|
||||
{
|
||||
toxav_kill_transmission(ASettins.av, call_index);
|
||||
ASettins.calls[call_index].ttas = _False;
|
||||
if ( ASettins.calls[call_index].ttas ) {
|
||||
toxav_kill_transmission(ASettins.av, call_index);
|
||||
ASettins.calls[call_index].ttas = _False;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* End of transmission
|
||||
@ -517,7 +291,7 @@ void callback_recv_starting ( int32_t call_index, void* arg )
|
||||
ToxWindow* windows = arg;
|
||||
int i;
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i)
|
||||
if (windows[i].onStarting != NULL && windows[i].call_index == call_index) {
|
||||
if (windows[i].onStarting != NULL && windows[i].call_idx == call_index) {
|
||||
windows[i].onStarting(&windows[i], ASettins.av, call_index);
|
||||
if ( 0 != start_transmission(&windows[i]) ) {/* YEAH! */
|
||||
line_info_add(&windows[i], NULL, NULL, NULL, "Error starting transmission!", SYS_MSG, 0, 0);
|
||||
@ -540,7 +314,7 @@ void callback_call_started ( int32_t call_index, void* arg )
|
||||
ToxWindow* windows = arg;
|
||||
int i;
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i)
|
||||
if (windows[i].onStart != NULL && windows[i].call_index == call_index) {
|
||||
if (windows[i].onStart != NULL && windows[i].call_idx == call_index) {
|
||||
windows[i].onStart(&windows[i], ASettins.av, call_index);
|
||||
if ( 0 != start_transmission(&windows[i]) ) {/* YEAH! */
|
||||
line_info_add(&windows[i], NULL, NULL, NULL, "Error starting transmission!", SYS_MSG, 0, 0);
|
||||
@ -601,7 +375,7 @@ void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
ToxAvError error = toxav_call(ASettins.av, &self->call_index, self->num, TypeAudio, 30);
|
||||
ToxAvError error = toxav_call(ASettins.av, &self->call_idx, self->num, TypeAudio, 30);
|
||||
|
||||
if ( error != ErrorNone ) {
|
||||
if ( error == ErrorAlreadyInCall ) error_str = "Already in a call!";
|
||||
@ -610,7 +384,7 @@ void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
snprintf(msg, sizeof(msg), "Calling... idx: %d", self->call_index);
|
||||
snprintf(msg, sizeof(msg), "Calling... idx: %d", self->call_idx);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
|
||||
return;
|
||||
@ -633,7 +407,7 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
ToxAvError error = toxav_answer(ASettins.av, self->call_index, TypeAudio);
|
||||
ToxAvError error = toxav_answer(ASettins.av, self->call_idx, TypeAudio);
|
||||
|
||||
if ( error != ErrorNone ) {
|
||||
if ( error == ErrorInvalidState ) error_str = "Cannot answer in invalid state!";
|
||||
@ -664,7 +438,7 @@ void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
ToxAvError error = toxav_reject(ASettins.av, self->call_index, "Why not?");
|
||||
ToxAvError error = toxav_reject(ASettins.av, self->call_idx, "Why not?");
|
||||
|
||||
if ( error != ErrorNone ) {
|
||||
if ( error == ErrorInvalidState ) error_str = "Cannot reject in invalid state!";
|
||||
@ -695,7 +469,7 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
ToxAvError error = toxav_hangup(ASettins.av, self->call_index);
|
||||
ToxAvError error = toxav_hangup(ASettins.av, self->call_idx);
|
||||
|
||||
if ( error != ErrorNone ) {
|
||||
if ( error == ErrorInvalidState ) error_str = "Cannot hangup in invalid state!";
|
||||
@ -724,7 +498,7 @@ void cmd_cancel(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
ToxAvError error = toxav_cancel(ASettins.av, self->call_index, self->num,
|
||||
ToxAvError error = toxav_cancel(ASettins.av, self->call_idx, self->num,
|
||||
"Only those who appreciate small things know the beauty that is life");
|
||||
|
||||
if ( error != ErrorNone ) {
|
||||
@ -754,7 +528,7 @@ void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
_Devices type;
|
||||
DeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
type = input;
|
||||
@ -768,18 +542,14 @@ void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
|
||||
return;
|
||||
}
|
||||
|
||||
int i = 0;
|
||||
|
||||
for ( ; i < ASettins.device[type].size; i ++) {
|
||||
snprintf(msg, sizeof(msg), "%d: %s", i, ASettins.device[type].devices[i]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
print_devices(self, type);
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
}
|
||||
|
||||
/* This changes primary device only */
|
||||
void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
@ -793,12 +563,7 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( ASettins.calls[self->call_index].ttas ) { /* Transmission is active */
|
||||
error_str = "Cannot change device while active transmission";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
_Devices type;
|
||||
DeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
type = input;
|
||||
@ -821,22 +586,151 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( device_close(self, type) != 0 ) {
|
||||
error_str = "Could not close device!";
|
||||
if ( set_primary_device(type, selection) == de_InvalidSelection ) {
|
||||
error_str="Invalid selection!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( device_set(self, type, selection ) == 0) {
|
||||
/*snprintf(msg, sizeof(msg), "Selected: %s", ASettins.device[type].devices[selection]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);*/
|
||||
}
|
||||
|
||||
if ( device_open(self, type) == 0 ) {
|
||||
snprintf(msg, sizeof(msg), "Now using: %s", ASettins.device[type].devices[selection]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
}
|
||||
|
||||
void cmd_ccur_device(WINDOW * window, ToxWindow * self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
uint8_t *error_str;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else if ( argc < 2 ) error_str = "Must have id!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
DeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
type = input;
|
||||
|
||||
else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
type = output;
|
||||
|
||||
else {
|
||||
snprintf(msg, sizeof(msg), "Invalid type: %s", argv[1]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
char *end;
|
||||
long int selection = strtol(argv[2], &end, 10);
|
||||
|
||||
if ( *end ) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( selection_valid(type, selection) == de_InvalidSelection ) {
|
||||
error_str="Invalid selection!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
/* If call is active, change device */
|
||||
if ( self->call_idx > -1) {
|
||||
Call* this_call = &ASettins.calls[self->call_idx];
|
||||
if (this_call->ttas) {
|
||||
if (type == output) {
|
||||
pthread_mutex_lock(&this_call->mutex);
|
||||
close_device(output, this_call->out_idx);
|
||||
open_device(output, selection, &this_call->out_idx);
|
||||
pthread_mutex_unlock(&this_call->mutex);
|
||||
}
|
||||
else {
|
||||
/* TODO: check for failure */
|
||||
close_device(input, this_call->in_idx);
|
||||
open_device(input, selection, &this_call->in_idx);
|
||||
/* Set VAD as true for all; TODO: Make it more dynamic */
|
||||
register_device_callback(self->call_idx, this_call->in_idx, read_device_callback, &self->call_idx, _True);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self->device_selection[type] = selection;
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
}
|
||||
|
||||
void cmd_mute(WINDOW * window, ToxWindow * self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
uint8_t *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
DeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
type = input;
|
||||
|
||||
else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
type = output;
|
||||
|
||||
else {
|
||||
snprintf(msg, sizeof(msg), "Invalid type: %s", argv[1]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* If call is active, use this_call values */
|
||||
if ( self->call_idx > -1) {
|
||||
Call* this_call = &ASettins.calls[self->call_idx];
|
||||
|
||||
pthread_mutex_lock(&this_call->mutex);
|
||||
device_mute(type, type == input ? this_call->in_idx : this_call->out_idx);
|
||||
pthread_mutex_unlock(&this_call->mutex);
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
}
|
||||
|
||||
void cmd_sense(WINDOW * window, ToxWindow * self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
uint8_t *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Must have value!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
char *end;
|
||||
float value = strtof(argv[1], &end);
|
||||
|
||||
if ( *end ) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
/* Call must be active */
|
||||
if ( self->call_idx > -1) device_set_VAD_treshold(ASettins.calls[self->call_idx].in_idx, value);
|
||||
|
||||
return;
|
||||
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
}
|
||||
|
@ -25,22 +25,15 @@
|
||||
|
||||
#include <tox/toxav.h>
|
||||
|
||||
#include "toxic.h"
|
||||
#include "windows.h"
|
||||
|
||||
#define MAX_DEVICES 32
|
||||
#include "device.h"
|
||||
|
||||
typedef enum _AudioError {
|
||||
NoError = 0,
|
||||
ErrorStartingCaptureDevice = 1 << 0,
|
||||
ErrorStartingOutputDevice = 1 << 1,
|
||||
ErrorStartingCoreAudio = 1 << 2
|
||||
ae_None = 0,
|
||||
ae_StartingCaptureDevice = 1 << 0,
|
||||
ae_StartingOutputDevice = 1 << 1,
|
||||
ae_StartingCoreAudio = 1 << 2
|
||||
} AudioError;
|
||||
|
||||
typedef enum _Devices {
|
||||
input,
|
||||
output,
|
||||
} _Devices;
|
||||
|
||||
/* You will have to pass pointer to first member of 'windows'
|
||||
* declared in windows.c otherwise undefined behaviour will
|
||||
@ -48,10 +41,8 @@ typedef enum _Devices {
|
||||
ToxAv *init_audio(ToxWindow *self, Tox *tox);
|
||||
void terminate_audio();
|
||||
|
||||
int errors();
|
||||
|
||||
int start_transmission(ToxWindow *self);
|
||||
int stop_transmission(int call_index);
|
||||
int device_set(ToxWindow *self, _Devices type, long int selection);
|
||||
|
||||
|
||||
#endif /* _audio_h */
|
||||
|
37
src/chat.c
37
src/chat.c
@ -54,7 +54,7 @@ extern struct _Winthread Winthread;
|
||||
extern struct user_settings *user_settings;
|
||||
|
||||
#ifdef _SUPPORT_AUDIO
|
||||
#define AC_NUM_CHAT_COMMANDS 23
|
||||
#define AC_NUM_CHAT_COMMANDS 26
|
||||
#else
|
||||
#define AC_NUM_CHAT_COMMANDS 18
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
@ -87,6 +87,9 @@ static const uint8_t chat_cmd_list[AC_NUM_CHAT_COMMANDS][MAX_CMDNAME_SIZE] = {
|
||||
{ "/answer" },
|
||||
{ "/reject" },
|
||||
{ "/hangup" },
|
||||
{ "/sdev" },
|
||||
{ "/mute" },
|
||||
{ "/sense" },
|
||||
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
};
|
||||
@ -430,7 +433,7 @@ void chat_onInvite (ToxWindow *self, ToxAv *av, int call_index)
|
||||
|
||||
/* call_index is set here and reset on call end */
|
||||
|
||||
self->call_index = call_index;
|
||||
self->call_idx = call_index;
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, "Incoming audio call! Type: \"/answer\" or \"/reject\"", SYS_MSG, 0, 0);
|
||||
|
||||
@ -439,7 +442,7 @@ void chat_onInvite (ToxWindow *self, ToxAv *av, int call_index)
|
||||
|
||||
void chat_onRinging (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if ( self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if ( self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, "Ringing...\"cancel\" ?", SYS_MSG, 0, 0);
|
||||
@ -447,7 +450,7 @@ void chat_onRinging (ToxWindow *self, ToxAv *av, int call_index)
|
||||
|
||||
void chat_onStarting (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if ( self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if ( self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, "Call started! Type: \"/hangup\" to end it.", SYS_MSG, 0, 0);
|
||||
@ -455,23 +458,25 @@ void chat_onStarting (ToxWindow *self, ToxAv *av, int call_index)
|
||||
|
||||
void chat_onEnding (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if (self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if (self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "Call ended!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
void chat_onError (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if (self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if (self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "Error!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
void chat_onStart (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if ( self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if ( self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, "Call started! Type: \"/hangup\" to end it.", SYS_MSG, 0, 0);
|
||||
@ -479,41 +484,46 @@ void chat_onStart (ToxWindow *self, ToxAv *av, int call_index)
|
||||
|
||||
void chat_onCancel (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if ( self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if ( self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "Call canceled!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
void chat_onReject (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if (self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if (self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "Rejected!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
void chat_onEnd (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if (self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if (self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "Call ended!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
void chat_onRequestTimeout (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if (self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if (self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "No answer!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
void chat_onPeerTimeout (ToxWindow *self, ToxAv *av, int call_index)
|
||||
{
|
||||
if (self->call_index != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
if (self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
|
||||
return;
|
||||
|
||||
self->call_idx = -1;
|
||||
line_info_add(self, NULL, NULL, NULL, "Peer disconnected; call ended!", SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
@ -949,7 +959,8 @@ ToxWindow new_chat(Tox *m, int32_t friendnum)
|
||||
ret.onRequestTimeout = &chat_onRequestTimeout;
|
||||
ret.onPeerTimeout = &chat_onPeerTimeout;
|
||||
|
||||
ret.call_index = -1;
|
||||
ret.call_idx = -1;
|
||||
ret.device_selection[0] = ret.device_selection[1] = -1;
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
uint8_t name[TOX_MAX_NAME_LENGTH] = {'\0'};
|
||||
|
@ -59,7 +59,7 @@ void cmd_chat_help(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*arg
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
|
||||
|
||||
#ifdef _SUPPORT_AUDIO
|
||||
#define NUMLINES 13
|
||||
#define NUMLINES 16
|
||||
#else
|
||||
#define NUMLINES 9
|
||||
#endif
|
||||
@ -72,6 +72,9 @@ void cmd_chat_help(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*arg
|
||||
{ " /answer : Answer incomming call" },
|
||||
{ " /reject : Reject incoming call" },
|
||||
{ " /hangup : Hangup active call" },
|
||||
{ " /sdev <type> <id> : Change active device" },
|
||||
{ " /mute <type> : Mute active device if in call" },
|
||||
{ " /sense <value> : VAD sensitivity treshold" },
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
{ " /invite <n> : Invite friend to a group chat" },
|
||||
{ " /join : Join a pending group chat" },
|
||||
|
@ -39,6 +39,9 @@ void cmd_answer(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZ
|
||||
void cmd_reject(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
|
||||
void cmd_hangup(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
|
||||
void cmd_cancel(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
|
||||
void cmd_ccur_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
|
||||
void cmd_mute(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
|
||||
void cmd_sense(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
#endif /* #define _chat_commands_h */
|
||||
|
420
src/device.c
Normal file
420
src/device.c
Normal file
@ -0,0 +1,420 @@
|
||||
#include "audio_call.h"
|
||||
#include "line_info.h"
|
||||
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include <OpenAL/al.h>
|
||||
#include <OpenAL/alc.h>
|
||||
#else
|
||||
#include <AL/al.h>
|
||||
#include <AL/alc.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include <tox/toxav.h>
|
||||
|
||||
#define openal_bufs 5
|
||||
#define sample_rate 48000
|
||||
#define inline__ inline __attribute__((always_inline))
|
||||
#define frame_size (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000)
|
||||
|
||||
typedef struct _Device {
|
||||
ALCdevice *dhndl; /* Handle of device selected/opened */
|
||||
ALCcontext *ctx; /* Device context */
|
||||
DataHandleCallback cb; /* Use this to handle data from input device usually */
|
||||
void* cb_data; /* Data to be passed to callback */
|
||||
int32_t call_idx; /* ToxAv call index */
|
||||
|
||||
uint32_t source, buffers[openal_bufs]; /* Playback source/buffers */
|
||||
size_t ref_count;
|
||||
int32_t selection;
|
||||
_Bool enable_VAD;
|
||||
_Bool muted;
|
||||
float VAD_treshold; /* 40 is usually recommended value */
|
||||
} Device;
|
||||
|
||||
const char *ddevice_names[2]; /* Default device */
|
||||
const char *devices_names[2][MAX_DEVICES]; /* Container of available devices */
|
||||
static int size[2]; /* Size of above containers */
|
||||
Device *running[2][MAX_DEVICES]={NULL}; /* Running devices */
|
||||
uint32_t primary_device[2] = {0}; /* Primary device */
|
||||
|
||||
static ToxAv* av = NULL;
|
||||
|
||||
/* q_mutex */
|
||||
#define lock pthread_mutex_lock(&mutex)
|
||||
#define unlock pthread_mutex_unlock(&mutex)
|
||||
pthread_mutex_t mutex;
|
||||
|
||||
|
||||
_Bool thread_running = _True,
|
||||
thread_paused = _True; /* Thread control */
|
||||
|
||||
void* thread_poll(void*);
|
||||
/* Meet devices */
|
||||
DeviceError init_devices(ToxAv* av_)
|
||||
{
|
||||
const char *stringed_device_list;
|
||||
|
||||
|
||||
|
||||
size[input] = 0;
|
||||
if ( (stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)) ) {
|
||||
ddevice_names[input] = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
|
||||
|
||||
for ( ; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input] ) {
|
||||
devices_names[input][size[input]] = stringed_device_list;
|
||||
stringed_device_list += strlen( stringed_device_list ) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
size[output] = 0;
|
||||
if ( (stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER)) ) {
|
||||
ddevice_names[output] = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
|
||||
|
||||
for ( ; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output] ) {
|
||||
devices_names[output][size[output]] = stringed_device_list;
|
||||
stringed_device_list += strlen( stringed_device_list ) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Start poll thread
|
||||
|
||||
pthread_mutex_init(&mutex, NULL);
|
||||
|
||||
pthread_t thread_id;
|
||||
if ( pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0)
|
||||
return de_InternalError;
|
||||
|
||||
av = av_;
|
||||
|
||||
return ae_None;
|
||||
}
|
||||
|
||||
DeviceError terminate_devices()
|
||||
{
|
||||
/* Cleanup if needed */
|
||||
thread_running = false;
|
||||
usleep(20000);
|
||||
|
||||
pthread_mutex_destroy(&mutex);
|
||||
|
||||
return ae_None;
|
||||
}
|
||||
|
||||
DeviceError device_mute(DeviceType type, uint32_t device_idx)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
lock;
|
||||
|
||||
Device* device = running[type][device_idx];
|
||||
|
||||
if (!device) {
|
||||
unlock;
|
||||
return de_DeviceNotActive;
|
||||
}
|
||||
|
||||
device->muted = !device->muted;
|
||||
|
||||
unlock;
|
||||
return de_None;
|
||||
}
|
||||
|
||||
DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
lock;
|
||||
|
||||
Device* device = running[input][device_idx];
|
||||
|
||||
if (!device) {
|
||||
unlock;
|
||||
return de_DeviceNotActive;
|
||||
}
|
||||
|
||||
device->VAD_treshold = value;
|
||||
|
||||
unlock;
|
||||
return de_None;
|
||||
}
|
||||
|
||||
DeviceError set_primary_device(DeviceType type, int32_t selection)
|
||||
{
|
||||
if (size[type] <= selection || selection < 0) return de_InvalidSelection;
|
||||
primary_device[type] = selection;
|
||||
|
||||
return de_None;
|
||||
}
|
||||
|
||||
DeviceError open_primary_device(DeviceType type, uint32_t* device_idx)
|
||||
{
|
||||
return open_device(type, primary_device[type], device_idx);
|
||||
}
|
||||
|
||||
|
||||
// TODO: generate buffers separately
|
||||
DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx)
|
||||
{
|
||||
if (size[type] <= selection || selection < 0) return de_InvalidSelection;
|
||||
|
||||
lock;
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; i < MAX_DEVICES && running[type][i] != NULL; i ++);
|
||||
|
||||
if (i == size[type]) { unlock; return de_AllDevicesBusy; }
|
||||
else *device_idx = i;
|
||||
|
||||
Device* device = running[type][*device_idx] = calloc(1, sizeof(Device));;
|
||||
device->selection = selection;
|
||||
|
||||
for (i = 0; i < *device_idx; i ++) { /* Check if any previous has the same selection */
|
||||
if ( running[type][i]->selection == selection ) {
|
||||
device->dhndl = running[type][i]->dhndl;
|
||||
if (type == output) {
|
||||
device->ctx = running[type][i]->ctx;
|
||||
memcpy(device->buffers, running[type][i]->buffers, sizeof(running[type][i]->buffers));
|
||||
device->source = running[type][i]->source;
|
||||
}
|
||||
device->ref_count++;
|
||||
unlock;
|
||||
return de_None;
|
||||
}
|
||||
}
|
||||
|
||||
if (type == input) {
|
||||
device->dhndl = alcCaptureOpenDevice(devices_names[type][selection],
|
||||
av_DefaultSettings.audio_sample_rate, AL_FORMAT_MONO16, frame_size * 4);
|
||||
device->VAD_treshold = 40.0;
|
||||
}
|
||||
else {
|
||||
device->dhndl = alcOpenDevice(devices_names[type][selection]);
|
||||
if ( !device->dhndl ) {
|
||||
free(device);
|
||||
running[type][*device_idx] = NULL;
|
||||
unlock;
|
||||
return de_FailedStart;
|
||||
}
|
||||
|
||||
device->ctx = alcCreateContext(device->dhndl, NULL);
|
||||
alcMakeContextCurrent(device->ctx);
|
||||
|
||||
alGenBuffers(openal_bufs, device->buffers);
|
||||
alGenSources((uint32_t)1, &device->source);
|
||||
alSourcei(device->source, AL_LOOPING, AL_FALSE);
|
||||
|
||||
uint16_t zeros[frame_size];
|
||||
memset(zeros, 0, frame_size);
|
||||
|
||||
for ( i =0; i < openal_bufs; ++i) {
|
||||
alBufferData(device->buffers[i], AL_FORMAT_MONO16, zeros, frame_size, sample_rate);
|
||||
}
|
||||
|
||||
alSourceQueueBuffers(device->source, openal_bufs, device->buffers);
|
||||
alSourcePlay(device->source);
|
||||
}
|
||||
|
||||
if (alcGetError(device->dhndl) != AL_NO_ERROR) {
|
||||
free(device);
|
||||
running[type][*device_idx] = NULL;
|
||||
unlock;
|
||||
return de_FailedStart;
|
||||
}
|
||||
|
||||
if (type == input) {
|
||||
alcCaptureStart(device->dhndl);
|
||||
thread_paused = _False;
|
||||
}
|
||||
|
||||
unlock;
|
||||
return de_None;
|
||||
}
|
||||
|
||||
DeviceError close_device(DeviceType type, uint32_t device_idx)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
|
||||
lock;
|
||||
Device* device = running[type][device_idx];
|
||||
|
||||
if (!device) {
|
||||
unlock;
|
||||
return de_DeviceNotActive;
|
||||
}
|
||||
|
||||
if ( !(device->ref_count--) ) {
|
||||
running[type][device_idx] = NULL;
|
||||
unlock;
|
||||
|
||||
DeviceError rc = de_None;
|
||||
|
||||
if (type == input) {
|
||||
if ( !alcCaptureCloseDevice(device->dhndl) ) rc = de_AlError;
|
||||
}
|
||||
else {
|
||||
if (alcGetCurrentContext() != device->ctx) alcMakeContextCurrent(device->ctx);
|
||||
|
||||
alDeleteSources(1, &device->source);
|
||||
alDeleteBuffers(openal_bufs, device->buffers);
|
||||
|
||||
if ( !alcCloseDevice(device->dhndl) ) rc = de_AlError;
|
||||
alcMakeContextCurrent(NULL);
|
||||
if ( device->ctx ) alcDestroyContext(device->ctx);
|
||||
}
|
||||
|
||||
free(device);
|
||||
return rc;
|
||||
}
|
||||
|
||||
return de_None;
|
||||
}
|
||||
|
||||
DeviceError register_device_callback( int32_t call_idx, uint32_t device_idx, DataHandleCallback callback, void* data, _Bool enable_VAD)
|
||||
{
|
||||
if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
|
||||
return de_InvalidSelection;
|
||||
|
||||
lock;
|
||||
running[input][device_idx]->cb = callback;
|
||||
running[input][device_idx]->cb_data = data;
|
||||
running[input][device_idx]->enable_VAD = enable_VAD;
|
||||
running[input][device_idx]->call_idx = call_idx;
|
||||
unlock;
|
||||
|
||||
return de_None;
|
||||
}
|
||||
|
||||
inline__ DeviceError playback_device_ready(uint32_t device_idx)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
|
||||
Device* device = running[output][device_idx];
|
||||
|
||||
if (!device) return de_DeviceNotActive;
|
||||
|
||||
int32_t ready;
|
||||
alGetSourcei(device->source, AL_BUFFERS_PROCESSED, &ready);
|
||||
|
||||
return ready <= 0 ? de_Busy : de_None;
|
||||
}
|
||||
|
||||
/* TODO: thread safety? */
|
||||
inline__ DeviceError write_out(uint32_t device_idx, int16_t* data, uint32_t lenght, uint8_t channels)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
|
||||
Device* device = running[output][device_idx];
|
||||
|
||||
if (!device || device->muted) return de_DeviceNotActive;
|
||||
|
||||
alcMakeContextCurrent(device->ctx); /* TODO: Check for error */
|
||||
|
||||
uint32_t buffer;
|
||||
int32_t ready;
|
||||
|
||||
|
||||
alSourceUnqueueBuffers(device->source, 1, &buffer);
|
||||
alBufferData(buffer, AL_FORMAT_MONO16, data, lenght * 2 * 1 /*channels*/, sample_rate); // TODO: Frequency must be set dynamically
|
||||
|
||||
int rc = alGetError();
|
||||
if (rc != AL_NO_ERROR) {
|
||||
fprintf(stderr, "Error setting buffer %d\n", rc);
|
||||
return de_BufferError;
|
||||
}
|
||||
|
||||
alSourceQueueBuffers(device->source, 1, &buffer);
|
||||
|
||||
rc = alGetError();
|
||||
if (alGetError() != AL_NO_ERROR) {
|
||||
fprintf(stderr, "Error: could not buffer audio: %d\n", rc);
|
||||
return de_BufferError;
|
||||
}
|
||||
|
||||
alGetSourcei(device->source, AL_SOURCE_STATE, &ready);
|
||||
|
||||
if (ready != AL_PLAYING) {
|
||||
alSourcePlay(device->source);
|
||||
return de_None;
|
||||
}
|
||||
|
||||
return de_Busy;
|
||||
}
|
||||
|
||||
void* thread_poll (void* arg) // TODO: maybe use thread for every input source
|
||||
{
|
||||
/*
|
||||
* NOTE: We only need to poll input devices for data.
|
||||
*/
|
||||
(void)arg;
|
||||
uint32_t i;
|
||||
int32_t sample = 0;
|
||||
|
||||
int f_size = frame_size;
|
||||
|
||||
while (thread_running)
|
||||
{
|
||||
if (thread_paused) usleep(10000); /* Wait for unpause. */
|
||||
else
|
||||
{
|
||||
for (i = 0; i < size[input]; i ++)
|
||||
{
|
||||
lock;
|
||||
if (running[input][i] != NULL)
|
||||
{
|
||||
alcGetIntegerv(running[input][i]->dhndl, ALC_CAPTURE_SAMPLES, sizeof(int32_t), &sample);
|
||||
|
||||
if (sample < f_size) {
|
||||
unlock;
|
||||
continue;
|
||||
}
|
||||
Device* device = running[input][i];
|
||||
|
||||
int16_t frame[4096];
|
||||
alcCaptureSamples(device->dhndl, frame, f_size);
|
||||
|
||||
if ( device->muted ||
|
||||
(device->enable_VAD && !toxav_has_activity(av, device->call_idx, frame, f_size, device->VAD_treshold)))
|
||||
{ unlock; continue; } /* Skip if no voice activity */
|
||||
|
||||
if ( device->cb ) device->cb(frame, f_size, device->cb_data);
|
||||
}
|
||||
unlock;
|
||||
}
|
||||
usleep(5000);
|
||||
}
|
||||
}
|
||||
|
||||
pthread_exit(NULL);
|
||||
}
|
||||
|
||||
void print_devices(ToxWindow* self, DeviceType type)
|
||||
{
|
||||
int i = 0;
|
||||
for ( ; i < size[type]; i ++) {
|
||||
uint8_t msg[MAX_STR_SIZE];
|
||||
snprintf(msg, sizeof(msg), "%d: %s", i, devices_names[type][i]);
|
||||
line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
DeviceError selection_valid(DeviceType type, int32_t selection)
|
||||
{
|
||||
return (size[type] <= selection || selection < 0) ? de_InvalidSelection : de_None;
|
||||
}
|
||||
|
||||
void* get_device_callback_data(uint32_t device_idx)
|
||||
{
|
||||
if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
|
||||
return NULL;
|
||||
|
||||
return running[input][device_idx]->cb_data;
|
||||
}
|
68
src/device.h
Normal file
68
src/device.h
Normal file
@ -0,0 +1,68 @@
|
||||
/*
|
||||
* Toxic -- Tox Curses Client
|
||||
*/
|
||||
|
||||
/*
|
||||
* You can have multiple sources (Input devices) but only one output device.
|
||||
* Pass buffers to output device via write();
|
||||
* Read from running input device(s) via select()/callback combo.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _device_h
|
||||
#define _device_h
|
||||
|
||||
#define MAX_DEVICES 32
|
||||
#include <inttypes.h>
|
||||
#include "windows.h"
|
||||
|
||||
#define _True 1
|
||||
#define _False 0
|
||||
|
||||
typedef enum DeviceType {
|
||||
input,
|
||||
output,
|
||||
} DeviceType;
|
||||
|
||||
typedef enum DeviceError {
|
||||
de_None,
|
||||
de_InternalError = -1,
|
||||
de_InvalidSelection = -2,
|
||||
de_FailedStart = -3,
|
||||
de_Busy = -4,
|
||||
de_AllDevicesBusy = -5,
|
||||
de_DeviceNotActive = -6,
|
||||
de_BufferError = -7,
|
||||
de_AlError = -8,
|
||||
} DeviceError;
|
||||
|
||||
typedef void (*DataHandleCallback) (const int16_t*, uint32_t size, void* data);
|
||||
|
||||
|
||||
DeviceError init_devices(ToxAv* av);
|
||||
DeviceError terminate_devices();
|
||||
|
||||
/* Callback handles ready data from INPUT device */
|
||||
DeviceError register_device_callback(int32_t call_idx, uint32_t device_idx, DataHandleCallback callback, void* data, _Bool enable_VAD);
|
||||
void* get_device_callback_data(uint32_t device_idx);
|
||||
|
||||
/* toggle device mute */
|
||||
DeviceError device_mute(DeviceType type, uint32_t device_idx);
|
||||
|
||||
DeviceError device_set_VAD_treshold(uint32_t device_idx, float value);
|
||||
|
||||
DeviceError set_primary_device(DeviceType type, int32_t selection);
|
||||
DeviceError open_primary_device(DeviceType type, uint32_t* device_idx);
|
||||
/* Start device */
|
||||
DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx);
|
||||
/* Stop device */
|
||||
DeviceError close_device(DeviceType type, uint32_t device_idx);
|
||||
|
||||
DeviceError playback_device_ready(uint32_t device_idx);
|
||||
/* Write data to device */
|
||||
DeviceError write_out(uint32_t device_idx, int16_t* data, uint32_t lenght, uint8_t channels);
|
||||
|
||||
void print_devices(ToxWindow* self, DeviceType type);
|
||||
|
||||
DeviceError selection_valid(DeviceType type, int32_t selection);
|
||||
#endif /* _device_h */
|
@ -76,6 +76,9 @@ static struct cmd_func chat_commands[] = {
|
||||
{ "/answer", cmd_answer },
|
||||
{ "/reject", cmd_reject },
|
||||
{ "/hangup", cmd_hangup },
|
||||
{ "/sdev", cmd_ccur_device },
|
||||
{ "/mute", cmd_mute },
|
||||
{ "/sense", cmd_sense },
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
};
|
||||
|
||||
|
@ -30,7 +30,7 @@
|
||||
|
||||
#ifdef _SUPPORT_AUDIO
|
||||
#define GLOBAL_NUM_COMMANDS 16
|
||||
#define CHAT_NUM_COMMANDS 10
|
||||
#define CHAT_NUM_COMMANDS 13
|
||||
#else
|
||||
#define GLOBAL_NUM_COMMANDS 14
|
||||
#define CHAT_NUM_COMMANDS 5
|
||||
|
@ -627,7 +627,8 @@ ToxWindow new_friendlist(void)
|
||||
ret.onRequestTimeout = &friendlist_onAv;
|
||||
ret.onPeerTimeout = &friendlist_onAv;
|
||||
|
||||
ret.call_index = -1;
|
||||
ret.call_idx = -1;
|
||||
ret.device_selection[0] = ret.device_selection[1] = -1;
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
strcpy(ret.name, "friends");
|
||||
|
@ -32,8 +32,8 @@
|
||||
#include "configdir.h"
|
||||
|
||||
#ifdef _SUPPORT_AUDIO
|
||||
#include "audio_call.h"
|
||||
#endif
|
||||
#include "device.h"
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
#include "settings.h"
|
||||
#include "line_info.h"
|
||||
@ -209,7 +209,7 @@ int settings_load(struct user_settings *s, char *path)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NUM_SETTINGS; ++i) {
|
||||
if (!strcmp(user_settings_list[i].key, key)) {
|
||||
if (strcmp(user_settings_list[i].key, key) == 0) {
|
||||
(user_settings_list[i].func)(s, val);
|
||||
break;
|
||||
}
|
||||
|
@ -29,7 +29,7 @@
|
||||
#define NUM_SETTINGS 8
|
||||
#else
|
||||
#define NUM_SETTINGS 6
|
||||
#endif
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
/* holds user setting values */
|
||||
struct user_settings {
|
||||
|
14
src/toxic.c
14
src/toxic.c
@ -606,16 +606,10 @@ int main(int argc, char *argv[])
|
||||
|
||||
av = init_audio(prompt, m);
|
||||
|
||||
device_set(prompt, input, user_settings->audio_in_dev);
|
||||
device_set(prompt, output, user_settings->audio_out_dev);
|
||||
|
||||
if ( errors() == NoError )
|
||||
msg = "Audio initiated with no problems.";
|
||||
else /* Get error code and stuff */
|
||||
msg = "Error initiating audio!";
|
||||
|
||||
line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
|
||||
|
||||
|
||||
set_primary_device(input, user_settings->audio_in_dev);
|
||||
set_primary_device(output, user_settings->audio_out_dev);
|
||||
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
if (config_err) {
|
||||
|
@ -107,8 +107,9 @@ struct ToxWindow {
|
||||
void(*onRequestTimeout)(ToxWindow *, ToxAv *, int);
|
||||
void(*onPeerTimeout)(ToxWindow *, ToxAv *, int);
|
||||
|
||||
int call_index; /* If in a call will have this index set, otherwise it's -1.
|
||||
* Don't modify outside av callbacks. */
|
||||
int call_idx; /* If in a call will have this index set, otherwise it's -1.
|
||||
* Don't modify outside av callbacks. */
|
||||
int device_selection[2]; /* -1 if not set, if set uses these selections instead of primary device */
|
||||
#endif /* _SUPPORT_AUDIO */
|
||||
|
||||
char name[TOX_MAX_NAME_LENGTH];
|
||||
|
Loading…
Reference in New Issue
Block a user