path: root/src/MediaTransporterReceiver.cpp

/**
 * 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 "MediaTransporterBase.h"
#include "MediaTransporterException.h"
#include "MediaTransporterReceiver.h"
#include "MediaTransporterGst.h"
#include "MediaTransporterLog.h"
#include "MediaTransporterUtil.h"
#include "MediaTransporterParseIni.h"

#include <media_packet_internal.h>
#include <sound_manager_internal.h>
#include <pulse/proplist.h>
#include <sstream>

using namespace tizen_media_transporter;

void MediaTransporterReceiver::setTrackAddedCallback(InvokablePtr callback)
{
	_trackAddedCallback = std::move(callback);
}

void MediaTransporterReceiver::unsetTrackAddedCallback()
{
	_trackAddedCallback = nullptr;
}

void MediaTransporterReceiver::setNoMoreTrackCallback(InvokablePtr callback)
{
	_noMoreTrackCallback = std::move(callback);
}

void MediaTransporterReceiver::unsetNoMoreTrackCallback()
{
	_noMoreTrackCallback = nullptr;
}

void MediaTransporterReceiver::setVideoPacketCallback(InvokablePtr callback)
{
	_videoCallback._callback = std::move(callback);
}

void MediaTransporterReceiver::setAudioPacketCallback(InvokablePtr callback)
{
	_audioCallback._callback = std::move(callback);
}

void MediaTransporterReceiver::unsetVideoPacketCallback()
{
	_videoCallback._callback = nullptr;
}

void MediaTransporterReceiver::unsetAudioPacketCallback()
{
	_audioCallback._callback = nullptr;
}

static media_format_mimetype_e _getMediaFormatMimeType(const std::string& mime)
{
	if (mime.find(gst::MEDIA_TYPE_AUDIO_AAC) != std::string::npos)
		return MEDIA_FORMAT_AAC;
	else if (mime.find(gst::MEDIA_TYPE_AUDIO_OPUS) != std::string::npos)
		return MEDIA_FORMAT_OPUS;
	else if (mime.find(gst::MEDIA_TYPE_AUDIO_VORBIS) != std::string::npos)
		return MEDIA_FORMAT_VORBIS;
	else if (mime.find(gst::MEDIA_TYPE_VIDEO_MPEG) != std::string::npos)
		return MEDIA_FORMAT_MPEG4_SP; /* FIXME: need to check format , MEDIA_FORMAT_MPEG4_ASP */
	else if (mime.find(gst::MEDIA_TYPE_VIDEO_VP8) != std::string::npos)
		return MEDIA_FORMAT_VP8;
	else if (mime.find(gst::MEDIA_TYPE_VIDEO_VP9) != std::string::npos)
		return MEDIA_FORMAT_VP9;
	else if (mime.find(gst::MEDIA_TYPE_VIDEO_H264) != std::string::npos)
		return MEDIA_FORMAT_H264_HP;
	else if (mime.find(gst::MEDIA_TYPE_VIDEO_JPEG) != std::string::npos)
		return MEDIA_FORMAT_MJPEG;

	LOG_ERROR("not supported mime[%s]", mime.c_str());
	return MEDIA_FORMAT_MAX;
}

