Line data Source code
1 : /*
2 : * If not stated otherwise in this file or this component's LICENSE file the
3 : * following copyright and licenses apply:
4 : *
5 : * Copyright 2022 Sky UK
6 : *
7 : * Licensed under the Apache License, Version 2.0 (the "License");
8 : * you may not use this file except in compliance with the License.
9 : * You may obtain a copy of the License at
10 : *
11 : * http://www.apache.org/licenses/LICENSE-2.0
12 : *
13 : * Unless required by applicable law or agreed to in writing, software
14 : * distributed under the License is distributed on an "AS IS" BASIS,
15 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 : * See the License for the specific language governing permissions and
17 : * limitations under the License.
18 : */
19 :
20 : #include "MediaPipelineClient.h"
21 : #include "RialtoServerLogging.h"
22 : #include "mediapipelinemodule.pb.h"
23 : #include <IIpcServer.h>
24 :
25 : namespace
26 : {
27 : firebolt::rialto::PlaybackStateChangeEvent_PlaybackState
28 1 : convertPlaybackState(const firebolt::rialto::PlaybackState &playbackState)
29 : {
30 1 : switch (playbackState)
31 : {
32 0 : case firebolt::rialto::PlaybackState::UNKNOWN:
33 : {
34 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_UNKNOWN;
35 : }
36 0 : case firebolt::rialto::PlaybackState::IDLE:
37 : {
38 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_IDLE;
39 : }
40 1 : case firebolt::rialto::PlaybackState::PLAYING:
41 : {
42 1 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_PLAYING;
43 : }
44 0 : case firebolt::rialto::PlaybackState::PAUSED:
45 : {
46 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_PAUSED;
47 : }
48 0 : case firebolt::rialto::PlaybackState::SEEKING:
49 : {
50 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_SEEKING;
51 : }
52 0 : case firebolt::rialto::PlaybackState::SEEK_DONE:
53 : {
54 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_SEEK_DONE;
55 : }
56 0 : case firebolt::rialto::PlaybackState::STOPPED:
57 : {
58 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_STOPPED;
59 : }
60 0 : case firebolt::rialto::PlaybackState::END_OF_STREAM:
61 : {
62 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_END_OF_STREAM;
63 : }
64 0 : case firebolt::rialto::PlaybackState::FAILURE:
65 : {
66 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_FAILURE;
67 : }
68 : }
69 0 : return firebolt::rialto::PlaybackStateChangeEvent_PlaybackState_UNKNOWN;
70 : }
71 :
72 : firebolt::rialto::NetworkStateChangeEvent_NetworkState
73 1 : convertNetworkState(const firebolt::rialto::NetworkState &networkState)
74 : {
75 1 : switch (networkState)
76 : {
77 0 : case firebolt::rialto::NetworkState::UNKNOWN:
78 : {
79 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_UNKNOWN;
80 : }
81 0 : case firebolt::rialto::NetworkState::IDLE:
82 : {
83 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_IDLE;
84 : }
85 0 : case firebolt::rialto::NetworkState::BUFFERING:
86 : {
87 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_BUFFERING;
88 : }
89 0 : case firebolt::rialto::NetworkState::BUFFERING_PROGRESS:
90 : {
91 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_BUFFERING_PROGRESS;
92 : }
93 1 : case firebolt::rialto::NetworkState::BUFFERED:
94 : {
95 1 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_BUFFERED;
96 : }
97 0 : case firebolt::rialto::NetworkState::STALLED:
98 : {
99 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_STALLED;
100 : }
101 0 : case firebolt::rialto::NetworkState::FORMAT_ERROR:
102 : {
103 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_FORMAT_ERROR;
104 : }
105 0 : case firebolt::rialto::NetworkState::NETWORK_ERROR:
106 : {
107 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_NETWORK_ERROR;
108 : }
109 0 : case firebolt::rialto::NetworkState::DECODE_ERROR:
110 : {
111 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_DECODE_ERROR;
112 : }
113 : }
114 0 : return firebolt::rialto::NetworkStateChangeEvent_NetworkState_UNKNOWN;
115 : }
116 :
117 1 : firebolt::rialto::PlaybackErrorEvent_PlaybackError convertPlaybackError(const firebolt::rialto::PlaybackError &playbackError)
118 : {
119 1 : switch (playbackError)
120 : {
121 0 : case firebolt::rialto::PlaybackError::UNKNOWN:
122 : {
123 0 : return firebolt::rialto::PlaybackErrorEvent_PlaybackError_UNKNOWN;
124 : }
125 1 : case firebolt::rialto::PlaybackError::DECRYPTION:
126 : {
127 1 : return firebolt::rialto::PlaybackErrorEvent_PlaybackError_DECRYPTION;
128 : }
129 0 : case firebolt::rialto::PlaybackError::OUTPUT_PROTECTION:
130 : {
131 0 : return firebolt::rialto::PlaybackErrorEvent_PlaybackError_OUTPUT_PROTECTION;
132 : }
133 : }
134 0 : return firebolt::rialto::PlaybackErrorEvent_PlaybackError_UNKNOWN;
135 : }
136 : } // namespace
137 :
138 : namespace firebolt::rialto::server::ipc
139 : {
140 24 : MediaPipelineClient::MediaPipelineClient(int sessionId, const std::shared_ptr<::firebolt::rialto::ipc::IClient> &ipcClient)
141 24 : : m_sessionId{sessionId}, m_ipcClient{ipcClient}
142 : {
143 : }
144 :
145 : MediaPipelineClient::~MediaPipelineClient() {}
146 :
147 0 : void MediaPipelineClient::notifyDuration(int64_t duration)
148 : {
149 0 : RIALTO_SERVER_LOG_WARN("Notify Duration not supported");
150 : }
151 :
152 1 : void MediaPipelineClient::notifyPosition(int64_t position)
153 : {
154 1 : RIALTO_SERVER_LOG_DEBUG("Sending PositionChangeEvent");
155 :
156 1 : auto event = std::make_shared<firebolt::rialto::PositionChangeEvent>();
157 1 : event->set_session_id(m_sessionId);
158 1 : event->set_position(position);
159 :
160 1 : m_ipcClient->sendEvent(event);
161 : }
162 :
163 0 : void MediaPipelineClient::notifyNativeSize(uint32_t width, uint32_t height, double aspect)
164 : {
165 0 : RIALTO_SERVER_LOG_WARN("Notify Native Size not supported");
166 : }
167 :
168 1 : void MediaPipelineClient::notifyNetworkState(NetworkState state)
169 : {
170 1 : RIALTO_SERVER_LOG_DEBUG("Sending NetworkStateChangeEvent");
171 :
172 1 : auto event = std::make_shared<firebolt::rialto::NetworkStateChangeEvent>();
173 1 : event->set_session_id(m_sessionId);
174 1 : event->set_state(convertNetworkState(state));
175 :
176 1 : m_ipcClient->sendEvent(event);
177 : }
178 :
179 1 : void MediaPipelineClient::notifyPlaybackState(PlaybackState state)
180 : {
181 1 : RIALTO_SERVER_LOG_DEBUG("Sending PlaybackStateChangeEvent...");
182 :
183 1 : auto event = std::make_shared<firebolt::rialto::PlaybackStateChangeEvent>();
184 1 : event->set_session_id(m_sessionId);
185 1 : event->set_state(convertPlaybackState(state));
186 :
187 1 : m_ipcClient->sendEvent(event);
188 : }
189 :
190 0 : void MediaPipelineClient::notifyVideoData(bool hasData)
191 : {
192 0 : RIALTO_SERVER_LOG_WARN("Notify Video Data not supported");
193 : }
194 :
195 0 : void MediaPipelineClient::notifyAudioData(bool hasData)
196 : {
197 0 : RIALTO_SERVER_LOG_WARN("Notify Audio Data not supported");
198 : }
199 :
200 1 : void MediaPipelineClient::notifyNeedMediaData(int32_t sourceId, size_t frameCount, uint32_t needDataRequestId,
201 : const std::shared_ptr<MediaPlayerShmInfo> &shmInfo)
202 : {
203 1 : RIALTO_SERVER_LOG_DEBUG("Sending NeedMediaDataEvent...");
204 :
205 1 : auto event = std::make_shared<firebolt::rialto::NeedMediaDataEvent>();
206 1 : event->set_session_id(m_sessionId);
207 1 : event->set_source_id(sourceId);
208 1 : event->set_request_id(needDataRequestId);
209 1 : event->set_frame_count(frameCount);
210 1 : event->mutable_shm_info()->set_max_metadata_bytes(shmInfo->maxMetadataBytes);
211 1 : event->mutable_shm_info()->set_metadata_offset(shmInfo->metadataOffset);
212 1 : event->mutable_shm_info()->set_media_data_offset(shmInfo->mediaDataOffset);
213 1 : event->mutable_shm_info()->set_max_media_bytes(shmInfo->maxMediaBytes);
214 :
215 1 : m_ipcClient->sendEvent(event);
216 : }
217 :
218 0 : void MediaPipelineClient::notifyCancelNeedMediaData(int32_t sourceId)
219 : {
220 0 : RIALTO_SERVER_LOG_WARN("Notify Cancel Need Media Data not supported");
221 : }
222 :
223 1 : void MediaPipelineClient::notifyQos(int32_t sourceId, const QosInfo &qosInfo)
224 : {
225 1 : RIALTO_SERVER_LOG_DEBUG("Sending QosEvent...");
226 :
227 1 : auto event = std::make_shared<firebolt::rialto::QosEvent>();
228 1 : event->set_session_id(m_sessionId);
229 1 : event->set_source_id(sourceId);
230 1 : event->mutable_qos_info()->set_processed(qosInfo.processed);
231 1 : event->mutable_qos_info()->set_dropped(qosInfo.dropped);
232 :
233 1 : m_ipcClient->sendEvent(event);
234 : }
235 :
236 0 : void MediaPipelineClient::notifyBufferUnderflow(int32_t sourceId)
237 : {
238 0 : RIALTO_SERVER_LOG_DEBUG("Sending BufferUnderflowEvent...");
239 :
240 0 : auto event = std::make_shared<firebolt::rialto::BufferUnderflowEvent>();
241 0 : event->set_session_id(m_sessionId);
242 0 : event->set_source_id(sourceId);
243 :
244 0 : m_ipcClient->sendEvent(event);
245 : }
246 :
247 1 : void MediaPipelineClient::notifyFirstFrameReceived(int32_t sourceId)
248 : {
249 1 : RIALTO_SERVER_LOG_DEBUG("Sending FirstFrameReceivedEvent...");
250 :
251 1 : auto event = std::make_shared<firebolt::rialto::FirstFrameReceivedEvent>();
252 1 : event->set_session_id(m_sessionId);
253 1 : event->set_source_id(sourceId);
254 :
255 1 : m_ipcClient->sendEvent(event);
256 : }
257 :
258 1 : void MediaPipelineClient::notifyPlaybackError(int32_t sourceId, PlaybackError error)
259 : {
260 1 : RIALTO_SERVER_LOG_DEBUG("Sending notifyPlaybackError...");
261 :
262 1 : auto event = std::make_shared<firebolt::rialto::PlaybackErrorEvent>();
263 1 : event->set_session_id(m_sessionId);
264 1 : event->set_source_id(sourceId);
265 1 : event->set_error(convertPlaybackError(error));
266 :
267 1 : m_ipcClient->sendEvent(event);
268 : }
269 :
270 1 : void MediaPipelineClient::notifySourceFlushed(int32_t sourceId)
271 : {
272 1 : RIALTO_SERVER_LOG_DEBUG("Sending SourceFlushedEvent...");
273 :
274 1 : auto event = std::make_shared<firebolt::rialto::SourceFlushedEvent>();
275 1 : event->set_session_id(m_sessionId);
276 1 : event->set_source_id(sourceId);
277 :
278 1 : m_ipcClient->sendEvent(event);
279 : }
280 :
281 1 : void MediaPipelineClient::notifyPlaybackInfo(const PlaybackInfo &playbackInfo)
282 : {
283 1 : RIALTO_SERVER_LOG_DEBUG("Sending PlaybackInfoEvent...");
284 :
285 1 : auto event = std::make_shared<firebolt::rialto::PlaybackInfoEvent>();
286 1 : event->set_session_id(m_sessionId);
287 1 : event->set_current_position(playbackInfo.currentPosition);
288 1 : event->set_volume(playbackInfo.volume);
289 :
290 1 : m_ipcClient->sendEvent(event);
291 : }
292 : } // namespace firebolt::rialto::server::ipc
|
