#define API_NAMESPACE "[CAPI_MEDIA_STREAMER]"
#define CAMERA_ID "2"
-#define PLAY_TIME 5
+#define PLAY_TIME 2
#define PACKET_SIZE 1000
#define MAX_PACKETS_TO_SEND 50000
#define CONFIG_VALUE_LEN_MAX 1024
#define DEFAULT_IP_ADDR "127.0.0.1"
#define MAX_NODES_COUNT 100
#define APPEND_NODE(x) {g_nodes[g_node_counter++] = x; }
+#define EXTREMUM 0
+
+#define VIDEO_WIDTH 352
+#define VIDEO_HEIGHT 288
+#define VIDEO_AVG_BPS 1
+#define VIDEO_MAX_BPS 3
+#define AUDIO_CHANNEL 1
+#define AUDIO_SAMPLERATE 8000
+
+#define FILE_NAME "Ice.mp4"
+#define FILE_PATH_PLAYLIST "segments/prog_index.m3u8"
static media_format_h vfmt_encoded = NULL;
static media_format_h vfmt_raw = NULL;
-static media_format_h afmt_raw = NULL;
static media_format_h afmt_encoded = NULL;
+static media_format_h vfmt_aenc = NULL;
+static media_format_h vfmt_aencm = NULL;
+static media_format_h afmt_raw = NULL;
+static media_format_h afmt_araw = NULL;
+static media_format_h afmt_aenc = NULL;
+static media_format_h tsfmt = NULL;
+static media_format_h qtfmt = NULL;
static media_streamer_node_h g_nodes[MAX_NODES_COUNT] = { 0, };
static int g_node_counter = 0;
static GMainLoop *g_mainloop = NULL;
static media_streamer_h streamer = NULL;
static char *file_path = NULL;
-static char *test_file = "Ice.mp4";
+static char *file_path_playlist = NULL;
const int set_play_pos = 20000;
/**
*/
void utc_capi_media_streamer_startup(void)
{
+
+ char *test_file = FILE_NAME;
+ char *test_playlist = FILE_PATH_PLAYLIST;
+
char pszValue[CONFIG_VALUE_LEN_MAX] = {0,};
if ( true == GetValueForTCTSetting("DEVICE_SUITE_TARGET_30", pszValue, API_NAMESPACE ))
{
unsigned int size_of_path = strlen(pszValue) + strlen(test_file) + 6;
file_path = (char*)malloc(size_of_path);
snprintf(file_path, size_of_path, "%s/res/%s", pszValue, test_file);
- }
- else
- {
+ unsigned int size_of_path_playlist = strlen(pszValue) + strlen(test_playlist) + 6;
+ file_path_playlist = (char*)malloc(size_of_path_playlist);
+ snprintf(file_path_playlist, size_of_path_playlist, "%s/res/%s", pszValue, test_playlist);
+ } else {
PRINT_UTC_LOG("[Line : %d][%s] GetValueForTCTSetting returned error for 'DEVICE_SUITE_TARGET_30'\\n", __LINE__, API_NAMESPACE);
}
media_format_create(&vfmt_raw);
media_format_set_video_mime(vfmt_raw, MEDIA_FORMAT_I420);
- media_format_set_video_width(vfmt_raw, 352);
- media_format_set_video_height(vfmt_raw, 288);
- media_format_set_video_avg_bps(vfmt_raw, 1);
- media_format_set_video_max_bps(vfmt_raw, 3);
+ media_format_set_video_width(vfmt_raw, VIDEO_WIDTH);
+ media_format_set_video_height(vfmt_raw, VIDEO_HEIGHT);
+ media_format_set_video_avg_bps(vfmt_raw, VIDEO_AVG_BPS);
+ media_format_set_video_max_bps(vfmt_raw, VIDEO_MAX_BPS);
/* Define video encoded format */
media_format_create(&vfmt_encoded);
media_format_set_video_mime(vfmt_encoded, MEDIA_FORMAT_H263);
- media_format_set_video_width(vfmt_encoded, 352);
- media_format_set_video_height(vfmt_encoded, 288);
- media_format_set_video_avg_bps(vfmt_encoded, 1);
- media_format_set_video_max_bps(vfmt_encoded, 3);
+ media_format_set_video_width(vfmt_encoded, VIDEO_WIDTH);
+ media_format_set_video_height(vfmt_encoded, VIDEO_HEIGHT);
+ media_format_set_video_avg_bps(vfmt_encoded, VIDEO_AVG_BPS);
+ media_format_set_video_max_bps(vfmt_encoded, VIDEO_MAX_BPS);
+
+ /* Define encoded video format for adaptive stream */
+ media_format_create(&vfmt_aenc);
+ media_format_set_video_mime(vfmt_aenc, MEDIA_FORMAT_H264_SP);
+ media_format_set_video_width(vfmt_aenc, VIDEO_WIDTH);
+ media_format_set_video_height(vfmt_aenc, VIDEO_HEIGHT);
+ media_format_set_video_avg_bps(vfmt_aenc, VIDEO_AVG_BPS);
+ media_format_set_video_max_bps(vfmt_aenc, VIDEO_MAX_BPS);
+
+ /* Define encoded video format for adaptive stream */
+ media_format_create(&vfmt_aencm);
+ media_format_set_video_mime(vfmt_aencm, MEDIA_FORMAT_MPEG4_SP);
+ media_format_set_video_width(vfmt_aencm, VIDEO_WIDTH);
+ media_format_set_video_height(vfmt_aencm, VIDEO_HEIGHT);
+ media_format_set_video_avg_bps(vfmt_aencm, VIDEO_AVG_BPS);
+ media_format_set_video_max_bps(vfmt_aencm, VIDEO_MAX_BPS);
/* Define audio raw format */
media_format_create(&afmt_raw);
media_format_set_audio_mime(afmt_raw, MEDIA_FORMAT_PCM);
+ media_format_set_audio_channel(afmt_raw, AUDIO_CHANNEL);
+ media_format_set_audio_samplerate(afmt_raw, AUDIO_SAMPLERATE);
- media_format_set_audio_channel(afmt_raw, 1);
- media_format_set_audio_samplerate(afmt_raw, 8000);
+ /* Define audio raw format for adaptive streaming */
+ media_format_create(&afmt_araw);
+ media_format_set_audio_mime(afmt_araw, MEDIA_FORMAT_PCM_F32LE);
+ media_format_set_audio_channel(afmt_araw, AUDIO_CHANNEL);
+ media_format_set_audio_samplerate(afmt_araw, AUDIO_SAMPLERATE);
/* Define audio encoded format */
media_format_create(&afmt_encoded);
media_format_set_audio_mime(afmt_encoded, MEDIA_FORMAT_AMR_NB);
+ media_format_set_audio_channel(afmt_encoded, AUDIO_CHANNEL);
+ media_format_set_audio_samplerate(afmt_encoded, AUDIO_SAMPLERATE);
+
+ /* Define audio encoded format for adaptive stream */
+ media_format_create(&afmt_aenc);
+ media_format_set_audio_mime(afmt_aenc, MEDIA_FORMAT_AAC);
+ media_format_set_audio_channel(afmt_aenc, AUDIO_CHANNEL);
+ media_format_set_audio_samplerate(afmt_aenc, AUDIO_SAMPLERATE);
+ media_format_set_audio_aac_type(afmt_aenc, TRUE);
- media_format_set_audio_channel(afmt_encoded, 1);
- media_format_set_audio_samplerate(afmt_encoded, 8000);
+ /* Define mpegts stream format */
+ media_format_create(&tsfmt);
+ media_format_set_container_mime(tsfmt, MEDIA_FORMAT_CONTAINER_MPEG2TS);
+
+ /* Define MP4 stream format */
+ media_format_create(&qtfmt);
+ media_format_set_container_mime(qtfmt, MEDIA_FORMAT_CONTAINER_MP4);
}
/**
- * @function utc_capi_media_streamer_cleanup
- * @description Called after each test.
+ * @function utc_capi_media_streamer_cleanup * @description Called after each test.
* @parameter NA
* @return NA
*/
return;
media_packet_get_buffer_data_ptr(packet, (void **)&received_data);
+
+ media_packet_destroy (packet);
+ packet = NULL;
+
if (received_data == NULL)
return;
free(received_data);
received_data = NULL;
- media_packet_destroy (packet);
- packet = NULL;
}
//& purpose: A purpose of a first positive TC.
ret = media_format_get_video_info(pad_fmt, &mime, &width, &height, &avg_bps, &max_bps);
assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
- assert_neq(mime, 0);
- assert_neq(width, 0);
- assert_neq(height, 0);
- assert_neq(avg_bps, 0);
- assert_neq(max_bps, 0);
+ assert_neq(mime, EXTREMUM);
+ assert_neq(width, EXTREMUM);
+ assert_neq(height, EXTREMUM);
+ assert_neq(avg_bps, EXTREMUM);
+ assert_neq(max_bps, EXTREMUM);
assert_eq(mime_init, mime);
assert_eq(width_init, width);
#endif //MOBILE //End MOBILE
/**
+ * @testcase utc_media_streamer_node_get_param_p5
+ * @since_tizen 3.0
+ * @description Gets a parameter value of
+ * media streamer node.
+ */
+int utc_media_streamer_node_get_param_p5(void)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ char *param_value = NULL;
+
+ media_streamer_node_h adaptive_src = NULL;
+ ret = media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE, &adaptive_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ assert_neq(adaptive_src, NULL);
+ APPEND_NODE(adaptive_src);
+
+ ret = media_streamer_node_set_param(adaptive_src, MEDIA_STREAMER_PARAM_URI, file_path);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_get_param(adaptive_src, MEDIA_STREAMER_PARAM_URI, ¶m_value);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ assert_neq(param_value, NULL);
+ assert(!strcmp(param_value, file_path));
+ free(param_value);
+
+ return 0;
+}
+
+/**
* @testcase utc_media_streamer_node_get_param_n1
* @since_tizen 3.0
* @description Gets a parameter value of
return 0;
}
-#endif //MOBILE //End MOBILE
+#endif //MOBILE //End
+
+/**
+ * @testcase utc_media_streamer_play_p3
+ * @since_tizen 3.0
+ * @description Adaptive auto playing of
+ * media streamer client.
+ */
+int utc_media_streamer_play_p3(void)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ media_streamer_node_h adaptive_src = NULL;
+
+ ret = media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE, &adaptive_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_set_param(adaptive_src, MEDIA_STREAMER_PARAM_URI, file_path_playlist);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, adaptive_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(adaptive_src);
+
+ /*********************** videosink *********************************** */
+ media_streamer_node_h video_sink = NULL;
+ ret = media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_OVERLAY, &video_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, video_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(video_sink);
+
+ /*********************** audiosink *********************************** */
+ media_streamer_node_h audio_sink = NULL;
+ ret = media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO, &audio_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, audio_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(audio_sink);
+
+ ret = media_streamer_prepare(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ ret = media_streamer_play(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+ return 0;
+}
+
+/**
+ * @testcase utc_media_streamer_play_p4
+ * @since_tizen 3.0
+ * @description Adaptive manual playing of
+ * media streamer client.
+ */
+int utc_media_streamer_play_p4(void)
+{
+
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+
+ media_streamer_node_h adaptive_src = NULL;
+ ret = media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE, &adaptive_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_set_param(adaptive_src, MEDIA_STREAMER_PARAM_URI, file_path_playlist);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, adaptive_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(adaptive_src);
+
+ media_streamer_node_h ts_demux = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_DEMUXER, tsfmt, NULL, &ts_demux);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, ts_demux);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(ts_demux);
+
+ media_streamer_node_h video_dec = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER, vfmt_aenc, vfmt_raw, &video_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, video_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(video_dec);
+
+ media_streamer_node_h audio_dec = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER, afmt_aenc, afmt_araw, &audio_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, audio_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(audio_dec);
+
+ /*********************** videosink *********************************** */
+ media_streamer_node_h video_sink = NULL;
+ ret = media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_OVERLAY, &video_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, video_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(video_sink);
+
+ /*********************** audiosink *********************************** */
+ media_streamer_node_h audio_sink = NULL;
+ ret = media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO, &audio_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, audio_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(audio_sink);
+
+ ret = media_streamer_prepare(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ ret = media_streamer_play(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_media_streamer_play_p5
+ * @since_tizen 3.0
+ * @description Adaptive server of
+ * media streamer server.
+ */
+int utc_media_streamer_play_p5(void)
+{
+
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ media_streamer_node_h file_src = NULL;
+ ret = media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &file_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_set_param(file_src, MEDIA_STREAMER_PARAM_URI, file_path);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, file_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(file_src);
+
+ /*********************** videosink *********************************** */
+ media_streamer_node_h adaptive_sink = NULL;
+ ret = media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_ADAPTIVE, &adaptive_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, adaptive_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(adaptive_sink);
+
+ ret = media_streamer_prepare(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ ret = media_streamer_play(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_media_streamer_play_p6
+ * @since_tizen 3.0
+ * @description Adaptive manual server of
+ * media streamer server.
+ */
+int utc_media_streamer_play_p6(void)
+{
+
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ media_streamer_node_h file_src = NULL;
+ ret = media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &file_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_set_param(file_src, MEDIA_STREAMER_PARAM_URI, file_path);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, file_src);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(file_src);
+
+ media_streamer_node_h qt_demux = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_DEMUXER, qtfmt, NULL, &qt_demux);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, qt_demux);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(qt_demux);
+
+ media_streamer_node_h video_dec = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER, vfmt_aenc, vfmt_raw, &video_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, video_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(video_dec);
+
+ media_streamer_node_h audio_dec = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER, afmt_aenc, afmt_araw, &audio_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, audio_dec);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(audio_dec);
+
+ media_streamer_node_h video_enc = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER, vfmt_raw, vfmt_aencm, &video_enc);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, video_enc);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(video_enc);
+
+ media_streamer_node_h audio_enc = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER, afmt_araw, afmt_aenc, &audio_enc);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, audio_enc);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(audio_enc);
+
+ media_streamer_node_h ts_mux = NULL;
+ ret = media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_MUXER, NULL, tsfmt, &ts_mux);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, ts_mux);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(ts_mux);
+
+ media_streamer_node_h adaptive_sink = NULL;
+ ret = media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_ADAPTIVE, &adaptive_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_add(streamer, adaptive_sink);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ APPEND_NODE(adaptive_sink);
+
+ ret = media_streamer_node_link(file_src, "src", qt_demux, "sink");
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_link(video_dec, "src", video_enc, "sink");
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_link(audio_dec, "src", audio_enc, "sink");
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_link(video_enc, "src", ts_mux, "sink_%d");
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_link(audio_enc, "src", ts_mux, "sink_%d");
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ ret = media_streamer_node_link(ts_mux, "src", adaptive_sink, "sink");
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+
+ ret = media_streamer_prepare(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ ret = media_streamer_play(streamer);
+ assert_eq(ret, MEDIA_STREAMER_ERROR_NONE);
+ wait_for_async(PLAY_TIME);
+
+ return 0;
+}
projects / test / tct / native / api.git / commitdiff