static media_format_h _makeMediaFormat(GstPad* pad)
{
	int ret;

	RET_VAL_IF(!pad, NULL, "pad is NULL");

	media_format_h format;
	RET_VAL_IF(media_format_create(&format) != MEDIA_FORMAT_ERROR_NONE, NULL,
			"failed to media_format_create()");

	GstCaps* caps = gst_pad_get_current_caps(pad);
	GstStructure* structure = gst_caps_get_structure(caps, 0);
	std::string mime = gst_structure_get_name(structure);

	media_format_mimetype_e mimetype = _getMediaFormatMimeType(mime);
	LOG_INFO("media format mimetype[0x%x]", mimetype);

	if (mimetype & MEDIA_FORMAT_VIDEO) {
		gint width = 0;
		gint height = 0;
		gint fps_n = 0;
		gint fps_d = 0;

		ret = media_format_set_video_mime(format, mimetype);
		if (ret != MEDIA_FORMAT_ERROR_NONE) {
			LOG_ERROR("failed to media_format_set_video_mime()");
			goto ERROR;
		}

		/* FIXME: We also need to get width/height in case of H26x with not this way. */
		gst_structure_get_int(structure, "width", &width);
		gst_structure_get_int(structure, "height", &height);
		if (width > 0 && height > 0) {
			ret |= media_format_set_video_width(format, width);
			ret |= media_format_set_video_height(format, height);
			if (ret != MEDIA_FORMAT_ERROR_NONE) {
				LOG_ERROR("failed to media_format_set_video_width/height()");
				goto ERROR;
			}
		}

		gst_structure_get_fraction(structure, "framerate", &fps_n, &fps_d);
		if (fps_n > 0 && fps_d > 0)
			media_format_set_video_frame_rate(format, fps_n / fps_d);
	} else if (mimetype & MEDIA_FORMAT_AUDIO) {
		gint channels = 0;
		gint rate = 0;

		ret = media_format_set_audio_mime(format, mimetype);
		if (ret != MEDIA_FORMAT_ERROR_NONE) {
			LOG_ERROR("failed to media_format_set_audio_mime()");
			goto ERROR;
		}

		gst_structure_get_int(structure, "channels", &channels);
		gst_structure_get_int(structure, "rate", &rate);
		if (channels > 0 && rate > 0) {
			ret |= media_format_set_audio_channel(format, channels);
			ret |= media_format_set_audio_samplerate(format, rate);
			if (ret != MEDIA_FORMAT_ERROR_NONE) {
				LOG_ERROR("failed to media_format_set_audio_channel/samplerate()");
				goto ERROR;
			}
		}
	} else {
		LOG_ERROR("Error on _getMediaFormatMimeType");
	}

	gst_caps_unref(caps);
	return format;

ERROR:
	gst_caps_unref(caps);
	media_format_unref(format);
	return NULL;
}

static void _setCodecDataIfExist(media_packet_h packet, GstPad* pad)
{
	GstCaps* caps = gst_pad_get_current_caps(pad);

	const GValue* codec_data_value = gst_structure_get_value(gst_caps_get_structure(caps, 0), "codec_data");
	if (codec_data_value) {
		GstBuffer* codec_data = gst_value_get_buffer(codec_data_value);

		GstMapInfo buff_info;
		gst_buffer_map(codec_data, &buff_info, GST_MAP_READ);

		int ret = media_packet_set_codec_data(packet, buff_info.data, buff_info.size);
		if (ret != MEDIA_PACKET_ERROR_NONE)
			LOG_ERROR("failed to media_packet_set_codec_data()");
		else
			LOG_VERBOSE("codec_data[%p, size:%" G_GSIZE_FORMAT "] is set to the media packet[%p]",
					buff_info.data, buff_info.size, packet);

		gst_buffer_unmap(codec_data, &buff_info);
	}

	gst_caps_unref(caps);
}

/* userData should not be handle */
static int __mediaPacketFinalizeCallBack(media_packet_h packet, int error_code, void* userData)
{
	GstBuffer* buffer = NULL;
	if (media_packet_get_extra(packet, (void**)&buffer) == MEDIA_PACKET_ERROR_NONE)
		gst_buffer_unref(buffer);

	LOG_VERBOSE("this[%p], packet[%p], buffer[%p]", userData, packet, buffer);

	return MEDIA_PACKET_FINALIZE;
}

