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