mediasoup-sys 0.12.2

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

#ifndef MS_RTC_RTP_CODECS_DEPENDENCY_DESCRIPTOR_HPP
#define MS_RTC_RTP_CODECS_DEPENDENCY_DESCRIPTOR_HPP

#include "common.hpp"
#include "Utils.hpp" // BitStream.
#include <ankerl/unordered_dense.h>

namespace RTC
{
	namespace RTP
	{
		namespace Codecs
		{
			struct DependencyDescriptor
			{
				class Listener
				{
				public:
					virtual ~Listener() = default;

				public:
					virtual void OnDependencyDescriptorUpdated(const uint8_t* data, size_t len) = 0;
				};

			public:
				enum class DecodeTargetIndication : uint8_t
				{
					NOT_PRESENT = 0,
					DISCARDABLE = 1,
					SWITCH      = 2,
					REQUIRED    = 3
				};

			private:
				static ankerl::unordered_dense::map<DecodeTargetIndication, std::string> dtiToString;

			private:
				struct FrameDependencyTemplate
				{
					FrameDependencyTemplate(uint32_t spatialLayer, uint32_t temporalLayer)
					  : spatialLayer(spatialLayer), temporalLayer(temporalLayer)
					{
					}

					uint32_t spatialLayer;
					uint32_t temporalLayer;
					std::vector<DecodeTargetIndication> decodeTargetIndications;
					std::vector<uint8_t> frameDiffs;
					std::vector<uint8_t> frameDiffChains;
				};

			public:
				struct TemplateDependencyStructure
				{
					uint32_t spatialLayers{ 0 };
					uint32_t temporalLayers{ 0 };
					uint8_t templateIdOffset{ 0 };
					uint8_t decodeTargetCount{ 0 };
					std::vector<FrameDependencyTemplate> templateLayers;
				};

			public:
				bool startOfFrame{ false };
				bool endOfFrame{ false };
				uint8_t frameDependencyTemplateId{ 0 };
				uint16_t frameNumber{ 0 };
				uint8_t templateId{ 0 };
				// Given by argument.
				TemplateDependencyStructure* templateDependencyStructure;
				std::vector<uint8_t> decodeTargetProtectedBy;
				std::optional<uint32_t> activeDecodeTargetsBitmask{ std::nullopt };
				// Calculated.
				uint8_t temporalLayer{ 0 };
				uint8_t spatialLayer{ 0 };
				// Whether the frame is a key frame. Set to true if the descriptor contains template layers.
				bool isKeyFrame{ false };

			private:
				DependencyDescriptor::Listener* listener{ nullptr };

			public:
				static DependencyDescriptor* Parse(
				  const uint8_t* data,
				  size_t len,
				  DependencyDescriptor::Listener* listener,
				  std::unique_ptr<TemplateDependencyStructure>& templateDependencyStructure);

				DependencyDescriptor(
				  const uint8_t* data,
				  size_t len,
				  DependencyDescriptor::Listener* listener,
				  TemplateDependencyStructure* templateDependencyStructure);

				void Dump(int indentation = 0) const;
				void UpdateListener(DependencyDescriptor::Listener* listener);
				const uint8_t* Serialize(uint8_t& len);
				bool UpdateActiveDecodeTargets(uint32_t maxSpatialLayer, uint32_t maxTemporalLayer);

			private:
				uint8_t GetSpatialLayer() const;
				uint8_t GetTemporalLayer() const;

				bool ReadMandatoryDescriptorFields();
				bool ReadExtendedDescriptorFields();
				bool ReadTemplateDependencyStructure();
				bool ReadTemplateLayers();
				bool ReadTemplateDecodeTargetIndications();
				bool ReadTemplateFrameDiffs();
				bool ReadTemplateFrameDiffChains();
				bool ReadFrameDependencyDefinition();
				bool WriteMandatoryDescriptorFields();
				bool WriteExtendedDescriptorFields();

			private:
				Utils::BitStream bitStream;
			};
		} // namespace Codecs
	} // namespace RTP
} // namespace RTC

#endif