Skip to content
GitLab
Select Git revision
  • v1.14.0-linphone default
  • v1.12.0-linphone
  • v1.9.0-linphone
  • v1.7.0-linphone
  • feature/update_to_v1.9.0-linphone
  • feature/uwp_nuget
  • m68-3440
  • m66-3359
  • sandbox/luoyi@google.com/convolve
  • mandarinduck
  • sandbox/wangch@google.com/vp9
  • v1.6.1_linphone
  • linphone-android
  • longtailedduck
  • m56-2924
  • nextgenv2
  • m54-2840
  • sandbox/yaowu@google.com/mergeaom
  • khakicampbell
  • m52-2743
  • v1.9.0
  • v1.9.0-rc1
  • v1.8.2
  • v1.8.1
  • v1.8.0
  • v1.7.0
  • v1.6.1
  • v1.6.0
  • v1.5.0
  • v1.4.0
  • v1.3.0
  • v1.2.0
  • v1.1.0
  • v1.0.0
  • v0.9.7-p1
  • v0.9.7
  • v0.9.6
  • v0.9.5
  • v0.9.2
  • v0.9.1
Find file BlameHistoryPermalink
  • Paul Wilkins's avatar
    Merge CONFIGURE_SEGMENTATION experiment. · 3cdfdb55
    Paul Wilkins authored 
    Removal of CONFIGURE_SEGMENTATION ifdefs.

Removal of legacy support code fo the old coding mechanism.

Use local reference "xd" for MACROBLOCKD structure in
encode_frame_to_data_rate()

Moved call to choose_segmap_coding_method() out of encode
loop as the cost of segmentation is not properly accounted
in the loop anyway. If this is desirable in the future it
can be moved back. The use of this function to do all the
analysis and set the probabilities also removes the need
to track segment useage in threading code.

Change-Id: I85bc8fd63440e7176c73d26cb742698f9b70cade
    3cdfdb55
alerts_tester.cpp 12.33 KiB
1 
/*
2 
 * Copyright (c) 2010-2023 Belledonne Communications SARL.
3 
 *
4 
 * This file is part of Liblinphone
5 
 * (see https://gitlab.linphone.org/BC/public/liblinphone).
6 
 *
7 
 * This program is free software: you can redistribute it and/or modify
8 
 * it under the terms of the GNU Affero General Public License as
9 
 * published by the Free Software Foundation, either version 3 of the
10 
 * License, or (at your option) any later version.
11 
 *
12 
 * This program is distributed in the hope that it will be useful,
13 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 
 * GNU Affero General Public License for more details.
16 
 *
17 
 * You should have received a copy of the GNU Affero General Public License
18 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 
 */
