mediastreamer2_player_tester.c 5.92 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
mediastreamer2 library - modular sound and video processing and streaming
Copyright (C) 2006-2013 Belledonne Communications, Grenoble

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

François Grisez's avatar
François Grisez committed
20
#include "mediastreamer2_tester.h"
21
#include "mediastreamer2/msmediaplayer.h"
François Grisez's avatar
François Grisez committed
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

static int tester_init() {
	ms_init();
	return 0;
}

static int tester_cleanup() {
	ms_exit();
	return 0;
}

typedef struct _Eof {
	bool_t eof;
	int time_ms;
	ms_mutex_t mutex;
} Eof;

static void eof_init(Eof *obj) {
	obj->eof = FALSE;
	obj->time_ms = 0;
	ms_mutex_init(&obj->mutex, NULL);
}

static void eof_callback(void *user_data) {
	Eof *obj = (Eof *)user_data;
	ms_mutex_lock(&obj->mutex);
	obj->eof = TRUE;
	ms_mutex_unlock(&obj->mutex);
}

static void wait_for_eof(Eof *obj, int refresh_time_ms, int timeout_ms) {
	ms_mutex_lock(&obj->mutex);
	while(obj->time_ms < timeout_ms && !obj->eof) {
		ms_mutex_unlock(&obj->mutex);
56
		ms_usleep((useconds_t)(refresh_time_ms) * 1000U);
François Grisez's avatar
François Grisez committed
57 58 59 60 61 62
		obj->time_ms += refresh_time_ms;
		ms_mutex_lock(&obj->mutex);
	}
	ms_mutex_unlock(&obj->mutex);
}

63
static void play_file(const char *filepath, bool_t unsupported_format, bool_t seeking_test, bool_t play_twice) {
François Grisez's avatar
François Grisez committed
64 65
	bool_t succeed;
	Eof eof;
66
	MSMediaPlayer *file_player = NULL;
François Grisez's avatar
François Grisez committed
67
	MSSndCard *snd_card = ms_snd_card_manager_get_default_card(ms_snd_card_manager_get());
François Grisez's avatar
François Grisez committed
68
	const char *display_name = video_stream_get_default_video_renderer();
69 70 71
	int duration, timeout;
	const int seek_time = 6100;
	const double timeout_prec = 0.05;
François Grisez's avatar
François Grisez committed
72 73 74

	eof_init(&eof);

75
	file_player = ms_media_player_new(snd_card, display_name, 0);
François Grisez's avatar
François Grisez committed
76 77 78
	CU_ASSERT_PTR_NOT_NULL(file_player);
	if(file_player == NULL) return;

79
	CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed);
80
	ms_media_player_set_eof_callback(file_player, eof_callback, &eof);
François Grisez's avatar
François Grisez committed
81

82
	succeed = ms_media_player_open(file_player, filepath);
François Grisez's avatar
François Grisez committed
83 84
	if(unsupported_format) {
		CU_ASSERT_FALSE(succeed);
85
		CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed);
François Grisez's avatar
François Grisez committed
86 87
	} else {
		CU_ASSERT_TRUE(succeed);
88
		CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerPaused);
François Grisez's avatar
François Grisez committed
89 90
	}
	if(!succeed) {
91
		ms_media_player_free(file_player);
François Grisez's avatar
François Grisez committed
92 93 94
		return;
	}

95 96 97 98 99 100 101 102 103 104 105 106 107
	duration = ms_media_player_get_duration(file_player);
	if(ms_media_player_get_file_format(file_player) == MS_FILE_FORMAT_WAVE) {
		CU_ASSERT_TRUE(duration == -1);
		duration = 20000;
	} else {
		CU_ASSERT_TRUE(duration >= 0);
	}

	if(seeking_test) {
		timeout = (duration - seek_time) * (1 + timeout_prec);
	} else {
		timeout = duration * (1 + timeout_prec);
	}
108

109
	succeed = ms_media_player_start(file_player);
François Grisez's avatar
François Grisez committed
110
	CU_ASSERT_TRUE(succeed);
111
	CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerPlaying);
François Grisez's avatar
François Grisez committed
112

