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
143
144
145
146
147
148
149
150
151
|
/*
* Copyright (C) 2017-2022 Igalia S.L. All rights reserved.
* Copyright (C) 2022 Metrological Group B.V.
*
* 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 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
*/
#pragma once
#if USE(GSTREAMER_WEBRTC)
#include "GRefPtrGStreamer.h"
#include "GStreamerRTPPacketizer.h"
#include "GStreamerWebRTCUtils.h"
#include "MediaStreamTrackPrivate.h"
#include "RTCRtpCapabilities.h"
#include <wtf/ThreadSafeRefCounted.h>
namespace WebCore {
class MediaStreamTrack;
class RealtimeOutgoingMediaSourceGStreamer : public ThreadSafeRefCountedAndCanMakeThreadSafeWeakPtr<RealtimeOutgoingMediaSourceGStreamer, WTF::DestructionThread::Main>, public MediaStreamTrackPrivateObserver {
public:
~RealtimeOutgoingMediaSourceGStreamer();
void start();
void stop();
const RefPtr<MediaStreamTrackPrivate>& track() const { return m_track; }
const String& mediaStreamID() const { return m_mediaStreamId; }
const GRefPtr<GstCaps>& allowedCaps() const;
WARN_UNUSED_RETURN GRefPtr<GstCaps> rtpCaps() const;
void link();
const GRefPtr<GstPad>& pad() const { return m_webrtcSinkPad; }
void setSinkPad(GRefPtr<GstPad>&&);
GRefPtr<GstWebRTCRTPSender> sender() const { return m_sender; }
GRefPtr<GstElement> bin() const { return m_bin; }
bool configurePacketizers(GRefPtr<GstCaps>&&);
GUniquePtr<GstStructure> parameters();
void setInitialParameters(GUniquePtr<GstStructure>&&);
void setParameters(GUniquePtr<GstStructure>&&);
void configure(GRefPtr<GstCaps>&&);
WARN_UNUSED_RETURN GUniquePtr<GstStructure> stats();
virtual WARN_UNUSED_RETURN GRefPtr<GstPad> outgoingSourcePad() const = 0;
virtual RefPtr<GStreamerRTPPacketizer> createPacketizer(RefPtr<UniqueSSRCGenerator>, const GstStructure*, GUniquePtr<GstStructure>&&) = 0;
void replaceTrack(RefPtr<MediaStreamTrackPrivate>&&);
virtual void teardown();
virtual void dispatchBitrateRequest(uint32_t bitrate) = 0;
RealtimeMediaSource::Type type() const;
protected:
enum Type {
Audio,
Video
};
explicit RealtimeOutgoingMediaSourceGStreamer(Type, const RefPtr<UniqueSSRCGenerator>&, const String& mediaStreamId, MediaStreamTrack&);
explicit RealtimeOutgoingMediaSourceGStreamer(Type, const RefPtr<UniqueSSRCGenerator>&);
void initializeSourceFromTrackPrivate();
virtual void sourceEnabledChanged();
bool isStopped() const { return m_isStopped; }
bool linkPacketizer(RefPtr<GStreamerRTPPacketizer>&&);
Type m_type;
String m_mediaStreamId;
String m_trackId;
String m_mid;
bool m_enabled { true };
bool m_muted { false };
bool m_isStopped { true };
RefPtr<MediaStreamTrackPrivate> m_track;
std::optional<RealtimeMediaSourceSettings> m_initialSettings;
GRefPtr<GstElement> m_bin;
GRefPtr<GstElement> m_outgoingSource;
GRefPtr<GstElement> m_preProcessor;
GRefPtr<GstElement> m_tee;
GRefPtr<GstElement> m_rtpFunnel;
GRefPtr<GstElement> m_rtpCapsfilter;
mutable GRefPtr<GstCaps> m_allowedCaps;
GRefPtr<GstWebRTCRTPTransceiver> m_transceiver;
GRefPtr<GstWebRTCRTPSender> m_sender;
GRefPtr<GstPad> m_webrtcSinkPad;
RefPtr<UniqueSSRCGenerator> m_ssrcGenerator;
GUniquePtr<GstStructure> m_parameters;
Vector<RefPtr<GStreamerRTPPacketizer>> m_packetizers;
private:
void initialize();
void sourceMutedChanged();
void stopOutgoingSource();
bool linkSource();
virtual RTCRtpCapabilities rtpCapabilities() const = 0;
void codecPreferencesChanged();
// MediaStreamTrackPrivateObserver API
void trackMutedChanged(MediaStreamTrackPrivate&) override { sourceMutedChanged(); }
void trackEnabledChanged(MediaStreamTrackPrivate&) override { sourceEnabledChanged(); }
void trackSettingsChanged(MediaStreamTrackPrivate&) override { initializeSourceFromTrackPrivate(); }
void trackEnded(MediaStreamTrackPrivate&) override { }
void checkMid();
struct ExtensionLookupResults {
bool hasRtpStreamIdExtension { false };
bool hasRtpRepairedStreamIdExtension { false };
bool hasMidExtension { false };
int lastIdentifier { 0 };
};
ExtensionLookupResults lookupRtpExtensions(const GstStructure*);
void startUpdatingStats();
void stopUpdatingStats();
RefPtr<GStreamerRTPPacketizer> getPacketizerForRid(StringView);
};
} // namespace WebCore
#endif // USE(GSTREAMER_WEBRTC)
|
