mediasoup-sys 0.12.0

FFI bindings to C++ libmediasoup-worker
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

#define MS_CLASS "RTC::RTP::Codecs::Opus"
// #define MS_LOG_DEV_LEVEL 3

#include "RTC/RTP/Codecs/Opus.hpp"
#include "Logger.hpp"

namespace RTC
{
	namespace RTP
	{
		namespace Codecs
		{
			/* Class methods. */

			Opus::PayloadDescriptor* Opus::Parse(const uint8_t* data, size_t len)
			{
				MS_TRACE();

				if (len < 1)
				{
					MS_WARN_DEV("ignoring empty payload");

					return nullptr;
				}

				std::unique_ptr<PayloadDescriptor> payloadDescriptor(new PayloadDescriptor());

				const uint8_t byte = data[0];

				payloadDescriptor->stereo = (byte >> 2) & 0x01;
				payloadDescriptor->code   = byte & 0x03;

				switch (payloadDescriptor->code)
				{
					case 0:
					case 1:
					{
						// In code 0 and 1 packets, DTX is determined by total length = 1 (TOC
						// byte only).
						if (len == 1)
						{
							payloadDescriptor->isDtx = true;
						}

						break;
					}

					case 2:
					{
						// As per spec, a 1-byte code 2 packet is always invalid.
						if (len == 1)
						{
							MS_WARN_DEV("ignoring invalid payload (1)");

							return nullptr;
						}

						// In code 2 packets, DTX is determined by total length = 2 (TOC byte
						// only). Per spec, the only valid 2-byte code 2 packet is one where
						// the length of both frames is zero.
						if (len == 2)
						{
							payloadDescriptor->isDtx = true;
						}

						break;
					}

					case 3:
					{
						// As per spec, a 1-byte code 3 packet is always invalid.
						if (len == 1)
						{
							MS_WARN_DEV("ignoring invalid payload (2)");

							return nullptr;
						}

						// A code 3 packet can never be DTX.

						break;
					}

					default:;
				}

				return payloadDescriptor.release();
			}

			void Opus::ProcessRtpPacket(RTP::Packet* packet)
			{
				MS_TRACE();

				auto* data = packet->GetPayload();
				auto len   = packet->GetPayloadLength();

				PayloadDescriptor* payloadDescriptor = Opus::Parse(data, len);

				if (!payloadDescriptor)
				{
					return;
				}

				auto* payloadDescriptorHandler = new PayloadDescriptorHandler(payloadDescriptor);

				packet->SetPayloadDescriptorHandler(payloadDescriptorHandler);
			}

			/* Instance methods. */

			void Opus::PayloadDescriptor::Dump(int indentation) const
			{
				MS_TRACE();

				MS_DUMP_CLEAN(indentation, "<Opus::PayloadDescriptor>");
				MS_DUMP_CLEAN(indentation, "  stereo: %" PRIu8, this->stereo);
				MS_DUMP_CLEAN(indentation, "  code: %" PRIu8, this->code);
				MS_DUMP_CLEAN(indentation, "  is dtx: %s", this->isDtx ? "true" : "false");
				MS_DUMP_CLEAN(indentation, "</Opus::PayloadDescriptor>");
			}

			Opus::PayloadDescriptorHandler::PayloadDescriptorHandler(Opus::PayloadDescriptor* payloadDescriptor)
			{
				MS_TRACE();

				this->payloadDescriptor.reset(payloadDescriptor);
			}

			bool Opus::PayloadDescriptorHandler::Process(
			  Codecs::EncodingContext* encodingContext, RTP::Packet* /*packet*/, bool& /*marker*/)
			{
				MS_TRACE();

				auto* context = static_cast<Codecs::Opus::EncodingContext*>(encodingContext);

				return !(this->payloadDescriptor->isDtx && context->GetIgnoreDtx());
			};
		} // namespace Codecs
	} // namespace RTP
} // namespace RTC