path: root/test/mtpr_test.c

/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <mtpr_internal.h>

#include <appcore-efl.h>
#include <Elementary.h>
#include <glib.h>
#include <sound_manager_internal.h>

#define TIZEN_FEATURE_ESPP
#ifdef TIZEN_FEATURE_ESPP
#include "mtpr_test_espp.h"
#endif
#include "mtpr_test_with_camera.h"

#ifdef PACKAGE
#undef PACKAGE
#endif
#define PACKAGE "mtpr_test"

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "MTPR_TEST"

#define MAX_STRING_LEN 512

enum {
	CURRENT_STATUS_MAINMENU,
	CURRENT_STATUS_CONNECTION_TYPE,
	CURRENT_STATUS_SENDER_ADDRESS,
	CURRENT_STATUS_RECEIVER_ADDRESS,
	CURRENT_STATUS_CONNECTION_SRT_MODE,
	CURRENT_STATUS_CONNECTION_SRT_STREAMID,
	CURRENT_STATUS_CONNECTION_SRT_PASSPHRASE,
	CURRENT_STATUS_CONNECTION_SRT_PBKEYLEN,
	CURRENT_STATUS_CONNECTION_RIST_BONDING_ADDRESS,
	CURRENT_STATUS_CONNECTION_RIST_MAX_RTCP_BANDWIDTH,
	CURRENT_STATUS_CONNECTION_RIST_MIN_RTCP_INTERVAL,
	CURRENT_STATUS_CONNECTION_RIST_SENDER_BUFFER,
	CURRENT_STATUS_CONNECTION_GET_PARAM,
	CURRENT_STATUS_ADD_MEDIA_SOURCE,
	CURRENT_STATUS_SOURCE_VIDEO_RESOLUTION,
	CURRENT_STATUS_SOURCE_VIDEO_FRAMERATE,
	CURRENT_STATUS_SOURCE_AUDIO_CHANNEL,
	CURRENT_STATUS_SOURCE_AUDIO_SAMPLERATE,
	CURRENT_STATUS_SOURCE_AUDIO_FORMAT,
	CURRENT_STATUS_ENCODING_BITRATE,
	CURRENT_STATUS_REMOVE_MEDIA_SOURCE,
	CURRENT_STATUS_SET_DISPLAY,
	CURRENT_STATUS_SET_DISPLAY_MODE,
	CURRENT_STATUS_SET_DISPLAY_VISIBLE,
	CURRENT_STATUS_SET_SOUND_STREAM_INFO,
};

/* for video display */
static Evas_Object *g_eo;
static Evas_Object *g_win_id;
static Evas_Object *g_selected_win_id;

typedef struct {
	Evas_Object *win;
	Evas_Object *layout_main;
} appdata;

static appdata g_ad;
static mtpr_h g_mtpr;

static bool g_dump_data = false;

static FILE* video_dump = NULL;
static FILE* audio_dump = NULL;

static int g_menu_state = CURRENT_STATUS_MAINMENU;
static sound_stream_info_h g_mic_stream_info = NULL;
static sound_stream_info_h g_stream_info = NULL;
static int g_audio_source_id = 0;
static int g_video_source_id = 0;

/* render using espp */
#ifdef TIZEN_FEATURE_ESPP
static bool g_use_espp = false;
#endif
static bool g_use_camera_for_packet = false;

static void _mtpr_test_unset_track_cb();
static void _mtpr_test_unset_encoded_audio_frame_cb();
static void _mtpr_test_unset_encoded_video_frame_cb();

static void __win_del(void *data, Evas_Object *obj, void *event)
{
	elm_exit();
}

static Evas_Object *create_win(const char *name)
{
	Evas_Object *eo = NULL;
	int w = 0;
	int h = 0;

	g_print("[%s][%d] name=%s\n", __func__, __LINE__, name);

	eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
	if (eo) {
		elm_win_title_set(eo, name);
		elm_win_borderless_set(eo, EINA_TRUE);
		evas_object_smart_callback_add(eo, "delete,request", __win_del, NULL);
		elm_win_screen_size_get(eo, NULL, NULL, &w, &h);
		g_print("window size :%d,%d", w, h);
		evas_object_resize(eo, w, h);
		elm_win_autodel_set(eo, EINA_TRUE);
		elm_win_alpha_set(eo, EINA_TRUE);
	}
	return eo;
}

static Evas_Object *__create_image_object(Evas_Object *eo_parent)
{
	if (!eo_parent)
		return NULL;

	Evas *evas = evas_object_evas_get(eo_parent);
	Evas_Object *eo = NULL;

	eo = evas_object_image_add(evas);

	return eo;
}

void create_render_rect_and_bg(Evas_Object *win)
{
	if (!win) {
		g_print("no win");
		return;
	}
	Evas_Object *bg, *rect;

	bg = elm_bg_add(win);
	elm_win_resize_object_add(win, bg);
	evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	evas_object_show(bg);

	rect = evas_object_rectangle_add(evas_object_evas_get(win));
	if (!rect) {
		g_print("no rect");
		return;
	}
	evas_object_color_set(rect, 0, 0, 0, 0);
	evas_object_render_op_set(rect, EVAS_RENDER_COPY);

	elm_win_resize_object_add(win, rect);
	evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	evas_object_show(rect);
	evas_object_show(win);
}

static int app_create(void *data)
{
	appdata *ad = data;
	Evas_Object *win = NULL;

	/* use gl backend */
	elm_config_accel_preference_set("opengl");

	/* create window */
	win = create_win(PACKAGE);
	if (win == NULL)
		return -1;
	ad->win = win;
	g_win_id = win;
	g_selected_win_id = g_win_id;
	create_render_rect_and_bg(ad->win);
	/* Create evas image object for EVAS surface */
	g_eo = __create_image_object(ad->win);
	evas_object_image_size_set(g_eo, 500, 500);
	evas_object_image_fill_set(g_eo, 0, 0, 500, 500);
	evas_object_resize(g_eo, 500, 500);

	elm_win_activate(win);
	evas_object_show(win);

	return 0;
}

static int app_terminate(void *data)
{
	appdata *ad = data;

	if (g_eo) {
		evas_object_del(g_eo);
		g_eo = NULL;
	}

	if (g_win_id) {
		evas_object_del(g_win_id);
		g_win_id = NULL;
	}

	ad->win = NULL;
	g_selected_win_id = NULL;

	return 0;
}

