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

Renamed Track::*RtcpHandler methods to Track::*MediaHandler

Browse Source
This commit is contained in:
Paul-Louis Ageneau
2021-03-03 12:25:43 +01:00
parent 767694a8b8
commit 30117bc3a3
8 changed files with 27 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
examples/media/main.cpp
View File

@ -68,7 +68,7 @@ int main() {
auto track = pc->addTrack(media); auto track = pc->addTrack(media);
auto session = std::make_shared<rtc::RtcpReceivingSession>(); auto session = std::make_shared<rtc::RtcpReceivingSession>();
track->setRtcpHandler(session); track->setMediaHandler(session);
track->onMessage( track->onMessage(
[session, sock, addr](rtc::binary message) { [session, sock, addr](rtc::binary message) {

2
examples/sfu-media/main.cpp
View File

@ -60,7 +60,7 @@ int main() {
pc->setLocalDescription(); pc->setLocalDescription();
auto session = std::make_shared<rtc::RtcpReceivingSession>(); auto session = std::make_shared<rtc::RtcpReceivingSession>();
track->setRtcpHandler(session); track->setMediaHandler(session);
const rtc::SSRC targetSSRC = 4; const rtc::SSRC targetSSRC = 4;

4
examples/streamer/main.cpp
View File

@ -230,7 +230,7 @@ shared_ptr<ClientTrackData> addVideo(const shared_ptr<PeerConnection> pc, const
auto nackResponder = make_shared<RtcpNackResponder>(); auto nackResponder = make_shared<RtcpNackResponder>();
h264Handler->addToChain(nackResponder); h264Handler->addToChain(nackResponder);
// set handler // set handler
track->setRtcpHandler(h264Handler); track->setMediaHandler(h264Handler);
track->onOpen(onOpen); track->onOpen(onOpen);
auto trackData = make_shared<ClientTrackData>(track, srReporter); auto trackData = make_shared<ClientTrackData>(track, srReporter);
return trackData; return trackData;
@ -254,7 +254,7 @@ shared_ptr<ClientTrackData> addAudio(const shared_ptr<PeerConnection> pc, const
auto nackResponder = make_shared<RtcpNackResponder>(); auto nackResponder = make_shared<RtcpNackResponder>();
opusHandler->addToChain(nackResponder); opusHandler->addToChain(nackResponder);
// set handler // set handler
track->setRtcpHandler(opusHandler); track->setMediaHandler(opusHandler);
track->onOpen(onOpen); track->onOpen(onOpen);
auto trackData = make_shared<ClientTrackData>(track, srReporter); auto trackData = make_shared<ClientTrackData>(track, srReporter);
return trackData; return trackData;

11
include/rtc/track.hpp
View File

@ -20,8 +20,8 @@
#define RTC_TRACK_H #define RTC_TRACK_H
#include "channel.hpp" #include "channel.hpp"
#include "description.hpp"
#include "common.hpp" #include "common.hpp"
#include "description.hpp"
#include "mediahandler.hpp" #include "mediahandler.hpp"
#include "message.hpp" #include "message.hpp"
@ -57,9 +57,12 @@ public:
bool requestKeyframe(); bool requestKeyframe();
// RTCP handler void setMediaHandler(shared_ptr<MediaHandler> handler);
void setRtcpHandler(shared_ptr<MediaHandler> handler); shared_ptr<MediaHandler> getMediaHandler();
shared_ptr<MediaHandler> getRtcpHandler();
// Deprecated, use setMediaHandler() and getMediaHandler()
inline void setRtcpHandler(shared_ptr<MediaHandler> handler) { setMediaHandler(handler); }
inline shared_ptr<MediaHandler> getRtcpHandler() { return getMediaHandler(); }
private: private:
using CheshireCat<impl::Track>::impl; using CheshireCat<impl::Track>::impl;

4
src/capi.cpp
View File

@ -550,7 +550,7 @@ int rtcSetH264PacketizationHandler(int tr, uint32_t ssrc, const char *cname, uin
emplaceMediaChainableHandler(h264Handler, tr); emplaceMediaChainableHandler(h264Handler, tr);
emplaceRTPConfig(rtpConfig, tr); emplaceRTPConfig(rtpConfig, tr);
// set handler // set handler
track->setRtcpHandler(h264Handler); track->setMediaHandler(h264Handler);
return RTC_ERR_SUCCESS; return RTC_ERR_SUCCESS;
}); });
} }
@ -570,7 +570,7 @@ int rtcSetOpusPacketizationHandler(int tr, uint32_t ssrc, const char *cname, uin
emplaceMediaChainableHandler(opusHandler, tr); emplaceMediaChainableHandler(opusHandler, tr);
emplaceRTPConfig(rtpConfig, tr); emplaceRTPConfig(rtpConfig, tr);
// set handler // set handler
track->setRtcpHandler(opusHandler); track->setMediaHandler(opusHandler);
return RTC_ERR_SUCCESS; return RTC_ERR_SUCCESS;
}); });
} }

