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 191 : MediaPlayerClientBackend() : m_mediaPlayerBackend(nullptr) {}
32 191 : ~MediaPlayerClientBackend() final { m_mediaPlayerBackend.reset(); }
33 :
34 190 : void createMediaPlayerBackend(std::weak_ptr<IMediaPipelineClient> client, uint32_t maxWidth, uint32_t maxHeight) override
35 : {
36 : firebolt::rialto::VideoRequirements videoRequirements;
37 190 : videoRequirements.maxWidth = maxWidth;
38 190 : videoRequirements.maxHeight = maxHeight;
39 :
40 : m_mediaPlayerBackend =
41 190 : firebolt::rialto::IMediaPipelineFactory::createFactory()->createMediaPipeline(client, videoRequirements);
42 :
43 190 : if (!m_mediaPlayerBackend)
44 : {
45 5 : GST_ERROR("Could not create media player backend");
46 5 : return;
47 : }
48 : }
49 :
50 193 : bool isMediaPlayerBackendCreated() const override { return static_cast<bool>(m_mediaPlayerBackend); }
51 :
52 143 : bool attachSource(std::unique_ptr<firebolt::rialto::IMediaPipeline::MediaSource> &source) override
53 : {
54 143 : return m_mediaPlayerBackend->attachSource(source);
55 : }
56 :
57 152 : bool removeSource(int32_t id) override { return m_mediaPlayerBackend->removeSource(id); }
58 :
59 142 : bool allSourcesAttached() override { return m_mediaPlayerBackend->allSourcesAttached(); }
60 :
61 159 : bool load(firebolt::rialto::MediaType type, const std::string &mimeType, const std::string &url, bool isLive) override
62 : {
63 159 : return m_mediaPlayerBackend->load(type, mimeType, url, isLive);
64 : }
65 :
66 8 : bool play(bool &async) override { return m_mediaPlayerBackend->play(async); }
67 149 : bool pause() override { return m_mediaPlayerBackend->pause(); }
68 159 : 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 3 : 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 2 : bool getImmediateOutput(int32_t sourceId, bool &immediateOutput) override
96 : {
97 2 : return m_mediaPlayerBackend->getImmediateOutput(sourceId, immediateOutput);
98 : }
99 :
100 1 : bool getStats(int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames) override
101 : {
102 1 : return m_mediaPlayerBackend->getStats(sourceId, renderedFrames, droppedFrames);
103 : }
104 :
105 3 : bool renderFrame() override { return m_mediaPlayerBackend->renderFrame(); }
106 :
107 6 : bool setVolume(double targetVolume, uint32_t volumeDuration, EaseType easeType) override
108 : {
109 6 : return m_mediaPlayerBackend->setVolume(targetVolume, volumeDuration, easeType);
110 : }
111 :
112 1 : bool getVolume(double ¤tVolume) override { return m_mediaPlayerBackend->getVolume(currentVolume); }
113 :
114 7 : bool setMute(bool mute, int sourceId) override { return m_mediaPlayerBackend->setMute(sourceId, mute); }
115 :
116 3 : bool getMute(bool &mute, int sourceId) override { return m_mediaPlayerBackend->getMute(sourceId, mute); }
117 :
118 2 : bool setTextTrackIdentifier(const std::string &textTrackIdentifier) override
119 : {
120 2 : return m_mediaPlayerBackend->setTextTrackIdentifier(textTrackIdentifier);
121 : }
122 :
123 1 : bool getTextTrackIdentifier(std::string &textTrackIdentifier) override
124 : {
125 1 : return m_mediaPlayerBackend->getTextTrackIdentifier(textTrackIdentifier);
126 : }
127 :
128 4 : bool setLowLatency(bool lowLatency) override { return m_mediaPlayerBackend->setLowLatency(lowLatency); }
129 :
130 4 : bool setSync(bool sync) override { return m_mediaPlayerBackend->setSync(sync); }
131 :
132 2 : bool getSync(bool &sync) override { return m_mediaPlayerBackend->getSync(sync); }
133 :
134 4 : bool setSyncOff(bool syncOff) override { return m_mediaPlayerBackend->setSyncOff(syncOff); }
135 :
136 8 : bool setStreamSyncMode(int32_t sourceId, int32_t streamSyncMode) override
137 : {
138 8 : return m_mediaPlayerBackend->setStreamSyncMode(sourceId, streamSyncMode);
139 : }
140 :
141 2 : bool getStreamSyncMode(int32_t &streamSyncMode) override
142 : {
143 2 : return m_mediaPlayerBackend->getStreamSyncMode(streamSyncMode);
144 : }
145 :
146 6 : bool flush(int32_t sourceId, bool resetTime, bool &async) override
147 : {
148 6 : return m_mediaPlayerBackend->flush(sourceId, resetTime, async);
149 : }
150 :
151 7 : bool setSourcePosition(int32_t sourceId, int64_t position, bool resetTime, double appliedRate = 1.0,
152 : uint64_t stopPosition = GST_CLOCK_TIME_NONE) override
153 : {
154 7 : return m_mediaPlayerBackend->setSourcePosition(sourceId, position, resetTime, appliedRate, stopPosition);
155 : }
156 :
157 1 : bool setSubtitleOffset(int32_t sourceId, int64_t position) override
158 : {
159 1 : return m_mediaPlayerBackend->setSubtitleOffset(sourceId, position);
160 : }
161 :
162 3 : bool processAudioGap(int64_t position, uint32_t duration, int64_t discontinuityGap, bool audioAac) override
163 : {
164 3 : return m_mediaPlayerBackend->processAudioGap(position, duration, discontinuityGap, audioAac);
165 : }
166 :
167 3 : bool setBufferingLimit(uint32_t limitBufferingMs) override
168 : {
169 3 : return m_mediaPlayerBackend->setBufferingLimit(limitBufferingMs);
170 : }
171 :
172 2 : bool getBufferingLimit(uint32_t &limitBufferingMs) override
173 : {
174 2 : return m_mediaPlayerBackend->getBufferingLimit(limitBufferingMs);
175 : }
176 :
177 3 : bool setUseBuffering(bool useBuffering) override { return m_mediaPlayerBackend->setUseBuffering(useBuffering); }
178 :
179 2 : bool getUseBuffering(bool &useBuffering) override { return m_mediaPlayerBackend->getUseBuffering(useBuffering); }
180 :
181 3 : bool switchSource(const std::unique_ptr<firebolt::rialto::IMediaPipeline::MediaSource> &source) override
182 : {
183 3 : return m_mediaPlayerBackend->switchSource(source);
184 : }
185 :
186 : private:
187 : std::unique_ptr<IMediaPipeline> m_mediaPlayerBackend;
188 : };
189 : } // namespace firebolt::rialto::client
|