static struct appcore_ops ops = {
	.create = app_create,
	.terminate = app_terminate,
};

static void __error_cb(mtpr_h mtpr, mtpr_error_e error, void *user_data)
{
	g_print("             => [ERROR_CB] mtpr[%p], error[0x%x], user_data[%p]\n",
		mtpr, error, user_data);
}

static void __track_added_cb(mtpr_h mtpr, mtpr_media_type_e type, unsigned int id, void *user_data)
{
	g_print("             => [TRACK ADDED CB] mtpr[%p], type[0x%x], id[%u], use_data[%p]\n",
		mtpr, type, id, user_data);
#ifdef TIZEN_FEATURE_ESPP
	if (g_use_espp)
		_espp_track_added(type, id);
#endif
}

static void __no_more_track_cb(mtpr_h mtpr, void *user_data)
{
	g_print("             => [NO MORE TRACK CB] mtpr[%p], use_data[%p]\n", mtpr, user_data);
#ifdef TIZEN_FEATURE_ESPP
	if (g_use_espp)
		_espp_no_more_track();
#endif
}

static void __encoded_frame_cb(mtpr_h mtpr, mtpr_media_type_e type, unsigned int id, media_packet_h packet, void *user_data)
{
	uint64_t gst_pts;
	void *temp;
	uint64_t buf_size;
	FILE *fp;

	if (!packet) {
		g_print("encoded_frame packet is NULL\n");
		return;
	}

	/* FIXME: dump file have to be created for each id */

	if (g_dump_data) {
		media_packet_get_buffer_data_ptr(packet, &temp);
		media_packet_get_buffer_size(packet, &buf_size);

		fp = (type == MTPR_MEDIA_TYPE_AUDIO) ? audio_dump : video_dump;
		fwrite(temp, (int)buf_size, 1, fp);
	}

#ifdef TIZEN_FEATURE_ESPP
	if (g_use_espp)
		_espp_submit_packet (type, id, packet);
#endif

	media_packet_get_pts(packet, &gst_pts);
	g_print("[%s][%u] frame [%llu ms]\n", (type == MTPR_MEDIA_TYPE_AUDIO) ? "Audio" : "Video", id, (unsigned long long)(gst_pts / 1000));

	media_packet_destroy(packet);
}

bool __connection_stats_cb(mtpr_h mtpr, const mtpr_connection_stats_prop_info_s *prop_info, void *user_data)
{
	if (!prop_info) {
		g_print("			  => [STATS_CB][ERROR] mtpr[%p] invalid prop_info\n", mtpr);
		return false;
	}

	switch(prop_info->type) {
	case MTPR_CONNECTION_STATS_PROP_TYPE_BOOL:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%u\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_bool);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_INT:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%d\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_int);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_UINT:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%u\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_uint);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_INT64:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%" G_GINT64_FORMAT "\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_int64);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_UINT64:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%" G_GUINT64_FORMAT "\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_uint64);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_FLOAT:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%f\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_float);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_DOUBLE:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%f\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_double);
		break;
	case MTPR_CONNECTION_STATS_PROP_TYPE_STRING:
		g_print("			  => [STATS_CB] mtpr[%p], prop[%d], type[%d], %s:%s\n",
			mtpr, prop_info->prop, prop_info->type, prop_info->name, prop_info->v_string);
		break;
	default:
		g_print("			  => [STATS_CB][ERROR] mtpr[%p] invalid type %d\n", mtpr, prop_info->type);
		break;
	}

	return true;
}

static void _mtpr_test_set_error_cb()
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_error_cb(g_mtpr, __error_cb, g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_error_cb()\n");
	else
		g_print("             => mtpr_set_error_cb() success\n");
}

static void _mtpr_test_unset_error_cb()
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_unset_error_cb(g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_unset_error_cb()\n");
	else
		g_print("             => mtpr_unset_error_cb() success\n");
}

static void _mtpr_test_destroy()
{
	int ret = MTPR_ERROR_NONE;

	if (!g_mtpr) {
		g_print("             => failed to _mtpr_test_destroy(), g_mtpr is NULL\n");
		return;
	}

	_mtpr_test_unset_error_cb();
	_mtpr_test_unset_track_cb();
	_mtpr_test_unset_encoded_audio_frame_cb();
	_mtpr_test_unset_encoded_video_frame_cb();

	ret = mtpr_destroy(g_mtpr);
	if (ret != MTPR_ERROR_NONE) {
		g_print("             => failed to mtpr_destroy() returned [0x%x]\n", ret);
	} else {
		g_print("             => mtpr_destroy() success\n");
		g_mtpr = NULL;
	}

	if (g_mic_stream_info) {
		sound_manager_destroy_stream_information(g_mic_stream_info);
		g_mic_stream_info = NULL;
	}
	if (g_stream_info) {
		sound_manager_destroy_stream_information(g_stream_info);
		g_stream_info = NULL;
	}

	if (g_use_camera_for_packet)
		_mtrp_test_camera_packet_src_destroy();
}

static void _mtpr_test_start()
{
	int ret = MTPR_ERROR_NONE;

	if (!g_mtpr) {
		g_print("             => failed to _mtpr_test_start(), g_mtpr is NULL\n");
		return;
	}

	ret = mtpr_start(g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_start() returned [0x%x]\n", ret);
	else
		g_print("             => mtpr_start() success\n");

	if (g_use_camera_for_packet)
		_mtpr_test_camera_packet_src_start();
}

static void _mtpr_test_stop()
{
	int ret = MTPR_ERROR_NONE;

	if (!g_mtpr) {
		g_print("             => failed to _mtpr_test_stop(), g_mtpr is NULL\n");
		return;
	}

	ret = mtpr_stop(g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_stop() returned [0x%x]\n", ret);
	else
		g_print("             => mtpr_stop() success\n");

	if (g_use_camera_for_packet)
		_mtrp_test_camera_packet_src_stop();
}

static void _mtpr_test_set_display(unsigned int type)
{
#ifdef TIZEN_FEATURE_ESPP
	if (g_use_espp) {
		_espp_set_display(type, g_win_id);
		return;
	}
#endif
	int ret = mtpr_set_display(g_mtpr, (mtpr_display_type_e)type, g_win_id);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_display() returned [0x%x]\n", ret);
	else
		g_print("             => mtpr_set_display() success\n");
}

static void _mtpr_test_set_display_mode(unsigned int mode)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_display_mode(g_mtpr, (mtpr_display_mode_e)mode);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_display_mode() returned [0x%x]\n", ret);
	else
		g_print("             => mtpr_set_display_mode() success\n");
}

static void _mtpr_test_set_display_visible(unsigned int visible)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_display_visible(g_mtpr, (bool)visible);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_display_visible() returned [0x%x]\n", ret);
	else
		g_print("             => mtpr_set_display_visible() success\n");
}

