namespace param {
struct videoInfo {
- int width { -1 };
- int height { -1 };
- int frameRate { -1 };
+ int width { -1 };
+ int height { -1 };
+ int frameRate { -1 };
};
struct audioInfo {
- int channel { -1 };
- int rate { -1 };
- std::string format;
+ int channel { -1 };
+ int rate { -1 };
+ std::string format;
};
struct encodingInfo {
- int bitrate = 0;
+ int bitrate { 0 };
};
void parseSourceParam(bundle* params, videoInfo* vInfo, encodingInfo* eInfo);
void parseSourceParam(bundle* params, audioInfo* aInfo, encodingInfo * eInfo);
+
+namespace srt {
+
+enum connectionMode {
+ MTPR_CONNECTION_SRT_MODE_NONE = 0, /**< not connected, default type */
+ MTPR_CONNECTION_SRT_MODE_CALLER, /**< The mode to send the connection request like a client (default) */
+ MTPR_CONNECTION_SRT_MODE_LISTENER, /**< The mode to wait for being connected by peer caller */
+ MTPR_CONNECTION_SRT_MODE_RENDEZVOUS, /**< The mode to support one-to-one only connection */
+};
+
+enum connectionKeyLength {
+ MTPR_CONNECTION_SRT_NO_KEY = 0, /**< no encryption, default value */
+ MTPR_CONNECTION_SRT_KEY_LEN_0 = 0, /**< no encryption */
+ MTPR_CONNECTION_SRT_KEY_LEN_16 = 16, /**< 16 bytes (128-bit) length */
+ MTPR_CONNECTION_SRT_KEY_LEN_24 = 24, /**< 24 bytes (192-bit) length */
+ MTPR_CONNECTION_SRT_KEY_LEN_32 = 32, /**< 32 bytes (256-bit) length */
+};
+
+struct connectionParam {
+ connectionMode mode { MTPR_CONNECTION_SRT_MODE_NONE };
+ std::string streamId;
+ std::string passPhrase;
+ connectionKeyLength pbKeyLen { MTPR_CONNECTION_SRT_NO_KEY };
+};
+
+bool _isValidKeyLength(int keyLen);
+void setConnectionParam(std::string key, std::string value, connectionParam* connectionParam);
+void setConnectionParamList(bundle* paramList, connectionParam* connectionParam);
+void getConnectionParamList(const connectionParam& connectionParam, bundle* paramList);
+}; // srt
+
}; // param
} // tizen_media_transporter
#include "MediaTransporterBase.h"
#include "MediaTransporterReceiver.h"
#include "MediaTransporterGst.h"
+#include "MediaTransporterParam.h"
namespace tizen_media_transporter {
void startPipeline() override;
void stopPipeline() override;
- void setConnection(std::string name, std::string value) override {}
- void setConnection(bundle* params) override {}
- void getConnection(bundle* params) override {}
+ void setConnection(std::string name, std::string value) override;
+ void setConnection(bundle* paramList) override;
+ void getConnection(bundle* paramList) override;
void setSenderAddress(std::string address) override;
std::string getSenderAddress() override { return _senderAddress; }
static void _demuxPadAddedCallback(GstElement* demux, GstPad* new_pad, gpointer userData);
static void _demuxNoMorePadsCallback(GstElement* demux, gpointer userData);
+ param::srt::connectionParam _connectionParam;
std::string _senderAddress;
};
#include "MediaTransporter.h"
#include "MediaTransporterSender.h"
#include "MediaTransporterGst.h"
+#include "MediaTransporterParam.h"
namespace tizen_media_transporter {
void stopPipeline() override;
void setConnection(std::string name, std::string value) override;
- void setConnection(bundle* params) override;
- void getConnection(bundle* params) override;
+ void setConnection(bundle* paramList) override;
+ void getConnection(bundle* paramList) override;
void setSenderAddress(std::string address) override;
std::string getSenderAddress() override { return _senderAddress; }
mtprConnectionType type() override { return MTPR_CONNECTION_TYPE_SRT_SENDER; }
private:
- bool _isValidKeyLength(int val);
-
- enum connectionMode {
- MTPR_CONNECTION_SRT_MODE_NONE = 0, /**< not connected, default type */
- MTPR_CONNECTION_SRT_MODE_CALLER, /**< The mode to send the connection request like a client (default) */
- MTPR_CONNECTION_SRT_MODE_LISTENER, /**< The mode to wait for being connected by peer caller */
- MTPR_CONNECTION_SRT_MODE_RENDEZVOUS, /**< The mode to support one-to-one only connection */
- };
-
- enum connectionKeyLength {
- MTPR_CONNECTION_SRT_NO_KEY = 0, /**< no encryption, default value */
- MTPR_CONNECTION_SRT_KEY_LEN_0 = 0, /**< no encryption */
- MTPR_CONNECTION_SRT_KEY_LEN_16 = 16, /**< 16 bytes (128-bit) length */
- MTPR_CONNECTION_SRT_KEY_LEN_24 = 24, /**< 24 bytes (192-bit) length */
- MTPR_CONNECTION_SRT_KEY_LEN_32 = 32, /**< 32 bytes (256-bit) length */
- };
-
- struct MtprConnectionParamSrt {
- connectionMode mode = MTPR_CONNECTION_SRT_MODE_NONE;
- std::string streamId;
- std::string passPhrase;
- connectionKeyLength pbKeyLen = MTPR_CONNECTION_SRT_NO_KEY;
- };
-
- MtprConnectionParamSrt _connectionParam;
-
+ param::srt::connectionParam _connectionParam;
std::string _senderAddress;
GstElement* _srtSink { nullptr };
Name: capi-media-transporter
Summary: A Media Transporter library in Tizen Native API
-Version: 0.0.8
+Version: 0.0.9
Release: 0
Group: Multimedia/API
License: Apache-2.0
#include "MediaTransporterLog.h"
using namespace tizen_media_transporter;
+using namespace tizen_media_transporter::param::srt;
void param::parseSourceParam(bundle* params, param::videoInfo* vInfo, param::encodingInfo* eInfo)
{
if (written_count == 0)
throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "Failed to parse Source Param");
}
+
+bool param::srt::_isValidKeyLength(int keyLen)
+{
+ switch (keyLen)
+ {
+ case MTPR_CONNECTION_SRT_NO_KEY:
+ case MTPR_CONNECTION_SRT_KEY_LEN_16:
+ case MTPR_CONNECTION_SRT_KEY_LEN_24:
+ case MTPR_CONNECTION_SRT_KEY_LEN_32:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void param::srt::setConnectionParam(std::string key, std::string value, param::srt::connectionParam* connectionParam)
+{
+ SECURE_LOG_INFO("%s : %s", key.c_str(), value.c_str());
+
+ try {
+ if (key.compare(MTPR_CONNECTION_PARAM_SRT_MODE) == 0) {
+ size_t size;
+ int val = stoi(value, &size);
+ if ((value.size() != size) ||
+ (val < MTPR_CONNECTION_SRT_MODE_NONE) || (val > MTPR_CONNECTION_SRT_MODE_RENDEZVOUS)) {
+ LOG_ERROR("invalid srt mode value %d", val);
+ throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid srt mode value");
+ }
+ connectionParam->mode = static_cast<connectionMode>(val);
+
+ } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_STREAMID) == 0) {
+ connectionParam->streamId = value;
+
+ } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE) == 0) {
+ connectionParam->passPhrase = value;
+
+ } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN) == 0) {
+ size_t size;
+ int val = stoi(value, &size);
+ if (value.size() != size || !_isValidKeyLength(val)) {
+ LOG_ERROR("invalid pbkeylen value %d", val);
+ throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid pbkeylen value");
+ }
+ connectionParam->pbKeyLen = static_cast<connectionKeyLength>(val);
+
+ } else {
+ LOG_ERROR("invalid param name %s", key.c_str());
+ throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid param name");
+ }
+ } catch (const std::exception& e) {
+ LOG_ERROR("error : %s, throw invalid param", e.what());
+ throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid parameter");
+ }
+}
+
+void param::srt::setConnectionParamList(bundle* paramList, param::srt::connectionParam* connectionParam)
+{
+ char* string_val = NULL;
+
+ if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_MODE, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
+ setConnectionParam(std::string{MTPR_CONNECTION_PARAM_SRT_MODE}, string_val, connectionParam);
+
+ if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_STREAMID, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
+ connectionParam->streamId = string_val;
+
+ if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
+ connectionParam->passPhrase = string_val;
+
+ if (bundle_get_str(paramList, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE)
+ setConnectionParam(std::string{MTPR_CONNECTION_PARAM_SRT_PBKEYLEN}, string_val, connectionParam);
+}
+
+void param::srt::getConnectionParamList(const param::srt::connectionParam& connectionParam, bundle *paramList)
+{
+ bundle_add_str(paramList,
+ MTPR_CONNECTION_PARAM_SRT_MODE,
+ std::to_string(static_cast<int>(connectionParam.mode)).c_str());
+
+ if (!connectionParam.streamId.empty())
+ bundle_add_str(paramList, MTPR_CONNECTION_PARAM_SRT_STREAMID, connectionParam.streamId.c_str());
+
+ if (!connectionParam.passPhrase.empty())
+ bundle_add_str(paramList, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, connectionParam.passPhrase.c_str());
+
+ bundle_add_str(paramList,
+ MTPR_CONNECTION_PARAM_SRT_PBKEYLEN,
+ std::to_string(static_cast<int>(connectionParam.pbKeyLen)).c_str());
+}
#include <cassert>
using namespace tizen_media_transporter;
+using namespace tizen_media_transporter::param::srt;
void MediaTransporterReceiverSrt::_demuxNoMorePadsCallback(GstElement *demux, gpointer userData)
{
src = gst::_createElement(gst::DEFAULT_ELEMENT_SRTSRC);
g_object_set(G_OBJECT(src), "uri", _senderAddress.c_str(), "latency", 10, NULL);
+ if (_connectionParam.mode != MTPR_CONNECTION_SRT_MODE_NONE)
+ g_object_set(G_OBJECT(src),
+ "mode", static_cast<int>(_connectionParam.mode), NULL);
+
+ if (_connectionParam.pbKeyLen != MTPR_CONNECTION_SRT_NO_KEY)
+ g_object_set(G_OBJECT(src),
+ "pbkeylen", static_cast<int>(_connectionParam.pbKeyLen), NULL);
+
+ if (!_connectionParam.passPhrase.empty())
+ g_object_set(G_OBJECT(src),
+ "passphrase", _connectionParam.passPhrase.c_str(), NULL);
+
+ if (!_connectionParam.streamId.empty())
+ g_object_set(G_OBJECT(src),
+ "streamid", _connectionParam.streamId.c_str(), NULL);
+
queue = gst::_createElement(gst::DEFAULT_ELEMENT_QUEUE);
tsdemux = gst::_createElement(gst::DEFAULT_ELEMENT_TSDEMUX);
gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(tsdemux), "pad-added", G_CALLBACK(_demuxPadAddedCallback), this);
gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(tsdemux), "no-more-pads", G_CALLBACK(_demuxNoMorePadsCallback), this);
LOG_INFO("linked mux and sink");
-
} catch (const MediaTransporterException& e) {
LOG_ERROR("%s", e.what());
MediaTransporterIni::get().general().timeout);
}
+void MediaTransporterReceiverSrt::setConnection(std::string name, std::string string_val)
+{
+ setConnectionParam(name, string_val, &_connectionParam);
+}
+
+void MediaTransporterReceiverSrt::setConnection(bundle* paramList)
+{
+ setConnectionParamList(paramList, &_connectionParam);
+}
+
+void MediaTransporterReceiverSrt::getConnection(bundle* paramList)
+{
+ getConnectionParamList(_connectionParam, paramList);
+}
+
void MediaTransporterReceiverSrt::setSenderAddress(std::string address)
{
_senderAddress = address;
#include "MediaTransporterParseIni.h"
using namespace tizen_media_transporter;
+using namespace tizen_media_transporter::param::srt;
static void __callerAddedCb(GstElement* element, gint socket, GSocketAddress* address, gpointer userData)
{
LOG_ERROR("failed to gst_element_link()");
throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed to gst_element_link()");
}
+
if (_connectionParam.mode != MTPR_CONNECTION_SRT_MODE_NONE)
g_object_set(G_OBJECT(sink),
"mode", static_cast<int>(_connectionParam.mode), NULL);
- if (!_connectionParam.pbKeyLen != MTPR_CONNECTION_SRT_NO_KEY)
+ if (_connectionParam.pbKeyLen != MTPR_CONNECTION_SRT_NO_KEY)
g_object_set(G_OBJECT(sink),
"pbkeylen", static_cast<int>(_connectionParam.pbKeyLen), NULL);
gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(sink), "caller-rejected", G_CALLBACK(__callerRejectedCb), &_gst);
gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(sink), "caller-connecting", G_CALLBACK(__callerConnectingCb), &_gst);
- LOG_ERROR("pp %s, ref %d",
- GST_ELEMENT_NAME(_gst.pipeline), GST_OBJECT_REFCOUNT_VALUE(_gst.pipeline));
-
linkMediaSourceToMuxer(mux);
_srtSink = sink;
MediaTransporterIni::get().general().timeout);
}
-bool MediaTransporterSenderSrt::_isValidKeyLength(int val)
-{
- switch(val)
- {
- case MTPR_CONNECTION_SRT_NO_KEY:
- case MTPR_CONNECTION_SRT_KEY_LEN_16:
- case MTPR_CONNECTION_SRT_KEY_LEN_24:
- case MTPR_CONNECTION_SRT_KEY_LEN_32:
- return true;
- default:
- return false;
- }
-}
-
void MediaTransporterSenderSrt::setConnection(std::string name, std::string string_val)
{
- SECURE_LOG_INFO("%s : %s", name.c_str(), string_val.c_str());
-
- try {
- if (name.compare(MTPR_CONNECTION_PARAM_SRT_MODE) == 0) {
- size_t size;
- int val = stoi(string_val, &size);
- if ((string_val.size() != size) ||
- (val < MTPR_CONNECTION_SRT_MODE_NONE) || (val > MTPR_CONNECTION_SRT_MODE_RENDEZVOUS)) {
- LOG_ERROR("invalid srt mode value %d", val);
- throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid srt mode value");
- }
- _connectionParam.mode = static_cast<connectionMode>(val);
-
- } else if (name.compare(MTPR_CONNECTION_PARAM_SRT_STREAMID) == 0) {
- _connectionParam.streamId = string_val;
-
- } else if (name.compare(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE) == 0) {
- _connectionParam.passPhrase = string_val;
-
- } else if (name.compare(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN) == 0) {
- size_t size;
- int val = stoi(string_val, &size);
- if (string_val.size() != size || !_isValidKeyLength(val)) {
- LOG_ERROR("invalid pbkeylen value %d", val);
- throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid pbkeylen value");
- }
- _connectionParam.pbKeyLen = static_cast<connectionKeyLength>(val);
-
- } else {
- LOG_ERROR("invalid param name %s", name.c_str());
- throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid param name");
- }
- } catch (const std::exception& e) {
- LOG_ERROR("error : %s, throw invalid param", e.what());
- throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid parameter");
- }
+ setConnectionParam(name, string_val, &_connectionParam);
}
-void MediaTransporterSenderSrt::setConnection(bundle* params)
+void MediaTransporterSenderSrt::setConnection(bundle* paramList)
{
- char* string_val = NULL;
-
- if (bundle_get_str(params, MTPR_CONNECTION_PARAM_SRT_MODE, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE) {
- setConnection(MTPR_CONNECTION_PARAM_SRT_MODE, string_val);
- }
-
- if (bundle_get_str(params, MTPR_CONNECTION_PARAM_SRT_STREAMID, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE) {
- _connectionParam.streamId = std::string {string_val};
- }
-
- if (bundle_get_str(params, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE) {
- _connectionParam.passPhrase = std::string {string_val};
- }
-
- if (bundle_get_str(params, MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE) {
- setConnection(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN, string_val);
- }
+ setConnectionParamList(paramList, &_connectionParam);
}
-void MediaTransporterSenderSrt::getConnection(bundle* params)
+void MediaTransporterSenderSrt::getConnection(bundle* paramList)
{
- bundle_add_str(params,
- MTPR_CONNECTION_PARAM_SRT_MODE,
- std::to_string(static_cast<int>(_connectionParam.mode)).c_str());
-
- if (!_connectionParam.streamId.empty())
- bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_STREAMID, _connectionParam.streamId.c_str());
-
- if (!_connectionParam.passPhrase.empty())
- bundle_add_str(params, MTPR_CONNECTION_PARAM_SRT_PASSPHRASE, _connectionParam.passPhrase.c_str());
-
- bundle_add_str(params,
- MTPR_CONNECTION_PARAM_SRT_PBKEYLEN,
- std::to_string(static_cast<int>(_connectionParam.pbKeyLen)).c_str());
+ getConnectionParamList(_connectionParam, paramList);
}
void MediaTransporterSenderSrt::setSenderAddress(std::string address)
projects / platform / core / api / mediatransporter.git / commitdiff