Line data Source code
1 : /*
2 : * Copyright (C) 2022 Sky UK
3 : *
4 : * This library is free software; you can redistribute it and/or
5 : * modify it under the terms of the GNU Lesser General Public
6 : * License as published by the Free Software Foundation;
7 : * version 2.1 of the License.
8 : *
9 : * This library is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 : * Lesser General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU Lesser General Public
15 : * License along with this library; if not, write to the Free Software
16 : * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 : */
18 :
19 : #pragma once
20 :
21 : #include "MediaPlayerClientBackendInterface.h"
22 : #include <IMediaPipeline.h>
23 : #include <gst/gst.h>
24 : #include <memory>
25 :
26 : namespace firebolt::rialto::client
27 : {
28 : class MediaPlayerClientBackend final : public MediaPlayerClientBackendInterface
29 : {
30 : public:
31 200 : MediaPlayerClientBackend() : m_mediaPlayerBackend(nullptr) {}
32 200 : ~MediaPlayerClientBackend() final { m_mediaPlayerBackend.reset(); }
33 :
34 199 : void createMediaPlayerBackend(std::weak_ptr<IMediaPipelineClient> client, uint32_t maxWidth, uint32_t maxHeight) override
35 : {
36 : firebolt::rialto::VideoRequirements videoRequirements;
37 199 : videoRequirements.maxWidth = maxWidth;
38 199 : videoRequirements.maxHeight = maxHeight;
39 :
40 : m_mediaPlayerBackend =
41 199 : firebolt::rialto::IMediaPipelineFactory::createFactory()->createMediaPipeline(client, videoRequirements);
42 :
43 199 : if (!m_mediaPlayerBackend)
44 : {
45 5 : GST_ERROR("Could not create media player backend");
46 5 : return;
47 : }
48 : }
49 :
50 202 : bool isMediaPlayerBackendCreated() const override { return static_cast<bool>(m_mediaPlayerBackend); }
51 :
52 152 : bool attachSource(std::unique_ptr<firebolt::rialto::IMediaPipeline::MediaSource> &source) override
53 : {
54 152 : return m_mediaPlayerBackend->attachSource(source);
55 : }
56 :
57 161 : bool removeSource(int32_t id) override { return m_mediaPlayerBackend->removeSource(id); }
58 :
59 151 : bool allSourcesAttached() override { return m_mediaPlayerBackend->allSourcesAttached(); }
60 :
61 168 : bool load(firebolt::rialto::MediaType type, const std::string &mimeType, const std::string &url, bool isLive) override
62 : {
63 168 : return m_mediaPlayerBackend->load(type, mimeType, url, isLive);
64 : }
65 :
66 8 : bool play(bool &async) override { return m_mediaPlayerBackend->play(async); }
67 158 : bool pause() override { return m_mediaPlayerBackend->pause(); }
68 168 : bool stop() override { return m_mediaPlayerBackend->stop(); }
69 3 : bool haveData(firebolt::rialto::MediaSourceStatus status, unsigned int needDataRequestId) override
70 : {
71 3 : return m_mediaPlayerBackend->haveData(status, needDataRequestId);
72 : }
73 4 : bool setPlaybackRate(double rate) override { return m_mediaPlayerBackend->setPlaybackRate(rate); }
74 3 : bool setVideoWindow(unsigned int x, unsigned int y, unsigned int width, unsigned int height) override
75 : {
76 3 : return m_mediaPlayerBackend->setVideoWindow(x, y, width, height);
77 : }
78 :
79 : firebolt::rialto::AddSegmentStatus
80 2 : addSegment(unsigned int needDataRequestId,
81 : const std::unique_ptr<firebolt::rialto::IMediaPipeline::MediaSegment> &mediaSegment) override
82 : {
83 2 : return m_mediaPlayerBackend->addSegment(needDataRequestId, mediaSegment);
84 : }
85 :
86 1 : bool getPosition(int64_t &position) override { return m_mediaPlayerBackend->getPosition(position); }
87 :
88 5 : bool getDuration(int64_t &duration) override { return m_mediaPlayerBackend->getDuration(duration); }
89 :
90 3 : bool setImmediateOutput(int32_t sourceId, bool immediateOutput) override
91 : {
92 3 : return m_mediaPlayerBackend->setImmediateOutput(sourceId, immediateOutput);
93 : }
94 :
95 3 : bool setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors) override
96 : {
97 3 : return m_mediaPlayerBackend->setReportDecodeErrors(sourceId, reportDecodeErrors);
98 : }
99 :
100 2 : bool getImmediateOutput(int32_t sourceId, bool &immediateOutput) override
101 : {
102 2 : return m_mediaPlayerBackend->getImmediateOutput(sourceId, immediateOutput);
103 : }
104 :
105 2 : bool getQueuedFrames(int32_t sourceId, uint32_t &queuedFrames) override
106 : {
107 2 : return m_mediaPlayerBackend->getQueuedFrames(sourceId, queuedFrames);
108 : }
109 :
110 1 : bool getStats(int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames) override
111 : {
112 1 : return m_mediaPlayerBackend->getStats(sourceId, renderedFrames, droppedFrames);
113 : }
114 :
115 3 : bool renderFrame() override { return m_mediaPlayerBackend->renderFrame(); }
116 :
117 6 : bool setVolume(double targetVolume, uint32_t volumeDuration, EaseType easeType) override
118 : {
119 6 : return m_mediaPlayerBackend->setVolume(targetVolume, volumeDuration, easeType);
120 : }
121 :
122 2 : bool getVolume(double ¤tVolume) override { return m_mediaPlayerBackend->getVolume(currentVolume); }
123 :
124 7 : bool setMute(bool mute, int sourceId) override { return m_mediaPlayerBackend->setMute(sourceId, mute); }
125 :
126 3 : bool getMute(bool &mute, int sourceId) override { return m_mediaPlayerBackend->getMute(sourceId, mute); }
127 :
128 2 : bool setTextTrackIdentifier(const std::string &textTrackIdentifier) override
129 : {
130 2 : return m_mediaPlayerBackend->setTextTrackIdentifier(textTrackIdentifier);
131 : }
132 :
133 1 : bool getTextTrackIdentifier(std::string &textTrackIdentifier) override
134 : {
135 1 : return m_mediaPlayerBackend->getTextTrackIdentifier(textTrackIdentifier);
136 : }
137 :
138 4 : bool setLowLatency(bool lowLatency) override { return m_mediaPlayerBackend->setLowLatency(lowLatency); }
139 :
140 4 : bool setSync(bool sync) override { return m_mediaPlayerBackend->setSync(sync); }
141 :
142 2 : bool getSync(bool &sync) override { return m_mediaPlayerBackend->getSync(sync); }
143 :
144 4 : bool setSyncOff(bool syncOff) override { return m_mediaPlayerBackend->setSyncOff(syncOff); }
145 :
146 8 : bool setStreamSyncMode(int32_t sourceId, int32_t streamSyncMode) override
147 : {
148 8 : return m_mediaPlayerBackend->setStreamSyncMode(sourceId, streamSyncMode);
149 : }
150 :
151 2 : bool getStreamSyncMode(int32_t &streamSyncMode) override
152 : {
153 2 : return m_mediaPlayerBackend->getStreamSyncMode(streamSyncMode);
154 : }
155 :
156 7 : bool flush(int32_t sourceId, bool resetTime, bool &async) override
157 : {
158 7 : return m_mediaPlayerBackend->flush(sourceId, resetTime, async);
159 : }
160 :
161 7 : bool setSourcePosition(int32_t sourceId, int64_t position, bool resetTime, double appliedRate = 1.0,
162 : uint64_t stopPosition = GST_CLOCK_TIME_NONE) override
163 : {
164 7 : return m_mediaPlayerBackend->setSourcePosition(sourceId, position, resetTime, appliedRate, stopPosition);
165 : }
166 :
167 1 : bool setSubtitleOffset(int32_t sourceId, int64_t position) override
168 : {
169 1 : return m_mediaPlayerBackend->setSubtitleOffset(sourceId, position);
170 : }
171 :
172 3 : bool processAudioGap(int64_t position, uint32_t duration, int64_t discontinuityGap, bool audioAac) override
173 : {
174 3 : return m_mediaPlayerBackend->processAudioGap(position, duration, discontinuityGap, audioAac);
175 : }
176 :
177 3 : bool setBufferingLimit(uint32_t limitBufferingMs) override
178 : {
179 3 : return m_mediaPlayerBackend->setBufferingLimit(limitBufferingMs);
180 : }
181 :
182 2 : bool getBufferingLimit(uint32_t &limitBufferingMs) override
183 : {
184 2 : return m_mediaPlayerBackend->getBufferingLimit(limitBufferingMs);
185 : }
186 :
187 3 : bool setUseBuffering(bool useBuffering) override { return m_mediaPlayerBackend->setUseBuffering(useBuffering); }
188 :
189 2 : bool getUseBuffering(bool &useBuffering) override { return m_mediaPlayerBackend->getUseBuffering(useBuffering); }
190 :
191 3 : bool switchSource(const std::unique_ptr<firebolt::rialto::IMediaPipeline::MediaSource> &source) override
192 : {
193 3 : return m_mediaPlayerBackend->switchSource(source);
194 : }
195 :
196 : private:
197 : std::unique_ptr<IMediaPipeline> m_mediaPlayerBackend;
198 : };
199 : } // namespace firebolt::rialto::client
|