static void _mtpr_test_create(int type)
{
	int ret = MTPR_ERROR_NONE;

	if (g_mtpr) {
		g_print("             => failed to _mtpr_test_create(), already created\n");
		return;
	}

	ret = mtpr_create(type, &g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_create(), ret[0x%x]\n", ret);
	else
		g_print("             => mtpr_create(type(%d)) success\n", type);
}

static void _mtpr_test_get_connection_type()
{
	int ret = MTPR_ERROR_NONE;
	mtpr_connection_type_e type = MTPR_CONNECTION_TYPE_RIST_SENDER;

	ret = mtpr_get_connection_type(g_mtpr, &type);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_get_connection_type() returned [0x%x]\n", ret);
	else
		g_print("             => type: [%d]\n", type);
}

static void _mtpr_test_set_sender_address(char *address)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_sender_address(g_mtpr, address);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_sender_address(), ret[0x%x]\n", ret);
	else
		g_print("             => mtpr_set_sender_address() success\n");
}

static void _mtpr_test_set_receiver_address(char *address)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_receiver_address(g_mtpr, address);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_receiver_address(), ret[0x%x]\n", ret);
	else
		g_print("             => mtpr_set_receiver_address() success\n");
}

static void _mtpr_test_get_sender_address()
{
	int ret = MTPR_ERROR_NONE;
	char *address = NULL;

	ret = mtpr_get_sender_address(g_mtpr, &address);
	if (ret != MTPR_ERROR_NONE) {
		g_print("             => failed to mtpr_get_sender_address(), ret[0x%x]\n", ret);
	} else {
		g_print("             => sender address (%s)\n", address);
	}

	if (address)
		free(address);
}

static void _mtpr_test_get_receiver_address()
{
	int ret = MTPR_ERROR_NONE;
	char *address = NULL;

	ret = mtpr_get_receiver_address(g_mtpr, &address);
	if (ret != MTPR_ERROR_NONE) {
		g_print("             => failed to mtpr_get_receiver_address(), ret[0x%x]\n", ret);
	} else {
		g_print("             => receiver address (%s)\n", address);
	}

	if (address)
		free(address);
}

static void _mtpr_test_foreach_connection_stats()
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_foreach_connection_stats(g_mtpr, __connection_stats_cb, g_mtpr);
	if (ret != MTPR_ERROR_NONE) {
		g_print("             => failed to mtpr_foreach_connection_stats(), ret[0x%x]\n", ret);
	} else {
		g_print("             => foreach stats done\n");
	}
}

static void __set_aec_reference_device(sound_stream_info_h stream_info)
{
	int ret;
	sound_device_list_h device_list = NULL;
	sound_device_h device;
	sound_device_type_e cur_playback_device_type;
	bool found = false;

	if(stream_info == NULL) {
		g_printerr("stream_info is NULL\n");
		return;
	}

	ret = sound_manager_get_current_media_playback_device_type(&cur_playback_device_type);
	if (ret != SOUND_MANAGER_ERROR_NONE) {
		g_printerr("failed to sound_manager_get_current_media_playback_device_type()\n");
		return;
	}

	ret = sound_manager_get_device_list(SOUND_DEVICE_IO_DIRECTION_OUT_MASK, &device_list);
	if (ret != SOUND_MANAGER_ERROR_NONE && ret != SOUND_MANAGER_ERROR_NO_DATA) {
		g_printerr("failed to sound_manager_get_device_list()\n");
		return;
	}

	while (sound_manager_get_next_device(device_list, &device) == SOUND_MANAGER_ERROR_NONE) {
		sound_device_type_e device_type;
		int device_id;

		ret = sound_manager_get_device_type(device, &device_type);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to sound_manager_get_device_type()\n");
			break;
		}

		if (cur_playback_device_type != device_type)
			continue;

		ret = sound_manager_get_device_id(device, &device_id);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to sound_manager_get_device_id()\n");
			break;
		}

		found = true;

		ret = sound_manager_set_effect_method_with_reference(stream_info, SOUND_EFFECT_ACOUSTIC_ECHO_CANCEL_WEBRTC, device);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to sound_manager_set_echo_cancel_reference_device()\n");
		} else {
			g_print("set a reference device[type:%u, id:%d]\n", device_type, device_id);
			break;
		}
	}

	sound_manager_free_device_list(device_list);

	if (!found)
		g_printerr("could not find a candidate for reference device\n");
}

static int __get_mic_sound_stream_info(bool aec, sound_stream_info_h *stream_info)
{
	int ret;
	sound_device_list_h device_list = NULL;
	sound_stream_info_h _stream_info = NULL;

	if (!stream_info) {
		g_printerr("stream_info is NULL\n");
		return -1;
	}

	ret = sound_manager_get_device_list(SOUND_DEVICE_IO_DIRECTION_IN_MASK | SOUND_DEVICE_TYPE_EXTERNAL_MASK, &device_list);
	if (ret != SOUND_MANAGER_ERROR_NONE && ret != SOUND_MANAGER_ERROR_NO_DATA) {
		g_printerr("failed to sound_manager_get_device_list()\n");
		return -1;
	}

	if (ret == SOUND_MANAGER_ERROR_NO_DATA) {
		ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &_stream_info);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to sound_manager_create_stream_information()\n");
			goto error;
		}

	} else {
		sound_device_h device;
		char *device_name = NULL;
		ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA_EXTERNAL_ONLY, NULL, NULL, &_stream_info);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to sound_manager_create_stream_information()\n");
			goto error;
		}
		ret = sound_manager_get_next_device(device_list, &device);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to get device\n");
			goto error;
		}
		ret |= sound_manager_add_device_for_stream_routing(_stream_info, device);
		ret |= sound_manager_apply_stream_routing(_stream_info);
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_printerr("failed to apply stream routing\n");
			goto error;
		}
		sound_manager_get_device_name(device, &device_name);
		g_print("device[%s] is applied.\n", device_name);
	}

	sound_manager_free_device_list(device_list);

	*stream_info = _stream_info;

	if (aec)
		__set_aec_reference_device(*stream_info);

	return 0;

