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