1 /* SPDX-License-Identifier: GPL-3.0-or-later
2 * Copyright © 2016-2018 The TokTok team.
3 * Copyright © 2013-2015 Tox project.
4 */
5 #ifdef HAVE_CONFIG_H
6 #include "config.h"
7 #endif /* HAVE_CONFIG_H */
8
9 #include "toxav.h"
10
11 #include "msi.h"
12 #include "rtp.h"
13
14 #include "../toxcore/Messenger.h"
15 #include "../toxcore/logger.h"
16 #include "../toxcore/mono_time.h"
17 #include "../toxcore/util.h"
18
19 #include <assert.h>
20 #include <errno.h>
21 #include <limits.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 // TODO(zoff99): don't hardcode this, let the application choose it
26 // VPX Info: Time to spend encoding, in microseconds (it's a *soft* deadline)
27 #define WANTED_MAX_ENCODER_FPS 40
28 #define MAX_ENCODE_TIME_US (1000000 / WANTED_MAX_ENCODER_FPS) // to allow x fps
29
30 #define VIDEO_SEND_X_KEYFRAMES_FIRST 7 // force the first n frames to be keyframes!
31
32 /*
33 * VPX_DL_REALTIME (1) deadline parameter analogous to VPx REALTIME mode.
34 * VPX_DL_GOOD_QUALITY (1000000) deadline parameter analogous to VPx GOOD QUALITY mode.
35 * VPX_DL_BEST_QUALITY (0) deadline parameter analogous to VPx BEST QUALITY mode.
36 */
37
38 typedef struct ToxAVCall_s {
39 ToxAV *av;
40
41 pthread_mutex_t mutex_audio[1];
42 RTPSession *audio_rtp;
43 ACSession *audio;
44
45 pthread_mutex_t mutex_video[1];
46 RTPSession *video_rtp;
47 VCSession *video;
48
49 BWController *bwc;
50
51 bool active;
52 MSICall *msi_call;
53 uint32_t friend_number;
54
55 uint32_t audio_bit_rate; /* Sending audio bit rate */
56 uint32_t video_bit_rate; /* Sending video bit rate */
57
58 /** Required for monitoring changes in states */
59 uint8_t previous_self_capabilities;
60
61 pthread_mutex_t toxav_call_mutex[1];
62
63 struct ToxAVCall_s *prev;
64 struct ToxAVCall_s *next;
65 } ToxAVCall;
66
67 struct ToxAV {
68 Tox *tox;
69 Messenger *m;
70 MSISession *msi;
71
72 /* Two-way storage: first is array of calls and second is list of calls with head and tail */
73 ToxAVCall **calls;
74 uint32_t calls_tail;
75 uint32_t calls_head;
76 pthread_mutex_t mutex[1];
77
78 /* Call callback */
79 toxav_call_cb *ccb;
80 void *ccb_user_data;
81 /* Call state callback */
82 toxav_call_state_cb *scb;
83 void *scb_user_data;
84 /* Audio frame receive callback */
85 toxav_audio_receive_frame_cb *acb;
86 void *acb_user_data;
87 /* Video frame receive callback */
88 toxav_video_receive_frame_cb *vcb;
89 void *vcb_user_data;
90 /* Bit rate control callback */
91 toxav_audio_bit_rate_cb *abcb;
92 void *abcb_user_data;
93 /* Bit rate control callback */
94 toxav_video_bit_rate_cb *vbcb;
95 void *vbcb_user_data;
96
97 /** Decode time measures */
98 int32_t dmssc; /** Measure count */
99 int32_t dmsst; /** Last cycle total */
100 int32_t dmssa; /** Average decoding time in ms */
101
102 uint32_t interval; /** Calculated interval */
103 Mono_Time *toxav_mono_time; /** ToxAV's own mono_time instance */
104 };
105
106 static void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *user_data);
107
108 static int callback_invite(void *toxav_inst, MSICall *call);
109 static int callback_start(void *toxav_inst, MSICall *call);
110 static int callback_end(void *toxav_inst, MSICall *call);
111 static int callback_error(void *toxav_inst, MSICall *call);
112 static int callback_capabilites(void *toxav_inst, MSICall *call);
113
114 static bool audio_bit_rate_invalid(uint32_t bit_rate);
115 static bool video_bit_rate_invalid(uint32_t bit_rate);
116 static bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state);
117 static ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, Toxav_Err_Call *error);
118 static ToxAVCall *call_get(ToxAV *av, uint32_t friend_number);
119 static ToxAVCall *call_remove(ToxAVCall *call);
120 static bool call_prepare_transmission(ToxAVCall *call);
121 static void call_kill_transmission(ToxAVCall *call);
122
toxav_new(Tox * tox,Toxav_Err_New * error)123 ToxAV *toxav_new(Tox *tox, Toxav_Err_New *error)
124 {
125 Toxav_Err_New rc = TOXAV_ERR_NEW_OK;
126 ToxAV *av = nullptr;
127
128 if (tox == nullptr) {
129 rc = TOXAV_ERR_NEW_NULL;
130 goto RETURN;
131 }
132
133 // TODO(iphydf): Don't rely on toxcore internals.
134 Messenger *m;
135 //!TOKSTYLE-
136 m = *(Messenger **)tox;
137 //!TOKSTYLE+
138
139 if (m->msi_packet) {
140 rc = TOXAV_ERR_NEW_MULTIPLE;
141 goto RETURN;
142 }
143
144 av = (ToxAV *)calloc(sizeof(ToxAV), 1);
145
146 if (av == nullptr) {
147 LOGGER_WARNING(m->log, "Allocation failed!");
148 rc = TOXAV_ERR_NEW_MALLOC;
149 goto RETURN;
150 }
151
152 if (create_recursive_mutex(av->mutex) != 0) {
153 LOGGER_WARNING(m->log, "Mutex creation failed!");
154 rc = TOXAV_ERR_NEW_MALLOC;
155 goto RETURN;
156 }
157
158 av->tox = tox;
159 av->m = m;
160 av->toxav_mono_time = mono_time_new();
161 av->msi = msi_new(av->m);
162
163 if (av->msi == nullptr) {
164 pthread_mutex_destroy(av->mutex);
165 rc = TOXAV_ERR_NEW_MALLOC;
166 goto RETURN;
167 }
168
169 av->interval = 200;
170 av->msi->av = av;
171
172 msi_register_callback(av->msi, callback_invite, MSI_ON_INVITE);
173 msi_register_callback(av->msi, callback_start, MSI_ON_START);
174 msi_register_callback(av->msi, callback_end, MSI_ON_END);
175 msi_register_callback(av->msi, callback_error, MSI_ON_ERROR);
176 msi_register_callback(av->msi, callback_error, MSI_ON_PEERTIMEOUT);
177 msi_register_callback(av->msi, callback_capabilites, MSI_ON_CAPABILITIES);
178
179 RETURN:
180
181 if (error) {
182 *error = rc;
183 }
184
185 if (rc != TOXAV_ERR_NEW_OK) {
186 free(av);
187 av = nullptr;
188 }
189
190 return av;
191 }
toxav_kill(ToxAV * av)192 void toxav_kill(ToxAV *av)
193 {
194 if (av == nullptr) {
195 return;
196 }
197
198 pthread_mutex_lock(av->mutex);
199
200 /* To avoid possible deadlocks */
201 while (av->msi && msi_kill(av->msi, av->m->log) != 0) {
202 pthread_mutex_unlock(av->mutex);
203 pthread_mutex_lock(av->mutex);
204 }
205
206 /* Msi kill will hang up all calls so just clean these calls */
207 if (av->calls) {
208 ToxAVCall *it = call_get(av, av->calls_head);
209
210 while (it) {
211 call_kill_transmission(it);
212 it->msi_call = nullptr; /* msi_kill() frees the call's msi_call handle; which causes #278 */
213 it = call_remove(it); /* This will eventually free av->calls */
214 }
215 }
216
217 mono_time_free(av->toxav_mono_time);
218
219 pthread_mutex_unlock(av->mutex);
220 pthread_mutex_destroy(av->mutex);
221
222 free(av);
223 }
toxav_get_tox(const ToxAV * av)224 Tox *toxav_get_tox(const ToxAV *av)
225 {
226 return av->tox;
227 }
toxav_iteration_interval(const ToxAV * av)228 uint32_t toxav_iteration_interval(const ToxAV *av)
229 {
230 /* If no call is active interval is 200 */
231 return av->calls ? av->interval : 200;
232 }
toxav_iterate(ToxAV * av)233 void toxav_iterate(ToxAV *av)
234 {
235 pthread_mutex_lock(av->mutex);
236
237 if (av->calls == nullptr) {
238 pthread_mutex_unlock(av->mutex);
239 return;
240 }
241
242 uint64_t start = current_time_monotonic(av->toxav_mono_time);
243 int32_t rc = 500;
244
245 ToxAVCall *i = av->calls[av->calls_head];
246
247 for (; i; i = i->next) {
248 if (i->active) {
249 pthread_mutex_lock(i->toxav_call_mutex);
250 pthread_mutex_unlock(av->mutex);
251
252 ac_iterate(i->audio);
253 vc_iterate(i->video);
254
255 if (i->msi_call->self_capabilities & MSI_CAP_R_AUDIO &&
256 i->msi_call->peer_capabilities & MSI_CAP_S_AUDIO) {
257 rc = min_s32(i->audio->lp_frame_duration, rc);
258 }
259
260 if (i->msi_call->self_capabilities & MSI_CAP_R_VIDEO &&
261 i->msi_call->peer_capabilities & MSI_CAP_S_VIDEO) {
262 pthread_mutex_lock(i->video->queue_mutex);
263 rc = min_u32(i->video->lcfd, rc);
264 pthread_mutex_unlock(i->video->queue_mutex);
265 }
266
267 uint32_t fid = i->friend_number;
268
269 pthread_mutex_unlock(i->toxav_call_mutex);
270 pthread_mutex_lock(av->mutex);
271
272 /* In case this call is popped from container stop iteration */
273 if (call_get(av, fid) != i) {
274 break;
275 }
276 }
277 }
278
279 av->interval = rc < av->dmssa ? 0 : (rc - av->dmssa);
280 av->dmsst += current_time_monotonic(av->toxav_mono_time) - start;
281
282 if (++av->dmssc == 3) {
283 av->dmssa = av->dmsst / 3 + 5; /* NOTE Magic Offset 5 for precision */
284 av->dmssc = 0;
285 av->dmsst = 0;
286 }
287
288 pthread_mutex_unlock(av->mutex);
289 }
toxav_call(ToxAV * av,uint32_t friend_number,uint32_t audio_bit_rate,uint32_t video_bit_rate,Toxav_Err_Call * error)290 bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate,
291 Toxav_Err_Call *error)
292 {
293 Toxav_Err_Call rc = TOXAV_ERR_CALL_OK;
294 ToxAVCall *call;
295
296 pthread_mutex_lock(av->mutex);
297
298 if ((audio_bit_rate && audio_bit_rate_invalid(audio_bit_rate))
299 || (video_bit_rate && video_bit_rate_invalid(video_bit_rate))) {
300 rc = TOXAV_ERR_CALL_INVALID_BIT_RATE;
301 goto RETURN;
302 }
303
304 call = call_new(av, friend_number, &rc);
305
306 if (call == nullptr) {
307 goto RETURN;
308 }
309
310 call->audio_bit_rate = audio_bit_rate;
311 call->video_bit_rate = video_bit_rate;
312
313 call->previous_self_capabilities = MSI_CAP_R_AUDIO | MSI_CAP_R_VIDEO;
314
315 call->previous_self_capabilities |= audio_bit_rate > 0 ? MSI_CAP_S_AUDIO : 0;
316 call->previous_self_capabilities |= video_bit_rate > 0 ? MSI_CAP_S_VIDEO : 0;
317
318 if (msi_invite(av->msi, &call->msi_call, friend_number, call->previous_self_capabilities) != 0) {
319 call_remove(call);
320 rc = TOXAV_ERR_CALL_SYNC;
321 goto RETURN;
322 }
323
324 call->msi_call->av_call = call;
325
326 RETURN:
327 pthread_mutex_unlock(av->mutex);
328
329 if (error) {
330 *error = rc;
331 }
332
333 return rc == TOXAV_ERR_CALL_OK;
334 }
toxav_callback_call(ToxAV * av,toxav_call_cb * callback,void * user_data)335 void toxav_callback_call(ToxAV *av, toxav_call_cb *callback, void *user_data)
336 {
337 pthread_mutex_lock(av->mutex);
338 av->ccb = callback;
339 av->ccb_user_data = user_data;
340 pthread_mutex_unlock(av->mutex);
341 }
toxav_answer(ToxAV * av,uint32_t friend_number,uint32_t audio_bit_rate,uint32_t video_bit_rate,Toxav_Err_Answer * error)342 bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate,
343 Toxav_Err_Answer *error)
344 {
345 pthread_mutex_lock(av->mutex);
346
347 Toxav_Err_Answer rc = TOXAV_ERR_ANSWER_OK;
348 ToxAVCall *call;
349
350 if (m_friend_exists(av->m, friend_number) == 0) {
351 rc = TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND;
352 goto RETURN;
353 }
354
355 if ((audio_bit_rate && audio_bit_rate_invalid(audio_bit_rate))
356 || (video_bit_rate && video_bit_rate_invalid(video_bit_rate))
357 ) {
358 rc = TOXAV_ERR_ANSWER_INVALID_BIT_RATE;
359 goto RETURN;
360 }
361
362 call = call_get(av, friend_number);
363
364 if (call == nullptr) {
365 rc = TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING;
366 goto RETURN;
367 }
368
369 if (!call_prepare_transmission(call)) {
370 rc = TOXAV_ERR_ANSWER_CODEC_INITIALIZATION;
371 goto RETURN;
372 }
373
374 call->audio_bit_rate = audio_bit_rate;
375 call->video_bit_rate = video_bit_rate;
376
377 call->previous_self_capabilities = MSI_CAP_R_AUDIO | MSI_CAP_R_VIDEO;
378
379 call->previous_self_capabilities |= audio_bit_rate > 0 ? MSI_CAP_S_AUDIO : 0;
380 call->previous_self_capabilities |= video_bit_rate > 0 ? MSI_CAP_S_VIDEO : 0;
381
382 if (msi_answer(call->msi_call, call->previous_self_capabilities) != 0) {
383 rc = TOXAV_ERR_ANSWER_SYNC;
384 }
385
386 RETURN:
387 pthread_mutex_unlock(av->mutex);
388
389 if (error) {
390 *error = rc;
391 }
392
393 return rc == TOXAV_ERR_ANSWER_OK;
394 }
toxav_callback_call_state(ToxAV * av,toxav_call_state_cb * callback,void * user_data)395 void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *user_data)
396 {
397 pthread_mutex_lock(av->mutex);
398 av->scb = callback;
399 av->scb_user_data = user_data;
400 pthread_mutex_unlock(av->mutex);
401 }
toxav_call_control(ToxAV * av,uint32_t friend_number,Toxav_Call_Control control,Toxav_Err_Call_Control * error)402 bool toxav_call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control, Toxav_Err_Call_Control *error)
403 {
404 pthread_mutex_lock(av->mutex);
405 Toxav_Err_Call_Control rc = TOXAV_ERR_CALL_CONTROL_OK;
406 ToxAVCall *call;
407
408 if (m_friend_exists(av->m, friend_number) == 0) {
409 rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND;
410 goto RETURN;
411 }
412
413 call = call_get(av, friend_number);
414
415 if (call == nullptr || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
416 rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
417 goto RETURN;
418 }
419
420 switch (control) {
421 case TOXAV_CALL_CONTROL_RESUME: {
422 /* Only act if paused and had media transfer active before */
423 if (call->msi_call->self_capabilities == 0 &&
424 call->previous_self_capabilities) {
425
426 if (msi_change_capabilities(call->msi_call,
427 call->previous_self_capabilities) == -1) {
428 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
429 goto RETURN;
430 }
431
432 rtp_allow_receiving(call->audio_rtp);
433 rtp_allow_receiving(call->video_rtp);
434 } else {
435 rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
436 goto RETURN;
437 }
438 }
439 break;
440
441 case TOXAV_CALL_CONTROL_PAUSE: {
442 /* Only act if not already paused */
443 if (call->msi_call->self_capabilities) {
444 call->previous_self_capabilities = call->msi_call->self_capabilities;
445
446 if (msi_change_capabilities(call->msi_call, 0) == -1) {
447 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
448 goto RETURN;
449 }
450
451 rtp_stop_receiving(call->audio_rtp);
452 rtp_stop_receiving(call->video_rtp);
453 } else {
454 rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
455 goto RETURN;
456 }
457 }
458 break;
459
460 case TOXAV_CALL_CONTROL_CANCEL: {
461 /* Hang up */
462 pthread_mutex_lock(call->toxav_call_mutex);
463
464 if (msi_hangup(call->msi_call) != 0) {
465 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
466 pthread_mutex_unlock(call->toxav_call_mutex);
467 goto RETURN;
468 }
469
470 call->msi_call = nullptr;
471 pthread_mutex_unlock(call->toxav_call_mutex);
472
473 /* No mather the case, terminate the call */
474 call_kill_transmission(call);
475 call_remove(call);
476 }
477 break;
478
479 case TOXAV_CALL_CONTROL_MUTE_AUDIO: {
480 if (call->msi_call->self_capabilities & MSI_CAP_R_AUDIO) {
481 if (msi_change_capabilities(call->msi_call, call->
482 msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) == -1) {
483 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
484 goto RETURN;
485 }
486
487 rtp_stop_receiving(call->audio_rtp);
488 } else {
489 rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
490 goto RETURN;
491 }
492 }
493 break;
494
495 case TOXAV_CALL_CONTROL_UNMUTE_AUDIO: {
496 if (call->msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) {
497 if (msi_change_capabilities(call->msi_call, call->
498 msi_call->self_capabilities | MSI_CAP_R_AUDIO) == -1) {
499 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
500 goto RETURN;
501 }
502
503 rtp_allow_receiving(call->audio_rtp);
504 } else {
505 rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
506 goto RETURN;
507 }
508 }
509 break;
510
511 case TOXAV_CALL_CONTROL_HIDE_VIDEO: {
512 if (call->msi_call->self_capabilities & MSI_CAP_R_VIDEO) {
513 if (msi_change_capabilities(call->msi_call, call->
514 msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) == -1) {
515 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
516 goto RETURN;
517 }
518
519 rtp_stop_receiving(call->video_rtp);
520 } else {
521 rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
522 goto RETURN;
523 }
524 }
525 break;
526
527 case TOXAV_CALL_CONTROL_SHOW_VIDEO: {
528 if (call->msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) {
529 if (msi_change_capabilities(call->msi_call, call->
530 msi_call->self_capabilities | MSI_CAP_R_VIDEO) == -1) {
531 rc = TOXAV_ERR_CALL_CONTROL_SYNC;
532 goto RETURN;
533 }
534
535 rtp_allow_receiving(call->video_rtp);
536 } else {
537 rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
538 goto RETURN;
539 }
540 }
541 break;
542 }
543
544 RETURN:
545 pthread_mutex_unlock(av->mutex);
546
547 if (error) {
548 *error = rc;
549 }
550
551 return rc == TOXAV_ERR_CALL_CONTROL_OK;
552 }
toxav_audio_set_bit_rate(ToxAV * av,uint32_t friend_number,uint32_t audio_bit_rate,Toxav_Err_Bit_Rate_Set * error)553 bool toxav_audio_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate,
554 Toxav_Err_Bit_Rate_Set *error)
555 {
556 Toxav_Err_Bit_Rate_Set rc = TOXAV_ERR_BIT_RATE_SET_OK;
557 ToxAVCall *call;
558
559 if (m_friend_exists(av->m, friend_number) == 0) {
560 rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND;
561 goto RETURN;
562 }
563
564 if (audio_bit_rate > 0 && audio_bit_rate_invalid(audio_bit_rate)) {
565 rc = TOXAV_ERR_BIT_RATE_SET_INVALID_BIT_RATE;
566 goto RETURN;
567 }
568
569 pthread_mutex_lock(av->mutex);
570 call = call_get(av, friend_number);
571
572 if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
573 pthread_mutex_unlock(av->mutex);
574 rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL;
575 goto RETURN;
576 }
577
578 LOGGER_DEBUG(av->m->log, "Setting new audio bitrate to: %d", audio_bit_rate);
579
580 if (call->audio_bit_rate == audio_bit_rate) {
581 LOGGER_DEBUG(av->m->log, "Audio bitrate already set to: %d", audio_bit_rate);
582 } else if (audio_bit_rate == 0) {
583 LOGGER_DEBUG(av->m->log, "Turned off audio sending");
584
585 if (msi_change_capabilities(call->msi_call, call->msi_call->
586 self_capabilities ^ MSI_CAP_S_AUDIO) != 0) {
587 pthread_mutex_unlock(av->mutex);
588 rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
589 goto RETURN;
590 }
591
592 /* Audio sending is turned off; notify peer */
593 call->audio_bit_rate = 0;
594 } else {
595 pthread_mutex_lock(call->toxav_call_mutex);
596
597 if (call->audio_bit_rate == 0) {
598 LOGGER_DEBUG(av->m->log, "Turned on audio sending");
599
600 /* The audio has been turned off before this */
601 if (msi_change_capabilities(call->msi_call, call->
602 msi_call->self_capabilities | MSI_CAP_S_AUDIO) != 0) {
603 pthread_mutex_unlock(call->toxav_call_mutex);
604 pthread_mutex_unlock(av->mutex);
605 rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
606 goto RETURN;
607 }
608 } else {
609 LOGGER_DEBUG(av->m->log, "Set new audio bit rate %d", audio_bit_rate);
610 }
611
612 call->audio_bit_rate = audio_bit_rate;
613 pthread_mutex_unlock(call->toxav_call_mutex);
614 }
615
616 pthread_mutex_unlock(av->mutex);
617 RETURN:
618
619 if (error) {
620 *error = rc;
621 }
622
623 return rc == TOXAV_ERR_BIT_RATE_SET_OK;
624 }
toxav_video_set_bit_rate(ToxAV * av,uint32_t friend_number,uint32_t video_bit_rate,Toxav_Err_Bit_Rate_Set * error)625 bool toxav_video_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t video_bit_rate,
626 Toxav_Err_Bit_Rate_Set *error)
627 {
628 Toxav_Err_Bit_Rate_Set rc = TOXAV_ERR_BIT_RATE_SET_OK;
629 ToxAVCall *call;
630
631 if (m_friend_exists(av->m, friend_number) == 0) {
632 rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND;
633 goto RETURN;
634 }
635
636 if (video_bit_rate > 0 && video_bit_rate_invalid(video_bit_rate)) {
637 rc = TOXAV_ERR_BIT_RATE_SET_INVALID_BIT_RATE;
638 goto RETURN;
639 }
640
641 pthread_mutex_lock(av->mutex);
642 call = call_get(av, friend_number);
643
644 if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
645 pthread_mutex_unlock(av->mutex);
646 rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL;
647 goto RETURN;
648 }
649
650 LOGGER_DEBUG(av->m->log, "Setting new video bitrate to: %d", video_bit_rate);
651
652 if (call->video_bit_rate == video_bit_rate) {
653 LOGGER_DEBUG(av->m->log, "Video bitrate already set to: %d", video_bit_rate);
654 } else if (video_bit_rate == 0) {
655 LOGGER_DEBUG(av->m->log, "Turned off video sending");
656
657 /* Video sending is turned off; notify peer */
658 if (msi_change_capabilities(call->msi_call, call->msi_call->
659 self_capabilities ^ MSI_CAP_S_VIDEO) != 0) {
660 pthread_mutex_unlock(av->mutex);
661 rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
662 goto RETURN;
663 }
664
665 call->video_bit_rate = 0;
666 } else {
667 pthread_mutex_lock(call->toxav_call_mutex);
668
669 if (call->video_bit_rate == 0) {
670 LOGGER_DEBUG(av->m->log, "Turned on video sending");
671
672 /* The video has been turned off before this */
673 if (msi_change_capabilities(call->msi_call, call->
674 msi_call->self_capabilities | MSI_CAP_S_VIDEO) != 0) {
675 pthread_mutex_unlock(call->toxav_call_mutex);
676 pthread_mutex_unlock(av->mutex);
677 rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
678 goto RETURN;
679 }
680 } else {
681 LOGGER_DEBUG(av->m->log, "Set new video bit rate %d", video_bit_rate);
682 }
683
684 call->video_bit_rate = video_bit_rate;
685 pthread_mutex_unlock(call->toxav_call_mutex);
686 }
687
688 pthread_mutex_unlock(av->mutex);
689 RETURN:
690
691 if (error) {
692 *error = rc;
693 }
694
695 return rc == TOXAV_ERR_BIT_RATE_SET_OK;
696 }
toxav_callback_audio_bit_rate(ToxAV * av,toxav_audio_bit_rate_cb * callback,void * user_data)697 void toxav_callback_audio_bit_rate(ToxAV *av, toxav_audio_bit_rate_cb *callback, void *user_data)
698 {
699 pthread_mutex_lock(av->mutex);
700 av->abcb = callback;
701 av->abcb_user_data = user_data;
702 pthread_mutex_unlock(av->mutex);
703 }
toxav_callback_video_bit_rate(ToxAV * av,toxav_video_bit_rate_cb * callback,void * user_data)704 void toxav_callback_video_bit_rate(ToxAV *av, toxav_video_bit_rate_cb *callback, void *user_data)
705 {
706 pthread_mutex_lock(av->mutex);
707 av->vbcb = callback;
708 av->vbcb_user_data = user_data;
709 pthread_mutex_unlock(av->mutex);
710 }
toxav_audio_send_frame(ToxAV * av,uint32_t friend_number,const int16_t * pcm,size_t sample_count,uint8_t channels,uint32_t sampling_rate,Toxav_Err_Send_Frame * error)711 bool toxav_audio_send_frame(ToxAV *av, uint32_t friend_number, const int16_t *pcm, size_t sample_count,
712 uint8_t channels, uint32_t sampling_rate, Toxav_Err_Send_Frame *error)
713 {
714 Toxav_Err_Send_Frame rc = TOXAV_ERR_SEND_FRAME_OK;
715 ToxAVCall *call;
716
717 if (m_friend_exists(av->m, friend_number) == 0) {
718 rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND;
719 goto RETURN;
720 }
721
722 if (pthread_mutex_trylock(av->mutex) != 0) {
723 rc = TOXAV_ERR_SEND_FRAME_SYNC;
724 goto RETURN;
725 }
726
727 call = call_get(av, friend_number);
728
729 if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
730 pthread_mutex_unlock(av->mutex);
731 rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
732 goto RETURN;
733 }
734
735 if (call->audio_bit_rate == 0 ||
736 !(call->msi_call->self_capabilities & MSI_CAP_S_AUDIO) ||
737 !(call->msi_call->peer_capabilities & MSI_CAP_R_AUDIO)) {
738 pthread_mutex_unlock(av->mutex);
739 rc = TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED;
740 goto RETURN;
741 }
742
743 pthread_mutex_lock(call->mutex_audio);
744 pthread_mutex_unlock(av->mutex);
745
746 if (pcm == nullptr) {
747 pthread_mutex_unlock(call->mutex_audio);
748 rc = TOXAV_ERR_SEND_FRAME_NULL;
749 goto RETURN;
750 }
751
752 if (channels > 2) {
753 pthread_mutex_unlock(call->mutex_audio);
754 rc = TOXAV_ERR_SEND_FRAME_INVALID;
755 goto RETURN;
756 }
757
758 { /* Encode and send */
759 if (ac_reconfigure_encoder(call->audio, call->audio_bit_rate * 1000, sampling_rate, channels) != 0) {
760 pthread_mutex_unlock(call->mutex_audio);
761 rc = TOXAV_ERR_SEND_FRAME_INVALID;
762 goto RETURN;
763 }
764
765 VLA(uint8_t, dest, sample_count + sizeof(sampling_rate)); /* This is more than enough always */
766
767 sampling_rate = net_htonl(sampling_rate);
768 memcpy(dest, &sampling_rate, sizeof(sampling_rate));
769 int vrc = opus_encode(call->audio->encoder, pcm, sample_count,
770 dest + sizeof(sampling_rate), SIZEOF_VLA(dest) - sizeof(sampling_rate));
771
772 if (vrc < 0) {
773 LOGGER_WARNING(av->m->log, "Failed to encode frame %s", opus_strerror(vrc));
774 pthread_mutex_unlock(call->mutex_audio);
775 rc = TOXAV_ERR_SEND_FRAME_INVALID;
776 goto RETURN;
777 }
778
779 if (rtp_send_data(call->audio_rtp, dest, vrc + sizeof(sampling_rate), false, av->m->log) != 0) {
780 LOGGER_WARNING(av->m->log, "Failed to send audio packet");
781 rc = TOXAV_ERR_SEND_FRAME_RTP_FAILED;
782 }
783 }
784
785 pthread_mutex_unlock(call->mutex_audio);
786
787 RETURN:
788
789 if (error) {
790 *error = rc;
791 }
792
793 return rc == TOXAV_ERR_SEND_FRAME_OK;
794 }
795
send_frames(const Logger * log,ToxAVCall * call)796 static Toxav_Err_Send_Frame send_frames(const Logger *log, ToxAVCall *call)
797 {
798 vpx_codec_iter_t iter = nullptr;
799
800 for (const vpx_codec_cx_pkt_t *pkt = vpx_codec_get_cx_data(call->video->encoder, &iter);
801 pkt != nullptr;
802 pkt = vpx_codec_get_cx_data(call->video->encoder, &iter)) {
803 if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) {
804 continue;
805 }
806
807 const bool is_keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
808
809 // https://www.webmproject.org/docs/webm-sdk/structvpx__codec__cx__pkt.html
810 // pkt->data.frame.sz -> size_t
811 const uint32_t frame_length_in_bytes = pkt->data.frame.sz;
812
813 const int res = rtp_send_data(
814 call->video_rtp,
815 (const uint8_t *)pkt->data.frame.buf,
816 frame_length_in_bytes,
817 is_keyframe,
818 log);
819
820 LOGGER_DEBUG(log, "+ _sending_FRAME_TYPE_==%s bytes=%d frame_len=%d", is_keyframe ? "K" : ".",
821 (int)pkt->data.frame.sz, (int)frame_length_in_bytes);
822 const uint8_t *const buf = (const uint8_t *)pkt->data.frame.buf;
823 LOGGER_DEBUG(log, "+ _sending_FRAME_ b0=%d b1=%d", buf[0], buf[1]);
824
825 if (res < 0) {
826 LOGGER_WARNING(log, "Could not send video frame: %s", strerror(errno));
827 return TOXAV_ERR_SEND_FRAME_RTP_FAILED;
828 }
829 }
830
831 return TOXAV_ERR_SEND_FRAME_OK;
832 }
833
toxav_video_send_frame(ToxAV * av,uint32_t friend_number,uint16_t width,uint16_t height,const uint8_t * y,const uint8_t * u,const uint8_t * v,Toxav_Err_Send_Frame * error)834 bool toxav_video_send_frame(ToxAV *av, uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t *y,
835 const uint8_t *u, const uint8_t *v, Toxav_Err_Send_Frame *error)
836 {
837 Toxav_Err_Send_Frame rc = TOXAV_ERR_SEND_FRAME_OK;
838 ToxAVCall *call;
839
840 int vpx_encode_flags = 0;
841
842 if (m_friend_exists(av->m, friend_number) == 0) {
843 rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND;
844 goto RETURN;
845 }
846
847 if (pthread_mutex_trylock(av->mutex) != 0) {
848 rc = TOXAV_ERR_SEND_FRAME_SYNC;
849 goto RETURN;
850 }
851
852 call = call_get(av, friend_number);
853
854 if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
855 pthread_mutex_unlock(av->mutex);
856 rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
857 goto RETURN;
858 }
859
860 if (call->video_bit_rate == 0 ||
861 !(call->msi_call->self_capabilities & MSI_CAP_S_VIDEO) ||
862 !(call->msi_call->peer_capabilities & MSI_CAP_R_VIDEO)) {
863 pthread_mutex_unlock(av->mutex);
864 rc = TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED;
865 goto RETURN;
866 }
867
868 pthread_mutex_lock(call->mutex_video);
869 pthread_mutex_unlock(av->mutex);
870
871 if (y == nullptr || u == nullptr || v == nullptr) {
872 pthread_mutex_unlock(call->mutex_video);
873 rc = TOXAV_ERR_SEND_FRAME_NULL;
874 goto RETURN;
875 }
876
877 if (vc_reconfigure_encoder(call->video, call->video_bit_rate * 1000, width, height, -1) != 0) {
878 pthread_mutex_unlock(call->mutex_video);
879 rc = TOXAV_ERR_SEND_FRAME_INVALID;
880 goto RETURN;
881 }
882
883 if (call->video_rtp->ssrc < VIDEO_SEND_X_KEYFRAMES_FIRST) {
884 // Key frame flag for first frames
885 vpx_encode_flags = VPX_EFLAG_FORCE_KF;
886 LOGGER_INFO(av->m->log, "I_FRAME_FLAG:%d only-i-frame mode", call->video_rtp->ssrc);
887
888 ++call->video_rtp->ssrc;
889 } else if (call->video_rtp->ssrc == VIDEO_SEND_X_KEYFRAMES_FIRST) {
890 // normal keyframe placement
891 vpx_encode_flags = 0;
892 LOGGER_INFO(av->m->log, "I_FRAME_FLAG:%d normal mode", call->video_rtp->ssrc);
893
894 ++call->video_rtp->ssrc;
895 }
896
897 // we start with I-frames (full frames) and then switch to normal mode later
898
899 { /* Encode */
900 vpx_image_t img;
901 img.w = 0;
902 img.h = 0;
903 img.d_w = 0;
904 img.d_h = 0;
905 vpx_img_alloc(&img, VPX_IMG_FMT_I420, width, height, 0);
906
907 /* I420 "It comprises an NxM Y plane followed by (N/2)x(M/2) V and U planes."
908 * http://fourcc.org/yuv.php#IYUV
909 */
910 memcpy(img.planes[VPX_PLANE_Y], y, width * height);
911 memcpy(img.planes[VPX_PLANE_U], u, (width / 2) * (height / 2));
912 memcpy(img.planes[VPX_PLANE_V], v, (width / 2) * (height / 2));
913
914 vpx_codec_err_t vrc = vpx_codec_encode(call->video->encoder, &img,
915 call->video->frame_counter, 1, vpx_encode_flags, MAX_ENCODE_TIME_US);
916
917 vpx_img_free(&img);
918
919 if (vrc != VPX_CODEC_OK) {
920 pthread_mutex_unlock(call->mutex_video);
921 LOGGER_ERROR(av->m->log, "Could not encode video frame: %s", vpx_codec_err_to_string(vrc));
922 rc = TOXAV_ERR_SEND_FRAME_INVALID;
923 goto RETURN;
924 }
925 }
926
927 ++call->video->frame_counter;
928
929 rc = send_frames(av->m->log, call);
930
931 pthread_mutex_unlock(call->mutex_video);
932
933 RETURN:
934
935 if (error) {
936 *error = rc;
937 }
938
939 return rc == TOXAV_ERR_SEND_FRAME_OK;
940 }
941
toxav_callback_audio_receive_frame(ToxAV * av,toxav_audio_receive_frame_cb * callback,void * user_data)942 void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback, void *user_data)
943 {
944 pthread_mutex_lock(av->mutex);
945 av->acb = callback;
946 av->acb_user_data = user_data;
947 pthread_mutex_unlock(av->mutex);
948 }
949
toxav_callback_video_receive_frame(ToxAV * av,toxav_video_receive_frame_cb * callback,void * user_data)950 void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback, void *user_data)
951 {
952 pthread_mutex_lock(av->mutex);
953 av->vcb = callback;
954 av->vcb_user_data = user_data;
955 pthread_mutex_unlock(av->mutex);
956 }
957
958 /*******************************************************************************
959 *
960 * :: Internal
961 *
962 ******************************************************************************/
callback_bwc(BWController * bwc,uint32_t friend_number,float loss,void * user_data)963 static void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *user_data)
964 {
965 /* Callback which is called when the internal measure mechanism reported packet loss.
966 * We report suggested lowered bitrate to an app. If app is sending both audio and video,
967 * we will report lowered bitrate for video only because in that case video probably
968 * takes more than 90% bandwidth. Otherwise, we report lowered bitrate on audio.
969 * The application may choose to disable video totally if the stream is too bad.
970 */
971
972 ToxAVCall *call = (ToxAVCall *)user_data;
973 assert(call);
974
975 LOGGER_DEBUG(call->av->m->log, "Reported loss of %f%%", (double)loss * 100);
976
977 /* if less than 10% data loss we do nothing! */
978 if (loss < 0.1f) {
979 return;
980 }
981
982 pthread_mutex_lock(call->av->mutex);
983
984 if (call->video_bit_rate) {
985 if (!call->av->vbcb) {
986 pthread_mutex_unlock(call->av->mutex);
987 LOGGER_WARNING(call->av->m->log, "No callback to report loss on");
988 return;
989 }
990
991 call->av->vbcb(call->av, friend_number,
992 call->video_bit_rate - (call->video_bit_rate * loss),
993 call->av->vbcb_user_data);
994 } else if (call->audio_bit_rate) {
995 if (!call->av->abcb) {
996 pthread_mutex_unlock(call->av->mutex);
997 LOGGER_WARNING(call->av->m->log, "No callback to report loss on");
998 return;
999 }
1000
1001 call->av->abcb(call->av, friend_number,
1002 call->audio_bit_rate - (call->audio_bit_rate * loss),
1003 call->av->abcb_user_data);
1004 }
1005
1006 pthread_mutex_unlock(call->av->mutex);
1007 }
callback_invite(void * toxav_inst,MSICall * call)1008 static int callback_invite(void *toxav_inst, MSICall *call)
1009 {
1010 ToxAV *toxav = (ToxAV *)toxav_inst;
1011 pthread_mutex_lock(toxav->mutex);
1012
1013 ToxAVCall *av_call = call_new(toxav, call->friend_number, nullptr);
1014
1015 if (av_call == nullptr) {
1016 LOGGER_WARNING(toxav->m->log, "Failed to initialize call...");
1017 pthread_mutex_unlock(toxav->mutex);
1018 return -1;
1019 }
1020
1021 call->av_call = av_call;
1022 av_call->msi_call = call;
1023
1024 if (toxav->ccb) {
1025 toxav->ccb(toxav, call->friend_number, call->peer_capabilities & MSI_CAP_S_AUDIO,
1026 call->peer_capabilities & MSI_CAP_S_VIDEO, toxav->ccb_user_data);
1027 } else {
1028 /* No handler to capture the call request, send failure */
1029 pthread_mutex_unlock(toxav->mutex);
1030 return -1;
1031 }
1032
1033 pthread_mutex_unlock(toxav->mutex);
1034 return 0;
1035 }
callback_start(void * toxav_inst,MSICall * call)1036 static int callback_start(void *toxav_inst, MSICall *call)
1037 {
1038 ToxAV *toxav = (ToxAV *)toxav_inst;
1039 pthread_mutex_lock(toxav->mutex);
1040
1041 ToxAVCall *av_call = call_get(toxav, call->friend_number);
1042
1043 if (av_call == nullptr) {
1044 /* Should this ever happen? */
1045 pthread_mutex_unlock(toxav->mutex);
1046 return -1;
1047 }
1048
1049 if (!call_prepare_transmission(av_call)) {
1050 callback_error(toxav_inst, call);
1051 pthread_mutex_unlock(toxav->mutex);
1052 return -1;
1053 }
1054
1055 if (!invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities)) {
1056 callback_error(toxav_inst, call);
1057 pthread_mutex_unlock(toxav->mutex);
1058 return -1;
1059 }
1060
1061 pthread_mutex_unlock(toxav->mutex);
1062 return 0;
1063 }
callback_end(void * toxav_inst,MSICall * call)1064 static int callback_end(void *toxav_inst, MSICall *call)
1065 {
1066 ToxAV *toxav = (ToxAV *)toxav_inst;
1067 pthread_mutex_lock(toxav->mutex);
1068
1069 invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED);
1070
1071 if (call->av_call) {
1072 call_kill_transmission(call->av_call);
1073 call_remove(call->av_call);
1074 }
1075
1076 pthread_mutex_unlock(toxav->mutex);
1077 return 0;
1078 }
callback_error(void * toxav_inst,MSICall * call)1079 static int callback_error(void *toxav_inst, MSICall *call)
1080 {
1081 ToxAV *toxav = (ToxAV *)toxav_inst;
1082 pthread_mutex_lock(toxav->mutex);
1083
1084 invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR);
1085
1086 if (call->av_call) {
1087 call_kill_transmission(call->av_call);
1088 call_remove(call->av_call);
1089 }
1090
1091 pthread_mutex_unlock(toxav->mutex);
1092 return 0;
1093 }
callback_capabilites(void * toxav_inst,MSICall * call)1094 static int callback_capabilites(void *toxav_inst, MSICall *call)
1095 {
1096 ToxAV *toxav = (ToxAV *)toxav_inst;
1097 pthread_mutex_lock(toxav->mutex);
1098
1099 if (call->peer_capabilities & MSI_CAP_S_AUDIO) {
1100 rtp_allow_receiving(call->av_call->audio_rtp);
1101 } else {
1102 rtp_stop_receiving(call->av_call->audio_rtp);
1103 }
1104
1105 if (call->peer_capabilities & MSI_CAP_S_VIDEO) {
1106 rtp_allow_receiving(call->av_call->video_rtp);
1107 } else {
1108 rtp_stop_receiving(call->av_call->video_rtp);
1109 }
1110
1111 invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities);
1112
1113 pthread_mutex_unlock(toxav->mutex);
1114 return 0;
1115 }
audio_bit_rate_invalid(uint32_t bit_rate)1116 static bool audio_bit_rate_invalid(uint32_t bit_rate)
1117 {
1118 /* Opus RFC 6716 section-2.1.1 dictates the following:
1119 * Opus supports all bit rates from 6 kbit/s to 510 kbit/s.
1120 */
1121 return bit_rate < 6 || bit_rate > 510;
1122 }
video_bit_rate_invalid(uint32_t bit_rate)1123 static bool video_bit_rate_invalid(uint32_t bit_rate)
1124 {
1125 /* https://www.webmproject.org/docs/webm-sdk/structvpx__codec__enc__cfg.html shows the following:
1126 * unsigned int rc_target_bitrate
1127 * the range of uint varies from platform to platform
1128 * though, uint32_t should be large enough to store bitrates,
1129 * we may want to prevent from passing overflowed bitrates to libvpx
1130 * more in detail, it's the case where bit_rate is larger than uint, but smaller than uint32_t
1131 */
1132 return bit_rate > UINT_MAX;
1133 }
invoke_call_state_callback(ToxAV * av,uint32_t friend_number,uint32_t state)1134 static bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state)
1135 {
1136 if (av->scb) {
1137 av->scb(av, friend_number, state, av->scb_user_data);
1138 } else {
1139 return false;
1140 }
1141
1142 return true;
1143 }
1144
call_new(ToxAV * av,uint32_t friend_number,Toxav_Err_Call * error)1145 static ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, Toxav_Err_Call *error)
1146 {
1147 /* Assumes mutex locked */
1148 Toxav_Err_Call rc = TOXAV_ERR_CALL_OK;
1149 ToxAVCall *call = nullptr;
1150
1151 if (m_friend_exists(av->m, friend_number) == 0) {
1152 rc = TOXAV_ERR_CALL_FRIEND_NOT_FOUND;
1153 goto RETURN;
1154 }
1155
1156 if (m_get_friend_connectionstatus(av->m, friend_number) < 1) {
1157 rc = TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED;
1158 goto RETURN;
1159 }
1160
1161 if (call_get(av, friend_number) != nullptr) {
1162 rc = TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL;
1163 goto RETURN;
1164 }
1165
1166 call = (ToxAVCall *)calloc(sizeof(ToxAVCall), 1);
1167
1168 if (call == nullptr) {
1169 rc = TOXAV_ERR_CALL_MALLOC;
1170 goto RETURN;
1171 }
1172
1173 call->av = av;
1174 call->friend_number = friend_number;
1175
1176 if (create_recursive_mutex(call->toxav_call_mutex)) {
1177 free(call);
1178 call = nullptr;
1179 rc = TOXAV_ERR_CALL_MALLOC;
1180 goto RETURN;
1181 }
1182
1183 if (av->calls == nullptr) { /* Creating */
1184 av->calls = (ToxAVCall **)calloc(sizeof(ToxAVCall *), friend_number + 1);
1185
1186 if (av->calls == nullptr) {
1187 pthread_mutex_destroy(call->toxav_call_mutex);
1188 free(call);
1189 call = nullptr;
1190 rc = TOXAV_ERR_CALL_MALLOC;
1191 goto RETURN;
1192 }
1193
1194 av->calls_tail = friend_number;
1195 av->calls_head = friend_number;
1196 } else if (av->calls_tail < friend_number) { /* Appending */
1197 ToxAVCall **tmp = (ToxAVCall **)realloc(av->calls, sizeof(ToxAVCall *) * (friend_number + 1));
1198
1199 if (tmp == nullptr) {
1200 pthread_mutex_destroy(call->toxav_call_mutex);
1201 free(call);
1202 call = nullptr;
1203 rc = TOXAV_ERR_CALL_MALLOC;
1204 goto RETURN;
1205 }
1206
1207 av->calls = tmp;
1208
1209 /* Set fields in between to null */
1210 for (uint32_t i = av->calls_tail + 1; i < friend_number; ++i) {
1211 av->calls[i] = nullptr;
1212 }
1213
1214 call->prev = av->calls[av->calls_tail];
1215 av->calls[av->calls_tail]->next = call;
1216
1217 av->calls_tail = friend_number;
1218 } else if (av->calls_head > friend_number) { /* Inserting at front */
1219 call->next = av->calls[av->calls_head];
1220 av->calls[av->calls_head]->prev = call;
1221 av->calls_head = friend_number;
1222 }
1223
1224 av->calls[friend_number] = call;
1225
1226 RETURN:
1227
1228 if (error) {
1229 *error = rc;
1230 }
1231
1232 return call;
1233 }
1234
call_get(ToxAV * av,uint32_t friend_number)1235 static ToxAVCall *call_get(ToxAV *av, uint32_t friend_number)
1236 {
1237 /* Assumes mutex locked */
1238 if (av->calls == nullptr || av->calls_tail < friend_number) {
1239 return nullptr;
1240 }
1241
1242 return av->calls[friend_number];
1243 }
1244
call_remove(ToxAVCall * call)1245 static ToxAVCall *call_remove(ToxAVCall *call)
1246 {
1247 if (call == nullptr) {
1248 return nullptr;
1249 }
1250
1251 uint32_t friend_number = call->friend_number;
1252 ToxAV *av = call->av;
1253
1254 ToxAVCall *prev = call->prev;
1255 ToxAVCall *next = call->next;
1256
1257 /* Set av call in msi to NULL in order to know if call if ToxAVCall is
1258 * removed from the msi call.
1259 */
1260 if (call->msi_call) {
1261 call->msi_call->av_call = nullptr;
1262 }
1263
1264 pthread_mutex_destroy(call->toxav_call_mutex);
1265 free(call);
1266
1267 if (prev) {
1268 prev->next = next;
1269 } else if (next) {
1270 av->calls_head = next->friend_number;
1271 } else {
1272 goto CLEAR;
1273 }
1274
1275 if (next) {
1276 next->prev = prev;
1277 } else if (prev) {
1278 av->calls_tail = prev->friend_number;
1279 } else {
1280 goto CLEAR;
1281 }
1282
1283 av->calls[friend_number] = nullptr;
1284 return next;
1285
1286 CLEAR:
1287 av->calls_head = 0;
1288 av->calls_tail = 0;
1289 free(av->calls);
1290 av->calls = nullptr;
1291
1292 return nullptr;
1293 }
1294
call_prepare_transmission(ToxAVCall * call)1295 static bool call_prepare_transmission(ToxAVCall *call)
1296 {
1297 /* Assumes mutex locked */
1298
1299 if (call == nullptr) {
1300 return false;
1301 }
1302
1303 ToxAV *av = call->av;
1304
1305 if (av->acb == nullptr && av->vcb == nullptr) {
1306 /* It makes no sense to have CSession without callbacks */
1307 return false;
1308 }
1309
1310 if (call->active) {
1311 LOGGER_WARNING(av->m->log, "Call already active!");
1312 return true;
1313 }
1314
1315 if (create_recursive_mutex(call->mutex_audio) != 0) {
1316 return false;
1317 }
1318
1319 if (create_recursive_mutex(call->mutex_video) != 0) {
1320 goto FAILURE_2;
1321 }
1322
1323 /* Prepare bwc */
1324 call->bwc = bwc_new(av->m, av->tox, call->friend_number, callback_bwc, call, av->toxav_mono_time);
1325
1326 if (call->bwc == nullptr) {
1327 LOGGER_ERROR(av->m->log, "Failed to create new bwc");
1328 goto FAILURE;
1329 }
1330
1331 { /* Prepare audio */
1332 call->audio = ac_new(av->toxav_mono_time, av->m->log, av, call->friend_number, av->acb, av->acb_user_data);
1333
1334 if (call->audio == nullptr) {
1335 LOGGER_ERROR(av->m->log, "Failed to create audio codec session");
1336 goto FAILURE;
1337 }
1338
1339 call->audio_rtp = rtp_new(RTP_TYPE_AUDIO, av->m, av->tox, call->friend_number, call->bwc,
1340 call->audio, ac_queue_message);
1341
1342 if (call->audio_rtp == nullptr) {
1343 LOGGER_ERROR(av->m->log, "Failed to create audio rtp session");
1344 goto FAILURE;
1345 }
1346 }
1347
1348 { /* Prepare video */
1349 call->video = vc_new(av->toxav_mono_time, av->m->log, av, call->friend_number, av->vcb, av->vcb_user_data);
1350
1351 if (call->video == nullptr) {
1352 LOGGER_ERROR(av->m->log, "Failed to create video codec session");
1353 goto FAILURE;
1354 }
1355
1356 call->video_rtp = rtp_new(RTP_TYPE_VIDEO, av->m, av->tox, call->friend_number, call->bwc,
1357 call->video, vc_queue_message);
1358
1359 if (call->video_rtp == nullptr) {
1360 LOGGER_ERROR(av->m->log, "Failed to create video rtp session");
1361 goto FAILURE;
1362 }
1363 }
1364
1365 call->active = 1;
1366 return true;
1367
1368 FAILURE:
1369 bwc_kill(call->bwc);
1370 rtp_kill(call->audio_rtp);
1371 ac_kill(call->audio);
1372 call->audio_rtp = nullptr;
1373 call->audio = nullptr;
1374 rtp_kill(call->video_rtp);
1375 vc_kill(call->video);
1376 call->video_rtp = nullptr;
1377 call->video = nullptr;
1378 pthread_mutex_destroy(call->mutex_video);
1379 FAILURE_2:
1380 pthread_mutex_destroy(call->mutex_audio);
1381 return false;
1382 }
1383
call_kill_transmission(ToxAVCall * call)1384 static void call_kill_transmission(ToxAVCall *call)
1385 {
1386 if (call == nullptr || call->active == 0) {
1387 return;
1388 }
1389
1390 call->active = 0;
1391
1392 pthread_mutex_lock(call->mutex_audio);
1393 pthread_mutex_unlock(call->mutex_audio);
1394 pthread_mutex_lock(call->mutex_video);
1395 pthread_mutex_unlock(call->mutex_video);
1396 pthread_mutex_lock(call->toxav_call_mutex);
1397 pthread_mutex_unlock(call->toxav_call_mutex);
1398
1399 bwc_kill(call->bwc);
1400
1401 rtp_kill(call->audio_rtp);
1402 ac_kill(call->audio);
1403 call->audio_rtp = nullptr;
1404 call->audio = nullptr;
1405
1406 rtp_kill(call->video_rtp);
1407 vc_kill(call->video);
1408 call->video_rtp = nullptr;
1409 call->video = nullptr;
1410
1411 pthread_mutex_destroy(call->mutex_audio);
1412 pthread_mutex_destroy(call->mutex_video);
1413 }
1414