1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "VirtualScreen.h"
17 #include "CommandParser.h"
18 #include "CppTimerManager.h"
19 #include "PreviewerEngineLog.h"
20 #include "VirtualScreen.h"
21
22 #define boolean jpegboolean
23 #include "jpeglib.h"
24 #undef boolean
25
26 uint32_t VirtualScreen::validFrameCountPerMinute = 0;
27 uint32_t VirtualScreen::invalidFrameCountPerMinute = 0;
28 uint32_t VirtualScreen::sendFrameCountPerMinute = 0;
29 uint32_t VirtualScreen::inputKeyCountPerMinute = 0;
30 uint32_t VirtualScreen::inputMethodCountPerMinute = 0;
31 bool VirtualScreen::isWebSocketListening = false;
32 std::string VirtualScreen::webSocketPort = "";
33
34 std::chrono::system_clock::time_point VirtualScreen::startTime = std::chrono::system_clock::now();
35 std::chrono::system_clock::time_point VirtualScreen::staticCardStartTime = std::chrono::system_clock::now();
36 bool VirtualScreen::isStartCount = true;
37 bool VirtualScreen::isOutOfSeconds = false;
38
VirtualScreen()39 VirtualScreen::VirtualScreen()
40 : isFrameUpdated(false),
41 orignalResolutionWidth(0),
42 orignalResolutionHeight(0),
43 compressionResolutionWidth(0),
44 compressionResolutionHeight(0),
45 screenSocket(nullptr),
46 frameCountTimer(nullptr),
47 isWebSocketConfiged(false),
48 currentRouter(""),
49 jpgScreenBuffer(nullptr),
50 jpgBufferSize(0)
51 {
52 }
53
~VirtualScreen()54 VirtualScreen::~VirtualScreen()
55 {
56 if (screenSocket != nullptr) {
57 screenSocket->DisconnectFromServer();
58 delete screenSocket;
59 screenSocket = nullptr;
60 }
61 }
62
GetCurrentRouter() const63 std::string VirtualScreen::GetCurrentRouter() const
64 {
65 return currentRouter;
66 }
67
SetCurrentRouter(const std::string currentRouterValue)68 void VirtualScreen::SetCurrentRouter(const std::string currentRouterValue)
69 {
70 currentRouter = currentRouterValue;
71 }
72
GetAbilityCurrentRouter() const73 std::string VirtualScreen::GetAbilityCurrentRouter() const
74 {
75 return abilityCurrentRouter;
76 }
77
SetAbilityCurrentRouter(const std::string currentRouterValue)78 void VirtualScreen::SetAbilityCurrentRouter(const std::string currentRouterValue)
79 {
80 abilityCurrentRouter = currentRouterValue;
81 }
82
GetOrignalWidth() const83 int32_t VirtualScreen::GetOrignalWidth() const
84 {
85 return orignalResolutionWidth;
86 }
87
SetOrignalWidth(const int32_t & value)88 void VirtualScreen::SetOrignalWidth(const int32_t& value)
89 {
90 orignalResolutionWidth = value;
91 }
92
GetOrignalHeight() const93 int32_t VirtualScreen::GetOrignalHeight() const
94 {
95 return orignalResolutionHeight;
96 }
97
SetOrignalHeight(const int32_t & value)98 void VirtualScreen::SetOrignalHeight(const int32_t& value)
99 {
100 orignalResolutionHeight = value;
101 }
102
GetCompressionWidth() const103 int32_t VirtualScreen::GetCompressionWidth() const
104 {
105 return compressionResolutionWidth;
106 }
107
SetCompressionWidth(const int32_t & value)108 void VirtualScreen::SetCompressionWidth(const int32_t& value)
109 {
110 compressionResolutionWidth = value;
111 }
112
GetCompressionHeight() const113 int32_t VirtualScreen::GetCompressionHeight() const
114 {
115 return compressionResolutionHeight;
116 }
117
SetCompressionHeight(const int32_t & value)118 void VirtualScreen::SetCompressionHeight(const int32_t& value)
119 {
120 compressionResolutionHeight = value;
121 }
122
InitPipe(std::string pipeName,std::string pipePort)123 void VirtualScreen::InitPipe(std::string pipeName, std::string pipePort)
124 {
125 webSocketPort = pipePort;
126 isWebSocketConfiged = true;
127 WebSocketServer::GetInstance().SetServerPort(atoi(pipePort.c_str()));
128 WebSocketServer::GetInstance().SetSid(CommandParser::GetInstance().GetSid());
129 WebSocketServer::GetInstance().Run();
130 isWebSocketListening = true;
131 }
132
InitVirtualScreen()133 void VirtualScreen::InitVirtualScreen()
134 {
135 int32_t orignalWidth = CommandParser::GetInstance().GetOrignalResolutionWidth();
136 int32_t orignalHeight = CommandParser::GetInstance().GetOrignalResolutionHeight();
137 int32_t compressionWidth = CommandParser::GetInstance().GetCompressionResolutionWidth();
138 int32_t compressionHeight = CommandParser::GetInstance().GetCompressionResolutionHeight();
139 SetVirtualScreenWidthAndHeight(orignalWidth, orignalHeight, compressionWidth, compressionHeight);
140 }
141
SetVirtualScreenWidthAndHeight(const int32_t & orignalWidth,const int32_t & orignalHeight,const int32_t & compressionWidth,const int32_t & compressionHeight)142 void VirtualScreen::SetVirtualScreenWidthAndHeight(const int32_t& orignalWidth,
143 const int32_t& orignalHeight,
144 const int32_t& compressionWidth,
145 const int32_t& compressionHeight)
146 {
147 VirtualScreen::SetOrignalWidth(orignalWidth);
148 VirtualScreen::SetOrignalHeight(orignalHeight);
149 VirtualScreen::SetCompressionWidth(compressionWidth);
150 VirtualScreen::SetCompressionHeight(compressionHeight);
151 }
152
WidthAndHeightReverse()153 void VirtualScreen::WidthAndHeightReverse()
154 {
155 int32_t temp = 0;
156 temp = orignalResolutionHeight;
157 orignalResolutionHeight = orignalResolutionWidth;
158 orignalResolutionWidth = temp;
159 temp = compressionResolutionHeight;
160 compressionResolutionHeight = compressionResolutionWidth;
161 compressionResolutionWidth = temp;
162 }
163
InitFrameCountTimer()164 void VirtualScreen::InitFrameCountTimer()
165 {
166 if (frameCountTimer.get() != nullptr) {
167 ILOG("VirtualScreen::InitFrameCountTimer timer is already started.");
168 return;
169 }
170
171 frameCountTimer = std::make_unique<CppTimer>(VirtualScreen::PrintFrameCount);
172 if (frameCountTimer == nullptr) {
173 ELOG("JsApp::InitTimer taskHandleTimer memory allocation failed.");
174 return;
175 }
176 CppTimerManager::GetTimerManager().AddCppTimer(*frameCountTimer);
177 frameCountTimer->Start(frameCountPeriod);
178 }
179
PrintFrameCount()180 void VirtualScreen::PrintFrameCount()
181 {
182 if ((validFrameCountPerMinute | invalidFrameCountPerMinute | sendFrameCountPerMinute |
183 inputKeyCountPerMinute | inputMethodCountPerMinute) == 0) {
184 return;
185 }
186
187 ELOG("ValidFrameCount: %d InvalidFrameCount: %d SendFrameCount: %d inputKeyCount: %d\
188 inputMethodCount: %d", validFrameCountPerMinute, invalidFrameCountPerMinute,
189 sendFrameCountPerMinute, inputKeyCountPerMinute, inputMethodCountPerMinute);
190 validFrameCountPerMinute = 0;
191 invalidFrameCountPerMinute = 0;
192 sendFrameCountPerMinute = 0;
193 inputKeyCountPerMinute = 0;
194 inputMethodCountPerMinute = 0;
195 }
196
197
SetLoadDocFlag(VirtualScreen::LoadDocType flag)198 void VirtualScreen::SetLoadDocFlag(VirtualScreen::LoadDocType flag)
199 {
200 startLoadDoc = flag;
201 }
202
GetLoadDocFlag() const203 VirtualScreen::LoadDocType VirtualScreen::GetLoadDocFlag() const
204 {
205 return startLoadDoc;
206 }
207
GetJpgQualityValue(int32_t width,int32_t height) const208 int VirtualScreen::GetJpgQualityValue(int32_t width, int32_t height) const
209 {
210 long long pixCount = static_cast<long long>(width) * static_cast<long long>(height);
211 if (pixCount <= static_cast<int>(JpgPixCountLevel::LOWCOUNT)) {
212 return static_cast<int>(JpgQualityLevel::HIGHLEVEL);
213 } else if (pixCount > static_cast<int>(JpgPixCountLevel::LOWCOUNT) &&
214 pixCount <= static_cast<int>(JpgPixCountLevel::MIDDLECOUNT)) {
215 return static_cast<int>(JpgQualityLevel::MIDDLELEVEL);
216 } else if (pixCount > static_cast<int>(JpgPixCountLevel::MIDDLECOUNT) &&
217 pixCount <= static_cast<int>(JpgPixCountLevel::HIGHCOUNT)) {
218 return static_cast<int>(JpgQualityLevel::LOWLEVEL);
219 } else {
220 return static_cast<int>(JpgQualityLevel::DEFAULTLEVEL);
221 }
222 }
223
GetFastPreviewMsg() const224 std::string VirtualScreen::GetFastPreviewMsg() const
225 {
226 return fastPreviewMsg;
227 }
228
SetFastPreviewMsg(const std::string msg)229 void VirtualScreen::SetFastPreviewMsg(const std::string msg)
230 {
231 fastPreviewMsg = msg;
232 }
233
SetDropFrameFrequency(const int32_t & value)234 void VirtualScreen::SetDropFrameFrequency(const int32_t& value)
235 {
236 dropFrameFrequency = value;
237 startDropFrameTime = std::chrono::system_clock::now();
238 }
239
JudgeAndDropFrame()240 bool VirtualScreen::JudgeAndDropFrame()
241 {
242 if (dropFrameFrequency <= 0) {
243 return false;
244 }
245 auto endTime = std::chrono::system_clock::now();
246 int64_t timePassed = std::chrono::duration_cast<std::chrono::milliseconds>(endTime -
247 startDropFrameTime).count();
248 if (timePassed >= dropFrameFrequency) {
249 startDropFrameTime = std::chrono::system_clock::now();
250 }
251 return timePassed < dropFrameFrequency;
252 }
253
JudgeStaticImage(const int duration)254 bool VirtualScreen::JudgeStaticImage(const int duration)
255 {
256 if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
257 if (VirtualScreen::isOutOfSeconds) {
258 return false;
259 }
260 if (VirtualScreen::isStartCount) {
261 VirtualScreen::isStartCount = false;
262 VirtualScreen::startTime = std::chrono::system_clock::now();
263 }
264 auto endTime = std::chrono::system_clock::now();
265 int64_t timePassed = std::chrono::duration_cast<std::chrono::milliseconds>(endTime -
266 VirtualScreen::startTime).count();
267 if (timePassed > duration) {
268 VirtualScreen::isOutOfSeconds = true;
269 return false;
270 }
271 }
272 return true;
273 }
274
StopSendStaticCardImage(const int duration)275 bool VirtualScreen::StopSendStaticCardImage(const int duration)
276 {
277 if (CommandParser::GetInstance().IsStaticCard()) {
278 static bool first = true;
279 if (first) {
280 first = false;
281 VirtualScreen::staticCardStartTime = std::chrono::system_clock::now();
282 }
283 auto endTime = std::chrono::system_clock::now();
284 int64_t timePassed = std::chrono::duration_cast<std::chrono::milliseconds>(endTime -
285 VirtualScreen::staticCardStartTime).count();
286 if (timePassed > duration) {
287 return true;
288 }
289 }
290 return false;
291 }
292
RgbToJpg(unsigned char * data,const int32_t width,const int32_t height)293 void VirtualScreen::RgbToJpg(unsigned char* data, const int32_t width, const int32_t height)
294 {
295 if (width < 1 || height < 1) {
296 FLOG("VirtualScreenImpl::RgbToJpg the width or height is invalid value");
297 }
298 jpeg_compress_struct jpeg = {0};
299 jpeg_error_mgr jerr;
300 jpeg.err = jpeg_std_error(&jerr);
301 jpeg_create_compress(&jpeg);
302 jpeg_mem_dest(&jpeg, &jpgScreenBuffer, &jpgBufferSize);
303 jpeg.image_width = width;
304 jpeg.image_height = height;
305 jpeg.input_components = jpgPix;
306 jpeg.in_color_space = JCS_RGB;
307 jpeg_set_defaults(&jpeg);
308 jpeg_set_quality(&jpeg, GetJpgQualityValue(width, height), TRUE);
309 jpeg_start_compress(&jpeg, TRUE);
310 JSAMPROW rowPointer[1];
311 int rowStride = width * jpgPix;
312 while (jpeg.next_scanline < jpeg.image_height) {
313 rowPointer[0] = &data[jpeg.next_scanline * rowStride];
314 jpeg_write_scanlines(&jpeg, rowPointer, 1);
315 }
316 jpeg_finish_compress(&jpeg);
317 jpeg_destroy_compress(&jpeg);
318 }
319
SetFoldable(const bool value)320 void VirtualScreen::SetFoldable(const bool value)
321 {
322 foldable = value;
323 }
324
GetFoldable() const325 bool VirtualScreen::GetFoldable() const
326 {
327 return foldable;
328 }
329
SetFoldStatus(const std::string & value)330 void VirtualScreen::SetFoldStatus(const std::string& value)
331 {
332 foldStatus = value;
333 }
334
GetFoldStatus() const335 std::string VirtualScreen::GetFoldStatus() const
336 {
337 return foldStatus;
338 }
339
SetFoldResolution(int32_t changedFoldWidth,int32_t changedFoldHeight)340 void VirtualScreen::SetFoldResolution(int32_t changedFoldWidth, int32_t changedFoldHeight)
341 {
342 foldWidth = changedFoldWidth;
343 foldHeight = changedFoldHeight;
344 }
345
GetFoldWidth() const346 int32_t VirtualScreen::GetFoldWidth() const
347 {
348 return foldWidth;
349 }
350
GetFoldHeight() const351 int32_t VirtualScreen::GetFoldHeight() const
352 {
353 return foldHeight;
354 }
355
SetCurrentResolution(int32_t width,int32_t height)356 void VirtualScreen::SetCurrentResolution(int32_t width, int32_t height)
357 {
358 currentWidth = width;
359 currentHeight = height;
360 }
361
GetCurrentWidth() const362 int32_t VirtualScreen::GetCurrentWidth() const
363 {
364 return currentWidth;
365 }
366
GetCurrentHeight() const367 int32_t VirtualScreen::GetCurrentHeight() const
368 {
369 return currentHeight;
370 }
371
InitFlushEmptyTime()372 void VirtualScreen::InitFlushEmptyTime() {}
373
InitResolution()374 void VirtualScreen::InitResolution()
375 {
376 CommandInfo commandInfo;
377 CommandParser::GetInstance().GetCommandInfo(commandInfo);
378 SetOrignalWidth(commandInfo.orignalResolutionWidth);
379 SetOrignalHeight(commandInfo.orignalResolutionHeight);
380 SetCompressionWidth(commandInfo.compressionResolutionWidth);
381 SetCompressionHeight(commandInfo.compressionResolutionHeight);
382 SetCurrentResolution(commandInfo.orignalResolutionWidth, commandInfo.orignalResolutionHeight);
383 }