error:
	if (device_list)
		sound_manager_free_device_list(device_list);
	if (_stream_info)
		sound_manager_destroy_stream_information(_stream_info);
	return -1;
}

static void _mtpr_test_add_media_source(int type)
{
	int ret = MTPR_ERROR_NONE;
	unsigned int source_id = 0;

	ret = mtpr_add_media_source(g_mtpr, (mtpr_source_type_e)type, &source_id);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_add_media_source(), ret[0x%x]\n", ret);
	else
		g_print("             => mtpr_add_media_source() success, source_id[%d]\n", source_id);

	if (type == MTPR_SOURCE_TYPE_MIC || type == MTPR_SOURCE_TYPE_AUDIOTEST)
		g_audio_source_id = source_id;
	else
		g_video_source_id = source_id;

	if (type == MTPR_SOURCE_TYPE_CAMERA || type == MTPR_SOURCE_TYPE_VIDEOTEST) {
		// mtpr_source_set_video_loopback(g_mtpr, source_id, MTPR_DISPLAY_TYPE_OVERLAY, g_win_id);
	} else if (type == MTPR_SOURCE_TYPE_MIC) {
		if (__get_mic_sound_stream_info(false, &g_mic_stream_info) < 0) {
			g_print("failed to __get_mic_sound_stream_info()\n");
		} else {
			mtpr_mic_source_set_sound_stream_info(g_mtpr, source_id, g_mic_stream_info);
		}
	}
}

static void _mtpr_media_source_set_video_resolution(int width, int height)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_media_source_set_video_resolution(g_mtpr, g_video_source_id, width, height);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_set_video_resolution(), source_id[%d], ret[0x%x]\n", g_video_source_id, ret);
	else
		g_print("             => mtpr_media_source_set_video_resolution() success, source_id[%d], width[%d], height[%d]\n", g_video_source_id, width, height);
}

static void _mtpr_media_source_get_video_resolution()
{
	int ret = MTPR_ERROR_NONE;
	int width = 0;
	int height = 0;

	ret = mtpr_media_source_get_video_resolution(g_mtpr, g_video_source_id, &width, &height);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_get_video_resolution(), source_id[%d], ret[0x%x]\n", g_video_source_id, ret);
	else
		g_print("             => mtpr_media_source_get_video_resolution() success, source_id[%d], width[%d], height[%d]\n", g_video_source_id, width, height);
}

static void _mtpr_media_source_set_video_framerate(int framerate)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_media_source_set_video_framerate(g_mtpr, g_video_source_id, framerate);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_set_video_framerate(), source_id[%d], ret[0x%x]\n", g_video_source_id, ret);
	else
		g_print("             => mtpr_media_source_set_video_framerate() success, source_id[%d], framerate[%d]\n", g_video_source_id, framerate);
}

static void _mtpr_media_source_get_video_framerate()
{
	int ret = MTPR_ERROR_NONE;
	int framerate = 0;

	ret = mtpr_media_source_get_video_framerate(g_mtpr, g_video_source_id, &framerate);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to _mtpr_media_source_get_video_framerate(), source_id[%d], ret[0x%x]\n", g_video_source_id, ret);
	else
		g_print("             => _mtpr_media_source_get_video_framerate() success, source_id[%d], framerate[%d]\n", g_video_source_id, framerate);
}

static void _mtpr_media_source_set_audio_channel(int channel)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_media_source_set_audio_channels(g_mtpr, g_audio_source_id, channel);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_set_audio_channels(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
	else
		g_print("             => mtpr_media_source_set_audio_channels() success, source_id[%d], channel[%d]\n", g_audio_source_id, channel);
}

static void _mtpr_media_source_get_audio_channel()
{
	int ret = MTPR_ERROR_NONE;
	int channel = 0;

	ret = mtpr_media_source_get_audio_channels(g_mtpr, g_audio_source_id, &channel);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_get_audio_channels(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
	else
		g_print("             => mtpr_media_source_get_audio_channels() success, source_id[%d], channel[%d]\n", g_audio_source_id, channel);
}

static void _mtpr_media_source_set_audio_samplerate(int samplerate)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_media_source_set_audio_samplerate(g_mtpr, g_audio_source_id, samplerate);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_set_audio_samplerate(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
	else
		g_print("             => mtpr_media_source_set_audio_samplerate() success, source_id[%d], samplerate[%d]\n", g_audio_source_id, samplerate);
}

static void _mtpr_media_source_get_audio_samplerate()
{
	int ret = MTPR_ERROR_NONE;
	int samplerate = 0;

	ret = mtpr_media_source_get_audio_samplerate(g_mtpr, g_audio_source_id, &samplerate);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_get_audio_samplerate(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
	else
		g_print("             => mtpr_media_source_get_audio_samplerate() success, source_id[%d], samplerate[%d]\n", g_audio_source_id, samplerate);
}

static void _mtpr_media_source_set_audio_format(int format)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_media_source_set_audio_format(g_mtpr, g_audio_source_id, (mtpr_source_audio_format_e)format);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_set_audio_format(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
	else
		g_print("             => mtpr_media_source_set_audio_format() success, source_id[%d], format[%d]\n", g_audio_source_id, format);
}

static void _mtpr_media_source_get_audio_format()
{
	int ret = MTPR_ERROR_NONE;
	mtpr_source_audio_format_e format;

	ret = mtpr_media_source_get_audio_format(g_mtpr, g_audio_source_id, &format);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_media_source_get_audio_format(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
	else
		g_print("             => mtpr_media_source_get_audio_format() success, source_id[%d], format[%d]\n", g_audio_source_id, format);
}

static void _mtpr_set_encoding_bitrate(int source_id, int bitrate)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_encoding_bitrate(g_mtpr, source_id, bitrate);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_encoding_bitrate(), source_id[%d], ret[0x%x]\n", source_id, ret);
	else
		g_print("             => mtpr_set_encoding_bitrate() success, source_id[%d], format[%d]\n", source_id, bitrate);
}

static void _mtpr_get_encoding_bitrate()
{
	int ret = MTPR_ERROR_NONE;
	int bitrate = 0;

	if (g_audio_source_id) {
		ret = mtpr_get_encoding_bitrate(g_mtpr, g_audio_source_id, &bitrate);
		if (ret != MTPR_ERROR_NONE)
			g_print("             => failed to mtpr_get_encoding_bitrate(), source_id[%d], ret[0x%x]\n", g_audio_source_id, ret);
		else
			g_print("             => mtpr_get_encoding_bitrate() success, source_id[%d], format[%d]\n", g_audio_source_id, bitrate);
	}

	if (g_video_source_id) {
		ret = mtpr_get_encoding_bitrate(g_mtpr, g_video_source_id, &bitrate);
		if (ret != MTPR_ERROR_NONE)
			g_print("             => failed to mtpr_get_encoding_bitrate(), source_id[%d], ret[0x%x]\n", g_video_source_id, ret);
		else
			g_print("             => mtpr_get_encoding_bitrate() success, source_id[%d], format[%d]\n", g_video_source_id, bitrate);
	}
}


static void _mtpr_test_remove_media_source(unsigned int source_id)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_remove_media_source(g_mtpr, source_id);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_remove_media_source(), source_id[%d], ret[0x%x]\n", source_id, ret);
	else
		g_print("             => mtpr_remove_media_source() success, source_id[%d]\n", source_id);
}



static void _mtpr_test_get_state()
{
	int ret = MTPR_ERROR_NONE;
	mtpr_state_e state = MTPR_STATE_IDLE;

	ret = mtpr_get_state(g_mtpr, &state);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_get_state() returned [0x%x]\n", ret);
	else
		g_print("             => state: [%d]\n", state);
}

static void _mtpr_test_set_connection_param(const char* name, const char* val)
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_connection_param(g_mtpr, name, val);
	if (ret != MTPR_ERROR_NONE)
		g_print("						=> failed to mtpr_set_connection_param(%s, %s) returned [0x%x]\n", name, val, ret);
}

