Random fixes

4 files changed, 132 insertions, 137 deletions

diff --git a/toxav/av_test.c b/toxav/av_test.c
index 007a1a10..dab1f6ef 100644
--- a/toxav/av_test.c
+++ b/toxav/av_test.c
@@ -1,14 +1,12 @@
 #include "../toxav/toxav.h"
 #include "../toxcore/tox.h"
 
-/* For playing audio data */
-#include <AL/al.h>
-#include <AL/alc.h>
-
-/* Processing wav's */
+/* Playing audio data */
+#include <portaudio.h>
+/* Reading audio */
 #include <sndfile.h>
 
-/* For reading and displaying video data */
+/* Reading and Displaying video data */
 #include <opencv/cv.h>
 #include <opencv/highgui.h>
 #include <opencv/cvwimage.h>
@@ -23,7 +21,6 @@
 #include <errno.h>
 #include <unistd.h>
 
-
 #define c_sleep(x) usleep(1000*x)
 
 
@@ -67,7 +64,7 @@ struct toxav_thread_data {
 };
 
 const char* vdout = "AV Test";
-uint32_t adout;
+PaStream* adout = NULL;
 
 const char* stringify_state(TOXAV_CALL_STATE s)
 {
@@ -137,34 +134,7 @@ void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
                                     uint32_t sampling_rate,
                                     void *user_data)
 {
-    uint32_t bufid;
-    int32_t processed = 0, queued = 16;
-    alGetSourcei(adout, AL_BUFFERS_PROCESSED, &processed);
-    alGetSourcei(adout, AL_BUFFERS_QUEUED, &queued);
-    
-    if(processed) {
-        uint32_t bufids[processed];
-        alSourceUnqueueBuffers(adout, processed, bufids);
-        alDeleteBuffers(processed - 1, bufids + 1);
-        bufid = bufids[0];
-    }
-//     else if(queued < 16) {
-        alGenBuffers(1, &bufid);
-//     }
-//     else
-//         return;
-    
-    
-    alBufferData(bufid, channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
-                 pcm, sample_count * 2 * channels, sampling_rate);
-    alSourceQueueBuffers(adout, 1, &bufid);
-    
-    int32_t state;
-    alGetSourcei(adout, AL_SOURCE_STATE, &state);
-    if(state != AL_PLAYING) {
-        printf("Here\n");
-        alSourcePlay(adout);
-    }
+    Pa_WriteStream(adout, pcm, sample_count/channels);
 }
 void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
 {
@@ -260,10 +230,8 @@ void* iterate_toxav (void * data)
         toxav_iterate(data_cast->BobAV);
         int rc = MIN(toxav_iteration_interval(data_cast->AliceAV), toxav_iteration_interval(data_cast->BobAV));
         
-        printf("\rToxAV interval: %d   ", rc);
-        fflush(stdout);
 //         cvWaitKey(rc);
-        c_sleep(rc/2);
+        c_sleep(10);
     }
     
     data_cast->sig = 1;
@@ -309,36 +277,13 @@ int send_opencv_img(ToxAV* av, uint32_t friend_number, const IplImage* img)
     return rc;
 }
 
-ALCdevice* open_audio_device(const char* audio_out_dev_name)
-{
-    ALCdevice* rc;
-    rc = alcOpenDevice(audio_out_dev_name);
-    if ( !rc ) {
-        printf("Failed to open playback device: %s: %d\n", audio_out_dev_name, alGetError());
-        exit(1);
-    }
-    
-    ALCcontext* out_ctx = alcCreateContext(rc, NULL);
-    alcMakeContextCurrent(out_ctx);
-    
-    alGenSources((uint32_t)1, &adout);
-    alSourcei(adout, AL_LOOPING, AL_FALSE);    
-    alSourcePlay(adout);
-    
-    return rc;
-}
-
 int print_audio_devices()
 {
-    const char *device;
-
-    printf("Default output device: %s\n", alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER));
-    printf("Output devices:\n");
-    
     int i = 0;