20
21 
#include "alert/alert.h"
22 
#include "call/call.h"
23 
#include "liblinphone_tester.h"
24 
#include "linphone/api/c-alert.h"
25 
#include "linphone/api/c-signal-information.h"
26 
#include "linphone/core.h"
27 
#include "shared_tester_functions.h"
28 
#include "signal-information/signal-information.h"
29 
#include "tester_utils.h"
30
31 
// =============================================================================
32
33 
using namespace std;
34
35 
using namespace LinphonePrivate;
36 
struct AlertCallbackData {
37
38 
	bool marieEnabled;
39 
	bool paulineEnabled;
40 
	LinphoneAlertType expectedType;
41 
	bool networkReachable = true;
42 
	bool camera_dysfunction = false;
43 
	int triggerCount = 0;
44 
	int stopped = 0;
45 
	int nack = false;
46 
};
47
48 
static void enable_video_stream(LinphoneCore *lc, LinphoneVideoActivationPolicy *policy, const char *name) {
49 
	disable_all_video_codecs_except_one(lc, "VP8");
50
51 
	linphone_core_set_video_device(lc, "Mire: Mire (synthetic moving picture)");
52 
	linphone_core_enable_video_capture(lc, TRUE);
53 
	linphone_core_enable_video_display(lc, TRUE);
54 
	linphone_core_set_video_activation_policy(lc, policy);
55 
	// linphone_core_set_video_preset(lc, "custom");
56 
	linphone_core_set_preferred_video_definition_by_name(lc, name);
57 
}
58 
static void alert_on_terminated(LinphoneAlert *alert) {
59
60 
	BC_ASSERT_PTR_NOT_NULL(alert);
61 
	LinphoneAlertCbs *cbs = linphone_alert_get_current_callbacks(alert);
62 
	AlertCallbackData *data = (AlertCallbackData *)linphone_alert_cbs_get_user_data(cbs);
63 
	auto type = linphone_alert_get_type(alert);
64 
	if (type == data->expectedType) {
65 
		data->stopped++;
66 
	}
67 
}
68 
static void alert_catch(LinphoneCore *core, LinphoneAlert *alert) {
69
70 
	BC_ASSERT_PTR_NOT_NULL(alert);
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
auto *data = (AlertCallbackData *)linphone_core_cbs_get_user_data(linphone_core_get_current_callbacks(core)); LinphoneAlertCbs *alert_cbs = linphone_factory_create_alert_cbs(linphone_factory_get()); auto type = linphone_alert_get_type(alert); if (type == data->expectedType) { data->triggerCount++; } linphone_alert_cbs_set_terminated(alert_cbs, alert_on_terminated); linphone_alert_add_callbacks(alert, alert_cbs); linphone_alert_cbs_set_user_data(alert_cbs, data); linphone_alert_cbs_unref(alert_cbs); } static void alert_call_base(OrtpNetworkSimulatorParams &networkParams, AlertCallbackData data) { LinphoneCoreManager *marie; LinphoneCoreManager *pauline; marie = linphone_core_manager_new("marie_rc"); pauline = linphone_core_manager_new("pauline_rc"); LinphoneCoreCbs *cbs = linphone_factory_create_core_cbs(linphone_factory_get()); linphone_core_cbs_set_new_alert_triggered(cbs, alert_catch); linphone_core_add_callbacks(marie->lc, cbs); linphone_core_cbs_set_user_data(cbs, &data); linphone_core_cbs_unref(cbs); linphone_core_enable_alerts(marie->lc, data.marieEnabled); linphone_core_enable_alerts(pauline->lc, data.paulineEnabled); linphone_core_set_network_reachable(marie->lc, data.networkReachable); LinphoneVideoActivationPolicy *pol = linphone_factory_create_video_activation_policy(linphone_factory_get()); linphone_video_activation_policy_set_automatically_accept(pol, TRUE); linphone_video_activation_policy_set_automatically_initiate(pol, TRUE); enable_video_stream(marie->lc, pol, "qvga"); enable_video_stream(pauline->lc, pol, "qvga"); linphone_video_activation_policy_unref(pol); if (data.nack) { linphone_core_set_avpf_mode(marie->lc, LinphoneAVPFEnabled); linphone_core_set_avpf_mode(pauline->lc, LinphoneAVPFEnabled); linphone_config_set_int(linphone_core_get_config(marie->lc), "rtp", "rtcp_fb_generic_nack_enabled", 1); linphone_config_set_int(linphone_core_get_config(pauline->lc), "rtp", "rtcp_fb_generic_nack_enabled", 1); linphone_core_enable_retransmission_on_nack(marie->lc, TRUE); linphone_core_enable_retransmission_on_nack(pauline->lc, TRUE); } if (data.expectedType == LinphoneAlertQoSLowSignal) { auto core = std::shared_ptr<Core>(L_GET_CPP_PTR_FROM_C_OBJECT(marie->lc)); auto info = (new SignalInformation(LinphoneSignalTypeWifi, LinphoneSignalStrengthUnitRssi, -80.0f))->toSharedPtr(); core->setSignalInformation(info); } /* Always use Outbound mode because it has real-time performance required for bandwidth estimations.*/ networkParams.mode = OrtpNetworkSimulatorOutbound; linphone_core_set_network_simulator_params(marie->lc, &networkParams); linphone_core_set_network_simulator_params(pauline->lc, &networkParams); BC_ASSERT_TRUE(call(marie, pauline)); if (data.camera_dysfunction) { float fps = (data.expectedType == LinphoneAlertQoSCameraMisfunction) ? 0.f : 5.f; VideoStream *marieVs = (VideoStream *)linphone_call_get_stream(linphone_core_get_current_call(marie->lc), LinphoneStreamTypeVideo); liblinphone_tester_simulate_mire_defunct(marieVs->source, TRUE, fps); } BC_ASSERT_TRUE(wait_for_until(marie->lc, marie->lc, &data.triggerCount, 1, 10000)); networkParams.enabled = FALSE; linphone_core_set_network_simulator_params(marie->lc, &networkParams); linphone_core_set_network_simulator_params(pauline->lc, &networkParams); linphone_core_set_preferred_video_definition_by_name(marie->lc, "svga"); linphone_core_set_preferred_video_definition_by_name(pauline->lc, "svga"); linphone_core_set_network_reachable(marie->lc, TRUE);
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
linphone_call_update(linphone_core_get_current_call(marie->lc), NULL); linphone_call_update(linphone_core_get_current_call(pauline->lc), NULL); if (data.expectedType == LinphoneAlertQoSLowSignal) { auto core = std::shared_ptr<Core>(L_GET_CPP_PTR_FROM_C_OBJECT(marie->lc)); core->setSignalInformation(nullptr); } // TODO : remove this if to make this assert true if (data.expectedType != LinphoneAlertQoSBurstOccured && data.expectedType != LinphoneAlertQoSCameraLowFramerate && data.expectedType != LinphoneAlertQoSLowQualitySentVideo) { /* the new bandwidth estimate might take up to 10 seconds to happen*/ BC_ASSERT_TRUE(wait_for_until(marie->lc, marie->lc, &data.stopped, 1, 15000)); } end_call(marie, pauline); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); } static void high_loss_rate_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.loss_rate = 25.; AlertCallbackData data = {true, true, LinphoneAlertQoSHighLossLateRate}; alert_call_base(network_params, data); } void low_video_bandwidth_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.max_bandwidth = 150000; AlertCallbackData data = {true, true, LinphoneAlertQoSLowQualityReceivedVideo}; alert_call_base(network_params, data); } void low_bandwidth_estimation_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.max_bandwidth = 120000; AlertCallbackData data = {true, true, LinphoneAlertQoSLowDownloadBandwidthEstimation}; alert_call_base(network_params, data); } static void remote_loss_rate_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.loss_rate = 15.; AlertCallbackData data = {true, false, LinphoneAlertQoSHighRemoteLossRate}; alert_call_base(network_params, data); } static void lost_signal_test(void) { OrtpNetworkSimulatorParams network_params = {0}; AlertCallbackData data = {true, false, LinphoneAlertQoSLostSignal, 0, false}; alert_call_base(network_params, data); } static void low_definition_video_sent_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.max_buffer_size = 100000; network_params.max_bandwidth = 100000; network_params.enabled = TRUE; AlertCallbackData data = {true, false, LinphoneAlertQoSLowQualitySentVideo, true}; alert_call_base(network_params, data); } static void camera_low_framerate_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.loss_rate = 0.; AlertCallbackData data = {true, true, LinphoneAlertQoSCameraLowFramerate, true, true}; alert_call_base(network_params, data);
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
} static void camera_misfunction_test(void) { OrtpNetworkSimulatorParams network_params = {0}; AlertCallbackData data = {true, false, LinphoneAlertQoSCameraMisfunction, true, true}; alert_call_base(network_params, data); } static void burst_occured_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.consecutive_loss_probability = 0.9f; network_params.loss_rate = 15.; AlertCallbackData data = {true, false, LinphoneAlertQoSBurstOccured}; alert_call_base(network_params, data); } static void video_stalled_test(void) { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = TRUE; network_params.loss_rate = 50.; AlertCallbackData data = {true, false, LinphoneAlertQoSVideoStalled}; alert_call_base(network_params, data); } static void signal_information_test() { LinphoneCoreManager *marie; marie = linphone_core_manager_new("marie_rc"); auto core = std::shared_ptr<Core>(L_GET_CPP_PTR_FROM_C_OBJECT(marie->lc)); auto signalInformation = core->getSignalInformation(); BC_ASSERT_PTR_NULL(signalInformation); auto info = (new SignalInformation(LinphoneSignalTypeMobile, LinphoneSignalStrengthUnitDbm, 25.3f))->toSharedPtr(); core->setSignalInformation(info); signalInformation = core->getSignalInformation(); BC_ASSERT_PTR_NOT_NULL(signalInformation); linphone_core_manager_destroy(marie); } static void signal_update_test(void) { LinphoneCoreManager *marie; marie = linphone_core_manager_new("marie_rc"); auto core = std::shared_ptr<Core>(L_GET_CPP_PTR_FROM_C_OBJECT(marie->lc)); auto signalInformation = core->getSignalInformation(); BC_ASSERT_PTR_NULL(signalInformation); auto info = (new SignalInformation(LinphoneSignalTypeWifi, LinphoneSignalStrengthUnitRssi, -70.0f))->toSharedPtr(); core->setSignalInformation(info); auto expected = core->getSignalInformation(); BC_ASSERT_PTR_NOT_NULL(expected); if (expected != NULL) { BC_ASSERT_EQUAL(expected->getStrength(), -70.0f, float, "%f"); } // Update info = (new SignalInformation(LinphoneSignalTypeWifi, LinphoneSignalStrengthUnitRssi, -80.0f))->toSharedPtr(); core->setSignalInformation(info); expected = core->getSignalInformation(); BC_ASSERT_PTR_NOT_NULL(expected); if (expected != NULL) { BC_ASSERT_EQUAL(expected->getStrength(), -80.0f, float, "%f"); } linphone_core_manager_destroy(marie); } static void low_signal_test() { OrtpNetworkSimulatorParams network_params = {0}; network_params.enabled = FALSE; AlertCallbackData data = {true, false, LinphoneAlertQoSLowSignal}; alert_call_base(network_params, data); } test_t alerts_tests[] = { TEST_NO_TAG("High loss rate", high_loss_rate_test), TEST_NO_TAG("Low video bandwidth", low_video_bandwidth_test), TEST_NO_TAG("Low bandwidth estimation", low_bandwidth_estimation_test),
281282283284285286287288289290291292293294295296297298299300301
TEST_NO_TAG("Remote loss rate", remote_loss_rate_test), TEST_NO_TAG("Lost signal", lost_signal_test), TEST_NO_TAG("Low definition sent", low_definition_video_sent_test), TEST_NO_TAG("Camera low framerate", camera_low_framerate_test), TEST_NO_TAG("Camera misfunction", camera_misfunction_test), TEST_NO_TAG("Burst occured", burst_occured_test), TEST_NO_TAG("Video stalled", video_stalled_test), TEST_NO_TAG("Signal informations", signal_information_test), TEST_NO_TAG("Signal update", signal_update_test), TEST_NO_TAG("Low signal", low_signal_test), }; test_suite_t alerts_test_suite = {"Alerts", NULL, NULL, liblinphone_tester_before_each, liblinphone_tester_after_each, sizeof(alerts_tests) / sizeof(alerts_tests[0]), alerts_tests};