datachannel-sys 0.23.0+0.23.2

Native bindings to libdatachannel.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

/**
 * Copyright (c) 2024 Paul-Louis Ageneau
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#if RTC_ENABLE_MEDIA

#include "rtpdepacketizer.hpp"
#include "rtp.hpp"

#include "impl/logcounter.hpp"

namespace rtc {

RtpDepacketizer::RtpDepacketizer() : mClockRate(0) {}

RtpDepacketizer::RtpDepacketizer(uint32_t clockRate) : mClockRate(clockRate) {}

RtpDepacketizer::~RtpDepacketizer() {}

void RtpDepacketizer::incoming(message_vector &messages,
                               [[maybe_unused]] const message_callback &send) {
	message_vector result;
	for (auto &message : messages) {
		if (message->type == Message::Control) {
			result.push_back(std::move(message));
			continue;
		}

		if (message->size() < sizeof(RtpHeader)) {
			PLOG_VERBOSE << "RTP packet is too small, size=" << message->size();
			continue;
		}

		auto pkt = reinterpret_cast<const rtc::RtpHeader *>(message->data());
		auto headerSize = sizeof(rtc::RtpHeader) + pkt->csrcCount() + pkt->getExtensionHeaderSize();
		result.push_back(make_message(message->begin() + headerSize, message->end(),
		                              createFrameInfo(pkt->timestamp(), pkt->payloadType())));
	}

	messages.swap(result);
}

shared_ptr<FrameInfo> RtpDepacketizer::createFrameInfo(uint32_t timestamp,
                                                       uint8_t payloadType) const {
	auto frameInfo = std::make_shared<FrameInfo>(timestamp);
	if (mClockRate > 0)
		frameInfo->timestampSeconds =
		    std::chrono::duration<double>(double(timestamp) / double(mClockRate));
	frameInfo->payloadType = payloadType;
	return frameInfo;
}

VideoRtpDepacketizer::VideoRtpDepacketizer() : RtpDepacketizer(ClockRate) {}

VideoRtpDepacketizer::~VideoRtpDepacketizer() {}

void VideoRtpDepacketizer::incoming(message_vector &messages,
                                    [[maybe_unused]] const message_callback &send) {
	message_vector result;
	for (auto message : messages) {
		if (message->type == Message::Control) {
			result.push_back(std::move(message));
			continue;
		}

		if (message->size() < sizeof(RtpHeader)) {
			PLOG_VERBOSE << "RTP packet is too small, size=" << message->size();
			continue;
		}

		auto header = reinterpret_cast<const RtpHeader *>(message->data());

		if (!mBuffer.empty()) {
			auto first = *mBuffer.begin();
			auto firstHeader = reinterpret_cast<const RtpHeader *>(first->data());
			if (firstHeader->timestamp() != header->timestamp()) {
				if (auto frame = reassemble(mBuffer))
					result.push_back(frame);

				mBuffer.clear();
			}
		}

		mBuffer.insert(std::move(message));

		if (header->marker()) {
			if (auto frame = reassemble(mBuffer))
				result.push_back(std::move(frame));

			mBuffer.clear();
		}
	};

	messages.swap(result);
}

bool VideoRtpDepacketizer::sequence_cmp::operator()(message_ptr a, message_ptr b) const {
	assert(a->size() >= sizeof(RtpHeader) && b->size() >= sizeof(RtpHeader));
	auto ha = reinterpret_cast<const rtc::RtpHeader *>(a->data());
	auto hb = reinterpret_cast<const rtc::RtpHeader *>(b->data());
	int16_t d = int16_t(hb->seqNumber() - ha->seqNumber());
	return d > 0;
}

} // namespace rtc

#endif /* RTC_ENABLE_MEDIA */