14
src/impl/track.cpp
View File

@ -58,7 +58,7 @@ void Track::setDescription(Description::Media description) {
void Track::close() { void Track::close() {
mIsClosed = true; mIsClosed = true;
setRtcpHandler(nullptr); setMediaHandler(nullptr);
resetCallbacks(); resetCallbacks();
} }
@ -120,7 +120,7 @@ void Track::incoming(message_ptr message) {
return; return;
} }
if (auto handler = getRtcpHandler()) { if (auto handler = getMediaHandler()) {
message = handler->incoming(message); message = handler->incoming(message);
if (!message) if (!message)
return; return;
@ -146,7 +146,7 @@ bool Track::outgoing(message_ptr message) {
return false; return false;
} }
if (auto handler = getRtcpHandler()) { if (auto handler = getMediaHandler()) {
message = handler->outgoing(message); message = handler->outgoing(message);
if (!message) if (!message)
return false; return false;
@ -179,18 +179,18 @@ bool Track::transportSend([[maybe_unused]] message_ptr message) {
#endif #endif
} }
void Track::setRtcpHandler(shared_ptr<MediaHandler> handler) { void Track::setMediaHandler(shared_ptr<MediaHandler> handler) {
{ {
std::unique_lock lock(mMutex); std::unique_lock lock(mMutex);
mRtcpHandler = handler; mMediaHandler = handler;
} }
handler->onOutgoing(std::bind(&Track::transportSend, this, std::placeholders::_1)); handler->onOutgoing(std::bind(&Track::transportSend, this, std::placeholders::_1));
} }
shared_ptr<MediaHandler> Track::getRtcpHandler() { shared_ptr<MediaHandler> Track::getMediaHandler() {
std::shared_lock lock(mMutex); std::shared_lock lock(mMutex);
return mRtcpHandler; return mMediaHandler;
} }
} // namespace rtc::impl } // namespace rtc::impl

6
src/impl/track.hpp
View File

@ -58,8 +58,8 @@ public:
Description::Media description() const; Description::Media description() const;
void setDescription(Description::Media description); void setDescription(Description::Media description);
shared_ptr<MediaHandler> getRtcpHandler(); shared_ptr<MediaHandler> getMediaHandler();
void setRtcpHandler(shared_ptr<MediaHandler> handler); void setMediaHandler(shared_ptr<MediaHandler> handler);
#if RTC_ENABLE_MEDIA #if RTC_ENABLE_MEDIA
void open(shared_ptr<DtlsSrtpTransport> transport); void open(shared_ptr<DtlsSrtpTransport> transport);
@ -74,7 +74,7 @@ private:
#endif #endif
Description::Media mMediaDescription; Description::Media mMediaDescription;
shared_ptr<MediaHandler> mRtcpHandler; shared_ptr<MediaHandler> mMediaHandler;
mutable std::shared_mutex mMutex; mutable std::shared_mutex mMutex;

8
src/track.cpp
View File

@ -50,17 +50,17 @@ size_t Track::maxMessageSize() const {
return impl()->maxMessageSize(); return impl()->maxMessageSize();
} }
void Track::setRtcpHandler(shared_ptr<MediaHandler> handler) { void Track::setMediaHandler(shared_ptr<MediaHandler> handler) {
impl()->setRtcpHandler(std::move(handler)); impl()->setMediaHandler(std::move(handler));
} }
bool Track::requestKeyframe() { bool Track::requestKeyframe() {
if (auto handler = impl()->getRtcpHandler()) if (auto handler = impl()->getMediaHandler())
return handler->requestKeyframe(); return handler->requestKeyframe();
return false; return false;
} }
shared_ptr<MediaHandler> Track::getRtcpHandler() { return impl()->getRtcpHandler(); } shared_ptr<MediaHandler> Track::getMediaHandler() { return impl()->getMediaHandler(); }
} // namespace rtc } // namespace rtc