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
|
/*
* Copyright (C) 2021, 2022 Igalia S.L
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* aint with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#if USE(GSTREAMER_TRANSCODER)
#include "GRefPtrGStreamer.h"
#include "MediaRecorderPrivate.h"
#include "SharedBuffer.h"
#include <wtf/CompletionHandler.h>
#include <wtf/Condition.h>
#include <wtf/Forward.h>
#include <wtf/Lock.h>
#include <wtf/TZoneMalloc.h>
#include <wtf/WeakPtr.h>
namespace WebCore {
class ContentType;
class MediaStreamTrackPrivate;
struct MediaRecorderPrivateOptions;
class MediaRecorderPrivateBackend : public ThreadSafeRefCountedAndCanMakeThreadSafeWeakPtr<MediaRecorderPrivateBackend, WTF::DestructionThread::Main> {
WTF_MAKE_TZONE_ALLOCATED(MediaRecorderPrivateBackend);
public:
using SelectTracksCallback = Function<void(MediaRecorderPrivate::AudioVideoSelectedTracks)>;
static RefPtr<MediaRecorderPrivateBackend> create(MediaStreamPrivate& stream, const MediaRecorderPrivateOptions& options)
{
return adoptRef(*new MediaRecorderPrivateBackend(stream, options));
}
~MediaRecorderPrivateBackend();
bool preparePipeline();
void fetchData(MediaRecorderPrivate::FetchDataCallback&&);
void startRecording(MediaRecorderPrivate::StartRecordingCallback&&);
void stopRecording(CompletionHandler<void()>&&);
void pauseRecording(CompletionHandler<void()>&&);
void resumeRecording(CompletionHandler<void()>&&);
const String& mimeType() const { return m_mimeType; }
void setSelectTracksCallback(SelectTracksCallback&& callback) { m_selectTracksCallback = WTFMove(callback); }
private:
MediaRecorderPrivateBackend(MediaStreamPrivate&, const MediaRecorderPrivateOptions&);
void setSource(GstElement*);
void setSink(GstElement*);
void configureAudioEncoder(GstElement*);
void configureVideoEncoder(GstElement*);
GRefPtr<GstEncodingContainerProfile> containerProfile();
MediaStreamPrivate& stream() const { return m_stream; }
void processSample(GRefPtr<GstSample>&&);
void notifyPosition(GstClockTime);
void notifyEOS();
GRefPtr<GstEncodingProfile> m_audioEncodingProfile;
GRefPtr<GstEncodingProfile> m_videoEncodingProfile;
String m_videoCodec;
GRefPtr<GstTranscoder> m_transcoder;
GRefPtr<GstTranscoderSignalAdapter> m_signalAdapter;
GRefPtr<GstElement> m_pipeline;
GRefPtr<GstElement> m_src;
GRefPtr<GstElement> m_sink;
Condition m_eosCondition;
Lock m_eosLock;
bool m_eos WTF_GUARDED_BY_LOCK(m_eosLock);
Lock m_dataLock;
SharedBufferBuilder m_data WTF_GUARDED_BY_LOCK(m_dataLock);
MediaTime m_position WTF_GUARDED_BY_LOCK(m_dataLock) { MediaTime::invalidTime() };
double m_timeCode WTF_GUARDED_BY_LOCK(m_dataLock) { 0 };
MediaStreamPrivate& m_stream;
const MediaRecorderPrivateOptions& m_options;
String m_mimeType;
std::optional<SelectTracksCallback> m_selectTracksCallback;
};
class MediaRecorderPrivateGStreamer final : public MediaRecorderPrivate {
WTF_MAKE_TZONE_ALLOCATED(MediaRecorderPrivateGStreamer);
WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(MediaRecorderPrivateGStreamer);
public:
static std::unique_ptr<MediaRecorderPrivateGStreamer> create(MediaStreamPrivate&, const MediaRecorderPrivateOptions&);
explicit MediaRecorderPrivateGStreamer(Ref<MediaRecorderPrivateBackend>&&);
~MediaRecorderPrivateGStreamer() = default;
static bool isTypeSupported(const ContentType&);
private:
void videoFrameAvailable(VideoFrame&, VideoFrameTimeMetadata) final { };
void audioSamplesAvailable(const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final { };
void fetchData(FetchDataCallback&&) final;
void startRecording(StartRecordingCallback&&) final;
void stopRecording(CompletionHandler<void()>&&) final;
void pauseRecording(CompletionHandler<void()>&&) final;
void resumeRecording(CompletionHandler<void()>&&) final;
String mimeType() const final;
Ref<MediaRecorderPrivateBackend> m_recorder;
};
} // namespace WebCore
#endif // USE(GSTREAMER_TRANSCODER)
|
