mediasoup-sys 0.10.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
141
142

#define MS_CLASS "RTC::Serializable"
// #define MS_LOG_DEV_LEVEL 3

#include "RTC/Serializable.hpp"
#include "Logger.hpp"
#include "MediaSoupErrors.hpp"
#include <cstring> // std::memmove(), std::memset()
#include <utility> // std::move()

namespace RTC
{
	void Serializable::Serialize(uint8_t* buffer, size_t bufferLength)
	{
		MS_TRACE();

		if (bufferLength < this->length)
		{
			MS_THROW_TYPE_ERROR(
			  "bufferLength (%zu bytes) is lower than current length (%zu bytes)",
			  bufferLength,
			  this->length);
		}

		std::memmove(buffer, this->buffer, this->length);

		this->buffer       = buffer;
		this->bufferLength = bufferLength;
		this->frozen       = false;
	}

	void Serializable::Consolidate()
	{
		MS_TRACE();

		AssertNotFrozen();

		if (!this->consolidatedListener)
		{
			MS_THROW_ERROR("consolidated listener not set");
		}

		this->consolidatedListener();
	}

	void Serializable::SetBufferLength(size_t bufferLength)
	{
		MS_TRACE();

		AssertNotFrozen();

		if (bufferLength < this->length)
		{
			MS_THROW_TYPE_ERROR(
			  "buffer length (%zu bytes) is lower than current length (%zu bytes)",
			  bufferLength,
			  this->length);
		}

		if (bufferLength == 0)
		{
			MS_THROW_TYPE_ERROR("bufferLength cannot be 0");
		}

		this->bufferLength = bufferLength;
	}

	void Serializable::SetLength(size_t length)
	{
		MS_TRACE();

		AssertNotFrozen();

		if (length > this->bufferLength)
		{
			MS_THROW_TYPE_ERROR(
			  "length (%zu bytes) is larger than internal buffer maximum length (%zu bytes)",
			  length,
			  this->bufferLength);
		}

		if (length == 0)
		{
			MS_THROW_TYPE_ERROR("length cannot be 0");
		}

		this->length = length;
	}

	void Serializable::CloneInto(Serializable* serializable) const
	{
		MS_TRACE();

		if (serializable->GetBufferLength() < this->length)
		{
			delete serializable;

			MS_THROW_TYPE_ERROR(
			  "bufferLength (%zu bytes) is lower than current length (%zu bytes)",
			  bufferLength,
			  this->length);
		}

		std::memmove(const_cast<uint8_t*>(serializable->GetBuffer()), this->buffer, this->length);

		// Need to manually set Serializable length.
		serializable->SetLength(this->length);
	}

	void Serializable::FillPadding(uint8_t padding)
	{
		MS_TRACE();

		AssertNotFrozen();

		if (padding > this->length)
		{
			MS_THROW_TYPE_ERROR(
			  "padding (%" PRIu8 " bytes) cannot be greater than length (%zu bytes)", padding, this->length);
		}

		std::memset(this->buffer + this->length - padding, 0x00, padding);
	}

	void Serializable::SetConsolidatedListener(const ConsolidatedListener&& listener)
	{
		MS_TRACE();

		AssertNotFrozen();

		this->consolidatedListener = std::move(listener);
	}

	void Serializable::AssertNotFrozen() const
	{
		MS_TRACE();

		if (this->frozen)
		{
			MS_THROW_ERROR("Serializable is frozen");
		}
	}
} // namespace RTC