media_packet_h MediaTransporterReceiver::_makeMediaPacket(GstBuffer* buffer, GstPad* pad, media_format_h* format)
{
	int ret;
	media_packet_h packet = NULL;
	GstMapInfo info = GST_MAP_INFO_INIT;

	RET_VAL_IF(!buffer, NULL, "buffer is NULL");
	RET_VAL_IF(!pad, NULL, "pad is NULL");

	if (!(*format))
		*format = _makeMediaFormat(pad);

	gst_buffer_ref(buffer);

	if (!gst_buffer_map(buffer, &info, GST_MAP_READ)) {
		LOG_ERROR("failed to gst_buffer_map()");
		goto ERROR;
	}

	ret = media_packet_create_from_external_memory(*format, info.data, gst_buffer_get_size(buffer), __mediaPacketFinalizeCallBack, nullptr, &packet);
	gst_buffer_unmap(buffer, &info);
	if (ret != MEDIA_PACKET_ERROR_NONE) {
		LOG_ERROR("failed to media_packet_create_from_external_memory()");
		goto ERROR;
	}

	ret |= media_packet_set_pts(packet, GST_BUFFER_PTS(buffer));
	ret |= media_packet_set_dts(packet, GST_BUFFER_DTS(buffer));
	ret |= media_packet_set_duration(packet, GST_BUFFER_DURATION(buffer));

	/* FIXME: We put the gstbuffer to extra field of media packet. It does not guarantee the validity of the gstbuffer
	 * after destroying this media packet. Currently, the gstbuffer must be used before destroying the packet. */
	ret |= media_packet_set_extra(packet, static_cast<void*>(buffer));
	if (ret != MEDIA_PACKET_ERROR_NONE) {
		LOG_ERROR("failed to media_packet_set_*()");
		goto ERROR;
	}

	if (!GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT)) {
		/* key frame */
		_setCodecDataIfExist(packet, pad);
		// if (ret != MTPR_ERROR_NONE)
		// 	goto ERROR;
	}

	LOG_VERBOSE("packet[%p], buffer[%p, pts:%" G_GUINT64_FORMAT ", dts:%" G_GUINT64_FORMAT ", duration:%" G_GUINT64_FORMAT "]",
		packet, buffer, GST_BUFFER_PTS(buffer), GST_BUFFER_DTS(buffer), GST_BUFFER_DURATION(buffer));

	return packet;

ERROR:
	if (packet)
		media_packet_destroy(packet);
	gst_buffer_unref(buffer);
	media_format_unref(*format);
	*format = NULL;

	return NULL;
}

static unsigned int _get_id_from_name(std::string name)
{
	auto pos = name.rfind("_");
	return strtoul(name.substr(pos + 1).c_str(), NULL, 10);
}

void MediaTransporterReceiver::_streamAddedCallback(GstPad* pad, gpointer data)
{
	mtprMediaType type;
	auto mtprReceiver = static_cast<MediaTransporterReceiver*>(data);
	RET_IF(!mtprReceiver, "mtprReceiver is NULL");

	auto id = _get_id_from_name(GST_PAD_NAME(pad));

	std::string mediaType = gst::_getMimeTypeFromPad(pad);
	if (mediaType.find("audio") != std::string::npos) {
		type = MTPR_MEDIA_TYPE_AUDIO;
	} else if (mediaType.find("video") != std::string::npos) {
		type = MTPR_MEDIA_TYPE_VIDEO;
	} else {
		LOG_INFO("not supported track %s", mediaType.c_str());
		return;
	}

	LOG_INFO("pad [%p][%s:%s], type %s, id %u", pad, GST_DEBUG_PAD_NAME(pad), mediaType.c_str(), id);

	if (mtprReceiver->_trackAddedCallback)
		mtprReceiver->_trackAddedCallback->invoke(VariantData{type}, VariantData{id});
}

void MediaTransporterReceiver::_noMoreStreamCallback(gpointer data)
{
	auto mtprReceiver = static_cast<MediaTransporterReceiver*>(data);
	RET_IF(!mtprReceiver, "mtprReceiver is NULL");

	if (mtprReceiver->_noMoreTrackCallback)
		mtprReceiver->_noMoreTrackCallback->invoke();
}

