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

Cleaned up, renamed and moved a few classes for consistency

Browse Source
This commit is contained in:
Paul-Louis Ageneau
2021-01-25 11:23:14 +01:00
parent 470d145a9a
commit fe4afcef85
27 changed files with 196 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
CMakeLists.txt
View File

@ -59,7 +59,7 @@ set(LIBDATACHANNEL_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/src/message.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/peerconnection.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/logcounter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/rtcp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpreceivingsession.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/sctptransport.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/threadpool.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/tls.cpp
@ -67,7 +67,7 @@ set(LIBDATACHANNEL_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/src/processor.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/capi.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/rtppacketizationconfig.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpsenderreportable.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpsenderreporter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/rtppacketizer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/opusrtppacketizer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/opuspacketizationhandler.cpp
@ -92,7 +92,8 @@ 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/rtcp.hpp
${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtcphandler.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
${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/log.hpp

2
examples/streamer/helpers.cpp
View File

@ -60,7 +60,7 @@ int gettimeofday(struct timeval *tv, struct timezone *tz)
using namespace std;
using namespace rtc;
ClientTrackData::ClientTrackData(shared_ptr<Track> track, shared_ptr<RTCPSenderReportable> sender) {
ClientTrackData::ClientTrackData(shared_ptr<Track> track, shared_ptr<RtcpSenderReporter> sender) {
this->track = track;
this->sender = sender;
}

4
examples/streamer/helpers.hpp
View File

@ -23,9 +23,9 @@
struct ClientTrackData {
std::shared_ptr<rtc::Track> track;
std::shared_ptr<rtc::RTCPSenderReportable> sender;
std::shared_ptr<rtc::RtcpSenderReporter> sender;
ClientTrackData(std::shared_ptr<rtc::Track> track, std::shared_ptr<rtc::RTCPSenderReportable> sender);
ClientTrackData(std::shared_ptr<rtc::Track> track, std::shared_ptr<rtc::RtcpSenderReporter> sender);
};
struct Client {

12
examples/streamer/main.cpp
View File

@ -217,9 +217,9 @@ shared_ptr<ClientTrackData> addVideo(const shared_ptr<PeerConnection> pc, const
video.addSSRC(ssrc, cname, msid);
auto track = pc->addTrack(video);
// create RTP configuration
auto rtpConfig = shared_ptr<RTPPacketizationConfig>(new RTPPacketizationConfig(ssrc, cname, payloadType, H264RTPPacketizer::defaultClockRate));
auto rtpConfig = shared_ptr<RtpPacketizationConfig>(new RtpPacketizationConfig(ssrc, cname, payloadType, H264RtpPacketizer::defaultClockRate));
// create packetizer
auto packetizer = shared_ptr<H264RTPPacketizer>(new H264RTPPacketizer(rtpConfig));
auto packetizer = shared_ptr<H264RtpPacketizer>(new H264RtpPacketizer(rtpConfig));
// create H264 and RTCP SP handler
shared_ptr<H264PacketizationHandler> h264Handler(new H264PacketizationHandler(H264PacketizationHandler::Separator::Length, packetizer));
// set handler
@ -235,9 +235,9 @@ shared_ptr<ClientTrackData> addAudio(const shared_ptr<PeerConnection> pc, const
audio.addSSRC(ssrc, cname, msid);
auto track = pc->addTrack(audio);
// create RTP configuration
auto rtpConfig = shared_ptr<RTPPacketizationConfig>(new RTPPacketizationConfig(ssrc, cname, payloadType, OpusRTPPacketizer::defaultClockRate));
auto rtpConfig = shared_ptr<RtpPacketizationConfig>(new RtpPacketizationConfig(ssrc, cname, payloadType, OpusRtpPacketizer::defaultClockRate));
// create packetizer
auto packetizer = make_shared<OpusRTPPacketizer>(rtpConfig);
auto packetizer = make_shared<OpusRtpPacketizer>(rtpConfig);
// create opus and RTCP SP handler
auto opusHandler = make_shared<OpusPacketizationHandler>(packetizer);
// set handler
@ -449,8 +449,8 @@ void addToStream(shared_ptr<Client> client, bool isAddingVideo) {
auto currentTime_s = currentTime_us / (1000 * 1000);
// set start time of stream
video->sender->rtpConfig->setStartTime(currentTime_s, RTPPacketizationConfig::EpochStart::T1970);
audio->sender->rtpConfig->setStartTime(currentTime_s, RTPPacketizationConfig::EpochStart::T1970);
video->sender->rtpConfig->setStartTime(currentTime_s, RtpPacketizationConfig::EpochStart::T1970);
audio->sender->rtpConfig->setStartTime(currentTime_s, RtpPacketizationConfig::EpochStart::T1970);
// start stat recording of RTCP SR
video->sender->startRecording();

16
include/rtc/h264packetizationhandler.hpp
View File

@ -16,22 +16,22 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef H264PacketizationHandler_hpp
#define H264PacketizationHandler_hpp
#ifndef H264_PACKETIZATION_HANDLER_H
#define H264_PACKETIZATION_HANDLER_H
#if RTC_ENABLE_MEDIA
#include "h264rtppacketizer.hpp"
#include "nalunit.hpp"
#include "rtcp.hpp"
#include "rtcpsenderreportable.hpp"
#include "rtcphandler.hpp"
#include "rtcpsenderreporter.hpp"
namespace rtc {
/// Handler for H264 packetization
class RTC_CPP_EXPORT H264PacketizationHandler : public RtcpHandler, public RTCPSenderReportable {
class RTC_CPP_EXPORT H264PacketizationHandler : public RtcpHandler, public RtcpSenderReporter {
/// RTP packetizer for H264
const std::shared_ptr<H264RTPPacketizer> packetizer;
const std::shared_ptr<H264RtpPacketizer> packetizer;
const uint16_t maximumFragmentSize;
@ -49,7 +49,7 @@ public:
/// Construct handler for H264 packetization.
/// @param separator Nal units separator
/// @param packetizer RTP packetizer for h264
H264PacketizationHandler(Separator separator, std::shared_ptr<H264RTPPacketizer> packetizer,
H264PacketizationHandler(Separator separator, std::shared_ptr<H264RtpPacketizer> packetizer,
uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
/// Returns message unchanged
@ -73,4 +73,4 @@ private:
#endif /* RTC_ENABLE_MEDIA */
#endif /* H264PacketizationHandler_hpp */
#endif /* H264_PACKETIZATION_HANDLER_H */

10
include/rtc/h264rtppacketizer.hpp
View File

@ -16,8 +16,8 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef H264RTPPacketizer_hpp
#define H264RTPPacketizer_hpp
#ifndef H264RtpPacketizer_hpp
#define H264RtpPacketizer_hpp
#if RTC_ENABLE_MEDIA
@ -26,7 +26,7 @@
namespace rtc {
/// RTP packetization of h264 payload
class RTC_CPP_EXPORT H264RTPPacketizer : public rtc::RTPPacketizer {
class RTC_CPP_EXPORT H264RtpPacketizer : public rtc::RtpPacketizer {
public:
/// Default clock rate for H264 in RTP
@ -36,11 +36,11 @@ public:
/// @note RTP configuration is used in packetization process which may change some configuration
/// properties such as sequence number.
/// @param rtpConfig RTP configuration
H264RTPPacketizer(std::shared_ptr<rtc::RTPPacketizationConfig> rtpConfig);
H264RtpPacketizer(std::shared_ptr<rtc::RtpPacketizationConfig> rtpConfig);
};
} // namespace rtc
#endif /* RTC_ENABLE_MEDIA */
#endif /* H264RTPPacketizer_hpp */
#endif /* H264RtpPacketizer_hpp */

16
include/rtc/opuspacketizationhandler.hpp
View File

@ -16,26 +16,26 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OpusPacketizationHandler_hpp
#define OpusPacketizationHandler_hpp
#ifndef RTC_OPUS_PACKETIZATION_HANDLER_H
#define RTC_OPUS_PACKETIZATION_HANDLER_H
#if RTC_ENABLE_MEDIA
#include "opusrtppacketizer.hpp"
#include "rtcp.hpp"
#include "rtcpsenderreportable.hpp"
#include "rtcphandler.hpp"
#include "rtcpsenderreporter.hpp"
namespace rtc {
/// Handler for opus packetization
class RTC_CPP_EXPORT OpusPacketizationHandler : public RtcpHandler, public RTCPSenderReportable {
class RTC_CPP_EXPORT OpusPacketizationHandler : public RtcpHandler, public RtcpSenderReporter {
/// RTP packetizer for opus
const std::shared_ptr<OpusRTPPacketizer> packetizer;
const std::shared_ptr<OpusRtpPacketizer> packetizer;
public:
/// Construct handler for opus packetization.
/// @param packetizer RTP packetizer for opus
OpusPacketizationHandler(std::shared_ptr<OpusRTPPacketizer> packetizer);
OpusPacketizationHandler(std::shared_ptr<OpusRtpPacketizer> packetizer);
/// Returns message unchanged
/// @param ptr message
@ -49,4 +49,4 @@ public:
#endif /* RTC_ENABLE_MEDIA */
#endif /* OpusPacketizationHandler_hpp */
#endif /* RTC_OPUS_PACKETIZATION_HANDLER_H */

12
include/rtc/opusrtppacketizer.hpp
View File

@ -16,8 +16,8 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OpusRTPPacketizer_hpp
#define OpusRTPPacketizer_hpp
#ifndef RTC_OPUS_RTP_PACKETIZER_H
#define RTC_OPUS_RTP_PACKETIZER_H
#if RTC_ENABLE_MEDIA
@ -26,7 +26,7 @@
namespace rtc {
/// RTP packetizer for opus
class RTC_CPP_EXPORT OpusRTPPacketizer : public rtc::RTPPacketizer {
class RTC_CPP_EXPORT OpusRtpPacketizer : public RtpPacketizer {
public:
/// default clock rate used in opus RTP communication
@ -36,17 +36,17 @@ public:
/// @note RTP configuration is used in packetization process which may change some configuration
/// properties such as sequence number.
/// @param rtpConfig RTP configuration
OpusRTPPacketizer(std::shared_ptr<rtc::RTPPacketizationConfig> rtpConfig);
OpusRtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig);
/// Creates RTP packet for given payload based on `rtpConfig`.
/// @note This function increase sequence number after packetization.
/// @param payload RTP payload
/// @param setMark This needs to be `false` for all RTP packets with opus payload
rtc::message_ptr packetize(rtc::binary payload, bool setMark) override;
message_ptr packetize(binary payload, bool setMark) override;
};
} // namespace rtc
#endif /* RTC_ENABLE_MEDIA */
#endif /* OpusRTPPacketizer_hpp */
#endif /* RTC_OPUS_RTP_PACKETIZER_H */

1
include/rtc/peerconnection.hpp
View File

@ -31,6 +31,7 @@
#include "track.hpp"
#include <atomic>
#include <chrono>
#include <functional>
#include <future>
#include <list>

2
include/rtc/rtc.h
View File

@ -282,7 +282,7 @@ int rtcSetTrackRTPTimestamp(int id, uint32_t timestamp);
/// @param timestamp Pointer for result
int rtcGetPreviousTrackSenderReportTimestamp(int id, uint32_t * timestamp);
/// Set `NeedsToReport` flag in RTCPSenderReportable handler identified by given track id
/// Set `NeedsToReport` flag in RtcpSenderReporter handler identified by given track id
/// @param id Track id
int rtcSetNeedsToSendRTCPSR(int id);

7
include/rtc/rtc.hpp
View File

@ -27,11 +27,14 @@
#if RTC_ENABLE_MEDIA
// opus/h264 streaming
// RTCP handling
#include "rtcpreceivingsession.hpp"
// Opus/h264 streaming
#include "h264packetizationhandler.hpp"
#include "opuspacketizationhandler.hpp"
#endif /* RTC_ENABLE_MEDIA */
#endif // RTC_ENABLE_MEDIA
// C API
#include "rtc.h"

48
include/rtc/rtcphandler.hpp Normal file
View File

@ -0,0 +1,48 @@
/**
* Copyright (c) 2020 Staz Modrzynski
* Copyright (c) 2020 Paul-Louis Ageneau
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef RTC_RTCP_HANDLER_H
#define RTC_RTCP_HANDLER_H
#include "include.hpp"
#include "message.hpp"
namespace rtc {
class RTC_CPP_EXPORT RtcpHandler {
protected:
// Use this callback when trying to send custom data (such as RTCP) to the client.
synchronized_callback<message_ptr> outgoingCallback;
public:
// Called when there is traffic coming from the peer
virtual message_ptr incoming(message_ptr ptr) = 0;
// Called when there is traffic that needs to be sent to the peer
virtual message_ptr outgoing(message_ptr ptr) = 0;
// This callback is used to send traffic back to the peer.
void onOutgoing(const std::function<void(message_ptr)> &cb);
virtual bool requestKeyframe() { return false; }
};
} // namespace rtc
#endif // RTC_RTCP_HANDLER_H

52
include/rtc/rtcp.hpp → include/rtc/rtcpreceivingsession.hpp
View File

@ -17,58 +17,24 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef RTC_RTCP_H
#define RTC_RTCP_H
#ifndef RTC_RTCP_RECEIVING_SESSION_H
#define RTC_RTCP_RECEIVING_SESSION_H
#include <utility>
#if RTC_ENABLE_MEDIA
#include "include.hpp"
#include "log.hpp"
#include "rtcphandler.hpp"
#include "message.hpp"
#include "rtp.hpp"
namespace rtc {
class RTC_CPP_EXPORT RtcpHandler {
protected:
/**
* Use this callback when trying to send custom data (such as RTCP) to the client.
*/
synchronized_callback<rtc::message_ptr> outgoingCallback;
public:
/**
* Called when there is traffic coming from the peer
* @param ptr
* @return
*/
virtual rtc::message_ptr incoming(rtc::message_ptr ptr) = 0;
/**
* Called when there is traffic that needs to be sent to the peer
* @param ptr
* @return
*/
virtual rtc::message_ptr outgoing(rtc::message_ptr ptr) = 0;
/**
* This callback is used to send traffic back to the peer.
* This callback skips calling the track's methods.
* @param cb
*/
void onOutgoing(const std::function<void(rtc::message_ptr)> &cb);
virtual bool requestKeyframe() { return false; }
};
class Track;
// An RtcpSession can be plugged into a Track to handle the whole RTCP session
class RTC_CPP_EXPORT RtcpReceivingSession : public RtcpHandler {
public:
rtc::message_ptr incoming(rtc::message_ptr ptr) override;
rtc::message_ptr outgoing(rtc::message_ptr ptr) override;
bool send(rtc::message_ptr ptr);
message_ptr incoming(message_ptr ptr) override;
message_ptr outgoing(message_ptr ptr) override;
bool send(message_ptr ptr);
void requestBitrate(unsigned int newBitrate);
@ -88,4 +54,6 @@ protected:
} // namespace rtc
#endif // RTC_RTCP_H
#endif // RTC_ENABLE_MEDIA
#endif // RTC_RTCP_RECEIVING_SESSION_H

12
include/rtc/rtcpsenderreportable.hpp → include/rtc/rtcpsenderreporter.hpp
View File

@ -16,8 +16,8 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef RTCPSenderReporter_hpp
#define RTCPSenderReporter_hpp
#ifndef RTC_RTCP_SENDER_REPORTABLE_H
#define RTC_RTCP_SENDER_REPORTABLE_H
#if RTC_ENABLE_MEDIA
@ -27,7 +27,7 @@
namespace rtc {
/// Class for sending RTCP SR
class RTC_CPP_EXPORT RTCPSenderReportable {
class RTC_CPP_EXPORT RtcpSenderReporter {
bool needsToReport = false;
uint32_t packetCount = 0;
@ -50,9 +50,9 @@ public:
const uint32_t &previousReportedTimestamp = _previousReportedTimestamp;
/// RTP configuration
const std::shared_ptr<RTPPacketizationConfig> rtpConfig;
const std::shared_ptr<RtpPacketizationConfig> rtpConfig;
RTCPSenderReportable(std::shared_ptr<RTPPacketizationConfig> rtpConfig);
RtcpSenderReporter(std::shared_ptr<RtpPacketizationConfig> rtpConfig);
/// Set `needsToReport` flag. Sender report will be sent before next RTP packet with same
/// timestamp.
@ -90,4 +90,4 @@ protected:
#endif /* RTC_ENABLE_MEDIA */
#endif /* RTCPSenderReporter_hpp */
#endif /* RTC_RTCP_SENDER_REPORTABLE_H */

12
include/rtc/rtppacketizationconfig.hpp
View File

@ -16,8 +16,8 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef RTPPacketizationConfig_hpp
#define RTPPacketizationConfig_hpp
#ifndef RTC_RTP_PACKETIZATION_CONFIG_H
#define RTC_RTP_PACKETIZATION_CONFIG_H
#if RTC_ENABLE_MEDIA
@ -26,10 +26,10 @@
namespace rtc {
/// RTP configuration used in packetization process
class RTC_CPP_EXPORT RTPPacketizationConfig {
class RTC_CPP_EXPORT RtpPacketizationConfig {
uint32_t _startTimestamp = 0;
double _startTime_s = 0;
RTPPacketizationConfig(const RTPPacketizationConfig &) = delete;
RtpPacketizationConfig(const RtpPacketizationConfig &) = delete;
public:
const SSRC ssrc;
@ -65,7 +65,7 @@ public:
/// @param sequenceNumber Initial sequence number of RTP packets (random number is choosed if
/// nullopt)
/// @param timestamp Initial timastamp of RTP packets (random number is choosed if nullopt)
RTPPacketizationConfig(SSRC ssrc, std::string cname, uint8_t payloadType, uint32_t clockRate,
RtpPacketizationConfig(SSRC ssrc, std::string cname, uint8_t payloadType, uint32_t clockRate,
std::optional<uint16_t> sequenceNumber = std::nullopt,
std::optional<uint32_t> timestamp = std::nullopt);
@ -92,4 +92,4 @@ public:
#endif /* RTC_ENABLE_MEDIA */
#endif /* RTPPacketizationConfig_hpp */
#endif /* RTC_RTP_PACKETIZATION_CONFIG_H */

16
include/rtc/rtppacketizer.hpp
View File

@ -16,8 +16,8 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef RTPPacketizer_hpp
#define RTPPacketizer_hpp
#ifndef RTC_RTP_PACKETIZER_H
#define RTC_RTP_PACKETIZER_H
#if RTC_ENABLE_MEDIA
@ -26,19 +26,19 @@
namespace rtc {
/// Class responsizble for rtp packetization
class RTC_CPP_EXPORT RTPPacketizer {
/// Class responsible for RTP packetization
class RTC_CPP_EXPORT RtpPacketizer {
static const auto rtpHeaderSize = 12;
public:
// rtp configuration
const std::shared_ptr<RTPPacketizationConfig> rtpConfig;
// RTP configuration
const std::shared_ptr<RtpPacketizationConfig> rtpConfig;
/// Constructs packetizer with given RTP configuration.
/// @note RTP configuration is used in packetization process which may change some configuration
/// properties such as sequence number.
/// @param rtpConfig RTP configuration
RTPPacketizer(std::shared_ptr<RTPPacketizationConfig> rtpConfig);
RtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig);
/// Creates RTP packet for given payload based on `rtpConfig`.
/// @note This function increase sequence number after packetization.
@ -51,4 +51,4 @@ public:
#endif /* RTC_ENABLE_MEDIA */
#endif /* RTPPacketizer_hpp */
#endif /* RTC_RTP_PACKETIZER_H */

2
include/rtc/track.hpp
View File

@ -24,7 +24,7 @@
#include "include.hpp"
#include "message.hpp"
#include "queue.hpp"
#include "rtcp.hpp"
#include "rtcphandler.hpp"
#include <atomic>
#include <variant>

32
src/capi.cpp
View File

@ -53,8 +53,8 @@ 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<RTCPSenderReportable>> rtcpSenderMap;
std::unordered_map<int, shared_ptr<RTPPacketizationConfig>> rtpConfigMap;
std::unordered_map<int, shared_ptr<RtcpSenderReporter>> rtcpSenderMap;
std::unordered_map<int, shared_ptr<RtpPacketizationConfig>> rtpConfigMap;
#endif
#if RTC_ENABLE_WEBSOCKET
std::unordered_map<int, shared_ptr<WebSocket>> webSocketMap;
@ -149,20 +149,20 @@ void eraseTrack(int tr) {
#if RTC_ENABLE_MEDIA
shared_ptr<RTCPSenderReportable> getRTCPSender(int id) {
shared_ptr<RtcpSenderReporter> getRTCPSender(int id) {
std::lock_guard lock(mutex);
if (auto it = rtcpSenderMap.find(id); it != rtcpSenderMap.end())
return it->second;
else
throw std::invalid_argument("RTCPSenderReportable ID does not exist");
throw std::invalid_argument("RtcpSenderReporter ID does not exist");
}
void emplaceRTCPSender(shared_ptr<RTCPSenderReportable> ptr, int tr) {
void emplaceRTCPSender(shared_ptr<RtcpSenderReporter> ptr, int tr) {
std::lock_guard lock(mutex);
rtcpSenderMap.emplace(std::make_pair(tr, ptr));
}
shared_ptr<RTPPacketizationConfig> getRTPConfig(int id) {
shared_ptr<RtpPacketizationConfig> getRTPConfig(int id) {
std::lock_guard lock(mutex);
if (auto it = rtpConfigMap.find(id); it != rtpConfigMap.end())
return it->second;
@ -170,7 +170,7 @@ shared_ptr<RTPPacketizationConfig> getRTPConfig(int id) {
throw std::invalid_argument("RTPConfiguration ID does not exist");
}
void emplaceRTPConfig(shared_ptr<RTPPacketizationConfig> ptr, int tr) {
void emplaceRTPConfig(shared_ptr<RtpPacketizationConfig> ptr, int tr) {
std::lock_guard lock(mutex);
rtpConfigMap.emplace(std::make_pair(tr, ptr));
}
@ -190,14 +190,14 @@ Description::Direction rtcDirectionToDirection(rtcDirection direction) {
}
}
shared_ptr<RTPPacketizationConfig>
getNewRTPPacketizationConfig(uint32_t ssrc, const char *cname, uint8_t payloadType,
shared_ptr<RtpPacketizationConfig>
getNewRtpPacketizationConfig(uint32_t ssrc, const char *cname, uint8_t payloadType,
uint32_t clockRate, uint16_t sequenceNumber, uint32_t timestamp) {
if (!cname) {
throw std::invalid_argument("Unexpected null pointer for cname");
}
return std::make_shared<RTPPacketizationConfig>(ssrc, cname, payloadType, clockRate,
return std::make_shared<RtpPacketizationConfig>(ssrc, cname, payloadType, clockRate,
sequenceNumber, timestamp);
}
@ -533,10 +533,10 @@ int rtcSetH264PacketizationHandler(int tr, uint32_t ssrc, const char *cname, uin
return WRAP({
auto track = getTrack(tr);
// create RTP configuration
auto rtpConfig = getNewRTPPacketizationConfig(ssrc, cname, payloadType, clockRate,
auto rtpConfig = getNewRtpPacketizationConfig(ssrc, cname, payloadType, clockRate,
sequenceNumber, timestamp);
// create packetizer
auto packetizer = shared_ptr<H264RTPPacketizer>(new H264RTPPacketizer(rtpConfig));
auto packetizer = shared_ptr<H264RtpPacketizer>(new H264RtpPacketizer(rtpConfig));
// create H264 and RTCP SP handler
shared_ptr<H264PacketizationHandler> h264Handler(
new H264PacketizationHandler(H264PacketizationHandler::Separator::Length, packetizer, maxFragmentSize));
@ -553,10 +553,10 @@ int rtcSetOpusPacketizationHandler(int tr, uint32_t ssrc, const char *cname, uin
return WRAP({
auto track = getTrack(tr);
// create RTP configuration
auto rtpConfig = getNewRTPPacketizationConfig(ssrc, cname, payloadType, clockRate,
auto rtpConfig = getNewRtpPacketizationConfig(ssrc, cname, payloadType, clockRate,
sequenceNumber, timestamp);
// create packetizer
auto packetizer = shared_ptr<OpusRTPPacketizer>(new OpusRTPPacketizer(rtpConfig));
auto packetizer = shared_ptr<OpusRtpPacketizer>(new OpusRtpPacketizer(rtpConfig));
// create Opus and RTCP SP handler
shared_ptr<OpusPacketizationHandler> opusHandler(new OpusPacketizationHandler(packetizer));
emplaceRTCPSender(opusHandler, tr);
@ -570,9 +570,9 @@ int rtcSetRtpConfigurationStartTime(int id, double startTime_s, bool timeInterva
uint32_t timestamp) {
return WRAP({
auto config = getRTPConfig(id);
auto epoch = RTPPacketizationConfig::EpochStart::T1900;
auto epoch = RtpPacketizationConfig::EpochStart::T1900;
if (timeIntervalSince1970) {
epoch = RTPPacketizationConfig::EpochStart::T1970;
epoch = RtpPacketizationConfig::EpochStart::T1970;
}
config->setStartTime(startTime_s, epoch, timestamp);
});

4
src/h264packetizationhandler.cpp
View File

@ -155,9 +155,9 @@ message_ptr H264PacketizationHandler::outgoing(message_ptr ptr) {
}
H264PacketizationHandler::H264PacketizationHandler(Separator separator,
std::shared_ptr<H264RTPPacketizer> packetizer,
std::shared_ptr<H264RtpPacketizer> packetizer,
uint16_t maximumFragmentSize)
: RtcpHandler(), rtc::RTCPSenderReportable(packetizer->rtpConfig), packetizer(packetizer),
: RtcpHandler(), rtc::RtcpSenderReporter(packetizer->rtpConfig), packetizer(packetizer),
maximumFragmentSize(maximumFragmentSize), separator(separator) {
senderReportOutgoingCallback = [this](message_ptr msg) { outgoingCallback(msg); };

4
src/h264rtppacketizer.cpp
View File

@ -22,8 +22,8 @@
namespace rtc {
H264RTPPacketizer::H264RTPPacketizer(std::shared_ptr<RTPPacketizationConfig> rtpConfig)
: RTPPacketizer(rtpConfig) {}
H264RtpPacketizer::H264RtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig)
: RtpPacketizer(rtpConfig) {}
} // namespace rtc

8
src/logcounter.hpp
View File

@ -16,13 +16,14 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef WEBRTC_SERVER_LOGCOUNTER_HPP
#define WEBRTC_SERVER_LOGCOUNTER_HPP
#ifndef RTC_SERVER_LOGCOUNTER_HPP
#define RTC_SERVER_LOGCOUNTER_HPP
#include "include.hpp"
#include "threadpool.hpp"
namespace rtc {
class LogCounter {
private:
struct LogData {
@ -41,6 +42,7 @@ public:
LogCounter &operator++(int);
};
} // namespace rtc
#endif // WEBRTC_SERVER_LOGCOUNTER_HPP
#endif // RTC_SERVER_LOGCOUNTER_HPP

4
src/opuspacketizationhandler.cpp
View File

@ -22,8 +22,8 @@
namespace rtc {
OpusPacketizationHandler::OpusPacketizationHandler(std::shared_ptr<OpusRTPPacketizer> packetizer)
: RtcpHandler(), RTCPSenderReportable(packetizer->rtpConfig), packetizer(packetizer) {
OpusPacketizationHandler::OpusPacketizationHandler(std::shared_ptr<OpusRtpPacketizer> packetizer)
: RtcpHandler(), RtcpSenderReporter(packetizer->rtpConfig), packetizer(packetizer) {
senderReportOutgoingCallback = [this](message_ptr msg) { outgoingCallback(msg); };
}

8
src/opusrtppacketizer.cpp
View File

@ -22,12 +22,12 @@
namespace rtc {
OpusRTPPacketizer::OpusRTPPacketizer(std::shared_ptr<RTPPacketizationConfig> rtpConfig)
: RTPPacketizer(rtpConfig) {}
OpusRtpPacketizer::OpusRtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig)
: RtpPacketizer(rtpConfig) {}
message_ptr OpusRTPPacketizer::packetize(binary payload, bool setMark) {
message_ptr OpusRtpPacketizer::packetize(binary payload, bool setMark) {
assert(!setMark);
return RTPPacketizer::packetize(payload, false);
return RtpPacketizer::packetize(payload, false);
}
} // namespace rtc

39
src/rtcp.cpp → src/rtcpreceivingsession.cpp
View File

@ -17,10 +17,12 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "rtcp.hpp"
#if RTC_ENABLE_MEDIA
#include "rtcpreceivingsession.hpp"
#include "logcounter.hpp"
#include "track.hpp"
#include <cmath>
#include <utility>
@ -30,18 +32,17 @@
#include <arpa/inet.h>
#endif
static rtc::LogCounter COUNTER_BAD_RTP_HEADER(plog::warning, "Number of malformed RTP headers");
static rtc::LogCounter COUNTER_UNKNOWN_PPID(plog::warning, "Number of Unknown PPID messages");
static rtc::LogCounter COUNTER_BAD_NOTIF_LEN(plog::warning, "Number of Bad-Lengthed notifications");
static rtc::LogCounter COUNTER_BAD_SCTP_STATUS(plog::warning,
"Number of unknown SCTP_STATUS errors");
namespace rtc {
rtc::message_ptr RtcpReceivingSession::outgoing(rtc::message_ptr ptr) { return ptr; }
static LogCounter COUNTER_BAD_RTP_HEADER(plog::warning, "Number of malformed RTP headers");
static LogCounter COUNTER_UNKNOWN_PPID(plog::warning, "Number of Unknown PPID messages");
static LogCounter COUNTER_BAD_NOTIF_LEN(plog::warning, "Number of Bad-Lengthed notifications");
static LogCounter COUNTER_BAD_SCTP_STATUS(plog::warning, "Number of unknown SCTP_STATUS errors");
rtc::message_ptr RtcpReceivingSession::incoming(rtc::message_ptr ptr) {
if (ptr->type == rtc::Message::Type::Binary) {
message_ptr RtcpReceivingSession::outgoing(message_ptr ptr) { return ptr; }
message_ptr RtcpReceivingSession::incoming(message_ptr ptr) {
if (ptr->type == Message::Type::Binary) {
auto rtp = reinterpret_cast<const RTP *>(ptr->data());
// https://tools.ietf.org/html/rfc3550#appendix-A.1
@ -65,7 +66,7 @@ rtc::message_ptr RtcpReceivingSession::incoming(rtc::message_ptr ptr) {
return ptr;
}
assert(ptr->type == rtc::Message::Type::Control);
assert(ptr->type == Message::Type::Control);
auto rr = reinterpret_cast<const RTCP_RR *>(ptr->data());
if (rr->header.payloadType() == 201) {
// RR
@ -95,8 +96,7 @@ void RtcpReceivingSession::requestBitrate(unsigned int newBitrate) {
}
void RtcpReceivingSession::pushREMB(unsigned int bitrate) {
rtc::message_ptr msg =
rtc::make_message(RTCP_REMB::sizeWithSSRCs(1), rtc::Message::Type::Control);
message_ptr msg = make_message(RTCP_REMB::sizeWithSSRCs(1), Message::Type::Control);
auto remb = reinterpret_cast<RTCP_REMB *>(msg->data());
remb->preparePacket(mSsrc, 1, bitrate);
remb->setSsrc(0, mSsrc);
@ -105,7 +105,7 @@ void RtcpReceivingSession::pushREMB(unsigned int bitrate) {
}
void RtcpReceivingSession::pushRR(unsigned int lastSR_delay) {
auto msg = rtc::make_message(RTCP_RR::sizeWithReportBlocks(1), rtc::Message::Type::Control);
auto msg = make_message(RTCP_RR::sizeWithReportBlocks(1), Message::Type::Control);
auto rr = reinterpret_cast<RTCP_RR *>(msg->data());
rr->preparePacket(mSsrc, 1);
rr->getReportBlock(0)->preparePacket(mSsrc, 0, 0, uint16_t(mGreatestSeqNo), 0, 0, mSyncNTPTS,
@ -131,13 +131,16 @@ bool RtcpReceivingSession::requestKeyframe() {
}
void RtcpReceivingSession::pushPLI() {
auto msg = rtc::make_message(rtc::RTCP_PLI::size(), rtc::Message::Type::Control);
auto *pli = reinterpret_cast<rtc::RTCP_PLI *>(msg->data());
auto msg = make_message(RTCP_PLI::size(), Message::Type::Control);
auto *pli = reinterpret_cast<RTCP_PLI *>(msg->data());
pli->preparePacket(mSsrc);
send(msg);
}
void RtcpHandler::onOutgoing(const std::function<void(rtc::message_ptr)> &cb) {
this->outgoingCallback = synchronized_callback<rtc::message_ptr>(cb);
void RtcpHandler::onOutgoing(const std::function<void(message_ptr)> &cb) {
this->outgoingCallback = synchronized_callback<message_ptr>(cb);
}
} // namespace rtc
#endif // RTC_ENABLE_MEDIA

16
src/rtcpsenderreportable.cpp → src/rtcpsenderreporter.cpp
View File

@ -18,37 +18,37 @@
#if RTC_ENABLE_MEDIA
#include "rtcpsenderreportable.hpp"
#include "rtcpsenderreporter.hpp"
namespace rtc {
void RTCPSenderReportable::startRecording() {
void RtcpSenderReporter::startRecording() {
_previousReportedTimestamp = rtpConfig->timestamp;
timeOffset = rtpConfig->startTime_s - rtpConfig->timestampToSeconds(rtpConfig->timestamp);
}
void RTCPSenderReportable::sendReport(uint32_t timestamp) {
void RtcpSenderReporter::sendReport(uint32_t timestamp) {
auto sr = getSenderReport(timestamp);
_previousReportedTimestamp = timestamp;
senderReportOutgoingCallback(move(sr));
}
void RTCPSenderReportable::addToReport(RTP *rtp, uint32_t rtpSize) {
void RtcpSenderReporter::addToReport(RTP *rtp, uint32_t rtpSize) {
packetCount += 1;
assert(!rtp->padding());
payloadOctets += rtpSize - rtp->getSize();
}
RTCPSenderReportable::RTCPSenderReportable(std::shared_ptr<RTPPacketizationConfig> rtpConfig)
RtcpSenderReporter::RtcpSenderReporter(std::shared_ptr<RtpPacketizationConfig> rtpConfig)
: rtpConfig(rtpConfig) {}
uint64_t RTCPSenderReportable::secondsToNTP(double seconds) {
uint64_t RtcpSenderReporter::secondsToNTP(double seconds) {
return std::round(seconds * double(uint64_t(1) << 32));
}
void RTCPSenderReportable::setNeedsToReport() { needsToReport = true; }
void RtcpSenderReporter::setNeedsToReport() { needsToReport = true; }
message_ptr RTCPSenderReportable::getSenderReport(uint32_t timestamp) {
message_ptr RtcpSenderReporter::getSenderReport(uint32_t timestamp) {
auto srSize = RTCP_SR::size(0);
auto msg = make_message(srSize + RTCP_SDES::size({{uint8_t(rtpConfig->cname.size())}}),
Message::Type::Control);

16
src/rtppacketizationconfig.cpp
View File

@ -22,7 +22,7 @@
namespace rtc {
RTPPacketizationConfig::RTPPacketizationConfig(SSRC ssrc, string cname, uint8_t payloadType,
RtpPacketizationConfig::RtpPacketizationConfig(SSRC ssrc, string cname, uint8_t payloadType,
uint32_t clockRate,
std::optional<uint16_t> sequenceNumber,
std::optional<uint32_t> timestamp)
@ -42,7 +42,7 @@ RTPPacketizationConfig::RTPPacketizationConfig(SSRC ssrc, string cname, uint8_t
this->_startTimestamp = this->timestamp;
}
void RTPPacketizationConfig::setStartTime(double startTime_s, EpochStart epochStart,
void RtpPacketizationConfig::setStartTime(double startTime_s, EpochStart epochStart,
std::optional<uint32_t> startTimestamp) {
this->_startTime_s = startTime_s + static_cast<unsigned long long>(epochStart);
if (startTimestamp.has_value()) {
@ -53,20 +53,20 @@ void RTPPacketizationConfig::setStartTime(double startTime_s, EpochStart epochSt
}
}
double RTPPacketizationConfig::getSecondsFromTimestamp(uint32_t timestamp, uint32_t clockRate) {
double RtpPacketizationConfig::getSecondsFromTimestamp(uint32_t timestamp, uint32_t clockRate) {
return double(timestamp) / double(clockRate);
}
double RTPPacketizationConfig::timestampToSeconds(uint32_t timestamp) {
return RTPPacketizationConfig::getSecondsFromTimestamp(timestamp, clockRate);
double RtpPacketizationConfig::timestampToSeconds(uint32_t timestamp) {
return RtpPacketizationConfig::getSecondsFromTimestamp(timestamp, clockRate);
}
uint32_t RTPPacketizationConfig::getTimestampFromSeconds(double seconds, uint32_t clockRate) {
uint32_t RtpPacketizationConfig::getTimestampFromSeconds(double seconds, uint32_t clockRate) {
return uint32_t(seconds * clockRate);
}
uint32_t RTPPacketizationConfig::secondsToTimestamp(double seconds) {
return RTPPacketizationConfig::getTimestampFromSeconds(seconds, clockRate);
uint32_t RtpPacketizationConfig::secondsToTimestamp(double seconds) {
return RtpPacketizationConfig::getTimestampFromSeconds(seconds, clockRate);
}
} // namespace rtc

4
src/rtppacketizer.cpp
View File

@ -22,10 +22,10 @@
namespace rtc {
RTPPacketizer::RTPPacketizer(std::shared_ptr<RTPPacketizationConfig> rtpConfig)
RtpPacketizer::RtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig)
: rtpConfig(rtpConfig) {}
message_ptr RTPPacketizer::packetize(binary payload, bool setMark) {
message_ptr RtpPacketizer::packetize(binary payload, bool setMark) {
auto msg = make_message(rtpHeaderSize + payload.size());
auto *rtp = (RTP *)msg->data();
rtp->setPayloadType(rtpConfig->payloadType);