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 : }
130 0 : return firebolt::rialto::PlaybackErrorEvent_PlaybackError_UNKNOWN;
131 : }
132 : } // namespace
133 :
134 : namespace firebolt::rialto::server::ipc
135 : {
136 20 : MediaPipelineClient::MediaPipelineClient(int sessionId, const std::shared_ptr<::firebolt::rialto::ipc::IClient> &ipcClient)
137 20 : : m_sessionId{sessionId}, m_ipcClient{ipcClient}
138 : {
139 : }
140 :
141 : MediaPipelineClient::~MediaPipelineClient() {}
142 :
143 0 : void MediaPipelineClient::notifyDuration(int64_t duration)
144 : {
145 0 : RIALTO_SERVER_LOG_WARN("Notify Duration not supported");
146 : }
147 :
148 1 : void MediaPipelineClient::notifyPosition(int64_t position)
149 : {
150 1 : RIALTO_SERVER_LOG_DEBUG("Sending PositionChangeEvent");
151 :
152 1 : auto event = std::make_shared<firebolt::rialto::PositionChangeEvent>();
153 1 : event->set_session_id(m_sessionId);
154 1 : event->set_position(position);
155 :
156 1 : m_ipcClient->sendEvent(event);
157 : }
158 :
159 0 : void MediaPipelineClient::notifyNativeSize(uint32_t width, uint32_t height, double aspect)
160 : {
161 0 : RIALTO_SERVER_LOG_WARN("Notify Native Size not supported");
162 : }
163 :
164 1 : void MediaPipelineClient::notifyNetworkState(NetworkState state)
165 : {
166 1 : RIALTO_SERVER_LOG_DEBUG("Sending NetworkStateChangeEvent");
167 :
168 1 : auto event = std::make_shared<firebolt::rialto::NetworkStateChangeEvent>();
169 1 : event->set_session_id(m_sessionId);
170 1 : event->set_state(convertNetworkState(state));
171 :
172 1 : m_ipcClient->sendEvent(event);
173 : }
174 :
175 1 : void MediaPipelineClient::notifyPlaybackState(PlaybackState state)
176 : {
177 1 : RIALTO_SERVER_LOG_DEBUG("Sending PlaybackStateChangeEvent...");
178 :
179 1 : auto event = std::make_shared<firebolt::rialto::PlaybackStateChangeEvent>();
180 1 : event->set_session_id(m_sessionId);
181 1 : event->set_state(convertPlaybackState(state));
182 :
183 1 : m_ipcClient->sendEvent(event);
184 : }
185 :
186 0 : void MediaPipelineClient::notifyVideoData(bool hasData)
187 : {
188 0 : RIALTO_SERVER_LOG_WARN("Notify Video Data not supported");
189 : }
190 :
191 0 : void MediaPipelineClient::notifyAudioData(bool hasData)
192 : {
193 0 : RIALTO_SERVER_LOG_WARN("Notify Audio Data not supported");
194 : }
195 :
196 1 : void MediaPipelineClient::notifyNeedMediaData(int32_t sourceId, size_t frameCount, uint32_t needDataRequestId,
197 : const std::shared_ptr<MediaPlayerShmInfo> &shmInfo)
198 : {
199 1 : RIALTO_SERVER_LOG_DEBUG("Sending NeedMediaDataEvent...");
200 :
201 1 : auto event = std::make_shared<firebolt::rialto::NeedMediaDataEvent>();
202 1 : event->set_session_id(m_sessionId);
203 1 : event->set_source_id(sourceId);
204 1 : event->set_request_id(needDataRequestId);
205 1 : event->set_frame_count(frameCount);
206 1 : event->mutable_shm_info()->set_max_metadata_bytes(shmInfo->maxMetadataBytes);
207 1 : event->mutable_shm_info()->set_metadata_offset(shmInfo->metadataOffset);
208 1 : event->mutable_shm_info()->set_media_data_offset(shmInfo->mediaDataOffset);
209 1 : event->mutable_shm_info()->set_max_media_bytes(shmInfo->maxMediaBytes);
210 :
211 1 : m_ipcClient->sendEvent(event);
212 : }
213 :
214 0 : void MediaPipelineClient::notifyCancelNeedMediaData(int32_t sourceId)
215 : {
216 0 : RIALTO_SERVER_LOG_WARN("Notify Cancel Need Media Data not supported");
217 : }
218 :
219 1 : void MediaPipelineClient::notifyQos(int32_t sourceId, const QosInfo &qosInfo)
220 : {
221 1 : RIALTO_SERVER_LOG_DEBUG("Sending QosEvent...");
222 :
223 1 : auto event = std::make_shared<firebolt::rialto::QosEvent>();
224 1 : event->set_session_id(m_sessionId);
225 1 : event->set_source_id(sourceId);
226 1 : event->mutable_qos_info()->set_processed(qosInfo.processed);
227 1 : event->mutable_qos_info()->set_dropped(qosInfo.dropped);
228 :
229 1 : m_ipcClient->sendEvent(event);
230 : }
231 :
232 0 : void MediaPipelineClient::notifyBufferUnderflow(int32_t sourceId)
233 : {
234 0 : RIALTO_SERVER_LOG_DEBUG("Sending BufferUnderflowEvent...");
235 :
236 0 : auto event = std::make_shared<firebolt::rialto::BufferUnderflowEvent>();
237 0 : event->set_session_id(m_sessionId);
238 0 : event->set_source_id(sourceId);
239 :
240 0 : m_ipcClient->sendEvent(event);
241 : }
242 :
243 1 : void MediaPipelineClient::notifyPlaybackError(int32_t sourceId, PlaybackError error)
244 : {
245 1 : RIALTO_SERVER_LOG_DEBUG("Sending notifyPlaybackError...");
246 :
247 1 : auto event = std::make_shared<firebolt::rialto::PlaybackErrorEvent>();
248 1 : event->set_session_id(m_sessionId);
249 1 : event->set_source_id(sourceId);
250 1 : event->set_error(convertPlaybackError(error));
251 :
252 1 : m_ipcClient->sendEvent(event);
253 : }
254 :
255 1 : void MediaPipelineClient::notifySourceFlushed(int32_t sourceId)
256 : {
257 1 : RIALTO_SERVER_LOG_DEBUG("Sending SourceFlushedEvent...");
258 :
259 1 : auto event = std::make_shared<firebolt::rialto::SourceFlushedEvent>();
260 1 : event->set_session_id(m_sessionId);
261 1 : event->set_source_id(sourceId);
262 :
263 1 : m_ipcClient->sendEvent(event);
264 : }
265 : } // namespace firebolt::rialto::server::ipc
|