/* handoff signal handler */
void MediaTransporterReceiver::_encodedAudioStreamCallback(GstElement* object, GstBuffer* buffer, GstPad* pad, gpointer data)
{
	auto mtprReceiver = static_cast<MediaTransporterReceiver*>(data);
	RET_IF(!mtprReceiver, "mtprReceiver is NULL");

	LOG_VERBOSE("object[%p] buffer[%p] pad[%p]", object, buffer, pad);

	// FIXME : extract common method for callback invoke

	auto id = _get_id_from_name(GST_ELEMENT_NAME(object));
	media_packet_h packet = _makeMediaPacket(buffer, pad, &mtprReceiver->_audioCallback.mediaFormat);
	RET_IF(!packet, "packet is NULL");

	if (mtprReceiver->_audioCallback._callback)
		mtprReceiver->_audioCallback._callback->invoke(VariantData{id}, VariantData{packet});
}

void MediaTransporterReceiver::_encodedVideoStreamCallback(GstElement* object, GstBuffer* buffer, GstPad* pad, gpointer data)
{
	auto mtprReceiver = static_cast<MediaTransporterReceiver*>(data);
	RET_IF(!mtprReceiver, "mtprReceiver is NULL");

	LOG_VERBOSE("object[%p] buffer[%p] pad[%p]", object, buffer, pad);

	auto id = _get_id_from_name(GST_ELEMENT_NAME(object));
	media_packet_h packet = _makeMediaPacket(buffer, pad, &mtprReceiver->_videoCallback.mediaFormat);
	RET_IF(!packet, "packet is NULL");

	if (mtprReceiver->_videoCallback._callback)
		mtprReceiver->_videoCallback._callback->invoke(VariantData{id}, VariantData{packet});
}

void MediaTransporterReceiver::_buildForwardingSink(gst::GstElements& elements, GstPad* pad, GCallback callback)
{
	GstElement* capsfilter = gst::_createElement(gst::DEFAULT_ELEMENT_CAPSFILTER);
	GstCaps* sink_caps = gst::_makeCapsForCapsfilter(pad);
	if (sink_caps) {
		gst::_printCaps(sink_caps, "capsfilter");
		g_object_set(G_OBJECT(capsfilter), "caps", sink_caps, NULL);
		gst_caps_unref(sink_caps);
	}
	elements.push_back(capsfilter);

	auto id = _get_id_from_name(GST_PAD_NAME(pad));
	std::string name = "fakesink_" + std::to_string(id);
	LOG_INFO("pad %s:%s, sink name = %s", GST_DEBUG_PAD_NAME(pad), name.c_str());

	GstElement* fakesink = gst::_createElement(gst::DEFAULT_ELEMENT_FAKESINK, name);
	g_object_set(G_OBJECT(fakesink), "signal-handoffs", TRUE, NULL);
	elements.push_back(fakesink);

	gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(fakesink), "handoff", callback, this);
}