113
	if(seeking_test) {
114
		CU_ASSERT_TRUE(ms_media_player_seek(file_player, seek_time));
115 116
	}

François Grisez's avatar
François Grisez committed
117
	if(succeed) {
118
		wait_for_eof(&eof, 100, timeout);
119
		CU_ASSERT_TRUE(eof.eof);
François Grisez's avatar
François Grisez committed
120
	}
121
	ms_media_player_close(file_player);
122
	CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed);
123 124 125 126 127 128 129 130 131

	if(play_twice) {
		eof_init(&eof);
		CU_ASSERT_TRUE(ms_media_player_open(file_player, filepath));
		CU_ASSERT_TRUE(ms_media_player_start(file_player));
		wait_for_eof(&eof, 100, timeout);
		ms_media_player_close(file_player);
		CU_ASSERT_TRUE(eof.eof);
	}
132
	ms_media_player_free(file_player);
François Grisez's avatar
François Grisez committed
133 134
}

135
static void play_root_file(const char *filepath, bool_t unsupported_format, bool_t seeking_test, bool_t play_twice){
136
    char* file = ms_strdup_printf("%s/%s", mediastreamer2_tester_get_file_root(), filepath);
137
	play_file(file, unsupported_format, seeking_test, play_twice);
138 139 140
    ms_free(file);
}

François Grisez's avatar
François Grisez committed
141
static void play_hello_8000_wav(void) {
142
	play_root_file("sounds/hello8000.wav", FALSE, FALSE, FALSE);
François Grisez's avatar
François Grisez committed
143 144 145
}

static void play_hello_16000_wav(void) {
146
	play_root_file("sounds/hello16000.wav", FALSE, FALSE, FALSE);
François Grisez's avatar
François Grisez committed
147 148 149
}

static void play_hello_pcmu_mka(void) {
150
	play_root_file("sounds/hello_pcmu.mka", !ms_media_player_matroska_supported(), FALSE, FALSE);
François Grisez's avatar
François Grisez committed
151 152 153
}

static void play_hello_opus_mka(void) {
154
	play_root_file("sounds/hello_opus.mka", !ms_media_player_matroska_supported(), FALSE, FALSE);
François Grisez's avatar
François Grisez committed
155 156
}

157 158
static void play_sintel_trailer_pcmu_h264_mkv(void) {
	play_root_file("sounds/sintel_trailer_pcmu_h264.mkv", !ms_media_player_matroska_supported(), FALSE, FALSE);
François Grisez's avatar
François Grisez committed
159 160
}

161 162
static void play_sintel_trailer_opus_h264_mkv(void) {
	play_root_file("sounds/sintel_trailer_opus_h264.mkv", !ms_media_player_matroska_supported(), FALSE, FALSE);
163 164
}

165
static void seeking_test(void) {
166
	play_root_file("sounds/sintel_trailer_opus_h264.mkv", !ms_media_player_matroska_supported(), TRUE, FALSE);
167 168 169
}

static void playing_twice_test(void) {
170
	play_root_file("./sounds/sintel_trailer_opus_h264.mkv", !ms_media_player_matroska_supported(), FALSE, TRUE);
François Grisez's avatar
François Grisez committed
171 172 173
}

static test_t tests[] = {
174 175 176 177 178 179 180 181
	{	"Play hello8000.wav"                 ,	play_hello_8000_wav                },
	{	"Play hello16000.wav"                ,	play_hello_16000_wav               },
	{	"Play hello_pcmu.mka"                ,	play_hello_pcmu_mka                },
	{	"Play hello_opus.mka"                ,	play_hello_opus_mka                },
	{	"Play sintel_trailer_pcmu_h264.mkv"  ,	play_sintel_trailer_pcmu_h264_mkv  },
	{	"Play sintel_trailer_opus_h264.mkv"  ,	play_sintel_trailer_opus_h264_mkv  },
	{	"Seeking"                            ,	seeking_test                       },
	{	"Playing twice"                      ,	playing_twice_test                 }
François Grisez's avatar
François Grisez committed
182 183 184 185 186 187 188 189 190
};

test_suite_t player_test_suite = {
	"Player",
	tester_init,
	tester_cleanup,
	sizeof(tests)/sizeof(test_t),
	tests
};