/********************************** Tests are starting now ********************/
static void packet_duplication() {
const rtp_stats_t *stats;
double dup_ratio;
stream_manager_t * marielle, * margaux;
dup_ratio = 0;
start_adaptive_stream(MSAudio, &marielle, &margaux, SPEEX_PAYLOAD_TYPE, 32000, 0, 0, 50,dup_ratio);
media_stream_enable_adaptive_bitrate_control(&marielle->audio_stream->ms,FALSE);
iterate_adaptive_stream(marielle, margaux, 10000, NULL, 0);
stats=rtp_session_get_stats(margaux->video_stream->ms.sessions.rtp_session);
CU_ASSERT_EQUAL(stats->packet_dup_recv, dup_ratio ? stats->packet_recv / (dup_ratio+1) : 0);
/*in theory, cumulative loss should be the invert of duplicated count, but
since cumulative loss is computed only on received RTCP report and duplicated
count is updated on each RTP packet received, we cannot accurately compare these values*/
CU_ASSERT_TRUE(stats->cum_packet_loss <= -.5*stats->packet_dup_recv);
stop_adaptive_stream(marielle,margaux);
dup_ratio = 1;
start_adaptive_stream(MSAudio, &marielle, &margaux, SPEEX_PAYLOAD_TYPE, 32000, 0, 0, 50,dup_ratio);
media_stream_enable_adaptive_bitrate_control(&marielle->audio_stream->ms,FALSE);
iterate_adaptive_stream(marielle, margaux, 10000, NULL, 0);
stats=rtp_session_get_stats(margaux->video_stream->ms.sessions.rtp_session);
CU_ASSERT_EQUAL(stats->packet_dup_recv, dup_ratio ? stats->packet_recv / (dup_ratio+1) : 0);
CU_ASSERT_TRUE(stats->cum_packet_loss <= -.5*stats->packet_dup_recv);
stop_adaptive_stream(marielle,margaux);
}
static float adaptive_audio_stream(int codec_payload, int initial_bitrate,int target_bw, int max_recv_rtcp_packet) {
stream_manager_t * marielle = stream_manager_new();
stream_manager_t * margaux = stream_manager_new();
int pause_time=0;
OrtpNetworkSimulatorParams params={0};
params.enabled=TRUE;
params.loss_rate=0;
params.max_bandwidth=target_bw;
params.max_buffer_size=initial_bitrate;
float bw_usage_ratio;
float marielle_send_bw;
media_stream_enable_adaptive_bitrate_control(&marielle->stream->ms,TRUE);
stream_manager_start(marielle,codec_payload, margaux->local_rtp,initial_bitrate,HELLO_16K_1S_FILE,NULL);
ms_filter_call_method(marielle->stream->soundread,MS_FILE_PLAYER_LOOP,&pause_time);
stream_manager_start(margaux,codec_payload, marielle->local_rtp,-1,NULL,RECORDED_16K_1S_FILE);
rtp_session_enable_network_simulation(margaux->stream->ms.sessions.rtp_session,¶ms);
wait_for_until(&marielle->stream->ms,&margaux->stream->ms,&marielle->stats.number_of_EndOfFile,10,2500*max_recv_rtcp_packet);
marielle_send_bw=media_stream_get_up_bw(&marielle->stream->ms);
bw_usage_ratio=marielle_send_bw/params.max_bandwidth;
ms_message("marielle sent bw=[%f], target was [%f] bw_usage_ratio [%f]",marielle_send_bw,params.max_bandwidth,bw_usage_ratio);
stream_manager_delete(marielle);
stream_manager_delete(margaux);
unlink(RECORDED_16K_1S_FILE);
return bw_usage_ratio;
}
static void start_adaptive_stream(StreamType type, stream_manager_t ** pmarielle, stream_manager_t ** pmargaux,
int payload, int initial_bitrate, int target_bw, float loss_rate, int latency, float dup_ratio) {
OrtpNetworkSimulatorParams params={0};
params.enabled=TRUE;
params.loss_rate=loss_rate;
params.max_bandwidth=target_bw;
params.latency=latency;
int pause_time=0;
MediaStream *marielle_ms,*margaux_ms;
#if VIDEO_ENABLED
MSWebCam * marielle_webcam=ms_web_cam_manager_get_default_cam (ms_web_cam_manager_get());
#endif
stream_manager_t *marielle=*pmarielle=stream_manager_new(type);
stream_manager_t *margaux=*pmargaux=stream_manager_new(type);
if (type == AudioStreamType){
marielle_ms=&marielle->audio_stream->ms;
margaux_ms=&margaux->audio_stream->ms;
}else{
marielle_ms=&marielle->video_stream->ms;
margaux_ms=&margaux->video_stream->ms;
}
/* Disable avpf. */
PayloadType* pt = rtp_profile_get_payload(&rtp_profile, VP8_PAYLOAD_TYPE);
CU_ASSERT_PTR_NOT_NULL_FATAL(pt);
payload_type_unset_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
media_stream_enable_adaptive_bitrate_control(marielle_ms,TRUE);
rtp_session_set_duplication_ratio(marielle_ms->sessions.rtp_session, dup_ratio);
if (marielle->type == AudioStreamType){
audio_manager_start(marielle,payload,margaux->local_rtp,initial_bitrate,HELLO_16K_1S_FILE,NULL);
ms_filter_call_method(marielle->audio_stream->soundread,MS_FILE_PLAYER_LOOP,&pause_time);
audio_manager_start(margaux,payload,marielle->local_rtp,0,NULL,RECORDED_16K_1S_FILE);
}else{
#if VIDEO_ENABLED
video_manager_start(marielle,payload,margaux->local_rtp,0,marielle_webcam);
video_stream_set_direction(margaux->video_stream,VideoStreamRecvOnly);
video_manager_start(margaux,payload,marielle->local_rtp,0,NULL);
#else
ms_fatal("Unsupported stream type [%s]",ms_stream_type_to_string(marielle->type));
#endif
}
rtp_session_enable_network_simulation(margaux_ms->sessions.rtp_session,¶ms);
}
void upload_bitrate(const char* codec, int payload, int target_bw, int expect_bw) {
bool_t supported = ms_filter_codec_supported(codec);
if( supported ) {
float upload_bw;
stream_manager_t * marielle, * margaux;
start_adaptive_stream(MSAudio, &marielle, &margaux, payload, target_bw*1000, target_bw*1000, 0, 50,0);
//these tests check that encoders stick to the guidelines, so we must use NOT
//the adaptive algorithm which would modify these guidelines
media_stream_enable_adaptive_bitrate_control(&marielle->audio_stream->ms,FALSE);
iterate_adaptive_stream(marielle, margaux, 15000, NULL, 0);
upload_bw=media_stream_get_up_bw(&marielle->audio_stream->ms) / 1000;
CU_ASSERT_IN_RANGE(upload_bw, expect_bw-2, expect_bw+2);
stop_adaptive_stream(marielle,margaux);
}
}
static void upload_bandwidth_computation() {
bool_t supported = ms_filter_codec_supported("pcma");
if( supported ) {
stream_manager_t * marielle, * margaux;
int i;
start_adaptive_stream(AudioStreamType, &marielle, &margaux, PCMA8_PAYLOAD_TYPE, 8000, 0, 0, 0, 0);
media_stream_enable_adaptive_bitrate_control(&marielle->audio_stream->ms,FALSE);
for (i = 0; i < 5; i++){
rtp_session_set_duplication_ratio(marielle->audio_stream->ms.sessions.rtp_session, i);
iterate_adaptive_stream(marielle, margaux, 100000, &marielle->rtcp_count, 2*(i+1));
/*since PCMA uses 80kbit/s, upload bandwidth should just be 80+80*duplication_ratio kbit/s */
CU_ASSERT_TRUE(fabs(rtp_session_get_send_bandwidth(marielle->audio_stream->ms.sessions.rtp_session)/1000. - 80.*(i+1)) < 1.f);
}
stop_adaptive_stream(marielle,margaux);
}
}
static void audio_stream_dtmf(int codec_payload, int initial_bitrate,int target_bw, int max_recv_rtcp_packet) {
stream_manager_t * marielle = stream_manager_new();
stream_manager_t * margaux = stream_manager_new();
int pause_time=0;
OrtpNetworkSimulatorParams params={0};
params.enabled=TRUE;
params.loss_rate=0;
params.max_bandwidth=target_bw;
params.max_buffer_size=initial_bitrate;
float recv_send_bw_ratio;
int rtcp_interval = 1000;
float marielle_send_bw;
media_stream_enable_adaptive_bitrate_control(&marielle->stream->ms,TRUE);
stream_manager_start(marielle,codec_payload, margaux->local_rtp,initial_bitrate,HELLO_16K_1S_FILE,NULL);
ms_filter_call_method(marielle->stream->soundread,MS_FILE_PLAYER_LOOP,&pause_time);
unlink("blibi.wav");
stream_manager_start(margaux,codec_payload, marielle->local_rtp,-1,NULL,"blibi.wav");
rtp_session_enable_network_simulation(margaux->stream->ms.session,¶ms);
rtp_session_set_rtcp_report_interval(margaux->stream->ms.session, rtcp_interval);
wait_for_until(&marielle->stream->ms,&margaux->stream->ms,&marielle->stats.number_of_EndOfFile,10,rtcp_interval*max_recv_rtcp_packet);
marielle_send_bw=media_stream_get_up_bw(&marielle->stream->ms);
recv_send_bw_ratio=params.max_bandwidth/marielle_send_bw;
ms_message("marielle sent bw= [%f] , target was [%f] recv/send [%f]",marielle_send_bw,params.max_bandwidth,recv_send_bw_ratio);
CU_ASSERT_TRUE(recv_send_bw_ratio>0.9);
stream_manager_delete(marielle);
stream_manager_delete(margaux);
}
void start_adaptive_stream(MSFormatType type, stream_manager_t ** pmarielle, stream_manager_t ** pmargaux,
int payload, int initial_bitrate, int max_bw, float loss_rate, int latency, float dup_ratio) {
int pause_time=0;
PayloadType* pt;
MediaStream *marielle_ms,*margaux_ms;
OrtpNetworkSimulatorParams params={0};
#if VIDEO_ENABLED
MSWebCam * marielle_webcam=ms_web_cam_manager_get_default_cam (ms_web_cam_manager_get());
#endif
stream_manager_t *marielle=*pmarielle=stream_manager_new(type);
stream_manager_t *margaux=*pmargaux=stream_manager_new(type);
char* file = ms_strdup_printf("%s/%s", mediastreamer2_tester_get_file_root(), HELLO_16K_1S_FILE);
char* recorded_file = ms_strdup_printf("%s/%s", mediastreamer2_tester_get_writable_dir(), RECORDED_16K_1S_FILE);
marielle->user_data = recorded_file;
params.enabled=TRUE;
params.loss_rate=loss_rate;
params.max_bandwidth=max_bw;
params.latency=latency;
if (type == MSAudio){
marielle_ms=&marielle->audio_stream->ms;
margaux_ms=&margaux->audio_stream->ms;
}else{
marielle_ms=&marielle->video_stream->ms;
margaux_ms=&margaux->video_stream->ms;
}
/* Disable avpf. */
pt = rtp_profile_get_payload(&rtp_profile, VP8_PAYLOAD_TYPE);
CU_ASSERT_PTR_NOT_NULL_FATAL(pt);
payload_type_unset_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
media_stream_enable_adaptive_bitrate_control(marielle_ms,TRUE);
media_stream_set_adaptive_bitrate_algorithm(marielle_ms, MSQosAnalyzerAlgorithmStateful);
rtp_session_set_duplication_ratio(marielle_ms->sessions.rtp_session, dup_ratio);
if (marielle->type == MSAudio){
audio_manager_start(marielle,payload,margaux->local_rtp,initial_bitrate,file,NULL);
ms_filter_call_method(marielle->audio_stream->soundread,MS_FILE_PLAYER_LOOP,&pause_time);
audio_manager_start(margaux,payload,marielle->local_rtp,0,NULL,recorded_file);
}else{
#if VIDEO_ENABLED
video_manager_start(marielle,payload,margaux->local_rtp,0,marielle_webcam);
video_stream_set_direction(margaux->video_stream,VideoStreamRecvOnly);
video_manager_start(margaux,payload,marielle->local_rtp,0,NULL);
#else
ms_fatal("Unsupported stream type [%s]",ms_format_type_to_string(marielle->type));
#endif
}
ms_qos_analyzer_set_on_action_suggested(ms_bitrate_controller_get_qos_analyzer(marielle_ms->rc),
qos_analyzer_on_action_suggested,
*pmarielle);
rtp_session_enable_network_simulation(margaux_ms->sessions.rtp_session,¶ms);
ms_free(recorded_file);
ms_free(file);
}
