#include "MediaTransporterSender.h"
#include "MediaTransporterGst.h"
-constexpr size_t DEFAULT_MAX_RTCP_BANDWIDTH = 0.05;
-constexpr size_t DEFAULT_MIN_RTCP_INTERVAL = 100;
-constexpr size_t DEFAULT_SEND_BUFFER = 1200;
+constexpr double DEFAULT_MAX_RTCP_BANDWIDTH = 0.05;
+constexpr unsigned int DEFAULT_MIN_RTCP_INTERVAL = 100;
+constexpr unsigned int DEFAULT_SEND_BUFFER = 1200;
namespace tizen_media_transporter {
std::string _senderAddress; // rtsp server ip, port + mount path
+ unsigned int _sourceId { 0 };
std::string _rtspMountPoint;
void* _rtspServer { nullptr };
};
* @brief Definition for password parameter of SRT.
* @details The password for the encrypted transmission of SRT.\n
* The number of characters must be 10 to 79.
+ * NULL input is allowed to clear the password.
* @since_tizen 7.0
* @remarks This is write only parameter.
* @see mtpr_set_connection_param()
Name: capi-media-transporter
Summary: A Media Transporter library in Tizen Native API
-Version: 0.0.13
+Version: 1.0.0
Release: 0
Group: Multimedia/API
License: Apache-2.0
mkdir -p %{buildroot}%{_bindir}
mkdir -p %{buildroot}%{_hal_datadir}
cp test/mtpr_test %{buildroot}%{_bindir}
-cp test/mtpr_rtsp_test %{buildroot}%{_bindir}
%make_install
mkdir -p %{buildroot}%{_hal_sysconfdir}/multimedia
%files tool
%defattr(-,root,root,-)
%{_bindir}/mtpr_test
-%{_bindir}/mtpr_rtsp_test
%if 0%{?gtests:1}
%{_bindir}/mtpr_ut
%endif
{
RET_ERR_IF_INVALID_INSTANCE(mtpr);
RET_ERR_IF_NULL_ARG(param_name);
- RET_ERR_IF_NULL_ARG(param_value);
try {
auto handle = static_cast<media_transporter_s*>(mtpr);
assert(handle->base);
- handle->base->setConnection(param_name, param_value);
+
+ /* param value could be null depends on the param spec. */
+ handle->base->setConnection(param_name, param_value ? param_value : "");
} catch (const MediaTransporterException& e) {
LOG_ERROR("Failed to set connection param!!! : %s", e.what());
return e.error();
void MediaTransporterBase::stopInternal()
{
try {
- stopPipeline();
- _state = MTPR_STATE_IDLE;
+ if (_state != MTPR_STATE_IDLE) {
+ stopPipeline();
+ _state = MTPR_STATE_IDLE;
+ }
} catch (const MediaTransporterException& e) {
LOG_ERROR("%s", e.what());
throw;
connectionParam->streamId = value;
} else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE) == 0) {
- if (value.length() < SRT_MIN_PASSPHRASE || value.length() > SRT_MAX_PASSPHRASE)
+ if (!value.empty() && (value.length() < SRT_MIN_PASSPHRASE || value.length() > SRT_MAX_PASSPHRASE))
throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "wrong passphrase");
connectionParam->passPhrase = value;
} else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN) == 0) {
MediaTransporterIni::get().general().timeout);
}
-void MediaTransporterReceiverSrt::setConnection(std::string name, std::string string_val)
+void MediaTransporterReceiverSrt::setConnection(std::string name, std::string val)
{
- setConnectionParam(name, string_val, &_connectionParam);
+ setConnectionParam(name, val, &_connectionParam);
}
std::string MediaTransporterReceiverSrt::getConnection(std::string name)
#include "MediaTransporterUtil.h"
#include "MediaTransporterParseIni.h"
-constexpr size_t MIN_RTCP_BANDWIDTH_PARAM = 0;
-constexpr size_t MAX_RTCP_BANDWIDTH_PARAM = 0.05;
-constexpr size_t MAX_RTCP_INTERVAL_PARAM = 100;
+constexpr double MIN_RTCP_BANDWIDTH_PARAM = 0;
+constexpr double MAX_RTCP_BANDWIDTH_PARAM = 0.05;
+constexpr unsigned int MAX_RTCP_INTERVAL_PARAM = 100;
using namespace tizen_media_transporter;
MediaTransporterIni::get().general().timeout);
}
-void MediaTransporterSenderRist::setConnection(std::string name, std::string string_val)
+void MediaTransporterSenderRist::setConnection(std::string name, std::string val)
{
- SECURE_LOG_INFO("%s : %s", name.c_str(), string_val.c_str());
+ SECURE_LOG_INFO("%s : %s", name.c_str(), val.c_str());
try {
if (name == MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS) {
- _connectionParam.bondingAddress = string_val; /* FIXME : need to consider with _receiverAddress */
+ _connectionParam.bondingAddress = val; /* FIXME : need to consider with _receiverAddress */
} else if (name == MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH) {
size_t size;
- double val = stod(string_val, &size);
- if ((string_val.size() != size) ||
- (val < MIN_RTCP_BANDWIDTH_PARAM) || (val > MAX_RTCP_BANDWIDTH_PARAM)) {
- LOG_ERROR("invalid rtcp bandwidth value %s", string_val.c_str());
+ double maxRtcpBandwidth = stod(val, &size);
+ if ((val.size() != size) ||
+ (maxRtcpBandwidth < MIN_RTCP_BANDWIDTH_PARAM) || (maxRtcpBandwidth > MAX_RTCP_BANDWIDTH_PARAM)) {
+ LOG_ERROR("invalid rtcp bandwidth value %s", val.c_str());
throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid rtcp bandwidth value");
}
- _connectionParam.maxRtcpBandwidth = val;
+ _connectionParam.maxRtcpBandwidth = maxRtcpBandwidth;
} else if (name == MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL) {
size_t size;
- unsigned int val = stoul(string_val, &size);
- if ((string_val.size() != size) || (val > MAX_RTCP_INTERVAL_PARAM)) {
- LOG_ERROR("invalid rtcp interval value %s", string_val.c_str());
+ unsigned int minRtcpInterval = stoul(val, &size);
+ if ((val.size() != size) || (minRtcpInterval > MAX_RTCP_INTERVAL_PARAM)) {
+ LOG_ERROR("invalid rtcp interval value %s", val.c_str());
throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid rtcp interval value");
}
- _connectionParam.minRtcpInterval = val;
+ _connectionParam.minRtcpInterval = minRtcpInterval;
} else if (name == MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER) {
size_t size;
- unsigned int val = stoul(string_val, &size);
- if (string_val.size() != size) {
- LOG_ERROR("invalid sender buffer value %s", string_val.c_str());
+ unsigned int senderBuffer = stoul(val, &size);
+ if (val.size() != size) {
+ LOG_ERROR("invalid sender buffer value %s", val.c_str());
throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid sender buffer value");
}
- _connectionParam.senderBuffer = val;
+ _connectionParam.senderBuffer = senderBuffer;
} else {
LOG_ERROR("invalid param name %s", name.c_str());
g_signal_connect(GST_RTSP_MEDIA_FACTORY(factoryMtpr), "media-constructed", G_CALLBACK(__mediaConstructedCb), NULL);
g_signal_connect(GST_RTSP_MEDIA_FACTORY(factoryMtpr), "media-configure", G_CALLBACK(__mediaConfigureCb), NULL);
- if (gst_rtsp_server_attach(server, NULL) == 0) {
+ if ((_sourceId = gst_rtsp_server_attach(server, NULL)) == 0) {
LOG_ERROR("failed to attach server to default context");
throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed to attach server");
}
void MediaTransporterSenderRtsp::stopRtspServer()
{
- guint ref_cnt = 0;
- GstRTSPMountPoints* mounts = NULL;
- GstRTSPServer* server = static_cast<GstRTSPServer*>(_rtspServer);
- mounts = gst_rtsp_server_get_mount_points(server);
+ if (!_rtspServer) {
+ LOG_ERROR("there is no running server");
+ throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "there is no running server");
+ }
+
+ GstRTSPServer* server = static_cast<GstRTSPServer*>(_rtspServer);
+ GstRTSPMountPoints* mounts = gst_rtsp_server_get_mount_points(server);
gst_rtsp_mount_points_remove_factory(mounts, _rtspMountPoint.c_str());
g_object_unref(mounts);
gst_rtsp_server_client_filter(server, __clientFilter, NULL);
- ref_cnt = GST_OBJECT_REFCOUNT_VALUE(server);
+ if (_sourceId > 0)
+ g_source_remove(_sourceId);
+ _sourceId = 0;
+
+ guint ref_cnt = GST_OBJECT_REFCOUNT_VALUE(server);
for (guint i = 0; i < ref_cnt; i++)
gst_object_unref(server);
MediaTransporterIni::get().general().timeout);
}
-void MediaTransporterSenderSrt::setConnection(std::string name, std::string string_val)
+void MediaTransporterSenderSrt::setConnection(std::string name, std::string val)
{
- setConnectionParam(name, string_val, &_connectionParam);
+ setConnectionParam(name, val, &_connectionParam);
}
std::string MediaTransporterSenderSrt::getConnection(std::string name)
throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed to gst_element_link()");
}
- LOG_ERROR("pp %s, ref %d",
- GST_ELEMENT_NAME(_gst.pipeline), GST_OBJECT_REFCOUNT_VALUE(_gst.pipeline));
-
linkMediaSourceToMuxer(mux);
_rtspSink = sink;
+++ /dev/null
-/*
-* 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 <gst/gst.h>
-#include <gst/rtsp-server/rtsp-server.h>
-
-#ifdef PACKAGE
-#undef PACKAGE
-#endif
-#define PACKAGE "mtpr_rtsp_test"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "MTPR_TEST"
-
-#define DEFAULT_RTSP_PORT "8554"
-
-int main(int argc, char *argv[])
-{
- GMainLoop *loop;
- GstRTSPServer *server;
- GstRTSPMountPoints *mounts;
- GstRTSPMediaFactory *factory;
-
- if (argc < 2) {
- g_print("Enter launch cmd : \"( decodebin name=depay0 ! videoconvert ! tizenwlsink )\"\n");
- return 1;
- }
-
- gst_init(NULL, NULL);
- loop = g_main_loop_new(NULL, FALSE);
-
- server = gst_rtsp_server_new();
- g_object_set(server, "service", DEFAULT_RTSP_PORT, NULL);
-
- mounts = gst_rtsp_server_get_mount_points(server);
-
- factory = gst_rtsp_media_factory_new();
- gst_rtsp_media_factory_set_transport_mode(factory, GST_RTSP_TRANSPORT_MODE_RECORD);
- gst_rtsp_media_factory_set_launch(factory, argv[1]);
-
- gst_rtsp_mount_points_add_factory(mounts, "/test", factory);
- g_object_unref(mounts);
-
- gst_rtsp_server_attach(server, NULL);
-
- g_print("stream ready at rtsp://127.0.0.1:%s/test\n", DEFAULT_RTSP_PORT);
- g_main_loop_run(loop);
-
- return 0;
-}
)
SET(UT_SRC
+ ut_rist_sender.cpp
+ ut_rtsp_sender.cpp
+ ut_rtsp_sender_to_server.cpp
ut_srt_sender.cpp
ut_main.cpp
)
--- /dev/null
+/*
+ * 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 "ut_base.hpp"
+
+class MediaTransporterTestRistSender : public MediaTransporterTestBase {
+public:
+ MediaTransporterTestRistSender() = default;
+ ~MediaTransporterTestRistSender() = default;
+
+ void SetUp() override {
+ LOGD("Enter");
+
+ int ret = mtpr_create(MTPR_CONNECTION_TYPE_RIST_SENDER, &_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ LOGD("Leave");
+ }
+
+ void TearDown() override {
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+ LOGD("Enter");
+
+ if (_mtpr) {
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ if (state != MTPR_STATE_IDLE) {
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ ret = mtpr_destroy(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ LOGD("Leave");
+ }
+
+protected:
+ const std::string _receiverPath = "127.0.0.1:5004";
+};
+
+TEST_F(MediaTransporterTestRistSender, set_address_p)
+{
+ int ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_address_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_receiver_address(NULL, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_receiver_address(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_receiver_address(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_address_n2)
+{
+ int ret = mtpr_set_sender_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_receiver_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_TRUE(address);
+ ASSERT_STREQ(_receiverPath.c_str(), address);
+
+ free(address);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_receiver_address(NULL, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_receiver_address(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_receiver_address(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_n2)
+{
+ char *address = NULL;
+
+ int ret = mtpr_get_receiver_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_address_n3)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_sender_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_type_p)
+{
+ mtpr_connection_type_e type;
+
+ int ret = mtpr_get_connection_type(_mtpr, &type);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(type, MTPR_CONNECTION_TYPE_RIST_SENDER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_type_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ mtpr_connection_type_e type;
+
+ ret = mtpr_get_connection_type(NULL, &type);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_type(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_type(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_n2)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, start_n3)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRistSender, stop_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, stop_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, stop_n2)
+{
+ int ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_p1)
+{
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ int ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_p2)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_PLAYING);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_p3)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_state_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_get_state(NULL, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_state(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_state(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_address_p1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, "0.0.0.0");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_address_p2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+/* FIXME: check with invalid addr format */
+TEST_F(MediaTransporterTestRistSender, DISABLED_set_connection_param_address_n)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_p1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_p2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.05");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.051");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "test");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n3)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.051test");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n4)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "-1");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_bw_n5)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_p1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "0");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_p2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "100");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "101");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "test");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n3)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "10test");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n4)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "-1");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_rtcp_interval_n5)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_p1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "0");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_p2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "4294967295");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_n1)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "11test");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_n2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "test");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_sender_buffer_n3)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_connection_param(NULL, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "1000");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_connection_param(_mtpr, NULL, "1000");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, set_connection_param_n2)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_p1)
+{
+ int ret = MTPR_ERROR_NONE;
+ gchar* value = NULL;
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, "127.0.0.1");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_STREQ(value, "127.0.0.1");
+ g_free(value);
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.03");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ double ret_val = strtod(value, NULL);
+ ASSERT_EQ(ret_val, (double)0.03);
+ g_free(value);
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "99");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_STREQ(value, "99");
+ g_free(value);
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "1300");
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_STREQ(value, "1300");
+ g_free(value);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_p2)
+{
+ int ret = MTPR_ERROR_NONE;
+ gchar* value = NULL;
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_TRUE(value);
+ g_free(value);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_TRUE(value);
+ g_free(value);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_TRUE(value);
+ g_free(value);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ gchar* value = NULL;
+
+ ret = mtpr_get_connection_param(NULL, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_param(_mtpr, NULL, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRistSender, get_connection_param_n2)
+{
+ int ret = MTPR_ERROR_NONE;
+ gchar* value = NULL;
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_BONDING_ADDRESS, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
--- /dev/null
+/*
+ * 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 "ut_base.hpp"
+
+class MediaTransporterTestRtspSender : public MediaTransporterTestBase {
+public:
+ MediaTransporterTestRtspSender() = default;
+ ~MediaTransporterTestRtspSender() = default;
+
+ void SetUp() override {
+ LOGD("Enter");
+
+ int ret = mtpr_create(MTPR_CONNECTION_TYPE_RTSP_SENDER, &_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ LOGD("Leave");
+ }
+
+ void TearDown() override {
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+ LOGD("Enter");
+
+ if (_mtpr) {
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ if (state != MTPR_STATE_IDLE) {
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ ret = mtpr_destroy(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ LOGD("Leave");
+ }
+
+protected:
+ const std::string _senderPath = "rtsp://127.0.0.1:8554/test";
+};
+
+TEST_F(MediaTransporterTestRtspSender, set_address_p)
+{
+ int ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, set_address_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_sender_address(NULL, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_sender_address(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_sender_address(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, set_address_n2)
+{
+ int ret = mtpr_set_receiver_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_sender_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_TRUE(address);
+ ASSERT_STREQ(_senderPath.c_str(), address);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_sender_address(NULL, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_sender_address(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_sender_address(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_n2)
+{
+ char *address = NULL;
+
+ int ret = mtpr_get_sender_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_address_n3)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_receiver_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_connection_type_p)
+{
+ mtpr_connection_type_e type;
+
+ int ret = mtpr_get_connection_type(_mtpr, &type);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(type, MTPR_CONNECTION_TYPE_RTSP_SENDER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_connection_type_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ mtpr_connection_type_e type;
+
+ ret = mtpr_get_connection_type(NULL, &type);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_type(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_type(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_n2)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, start_n3)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, stop_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, stop_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, stop_n2)
+{
+ int ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_p1)
+{
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ int ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_p2)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_PLAYING);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_p3)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_state_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_get_state(NULL, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_state(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_state(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSender, set_connection_param_n)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.02");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSender, get_connection_param_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ gchar* value = NULL;
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
--- /dev/null
+/*
+ * 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 <gst/gst.h>
+#include <gst/rtsp-server/rtsp-server.h>
+
+#include "ut_base.hpp"
+
+static GMainLoop* _mainloop;
+static void* _run_rtsp_server(void* ptr) {
+ GstRTSPServer* server;
+ GstRTSPMountPoints* mounts;
+ GstRTSPMediaFactory* factory;
+
+ gst_init(NULL, NULL);
+ _mainloop = g_main_loop_new(NULL, FALSE);
+
+ server = gst_rtsp_server_new();
+ g_object_set(server, "service", "8554", NULL);
+
+ mounts = gst_rtsp_server_get_mount_points(server);
+
+ factory = gst_rtsp_media_factory_new();
+ gst_rtsp_media_factory_set_transport_mode(factory, GST_RTSP_TRANSPORT_MODE_RECORD);
+ gst_rtsp_media_factory_set_launch(factory, "decodebin name=depay0 ! videoconvert ! tizenwlsink");
+
+ gst_rtsp_mount_points_add_factory(mounts, "/test", factory);
+ g_object_unref(mounts);
+
+ gst_rtsp_server_attach(server, NULL);
+
+ LOGD("server ready");
+ g_main_loop_run(_mainloop);
+
+ LOGD("server terminated");
+ g_main_loop_unref(_mainloop);
+
+ return NULL;
+}
+
+class MediaTransporterTestRtspSenderToServerRun : public MediaTransporterTestBase {
+public:
+ MediaTransporterTestRtspSenderToServerRun() = default;
+ ~MediaTransporterTestRtspSenderToServerRun() = default;
+
+ void SetUp() override {
+ LOGD("Enter");
+
+ start_rtsp_server();
+
+ int ret = mtpr_create(MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER, &_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ LOGD("Leave");
+ }
+
+ void TearDown() override {
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+ LOGD("Enter");
+
+ if (_mtpr) {
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ if (state != MTPR_STATE_IDLE) {
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ ret = mtpr_destroy(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+
+ stop_rtsp_server();
+ LOGD("Leave");
+ }
+
+protected:
+ const std::string _receiverPath = "rtsp://127.0.0.1:8554/test";
+
+ void start_rtsp_server() {
+ _rtspServer = g_thread_try_new("rtsp_server", _run_rtsp_server, NULL, NULL);
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ }
+
+ void stop_rtsp_server() {
+ if (_mainloop)
+ g_main_loop_quit(_mainloop);
+ if (_rtspServer)
+ g_thread_join(_rtspServer);
+ }
+
+ GThread* _rtspServer {nullptr};
+};
+
+class MediaTransporterTestRtspSenderToServer : public MediaTransporterTestBase {
+public:
+ MediaTransporterTestRtspSenderToServer() = default;
+ ~MediaTransporterTestRtspSenderToServer() = default;
+
+ void SetUp() override {
+ LOGD("Enter");
+
+ int ret = mtpr_create(MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER, &_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ LOGD("Leave");
+ }
+
+ void TearDown() override {
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+ LOGD("Enter");
+
+ if (_mtpr) {
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ if (state != MTPR_STATE_IDLE) {
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ ret = mtpr_destroy(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ }
+ LOGD("Leave");
+ }
+
+protected:
+ const std::string _receiverPath = "rtsp://127.0.0.1:8554/test";
+};
+
+// MediaTransporterTestRtspSenderToServer
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_address_p)
+{
+ int ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_address_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_receiver_address(NULL, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_receiver_address(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_set_receiver_address(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_address_n2)
+{
+ int ret = mtpr_set_sender_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_receiver_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_TRUE(address);
+ ASSERT_STREQ(_receiverPath.c_str(), address);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_receiver_address(NULL, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_receiver_address(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_receiver_address(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_n2)
+{
+ char *address = NULL;
+
+ int ret = mtpr_get_receiver_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_NO_DATA);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_address_n3)
+{
+ int ret = MTPR_ERROR_NONE;
+ char *address = NULL;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_sender_address(_mtpr, &address);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_type_p)
+{
+ mtpr_connection_type_e type;
+
+ int ret = mtpr_get_connection_type(_mtpr, &type);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(type, MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_type_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ mtpr_connection_type_e type;
+
+ ret = mtpr_get_connection_type(NULL, &type);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_type(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_connection_type(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, start_n1)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, start_n2)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, start_n3)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+
+TEST_F(MediaTransporterTestRtspSenderToServer, stop_n)
+{
+ int ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_STATE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_state_p)
+{
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ int ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_state_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_get_state(NULL, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_state(_mtpr, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+
+ ret = mtpr_get_state(NULL, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, set_connection_param_n)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.02");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_param_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ gchar* value = NULL;
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+
+ ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+}
+
+// MediaTransporterTestRtspSenderToServerRun
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, start_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, stop_p)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, stop_n)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, get_state_p1)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_PLAYING);
+}
+
+TEST_F(MediaTransporterTestRtspSenderToServerRun, get_state_p2)
+{
+ int ret = MTPR_ERROR_NONE;
+ unsigned int source_id = 0;
+ mtpr_state_e state = MTPR_STATE_IDLE;
+
+ ret = mtpr_set_receiver_address(_mtpr, _receiverPath.c_str());
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_GE(source_id, 0);
+
+ ret = mtpr_start(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_stop(_mtpr);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+ ret = mtpr_get_state(_mtpr, &state);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+ ASSERT_EQ(state, MTPR_STATE_IDLE);
+}
}
protected:
- const std::string _srtSenderPath = "srt://:8888";
+ const std::string _senderPath = "srt://:8888";
};
TEST_F(MediaTransporterTestSrtSender, set_address_p)
{
- int ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ int ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
}
{
int ret = MTPR_ERROR_NONE;
- ret = mtpr_set_sender_address(NULL, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(NULL, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
ret = mtpr_set_sender_address(_mtpr, NULL);
TEST_F(MediaTransporterTestSrtSender, set_address_n2)
{
- int ret = mtpr_set_receiver_address(_mtpr, _srtSenderPath.c_str());
+ int ret = mtpr_set_receiver_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
}
int ret = MTPR_ERROR_NONE;
char *address = NULL;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_get_sender_address(_mtpr, &address);
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ASSERT_TRUE(address);
- ASSERT_STREQ(_srtSenderPath.c_str(), address);
+ ASSERT_STREQ(_senderPath.c_str(), address);
}
TEST_F(MediaTransporterTestSrtSender, get_address_n1)
int ret = MTPR_ERROR_NONE;
char *address = NULL;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_get_sender_address(NULL, &address);
int ret = MTPR_ERROR_NONE;
char *address = NULL;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_get_receiver_address(_mtpr, &address);
ASSERT_EQ(type, MTPR_CONNECTION_TYPE_SRT_SENDER);
}
-TEST_F(MediaTransporterTestSrtSender, get_connection_type_n1)
+TEST_F(MediaTransporterTestSrtSender, get_connection_type_n)
{
int ret = MTPR_ERROR_NONE;
mtpr_connection_type_e type;
int ret = MTPR_ERROR_NONE;
unsigned int source_id = 0;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ASSERT_GE(source_id, 0);
-
ret = mtpr_start(_mtpr);
ASSERT_EQ(ret, MTPR_ERROR_NONE);
}
int ret = MTPR_ERROR_NONE;
unsigned int source_id = 0;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
{
int ret = MTPR_ERROR_NONE;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_start(_mtpr);
int ret = MTPR_ERROR_NONE;
unsigned int source_id = 0;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
int ret = MTPR_ERROR_NONE;
unsigned int source_id = 0;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
unsigned int source_id = 0;
mtpr_state_e state = MTPR_STATE_IDLE;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
unsigned int source_id = 0;
mtpr_state_e state = MTPR_STATE_IDLE;
- ret = mtpr_set_sender_address(_mtpr, _srtSenderPath.c_str());
+ ret = mtpr_set_sender_address(_mtpr, _senderPath.c_str());
ASSERT_EQ(ret, MTPR_ERROR_NONE);
ret = mtpr_add_media_source(_mtpr, MTPR_SOURCE_TYPE_VIDEOTEST, NULL, &source_id);
ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
}
-TEST_F(MediaTransporterTestSrtSender, set_connection_param_streamid_p)
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_mode_n3)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_streamid_p1)
{
int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, "testid");
ASSERT_EQ(ret, MTPR_ERROR_NONE);
}
-TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_p)
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_streamid_p2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_STREAMID, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_p1)
{
int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpassphrase");
ASSERT_EQ(ret, MTPR_ERROR_NONE);
}
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_p2)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_NONE);
+}
+
TEST_F(MediaTransporterTestSrtSender, set_connection_param_passphrase_n)
{
int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, "testpwd");
ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
}
-TEST_F(MediaTransporterTestSrtSender, set_connection_param_n)
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_pbkeylen_n4)
+{
+ int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, NULL);
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_n1)
{
int ret = MTPR_ERROR_NONE;
ret = mtpr_set_connection_param(_mtpr, NULL, "2");
ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(MediaTransporterTestSrtSender, set_connection_param_n2)
+{
+ int ret = MTPR_ERROR_NONE;
+
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER, "1000");
+ ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
- ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, NULL);
+ ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MIN_RTCP_INTERVAL, "50");
ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
}
-TEST_F(MediaTransporterTestSrtSender, get_connection_param_p)
+TEST_F(MediaTransporterTestSrtSender, get_connection_param_p1)
{
int ret = MTPR_ERROR_NONE;
gchar* value = NULL;
projects / platform / core / api / mediatransporter.git / commitdiff