int MediaTransporterReceiver::_buildForwardingElements(GstElement* demux, GstPad* pad, bool isAudio, GCallback callback)
{
	gst::GstElements elements;

	RET_VAL_IF(!demux, MTPR_ERROR_INVALID_PARAMETER, "demux element is NULL");
	RET_VAL_IF(!pad, MTPR_ERROR_INVALID_PARAMETER, "pad is NULL");

	GstElement* queue = gst::_createElement(gst::DEFAULT_ELEMENT_QUEUE);
	/* FIXME: need to check queue size */
	g_object_set(G_OBJECT(queue),
				"max-size-buffers", DEFAULT_QUEUE_MAX_SIZE_BUFFERS,
				"max-size-bytes", DEFAULT_QUEUE_MAX_SIZE_BYTES,
				"max-size-time", DEFAULT_QUEUE_MAX_SIZE_TIME,
				NULL);
	elements.push_back(queue);

    GstElement* parser = nullptr;
	std::string demuxerName = GST_ELEMENT_NAME(demux);
    if (demuxerName.find("decodebin") == std::string::npos)
		parser = gst::_createElementFromRegistry("Parser", gst_pad_get_current_caps(pad), NULL,
												MediaTransporterIni::get().general().gstExcludedElements);

	if (parser) {
		if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(parser)), "config-interval")) {
			g_object_set(G_OBJECT(parser), "config-interval", -1, NULL);
			LOG_DEBUG("[%s] set config-interval -1", GST_ELEMENT_NAME(parser) );
		}
		elements.push_back(parser);
	}

	_buildForwardingSink(elements, pad, callback);

	std::string binName = isAudio ? "forwardingAudioBin" : "forwordingVideoBin";

	GstBin* bin = GST_BIN(gst_bin_new(binName.c_str()));
	if (!bin) {
		LOG_ERROR("Failed to create bin");
		gst::_clearElements(elements);
		return MTPR_ERROR_INVALID_OPERATION;
	}

	try {
		gst::_addElementsToBin(bin, elements);
	} catch (const MediaTransporterException& e) {
		LOG_ERROR("%s", e.what());
		gst::_clearElements(elements);
		gst_object_unref(bin);
		return MTPR_ERROR_INVALID_OPERATION;
	}


	if (!gst_bin_add(GST_BIN(_gst.pipeline), GST_ELEMENT(bin))) {
		LOG_ERROR("failed to add (%s)bin into pipeline", binName.c_str());
		gst_object_unref(bin);
		return MTPR_ERROR_INVALID_OPERATION;
	}

	GstPad* sinkPad = nullptr;
	try {
		sinkPad = gst::_getGhostPadFromBin(bin, GST_ELEMENT_NAME(queue), false);
		GstPadLinkReturn res = gst_pad_link(pad, sinkPad);
		if (GST_PAD_LINK_FAILED(res)) {
			LOG_ERROR("failed to link pads, [%s:%s] - [%s:%s]",
					GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(sinkPad));
			gst_bin_remove(GST_BIN(_gst.pipeline), GST_ELEMENT(bin));
			gst_object_unref(sinkPad);
			return MTPR_ERROR_INVALID_OPERATION;
		}

		gst::_linkElements(elements);
	} catch (const MediaTransporterException& e) {
		LOG_ERROR("%s", e.what());

		gst_bin_remove(GST_BIN(_gst.pipeline), GST_ELEMENT(bin));
		gst_object_unref(sinkPad);
		if (sinkPad)
			gst_object_unref(sinkPad);

		return MTPR_ERROR_INVALID_OPERATION;
	}

	if (!gst_element_sync_state_with_parent(GST_ELEMENT(bin))) {
		LOG_ERROR("failed to sync %s state with parent", binName.c_str());
		gst_bin_remove(GST_BIN(_gst.pipeline), GST_ELEMENT(bin));
		return MTPR_ERROR_INVALID_OPERATION;
	}

	return MTPR_ERROR_NONE;
}

void MediaTransporterReceiver::_buildAudioRenderingSink(gst::GstElements& elements)
{
	if (_streamInfo.empty()) {
		LOG_WARNING("Not set streaminfo, link fakesink");
		elements.push_back(gst::_createElement(gst::DEFAULT_ELEMENT_FAKESINK));
		return;
	}

	GstElement* converter = nullptr;
	GstElement* resample = nullptr;
	GstElement* sink = nullptr;

	try {
		// display RM acquire
		converter = gst::_createElement(gst::DEFAULT_ELEMENT_AUDIOCONVERT);
		elements.push_back(converter);

		resample = gst::_createElement(gst::DEFAULT_ELEMENT_AUDIORESAMPLE);
		elements.push_back(resample);

		std::string audioSinkName = MediaTransporterIni::get().renderingSink().audioSinkElement;
		sink = gst::_createElement(audioSinkName);
		gst::_applyStreamInfo(sink, _streamInfo);
		elements.push_back(sink);
	} catch (const MediaTransporterException& e) {
		if (converter) {
			gst::_removeElement(elements, converter);
			gst_object_unref(converter);
		}
		if (resample) {
			gst::_removeElement(elements, resample);
			gst_object_unref(resample);
		}
		if (sink) {
			gst::_removeElement(elements, sink);
			gst_object_unref(sink);
		}
		throw;
	}
}

