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 using namespace std;
27
28 uint32_t VirtualScreen::validFrameCountPerMinute = 0;
29 uint32_t VirtualScreen::invalidFrameCountPerMinute = 0;
30 uint32_t VirtualScreen::sendFrameCountPerMinute = 0;
31 uint32_t VirtualScreen::inputKeyCountPerMinute = 0;
32 uint32_t VirtualScreen::inputMethodCountPerMinute = 0;
33 bool VirtualScreen::isWebSocketListening = false;
34 std::string VirtualScreen::webSocketPort = "";
35
36 std::chrono::system_clock::time_point VirtualScreen::startTime = std::chrono::system_clock::now();
37 std::chrono::system_clock::time_point VirtualScreen::staticCardStartTime = std::chrono::system_clock::now();
38 bool VirtualScreen::isStartCount = true;
39 bool VirtualScreen::isOutOfSeconds = false;
40
VirtualScreen()41 VirtualScreen::VirtualScreen()
42 : isFrameUpdated(false),
43 orignalResolutionWidth(0),
44 orignalResolutionHeight(0),
45 compressionResolutionWidth(0),
46 compressionResolutionHeight(0),
47 screenSocket(nullptr),
48 frameCountTimer(nullptr),
49 isWebSocketConfiged(false),
50 currentRouter(""),
51 jpgScreenBuffer(nullptr),
52 jpgBufferSize(0)
53 {
54 }
55
~VirtualScreen()56 VirtualScreen::~VirtualScreen()
57 {
58 if (screenSocket != nullptr) {
59 screenSocket->DisconnectFromServer();
60 delete screenSocket;
61 screenSocket = nullptr;
62 }
63 }
64
GetCurrentRouter() const65 std::string VirtualScreen::GetCurrentRouter() const
66 {
67 return currentRouter;
68 }
69
SetCurrentRouter(const std::string currentRouterValue)70 void VirtualScreen::SetCurrentRouter(const std::string currentRouterValue)
71 {
72 currentRouter = currentRouterValue;
73 }
74
GetAbilityCurrentRouter() const75 std::string VirtualScreen::GetAbilityCurrentRouter() const
76 {
77 return abilityCurrentRouter;
78 }
79
SetAbilityCurrentRouter(const std::string currentRouterValue)80 void VirtualScreen::SetAbilityCurrentRouter(const std::string currentRouterValue)
81 {
82 abilityCurrentRouter = currentRouterValue;
83 }
84
GetOrignalWidth() const85 int32_t VirtualScreen::GetOrignalWidth() const
86 {
87 return orignalResolutionWidth;
88 }
89
SetOrignalWidth(const int32_t & value)90 void VirtualScreen::SetOrignalWidth(const int32_t& value)
91 {
92 orignalResolutionWidth = value;
93 }
94
GetOrignalHeight() const95 int32_t VirtualScreen::GetOrignalHeight() const
96 {
97 return orignalResolutionHeight;
98 }
99
SetOrignalHeight(const int32_t & value)100 void VirtualScreen::SetOrignalHeight(const int32_t& value)
101 {
102 orignalResolutionHeight = value;
103 }
104
GetCompressionWidth() const105 int32_t VirtualScreen::GetCompressionWidth() const
106 {
107 return compressionResolutionWidth;
108 }
109
SetCompressionWidth(const int32_t & value)110 void VirtualScreen::SetCompressionWidth(const int32_t& value)
111 {
112 compressionResolutionWidth = value;
113 }
114
GetCompressionHeight() const115 int32_t VirtualScreen::GetCompressionHeight() const
116 {
117 return compressionResolutionHeight;
118 }
119
SetCompressionHeight(const int32_t & value)120 void VirtualScreen::SetCompressionHeight(const int32_t& value)
121 {
122 compressionResolutionHeight = value;
123 }
124
InitPipe(string pipeName,string pipePort)125 void VirtualScreen::InitPipe(string pipeName, string pipePort)
126 {
127 webSocketPort = pipePort;
128 isWebSocketConfiged = true;
129 WebSocketServer::GetInstance().SetServerPort(atoi(pipePort.c_str()));
130 WebSocketServer::GetInstance().SetSid(CommandParser::GetInstance().GetSid());
131 WebSocketServer::GetInstance().Run();
132 isWebSocketListening = true;
133 }
134
InitVirtualScreen()135 void VirtualScreen::InitVirtualScreen()
136 {
137 int32_t orignalWidth = CommandParser::GetInstance().GetOrignalResolutionWidth();
138 int32_t orignalHeight = CommandParser::GetInstance().GetOrignalResolutionHeight();
139 int32_t compressionWidth = CommandParser::GetInstance().GetCompressionResolutionWidth();
140 int32_t compressionHeight = CommandParser::GetInstance().GetCompressionResolutionHeight();
141 SetVirtualScreenWidthAndHeight(orignalWidth, orignalHeight, compressionWidth, compressionHeight);
142 }
143
SetVirtualScreenWidthAndHeight(const int32_t & orignalWidth,const int32_t & orignalHeight,const int32_t & compressionWidth,const int32_t & compressionHeight)144 void VirtualScreen::SetVirtualScreenWidthAndHeight(const int32_t& orignalWidth,
145 const int32_t& orignalHeight,
146 const int32_t& compressionWidth,
147 const int32_t& compressionHeight)
148 {
149 VirtualScreen::SetOrignalWidth(orignalWidth);
150 VirtualScreen::SetOrignalHeight(orignalHeight);
151 VirtualScreen::SetCompressionWidth(compressionWidth);
152 VirtualScreen::SetCompressionHeight(compressionHeight);
153 }
154
WidthAndHeightReverse()155 void VirtualScreen::WidthAndHeightReverse()
156 {
157 int32_t temp = 0;
158 temp = orignalResolutionHeight;
159 orignalResolutionHeight = orignalResolutionWidth;
160 orignalResolutionWidth = temp;
161 temp = compressionResolutionHeight;
162 compressionResolutionHeight = compressionResolutionWidth;
163 compressionResolutionWidth = temp;
164 }
165
InitFrameCountTimer()166 void VirtualScreen::InitFrameCountTimer()
167 {
168 if (frameCountTimer.get() != nullptr) {
169 ILOG("VirtualScreen::InitFrameCountTimer timer is already started.");
170 return;
171 }
172
173 frameCountTimer = make_unique<CppTimer>(VirtualScreen::PrintFrameCount);
174 if (frameCountTimer == nullptr) {
175 ELOG("JsApp::InitTimer taskHandleTimer memory allocation failed.");
176 return;
177 }
178 CppTimerManager::GetTimerManager().AddCppTimer(*frameCountTimer);
179 frameCountTimer->Start(frameCountPeriod);
180 }
181
PrintFrameCount()182 void VirtualScreen::PrintFrameCount()
183 {
184 if ((validFrameCountPerMinute | invalidFrameCountPerMinute | sendFrameCountPerMinute |
185 inputKeyCountPerMinute | inputMethodCountPerMinute) == 0) {
186 return;
187 }
188
189 ELOG("ValidFrameCount: %d InvalidFrameCount: %d SendFrameCount: %d inputKeyCount: %d\
190 inputMethodCount: %d", validFrameCountPerMinute, invalidFrameCountPerMinute,
191 sendFrameCountPerMinute, inputKeyCountPerMinute, inputMethodCountPerMinute);
192 validFrameCountPerMinute = 0;
193 invalidFrameCountPerMinute = 0;
194 sendFrameCountPerMinute = 0;
195 inputKeyCountPerMinute = 0;
196 inputMethodCountPerMinute = 0;
197 }
198
199
SetLoadDocFlag(VirtualScreen::LoadDocType flag)200 void VirtualScreen::SetLoadDocFlag(VirtualScreen::LoadDocType flag)
201 {
202 startLoadDoc = flag;
203 }
204
GetLoadDocFlag() const205 VirtualScreen::LoadDocType VirtualScreen::GetLoadDocFlag() const
206 {
207 return startLoadDoc;
208 }
209
GetJpgQualityValue(int32_t width,int32_t height) const210 int VirtualScreen::GetJpgQualityValue(int32_t width, int32_t height) const
211 {
212 long long pixCount = static_cast<long long>(width) * static_cast<long long>(height);
213 if (pixCount <= static_cast<int>(JpgPixCountLevel::LOWCOUNT)) {
214 return static_cast<int>(JpgQualityLevel::HIGHLEVEL);
215 } else if (pixCount > static_cast<int>(JpgPixCountLevel::LOWCOUNT) &&
216 pixCount <= static_cast<int>(JpgPixCountLevel::MIDDLECOUNT)) {
217 return static_cast<int>(JpgQualityLevel::MIDDLELEVEL);
218 } else if (pixCount > static_cast<int>(JpgPixCountLevel::MIDDLECOUNT) &&
219 pixCount <= static_cast<int>(JpgPixCountLevel::HIGHCOUNT)) {
220 return static_cast<int>(JpgQualityLevel::LOWLEVEL);
221 } else {
222 return static_cast<int>(JpgQualityLevel::DEFAULTLEVEL);
223 }
224 }
225
GetFastPreviewMsg() const226 std::string VirtualScreen::GetFastPreviewMsg() const
227 {
228 return fastPreviewMsg;
229 }
230
SetFastPreviewMsg(const std::string msg)231 void VirtualScreen::SetFastPreviewMsg(const std::string msg)
232 {
233 fastPreviewMsg = msg;
234 }
235
SetDropFrameFrequency(const int32_t & value)236 void VirtualScreen::SetDropFrameFrequency(const int32_t& value)
237 {
238 dropFrameFrequency = value;
239 startDropFrameTime = std::chrono::system_clock::now();
240 }
241
JudgeAndDropFrame()242 bool VirtualScreen::JudgeAndDropFrame()
243 {
244 if (dropFrameFrequency <= 0) {
245 return false;
246 }
247 auto endTime = std::chrono::system_clock::now();
248 int64_t timePassed = chrono::duration_cast<chrono::milliseconds>(endTime -
249 startDropFrameTime).count();
250 if (timePassed >= dropFrameFrequency) {
251 startDropFrameTime = std::chrono::system_clock::now();
252 }
253 return timePassed < dropFrameFrequency;
254 }
255
JudgeStaticImage(const int duration)256 bool VirtualScreen::JudgeStaticImage(const int duration)
257 {
258 if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
259 if (VirtualScreen::isOutOfSeconds) {
260 return false;
261 }
262 if (VirtualScreen::isStartCount) {
263 VirtualScreen::isStartCount = false;
264 VirtualScreen::startTime = std::chrono::system_clock::now();
265 }
266 auto endTime = std::chrono::system_clock::now();
267 int64_t timePassed = chrono::duration_cast<chrono::milliseconds>(endTime -
268 VirtualScreen::startTime).count();
269 if (timePassed > duration) {
270 VirtualScreen::isOutOfSeconds = true;
271 return false;
272 }
273 }
274 return true;
275 }
276
StopSendStaticCardImage(const int duration)277 bool VirtualScreen::StopSendStaticCardImage(const int duration)
278 {
279 if (CommandParser::GetInstance().IsStaticCard()) {
280 static bool first = true;
281 if (first) {
282 first = false;
283 VirtualScreen::staticCardStartTime = std::chrono::system_clock::now();
284 }
285 auto endTime = std::chrono::system_clock::now();
286 int64_t timePassed = chrono::duration_cast<chrono::milliseconds>(endTime -
287 VirtualScreen::staticCardStartTime).count();
288 if (timePassed > duration) {
289 return true;
290 }
291 }
292 return false;
293 }
294
RgbToJpg(unsigned char * data,const int32_t width,const int32_t height)295 void VirtualScreen::RgbToJpg(unsigned char* data, const int32_t width, const int32_t height)
296 {
297 if (width < 1 || height < 1) {
298 FLOG("VirtualScreenImpl::RgbToJpg the width or height is invalid value");
299 }
300 jpeg_compress_struct jpeg = {0};
301 jpeg_error_mgr jerr;
302 jpeg.err = jpeg_std_error(&jerr);
303 jpeg_create_compress(&jpeg);
304 jpeg_mem_dest(&jpeg, &jpgScreenBuffer, &jpgBufferSize);
305 jpeg.image_width = width;
306 jpeg.image_height = height;
307 jpeg.input_components = jpgPix;
308 jpeg.in_color_space = JCS_RGB;
309 jpeg_set_defaults(&jpeg);
310 jpeg_set_quality(&jpeg, GetJpgQualityValue(width, height), TRUE);
311 jpeg_start_compress(&jpeg, TRUE);
312 JSAMPROW rowPointer[1];
313 int rowStride = width * jpgPix;
314 while (jpeg.next_scanline < jpeg.image_height) {
315 rowPointer[0] = &data[jpeg.next_scanline * rowStride];
316 jpeg_write_scanlines(&jpeg, rowPointer, 1);
317 }
318 jpeg_finish_compress(&jpeg);
319 jpeg_destroy_compress(&jpeg);
320 }
321
SetFoldable(const bool value)322 void VirtualScreen::SetFoldable(const bool value)
323 {
324 foldable = value;
325 }
326
GetFoldable() const327 bool VirtualScreen::GetFoldable() const
328 {
329 return foldable;
330 }
331
SetFoldStatus(const std::string & value)332 void VirtualScreen::SetFoldStatus(const std::string& value)
333 {
334 foldStatus = value;
335 }
336
GetFoldStatus() const337 std::string VirtualScreen::GetFoldStatus() const
338 {
339 return foldStatus;
340 }
341
SetFoldResolution(int32_t changedFoldWidth,int32_t changedFoldHeight)342 void VirtualScreen::SetFoldResolution(int32_t changedFoldWidth, int32_t changedFoldHeight)
343 {
344 foldWidth = changedFoldWidth;
345 foldHeight = changedFoldHeight;
346 }
347
GetFoldWidth() const348 int32_t VirtualScreen::GetFoldWidth() const
349 {
350 return foldWidth;
351 }
352
GetFoldHeight() const353 int32_t VirtualScreen::GetFoldHeight() const
354 {
355 return foldHeight;
356 }
357
SetCurrentResolution(int32_t width,int32_t height)358 void VirtualScreen::SetCurrentResolution(int32_t width, int32_t height)
359 {
360 currentWidth = width;
361 currentHeight = height;
362 }
363
GetCurrentWidth() const364 int32_t VirtualScreen::GetCurrentWidth() const
365 {
366 return currentWidth;
367 }
368
GetCurrentHeight() const369 int32_t VirtualScreen::GetCurrentHeight() const
370 {
371 return currentHeight;
372 }
373
InitFlushEmptyTime()374 void VirtualScreen::InitFlushEmptyTime() {}
375
InitResolution()376 void VirtualScreen::InitResolution()
377 {
378 CommandInfo commandInfo;
379 CommandParser::GetInstance().GetCommandInfo(commandInfo);
380 SetOrignalWidth(commandInfo.orignalResolutionWidth);
381 SetOrignalHeight(commandInfo.orignalResolutionHeight);
382 SetCompressionWidth(commandInfo.compressionResolutionWidth);
383 SetCompressionHeight(commandInfo.compressionResolutionHeight);
384 SetCurrentResolution(commandInfo.orignalResolutionWidth, commandInfo.orignalResolutionHeight);
385 }