static void _mtpr_test_get_connection_param(const char *name)
{
	int ret = MTPR_ERROR_NONE;
	char *value = NULL;

	ret = mtpr_get_connection_param(g_mtpr, name, &value);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_get_connection_param(%s) returned [0x%x]\n", name, ret);
	else
		g_print("             => param: %s, %s\n", name, value);

	if (value)
		free(value);
}

static void _mtpr_test_set_track_cb()
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_set_track_added_cb(g_mtpr, __track_added_cb, g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_track_added_cb()\n");
	else
		g_print("             => mtpr_set_track_added_cb() success\n");

	ret = mtpr_set_no_more_track_cb(g_mtpr, __no_more_track_cb, g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_no_more_track_cb()\n");
	else
		g_print("             => mtpr_set_no_more_track_cb() success\n");
}

static void _mtpr_test_unset_track_cb()
{
	mtpr_unset_track_added_cb(g_mtpr);
	mtpr_unset_no_more_track_cb(g_mtpr);
}

static void _mtpr_test_set_encoded_audio_frame_cb()
{
	int ret = MTPR_ERROR_NONE;
	if (g_dump_data)
		audio_dump = fopen ("/tmp/audio_encoded.dump", "w+");

	ret = mtpr_set_audio_packet_cb(g_mtpr, __encoded_frame_cb, g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_audio_packet_cb()\n");
	else
		g_print("             => mtpr_set_audio_packet_cb() success\n");
}

static void _mtpr_test_unset_encoded_audio_frame_cb()
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_unset_audio_packet_cb(g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_unset_audio_packet_cb()\n");
	else
		g_print("             => mtpr_unset_audio_packet_cb() success\n");

	if (g_dump_data && audio_dump) {
		fclose (audio_dump);
		audio_dump = NULL;
	}
}

static void _mtpr_test_set_encoded_video_frame_cb()
{
	int ret = MTPR_ERROR_NONE;

	if (g_dump_data)
		video_dump = fopen ("/tmp/video_encoded.dump", "w+");

	ret = mtpr_set_video_packet_cb(g_mtpr, __encoded_frame_cb, g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_set_video_packet_cb()\n");
	else
		g_print("             => mtpr_set_video_packet_cb() success\n");
}

static void _mtpr_test_unset_encoded_video_frame_cb()
{
	int ret = MTPR_ERROR_NONE;

	ret = mtpr_unset_video_packet_cb(g_mtpr);
	if (ret != MTPR_ERROR_NONE)
		g_print("             => failed to mtpr_unset_video_packet_cb()\n");
	else
		g_print("             => mtpr_unset_video_packet_cb() success\n");

	if (g_dump_data && video_dump) {
		fclose (video_dump);
		video_dump = NULL;
	}
}

static void _mtpr_test_set_sound_stream_info(int type)
{
	sound_device_list_h device_list = NULL;
	int ret = SOUND_MANAGER_ERROR_NONE;

	if (g_stream_info) {
		g_print("stream information is already set, please destroy handle and try again\n");
		return;
	}
	if (sound_manager_create_stream_information(type, NULL, NULL, &g_stream_info)) {
		g_print("failed to create stream_information()\n");
		return;
	}
	/* In case of MEDIA_EXTERNAL_ONLY, we need to set external device manually */
	if (type == (int)SOUND_STREAM_TYPE_MEDIA_EXTERNAL_ONLY) {
		sound_device_h device = NULL;
		sound_device_type_e device_type;

		if ((ret = sound_manager_get_device_list(SOUND_DEVICE_ALL_MASK, &device_list))) {
			g_print("failed to sound_manager_get_device_list(), ret(0x%x)\n", ret);
			goto END;
		}
		while (!(ret = sound_manager_get_next_device(device_list, &device))) {
			if ((ret = sound_manager_get_device_type(device, &device_type))) {
				g_print("failed to sound_manager_get_device_type(), ret(0x%x)\n", ret);
				goto END;
			}
			if (device_type == SOUND_DEVICE_BLUETOOTH_MEDIA || device_type == SOUND_DEVICE_USB_AUDIO) {
				if ((ret = sound_manager_add_device_for_stream_routing(g_stream_info, device))) {
					g_print("failed to sound_manager_add_device_for_stream_routing(), ret(0x%x)\n", ret);
					goto END;
				}
				if ((ret = sound_manager_apply_stream_routing(g_stream_info))) {
					g_print("failed to sound_manager_apply_stream_routing(), ret(0x%x)\n", ret);
					goto END;
				}
				break;
			}
		}
		if (ret != SOUND_MANAGER_ERROR_NONE) {
			g_print("failed to sound_manager_get_next_device(), ret(0x%x)\n", ret);
			goto END;
		}
	}

	if (mtpr_set_sound_stream_info(g_mtpr, g_stream_info) != MTPR_ERROR_NONE)
		g_print("failed to set sound stream information(%p)\n", g_stream_info);
	else
		g_print("set stream information(%p) success", g_stream_info);

END:
	if (device_list)
		sound_manager_free_device_list(device_list);
	return;
}

void quit_program()
{
	if (g_mtpr != NULL) {
		_mtpr_test_stop();
		_mtpr_test_destroy();
#ifdef TIZEN_FEATURE_ESPP
		if (g_use_espp)
			_espp_deinit();
#endif
	}

	g_print("             => EXIT\n");
	elm_exit();
}

void _interpret_main_menu(char *cmd)
{
	int len = strlen(cmd);
	if (len == 1) {
		if (strncmp(cmd, "c", 1) == 0) {
			g_menu_state = CURRENT_STATUS_CONNECTION_TYPE;
		} else if (strncmp(cmd, "d", 1) == 0) {
			_mtpr_test_destroy();
		} else if (strncmp(cmd, "s", 1) == 0) {
			_mtpr_test_start();
		} else if (strncmp(cmd, "t", 1) == 0) {
			_mtpr_test_stop();
		} else if (strncmp(cmd, "a", 1) == 0) {
			g_menu_state = CURRENT_STATUS_ADD_MEDIA_SOURCE;
		} else if (strncmp(cmd, "r", 1) == 0) {
			g_menu_state = CURRENT_STATUS_REMOVE_MEDIA_SOURCE;
		} else if (strncmp(cmd, "g", 1) == 0) {
			_mtpr_test_get_state();
		} else if (strncmp(cmd, "q", 1) == 0) {
			quit_program();
		} else {
			g_print("unknown menu \n");
		}
	} else if (len == 2) {
		if (strncmp(cmd, "se", 2) == 0) {
			_mtpr_test_set_error_cb();
		} else if (strncmp(cmd, "cs", 2) == 0) {
			g_menu_state = CURRENT_STATUS_CONNECTION_SRT_MODE;
		} else if (strncmp(cmd, "cr", 2) == 0) {
			g_menu_state = CURRENT_STATUS_CONNECTION_RIST_BONDING_ADDRESS;
		} else if (strncmp(cmd, "cg", 2) == 0) {
			g_menu_state = CURRENT_STATUS_CONNECTION_GET_PARAM;
		} else if (strncmp(cmd, "ds", 2) == 0) {
			g_menu_state = CURRENT_STATUS_SET_DISPLAY;
		} else if (strncmp(cmd, "dm", 2) == 0) {
			g_menu_state = CURRENT_STATUS_SET_DISPLAY_MODE;
		} else if (strncmp(cmd, "dv", 2) == 0) {
			g_menu_state = CURRENT_STATUS_SET_DISPLAY_VISIBLE;
		} else if (strncmp(cmd, "ea", 2) == 0) {
			_mtpr_test_set_encoded_audio_frame_cb();
		} else if (strncmp(cmd, "ev", 2) == 0) {
			_mtpr_test_set_encoded_video_frame_cb();
		} else if (strncmp(cmd, "ed", 2) == 0) {
			g_dump_data = true;
		} else if (strncmp(cmd, "et", 2) == 0) {
			_mtpr_test_set_track_cb();
		} else if (strncmp(cmd, "rs", 2) == 0) {
			g_menu_state = CURRENT_STATUS_SET_SOUND_STREAM_INFO;
		} else if (strncmp(cmd, "fs", 2) == 0) {
			_mtpr_test_foreach_connection_stats();
		} else {
			g_print("unknown menu \n");
		}
	} else if (len == 3) {
		if (strncmp(cmd, "cgt", 3) == 0) {
			_mtpr_test_get_connection_type();
		} else if (strncmp(cmd, "csa", 3) == 0) {
			g_menu_state = CURRENT_STATUS_SENDER_ADDRESS;
		} else if (strncmp(cmd, "cra", 3) == 0) {
			g_menu_state = CURRENT_STATUS_RECEIVER_ADDRESS;
		} else if (strncmp(cmd, "cgs", 3) == 0) {
			_mtpr_test_get_sender_address();
		} else if (strncmp(cmd, "cgr", 3) == 0) {
			_mtpr_test_get_receiver_address();
#ifdef TIZEN_FEATURE_ESPP
		} else if (strncmp(cmd, "esp", 3) == 0) {
			g_use_espp = true;
			_espp_init();
#endif
		} else if (strncmp(cmd, "esb", 3) == 0) {
			g_menu_state = CURRENT_STATUS_ENCODING_BITRATE;
		} else if (strncmp(cmd, "egb", 3) == 0) {
			_mtpr_get_encoding_bitrate();
		} else if (strncmp(cmd, "ssr", 3) == 0) {
			g_menu_state = CURRENT_STATUS_SOURCE_VIDEO_RESOLUTION;
		} else if (strncmp(cmd, "sgr", 3) == 0) {
			_mtpr_media_source_get_video_resolution();
		} else if (strncmp(cmd, "ssf", 3) == 0) {
			g_menu_state = CURRENT_STATUS_SOURCE_VIDEO_FRAMERATE;
		} else if (strncmp(cmd, "sgf", 3) == 0) {
			_mtpr_media_source_get_video_framerate();
		} else if (strncmp(cmd, "ssc", 3) == 0) {
			g_menu_state = CURRENT_STATUS_SOURCE_AUDIO_CHANNEL;
		} else if (strncmp(cmd, "sgc", 3) == 0) {
			_mtpr_media_source_get_audio_channel();
		} else if (strncmp(cmd, "sss", 3) == 0) {
			g_menu_state = CURRENT_STATUS_SOURCE_AUDIO_SAMPLERATE;
		} else if (strncmp(cmd, "sgs", 3) == 0) {
			_mtpr_media_source_get_audio_samplerate();
		} else if (strncmp(cmd, "sst", 3) == 0) {
			g_menu_state = CURRENT_STATUS_SOURCE_AUDIO_FORMAT;
		} else if (strncmp(cmd, "sgt", 3) == 0) {
			_mtpr_media_source_get_audio_format();
		} else {
			g_print("unknown menu \n");
		}
	} else {
		g_print("unknown menu \n");
	}
}

void display_sub_basic()
{
	g_print("\n");
	g_print("=========================================================================================\n");
	g_print("                Media Transporter Test (press q to quit) \n");
	g_print("-----------------------------------------------------------------------------------------\n");

	g_print("c. Create\t");
	g_print("d. Destroy\n");
	g_print("se. Set error callback\t");
	g_print("s. Start\t");
	g_print("t. Stop\n");
	g_print("g. Get state\n\n");
#ifdef TIZEN_FEATURE_ESPP
	g_print("-- << render with ESPP >> ----------------------------------------------------------------\n");
	g_print("esp. use espp for render\n\n");
#endif
	g_print("-- << Sender source >> ------------------------------------------------------------------\n");
	g_print("a. Add media source\t");
	g_print("r. Remove media source\n\n");

	g_print("-- << Connection Info >> ----------------------------------------------------------------\n");
	g_print("csa. set sender address\t\t");
	g_print("cra. set receiver address\n");
	g_print("cgs. get sender address\t\t");
	g_print("cgr. get receiver address\n");
	g_print("cs. set SRT params\t\t");
	g_print("cr. set RIST params\n");
	g_print("cgt. get connection type\t");
	g_print("cg. get connection params\n\n");

	g_print("-- << Source Info >> ----------------------------------------------------------------\n");
	g_print("ssr. set video resolution\t");
	g_print("sgr. get video resolution\n");
	g_print("ssf. set video framerate\t");
	g_print("sgf. get video framerate\n");
	g_print("ssc. set audio channel\t\t");
	g_print("sgc. get audio channel\n");
	g_print("sss. set audio samplerate\t");
	g_print("sgs. get audio samplerate\n");
	g_print("sst. set audio format\t\t");
	g_print("sgt. get audio format\n\n");

	g_print("-- << Encoding Info >> ----------------------------------------------------------------\n");
	g_print("esb. set encoding bitrate\t");
	g_print("egb. get encoding bitrate\n\n");

	g_print("-- << Receiver sink >> ------------------------------------------------------------------\n");
	g_print("ds. set display \t");
	g_print("dm. set display mode \t");
	g_print("dv. set display visible \n");
	g_print("rs. set sound stream info \t");
	g_print("ed. dump frame data \n");
	g_print("ea. set audio frame cb \t");
	g_print("ev. set video frame cb \t");
	g_print("et. set track added & no more track cb \n\n");

	g_print("-- << Connection Stats Info >> ----------------------------------------------------------------\n");
	g_print("fs. foreach stats\n");

	g_print("=========================================================================================\n");
}

static void displaymenu()
{
	if (g_menu_state == CURRENT_STATUS_MAINMENU) {
		display_sub_basic();
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_TYPE) {
		g_print("*** Input connection type.\n\
    (0:RIST_SENDER, 1:RIST_RECEIVER, 2:SRT_SENDER, 3:SRT_RECEIVER, 4:RTSP_SENDER, 5:RTS_RECEIVER, 6:RTSP_SENDER_TO_SERVER)\n");
	} else if (g_menu_state == CURRENT_STATUS_SENDER_ADDRESS) {
		g_print("*** Input sender address:\n");
	} else if (g_menu_state == CURRENT_STATUS_RECEIVER_ADDRESS) {
		g_print("*** Input receiver address:\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_SRT_MODE) {
		g_print("*** Input SRT mode:\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_SRT_STREAMID) {
		g_print("*** Input SRT streamid:\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_SRT_PASSPHRASE) {
		g_print("*** Input SRT passphrase:\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_SRT_PBKEYLEN) {
		g_print("*** Input SRT crypto key len (0, 16, 24, 32):\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_RIST_BONDING_ADDRESS) {
		g_print("*** Input RIST bonding address(Comma(,) separated)\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_RIST_MAX_RTCP_BANDWIDTH) {
		g_print("*** Input RIST max rtcp bandwidth (0 ~ 0.05)(default: 0.05)\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_RIST_MIN_RTCP_INTERVAL) {
		g_print("*** Input RIST min RTCP interval (0 ~ 100ms)(default:100)\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_RIST_SENDER_BUFFER) {
		g_print("*** Input RIST sender buffer size (default:1200)\n");
	} else if (g_menu_state == CURRENT_STATUS_CONNECTION_GET_PARAM) {
		g_print("*** Input connection param key\n");
	} else if (g_menu_state == CURRENT_STATUS_ADD_MEDIA_SOURCE) {
		g_print("*** Input media source type.(1:camera, 2:mic, 3:videotest, 4:audiotest, 5:mediapacket(camera))\n");
	} else if (g_menu_state == CURRENT_STATUS_SOURCE_VIDEO_RESOLUTION) {
		g_print("*** Input source video resolution(width, height)\n");
	} else if (g_menu_state == CURRENT_STATUS_SOURCE_VIDEO_FRAMERATE) {
		g_print("*** Input source video framerate\n");
	} else if (g_menu_state == CURRENT_STATUS_SOURCE_AUDIO_CHANNEL) {
		g_print("*** Input source audio channel\n");
	} else if (g_menu_state == CURRENT_STATUS_SOURCE_AUDIO_SAMPLERATE) {
		g_print("*** Input source audio rate\n");
	} else if (g_menu_state == CURRENT_STATUS_SOURCE_AUDIO_FORMAT) {
		g_print("*** Input source audio format\n");
		g_print("   (1.S16LE, 2.S24LE, 3.S32LE, 4.S16BE, 5.S24BE, 6.S32BE, 7.F32LE\n   8.F32BE, 9.U16LE, 10.U24LE, 11.U32LE, 12.U16BE, 13.U24BE, 14.U32BE)\n");
	} else if (g_menu_state == CURRENT_STATUS_ENCODING_BITRATE) {
		g_print("*** Input encoding bitrate: (source_id, bitrate(bits/s)\n");
	} else if (g_menu_state == CURRENT_STATUS_REMOVE_MEDIA_SOURCE) {
		g_print("*** Input media source id to remove.\n");
	} else if (g_menu_state == CURRENT_STATUS_SET_DISPLAY) {
		g_print("*** Input display surface type. (0:overlay, 1:evas)\n");
	} else if (g_menu_state == CURRENT_STATUS_SET_DISPLAY_MODE) {
		g_print("*** Input display surface type. (0:Letter box, 1:Origin size, 2:Full mode)\n");
	} else if (g_menu_state == CURRENT_STATUS_SET_DISPLAY_VISIBLE) {
		g_print("*** Input display surface type. (0:invisible, 1:visible)\n");
	} else if (g_menu_state == CURRENT_STATUS_SET_SOUND_STREAM_INFO) {
		g_print("*** input sound stream type.(0:MEDIA 1:SYSTEM 2:ALARM 3:NOTIFICATION 4:EMERGENCY 5:VOICE_INFORMATION 9:MEDIA_EXT_ONLY)\n");
	} else {
		g_print("*** Unknown status.\n");
		quit_program();
	}
	g_print(" >>> ");
}

gboolean timeout_menu_display(void *data)
{
	displaymenu();
	return FALSE;
}

gboolean timeout_quit_program(void *data)
{
	quit_program();
	return FALSE;
}

void reset_menu_state(void)
{
	g_menu_state = CURRENT_STATUS_MAINMENU;
}

static void interpret(char *cmd)
{
	int value = 0;

	switch (g_menu_state) {
	case CURRENT_STATUS_MAINMENU:
		_interpret_main_menu(cmd);
		break;
	case CURRENT_STATUS_CONNECTION_TYPE: {
		value = atoi(cmd);
		_mtpr_test_create(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SENDER_ADDRESS: {
		_mtpr_test_set_sender_address(cmd);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_RECEIVER_ADDRESS: {
		_mtpr_test_set_receiver_address(cmd);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_CONNECTION_SRT_MODE: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_SRT_MODE, cmd);
		g_menu_state = CURRENT_STATUS_CONNECTION_SRT_STREAMID;
		break;
	}
	case CURRENT_STATUS_CONNECTION_SRT_STREAMID: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_SRT_STREAMID, cmd);
		g_menu_state = CURRENT_STATUS_CONNECTION_SRT_PASSPHRASE;
		break;
	}
	case CURRENT_STATUS_CONNECTION_SRT_PASSPHRASE: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, cmd);
		g_menu_state = CURRENT_STATUS_CONNECTION_SRT_PBKEYLEN;
		break;
	}
	case CURRENT_STATUS_CONNECTION_SRT_PBKEYLEN: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, cmd);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_CONNECTION_RIST_BONDING_ADDRESS: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, cmd);
		g_menu_state = CURRENT_STATUS_CONNECTION_RIST_MAX_RTCP_BANDWIDTH;
		break;
	}
	case CURRENT_STATUS_CONNECTION_RIST_MAX_RTCP_BANDWIDTH: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, cmd);
		g_menu_state = CURRENT_STATUS_CONNECTION_RIST_MIN_RTCP_INTERVAL;
		break;
	}
	case CURRENT_STATUS_CONNECTION_RIST_MIN_RTCP_INTERVAL: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, cmd);
		g_menu_state = CURRENT_STATUS_CONNECTION_RIST_SENDER_BUFFER;
		break;
	}
	case CURRENT_STATUS_CONNECTION_RIST_SENDER_BUFFER: {
		if (strlen(cmd) > 0)
			_mtpr_test_set_connection_param(MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, cmd);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_CONNECTION_GET_PARAM: {
		if (strlen(cmd) > 0)
			_mtpr_test_get_connection_param(cmd);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_ADD_MEDIA_SOURCE: {
		value = atoi(cmd);
		if (value < 1) {
			reset_menu_state();
			break;
		}
		_mtpr_test_add_media_source((mtpr_source_type_e)(value - 1));
		if (value == 5) {
			_mtpr_test_camera_packet_src_create(g_mtpr, g_video_source_id);
			g_use_camera_for_packet = true;
		}
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SOURCE_VIDEO_RESOLUTION: {
		static int width = 0;
		static int height = 0;
		static int cnt = 0;
		switch (cnt) {
		case 0:
			value = atoi(cmd);
			width = value;
			cnt++;
			break;
		case 1:
			value = atoi(cmd);
			height = value;
			_mtpr_media_source_set_video_resolution(width, height);
			cnt = 0;
			reset_menu_state();
			break;
		default:
			break;
		}
		break;
	}
	case CURRENT_STATUS_SOURCE_VIDEO_FRAMERATE: {
		value = atoi(cmd);
		_mtpr_media_source_set_video_framerate(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SOURCE_AUDIO_CHANNEL: {
		value = atoi(cmd);
		_mtpr_media_source_set_audio_channel(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SOURCE_AUDIO_SAMPLERATE: {
		value = atoi(cmd);
		_mtpr_media_source_set_audio_samplerate(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SOURCE_AUDIO_FORMAT: {
		value = atoi(cmd);
		_mtpr_media_source_set_audio_format(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_REMOVE_MEDIA_SOURCE: {
		value = atoi(cmd);
		_mtpr_test_remove_media_source(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SET_DISPLAY:{
		value = atoi(cmd);
		_mtpr_test_set_display(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SET_DISPLAY_MODE:{
		value = atoi(cmd);
		_mtpr_test_set_display_mode(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_SET_DISPLAY_VISIBLE:{
		value = atoi(cmd);
		_mtpr_test_set_display_visible(value);
		reset_menu_state();
		break;
	}
	case CURRENT_STATUS_ENCODING_BITRATE:{
		static int id = 0;
		static int cnt = 0;
		switch (cnt) {
		case 0:
			value = atoi(cmd);
			id = value;
			cnt++;
			break;
		case 1:
			value = atoi(cmd);
			_mtpr_set_encoding_bitrate(id, value);
			cnt = 0;
			reset_menu_state();
			break;
		default:
			break;
		}
		break;
	}
	case CURRENT_STATUS_SET_SOUND_STREAM_INFO:{
		value = atoi(cmd);
		_mtpr_test_set_sound_stream_info(value);
		reset_menu_state();
		break;
	}
	default:
		break;
	}

	g_timeout_add(100, timeout_menu_display, 0);
}


static gboolean input(GIOChannel *channel, GIOCondition condition, gpointer data)
{
	gchar buf[MAX_STRING_LEN];
	gsize read;
	GIOStatus status;

	status = g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, NULL);
	if (status != G_IO_STATUS_NORMAL) {
		g_printerr("failed to g_io_channel_read_chars(), status[%d]", status);
		return TRUE;
	}

	buf[read] = '\0';
	g_strstrip(buf);
	interpret(buf);

	return TRUE;
}

int main(int argc, char *argv[])
{
	GIOChannel *stdin_channel;
	stdin_channel = g_io_channel_unix_new(0);
	g_io_channel_set_flags(stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
	g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);

	displaymenu();
	memset(&g_ad, 0x0, sizeof(appdata));
	ops.data = &g_ad;

	return appcore_efl_main(PACKAGE, &argc, &argv, &ops);
}