void MediaTransporterReceiver::_buildVideoRenderingSink(gst::GstElements& elements)
{
	if (!_display) {
		LOG_WARNING("Not set display, link fakesink");
		elements.push_back(gst::_createElement(gst::DEFAULT_ELEMENT_FAKESINK));
		return;
	}

	GstElement* converter = nullptr;
	GstElement* sink = nullptr;

	try {
		// display RM acquire
		_resourceManager->acquire(MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY);
		converter = gst::_createElement(gst::DEFAULT_ELEMENT_VIDEOCONVERT);
		elements.push_back(converter);
		sink = _display->videoSink();
		elements.push_back(sink);
	} catch (const MediaTransporterException& e) {
		if (converter) {
			gst::_removeElement(elements, converter);
			gst_object_unref(converter);
		}
		if (sink) {
			gst::_removeElement(elements, sink);
			gst_object_unref(sink);
		}
		throw;
	}
}

int MediaTransporterReceiver::_buildRenderingElements(GstElement* demux, GstPad* pad, bool isAudio)
{
	gst::GstElements elements;

	RET_VAL_IF(!demux, MTPR_ERROR_INVALID_PARAMETER, "demux element is NULL");
	RET_VAL_IF(!pad, MTPR_ERROR_INVALID_PARAMETER, "pad is NULL");

	GstElement* queue = gst::_createElement(gst::DEFAULT_ELEMENT_QUEUE);
	/* FIXME: need to check queue size */
	g_object_set(G_OBJECT(queue),
				"max-size-buffers", DEFAULT_QUEUE_MAX_SIZE_BUFFERS,
				"max-size-bytes", DEFAULT_QUEUE_MAX_SIZE_BYTES,
				"max-size-time", DEFAULT_QUEUE_MAX_SIZE_TIME,
				NULL);
	elements.push_back(queue);

	GstPad* srcPad = nullptr;
	GstElement* parser = nullptr;
	std::string demuxerName = GST_ELEMENT_NAME(demux);

	if (demuxerName.find("decodebin") == std::string::npos)
		parser = gst::_createElementFromRegistry("Parser", gst_pad_get_current_caps(pad), NULL,
															MediaTransporterIni::get().general().gstExcludedElements);
	if (parser) {
		if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(parser)), "config-interval")) {
			g_object_set(G_OBJECT(parser), "config-interval", -1, NULL);
			LOG_DEBUG("[%s] set config-interval -1", GST_ELEMENT_NAME(parser) );
		}
		srcPad = gst_element_get_static_pad(parser, "src");
		elements.push_back(parser);
	} else {
		srcPad = g_object_ref(pad);
	}

	GstCaps* caps = gst_pad_has_current_caps(srcPad) ? gst_pad_get_current_caps(srcPad)
			: gst_pad_query_caps(srcPad, NULL);
	GstElement* decoder = gst::_createElementFromRegistry(
			isAudio ? "Codec/Decoder/Audio" : "Codec/Decoder/Video", caps, NULL,
			MediaTransporterIni::get().general().gstExcludedElements);
	elements.push_back(decoder);
	g_object_unref(srcPad);

	if (isAudio)
		_buildAudioRenderingSink(elements);
	else
		_buildVideoRenderingSink(elements);

	std::string binName = isAudio ? "renderingAudioBin" : "renderingVideoBin";

	GstBin* bin = GST_BIN(gst_bin_new(binName.c_str()));
	if (!bin) {
		LOG_ERROR("Failed to create bin");
		gst::_clearElements(elements);
		return MTPR_ERROR_INVALID_OPERATION;
	}

	try {
		gst::_addElementsToBin(bin, elements);
	} catch (const MediaTransporterException& e) {
		LOG_ERROR("%s", e.what());
		gst::_clearElements(elements);
		gst_object_unref(bin);
		return MTPR_ERROR_INVALID_OPERATION;
	}

	if (!gst_bin_add(GST_BIN(_gst.pipeline), GST_ELEMENT(bin))) {
		LOG_ERROR("failed to add (%s)bin into pipeline", binName.c_str());
		gst_object_unref(bin);
		return MTPR_ERROR_INVALID_OPERATION;
	}

	GstPad* sinkPad = nullptr;
	try {
		sinkPad = gst::_getGhostPadFromBin(bin, GST_ELEMENT_NAME(queue), false);
		GstPadLinkReturn res = gst_pad_link(pad, sinkPad);
		if (GST_PAD_LINK_FAILED(res)) {
			LOG_ERROR("failed to link pads, [%s:%s] - [%s:%s]",
					GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(sinkPad));
			gst_bin_remove(GST_BIN(_gst.pipeline), GST_ELEMENT(bin));
			gst_object_unref(sinkPad);
			return MTPR_ERROR_INVALID_OPERATION;
		}

		gst::_linkElements(elements);
	} catch (const MediaTransporterException& e) {
		LOG_ERROR("%s", e.what());

		gst_bin_remove(GST_BIN(_gst.pipeline), GST_ELEMENT(bin));
		gst_object_unref(sinkPad);
		if (sinkPad)
			gst_object_unref(sinkPad);

		return MTPR_ERROR_INVALID_OPERATION;
	}

	if (!gst_element_sync_state_with_parent(GST_ELEMENT(bin))) {
		LOG_ERROR("failed to sync %s state with parent", binName.c_str());
		gst_bin_remove(GST_BIN(_gst.pipeline), GST_ELEMENT(bin));
		return MTPR_ERROR_INVALID_OPERATION;
	}

	return MTPR_ERROR_NONE;
}