-    for(device = alcGetString(NULL, ALC_DEVICE_SPECIFIER); *device; 
-        device += strlen( device ) + 1, ++i) {
-        printf("%d) %s\n", i, device);
+    for (i = 0; i < Pa_GetDeviceCount(); ++i) {
+        const PaDeviceInfo* info = Pa_GetDeviceInfo(i);
+        if (info)
+            printf("%d) %s\n", i, info->name);
     }
     
     return 0;
@@ -361,12 +306,13 @@ int print_help (const char* name)
 
 int main (int argc, char** argv)
 {
+    Pa_Initialize();
     struct stat st;
     
     /* AV files for testing */
     const char* af_name = NULL;
     const char* vf_name = NULL;
-    long audio_out_dev_idx = 0;
+    long audio_out_dev_idx = -1;
     
     int32_t audio_frame_duration = 20;
     int32_t video_frame_duration = 10;
@@ -440,52 +386,66 @@ int main (int argc, char** argv)
         }
     }
     
-    const char* audio_out_dev_name = NULL;
+    if (audio_out_dev_idx < 0)
+        audio_out_dev_idx = Pa_GetDefaultOutputDevice();
     
-    int i = 0;
-    for(audio_out_dev_name = alcGetString(NULL, ALC_DEVICE_SPECIFIER); i < audio_out_dev_idx;
-        audio_out_dev_name += strlen( audio_out_dev_name ) + 1, ++i)
-        if (!(audio_out_dev_name + strlen( audio_out_dev_name ) + 1))
-            break;
-        
-    printf("Using audio device: %s\n", audio_out_dev_name);
-    printf("Using audio file: %s\n", af_name);
-    printf("Using video file: %s\n", vf_name);
+    const PaDeviceInfo* audio_dev = Pa_GetDeviceInfo(audio_out_dev_idx);
+    if (!audio_dev) {
+        fprintf(stderr, "Device under index: %ld invalid", audio_out_dev_idx);
+        return 1;
+    }
     
     if (0) {
-        /* Open audio file */
+        SNDFILE* af_handle;
         SF_INFO af_info;
-        SNDFILE* af_handle = sf_open(af_name, SFM_READ, &af_info);
-        if (af_handle == NULL)
-        {
+        
+        /* Open audio file */
+        af_handle = sf_open(af_name, SFM_READ, &af_info);
+        if (af_handle == NULL) {
             printf("Failed to open the file.\n");
             exit(1);
         }
-        ALCdevice* audio_out_device = open_audio_device(audio_out_dev_name);
         
+        int frame_size = (af_info.samplerate * audio_frame_duration / 1000) * af_info.channels;
         
-        int16_t PCM[5760];
+        struct PaStreamParameters output;
+        output.device = audio_out_dev_idx; /* default output device */
+        output.channelCount = af_info.channels;
+        output.sampleFormat = paInt16;
+        output.suggestedLatency = audio_dev->defaultHighOutputLatency;
+        output.hostApiSpecificStreamInfo = NULL;
+        
+        
+        PaError err = Pa_OpenStream(&adout, NULL, &output, af_info.samplerate, frame_size, paNoFlag, NULL, NULL);
+        assert(err == paNoError);
+        
+        err = Pa_StartStream(adout);
+        assert(err == paNoError);
+        
+        int16_t PCM[frame_size];
         
         time_t start_time = time(NULL);
         time_t expected_time = af_info.frames / af_info.samplerate + 2;
         
         printf("Sample rate %d\n", af_info.samplerate);
         while ( start_time + expected_time > time(NULL) ) {
-            int frame_size = (af_info.samplerate * audio_frame_duration / 1000) * af_info.channels;
             
             int64_t count = sf_read_short(af_handle, PCM, frame_size);
-            if (count > 0)
+            if (count > 0) {
                 t_toxav_receive_audio_frame_cb(NULL, 0, PCM, count, af_info.channels, af_info.samplerate, NULL);
-            c_sleep(audio_frame_duration);
+            }
+            
+            c_sleep(audio_frame_duration / 2);
         }
-    
-        
-        printf("Played file in: %lu\n", time(NULL) - start_time);
         
-        alcCloseDevice(audio_out_device);
-        sf_close(af_handle);
+        Pa_Terminate();
         return 0;
     }
+    
+    printf("Using audio device: %s\n", audio_dev->name);
+    printf("Using audio file: %s\n", af_name);
+    printf("Using video file: %s\n", vf_name);
+    
     /* START TOX NETWORK */
     
     Tox *bootstrap;
@@ -733,7 +693,7 @@ int main (int argc, char** argv)
         
         { /* Call */
             TOXAV_ERR_CALL rc;
-            toxav_call(AliceAV, 0, 8, 0, &rc);
+            toxav_call(AliceAV, 0, 48, 0, &rc);
             
             if (rc != TOXAV_ERR_CALL_OK) {
                 printf("toxav_call failed: %d\n", rc);
@@ -746,7 +706,7 @@ int main (int argc, char** argv)
                 
                 { /* Answer */
             TOXAV_ERR_ANSWER rc;
-            toxav_answer(BobAV, 0, 64, 0, &rc);
+            toxav_answer(BobAV, 0, 48, 0, &rc);
             
             if (rc != TOXAV_ERR_ANSWER_OK) {
                 printf("toxav_answer failed: %d\n", rc);
@@ -758,12 +718,26 @@ int main (int argc, char** argv)
                 
         /* Open audio file */
         af_handle = sf_open(af_name, SFM_READ, &af_info);
-        if (af_handle == NULL)
-        {
+        if (af_handle == NULL) {
             printf("Failed to open the file.\n");
             exit(1);
         }
-        ALCdevice* audio_out_device = open_audio_device(audio_out_dev_name);
+        
+        
+        int frame_size = (af_info.samplerate * audio_frame_duration / 1000) * af_info.channels;
+        
+        struct PaStreamParameters output;
+        output.device = audio_out_dev_idx;
+        output.channelCount = af_info.channels;
+        output.sampleFormat = paInt16;
+        output.suggestedLatency = audio_dev->defaultHighOutputLatency;
+        output.hostApiSpecificStreamInfo = NULL;
+        
+        PaError err = Pa_OpenStream(&adout, NULL, &output, af_info.samplerate, frame_size, paNoFlag, NULL, NULL);
+        assert(err == paNoError);
+        
+        err = Pa_StartStream(adout);
+        assert(err == paNoError);
         
         int16_t PCM[5760];
         
@@ -784,24 +758,22 @@ int main (int argc, char** argv)
         
         printf("Sample rate %d\n", af_info.samplerate);
                 while ( start_time + expected_time > time(NULL) ) {
-            int frame_size = (af_info.samplerate * audio_frame_duration / 1000) * af_info.channels;
             
             int64_t count = sf_read_short(af_handle, PCM, frame_size);
             if (count > 0) {
                 TOXAV_ERR_SEND_FRAME rc;
-                if (toxav_send_audio_frame(AliceAV, 0, PCM, count, af_info.channels, af_info.samplerate, &rc) == false) {
+                if (toxav_send_audio_frame(AliceAV, 0, PCM, count/af_info.channels, af_info.channels, af_info.samplerate, &rc) == false) {
                     printf("Error sending frame of size %ld: %d\n", count, rc);
-                    exit(1);
+//                     exit(1);
                 }
             }
             iterate_tox(bootstrap, AliceAV, BobAV);
-            c_sleep(audio_frame_duration);
+            c_sleep(30);
                 }
     
         
                 printf("Played file in: %lu\n", time(NULL) - start_time);
         
-        alcCloseDevice(audio_out_device);
         sf_close(af_handle);
                 
                 { /* Hangup */
diff --git a/toxav/codec.c b/toxav/codec.c
index be69ee70..d55cc345 100644
--- a/toxav/codec.c
+++ b/toxav/codec.c
@@ -175,7 +175,7 @@ static int jbuf_write(JitterBuffer *q, RTPMessage *m)
     unsigned int num = sequnum % q->size;
 
     if ((uint32_t)(sequnum - q->bottom) > q->size) {
-        LOGGER_DEBUG("Clearing jitter: %p", q);
+        LOGGER_DEBUG("Clearing filled jitter buffer: %p", q);
         
         jbuf_clear(q);
         q->bottom = sequnum - q->capacity;
@@ -309,6 +309,32 @@ bool create_video_encoder (vpx_codec_ctx_t* dest, int32_t bitrate)
     return true;
 }
 
+bool reconfigure_audio_decoder(CSession* cs, int32_t sampling_rate, int8_t channels)
+{
+    if (sampling_rate != cs->last_decoding_sampling_rate || channels != cs->last_decoding_channel_count) {
+        if (current_time_monotonic() - cs->last_decoder_reconfiguration < 500)
+            return false;
+        
+        int status;
+        OpusDecoder* new_dec = opus_decoder_create(sampling_rate, channels, &status );
+        if ( status != OPUS_OK ) {
+            LOGGER_ERROR("Error while starting audio decoder: %s", opus_strerror(status));
+            return false;
+        }
+        
+        cs->last_decoding_sampling_rate = sampling_rate;
+        cs->last_decoding_channel_count = channels;
+        cs->last_decoder_reconfiguration = current_time_monotonic();
+        
+        opus_decoder_destroy(cs->audio_decoder);
+        cs->audio_decoder = new_dec;
+        
+        LOGGER_DEBUG("Reconfigured audio decoder sr: %d cc: %d", sampling_rate, channels);
+    }
+    
+    return true;
+}
+
 /* PUBLIC */
 
 void cs_do(CSession *cs)
@@ -339,7 +365,7 @@ void cs_do(CSession *cs)
             if (success == 2) {
                 LOGGER_DEBUG("OPUS correction");
                 rc = opus_decode(cs->audio_decoder, NULL, 0, tmp,
-                                (cs->last_packet_sampling_rate * cs->last_packet_frame_duration / 1000) *
+                                (cs->last_packet_sampling_rate * cs->last_packet_frame_duration / 1000) /
                                  cs->last_packet_channel_count, 1);
             } else {
                 /* Get values from packet and decode. */
@@ -359,6 +385,17 @@ void cs_do(CSession *cs)
                 cs->last_packet_sampling_rate = ntohl(cs->last_packet_sampling_rate);
                 
                 cs->last_packet_channel_count = opus_packet_get_nb_channels(msg->data + 4);
+                
+                /* 
+                 * NOTE: even though OPUS supports decoding mono frames with stereo decoder and vice versa,
+                 * it didn't work quite well.
+                 */
+                if (!reconfigure_audio_decoder(cs, cs->last_packet_sampling_rate, cs->last_packet_channel_count)) {
+                    LOGGER_WARNING("Failed to reconfigure decoder!");
+                    rtp_free_msg(NULL, msg);
+                    continue;
+                }
+                
                 rc = opus_decode(cs->audio_decoder, msg->data + 4, msg->length - 4, tmp, 5760, 0);
                 rtp_free_msg(NULL, msg);
             }
@@ -366,35 +403,12 @@ void cs_do(CSession *cs)
             if (rc < 0) {
                 LOGGER_WARNING("Decoding error: %s", opus_strerror(rc));
             } else if (cs->acb.first) {
+                cs->last_packet_channel_count = 2;
+                cs->last_packet_frame_duration = (rc * 1000) / cs->last_packet_sampling_rate * cs->last_packet_channel_count;
                 
-                /* Extract channels */
-                int16_t left[rc/2];
-                int16_t right[rc/2];
-                int i = 0;
-                for (; i < rc/2; i ++) {
-                    left[i] = tmp[i * 2];
-                    right[i] = tmp[(i * 2) + 1];
-                }
+                cs->acb.first(cs->av, cs->friend_id, tmp, rc * cs->last_packet_channel_count,
+                            cs->last_packet_channel_count, cs->last_packet_sampling_rate, cs->acb.second);
                 
-                if (memcmp(left, right, sizeof(int16_t)) == 0) {
-                    cs->last_packet_channel_count = 1;
-                    cs->last_packet_frame_duration = (rc * 1000) / cs->last_packet_sampling_rate * cs->last_packet_channel_count;
-                    
-                    LOGGER_DEBUG("Playing mono audio frame size: %d; srate: %d; duration %d", rc, 
-                                 cs->last_packet_sampling_rate, cs->last_packet_frame_duration);
-                    
-                    cs->acb.first(cs->av, cs->friend_id, right, rc / 2,
-                                cs->last_packet_channel_count, cs->last_packet_sampling_rate, cs->acb.second);
-                } else {
-                    cs->last_packet_channel_count = 2;
-                    cs->last_packet_frame_duration = (rc * 1000) / cs->last_packet_sampling_rate * cs->last_packet_channel_count;
-                    
-                    LOGGER_DEBUG("Playing stereo audio frame size: %d; channels: %d; srate: %d; duration %d", rc, 
-                                cs->last_packet_channel_count, cs->last_packet_sampling_rate, cs->last_packet_frame_duration);
-                    
-                    cs->acb.first(cs->av, cs->friend_id, tmp, rc,
-                                cs->last_packet_channel_count, cs->last_packet_sampling_rate, cs->acb.second);
-                }
             }
             
             LOGGED_LOCK(cs->queue_mutex);
@@ -458,13 +472,17 @@ CSession *cs_new(uint32_t peer_video_frame_piece_size)
      */
     
     int status;
-    cs->audio_decoder = opus_decoder_create(48000, 2, &status ); /* NOTE: Must be stereo */
+    cs->audio_decoder = opus_decoder_create(48000, 2, &status );
     
     if ( status != OPUS_OK ) {
         LOGGER_ERROR("Error while starting audio decoder: %s", opus_strerror(status));
         goto FAILURE;
     }
     
+    cs->last_decoding_channel_count = 2;
+    cs->last_decoding_sampling_rate = 48000;
+    cs->last_decoder_reconfiguration = 0; /* Make it possible to reconfigure straight away */
+    
     /* These need to be set in order to properly
      * do error correction with opus */
     cs->last_packet_frame_duration = 120;
diff --git a/toxav/codec.h b/toxav/codec.h
index 4e2b995b..830dbbf6 100644
--- a/toxav/codec.h
+++ b/toxav/codec.h
@@ -93,6 +93,9 @@ typedef struct CSession_s {
     int32_t last_packet_channel_count;
     int32_t last_packet_sampling_rate;
     int32_t last_packet_frame_duration;
+    int32_t last_decoding_sampling_rate;
+    int32_t last_decoding_channel_count;
+    uint64_t last_decoder_reconfiguration;
     struct JitterBuffer_s *j_buf;
 
 
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 12f8b561..bd788d7d 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -237,7 +237,8 @@ void toxav_iterate(ToxAV* av)
     }
     LOGGED_UNLOCK(av->mutex);
     
-    av->interval = rc < av->dmssa ? 0 : (rc - av->dmssa);
+//     av->interval = rc < av->dmssa ? 0 : (rc - av->dmssa);
+    av->interval = rc < 5 ? 1: rc - 5;
     av->dmsst += current_time_monotonic() - start;
     
     if (++av->dmssc == 3) {
@@ -712,21 +713,22 @@ bool toxav_send_audio_frame(ToxAV* av, uint32_t friend_number, const int16_t* pc
             goto END;
         }
         
-        uint8_t dest[sample_count * channels + sizeof(sampling_rate)]; /* This is more than enough always */
+        uint8_t dest[sample_count + sizeof(sampling_rate)]; /* This is more than enough always */
         
         sampling_rate = htonl(sampling_rate);
         memcpy(dest, &sampling_rate, sizeof(sampling_rate));
-        int vrc = opus_encode(call->cs->audio_encoder, pcm, sample_count, dest + sizeof(sampling_rate), sizeof(dest) - sizeof(sampling_rate));
+        int vrc = opus_encode(call->cs->audio_encoder, pcm, sample_count,
+                              dest + sizeof(sampling_rate), sizeof(dest) - sizeof(sampling_rate));
         
         if (vrc < 0) {
-            LOGGER_WARNING("Failed to encode frame");
+            LOGGER_WARNING("Failed to encode frame %s", opus_strerror(vrc));
             LOGGED_UNLOCK(call->mutex_audio_sending);
             rc = TOXAV_ERR_SEND_FRAME_INVALID;
             goto END;
         }
         
-        LOGGER_DEBUG("Sending encoded audio frame size: %d; channels: %d; srate: %d", vrc, channels,
-                     ntohl(sampling_rate));
+//         LOGGER_DEBUG("Sending encoded audio frame size: %d; channels: %d; srate: %d", vrc, channels,
+//                      ntohl(sampling_rate));
         
                 if (rtp_send_msg(call->rtps[audio_index], dest, vrc + sizeof(sampling_rate)) != 0) {
                         LOGGER_WARNING("Failed to send audio packet");