summaryrefslogtreecommitdiff
path: root/auto_tests
diff options
context:
space:
mode:
Diffstat (limited to 'auto_tests')
-rw-r--r--auto_tests/toxav_basic_test.c891
-rw-r--r--auto_tests/toxav_many_test.c593
2 files changed, 627 insertions, 857 deletions
diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index a43b7c2f..79c5b724 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -9,11 +9,11 @@
9#include <check.h> 9#include <check.h>
10#include <stdlib.h> 10#include <stdlib.h>
11#include <time.h> 11#include <time.h>
12#include <assert.h>
13 12
14#include <vpx/vpx_image.h> 13#include <vpx/vpx_image.h>
15 14
16#include "../toxcore/tox.h" 15#include "../toxcore/tox.h"
16#include "../toxcore/util.h"
17#include "../toxcore/logger.h" 17#include "../toxcore/logger.h"
18#include "../toxcore/crypto_core.h" 18#include "../toxcore/crypto_core.h"
19#include "../toxav/toxav.h" 19#include "../toxav/toxav.h"
@@ -28,604 +28,425 @@
28#endif 28#endif
29 29
30 30
31#define TEST_REGULAR_AV 1
32#define TEST_REGULAR_A 1
33#define TEST_REGULAR_V 1
34#define TEST_REJECT 1
35#define TEST_CANCEL 1
36#define TEST_MUTE_UNMUTE 1
31 37
32typedef enum _CallStatus {
33 none,
34 InCall,
35 Ringing,
36 Ended,
37 Rejected,
38 Canceled,
39 TimedOut
40 38
41} CallStatus; 39typedef struct {
40 bool incoming;
41 uint32_t state;
42
43} CallControl;
42 44
43typedef struct _Party {
44 CallStatus status;
45 ToxAv *av;
46 time_t *CallStarted;
47 int call_index;
48} Party;
49 45
50typedef struct _Status { 46/**
51 Party Alice; 47 * Callbacks
52 Party Bob; 48 */
53} Status; 49void t_toxav_call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)
54
55/* My default settings */
56static ToxAvCSettings muhcaps;
57
58void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
59{
60 if (length == 7 && memcmp("gentoo", data, 7) == 0) {
61 tox_friend_add_norequest(m, public_key, 0);
62 }
63}
64
65
66/******************************************************************************/
67void callback_recv_invite ( void *av, int32_t call_index, void *_arg )
68{
69 Status *cast = _arg;
70
71 if (cast->Alice.av == av) {
72 // ...
73 } else if (cast->Bob.av == av) {
74 /* Bob always receives invite */
75 cast->Bob.status = Ringing;
76 cast->Bob.call_index = call_index;
77 }
78}
79void callback_recv_ringing ( void *av, int32_t call_index, void *_arg )
80{
81 Status *cast = _arg;
82
83 if (cast->Alice.av == av) {
84 /* Alice always sends invite */
85 cast->Alice.status = Ringing;
86 } else if (cast->Bob.av == av) {
87 // ...
88 }
89}
90
91
92void callback_call_started ( void *av, int32_t call_index, void *_arg )
93{
94 Status *cast = _arg;
95
96 if (cast->Alice.av == av) {
97 printf("Call started on Alices side...\n");
98 cast->Alice.status = InCall;
99 toxav_prepare_transmission(av, call_index, 1);
100 } else if (cast->Bob.av == av) {
101 printf("Call started on Bob side...\n");
102 cast->Bob.status = InCall;
103 toxav_prepare_transmission(av, call_index, 1);
104 }
105}
106void callback_call_canceled ( void *av, int32_t call_index, void *_arg )
107{ 50{
108 Status *cast = _arg; 51 (void) av;
109 52 (void) friend_number;
110 if (cast->Alice.av == av) { 53 (void) audio_enabled;
111 // ... 54 (void) video_enabled;
112 } else if (cast->Bob.av == av) { 55
113 printf ( "Call Canceled for Bob!\n" ); 56 printf("Handling CALL callback\n");
114 cast->Bob.status = Canceled; 57 ((CallControl*)user_data)->incoming = true;
115 }
116} 58}
117void callback_call_rejected ( void *av, int32_t call_index, void *_arg ) 59void t_toxav_call_state_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)
118{ 60{
119 Status *cast = _arg; 61 (void) av;
120 62 (void) friend_number;
121 printf ( "Call rejected by Bob!\n" 63
122 "Call ended for Alice!\n" ); 64 printf("Handling CALL STATE callback: %d\n", state);
123 65 ((CallControl*)user_data)->state = state;
124 /* If Bob rejects, call is ended for alice and she sends ending */
125 if (cast->Alice.av == av) {
126 cast->Alice.status = Rejected;
127 } else if (cast->Bob.av == av) {
128 //... ignor
129 }
130} 66}
131void callback_call_ended ( void *av, int32_t call_index, void *_arg ) 67void t_toxav_receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
68 uint16_t width, uint16_t height,
69 uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
70 int32_t ystride, int32_t ustride, int32_t vstride, int32_t astride,
71 void *user_data)
132{ 72{
133 Status *cast = _arg; 73 (void) av;
134 74 (void) friend_number;
135 if (cast->Alice.av == av) { 75 (void) width;
136 printf ( "Call ended for Alice!\n" ); 76 (void) height;
137 cast->Alice.status = Ended; 77 (void) y;
138 } else if (cast->Bob.av == av) { 78 (void) u;
139 printf ( "Call ended for Bob!\n" ); 79 (void) v;
140 cast->Bob.status = Ended; 80 (void) ystride;
141 } 81 (void) ustride;
82 (void) vstride;
83 (void) user_data;
142} 84}
143 85void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
144void callback_peer_cs_change ( void *av, int32_t call_index, void *_arg ) 86 int16_t const *pcm,
87 size_t sample_count,
88 uint8_t channels,
89 uint32_t sampling_rate,
90 void *user_data)
145{ 91{
146 ToxAvCSettings csettings; 92 (void) av;
147 toxav_get_peer_csettings(av, call_index, 0, &csettings); 93 (void) friend_number;
148 94 (void) pcm;
149 printf("Peer changing settings to: \n" 95 (void) sample_count;
150 "Type: %u \n" 96 (void) channels;
151 "Video bitrate: %u \n" 97 (void) sampling_rate;
152 "Video height: %u \n" 98 (void) user_data;
153 "Video width: %u \n"
154 "Audio bitrate: %u \n"
155 "Audio framedur: %u \n"
156 "Audio sample rate: %u \n"
157 "Audio channels: %u \n",
158 csettings.call_type,
159 csettings.video_bitrate,
160 csettings.max_video_height,
161 csettings.max_video_width,
162 csettings.audio_bitrate,
163 csettings.audio_frame_duration,
164 csettings.audio_sample_rate,
165 csettings.audio_channels
166 );
167} 99}
168 100void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
169void callback_self_cs_change ( void *av, int32_t call_index, void *_arg )
170{ 101{
171 ToxAvCSettings csettings; 102 (void) userdata;
172 toxav_get_peer_csettings(av, call_index, 0, &csettings); 103
173 104 if (length == 7 && memcmp("gentoo", data, 7) == 0) {
174 printf("Changed settings to: \n" 105 ck_assert(tox_friend_add_norequest(m, public_key, NULL) != (uint32_t) ~0);
175 "Type: %u \n"
176 "Video bitrate: %u \n"
177 "Video height: %u \n"
178 "Video width: %u \n"
179 "Audio bitrate: %u \n"
180 "Audio framedur: %u \n"
181 "Audio sample rate: %u \n"
182 "Audio channels: %u \n",
183 csettings.call_type,
184 csettings.video_bitrate,
185 csettings.max_video_height,
186 csettings.max_video_width,
187 csettings.audio_bitrate,
188 csettings.audio_frame_duration,
189 csettings.audio_sample_rate,
190 csettings.audio_channels
191 );
192}
193
194void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
195{
196 Status *cast = _arg;
197 printf("Call timed-out!\n");
198
199 if (cast->Alice.av == av) {
200 cast->Alice.status = TimedOut;
201 } else if (cast->Bob.av == av) {
202 cast->Bob.status = TimedOut;
203 } 106 }
204} 107}
205 108
206void callback_audio (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data)
207{}
208
209void callback_video (void *agent, int32_t call_idx, const vpx_image_t *img, void *data)
210{}
211 109
212void register_callbacks(ToxAv *av, void *data) 110/**
111 * Iterate helper
112 */
113int iterate_tox(Tox* bootstrap, Tox* Alice, Tox* Bob)
213{ 114{
214 toxav_register_callstate_callback(av, callback_call_started, av_OnStart, data); 115 tox_iterate(bootstrap);
215 toxav_register_callstate_callback(av, callback_call_canceled, av_OnCancel, data); 116 tox_iterate(Alice);
216 toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data); 117 tox_iterate(Bob);
217 toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data); 118
218 toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data); 119 return MIN(tox_iteration_interval(Alice), tox_iteration_interval(Bob));
219 toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
220 toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
221 toxav_register_callstate_callback(av, callback_peer_cs_change, av_OnPeerCSChange, data);
222 toxav_register_callstate_callback(av, callback_self_cs_change, av_OnSelfCSChange, data);
223 toxav_register_audio_callback(av, callback_audio, NULL);
224 toxav_register_video_callback(av, callback_video, NULL);
225} 120}
226 121
227 122
228/*************************************************************************************************/
229
230/* Alice calls bob and the call starts.
231 * What happens during the call is defined after. To quit the loop use: step++;
232 */
233#define CALL_AND_START_LOOP(AliceCallType, BobCallType) \
234{ int step = 0, running = 1; while (running) {\
235 tox_iterate(bootstrap_node); tox_iterate(Alice); tox_iterate(Bob); \
236 toxav_do(status_control.Bob.av); toxav_do(status_control.Alice.av); \
237 switch ( step ) {\
238 case 0: /* Alice */ printf("Alice is calling...\n");\
239 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10); step++; break;\
240 case 1: /* Bob */ if (status_control.Bob.status == Ringing) { printf("Bob answers...\n");\
241 cur_time = time(NULL); toxav_answer(status_control.Bob.av, status_control.Bob.call_index, &muhcaps); step++; } break; \
242 case 2: /* Rtp transmission */ \
243 if (status_control.Bob.status == InCall && status_control.Alice.status == InCall)
244
245
246#define TERMINATE_SCOPE() break;\
247case 3: /* Wait for Both to have status ended */\
248if (status_control.Alice.status == Ended && status_control.Bob.status == Ended) running = 0; break; } c_sleep(20); } } printf("\n");
249 123
250START_TEST(test_AV_flows) 124START_TEST(test_AV_flows)
251{ 125{
126 Tox* Alice, *Bob, *bootstrap;
127 ToxAV* AliceAV, *BobAV;
128
129 CallControl AliceCC, BobCC;
130
131 {
132 TOX_ERR_NEW error;
133
134 bootstrap = tox_new(NULL, NULL, 0, &error);
135 ck_assert(error == TOX_ERR_NEW_OK);
136
137 Alice = tox_new(NULL, NULL, 0, &error);
138 ck_assert(error == TOX_ERR_NEW_OK);
139
140 Bob = tox_new(NULL, NULL, 0, &error);
141 ck_assert(error == TOX_ERR_NEW_OK);
142 }
143
144 printf("Created 3 instances of Tox\n");
145 printf("Preparing network...\n");
252 long long unsigned int cur_time = time(NULL); 146 long long unsigned int cur_time = time(NULL);
253 Tox *bootstrap_node = tox_new(0, 0, 0, 0); 147
254 Tox *Alice = tox_new(0, 0, 0, 0);
255 Tox *Bob = tox_new(0, 0, 0, 0);
256
257 ck_assert_msg(bootstrap_node || Alice || Bob, "Failed to create 3 tox instances");
258
259 uint32_t to_compare = 974536; 148 uint32_t to_compare = 974536;
260 tox_callback_friend_request(Alice, accept_friend_request, &to_compare);
261 uint8_t address[TOX_ADDRESS_SIZE]; 149 uint8_t address[TOX_ADDRESS_SIZE];
150
151 tox_callback_friend_request(Alice, t_accept_friend_request_cb, &to_compare);
262 tox_self_get_address(Alice, address); 152 tox_self_get_address(Alice, address);
263 uint32_t test = tox_friend_add(Bob, address, (uint8_t *)"gentoo", 7, 0); 153
264 154
265 ck_assert_msg(test == 0, "Failed to add friend error code: %i", test); 155 ck_assert(tox_friend_add(Bob, address, (uint8_t *)"gentoo", 7, NULL) != (uint32_t) ~0);
266 156
267 uint8_t off = 1; 157 uint8_t off = 1;
268 158
269 while (1) { 159 while (1) {
270 tox_iterate(bootstrap_node); 160 iterate_tox(bootstrap, Alice, Bob);
271 tox_iterate(Alice); 161
272 tox_iterate(Bob); 162 if (tox_self_get_connection_status(bootstrap) &&
273 163 tox_self_get_connection_status(Alice) &&
274 if (tox_self_get_connection_status(bootstrap_node) && tox_self_get_connection_status(Alice) 164 tox_self_get_connection_status(Bob) && off) {
275 && tox_self_get_connection_status(Bob)
276 && off) {
277 printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time); 165 printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time);
278 off = 0; 166 off = 0;
279 } 167 }
280 168
281 if (tox_friend_get_connection_status(Alice, 0, 0) && tox_friend_get_connection_status(Bob, 0, 0)) 169 if (tox_friend_get_connection_status(Alice, 0, NULL) == TOX_CONNECTION_UDP &&
170 tox_friend_get_connection_status(Bob, 0, NULL) == TOX_CONNECTION_UDP)
282 break; 171 break;
283 172
284 c_sleep(20); 173 c_sleep(20);
285 } 174 }
286 175
287 printf("All set after %llu seconds! Starting call...\n", time(NULL) - cur_time); 176
288 177 {
289 muhcaps = av_DefaultSettings; 178 TOXAV_ERR_NEW error;
290 muhcaps.max_video_height = muhcaps.max_video_width = 128; 179 AliceAV = toxav_new(Alice, &error);
291 180 ck_assert(error == TOXAV_ERR_NEW_OK);
292 Status status_control = { 181
293 {none, toxav_new(Alice, 1), NULL, -1}, 182 BobAV = toxav_new(Bob, &error);
294 {none, toxav_new(Bob, 1), NULL, -1}, 183 ck_assert(error == TOXAV_ERR_NEW_OK);
295 };
296
297 ck_assert_msg(status_control.Alice.av || status_control.Bob.av, "Failed to create 2 toxav instances");
298
299
300 register_callbacks(status_control.Alice.av, &status_control);
301 register_callbacks(status_control.Bob.av, &status_control);
302
303 const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
304 int16_t sample_payload[frame_size];
305 randombytes((uint8_t *)sample_payload, sizeof(int16_t) * frame_size);
306
307 uint8_t prepared_payload[RTP_PAYLOAD_SIZE];
308 int payload_size;
309
310 vpx_image_t *sample_image = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, 128, 128, 1);
311
312 memcpy(sample_image->planes[VPX_PLANE_Y], sample_payload, 10);
313 memcpy(sample_image->planes[VPX_PLANE_U], sample_payload, 10);
314 memcpy(sample_image->planes[VPX_PLANE_V], sample_payload, 10);
315
316
317 /*************************************************************************************************
318 * Successful flows (when call starts)
319 */
320
321 /*
322 * Call with audio only on both sides. Alice calls Bob.
323 */
324
325
326 CALL_AND_START_LOOP(TypeAudio, TypeAudio) {
327 /* Both send */
328 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload,
329 1000, sample_payload, frame_size);
330
331 if ( payload_size < 0 ) {
332 ck_assert_msg ( 0, "Failed to encode payload" );
333 }
334
335 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size);
336
337 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000,
338 sample_payload, frame_size);
339
340 if ( payload_size < 0 ) {
341 ck_assert_msg ( 0, "Failed to encode payload" );
342 }
343
344 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
345
346 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
347 step++; /* This terminates the loop */
348 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
349 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index);
350
351 /* Call over Alice hangs up */
352 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index);
353 }
354 } 184 }
355 TERMINATE_SCOPE() 185
356 186 toxav_callback_call(AliceAV, t_toxav_call_cb, &AliceCC);
357 187 toxav_callback_call_state(AliceAV, t_toxav_call_state_cb, &AliceCC);
358 /* 188 toxav_callback_video_receive_frame(AliceAV, t_toxav_receive_video_frame_cb, &AliceCC);
359 * Call with audio on both sides and video on one side. Alice calls Bob. 189 toxav_callback_audio_receive_frame(AliceAV, t_toxav_receive_audio_frame_cb, &AliceCC);
360 */ 190
361 CALL_AND_START_LOOP(TypeAudio, TypeVideo) { 191 toxav_callback_call(BobAV, t_toxav_call_cb, &BobCC);
362 /* Both send */ 192 toxav_callback_call_state(BobAV, t_toxav_call_state_cb, &BobCC);
363 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, 193 toxav_callback_video_receive_frame(BobAV, t_toxav_receive_video_frame_cb, &BobCC);
364 1000, sample_payload, frame_size); 194 toxav_callback_audio_receive_frame(BobAV, t_toxav_receive_audio_frame_cb, &BobCC);
365 195
366 if ( payload_size < 0 ) { 196 printf("Created 2 instances of ToxAV\n");
367 ck_assert_msg ( 0, "Failed to encode payload" ); 197 printf("All set after %llu seconds!\n", time(NULL) - cur_time);
368 } 198
369 199
370 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size); 200#define REGULAR_CALL_FLOW(A_BR, V_BR) \
371 201 do { \
372 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000, 202 memset(&AliceCC, 0, sizeof(CallControl)); \
373 sample_payload, frame_size); 203 memset(&BobCC, 0, sizeof(CallControl)); \
374 204 \
375 if ( payload_size < 0 ) { 205 TOXAV_ERR_CALL rc; \
376 ck_assert_msg ( 0, "Failed to encode payload" ); 206 toxav_call(AliceAV, 0, A_BR, V_BR, &rc); \
377 } 207 \
378 208 if (rc != TOXAV_ERR_CALL_OK) { \
379 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size); 209 printf("toxav_call failed: %d\n", rc); \
380 210 ck_assert(0); \
381// toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image); 211 } \
382 212 \
383 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */ 213 \
384 step++; /* This terminates the loop */ 214 long long unsigned int start_time = time(NULL); \
385 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index); 215 \
386 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index); 216 \
387 217 while (BobCC.state != TOXAV_CALL_STATE_FINISHED) { \
388 /* Call over Alice hangs up */ 218 \
389 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index); 219 if (BobCC.incoming) { \
390 } 220 TOXAV_ERR_ANSWER rc; \
221 toxav_answer(BobAV, 0, A_BR, V_BR, &rc); \
222 \
223 if (rc != TOXAV_ERR_ANSWER_OK) { \
224 printf("toxav_answer failed: %d\n", rc); \
225 ck_assert(0); \
226 } \
227 BobCC.incoming = false; \
228 } else { \
229 /* TODO rtp */ \
230 \
231 if (time(NULL) - start_time >= 1) { \
232 \
233 TOXAV_ERR_CALL_CONTROL rc; \
234 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc); \
235 \
236 if (rc != TOXAV_ERR_CALL_CONTROL_OK) { \
237 printf("toxav_call_control failed: %d\n", rc); \
238 ck_assert(0); \
239 } \
240 } \
241 } \
242 \
243 iterate_tox(bootstrap, Alice, Bob); \
244 } \
245 printf("Success!\n");\
246 } while(0)
247
248 if (TEST_REGULAR_AV) {
249 printf("\nTrying regular call (Audio and Video)...\n");
250 REGULAR_CALL_FLOW(48, 4000);
391 } 251 }
392 TERMINATE_SCOPE() 252
393 253 if (TEST_REGULAR_A) {
394 254 printf("\nTrying regular call (Audio only)...\n");
395 /* 255 REGULAR_CALL_FLOW(48, 0);
396 * Call with audio and video on both sides. Alice calls Bob.
397 */
398 CALL_AND_START_LOOP(TypeVideo, TypeVideo) {
399 /* Both send */
400
401 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload,
402 1000, sample_payload, frame_size);
403
404 if ( payload_size < 0 ) {
405 ck_assert_msg ( 0, "Failed to encode payload" );
406 }
407
408 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size);
409
410 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000,
411 sample_payload, frame_size);
412
413 if ( payload_size < 0 ) {
414 ck_assert_msg ( 0, "Failed to encode payload" );
415 }
416
417 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
418
419// toxav_send_video(status_control.Alice.av, status_control.Alice.call_index, sample_image);
420// toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image);
421
422
423 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
424 step++; /* This terminates the loop */
425 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
426 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index);
427
428 /* Call over Alice hangs up */
429 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index);
430 }
431 } 256 }
432 TERMINATE_SCOPE() 257
433 258 if (TEST_REGULAR_V) {
434 259 printf("\nTrying regular call (Video only)...\n");
435 uint64_t times_they_are_a_changin = time(NULL); 260 REGULAR_CALL_FLOW(0, 4000);
436 /* Media change */ 261 }
437 CALL_AND_START_LOOP(TypeAudio, TypeAudio) { 262
438 /* Both send */ 263#undef REGULAR_CALL_FLOW
439 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, 264
440 1000, sample_payload, frame_size); 265 if (TEST_REJECT) { /* Alice calls; Bob rejects */
441 266 printf("\nTrying reject flow...\n");
442 if ( payload_size < 0 ) { 267
443 ck_assert_msg ( 0, "Failed to encode payload" ); 268 memset(&AliceCC, 0, sizeof(CallControl));
269 memset(&BobCC, 0, sizeof(CallControl));
270
271 {
272 TOXAV_ERR_CALL rc;
273 toxav_call(AliceAV, 0, 48, 0, &rc);
274
275 if (rc != TOXAV_ERR_CALL_OK) {
276 printf("toxav_call failed: %d\n", rc);
277 ck_assert(0);
278 }
444 } 279 }
445 280
446 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size); 281 while (!BobCC.incoming)
447 282 iterate_tox(bootstrap, Alice, Bob);
448 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000, 283
449 sample_payload, frame_size); 284 /* Reject */
450 285 {
451 if ( payload_size < 0 ) { 286 TOXAV_ERR_CALL_CONTROL rc;
452 ck_assert_msg ( 0, "Failed to encode payload" ); 287 toxav_call_control(BobAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
288
289 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
290 printf("toxav_call_control failed: %d\n", rc);
291 ck_assert(0);
292 }
453 } 293 }
454 294
455 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size); 295 while (AliceCC.state != TOXAV_CALL_STATE_FINISHED)
456 296 iterate_tox(bootstrap, Alice, Bob);
457 /* Wait 2 seconds and change transmission type */ 297
458 if (time(NULL) - times_they_are_a_changin > 2) { 298 printf("Success!\n");
459 times_they_are_a_changin = time(NULL); 299 }
460 muhcaps.audio_bitrate ++; 300
461 toxav_change_settings(status_control.Alice.av, status_control.Alice.call_index, &muhcaps); 301 if (TEST_CANCEL) { /* Alice calls; Alice cancels while ringing */
302 printf("\nTrying cancel (while ringing) flow...\n");
303
304 memset(&AliceCC, 0, sizeof(CallControl));
305 memset(&BobCC, 0, sizeof(CallControl));
306
307 {
308 TOXAV_ERR_CALL rc;
309 toxav_call(AliceAV, 0, 48, 0, &rc);
310
311 if (rc != TOXAV_ERR_CALL_OK) {
312 printf("toxav_call failed: %d\n", rc);
313 ck_assert(0);
314 }
462 } 315 }
463 316
464 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */ 317 while (!BobCC.incoming)
465 step++; /* This terminates the loop */ 318 iterate_tox(bootstrap, Alice, Bob);
466 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index); 319
467 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index); 320 /* Cancel */
468 321 {
469 /* Call over Alice hangs up */ 322 TOXAV_ERR_CALL_CONTROL rc;
470 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index); 323 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
324
325 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
326 printf("toxav_call_control failed: %d\n", rc);
327 ck_assert(0);
328 }
471 } 329 }
330
331 /* Alice will not receive end state */
332 while (BobCC.state != TOXAV_CALL_STATE_FINISHED)
333 iterate_tox(bootstrap, Alice, Bob);
334
335 printf("Success!\n");
472 } 336 }
473 TERMINATE_SCOPE() 337
474 338 if (TEST_MUTE_UNMUTE) { /* Check Mute-Unmute etc */
475 339 printf("\nTrying mute functionality...\n");
476 /************************************************************************************************* 340
477 * Other flows 341 memset(&AliceCC, 0, sizeof(CallControl));
478 */ 342 memset(&BobCC, 0, sizeof(CallControl));
479 343
480 /* 344 /* Assume sending audio and video */
481 * Call and reject 345 {
482 */ 346 TOXAV_ERR_CALL rc;
483 { 347 toxav_call(AliceAV, 0, 48, 1000, &rc);
484 int step = 0; 348
485 int running = 1; 349 if (rc != TOXAV_ERR_CALL_OK) {
486 350 printf("toxav_call failed: %d\n", rc);
487 while (running) { 351 ck_assert(0);
488 tox_iterate(bootstrap_node);
489 tox_iterate(Alice);
490 tox_iterate(Bob);
491
492 switch ( step ) {
493 case 0: /* Alice */
494 printf("Alice is calling...\n");
495 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10);
496 step++;
497 break;
498
499 case 1: /* Bob */
500 if (status_control.Bob.status == Ringing) {
501 printf("Bob rejects...\n");
502 toxav_reject(status_control.Bob.av, status_control.Bob.call_index, "Who likes D's anyway?");
503 step++;
504 }
505
506 break;
507
508 case 2: /* Wait for Both to have status ended */
509 if (status_control.Alice.status == Rejected && status_control.Bob.status == Ended) running = 0;
510
511 break;
512 } 352 }
513
514 c_sleep(20);
515 } 353 }
516 354
517 printf("\n"); 355 while (!BobCC.incoming)
518 } 356 iterate_tox(bootstrap, Alice, Bob);
519 357
520 358 /* At first try all stuff while in invalid state */
521 /* 359 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, NULL));
522 * Call and cancel 360 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, NULL));
523 */ 361 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, NULL));
524 { 362 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, NULL));
525 int step = 0; 363 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO, NULL));
526 int running = 1; 364 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, NULL));
527 365
528 while (running) { 366 {
529 tox_iterate(bootstrap_node); 367 TOXAV_ERR_ANSWER rc;
530 tox_iterate(Alice); 368 toxav_answer(BobAV, 0, 48, 4000, &rc);
531 tox_iterate(Bob); 369
532 370 if (rc != TOXAV_ERR_ANSWER_OK) {
533 toxav_do(status_control.Alice.av); 371 printf("toxav_answer failed: %d\n", rc);
534 toxav_do(status_control.Bob.av); 372 ck_assert(0);
535
536
537 switch ( step ) {
538 case 0: /* Alice */
539 printf("Alice is calling...\n");
540 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10);
541 step++;
542 break;
543
544
545 case 1: /* Alice again */
546 if (status_control.Bob.status == Ringing) {
547 printf("Alice cancels...\n");
548 toxav_cancel(status_control.Alice.av, status_control.Alice.call_index, 0, "Who likes D's anyway?");
549 step++;
550 }
551
552 break;
553
554 case 2: /* Wait for Both to have status ended */
555 if (status_control.Bob.status == Canceled) running = 0;
556
557 break;
558 } 373 }
559
560 c_sleep(20);
561 } 374 }
562 375
563 printf("\n"); 376 iterate_tox(bootstrap, Alice, Bob);
564 } 377
565 378 /* Pause and Resume */
566 /* 379 printf("Pause and Resume\n");
567 * Timeout 380 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, NULL));
568 */ 381 iterate_tox(bootstrap, Alice, Bob);
569 { 382 ck_assert(BobCC.state == 0);
570 int step = 0; 383 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, NULL));
571 int running = 1; 384 iterate_tox(bootstrap, Alice, Bob);
572 385 ck_assert(BobCC.state & (TOXAV_CALL_STATE_SENDING_A | TOXAV_CALL_STATE_SENDING_V));
573 while (running) { 386
574 tox_iterate(bootstrap_node); 387 /* Mute/Unmute single */
575 tox_iterate(Alice); 388 printf("Mute/Unmute single\n");
576 tox_iterate(Bob); 389 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, NULL));
577 390 iterate_tox(bootstrap, Alice, Bob);
578 toxav_do(status_control.Alice.av); 391 ck_assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_A);
579 toxav_do(status_control.Bob.av); 392 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, NULL));
580 393 iterate_tox(bootstrap, Alice, Bob);
581 switch ( step ) { 394 ck_assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_A);
582 case 0: 395
583 printf("Alice is calling...\n"); 396 /* Mute/Unmute both */
584 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10); 397 printf("Mute/Unmute both\n");
585 step++; 398 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, NULL));
586 break; 399 iterate_tox(bootstrap, Alice, Bob);
587 400 ck_assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_A);
588 case 1: 401 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO, NULL));
589 if (status_control.Alice.status == TimedOut) running = 0; 402 iterate_tox(bootstrap, Alice, Bob);
590 403 ck_assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_V);
591 break; 404 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, NULL));
405 iterate_tox(bootstrap, Alice, Bob);
406 ck_assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_A);
407 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, NULL));
408 iterate_tox(bootstrap, Alice, Bob);
409 ck_assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_V);
410
411 {
412 TOXAV_ERR_CALL_CONTROL rc;
413 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
414
415 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
416 printf("toxav_call_control failed: %d\n", rc);
417 ck_assert(0);
592 } 418 }
593
594 c_sleep(20);
595 } 419 }
596 420
597 printf("\n"); 421 iterate_tox(bootstrap, Alice, Bob);
422 ck_assert(BobCC.state == TOXAV_CALL_STATE_FINISHED);
423
424 printf("Success!\n");
598 } 425 }
599 426
600 vpx_img_free(sample_image); 427 toxav_kill(BobAV);
601 toxav_kill(status_control.Alice.av); 428 toxav_kill(AliceAV);
602 toxav_kill(status_control.Bob.av);
603 tox_kill(bootstrap_node);
604 tox_kill(Alice);
605 tox_kill(Bob); 429 tox_kill(Bob);
606 430 tox_kill(Alice);
607 printf("Calls ended!\n"); 431 tox_kill(bootstrap);
432
433 printf("\nTest successful!\n");
608} 434}
609END_TEST 435END_TEST
610 436
611/*************************************************************************************************/
612
613
614/*************************************************************************************************/
615
616/*************************************************************************************************/
617
618 437
619Suite *tox_suite(void) 438Suite *tox_suite(void)
620{ 439{
621 Suite *s = suite_create("ToxAV"); 440 Suite *s = suite_create("ToxAV");
622 441
623 DEFTESTCASE_SLOW(AV_flows, 200); 442 DEFTESTCASE_SLOW(AV_flows, 200);
624
625 return s; 443 return s;
626} 444}
627int main(int argc, char *argv[]) 445int main(int argc, char *argv[])
628{ 446{
447 (void) argc;
448 (void) argv;
449
629 Suite *tox = tox_suite(); 450 Suite *tox = tox_suite();
630 SRunner *test_runner = srunner_create(tox); 451 SRunner *test_runner = srunner_create(tox);
631 452
@@ -637,6 +458,4 @@ int main(int argc, char *argv[])
637 srunner_free(test_runner); 458 srunner_free(test_runner);
638 459
639 return number_failed; 460 return number_failed;
640
641// return test_AV_flows();
642} 461}
diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index 4287118f..a15acce3 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -9,11 +9,13 @@
9#include <check.h> 9#include <check.h>
10#include <stdlib.h> 10#include <stdlib.h>
11#include <time.h> 11#include <time.h>
12#include <assert.h>
13 12
14#include <vpx/vpx_image.h> 13#include <vpx/vpx_image.h>
15 14
15#include "helpers.h"
16
16#include "../toxcore/tox.h" 17#include "../toxcore/tox.h"
18#include "../toxcore/util.h"
17#include "../toxcore/logger.h" 19#include "../toxcore/logger.h"
18#include "../toxcore/crypto_core.h" 20#include "../toxcore/crypto_core.h"
19#include "../toxav/toxav.h" 21#include "../toxav/toxav.h"
@@ -26,359 +28,309 @@
26#define c_sleep(x) usleep(1000*x) 28#define c_sleep(x) usleep(1000*x)
27#endif 29#endif
28 30
29pthread_mutex_t muhmutex;
30
31typedef enum _CallStatus {
32 none,
33 InCall,
34 Ringing,
35 Ended,
36 Rejected,
37 Canceled
38
39} CallStatus;
40
41typedef struct _Party {
42 CallStatus status;
43 ToxAv *av;
44 int id;
45} Party;
46
47typedef struct _ACall {
48 pthread_t tid;
49 int idx;
50
51 Party Caller;
52 Party Callee;
53} ACall;
54
55typedef struct _Status {
56 ACall calls[3]; /* Make 3 calls for this test */
57} Status;
58 31
59Status status_control; 32typedef struct {
33 bool incoming;
34 uint32_t state;
35} CallControl;
60 36
61void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) 37typedef struct {
62{ 38 ToxAV* AliceAV;
63 if (length == 7 && memcmp("gentoo", data, 7) == 0) { 39 ToxAV* BobAV;
64 tox_friend_add_norequest(m, public_key, 0); 40 CallControl* AliceCC;
65 } 41 CallControl* BobCC;
66} 42 uint32_t friend_number;
43} thread_data;
67 44
68 45/**
69/******************************************************************************/ 46 * Callbacks
70void callback_recv_invite ( void *av, int32_t call_index, void *_arg ) 47 */
71{ 48void t_toxav_call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)
72 Status *cast = _arg;
73 cast->calls[call_index].Callee.status = Ringing;
74}
75void callback_recv_ringing ( void *av, int32_t call_index, void *_arg )
76{ 49{
77 Status *cast = _arg; 50 (void) av;
78 cast->calls[call_index].Caller.status = Ringing; 51 (void) audio_enabled;
52 (void) video_enabled;
53
54 printf("Handling CALL callback\n");
55 ((CallControl*)user_data)[friend_number].incoming = true;
79} 56}
80void callback_call_ended ( void *av, int32_t call_index, void *_arg ) 57void t_toxav_call_state_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)
81{ 58{
82 Status *cast = _arg; 59 (void) av;
83 60
84 if (av == cast->calls[call_index].Caller.av) 61 printf("Handling CALL STATE callback: %d\n", state);
85 cast->calls[call_index].Caller.status = Ended; 62 ((CallControl*)user_data)[friend_number].state = state;
86 else
87 cast->calls[call_index].Callee.status = Ended;
88} 63}
89void callback_call_started ( void *av, int32_t call_index, void *_arg ) 64void t_toxav_receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
65 uint16_t width, uint16_t height,
66 uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
67 int32_t ystride, int32_t ustride, int32_t vstride, int32_t stride,
68 void *user_data)
90{ 69{
91 Status *cast = _arg; 70 (void) av;
92 71 (void) friend_number;
93 if (av == cast->calls[call_index].Caller.av) 72 (void) width;
94 cast->calls[call_index].Caller.status = InCall; 73 (void) height;
95 else 74 (void) y;
96 cast->calls[call_index].Callee.status = InCall; 75 (void) u;
76 (void) v;
77 (void) ystride;
78 (void) ustride;
79 (void) vstride;
80 (void) user_data;
97} 81}
98void callback_call_canceled ( void *av, int32_t call_index, void *_arg ) 82void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
83 int16_t const *pcm,
84 size_t sample_count,
85 uint8_t channels,
86 uint32_t sampling_rate,
87 void *user_data)
99{ 88{
89 (void) av;
90 (void) friend_number;
91 (void) pcm;
92 (void) sample_count;
93 (void) channels;
94 (void) sampling_rate;
95 (void) user_data;
100} 96}
101void callback_call_rejected ( void *av, int32_t call_index, void *_arg ) 97void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
102{ 98{
103 Status *cast = _arg; 99 (void) userdata;
104 cast->calls[call_index].Caller.status = Rejected; 100 if (length == 7 && memcmp("gentoo", data, 7) == 0) {
105} 101 ck_assert(tox_friend_add_norequest(m, public_key, NULL) != (uint32_t) ~0);
106 102 }
107void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
108{
109 ck_assert_msg(0, "No answer!");
110} 103}
111 104
112void callback_audio (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data)
113{}
114 105
115void callback_video (void *agent, int32_t call_idx, const vpx_image_t *img, void *data) 106/**
116{} 107 * Iterate helper
117 108 */
118void register_callbacks(ToxAv *av, void *data) 109ToxAV* setup_av_instance(Tox* tox, CallControl *CC)
119{ 110{
120 toxav_register_callstate_callback(av, callback_call_started, av_OnStart, data); 111 TOXAV_ERR_NEW error;
121 toxav_register_callstate_callback(av, callback_call_canceled, av_OnCancel, data); 112
122 toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data); 113 ToxAV* av = toxav_new(tox, &error);
123 toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data); 114 ck_assert(error == TOXAV_ERR_NEW_OK);
124 toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data); 115
125 toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data); 116 toxav_callback_call(av, t_toxav_call_cb, CC);
126 toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data); 117 toxav_callback_call_state(av, t_toxav_call_state_cb, CC);
127 118 toxav_callback_video_receive_frame(av, t_toxav_receive_video_frame_cb, CC);
128 119 toxav_callback_audio_receive_frame(av, t_toxav_receive_audio_frame_cb, CC);
129 toxav_register_audio_callback(av, callback_audio, NULL); 120
130 toxav_register_video_callback(av, callback_video, NULL); 121 return av;
131} 122}
132/*************************************************************************************************/ 123void* call_thread(void* pd)
133
134int call_running[3];
135
136void *in_thread_call (void *arg)
137{ 124{
138#define call_print(call, what, args...) printf("[%d] " what "\n", call, ##args) 125 ToxAV* AliceAV = ((thread_data*) pd)->AliceAV;
139 126 ToxAV* BobAV = ((thread_data*) pd)->BobAV;
140 ACall *this_call = arg; 127 CallControl* AliceCC = ((thread_data*) pd)->AliceCC;
141 uint64_t start = 0; 128 CallControl* BobCC = ((thread_data*) pd)->BobCC;
142 int step = 0; 129 uint32_t friend_number = ((thread_data*) pd)->friend_number;
143 int call_idx; 130
144 131
145 const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000); 132 memset(AliceCC, 0, sizeof(CallControl));
146 int16_t sample_payload[frame_size]; 133 memset(BobCC, 0, sizeof(CallControl));
147 randombytes((uint8_t *)sample_payload, sizeof(int16_t) * frame_size); 134
148 135 { /* Call */
149 uint8_t prepared_payload[RTP_PAYLOAD_SIZE]; 136 TOXAV_ERR_CALL rc;
150 137 toxav_call(AliceAV, friend_number, 48, 3000, &rc);
151 register_callbacks(this_call->Caller.av, &status_control); 138
152 register_callbacks(this_call->Callee.av, arg); 139 if (rc != TOXAV_ERR_CALL_OK) {
153 140 printf("toxav_call failed: %d\n", rc);
154 /* NOTE: CALLEE WILL ALWAHYS NEED CALL_IDX == 0 */ 141 ck_assert(0);
155 pthread_mutex_lock(&muhmutex);
156
157 while (call_running[this_call->idx]) {
158
159 pthread_mutex_unlock(&muhmutex);
160
161 switch ( step ) {
162 case 0: /* CALLER */
163 toxav_call(this_call->Caller.av, &call_idx, this_call->Callee.id, &av_DefaultSettings, 10);
164 call_print(call_idx, "Calling ...");
165 step++;
166 break;
167
168 case 1: /* CALLEE */
169 pthread_mutex_lock(&muhmutex);
170
171 if (this_call->Caller.status == Ringing) {
172 call_print(call_idx, "Callee answers ...");
173 pthread_mutex_unlock(&muhmutex);
174 toxav_answer(this_call->Callee.av, 0, &av_DefaultSettings);
175 step++;
176 start = time(NULL);
177 pthread_mutex_lock(&muhmutex);
178 }
179
180 pthread_mutex_unlock(&muhmutex);
181 break;
182
183 case 2: /* Rtp transmission */
184 pthread_mutex_lock(&muhmutex);
185
186 if (this_call->Caller.status == InCall) { /* I think this is okay */
187 call_print(call_idx, "Sending rtp ...");
188 pthread_mutex_unlock(&muhmutex);
189
190 c_sleep(1000); /* We have race condition here */
191 toxav_prepare_transmission(this_call->Callee.av, 0, 1);
192 toxav_prepare_transmission(this_call->Caller.av, call_idx, 1);
193
194 int payload_size = toxav_prepare_audio_frame(this_call->Caller.av, call_idx, prepared_payload, RTP_PAYLOAD_SIZE,
195 sample_payload, frame_size);
196
197 if ( payload_size < 0 ) {
198 ck_assert_msg ( 0, "Failed to encode payload" );
199 }
200
201
202 while (time(NULL) - start < 10) { /* 10 seconds */
203 /* Both send */
204 toxav_send_audio(this_call->Caller.av, call_idx, prepared_payload, payload_size);
205
206 toxav_send_audio(this_call->Callee.av, 0, prepared_payload, payload_size);
207
208 /* Both receive */
209 int16_t storage[RTP_PAYLOAD_SIZE];
210 int recved;
211
212 c_sleep(20);
213 }
214
215 step++; /* This terminates the loop */
216
217 pthread_mutex_lock(&muhmutex);
218 toxav_kill_transmission(this_call->Callee.av, 0);
219 toxav_kill_transmission(this_call->Caller.av, call_idx);
220 pthread_mutex_unlock(&muhmutex);
221
222 /* Call over CALLER hangs up */
223 toxav_hangup(this_call->Caller.av, call_idx);
224 call_print(call_idx, "Hanging up ...");
225
226 pthread_mutex_lock(&muhmutex);
227 }
228
229 pthread_mutex_unlock(&muhmutex);
230 break;
231
232 case 3: /* Wait for Both to have status ended */
233 pthread_mutex_lock(&muhmutex);
234
235 if (this_call->Caller.status == Ended) {
236 pthread_mutex_unlock(&muhmutex);
237 c_sleep(1000); /* race condition */
238 pthread_mutex_lock(&muhmutex);
239 this_call->Callee.status = Ended;
240 call_running[this_call->idx] = 0;
241 }
242
243 pthread_mutex_unlock(&muhmutex);
244
245 break;
246
247 } 142 }
248
249 c_sleep(20);
250
251 pthread_mutex_lock(&muhmutex);
252 } 143 }
253 144
254 pthread_mutex_unlock(&muhmutex); 145 while (!BobCC->incoming)
255 call_print(call_idx, "Call ended successfully!"); 146 c_sleep(10);
147
148 { /* Answer */
149 TOXAV_ERR_ANSWER rc;
150 toxav_answer(BobAV, 0, 8, 500, &rc);
151
152 if (rc != TOXAV_ERR_ANSWER_OK) {
153 printf("toxav_answer failed: %d\n", rc);
154 ck_assert(0);
155 }
156 }
157
158 c_sleep(30);
159
160 int16_t PCM[960];
161 uint8_t video_y[800*600];
162 uint8_t video_u[800*600 / 2];
163 uint8_t video_v[800*600 / 2];
164 uint8_t video_a[800*600];
165
166 memset(PCM, 0, sizeof(PCM));
167 memset(video_y, 0, sizeof(video_y));
168 memset(video_u, 0, sizeof(video_u));
169 memset(video_v, 0, sizeof(video_v));
170 memset(video_a, 0, sizeof(video_a));
171
172 time_t start_time = time(NULL);
173 while(time(NULL) - start_time < 4) {
174 toxav_iterate(AliceAV);
175 toxav_iterate(BobAV);
176
177 toxav_audio_send_frame(AliceAV, friend_number, PCM, 960, 1, 48000, NULL);
178 toxav_audio_send_frame(BobAV, 0, PCM, 960, 1, 48000, NULL);
179
180 toxav_video_send_frame(AliceAV, friend_number, 800, 600, video_y, video_u, video_v, video_a, NULL);
181 toxav_video_send_frame(BobAV, 0, 800, 600, video_y, video_u, video_v, video_a, NULL);
182
183 c_sleep(10);
184 }
185
186 { /* Hangup */
187 TOXAV_ERR_CALL_CONTROL rc;
188 toxav_call_control(AliceAV, friend_number, TOXAV_CALL_CONTROL_CANCEL, &rc);
189
190 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
191 printf("toxav_call_control failed: %d\n", rc);
192 ck_assert(0);
193 }
194 }
195
196 c_sleep(30);
197
198 printf ("Closing thread\n");
256 pthread_exit(NULL); 199 pthread_exit(NULL);
257} 200}
258 201
259 202
260
261
262
263START_TEST(test_AV_three_calls) 203START_TEST(test_AV_three_calls)
264// void test_AV_three_calls()
265{ 204{
266 long long unsigned int cur_time = time(NULL); 205 Tox* Alice, *bootstrap, *Bobs[3];
267 Tox *bootstrap_node = tox_new(0, 0, 0, 0); 206 ToxAV* AliceAV, *BobsAV[3];
268 Tox *caller = tox_new(0, 0, 0, 0); 207
269 Tox *callees[3] = { 208 CallControl AliceCC[3], BobsCC[3];
270 tox_new(0, 0, 0, 0), 209
271 tox_new(0, 0, 0, 0), 210 {
272 tox_new(0, 0, 0, 0), 211 TOX_ERR_NEW error;
273 }; 212
274 213 bootstrap = tox_new(NULL, NULL, 0, &error);
275 214 ck_assert(error == TOX_ERR_NEW_OK);
276 ck_assert_msg(bootstrap_node != NULL, "Failed to create bootstrap node"); 215
277 216 Alice = tox_new(NULL, NULL, 0, &error);
278 int i = 0; 217 ck_assert(error == TOX_ERR_NEW_OK);
279 218
280 for (; i < 3; i ++) { 219 Bobs[0] = tox_new(NULL, NULL, 0, &error);
281 ck_assert_msg(callees[i] != NULL, "Failed to create 3 tox instances"); 220 ck_assert(error == TOX_ERR_NEW_OK);
221
222 Bobs[1] = tox_new(NULL, NULL, 0, &error);
223 ck_assert(error == TOX_ERR_NEW_OK);
224
225 Bobs[2] = tox_new(NULL, NULL, 0, &error);
226 ck_assert(error == TOX_ERR_NEW_OK);
282 } 227 }
283 228
284 for ( i = 0; i < 3; i ++ ) { 229 printf("Created 5 instances of Tox\n");
285 uint32_t to_compare = 974536; 230 printf("Preparing network...\n");
286 tox_callback_friend_request(callees[i], accept_friend_request, &to_compare); 231 long long unsigned int cur_time = time(NULL);
287 uint8_t address[TOX_ADDRESS_SIZE]; 232
288 tox_self_get_address(callees[i], address); 233 uint32_t to_compare = 974536;
289 234 uint8_t address[TOX_ADDRESS_SIZE];
290 uint32_t test = tox_friend_add(caller, address, (uint8_t *)"gentoo", 7, 0); 235
291 ck_assert_msg( test == i, "Failed to add friend error code: %i", test); 236 tox_callback_friend_request(Alice, t_accept_friend_request_cb, &to_compare);
292 } 237 tox_self_get_address(Alice, address);
293 238
239
240 ck_assert(tox_friend_add(Bobs[0], address, (uint8_t *)"gentoo", 7, NULL) != (uint32_t) ~0);
241 ck_assert(tox_friend_add(Bobs[1], address, (uint8_t *)"gentoo", 7, NULL) != (uint32_t) ~0);
242 ck_assert(tox_friend_add(Bobs[2], address, (uint8_t *)"gentoo", 7, NULL) != (uint32_t) ~0);
243
294 uint8_t off = 1; 244 uint8_t off = 1;
295 245
296 while (1) { 246 while (1) {
297 tox_iterate(bootstrap_node); 247 tox_iterate(bootstrap);
298 tox_iterate(caller); 248 tox_iterate(Alice);
299 249 tox_iterate(Bobs[0]);
300 for (i = 0; i < 3; i ++) { 250 tox_iterate(Bobs[1]);
301 tox_iterate(callees[i]); 251 tox_iterate(Bobs[2]);
302 } 252
303 253 if (tox_self_get_connection_status(bootstrap) &&
304 254 tox_self_get_connection_status(Alice) &&
305 if (tox_self_get_connection_status(bootstrap_node) && 255 tox_self_get_connection_status(Bobs[0]) &&
306 tox_self_get_connection_status(caller) && 256 tox_self_get_connection_status(Bobs[1]) &&
307 tox_self_get_connection_status(callees[0]) && 257 tox_self_get_connection_status(Bobs[2]) && off) {
308 tox_self_get_connection_status(callees[1]) &&
309 tox_self_get_connection_status(callees[2]) && off) {
310 printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time); 258 printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time);
311 off = 0; 259 off = 0;
312 } 260 }
313 261
314 262 if (tox_friend_get_connection_status(Alice, 0, NULL) == TOX_CONNECTION_UDP &&
315 if (tox_friend_get_connection_status(caller, 0, 0) && 263 tox_friend_get_connection_status(Alice, 1, NULL) == TOX_CONNECTION_UDP &&
316 tox_friend_get_connection_status(caller, 1, 0) && 264 tox_friend_get_connection_status(Alice, 2, NULL) == TOX_CONNECTION_UDP &&
317 tox_friend_get_connection_status(caller, 2, 0) ) 265 tox_friend_get_connection_status(Bobs[0], 0, NULL) == TOX_CONNECTION_UDP &&
266 tox_friend_get_connection_status(Bobs[1], 0, NULL) == TOX_CONNECTION_UDP &&
267 tox_friend_get_connection_status(Bobs[2], 0, NULL) == TOX_CONNECTION_UDP)
318 break; 268 break;
319 269
320 c_sleep(20); 270 c_sleep(20);
321 } 271 }
322 272
323 printf("All set after %llu seconds! Starting call...\n", time(NULL) - cur_time); 273 AliceAV = setup_av_instance(Alice, AliceCC);
324 274 BobsAV[0] = setup_av_instance(Bobs[0], BobsCC + 0);
325 ToxAv *uniqcallerav = toxav_new(caller, 3); 275 BobsAV[1] = setup_av_instance(Bobs[1], BobsCC + 1);
326 276 BobsAV[2] = setup_av_instance(Bobs[2], BobsCC + 2);
327 for (i = 0; i < 3; i ++) { 277
328 status_control.calls[i].idx = i; 278 printf("Created 4 instances of ToxAV\n");
329 279 printf("All set after %llu seconds!\n", time(NULL) - cur_time);
330 status_control.calls[i].Caller.av = uniqcallerav; 280
331 status_control.calls[i].Caller.id = 0; 281 thread_data tds[3];
332 status_control.calls[i].Caller.status = none; 282 tds[0].AliceAV = AliceAV;
333 283 tds[0].BobAV = BobsAV[0];
334 status_control.calls[i].Callee.av = toxav_new(callees[i], 1); 284 tds[0].AliceCC = AliceCC + 0;
335 status_control.calls[i].Callee.id = i; 285 tds[0].BobCC = BobsCC + 0;
336 status_control.calls[i].Callee.status = none; 286 tds[0].friend_number = 0;
337 } 287
338 288 tds[1].AliceAV = AliceAV;
339 pthread_mutex_init(&muhmutex, NULL); 289 tds[1].BobAV = BobsAV[1];
340 290 tds[1].AliceCC = AliceCC + 1;
341 for ( i = 0; i < 3; i++ ) { 291 tds[1].BobCC = BobsCC + 1;
342 call_running[i] = 1; 292 tds[1].friend_number = 1;
343 pthread_create(&status_control.calls[i].tid, NULL, in_thread_call, &status_control.calls[i]); 293
344 } 294 tds[2].AliceAV = AliceAV;
345 295 tds[2].BobAV = BobsAV[2];
346 /* Now start 3 calls and they'll run for 10 s */ 296 tds[2].AliceCC = AliceCC + 2;
347 297 tds[2].BobCC = BobsCC + 2;
348 for ( i = 0; i < 3; i++ ) 298 tds[2].friend_number = 2;
349 pthread_detach(status_control.calls[i].tid); 299
350 300 pthread_t tids[3];
351 while (call_running[0] || call_running[1] || call_running[2]) { 301 (void) pthread_create(tids + 0, NULL, call_thread, tds + 0);
352 pthread_mutex_lock(&muhmutex); 302 (void) pthread_create(tids + 1, NULL, call_thread, tds + 1);
353 303 (void) pthread_create(tids + 2, NULL, call_thread, tds + 2);
354 tox_iterate(bootstrap_node); 304
355 tox_iterate(caller); 305 (void) pthread_detach(tids[0]);
356 tox_iterate(callees[0]); 306 (void) pthread_detach(tids[1]);
357 tox_iterate(callees[1]); 307 (void) pthread_detach(tids[2]);
358 tox_iterate(callees[2]); 308
359 309 time_t start_time = time(NULL);
360 for ( i = 0; i < 3; i++ ) 310 while (time(NULL) - start_time < 5) {
361 toxav_do(status_control.calls[0].Caller.av); 311 tox_iterate(Alice);
362 312 tox_iterate(Bobs[0]);
363 toxav_do(status_control.calls[0].Callee.av); 313 tox_iterate(Bobs[1]);
364 toxav_do(status_control.calls[1].Callee.av); 314 tox_iterate(Bobs[2]);
365 toxav_do(status_control.calls[2].Callee.av);
366
367 pthread_mutex_unlock(&muhmutex);
368 c_sleep(20); 315 c_sleep(20);
369 } 316 }
370 317
371 toxav_kill(status_control.calls[0].Caller.av); 318 (void) pthread_join(tids[0], NULL);
372 toxav_kill(status_control.calls[0].Callee.av); 319 (void) pthread_join(tids[1], NULL);
373 toxav_kill(status_control.calls[1].Callee.av); 320 (void) pthread_join(tids[2], NULL);
374 toxav_kill(status_control.calls[2].Callee.av); 321
375 322 printf ("Killing all instances\n");
376 tox_kill(bootstrap_node); 323 toxav_kill(BobsAV[0]);
377 tox_kill(caller); 324 toxav_kill(BobsAV[1]);
378 325 toxav_kill(BobsAV[2]);
379 for ( i = 0; i < 3; i ++) 326 toxav_kill(AliceAV);
380 tox_kill(callees[i]); 327 tox_kill(Bobs[0]);
381 328 tox_kill(Bobs[1]);
329 tox_kill(Bobs[2]);
330 tox_kill(Alice);
331 tox_kill(bootstrap);
332
333 printf("\nTest successful!\n");
382} 334}
383END_TEST 335END_TEST
384 336
@@ -399,6 +351,9 @@ Suite *tox_suite(void)
399 351
400int main(int argc, char *argv[]) 352int main(int argc, char *argv[])
401{ 353{
354 (void) argc;
355 (void) argv;
356
402 Suite *tox = tox_suite(); 357 Suite *tox = tox_suite();
403 SRunner *test_runner = srunner_create(tox); 358 SRunner *test_runner = srunner_create(tox);
404 359
@@ -410,8 +365,4 @@ int main(int argc, char *argv[])
410 srunner_free(test_runner); 365 srunner_free(test_runner);
411 366
412 return number_failed; 367 return number_failed;
413
414// test_AV_three_calls();
415
416// return 0;
417} 368}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-30 04:07:44 +0000