void MediaTransporterReceiver::setDisplay(std::shared_ptr<MediaTransporterDisplay> display)
{
	_display = display;
}

void MediaTransporterReceiver::setSoundStreamInfo(sound_stream_info_h streamInfo)
{
	char *stream_type;
	int stream_index;
	// bool available = false;

	RET_IF(!streamInfo, "streamInfo is NULL");

	sound_manager_get_type_from_stream_information(streamInfo, &stream_type);
	sound_manager_get_index_from_stream_information(streamInfo, &stream_index);

	/* FIXEME: need to add NATIVE_API_MEDIATRANSPORTER in sound-manager */
	// ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_MEDIATRANSPORTER, &available);
	// if (ret != SOUND_MANAGER_ERROR_NONE) {
	// 	LOG_ERROR("failed to sound_manager_is_available_stream_information()");
	// 	return MTPR_ERROR_INVALID_OPERATION;
	// }

	// if (!available) {
	// 	LOG_ERROR("this stream info[%p, type:%s, index:%d] is not allowed to this framework", stream_info, stream_type, stream_index);
	// 	return MTPR_ERROR_INVALID_PARAMETER;
	// }

	RET_IF(!stream_type, "stream_type is NULL");

	LOG_INFO("stream_info[%p, type:%s, index:%d",
		streamInfo, stream_type, stream_index);

	std::ostringstream stringStream;
	stringStream << "props," << PA_PROP_MEDIA_ROLE << "=" <<
		stream_type << ", " << PA_PROP_MEDIA_PARENT_ID << "=" << stream_index;

	_streamInfo = stringStream.str();
}

bool MediaTransporterReceiver::_isSupportedMediaType(std::string mediaType)
{
	if ((mediaType.find("audio") == std::string::npos) &&
			(mediaType.find("video") == std::string::npos)) {
		LOG_ERROR("not supported media type [%s]", mediaType.c_str());
		return false;
	}

	return true;
}

bool MediaTransporterReceiver::_isAudioMediaType(std::string mediaType)
{
	return mediaType.find("audio") != std::string::npos;
}