Rename RtcpHandler to MediaHandler

CMakeLists.txt

@@ -74,9 +74,9 @@ set(LIBDATACHANNEL_SOURCES
 	${CMAKE_CURRENT_SOURCE_DIR}/src/h264rtppacketizer.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/nalunit.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/h264packetizationhandler.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpchainablehandler.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/messagehandlerelement.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/messagehandlerrootelement.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/mediachainablehandler.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/mediahandlerelement.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/mediahandlerrootelement.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpnackresponder.cpp
 )
 
@@ -96,7 +96,7 @@ set(LIBDATACHANNEL_HEADERS
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/configuration.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/datachannel.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/description.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtcphandler.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/mediahandler.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtcpreceivingsession.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/include.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/init.hpp
@@ -118,9 +118,9 @@ set(LIBDATACHANNEL_HEADERS
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/h264rtppacketizer.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/nalunit.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/h264packetizationhandler.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpchainablehandler.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/messagehandlerelement.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/messagehandlerrootelement.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/mediachainablehandler.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/mediahandlerelement.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/mediahandlerrootelement.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpnackresponder.hpp
 )
 

include/rtc/h264packetizationhandler.hpp

@@ -23,12 +23,12 @@
 
 #include "h264rtppacketizer.hpp"
 #include "nalunit.hpp"
-#include "rtcpchainablehandler.hpp"
+#include "mediachainablehandler.hpp"
 
 namespace rtc {
 
 /// Handler for H264 packetization
-class RTC_CPP_EXPORT H264PacketizationHandler : public RtcpChainableHandler {
+class RTC_CPP_EXPORT H264PacketizationHandler : public MediaChainableHandler {
 public:
 	/// Construct handler for H264 packetization.
 	/// @param packetizer RTP packetizer for h264

include/rtc/h264rtppacketizer.hpp

@@ -23,12 +23,12 @@
 
 #include "nalunit.hpp"
 #include "rtppacketizer.hpp"
-#include "messagehandlerrootelement.hpp"
+#include "mediahandlerrootelement.hpp"
 
 namespace rtc {
 
 /// RTP packetization of h264 payload
-class RTC_CPP_EXPORT H264RtpPacketizer : public RtpPacketizer, public MessageHandlerRootElement {
+class RTC_CPP_EXPORT H264RtpPacketizer : public RtpPacketizer, public MediaHandlerRootElement {
 	std::shared_ptr<NalUnits> splitMessage(binary_ptr message);
 	const uint16_t maximumFragmentSize;
 

include/rtc/rtcpchainablehandler.hpp → include/rtc/mediachainablehandler.hpp

@@ -15,19 +15,19 @@
  * along with this program; If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef RTC_RTCP_CHAINABLE_HANDLER_H
-#define RTC_RTCP_CHAINABLE_HANDLER_H
+#ifndef RTC_MEDIA_CHAINABLE_HANDLER_H
+#define RTC_MEDIA_CHAINABLE_HANDLER_H
 
 #if RTC_ENABLE_MEDIA
 
-#include "rtcphandler.hpp"
-#include "messagehandlerrootelement.hpp"
+#include "mediahandler.hpp"
+#include "mediahandlerrootelement.hpp"
 
 namespace rtc {
 
-class RTC_CPP_EXPORT RtcpChainableHandler : public RtcpHandler {
-	const std::shared_ptr<MessageHandlerRootElement> root;
-	std::shared_ptr<MessageHandlerElement> leaf;
+class RTC_CPP_EXPORT MediaChainableHandler : public MediaHandler {
+	const std::shared_ptr<MediaHandlerRootElement> root;
+	std::shared_ptr<MediaHandlerElement> leaf;
 	std::mutex inoutMutex;
 
 	std::optional<message_ptr> handleIncomingBinary(message_ptr);
@@ -36,8 +36,8 @@ class RTC_CPP_EXPORT RtcpChainableHandler : public RtcpHandler {
 	std::optional<message_ptr> handleOutgoingControl(message_ptr);
 	bool sendProduct(ChainedOutgoingResponseProduct product);
 public:
-	RtcpChainableHandler(std::shared_ptr<MessageHandlerRootElement> root);
-	~RtcpChainableHandler();
+	MediaChainableHandler(std::shared_ptr<MediaHandlerRootElement> root);
+	~MediaChainableHandler();
 	message_ptr incoming(message_ptr ptr) override;
 	message_ptr outgoing(message_ptr ptr) override;
 
@@ -45,11 +45,11 @@ public:
 
 	/// Adds element to chain
 	/// @param chainable Chainable element
-    void addToChain(std::shared_ptr<MessageHandlerElement> chainable);
+    void addToChain(std::shared_ptr<MediaHandlerElement> chainable);
 };
 
 } // namespace rtc
 
 #endif // RTC_ENABLE_MEDIA
 
-#endif // RTC_RTCP_CHAINABLE_HANDLER_H
+#endif // RTC_MEDIA_CHAINABLE_HANDLER_H

include/rtc/rtcphandler.hpp → include/rtc/mediahandler.hpp

@@ -17,15 +17,15 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef RTC_RTCP_HANDLER_H
-#define RTC_RTCP_HANDLER_H
+#ifndef RTC_MEDIA_HANDLER_H
+#define RTC_MEDIA_HANDLER_H
 
 #include "include.hpp"
 #include "message.hpp"
 
 namespace rtc {
 
-class RTC_CPP_EXPORT RtcpHandler {
+class RTC_CPP_EXPORT MediaHandler {
 protected:
 	// Use this callback when trying to send custom data (such as RTCP) to the client.
 	synchronized_callback<message_ptr> outgoingCallback;
@@ -47,4 +47,4 @@ public:
 
 } // namespace rtc
 
-#endif // RTC_RTCP_HANDLER_H
+#endif // RTC_MEDIA_HANDLER_H

include/rtc/messagehandlerelement.hpp → include/rtc/mediahandlerelement.hpp

@@ -15,8 +15,8 @@
  * along with this program; If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef RTC_MESSAGE_HANDLER_ELEMENT_H
-#define RTC_MESSAGE_HANDLER_ELEMENT_H
+#ifndef RTC_MEDIA_HANDLER_ELEMENT_H
+#define RTC_MEDIA_HANDLER_ELEMENT_H
 
 #if RTC_ENABLE_MEDIA
 
@@ -60,15 +60,15 @@ struct RTC_CPP_EXPORT ChainedIncomingControlProduct {
 };
 
 /// Chainable handler
-class RTC_CPP_EXPORT MessageHandlerElement: public std::enable_shared_from_this<MessageHandlerElement> {
-	std::optional<std::shared_ptr<MessageHandlerElement>> upstream = nullopt;
-	std::optional<std::shared_ptr<MessageHandlerElement>> downstream = nullopt;
+class RTC_CPP_EXPORT MediaHandlerElement: public std::enable_shared_from_this<MediaHandlerElement> {
+	std::optional<std::shared_ptr<MediaHandlerElement>> upstream = nullopt;
+	std::optional<std::shared_ptr<MediaHandlerElement>> downstream = nullopt;
 
 	void prepareAndSendResponse(std::optional<ChainedOutgoingResponseProduct> outgoing, std::function<bool (ChainedOutgoingResponseProduct)> send);
 
 	void removeFromChain();
 public:
-	MessageHandlerElement();
+	MediaHandlerElement();
 
 	/// Creates response to incoming message
 	/// @param messages Current repsonse
@@ -105,7 +105,7 @@ public:
 	/// Set given element as upstream to this
 	/// @param upstream Upstream element
 	/// @returns Upstream element
-	std::shared_ptr<MessageHandlerElement> chainWith(std::shared_ptr<MessageHandlerElement> upstream);
+	std::shared_ptr<MediaHandlerElement> chainWith(std::shared_ptr<MediaHandlerElement> upstream);
 
 	/// Remove all downstream elements from chain
 	void recursiveRemoveChain();
@@ -115,4 +115,4 @@ public:
 
 #endif // RTC_ENABLE_MEDIA
 
-#endif // RTC_MESSAGE_HANDLER_ELEMENT_H
+#endif // RTC_MEDIA_HANDLER_ELEMENT_H

include/rtc/messagehandlerrootelement.hpp → include/rtc/mediahandlerrootelement.hpp

@@ -15,19 +15,19 @@
  * along with this program; If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef RTCP_MESSAGE_HANDLER_ROOT_ELEMENT_H
-#define RTCP_MESSAGE_HANDLER_ROOT_ELEMENT_H
+#ifndef RTCP_MEDIA_HANDLER_ROOT_ELEMENT_H
+#define RTCP_MEDIA_HANDLER_ROOT_ELEMENT_H
 
 #if RTC_ENABLE_MEDIA
 
-#include "messagehandlerelement.hpp"
+#include "mediahandlerelement.hpp"
 
 namespace rtc {
 
 /// Chainable message handler
-class RTC_CPP_EXPORT MessageHandlerRootElement : public MessageHandlerElement {
+class RTC_CPP_EXPORT MediaHandlerRootElement : public MediaHandlerElement {
 public:
-	MessageHandlerRootElement() { }
+	MediaHandlerRootElement() { }
 
 	/// Reduce multiple messages into one message
 	/// @param messages Messages to reduce
@@ -42,4 +42,4 @@ public:
 
 #endif // RTC_ENABLE_MEDIA
 
-#endif // RTCP_MESSAGE_HANDLER_ROOT_ELEMENT_H
+#endif // RTCP_MEDIA_HANDLER_ROOT_ELEMENT_H

include/rtc/opuspacketizationhandler.hpp

@@ -22,12 +22,12 @@
 #if RTC_ENABLE_MEDIA
 
 #include "opusrtppacketizer.hpp"
-#include "rtcpchainablehandler.hpp"
+#include "mediachainablehandler.hpp"
 
 namespace rtc {
 
 /// Handler for opus packetization
-class RTC_CPP_EXPORT OpusPacketizationHandler : public RtcpChainableHandler {
+class RTC_CPP_EXPORT OpusPacketizationHandler : public MediaChainableHandler {
 
 public:
 	/// Construct handler for opus packetization.

include/rtc/opusrtppacketizer.hpp

@@ -22,12 +22,12 @@
 #if RTC_ENABLE_MEDIA
 
 #include "rtppacketizer.hpp"
-#include "messagehandlerrootelement.hpp"
+#include "mediahandlerrootelement.hpp"
 
 namespace rtc {
 
 /// RTP packetizer for opus
-class RTC_CPP_EXPORT OpusRtpPacketizer : public RtpPacketizer, public MessageHandlerRootElement {
+class RTC_CPP_EXPORT OpusRtpPacketizer : public RtpPacketizer, public MediaHandlerRootElement {
 public:
 	/// default clock rate used in opus RTP communication
 	static const uint32_t defaultClockRate = 48 * 1000;

include/rtc/rtc.hpp

@@ -27,9 +27,9 @@
 
 #if RTC_ENABLE_MEDIA
 
-// RTCP handling
+// Media handling
 #include "rtcpreceivingsession.hpp"
-#include "rtcpchainablehandler.hpp"
+#include "mediachainablehandler.hpp"
 #include "rtcpsrreporter.hpp"
 #include "rtcpnackresponder.hpp"
 

include/rtc/rtcpnackresponder.hpp

@@ -20,14 +20,14 @@
 
 #if RTC_ENABLE_MEDIA
 
-#include "messagehandlerelement.hpp"
+#include "mediahandlerelement.hpp"
 
 #include <unordered_map>
 #include <queue>
 
 namespace rtc {
 
-class RTC_CPP_EXPORT RtcpNackResponder: public MessageHandlerElement {
+class RTC_CPP_EXPORT RtcpNackResponder: public MediaHandlerElement {
 
 	/// Packet storage
 	class RTC_CPP_EXPORT Storage {

include/rtc/rtcpreceivingsession.hpp

@@ -23,14 +23,14 @@
 #if RTC_ENABLE_MEDIA
 
 #include "include.hpp"
-#include "rtcphandler.hpp"
+#include "mediahandler.hpp"
 #include "message.hpp"
 #include "rtp.hpp"
 
 namespace rtc {
 
 // An RtcpSession can be plugged into a Track to handle the whole RTCP session
-class RTC_CPP_EXPORT RtcpReceivingSession : public RtcpHandler {
+class RTC_CPP_EXPORT RtcpReceivingSession : public MediaHandler {
 public:
 	message_ptr incoming(message_ptr ptr) override;
 	message_ptr outgoing(message_ptr ptr) override;

include/rtc/rtcpsrreporter.hpp

@@ -22,11 +22,11 @@
 
 #include "message.hpp"
 #include "rtppacketizationconfig.hpp"
-#include "messagehandlerelement.hpp"
+#include "mediahandlerelement.hpp"
 
 namespace rtc {
 
-class RTC_CPP_EXPORT RtcpSrReporter: public MessageHandlerElement {
+class RTC_CPP_EXPORT RtcpSrReporter: public MediaHandlerElement {
 
 	bool needsToReport = false;
 

include/rtc/track.hpp

@@ -24,7 +24,7 @@
 #include "include.hpp"
 #include "message.hpp"
 #include "queue.hpp"
-#include "rtcphandler.hpp"
+#include "mediahandler.hpp"
 
 #include <atomic>
 #include <variant>
@@ -62,8 +62,8 @@ public:
 	bool requestKeyframe();
 
 	// RTCP handler
-	void setRtcpHandler(std::shared_ptr<RtcpHandler> handler);
-	std::shared_ptr<RtcpHandler> getRtcpHandler();
+	void setRtcpHandler(std::shared_ptr<MediaHandler> handler);
+	std::shared_ptr<MediaHandler> getRtcpHandler();
 
 private:
 #if RTC_ENABLE_MEDIA
@@ -80,7 +80,7 @@ private:
 	Queue<message_ptr> mRecvQueue;
 
 	std::shared_mutex mRtcpHandlerMutex;
-	std::shared_ptr<RtcpHandler> mRtcpHandler;
+	std::shared_ptr<MediaHandler> mRtcpHandler;
 
 	friend class PeerConnection;
 };

src/capi.cpp

@@ -53,7 +53,7 @@ std::unordered_map<int, shared_ptr<PeerConnection>> peerConnectionMap;
 std::unordered_map<int, shared_ptr<DataChannel>> dataChannelMap;
 std::unordered_map<int, shared_ptr<Track>> trackMap;
 #if RTC_ENABLE_MEDIA
-std::unordered_map<int, shared_ptr<RtcpChainableHandler>> rtcpChainableHandlerMap;
+std::unordered_map<int, shared_ptr<MediaChainableHandler>> rtcpChainableHandlerMap;
 std::unordered_map<int, shared_ptr<RtcpSrReporter>> rtcpSrReporterMap;
 std::unordered_map<int, shared_ptr<RtpPacketizationConfig>> rtpConfigMap;
 #endif
@@ -165,7 +165,7 @@ void emplaceRtcpSrReporter(shared_ptr<RtcpSrReporter> ptr, int tr) {
 	rtcpSrReporterMap.emplace(std::make_pair(tr, ptr));
 }
 
-shared_ptr<RtcpChainableHandler> getRTCPChainableHandler(int id) {
+shared_ptr<MediaChainableHandler> getMediaChainableHandler(int id) {
 	std::lock_guard lock(mutex);
 	if (auto it = rtcpChainableHandlerMap.find(id); it != rtcpChainableHandlerMap.end()) {
 		return it->second;
@@ -174,7 +174,7 @@ shared_ptr<RtcpChainableHandler> getRTCPChainableHandler(int id) {
 	}
 }
 
-void emplaceRTCPChainableHandler(shared_ptr<RtcpChainableHandler> ptr, int tr) {
+void emplaceMediaChainableHandler(shared_ptr<MediaChainableHandler> ptr, int tr) {
 	std::lock_guard lock(mutex);
 	rtcpChainableHandlerMap.emplace(std::make_pair(tr, ptr));
 }
@@ -557,7 +557,7 @@ int rtcSetH264PacketizationHandler(int tr, uint32_t ssrc, const char *cname, uin
 		auto packetizer = std::make_shared<H264RtpPacketizer>(rtpConfig, maxFragmentSize);
 		// create H264 handler
 		auto h264Handler = std::make_shared<H264PacketizationHandler>(packetizer);
-		emplaceRTCPChainableHandler(h264Handler, tr);
+		emplaceMediaChainableHandler(h264Handler, tr);
 		emplaceRTPConfig(rtpConfig, tr);
 		// set handler
 		track->setRtcpHandler(h264Handler);
@@ -576,7 +576,7 @@ int rtcSetOpusPacketizationHandler(int tr, uint32_t ssrc, const char *cname, uin
 		auto packetizer = std::make_shared<OpusRtpPacketizer>(rtpConfig);
 		// create Opus handler
 		auto opusHandler = std::make_shared<OpusPacketizationHandler>(packetizer);
-        emplaceRTCPChainableHandler(opusHandler, tr);
+        emplaceMediaChainableHandler(opusHandler, tr);
 		emplaceRTPConfig(rtpConfig, tr);
 		// set handler
 		track->setRtcpHandler(opusHandler);
@@ -588,7 +588,7 @@ int rtcChainRtcpSrReporter(int tr) {
 		auto config = getRTPConfig(tr);
 		auto reporter = std::make_shared<RtcpSrReporter>(config);
 		emplaceRtcpSrReporter(reporter, tr);
-		auto chainableHandler = getRTCPChainableHandler(tr);
+		auto chainableHandler = getMediaChainableHandler(tr);
 		chainableHandler->addToChain(reporter);
 	});
 }
@@ -596,7 +596,7 @@ int rtcChainRtcpSrReporter(int tr) {
 int rtcChainRtcpNackResponder(int tr, unsigned maxStoredPacketsCount) {
 	return WRAP({
 		auto responder = std::make_shared<RtcpNackResponder>(maxStoredPacketsCount);
-		auto chainableHandler = getRTCPChainableHandler(tr);
+		auto chainableHandler = getMediaChainableHandler(tr);
 		chainableHandler->addToChain(responder);
 	});
 }

src/h264packetizationhandler.cpp

@@ -22,7 +22,7 @@
 
 namespace rtc {
 
-H264PacketizationHandler::H264PacketizationHandler(std::shared_ptr<H264RtpPacketizer> packetizer): RtcpChainableHandler(packetizer) { }
+H264PacketizationHandler::H264PacketizationHandler(std::shared_ptr<H264RtpPacketizer> packetizer): MediaChainableHandler(packetizer) { }
 
 } // namespace rtc
 

src/h264rtppacketizer.cpp

@@ -133,11 +133,11 @@ shared_ptr<NalUnits> H264RtpPacketizer::splitMessage(binary_ptr message) {
 
 H264RtpPacketizer::H264RtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig,
 									 uint16_t maximumFragmentSize)
-: RtpPacketizer(rtpConfig), MessageHandlerRootElement(), maximumFragmentSize(maximumFragmentSize), separator(Separator::Length) {}
+: RtpPacketizer(rtpConfig), MediaHandlerRootElement(), maximumFragmentSize(maximumFragmentSize), separator(Separator::Length) {}
 
 H264RtpPacketizer::H264RtpPacketizer(H264RtpPacketizer::Separator separator, std::shared_ptr<RtpPacketizationConfig> rtpConfig,
 									 uint16_t maximumFragmentSize)
-: RtpPacketizer(rtpConfig), MessageHandlerRootElement(), maximumFragmentSize(maximumFragmentSize), separator(separator) {}
+: RtpPacketizer(rtpConfig), MediaHandlerRootElement(), maximumFragmentSize(maximumFragmentSize), separator(separator) {}
 
 ChainedOutgoingProduct H264RtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
 	ChainedMessagesProduct packets = std::make_shared<std::vector<binary_ptr>>();

src/rtcpchainablehandler.cpp → src/mediachainablehandler.cpp

@@ -17,17 +17,17 @@
 
 #if RTC_ENABLE_MEDIA
 
-#include "rtcpchainablehandler.hpp"
+#include "mediachainablehandler.hpp"
 
 namespace rtc {
 
-RtcpChainableHandler::RtcpChainableHandler(std::shared_ptr<MessageHandlerRootElement> root): RtcpHandler(), root(root), leaf(root) { }
+MediaChainableHandler::MediaChainableHandler(std::shared_ptr<MediaHandlerRootElement> root): MediaHandler(), root(root), leaf(root) { }
 
-RtcpChainableHandler::~RtcpChainableHandler() {
+MediaChainableHandler::~MediaChainableHandler() {
 	leaf->recursiveRemoveChain();
 }
 
-bool RtcpChainableHandler::sendProduct(ChainedOutgoingResponseProduct product) {
+bool MediaChainableHandler::sendProduct(ChainedOutgoingResponseProduct product) {
 	bool result = true;
 	if (product.control.has_value()) {
 		auto sendResult = send(product.control.value());
@@ -53,7 +53,7 @@ bool RtcpChainableHandler::sendProduct(ChainedOutgoingResponseProduct product) {
 	return result;
 }
 
-std::optional<message_ptr> RtcpChainableHandler::handleIncomingBinary(message_ptr msg) {
+std::optional<message_ptr> MediaChainableHandler::handleIncomingBinary(message_ptr msg) {
 	assert(msg->type == Message::Binary);
 	auto messages = root->split(msg);
 	auto incoming = leaf->formIncomingBinaryMessage(messages, [this](ChainedOutgoingResponseProduct outgoing) {
@@ -66,7 +66,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleIncomingBinary(message_pt
 	}
 }
 
-std::optional<message_ptr> RtcpChainableHandler::handleIncomingControl(message_ptr msg) {
+std::optional<message_ptr> MediaChainableHandler::handleIncomingControl(message_ptr msg) {
 	assert(msg->type == Message::Control);
 	auto incoming = leaf->formIncomingControlMessage(msg, [this](ChainedOutgoingResponseProduct outgoing) {
 		return sendProduct(outgoing);
@@ -75,7 +75,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleIncomingControl(message_p
 	return incoming;
 }
 
-std::optional<message_ptr> RtcpChainableHandler::handleOutgoingBinary(message_ptr msg) {
+std::optional<message_ptr> MediaChainableHandler::handleOutgoingBinary(message_ptr msg) {
 	assert(msg->type == Message::Binary);
 	auto messages = make_chained_messages_product(msg);
 	auto optOutgoing = root->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages));
@@ -106,7 +106,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleOutgoingBinary(message_pt
 	return make_message(*lastMessage);
 }
 
-std::optional<message_ptr> RtcpChainableHandler::handleOutgoingControl(message_ptr msg) {
+std::optional<message_ptr> MediaChainableHandler::handleOutgoingControl(message_ptr msg) {
 	assert(msg->type == Message::Control);
 	auto optOutgoing = root->formOutgoingControlMessage(msg);
 	assert(!optOutgoing.has_value() || optOutgoing.value()->type == Message::Control);
@@ -117,7 +117,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleOutgoingControl(message_p
 	return optOutgoing.value();
 }
 
-message_ptr RtcpChainableHandler::outgoing(message_ptr ptr) {
+message_ptr MediaChainableHandler::outgoing(message_ptr ptr) {
 	assert(ptr);
 	if (!ptr) {
 		LOG_ERROR << "Outgoing message is nullptr, ignoring";
@@ -132,7 +132,7 @@ message_ptr RtcpChainableHandler::outgoing(message_ptr ptr) {
 	return ptr;
 }
 
-message_ptr RtcpChainableHandler::incoming(message_ptr ptr) {
+message_ptr MediaChainableHandler::incoming(message_ptr ptr) {
 	if (!ptr) {
 		LOG_ERROR << "Incoming message is nullptr, ignoring";
 		return nullptr;
@@ -146,7 +146,7 @@ message_ptr RtcpChainableHandler::incoming(message_ptr ptr) {
 	return ptr;
 }
 
-bool RtcpChainableHandler::send(message_ptr msg) {
+bool MediaChainableHandler::send(message_ptr msg) {
 	try {
 		outgoingCallback(std::move(msg));
 		return true;
@@ -156,7 +156,7 @@ bool RtcpChainableHandler::send(message_ptr msg) {
 	return false;
 }
 
-void RtcpChainableHandler::addToChain(std::shared_ptr<MessageHandlerElement> chainable) {
+void MediaChainableHandler::addToChain(std::shared_ptr<MediaHandlerElement> chainable) {
 	assert(leaf);
 	leaf = leaf->chainWith(chainable);
 }

src/messagehandlerelement.cpp → src/mediahandlerelement.cpp

@@ -17,7 +17,7 @@
 
 #if RTC_ENABLE_MEDIA
 
-#include "messagehandlerelement.hpp"
+#include "mediahandlerelement.hpp"
 
 namespace rtc {
 
@@ -42,9 +42,9 @@ ChainedIncomingProduct::ChainedIncomingProduct(std::optional<ChainedMessagesProd
 ChainedIncomingControlProduct::ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingResponseProduct> outgoing)
 : incoming(incoming), outgoing(outgoing) { }
 
-MessageHandlerElement::MessageHandlerElement() { }
+MediaHandlerElement::MediaHandlerElement() { }
 
-void MessageHandlerElement::removeFromChain() {
+void MediaHandlerElement::removeFromChain() {
 	if (upstream.has_value()) {
 		upstream.value()->downstream = downstream;
 	}
@@ -55,7 +55,7 @@ void MessageHandlerElement::removeFromChain() {
 	downstream = nullopt;
 }
 
-void MessageHandlerElement::recursiveRemoveChain() {
+void MediaHandlerElement::recursiveRemoveChain() {
 	if (downstream.has_value()) {
 		// `recursiveRemoveChain` removes last strong reference to downstream element
 		// we need to keep strong reference to prevent deallocation of downstream element
@@ -66,7 +66,7 @@ void MessageHandlerElement::recursiveRemoveChain() {
 	removeFromChain();
 }
 
-std::optional<ChainedOutgoingResponseProduct> MessageHandlerElement::processOutgoingResponse(ChainedOutgoingResponseProduct messages) {
+std::optional<ChainedOutgoingResponseProduct> MediaHandlerElement::processOutgoingResponse(ChainedOutgoingResponseProduct messages) {
 	if (messages.messages.has_value()) {
 		if (upstream.has_value()) {
 			auto msgs = upstream.value()->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages.messages.value(), messages.control));
@@ -97,7 +97,7 @@ std::optional<ChainedOutgoingResponseProduct> MessageHandlerElement::processOutg
 	}
 }
 
-void MessageHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoingResponseProduct> outgoing, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+void MediaHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoingResponseProduct> outgoing, std::function<bool (ChainedOutgoingResponseProduct)> send) {
 	if (outgoing.has_value()) {
 		auto message = outgoing.value();
 		auto response = processOutgoingResponse(message);
@@ -111,7 +111,7 @@ void MessageHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoing
 	}
 }
 
-std::optional<message_ptr> MessageHandlerElement::formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+std::optional<message_ptr> MediaHandlerElement::formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send) {
 	assert(message);
 	auto product = processIncomingControlMessage(message);
 	prepareAndSendResponse(product.outgoing, send);
@@ -131,7 +131,7 @@ std::optional<message_ptr> MessageHandlerElement::formIncomingControlMessage(mes
 	}
 }
 
-std::optional<ChainedMessagesProduct> MessageHandlerElement::formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+std::optional<ChainedMessagesProduct> MediaHandlerElement::formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send) {
 	assert(messages && !messages->empty());
 	auto product = processIncomingBinaryMessage(messages);
 	prepareAndSendResponse(product.outgoing, send);
@@ -151,7 +151,7 @@ std::optional<ChainedMessagesProduct> MessageHandlerElement::formIncomingBinaryM
 	}
 }
 
-std::optional<message_ptr> MessageHandlerElement::formOutgoingControlMessage(message_ptr message) {
+std::optional<message_ptr> MediaHandlerElement::formOutgoingControlMessage(message_ptr message) {
 	assert(message);
 	auto newMessage = processOutgoingControlMessage(message);
 	assert(newMessage);
@@ -166,7 +166,7 @@ std::optional<message_ptr> MessageHandlerElement::formOutgoingControlMessage(mes
 	}
 }
 
-std::optional<ChainedOutgoingProduct> MessageHandlerElement::formOutgoingBinaryMessage(ChainedOutgoingProduct product) {
+std::optional<ChainedOutgoingProduct> MediaHandlerElement::formOutgoingBinaryMessage(ChainedOutgoingProduct product) {
 	assert(product.messages && !product.messages->empty());
 	auto newProduct = processOutgoingBinaryMessage(product.messages, product.control);
 	assert(!product.control.has_value() || newProduct.control.has_value());
@@ -191,23 +191,23 @@ std::optional<ChainedOutgoingProduct> MessageHandlerElement::formOutgoingBinaryM
 	}
 }
 
-ChainedIncomingControlProduct MessageHandlerElement::processIncomingControlMessage(message_ptr messages) {
+ChainedIncomingControlProduct MediaHandlerElement::processIncomingControlMessage(message_ptr messages) {
 	return {messages};
 }
 
-message_ptr MessageHandlerElement::processOutgoingControlMessage(message_ptr messages) {
+message_ptr MediaHandlerElement::processOutgoingControlMessage(message_ptr messages) {
 	return messages;
 }
 
-ChainedIncomingProduct MessageHandlerElement::processIncomingBinaryMessage(ChainedMessagesProduct messages) {
+ChainedIncomingProduct MediaHandlerElement::processIncomingBinaryMessage(ChainedMessagesProduct messages) {
 	return {messages};
 }
 
-ChainedOutgoingProduct MessageHandlerElement::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct MediaHandlerElement::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
 	return {messages, control};
 }
 
-std::shared_ptr<MessageHandlerElement> MessageHandlerElement::chainWith(std::shared_ptr<MessageHandlerElement> upstream) {
+std::shared_ptr<MediaHandlerElement> MediaHandlerElement::chainWith(std::shared_ptr<MediaHandlerElement> upstream) {
 	assert(this->upstream == nullopt);
 	assert(upstream->downstream == nullopt);
 	this->upstream = upstream;

src/messagehandlerrootelement.cpp → src/mediahandlerrootelement.cpp

@@ -17,11 +17,11 @@
 
 #if RTC_ENABLE_MEDIA
 
-#include "messagehandlerrootelement.hpp"
+#include "mediahandlerrootelement.hpp"
 
 namespace rtc {
 
-message_ptr MessageHandlerRootElement::reduce(ChainedMessagesProduct messages) {
+message_ptr MediaHandlerRootElement::reduce(ChainedMessagesProduct messages) {
 	if (messages && !messages->empty()) {
 		auto msg_ptr = messages->front();
 		if (msg_ptr) {
@@ -34,7 +34,7 @@ message_ptr MessageHandlerRootElement::reduce(ChainedMessagesProduct messages) {
 	}
 }
 
-ChainedMessagesProduct MessageHandlerRootElement::split(message_ptr message) {
+ChainedMessagesProduct MediaHandlerRootElement::split(message_ptr message) {
 	return make_chained_messages_product(message);
 }
 

src/opuspacketizationhandler.cpp

@@ -23,7 +23,7 @@
 namespace rtc {
 
 OpusPacketizationHandler::OpusPacketizationHandler(std::shared_ptr<OpusRtpPacketizer> packetizer)
-: RtcpChainableHandler(packetizer) { }
+: MediaChainableHandler(packetizer) { }
 
 } // namespace rtc
 

src/opusrtppacketizer.cpp

@@ -23,7 +23,7 @@
 namespace rtc {
 
 OpusRtpPacketizer::OpusRtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig)
-: RtpPacketizer(rtpConfig), MessageHandlerRootElement() {}
+: RtpPacketizer(rtpConfig), MediaHandlerRootElement() {}
 
 binary_ptr OpusRtpPacketizer::packetize(binary_ptr payload, bool setMark) {
 	assert(!setMark);

src/rtcpnackresponder.cpp

@@ -66,7 +66,7 @@ void RtcpNackResponder::Storage::store(binary_ptr packet) {
 }
 
 RtcpNackResponder::RtcpNackResponder(unsigned maxStoredPacketCount)
-: MessageHandlerElement(), storage(std::make_shared<Storage>(maxStoredPacketCount)) { }
+: MediaHandlerElement(), storage(std::make_shared<Storage>(maxStoredPacketCount)) { }
 
 ChainedIncomingControlProduct RtcpNackResponder::processIncomingControlMessage(message_ptr message) {
 	std::optional<ChainedOutgoingResponseProduct> optPackets = ChainedOutgoingResponseProduct();

src/rtcpsrreporter.cpp

@@ -52,7 +52,7 @@ void RtcpSrReporter::addToReport(RTP *rtp, uint32_t rtpSize) {
 }
 
 RtcpSrReporter::RtcpSrReporter(std::shared_ptr<RtpPacketizationConfig> rtpConfig)
-: MessageHandlerElement(), rtpConfig(rtpConfig) {}
+: MediaHandlerElement(), rtpConfig(rtpConfig) {}
 
 uint64_t RtcpSrReporter::secondsToNTP(double seconds) {
 	return std::round(seconds * double(uint64_t(1) << 32));

src/track.cpp

@@ -161,7 +161,7 @@ bool Track::outgoing([[maybe_unused]] message_ptr message) {
 #endif
 }
 
-void Track::setRtcpHandler(std::shared_ptr<RtcpHandler> handler) {
+void Track::setRtcpHandler(std::shared_ptr<MediaHandler> handler) {
 	std::unique_lock lock(mRtcpHandlerMutex);
 	mRtcpHandler = std::move(handler);
 	if (mRtcpHandler) {
@@ -178,7 +178,7 @@ bool Track::requestKeyframe() {
 	return false;
 }
 
-std::shared_ptr<RtcpHandler> Track::getRtcpHandler() {
+std::shared_ptr<MediaHandler> Track::getRtcpHandler() {
 	std::shared_lock lock(mRtcpHandlerMutex);
 	return mRtcpHandler;
 }