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 "VirtualScreenImpl.h"
17
18 #define boolean jpegboolean
19 #include "jpeglib.h"
20 #undef boolean
21
22 #include "CommandLineInterface.h"
23 #include "CommandParser.h"
24 #include "PreviewerEngineLog.h"
25 #include "TraceTool.h"
26
27 using namespace std;
28
GetInstance()29 VirtualScreenImpl& VirtualScreenImpl::GetInstance()
30 {
31 static VirtualScreenImpl virtualScreen;
32 return virtualScreen;
33 }
34
StartTimer()35 void VirtualScreenImpl::StartTimer()
36 {
37 while (true) {
38 auto endTime = std::chrono::system_clock::now();
39 int64_t timePassed = chrono::duration_cast<chrono::milliseconds>(endTime -
40 VirtualScreenImpl::GetInstance().startTime).count();
41 if (timePassed >= SEND_IMG_DURATION_MS) {
42 GetInstance().SetLoadDocFlag(VirtualScreen::LoadDocType::NORMAL);
43 VirtualScreen::isStartCount = true;
44 {
45 std::lock_guard<std::mutex> guard(WebSocketServer::GetInstance().mutex);
46 if (GetInstance().loadDocCopyBuffer != nullptr) {
47 delete [] GetInstance().loadDocCopyBuffer;
48 GetInstance().loadDocCopyBuffer = nullptr;
49 }
50 GetInstance().loadDocCopyBuffer = new uint8_t[GetInstance().lengthTemp];
51 std::copy(GetInstance().loadDocTempBuffer,
52 GetInstance().loadDocTempBuffer + GetInstance().lengthTemp,
53 GetInstance().loadDocCopyBuffer);
54 }
55 VirtualScreenImpl::GetInstance().protocolVersion =
56 static_cast<uint16_t>(VirtualScreen::ProtocolVersion::LOADDOC);
57 GetInstance().bufferSize = GetInstance().lengthTemp + GetInstance().headSize;
58 GetInstance().wholeBuffer = new uint8_t[LWS_PRE + GetInstance().bufferSize];
59 GetInstance().screenBuffer = GetInstance().wholeBuffer + LWS_PRE;
60 GetInstance().SendPixmap(GetInstance().loadDocCopyBuffer,
61 GetInstance().lengthTemp,
62 GetInstance().widthTemp,
63 GetInstance().heightTemp);
64 ILOG("LoadDocFlag2:finished");
65 return;
66 }
67 }
68 }
69
LoadDocCallback(const void * data,const size_t length,const int32_t width,const int32_t height)70 bool VirtualScreenImpl::LoadDocCallback(const void* data,
71 const size_t length,
72 const int32_t width,
73 const int32_t height)
74 {
75 if (GetInstance().GetLoadDocFlag() == VirtualScreen::LoadDocType::FINISHED) {
76 {
77 std::lock_guard<std::mutex> guard(WebSocketServer::GetInstance().mutex);
78 if (GetInstance().loadDocTempBuffer != nullptr) {
79 delete [] GetInstance().loadDocTempBuffer;
80 GetInstance().loadDocTempBuffer = nullptr;
81 }
82 GetInstance().lengthTemp = length;
83 GetInstance().widthTemp = width;
84 GetInstance().heightTemp = height;
85 if (length <= 0) {
86 return false;
87 }
88 GetInstance().loadDocTempBuffer = new uint8_t[length];
89 uint8_t* dataPtr = reinterpret_cast<uint8_t*>(const_cast<void*>(data));
90 std::copy(dataPtr, dataPtr + length, GetInstance().loadDocTempBuffer);
91 }
92 if (VirtualScreen::isStartCount) {
93 VirtualScreen::isStartCount = false;
94 VirtualScreen::startTime = std::chrono::system_clock::now();
95 thread timerThread(std::ref(VirtualScreenImpl::StartTimer));
96 timerThread.detach();
97 }
98 return false;
99 }
100 return true;
101 }
102
CallBack(const void * data,const size_t length,const int32_t width,const int32_t height)103 bool VirtualScreenImpl::CallBack(const void* data, const size_t length,
104 const int32_t width, const int32_t height)
105 {
106 if (VirtualScreenImpl::GetInstance().GetLoadDocFlag() < VirtualScreen::LoadDocType::FINISHED) {
107 return false;
108 }
109 if (VirtualScreenImpl::GetInstance().JudgeAndDropFrame()) {
110 return false;
111 }
112 VirtualScreenImpl::GetInstance().SetOrignalWidth(width);
113 VirtualScreenImpl::GetInstance().SetOrignalHeight(height);
114 VirtualScreenImpl::GetInstance().SetCompressionWidth(width);
115 VirtualScreenImpl::GetInstance().SetCompressionHeight(height);
116
117 bool staticRet = VirtualScreen::JudgeStaticImage(SEND_IMG_DURATION_MS);
118 if (!staticRet) {
119 return false;
120 }
121
122 if (!LoadDocCallback(data, length, width, height)) {
123 return false;
124 }
125
126 GetInstance().bufferSize = length + GetInstance().headSize;
127 GetInstance().wholeBuffer = new uint8_t[LWS_PRE + GetInstance().bufferSize];
128 GetInstance().screenBuffer = GetInstance().wholeBuffer + LWS_PRE;
129
130 return GetInstance().SendPixmap(data, length, width, height);
131 }
132
PageCallBack(const std::string currentRouterPath)133 bool VirtualScreenImpl::PageCallBack(const std::string currentRouterPath)
134 {
135 std::string currentRouter = currentRouterPath.substr(0, currentRouterPath.size() - 3);
136 ILOG("PageCallBack currentPage is : %s", currentRouter.c_str());
137 GetInstance().SetCurrentRouter(currentRouter);
138 Json::Value val;
139 CommandLineInterface::GetInstance().CreatCommandToSendData("CurrentRouter", val, "get");
140 return true;
141 }
142
FastPreviewCallBack(const std::string & jsonStr)143 void VirtualScreenImpl::FastPreviewCallBack(const std::string& jsonStr)
144 {
145 GetInstance().SetFastPreviewMsg(jsonStr);
146 Json::Value val;
147 CommandLineInterface::GetInstance().CreatCommandToSendData("FastPreviewMsg", val, "get");
148 }
149
InitAll(string pipeName,string pipePort)150 void VirtualScreenImpl::InitAll(string pipeName, string pipePort)
151 {
152 VirtualScreen::InitPipe(pipeName, pipePort);
153 }
154
VirtualScreenImpl()155 VirtualScreenImpl::VirtualScreenImpl()
156 : isFirstSend(true),
157 isFirstRender(true),
158 writed(0),
159 wholeBuffer(nullptr),
160 screenBuffer(nullptr),
161 bufferSize(0),
162 currentPos(0)
163 {
164 }
165
~VirtualScreenImpl()166 VirtualScreenImpl::~VirtualScreenImpl()
167 {
168 FreeJpgMemory();
169 if (WebSocketServer::GetInstance().firstImageBuffer) {
170 delete [] WebSocketServer::GetInstance().firstImageBuffer;
171 WebSocketServer::GetInstance().firstImageBuffer = nullptr;
172 }
173 if (VirtualScreenImpl::GetInstance().loadDocTempBuffer != nullptr) {
174 delete [] VirtualScreenImpl::GetInstance().loadDocTempBuffer;
175 VirtualScreenImpl::GetInstance().loadDocTempBuffer = nullptr;
176 }
177 if (VirtualScreenImpl::GetInstance().loadDocCopyBuffer != nullptr) {
178 delete [] VirtualScreenImpl::GetInstance().loadDocCopyBuffer;
179 VirtualScreenImpl::GetInstance().loadDocCopyBuffer = nullptr;
180 }
181 }
182
Send(const void * data,int32_t retWidth,int32_t retHeight)183 void VirtualScreenImpl::Send(const void* data, int32_t retWidth, int32_t retHeight)
184 {
185 if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC
186 && VirtualScreen::isOutOfSeconds) {
187 return;
188 }
189
190 if (retWidth < 1 || retHeight < 1) {
191 FLOG("VirtualScreenImpl::RgbToJpg the retWidth or height is invalid value");
192 }
193 unsigned char* dataTemp = new unsigned char[retWidth * retHeight * jpgPix];
194 for (int i = 0; i < retHeight; i++) {
195 for (int j = 0; j < retWidth; j++) {
196 int input_base_pos = i * retWidth * pixelSize + j * pixelSize;
197 int now_base_pos = i * retWidth * jpgPix + j * jpgPix;
198 dataTemp[now_base_pos + redPos] = *((char*)data + input_base_pos + redPos);
199 dataTemp[now_base_pos + greenPos] = *((char*)data + input_base_pos + greenPos);
200 dataTemp[now_base_pos + bluePos] = *((char*)data + input_base_pos + bluePos);
201 }
202 }
203 VirtualScreen::RgbToJpg(dataTemp, retWidth, retHeight);
204 delete [] dataTemp;
205 if (jpgBufferSize > bufferSize - headSize) {
206 FLOG("VirtualScreenImpl::Send length must < %d", bufferSize - headSize);
207 }
208
209 std::copy(jpgScreenBuffer, jpgScreenBuffer + jpgBufferSize, screenBuffer + headSize);
210 writed = WebSocketServer::GetInstance().WriteData(screenBuffer, headSize + jpgBufferSize);
211 std::lock_guard<std::mutex> guard(WebSocketServer::GetInstance().mutex);
212 if (WebSocketServer::GetInstance().firstImageBuffer) {
213 delete [] WebSocketServer::GetInstance().firstImageBuffer;
214 WebSocketServer::GetInstance().firstImageBuffer = nullptr;
215 }
216 WebSocketServer::GetInstance().firstImageBuffer = new uint8_t[LWS_PRE + bufferSize];
217 WebSocketServer::GetInstance().firstImagebufferSize = headSize + jpgBufferSize;
218 std::copy(screenBuffer,
219 screenBuffer + headSize + jpgBufferSize,
220 WebSocketServer::GetInstance().firstImageBuffer + LWS_PRE);
221
222 FreeJpgMemory();
223 }
224
SendPixmap(const void * data,size_t length,int32_t retWidth,int32_t retHeight)225 bool VirtualScreenImpl::SendPixmap(const void* data, size_t length, int32_t retWidth, int32_t retHeight)
226 {
227 if (data == nullptr) {
228 ELOG("render callback data is null.");
229 invalidFrameCountPerMinute++;
230 return false;
231 }
232
233 if (!isWebSocketConfiged) {
234 ELOG("image socket is not ready");
235 return false;
236 }
237
238 if (isFirstRender) {
239 ILOG("Get first render buffer");
240 TraceTool::GetInstance().HandleTrace("Get first render buffer");
241 isFirstRender = false;
242 }
243
244 isFrameUpdated = true;
245 currentPos = 0;
246
247 WriteBuffer(headStart);
248 WriteBuffer(retWidth);
249 WriteBuffer(retHeight);
250 WriteBuffer(retWidth);
251 WriteBuffer(retHeight);
252 if (!CommandParser::GetInstance().IsRegionRefresh()) {
253 for (size_t i = 0; i < headReservedSize / sizeof(int32_t); i++) {
254 WriteBuffer(static_cast<uint32_t>(0));
255 }
256 } else {
257 uint16_t x1 = 0;
258 uint16_t y1 = 0;
259 uint16_t width = static_cast<uint16_t>(retWidth);
260 uint16_t height = static_cast<uint16_t>(retHeight);
261 WriteBuffer(protocolVersion);
262 WriteBuffer(x1);
263 WriteBuffer(y1);
264 WriteBuffer(width);
265 WriteBuffer(height);
266 for (size_t i = 0; i < 10 / sizeof(uint16_t); i++) { // fill 10bytes for header
267 WriteBuffer(static_cast<uint16_t>(0));
268 }
269 }
270 Send(data, retWidth, retHeight);
271 if (isFirstSend) {
272 ILOG("Send first buffer finish");
273 TraceTool::GetInstance().HandleTrace("Send first buffer finish");
274 isFirstSend = false;
275 }
276
277 validFrameCountPerMinute++;
278 sendFrameCountPerMinute++;
279 return writed == length;
280 }
281
FreeJpgMemory()282 void VirtualScreenImpl::FreeJpgMemory()
283 {
284 if (wholeBuffer != nullptr) {
285 delete [] wholeBuffer;
286 wholeBuffer = nullptr;
287 screenBuffer = nullptr;
288 }
289 if (jpgScreenBuffer != nullptr) {
290 free(jpgScreenBuffer);
291 jpgScreenBuffer = NULL;
292 jpgBufferSize = 0;
293 }
294 if (VirtualScreenImpl::GetInstance().loadDocCopyBuffer != nullptr) {
295 delete [] VirtualScreenImpl::GetInstance().loadDocCopyBuffer;
296 VirtualScreenImpl::GetInstance().loadDocCopyBuffer = nullptr;
297 }
298 }
299