mii/libdatachannel
1
0
Fork 0
mirror of https://github.com/mii443/libdatachannel.git synced 2025-08-22 23:25:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename RtcpHandler to MediaHandler

Browse Source
This commit is contained in:
Filip Klembara
2021-02-05 13:17:59 +01:00
parent b5699239cc
commit 2b7dc4c529
25 changed files with 102 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
CMakeLists.txt
View File

@ -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
)

4
include/rtc/h264packetizationhandler.hpp
View File

@ -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

4
include/rtc/h264rtppacketizer.hpp
View File

@ -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;

22
include/rtc/rtcpchainablehandler.hpp → include/rtc/mediachainablehandler.hpp
View File

@ -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

8
include/rtc/rtcphandler.hpp → include/rtc/mediahandler.hpp
View File

@ -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

16
include/rtc/messagehandlerelement.hpp → include/rtc/mediahandlerelement.hpp
View File

@ -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

12
include/rtc/messagehandlerrootelement.hpp → include/rtc/mediahandlerrootelement.hpp
View File

@ -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

4
include/rtc/opuspacketizationhandler.hpp
View File

@ -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.

4
include/rtc/opusrtppacketizer.hpp
View File

@ -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;

4
include/rtc/rtc.hpp
View File

@ -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"

4
include/rtc/rtcpnackresponder.hpp
View File

@ -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 {

4
include/rtc/rtcpreceivingsession.hpp
View File

@ -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;

4
include/rtc/rtcpsrreporter.hpp
View File

@ -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;

8
include/rtc/track.hpp
View File

@ -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;
};

14
src/capi.cpp
View File

@ -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);
});
}

2
src/h264packetizationhandler.cpp
View File

@ -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

4
src/h264rtppacketizer.cpp
View File

@ -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>>();

24
src/rtcpchainablehandler.cpp → src/mediachainablehandler.cpp
View File

@ -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);
}

30
src/messagehandlerelement.cpp → src/mediahandlerelement.cpp
View File

@ -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;

6
src/messagehandlerrootelement.cpp → src/mediahandlerrootelement.cpp
View File

@ -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);
}

2
src/opuspacketizationhandler.cpp
View File

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

2
src/opusrtppacketizer.cpp
View File

@ -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);

2
src/rtcpnackresponder.cpp
View File

@ -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();

2
src/rtcpsrreporter.cpp
View File

@ -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));

4
src/track.cpp
View File

@ -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;
}