Update README.md

2025-10-28 20:06:14 +08:00 · 2023-12-20 13:00:39 +08:00 · 2023-12-20 09:34:43 +08:00 · 2023-12-19 17:33:16 +08:00 · 2023-12-18 16:52:49 +08:00 · 2023-12-18 16:17:55 +08:00
39 changed files with 1796 additions and 675 deletions
--- a/20
+++ b/20
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 The Continuous Desk Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -0,0 +1,67 @@
+# Continuous Desk
+
+#### More than remote desktop
+
+----
+[Chinese](README_CN.md) / [English](README.md)
+
+![example](https://github.com/dijunkun/continuous-desk/assets/29698109/f3153e28-751e-477c-b4e3-ac2384d3370f)
+
+# Intro
+
+Continuous Desk is a lightweight cross-platform remote desktop. It allows multiple users to remotely control the same computer at the same time. In addition to desktop image transmission, it also supports end-to-end voice transmission, providing collaboration capabilities on the basis of remote desktop.
+
+Continuous Desk is an experimental application of [Projectx](https://github.com/dijunkun/projectx) real-time communications library. Projectx is a lightweight cross-platform real-time communications library. It has basic capabilities such as network traversal ([RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)), video softwar/hardware encoding/decoding (H264), audio encoding/decoding ([Opus](https://github.com/xiph/opus)), signaling interaction, and network congestion control ([TCP over UDP](https://libnice.freedesktop.org/)).
+
+## Usage
+
+Enter the remote desktop ID in the 'REMOTE ID' field on the menu bar, and click 'Connect' button to initiate the remote connection.
+
+![usage1](https://github.com/dijunkun/continuous-desk/assets/29698109/80099485-f2db-4f09-9fb2-e811d87265dc)
+
+If the remote desktop is set with a connection password, the local end needs to enter the correct password to initiate the remote connection. If the password is incorrect, an "Incorrect password" alert will appear in the status bar.
+
+![incorrect password](https://github.com/dijunkun/continuous-desk/assets/29698109/0b16d21a-baa6-49c1-9d87-5e80978dd345)
+
+After connection successfully established, the status bar will display the message "ClientConnected."
+
+![success](https://github.com/dijunkun/continuous-desk/assets/29698109/9c4f6604-2b1b-47b6-9c73-21c5026d1f26)
+
+## How to build
+
+Requirements<EFBFBD><EFBFBD>
+- [xmake](https://xmake.io/#/guide/installation)
+- [cmake](https://cmake.org/download/)
+- [vcpkg](https://vcpkg.io/en/getting-started)
+
+Following packages need to be installed on Linux<75><78>
+
+```
+sudo apt-get install -y nvidia-cuda-toolkit libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev libxv-dev libasound2-dev libsndio-dev libasound2-dev libpulse-dev
+```
+
+Commands
+```
+git clone https://github.com/dijunkun/continuous-desk
+
+cd continuous-desk
+
+git submodule init 
+
+git submodule update
+
+xmake b remote_desk
+```
+Run
+```
+# Windows/MacOS
+xmake r remote_desk
+
+# root privileges are required on Linux
+./remote_desk
+```
+
+## LICENSE
+
+Continuous Desk is licenced under MIT, and some third-party libraries are distributed under their licenses.
+
--- a/README_CN.md
+++ b/README_CN.md
@@ -0,0 +1,67 @@
+# Continuous Desk
+
+#### <20><>ֹԶ<D6B9><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+----
+[English](README.md) / [<EFBFBD><EFBFBD><EFBFBD><EFBFBD>](README_CN.md)
+
+![example](https://github.com/dijunkun/continuous-desk/assets/29698109/f3153e28-751e-477c-b4e3-ac2384d3370f)
+
+## <20><><EFBFBD><EFBFBD>
+
+Continuous Desk <20><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD>ƽ̨Զ<CCA8><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD>ͬһʱ<D2BB><CAB1>Զ<EFBFBD>̲ٿ<CCB2>ͬһ̨<D2BB><CCA8><EFBFBD>ԡ<EFBFBD><D4A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>⣬<EFBFBD><E2A3AC><EFBFBD><EFBFBD>֧<EFBFBD>ֶ˵<D6B6><CBB5>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䣬<EFBFBD><E4A3AC>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ṩ<EFBFBD><E1B9A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Э<EFBFBD><D0AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+Continuous Desk <20><> [Projectx](https://github.com/dijunkun/projectx) ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD>Ӧ<EFBFBD>á<EFBFBD>Projectx <20><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD>ƽ̨ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD><EFBFBD>⡣<EFBFBD><E2A1A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD><CDB8><EFBFBD><EFBFBD>[RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD>루H264<36><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD><EFBFBD>루[Opus](https://github.com/xiph/opus)<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EEBDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD>ƣ<EFBFBD>[TCP over UDP](https://libnice.freedesktop.org/)<29><><EFBFBD>Ȼ<EFBFBD><C8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+
+## ʹ<><CAB9>
+
+<EFBFBD>ڲ˵<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>REMOTE ID<49><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ID<49><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Connect<63><74><EFBFBD><EFBFBD><EFBFBD>ɷ<EFBFBD><C9B7><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>ӡ<EFBFBD>
+
+![usage1](https://github.com/dijunkun/continuous-desk/assets/29698109/80099485-f2db-4f09-9fb2-e811d87265dc)
+
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>룬<EFBFBD>򱾶<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><EFBFBD>ȷ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܳɹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӡ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD>״̬<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֡<EFBFBD>Incorrect password<72><64><EFBFBD>澯<EFBFBD><E6BEAF>ʾ<EFBFBD><CABE>
+
+![incorrect password](https://github.com/dijunkun/continuous-desk/assets/29698109/0b16d21a-baa6-49c1-9d87-5e80978dd345)
+
+<EFBFBD><EFBFBD><EFBFBD>ӳɹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD>ClientConnected<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+![success](https://github.com/dijunkun/continuous-desk/assets/29698109/9c4f6604-2b1b-47b6-9c73-21c5026d1f26)
+
+## <20><><EFBFBD><EFBFBD>
+
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+- [xmake](https://xmake.io/#/guide/installation)
+- [cmake](https://cmake.org/download/)
+- [vcpkg](https://vcpkg.io/en/getting-started)
+
+Linux<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>谲װ<EFBFBD><EFBFBD><EFBFBD>°<EFBFBD><EFBFBD><EFBFBD>
+
+```
+sudo apt-get install -y nvidia-cuda-toolkit libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev libxv-dev libasound2-dev libsndio-dev libasound2-dev libpulse-dev
+```
+
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+```
+git clone https://github.com/dijunkun/continuous-desk
+
+cd continuous-desk
+
+git submodule init 
+
+git submodule update
+
+xmake b remote_desk
+```
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+```
+# Windows/MacOS
+xmake r remote_desk
+
+# Linux<75><78><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9>rootȨ<74><C8A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+./remote_desk
+```
+
+## <20><><EFBFBD><EFBFBD>֤
+
+Continuous Desk ʹ<><CAB9> MIT <20><><EFBFBD><EFBFBD>֤<EFBFBD><D6A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD>õ<EFBFBD><C3B5>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֤<EFBFBD><D6A4><EFBFBD>зַ<D0B7><D6B7><EFBFBD>
--- a/icon/捕获.PNG
+++ b/icon/捕获.PNG
--- a/icon/捕获.ico
+++ b/icon/捕获.ico
--- a/src/common/platform.cpp
+++ b/src/common/platform.cpp
@@ -0,0 +1,101 @@
+#include "platform.h"
+
+#include "log.h"
+
+#ifdef _WIN32
+#include <Winsock2.h>
+#include <iphlpapi.h>
+#elif __APPLE__
+#include <ifaddrs.h>
+#include <net/if_dl.h>
+#include <net/if_types.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#elif __linux__
+#include <fcntl.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif
+
+std::string GetMac() {
+  char mac_addr[16];
+  int len = 0;
+#ifdef _WIN32
+  IP_ADAPTER_INFO adapterInfo[16];
+  DWORD bufferSize = sizeof(adapterInfo);
+
+  DWORD result = GetAdaptersInfo(adapterInfo, &bufferSize);
+  if (result == ERROR_SUCCESS) {
+    PIP_ADAPTER_INFO adapter = adapterInfo;
+    while (adapter) {
+      for (UINT i = 0; i < adapter->AddressLength; i++) {
+        len += sprintf(mac_addr + len, "%.2X", adapter->Address[i]);
+      }
+      break;
+    }
+  }
+#elif __APPLE__
+  std::string if_name = "en0";
+
+  struct ifaddrs *addrs;
+  struct ifaddrs *cursor;
+  const struct sockaddr_dl *dlAddr;
+
+  if (!getifaddrs(&addrs)) {
+    cursor = addrs;
+    while (cursor != 0) {
+      const struct sockaddr_dl *socAddr =
+          (const struct sockaddr_dl *)cursor->ifa_addr;
+      if ((cursor->ifa_addr->sa_family == AF_LINK) &&
+          (socAddr->sdl_type == IFT_ETHER) &&
+          strcmp(if_name.c_str(), cursor->ifa_name) == 0) {
+        dlAddr = (const struct sockaddr_dl *)cursor->ifa_addr;
+        const unsigned char *base =
+            (const unsigned char *)&dlAddr->sdl_data[dlAddr->sdl_nlen];
+        for (int i = 0; i < dlAddr->sdl_alen; i++) {
+          len += sprintf(mac_addr + len, "%.2X", base[i]);
+        }
+      }
+      cursor = cursor->ifa_next;
+    }
+    freeifaddrs(addrs);
+  }
+#elif __linux__
+  int sock = socket(AF_INET, SOCK_DGRAM, 0);
+  if (sock < 0) {
+    return "";
+  }
+  struct ifreq ifr;
+  struct ifconf ifc;
+  char buf[1024];
+  ifc.ifc_len = sizeof(buf);
+  ifc.ifc_buf = buf;
+  if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) {
+    close(sock);
+    return "";
+  }
+  struct ifreq *it = ifc.ifc_req;
+  const struct ifreq *const end = it + (ifc.ifc_len / sizeof(struct ifreq));
+  for (; it != end; ++it) {
+    std::strcpy(ifr.ifr_name, it->ifr_name);
+    if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
+      continue;
+    }
+    if (ifr.ifr_flags & IFF_LOOPBACK) {
+      continue;
+    }
+    if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0) {
+      continue;
+    }
+    std::string mac_address;
+    for (int i = 0; i < 6; ++i) {
+      len += sprintf(mac_addr + len, "%.2X", ifr.ifr_hwaddr.sa_data[i] & 0xff);
+    }
+    break;
+  }
+  close(sock);
+#endif
+  return mac_addr;
+}
--- a/src/common/platform.h
+++ b/src/common/platform.h
@@ -0,0 +1,14 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-18
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PLATFORM_H_
+#define _PLATFORM_H_
+
+#include <iostream>
+
+std::string GetMac();
+
+#endif
--- a/src/device_controller/device_controller.h
+++ b/src/device_controller/device_controller.h
@@ -0,0 +1,44 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-14
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DEVICE_CONTROLLER_H_
+#define _DEVICE_CONTROLLER_H_
+
+#include <stdio.h>
+
+typedef enum { mouse = 0, keyboard } ControlType;
+typedef enum { move = 0, left_down, left_up, right_down, right_up } MouseFlag;
+typedef enum { key_down = 0, key_up } KeyFlag;
+typedef struct {
+  size_t x;
+  size_t y;
+  MouseFlag flag;
+} Mouse;
+
+typedef struct {
+  size_t key_value;
+  KeyFlag flag;
+} Key;
+
+typedef struct {
+  ControlType type;
+  union {
+    Mouse m;
+    Key k;
+  };
+} RemoteAction;
+
+class DeviceController {
+ public:
+  virtual ~DeviceController() {}
+
+ public:
+  virtual int Init(int screen_width, int screen_height) = 0;
+  virtual int Destroy() = 0;
+  virtual int SendCommand(RemoteAction remote_action) = 0;
+};
+
+#endif
--- a/src/device_controller/device_controller_factory.h
+++ b/src/device_controller/device_controller_factory.h
@@ -0,0 +1,33 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-14
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DEVICE_CONTROLLER_FACTORY_H_
+#define _DEVICE_CONTROLLER_FACTORY_H_
+
+#include "device_controller.h"
+#include "mouse_controller.h"
+
+class DeviceControllerFactory {
+ public:
+  enum Device { Mouse = 0, Keyboard };
+
+ public:
+  virtual ~DeviceControllerFactory() {}
+
+ public:
+  DeviceController* Create(Device device) {
+    switch (device) {
+      case Mouse:
+        return new MouseController();
+      case Keyboard:
+        return nullptr;
+      default:
+        return nullptr;
+    }
+  }
+};
+
+#endif
--- a/src/device_controller/mouse/linux/mouse_controller.cpp
+++ b/src/device_controller/mouse/linux/mouse_controller.cpp
@@ -0,0 +1,122 @@
+#include "mouse_controller.h"
+
+#include "log.h"
+
+MouseController::MouseController() {}
+
+MouseController::~MouseController() {}
+
+int MouseController::Init(int screen_width, int screen_height) {
+  screen_width_ = screen_width;
+  screen_height_ = screen_height;
+
+  uinput_fd_ = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
+  if (uinput_fd_ < 0) {
+    LOG_ERROR("Cannot open device: /dev/uinput");
+  }
+
+  ioctl(uinput_fd_, UI_SET_EVBIT, EV_KEY);
+  ioctl(uinput_fd_, UI_SET_KEYBIT, BTN_RIGHT);
+  ioctl(uinput_fd_, UI_SET_KEYBIT, BTN_LEFT);
+  ioctl(uinput_fd_, UI_SET_EVBIT, EV_ABS);
+  ioctl(uinput_fd_, UI_SET_ABSBIT, ABS_X);
+  ioctl(uinput_fd_, UI_SET_ABSBIT, ABS_Y);
+  ioctl(uinput_fd_, UI_SET_EVBIT, EV_REL);
+
+  struct uinput_user_dev uidev;
+  memset(&uidev, 0, sizeof(uidev));
+  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "VirtualMouse");
+  uidev.id.bustype = BUS_USB;
+  uidev.id.version = 1;
+  uidev.id.vendor = 0x1;
+  uidev.id.product = 0x1;
+  uidev.absmin[ABS_X] = 0;
+  uidev.absmax[ABS_X] = screen_width_;
+  uidev.absmin[ABS_Y] = 0;
+  uidev.absmax[ABS_Y] = screen_height_;
+
+  write(uinput_fd_, &uidev, sizeof(uidev));
+  ioctl(uinput_fd_, UI_DEV_CREATE);
+  return 0;
+}
+
+int MouseController::Destroy() {
+  ioctl(uinput_fd_, UI_DEV_DESTROY);
+  close(uinput_fd_);
+}
+
+int MouseController::SendCommand(RemoteAction remote_action) {
+  int mouse_pos_x = remote_action.m.x * screen_width_ / 1280;
+  int mouse_pos_y = remote_action.m.y * screen_height_ / 720;
+
+  if (remote_action.type == ControlType::mouse) {
+    struct input_event event;
+    memset(&event, 0, sizeof(event));
+    gettimeofday(&event.time, NULL);
+
+    if (remote_action.m.flag == MouseFlag::left_down) {
+      SimulateKeyDown(uinput_fd_, BTN_LEFT);
+    } else if (remote_action.m.flag == MouseFlag::left_up) {
+      SimulateKeyUp(uinput_fd_, BTN_LEFT);
+    } else if (remote_action.m.flag == MouseFlag::right_down) {
+      SimulateKeyDown(uinput_fd_, BTN_RIGHT);
+    } else if (remote_action.m.flag == MouseFlag::right_up) {
+      SimulateKeyUp(uinput_fd_, BTN_RIGHT);
+    } else {
+      SetMousePosition(uinput_fd_, mouse_pos_x, mouse_pos_y);
+    }
+  }
+
+  return 0;
+}
+
+void MouseController::SimulateKeyDown(int fd, int kval) {
+  struct input_event event;
+  memset(&event, 0, sizeof(event));
+  gettimeofday(&event.time, 0);
+
+  event.type = EV_KEY;
+  event.value = 1;
+  event.code = kval;
+  write(fd, &event, sizeof(event));
+
+  event.type = EV_SYN;
+  event.value = 0;
+  event.code = SYN_REPORT;
+  write(fd, &event, sizeof(event));
+}
+
+void MouseController::SimulateKeyUp(int fd, int kval) {
+  struct input_event event;
+  memset(&event, 0, sizeof(event));
+  gettimeofday(&event.time, 0);
+
+  event.type = EV_KEY;
+  event.value = 0;
+  event.code = kval;
+  write(fd, &event, sizeof(event));
+
+  event.type = EV_SYN;
+  event.value = 0;
+  event.code = SYN_REPORT;
+  write(fd, &event, sizeof(event));
+}
+
+void MouseController::SetMousePosition(int fd, int x, int y) {
+  struct input_event ev[2], ev_sync;
+  memset(ev, 0, sizeof(ev));
+  memset(&ev_sync, 0, sizeof(ev_sync));
+
+  ev[0].type = EV_ABS;
+  ev[0].code = ABS_X;
+  ev[0].value = x;
+  ev[1].type = EV_ABS;
+  ev[1].code = ABS_Y;
+  ev[1].value = y;
+  int res_w = write(fd, ev, sizeof(ev));
+
+  ev_sync.type = EV_SYN;
+  ev_sync.value = 0;
+  ev_sync.code = 0;
+  int res_ev_sync = write(fd, &ev_sync, sizeof(ev_sync));
+}
--- a/src/device_controller/mouse/linux/mouse_controller.h
+++ b/src/device_controller/mouse/linux/mouse_controller.h
@@ -0,0 +1,41 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-14
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _MOUSE_CONTROLLER_H_
+#define _MOUSE_CONTROLLER_H_
+
+#include <fcntl.h>
+#include <linux/uinput.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "device_controller.h"
+
+class MouseController : public DeviceController {
+ public:
+  MouseController();
+  virtual ~MouseController();
+
+ public:
+  virtual int Init(int screen_width, int screen_height);
+  virtual int Destroy();
+  virtual int SendCommand(RemoteAction remote_action);
+
+ private:
+  void SimulateKeyDown(int fd, int kval);
+  void SimulateKeyUp(int fd, int kval);
+  void SetMousePosition(int fd, int x, int y);
+
+ private:
+  int uinput_fd_;
+  struct uinput_user_dev uinput_dev_;
+  int screen_width_ = 0;
+  int screen_height_ = 0;
+};
+
+#endif
--- a/src/device_controller/mouse/mac/mouse_controller.cpp
+++ b/src/device_controller/mouse/mac/mouse_controller.cpp
@@ -0,0 +1,49 @@
+#include "mouse_controller.h"
+
+#include <ApplicationServices/ApplicationServices.h>
+
+#include "log.h"
+
+MouseController::MouseController() {}
+
+MouseController::~MouseController() {}
+
+int MouseController::Init(int screen_width, int screen_height) {
+  screen_width_ = screen_width;
+  screen_height_ = screen_height;
+
+  return 0;
+}
+
+int MouseController::Destroy() { return 0; }
+
+int MouseController::SendCommand(RemoteAction remote_action) {
+  int mouse_pos_x = remote_action.m.x * screen_width_ / 1280;
+  int mouse_pos_y = remote_action.m.y * screen_height_ / 720;
+
+  if (remote_action.type == ControlType::mouse) {
+    CGEventRef mouse_event;
+    CGEventType mouse_type;
+
+    if (remote_action.m.flag == MouseFlag::left_down) {
+      mouse_type = kCGEventLeftMouseDown;
+    } else if (remote_action.m.flag == MouseFlag::left_up) {
+      mouse_type = kCGEventLeftMouseUp;
+    } else if (remote_action.m.flag == MouseFlag::right_down) {
+      mouse_type = kCGEventRightMouseDown;
+    } else if (remote_action.m.flag == MouseFlag::right_up) {
+      mouse_type = kCGEventRightMouseUp;
+    } else {
+      mouse_type = kCGEventMouseMoved;
+    }
+
+    mouse_event = CGEventCreateMouseEvent(NULL, mouse_type,
+                                          CGPointMake(mouse_pos_x, mouse_pos_y),
+                                          kCGMouseButtonLeft);
+
+    CGEventPost(kCGHIDEventTap, mouse_event);
+    CFRelease(mouse_event);
+  }
+
+  return 0;
+}
--- a/src/device_controller/mouse/mac/mouse_controller.h
+++ b/src/device_controller/mouse/mac/mouse_controller.h
@@ -0,0 +1,27 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-14
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _MOUSE_CONTROLLER_H_
+#define _MOUSE_CONTROLLER_H_
+
+#include "device_controller.h"
+
+class MouseController : public DeviceController {
+ public:
+  MouseController();
+  virtual ~MouseController();
+
+ public:
+  virtual int Init(int screen_width, int screen_height);
+  virtual int Destroy();
+  virtual int SendCommand(RemoteAction remote_action);
+
+ private:
+  int screen_width_ = 0;
+  int screen_height_ = 0;
+};
+
+#endif
--- a/src/device_controller/mouse/windows/mouse_controller.cpp
+++ b/src/device_controller/mouse/windows/mouse_controller.cpp
@@ -0,0 +1,47 @@
+#include "mouse_controller.h"
+
+#include "log.h"
+
+MouseController::MouseController() {}
+
+MouseController::~MouseController() {}
+
+int MouseController::Init(int screen_width, int screen_height) {
+  screen_width_ = screen_width;
+  screen_height_ = screen_height;
+
+  return 0;
+}
+
+int MouseController::Destroy() { return 0; }
+
+int MouseController::SendCommand(RemoteAction remote_action) {
+  INPUT ip;
+
+  if (remote_action.type == ControlType::mouse) {
+    ip.type = INPUT_MOUSE;
+    ip.mi.dx = remote_action.m.x * screen_width_ / 1280;
+    ip.mi.dy = remote_action.m.y * screen_height_ / 720;
+    if (remote_action.m.flag == MouseFlag::left_down) {
+      ip.mi.dwFlags = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE;
+    } else if (remote_action.m.flag == MouseFlag::left_up) {
+      ip.mi.dwFlags = MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE;
+    } else if (remote_action.m.flag == MouseFlag::right_down) {
+      ip.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;
+    } else if (remote_action.m.flag == MouseFlag::right_up) {
+      ip.mi.dwFlags = MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE;
+    } else {
+      ip.mi.dwFlags = MOUSEEVENTF_MOVE;
+    }
+    ip.mi.mouseData = 0;
+    ip.mi.time = 0;
+
+    SetCursorPos(ip.mi.dx, ip.mi.dy);
+
+    if (ip.mi.dwFlags != MOUSEEVENTF_MOVE) {
+      SendInput(1, &ip, sizeof(INPUT));
+    }
+  }
+
+  return 0;
+}
--- a/src/device_controller/mouse/windows/mouse_controller.h
+++ b/src/device_controller/mouse/windows/mouse_controller.h
@@ -0,0 +1,27 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-14
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _MOUSE_CONTROLLER_H_
+#define _MOUSE_CONTROLLER_H_
+
+#include "device_controller.h"
+
+class MouseController : public DeviceController {
+ public:
+  MouseController();
+  virtual ~MouseController();
+
+ public:
+  virtual int Init(int screen_width, int screen_height);
+  virtual int Destroy();
+  virtual int SendCommand(RemoteAction remote_action);
+
+ private:
+  int screen_width_ = 0;
+  int screen_height_ = 0;
+};
+
+#endif
--- a/src/gui/main.cpp
+++ b/src/gui/main.cpp
@@ -1,21 +1,11 @@
 #include <SDL.h>
 #include <stdio.h>
 #ifdef _WIN32
-// #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
+#ifdef REMOTE_DESK_DEBUG
 #pragma comment(linker, "/subsystem:\"console\"")
-#include <Winsock2.h>
-#include <iphlpapi.h>
-#elif __APPLE__
-#include <ifaddrs.h>
-#include <net/if_dl.h>
-#include <net/if_types.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#elif __linux__
-#include <net/if.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <unistd.h>
+#else
+#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
+#endif
 #endif

 #include <atomic>
@@ -26,31 +16,23 @@
 #include <string>
 #include <thread>

+#include "platform.h"
+
 extern "C" {
-#include <libavcodec/avcodec.h>
 #include <libavdevice/avdevice.h>
-#include <libavfilter/avfilter.h>
-#include <libavformat/avformat.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/imgutils.h>
-#include <libavutil/opt.h>
-#include <libavutil/samplefmt.h>
 #include <libswresample/swresample.h>
 #include <libswscale/swscale.h>
 };

 #include <stdio.h>

+#include "../../thirdparty/projectx/src/interface/x.h"
+#include "device_controller_factory.h"
 #include "imgui.h"
 #include "imgui_impl_sdl2.h"
 #include "imgui_impl_sdlrenderer2.h"
 #include "log.h"
-#ifdef _WIN32
-#include "screen_capture_wgc.h"
-#elif __linux__
-#include "screen_capture_x11.h"
-#endif
-#include "../../thirdparty/projectx/src/interface/x.h"
+#include "screen_capturer_factory.h"

 #define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2

@@ -77,58 +59,45 @@ uint32_t start_time, end_time, elapsed_time;
 uint32_t frame_count = 0;
 int fps = 0;

-#if 1
-static Uint8 *buffer = 0;
-static int in_pos = 0;
-static int out_pos = 0;
 static std::atomic<bool> audio_buffer_fresh = false;
 static uint32_t last_ts = 0;

-char *out = "audio_old.pcm";
-// FILE *outfile = fopen(out, "wb+");
-
 int64_t src_ch_layout = AV_CH_LAYOUT_MONO;
 int src_rate = 48000;
 enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_S16;
 int src_nb_channels = 0;
-uint8_t **src_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
+uint8_t **src_data = NULL;
 int src_linesize;
 int src_nb_samples = 480;

-// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 int64_t dst_ch_layout = AV_CH_LAYOUT_MONO;
 int dst_rate = 48000;
 enum AVSampleFormat dst_sample_fmt = AV_SAMPLE_FMT_S16;
 int dst_nb_channels = 0;
-uint8_t **dst_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
+uint8_t **dst_data = NULL;
 int dst_linesize;
 int dst_nb_samples;
 int max_dst_nb_samples;

-// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
-const char *dst_filename = NULL;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>pcm<63><6D><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>Ȼ<EFBFBD>󲥷<EFBFBD><F3B2A5B7><EFBFBD>֤
-FILE *dst_file;
-
 int dst_bufsize;
-
-// <20>ز<EFBFBD><D8B2><EFBFBD>ʵ<EFBFBD><CAB5>
 struct SwrContext *swr_ctx;

-double t;
 int ret;
-#endif

 int audio_len = 0;
-#define MAX_FRAME_SIZE 6 * 960
-#define CHANNELS 2
-unsigned char pcm_bytes[MAX_FRAME_SIZE * CHANNELS * 2];

 std::string window_title = "Remote Desk Client";
+std::string server_connection_status_str = "-";
+std::string client_connection_status_str = "-";
+std::string server_signal_status_str = "-";
+std::string client_signal_status_str = "-";

-std::string server_connection_status = "-";
-std::string client_connection_status = "-";
-std::string server_signal_status = "-";
-std::string client_signal_status = "-";
+std::atomic<ConnectionStatus> server_connection_status =
+    ConnectionStatus::Closed;
+std::atomic<ConnectionStatus> client_connection_status =
+    ConnectionStatus::Closed;
+std::atomic<SignalStatus> server_signal_status = SignalStatus::SignalClosed;
+std::atomic<SignalStatus> client_signal_status = SignalStatus::SignalClosed;

 // Refresh Event
 #define REFRESH_EVENT (SDL_USEREVENT + 1)
@@ -143,21 +112,22 @@ PeerPtr *peer_server = nullptr;
 PeerPtr *peer_client = nullptr;
 bool joined = false;
 bool received_frame = false;
+bool menu_hovered = false;

 static bool connect_button_pressed = false;
 static const char *connect_label = "Connect";
 static char input_password[7] = "";
 static FILE *cd_cache_file = nullptr;
 static CDCache cd_cache;
-static char mac_addr[16];
+
 static bool is_create_connection = false;
 static bool done = false;

-#ifdef _WIN32
-ScreenCaptureWgc *screen_capture = nullptr;
-#elif __linux__
-ScreenCaptureX11 *screen_capture = nullptr;
-#endif
+ScreenCapturerFactory *screen_capturer_factory = nullptr;
+ScreenCapturer *screen_capturer = nullptr;
+
+DeviceControllerFactory *device_controller_factory = nullptr;
+MouseController *mouse_controller = nullptr;

 char *nv12_buffer = nullptr;

@@ -167,32 +137,12 @@ std::chrono::_V2::system_clock::time_point last_frame_time_;
 std::chrono::steady_clock::time_point last_frame_time_;
 #endif

-typedef enum { mouse = 0, keyboard } ControlType;
-typedef enum { move = 0, left_down, left_up, right_down, right_up } MouseFlag;
-typedef enum { key_down = 0, key_up } KeyFlag;
-typedef struct {
-  size_t x;
-  size_t y;
-  MouseFlag flag;
-} Mouse;
-
-typedef struct {
-  size_t key_value;
-  KeyFlag flag;
-} Key;
-
-typedef struct {
-  ControlType type;
-  union {
-    Mouse m;
-    Key k;
-  };
-} RemoteAction;
-
 inline int ProcessMouseKeyEven(SDL_Event &ev) {
-  float ratio = 1280.0 / window_w;
+  float ratio = (float)(1280.0 / window_w);

  RemoteAction remote_action;
+  remote_action.m.x = (size_t)(ev.button.x * ratio);
+  remote_action.m.y = (size_t)(ev.button.y * ratio);

  if (SDL_KEYDOWN == ev.type)  // SDL_KEYUP
  {
@@ -210,70 +160,26 @@ inline int ProcessMouseKeyEven(SDL_Event &ev) {
      // printf("SDLK_RIGHT  \n");
    }
  } else if (SDL_MOUSEBUTTONDOWN == ev.type) {
+    remote_action.type = ControlType::mouse;
    if (SDL_BUTTON_LEFT == ev.button.button) {
-      int px = ev.button.x;
-      int py = ev.button.y;
-      // printf("SDL_MOUSEBUTTONDOWN x, y %d %d  \n", px, py);
-
-      remote_action.type = ControlType::mouse;
      remote_action.m.flag = MouseFlag::left_down;
-      remote_action.m.x = ev.button.x * ratio;
-      remote_action.m.y = ev.button.y * ratio;
-
-      SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
-               sizeof(remote_action));
-
    } else if (SDL_BUTTON_RIGHT == ev.button.button) {
-      int px = ev.button.x;
-      int py = ev.button.y;
-      // printf("SDL_BUTTON_RIGHT x, y %d %d  \n", px, py);
-
-      remote_action.type = ControlType::mouse;
      remote_action.m.flag = MouseFlag::right_down;
-      remote_action.m.x = ev.button.x * ratio;
-      remote_action.m.y = ev.button.y * ratio;
-
-      SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
-               sizeof(remote_action));
    }
+    SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
+             sizeof(remote_action));
  } else if (SDL_MOUSEBUTTONUP == ev.type) {
+    remote_action.type = ControlType::mouse;
    if (SDL_BUTTON_LEFT == ev.button.button) {
-      int px = ev.button.x;
-      int py = ev.button.y;
-      // printf("SDL_MOUSEBUTTONUP x, y %d %d  \n", px, py);
-
-      remote_action.type = ControlType::mouse;
      remote_action.m.flag = MouseFlag::left_up;
-      remote_action.m.x = ev.button.x * ratio;
-      remote_action.m.y = ev.button.y * ratio;
-
-      SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
-               sizeof(remote_action));
-
    } else if (SDL_BUTTON_RIGHT == ev.button.button) {
-      int px = ev.button.x;
-      int py = ev.button.y;
-      // printf("SDL_MOUSEBUTTONUP x, y %d %d  \n", px, py);
-
-      remote_action.type = ControlType::mouse;
      remote_action.m.flag = MouseFlag::right_up;
-      remote_action.m.x = ev.button.x * ratio;
-      remote_action.m.y = ev.button.y * ratio;
-
-      SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
-               sizeof(remote_action));
    }
+    SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
+             sizeof(remote_action));
  } else if (SDL_MOUSEMOTION == ev.type) {
-    int px = ev.motion.x;
-    int py = ev.motion.y;
-
-    // printf("SDL_MOUSEMOTION x, y %d %d  \n", px, py);
-
    remote_action.type = ControlType::mouse;
    remote_action.m.flag = MouseFlag::move;
-    remote_action.m.x = ev.button.x * ratio;
-    remote_action.m.y = ev.button.y * ratio;
-
    SendData(peer_client, DATA_TYPE::DATA, (const char *)&remote_action,
             sizeof(remote_action));
  } else if (SDL_QUIT == ev.type) {
@@ -289,8 +195,8 @@ inline int ProcessMouseKeyEven(SDL_Event &ev) {

 void SdlCaptureAudioIn(void *userdata, Uint8 *stream, int len) {
  int64_t delay = swr_get_delay(swr_ctx, src_rate);
-  dst_nb_samples =
-      av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
+  dst_nb_samples = (int)av_rescale_rnd(delay + src_nb_samples, dst_rate,
+                                       src_rate, AV_ROUND_UP);
  if (dst_nb_samples > max_dst_nb_samples) {
    av_freep(&dst_data[0]);
    ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
@@ -313,12 +219,12 @@ void SdlCaptureAudioIn(void *userdata, Uint8 *stream, int len) {
  }

  if (1) {
-    if ("ClientConnected" == client_connection_status) {
+    if ("ClientConnected" == client_connection_status_str) {
      SendData(peer_client, DATA_TYPE::AUDIO, (const char *)dst_data[0],
               dst_bufsize);
    }

-    if ("ServerConnected" == server_connection_status) {
+    if ("ServerConnected" == server_connection_status_str) {
      SendData(peer_server, DATA_TYPE::AUDIO, (const char *)dst_data[0],
               dst_bufsize);
    }
@@ -331,7 +237,7 @@ void SdlCaptureAudioIn(void *userdata, Uint8 *stream, int len) {
 }

 void SdlCaptureAudioOut(void *userdata, Uint8 *stream, int len) {
-  // if ("ClientConnected" != client_connection_status) {
+  // if ("ClientConnected" != client_connection_status_str) {
  //   return;
  // }

@@ -375,7 +281,7 @@ void ServerReceiveAudioBuffer(const char *data, size_t size,
  // audio_len = size;
  audio_buffer_fresh = true;

-  SDL_QueueAudio(output_dev, data, size);
+  SDL_QueueAudio(output_dev, data, (Uint32)size);
  // printf("queue audio\n");
 }

@@ -383,7 +289,7 @@ void ClientReceiveAudioBuffer(const char *data, size_t size,
                              const char *user_id, size_t user_id_size) {
  // std::cout << "Client receive audio, size " << size << ", user [" << user_id
  //           << "] " << std::endl;
-  SDL_QueueAudio(output_dev, data, size);
+  SDL_QueueAudio(output_dev, data, (Uint32)size);
 }

 void ServerReceiveDataBuffer(const char *data, size_t size, const char *user_id,
@@ -396,129 +302,58 @@ void ServerReceiveDataBuffer(const char *data, size_t size, const char *user_id,
  // std::cout << "remote_action: " << remote_action.type << " "
  //           << remote_action.m.flag << " " << remote_action.m.x << " "
  //           << remote_action.m.y << std::endl;
-#ifdef _WIN32
-  INPUT ip;
-
-  if (remote_action.type == ControlType::mouse) {
-    ip.type = INPUT_MOUSE;
-    ip.mi.dx = remote_action.m.x * screen_w / 1280;
-    ip.mi.dy = remote_action.m.y * screen_h / 720;
-    if (remote_action.m.flag == MouseFlag::left_down) {
-      ip.mi.dwFlags = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::left_up) {
-      ip.mi.dwFlags = MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::right_down) {
-      ip.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::right_up) {
-      ip.mi.dwFlags = MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE;
-    } else {
-      ip.mi.dwFlags = MOUSEEVENTF_MOVE;
-    }
-    ip.mi.mouseData = 0;
-    ip.mi.time = 0;
-
 #if MOUSE_CONTROL
-    // Set cursor pos
-    SetCursorPos(ip.mi.dx, ip.mi.dy);
-    // Send the press
-    if (ip.mi.dwFlags != MOUSEEVENTF_MOVE) {
-      SendInput(1, &ip, sizeof(INPUT));
-    }
-#endif
-    // std::cout << "Receive data from [" << user << "], " << ip.type << " "
-    //           << ip.mi.dwFlags << " " << ip.mi.dx << " " << ip.mi.dy
-    //           << std::endl;
-  }
+  mouse_controller->SendCommand(remote_action);
 #endif
 }

 void ClientReceiveDataBuffer(const char *data, size_t size, const char *user_id,
-                             size_t user_id_size) {
-  std::string user(user_id, user_id_size);
-
-  RemoteAction remote_action;
-  memcpy(&remote_action, data, sizeof(remote_action));
-
-  // std::cout << "remote_action: " << remote_action.type << " "
-  //           << remote_action.m.flag << " " << remote_action.m.x << " "
-  //           << remote_action.m.y << std::endl;
-#ifdef _WIN32
-  INPUT ip;
-
-  if (remote_action.type == ControlType::mouse) {
-    ip.type = INPUT_MOUSE;
-    ip.mi.dx = remote_action.m.x * screen_w / 1280;
-    ip.mi.dy = remote_action.m.y * screen_h / 720;
-    if (remote_action.m.flag == MouseFlag::left_down) {
-      ip.mi.dwFlags = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::left_up) {
-      ip.mi.dwFlags = MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::right_down) {
-      ip.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::right_up) {
-      ip.mi.dwFlags = MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE;
-    } else {
-      ip.mi.dwFlags = MOUSEEVENTF_MOVE;
-    }
-    ip.mi.mouseData = 0;
-    ip.mi.time = 0;
-
-#if MOUSE_CONTROL
-    // Set cursor pos
-    SetCursorPos(ip.mi.dx, ip.mi.dy);
-    // Send the press
-    if (ip.mi.dwFlags != MOUSEEVENTF_MOVE) {
-      SendInput(1, &ip, sizeof(INPUT));
-    }
-#endif
-    // std::cout << "Receive data from [" << user << "], " << ip.type << " "
-    //           << ip.mi.dwFlags << " " << ip.mi.dx << " " << ip.mi.dy
-    //           << std::endl;
-  }
-#endif
-}
+                             size_t user_id_size) {}

 void ServerSignalStatus(SignalStatus status) {
+  server_signal_status = status;
  if (SignalStatus::SignalConnecting == status) {
-    server_signal_status = "ServerSignalConnecting";
+    server_signal_status_str = "ServerSignalConnecting";
  } else if (SignalStatus::SignalConnected == status) {
-    server_signal_status = "ServerSignalConnected";
+    server_signal_status_str = "ServerSignalConnected";
  } else if (SignalStatus::SignalFailed == status) {
-    server_signal_status = "ServerSignalFailed";
+    server_signal_status_str = "ServerSignalFailed";
  } else if (SignalStatus::SignalClosed == status) {
-    server_signal_status = "ServerSignalClosed";
+    server_signal_status_str = "ServerSignalClosed";
  } else if (SignalStatus::SignalReconnecting == status) {
-    server_signal_status = "ServerSignalReconnecting";
+    server_signal_status_str = "ServerSignalReconnecting";
  }
 }

 void ClientSignalStatus(SignalStatus status) {
+  client_signal_status = status;
  if (SignalStatus::SignalConnecting == status) {
-    client_signal_status = "ClientSignalConnecting";
+    client_signal_status_str = "ClientSignalConnecting";
  } else if (SignalStatus::SignalConnected == status) {
-    client_signal_status = "ClientSignalConnected";
+    client_signal_status_str = "ClientSignalConnected";
  } else if (SignalStatus::SignalFailed == status) {
-    client_signal_status = "ClientSignalFailed";
+    client_signal_status_str = "ClientSignalFailed";
  } else if (SignalStatus::SignalClosed == status) {
-    client_signal_status = "ClientSignalClosed";
+    client_signal_status_str = "ClientSignalClosed";
  } else if (SignalStatus::SignalReconnecting == status) {
-    client_signal_status = "ClientSignalReconnecting";
+    client_signal_status_str = "ClientSignalReconnecting";
  }
 }

 void ServerConnectionStatus(ConnectionStatus status) {
+  server_connection_status = status;
  if (ConnectionStatus::Connecting == status) {
-    server_connection_status = "ServerConnecting";
+    server_connection_status_str = "ServerConnecting";
  } else if (ConnectionStatus::Connected == status) {
-    server_connection_status = "ServerConnected";
+    server_connection_status_str = "ServerConnected";
  } else if (ConnectionStatus::Disconnected == status) {
-    server_connection_status = "ServerDisconnected";
+    server_connection_status_str = "ServerDisconnected";
  } else if (ConnectionStatus::Failed == status) {
-    server_connection_status = "ServerFailed";
+    server_connection_status_str = "ServerFailed";
  } else if (ConnectionStatus::Closed == status) {
-    server_connection_status = "ServerClosed";
+    server_connection_status_str = "ServerClosed";
  } else if (ConnectionStatus::IncorrectPassword == status) {
-    server_connection_status = "Incorrect password";
+    server_connection_status_str = "Incorrect password";
    if (connect_button_pressed) {
      connect_button_pressed = false;
      joined = false;
@@ -528,18 +363,27 @@ void ServerConnectionStatus(ConnectionStatus status) {
 }

 void ClientConnectionStatus(ConnectionStatus status) {
+  client_connection_status = status;
  if (ConnectionStatus::Connecting == status) {
-    client_connection_status = "ClientConnecting";
+    client_connection_status_str = "ClientConnecting";
  } else if (ConnectionStatus::Connected == status) {
-    client_connection_status = "ClientConnected";
+    client_connection_status_str = "ClientConnected";
+    joined = true;
  } else if (ConnectionStatus::Disconnected == status) {
-    client_connection_status = "ClientDisconnected";
+    client_connection_status_str = "ClientDisconnected";
  } else if (ConnectionStatus::Failed == status) {
-    client_connection_status = "ClientFailed";
+    client_connection_status_str = "ClientFailed";
  } else if (ConnectionStatus::Closed == status) {
-    client_connection_status = "ClientClosed";
+    client_connection_status_str = "ClientClosed";
  } else if (ConnectionStatus::IncorrectPassword == status) {
-    client_connection_status = "Incorrect password";
+    client_connection_status_str = "Incorrect password";
+    if (connect_button_pressed) {
+      connect_button_pressed = false;
+      joined = false;
+      connect_label = connect_button_pressed ? "Disconnect" : "Connect";
+    }
+  } else if (ConnectionStatus::NoSuchTransmissionId == status) {
+    client_connection_status_str = "No such transmission id";
    if (connect_button_pressed) {
      connect_button_pressed = false;
      joined = false;
@@ -549,15 +393,6 @@ void ClientConnectionStatus(ConnectionStatus status) {
 }

 int initResampler() {
-  // dst_filename = "res.pcm";
-
-  // dst_file = fopen(dst_filename, "wb");
-  // if (!dst_file) {
-  //   fprintf(stderr, "Could not open destination file %s\n", dst_filename);
-  //   exit(1);
-  // }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>
  /* create resampler context */
  swr_ctx = swr_alloc();
  if (!swr_ctx) {
@@ -566,18 +401,15 @@ int initResampler() {
    return -1;
  }

-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
  /* set options */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
  av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0);
  av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
  av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
  av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0);
  av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
  av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);

-  // <20><>ʼ<EFBFBD><CABC><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>
  /* initialize the resampling context */
  if ((ret = swr_init(swr_ctx)) < 0) {
    fprintf(stderr, "Failed to initialize the resampling context\n");
@@ -585,9 +417,8 @@ int initResampler() {
  }

  /* allocate source and destination samples buffers */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
  src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
+
  ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize,
                                           src_nb_channels, src_nb_samples,
                                           src_sample_fmt, 0);
@@ -596,13 +427,12 @@ int initResampler() {
    return -1;
  }

-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
  max_dst_nb_samples = dst_nb_samples =
      av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

  /* buffer is going to be directly written to a rawaudio file, no alignment */
  dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
+
  ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize,
                                           dst_nb_channels, dst_nb_samples,
                                           dst_sample_fmt, 0);
@@ -612,110 +442,6 @@ int initResampler() {
  }
 }

-std::string GetMac(char *mac_addr) {
-  int len = 0;
-#ifdef _WIN32
-  IP_ADAPTER_INFO adapterInfo[16];
-  DWORD bufferSize = sizeof(adapterInfo);
-
-  DWORD result = GetAdaptersInfo(adapterInfo, &bufferSize);
-  if (result == ERROR_SUCCESS) {
-    PIP_ADAPTER_INFO adapter = adapterInfo;
-    while (adapter) {
-      for (UINT i = 0; i < adapter->AddressLength; i++) {
-        len += sprintf(mac_addr + len, "%.2X", adapter->Address[i]);
-      }
-      break;
-    }
-  }
-#elif __APPLE__
-  std::string if_name = "en0";
-
-  struct ifaddrs *addrs;
-  struct ifaddrs *cursor;
-  const struct sockaddr_dl *dlAddr;
-
-  if (!getifaddrs(&addrs)) {
-    cursor = addrs;
-    while (cursor != 0) {
-      const struct sockaddr_dl *socAddr =
-          (const struct sockaddr_dl *)cursor->ifa_addr;
-      if ((cursor->ifa_addr->sa_family == AF_LINK) &&
-          (socAddr->sdl_type == IFT_ETHER) &&
-          strcmp(if_name.c_str(), cursor->ifa_name) == 0) {
-        dlAddr = (const struct sockaddr_dl *)cursor->ifa_addr;
-        const unsigned char *base =
-            (const unsigned char *)&dlAddr->sdl_data[dlAddr->sdl_nlen];
-        for (int i = 0; i < dlAddr->sdl_alen; i++) {
-          len += sprintf(mac_addr + len, "%.2X", base[i]);
-        }
-      }
-      cursor = cursor->ifa_next;
-    }
-    freeifaddrs(addrs);
-  }
-#elif __linux__
-  int sock = socket(AF_INET, SOCK_DGRAM, 0);
-  if (sock < 0) {
-    return "";
-  }
-  struct ifreq ifr;
-  struct ifconf ifc;
-  char buf[1024];
-  ifc.ifc_len = sizeof(buf);
-  ifc.ifc_buf = buf;
-  if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) {
-    close(sock);
-    return "";
-  }
-  struct ifreq *it = ifc.ifc_req;
-  const struct ifreq *const end = it + (ifc.ifc_len / sizeof(struct ifreq));
-  for (; it != end; ++it) {
-    std::strcpy(ifr.ifr_name, it->ifr_name);
-    if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
-      continue;
-    }
-    if (ifr.ifr_flags & IFF_LOOPBACK) {
-      continue;
-    }
-    if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0) {
-      continue;
-    }
-    std::string mac_address;
-    for (int i = 0; i < 6; ++i) {
-      len += sprintf(mac_addr + len, "%.2X", ifr.ifr_hwaddr.sa_data[i] & 0xff);
-    }
-    break;
-  }
-  close(sock);
-#endif
-  return mac_addr;
-}
-
-int BGRAToNV12FFmpeg(unsigned char *src_buffer, int width, int height,
-                     unsigned char *dst_buffer) {
-  AVFrame *Input_pFrame = av_frame_alloc();
-  AVFrame *Output_pFrame = av_frame_alloc();
-  struct SwsContext *img_convert_ctx =
-      sws_getContext(width, height, AV_PIX_FMT_BGRA, 1280, 720, AV_PIX_FMT_NV12,
-                     SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
-
-  av_image_fill_arrays(Input_pFrame->data, Input_pFrame->linesize, src_buffer,
-                       AV_PIX_FMT_BGRA, width, height, 1);
-  av_image_fill_arrays(Output_pFrame->data, Output_pFrame->linesize, dst_buffer,
-                       AV_PIX_FMT_NV12, 1280, 720, 1);
-
-  sws_scale(img_convert_ctx, (uint8_t const **)Input_pFrame->data,
-            Input_pFrame->linesize, 0, height, Output_pFrame->data,
-            Output_pFrame->linesize);
-
-  if (Input_pFrame) av_free(Input_pFrame);
-  if (Output_pFrame) av_free(Output_pFrame);
-  if (img_convert_ctx) sws_freeContext(img_convert_ctx);
-
-  return 0;
-}
-
 int main() {
  LOG_INFO("Remote desk");

@@ -734,116 +460,6 @@ int main() {
    strncpy(input_password, cd_cache.password, sizeof(cd_cache.password));
  }

-  std::thread rtc_thread([] {
-    std::string default_cfg_path = "../../../../config/config.ini";
-    std::ifstream f(default_cfg_path.c_str());
-
-    Params server_params;
-    server_params.cfg_path =
-        f.good() ? "../../../../config/config.ini" : "config.ini";
-    server_params.on_receive_video_buffer = ServerReceiveVideoBuffer;
-    server_params.on_receive_audio_buffer = ServerReceiveAudioBuffer;
-    server_params.on_receive_data_buffer = ServerReceiveDataBuffer;
-    server_params.on_signal_status = ServerSignalStatus;
-    server_params.on_connection_status = ServerConnectionStatus;
-
-    Params client_params;
-    client_params.cfg_path =
-        f.good() ? "../../../../config/config.ini" : "config.ini";
-    client_params.on_receive_video_buffer = ClientReceiveVideoBuffer;
-    client_params.on_receive_audio_buffer = ClientReceiveAudioBuffer;
-    client_params.on_receive_data_buffer = ClientReceiveDataBuffer;
-    client_params.on_signal_status = ClientSignalStatus;
-    client_params.on_connection_status = ClientConnectionStatus;
-
-    std::string transmission_id = "000001";
-    GetMac(mac_addr);
-
-    peer_server = CreatePeer(&server_params);
-    LOG_INFO("Create peer_server");
-    std::string server_user_id = "S-" + std::string(GetMac(mac_addr));
-    Init(peer_server, server_user_id.c_str());
-    LOG_INFO("peer_server init finish");
-
-    peer_client = CreatePeer(&client_params);
-    LOG_INFO("Create peer_client");
-    std::string client_user_id = "C-" + std::string(GetMac(mac_addr));
-    Init(peer_client, client_user_id.c_str());
-    LOG_INFO("peer_client init finish");
-
-    {
-      while ("ServerSignalConnected" != server_signal_status && !done) {
-      }
-
-      if (done) {
-        return;
-      }
-
-      std::string user_id = "S-" + std::string(GetMac(mac_addr));
-      is_create_connection =
-          CreateConnection(peer_server, mac_addr, input_password) ? false
-                                                                  : true;
-
-      nv12_buffer = new char[NV12_BUFFER_SIZE];
-#ifdef _WIN32
-      screen_capture = new ScreenCaptureWgc();
-
-      RECORD_DESKTOP_RECT rect;
-      rect.left = 0;
-      rect.top = 0;
-      rect.right = GetSystemMetrics(SM_CXSCREEN);
-      rect.bottom = GetSystemMetrics(SM_CYSCREEN);
-
-      last_frame_time_ = std::chrono::high_resolution_clock::now();
-      screen_capture->Init(
-          rect, 60,
-          [](unsigned char *data, int size, int width, int height) -> void {
-            auto now_time = std::chrono::high_resolution_clock::now();
-            std::chrono::duration<double> duration =
-                now_time - last_frame_time_;
-            auto tc = duration.count() * 1000;
-
-            if (tc >= 0) {
-              BGRAToNV12FFmpeg(data, width, height,
-                               (unsigned char *)nv12_buffer);
-              SendData(peer_server, DATA_TYPE::VIDEO, (const char *)nv12_buffer,
-                       NV12_BUFFER_SIZE);
-              // std::cout << "Send" << std::endl;
-              last_frame_time_ = now_time;
-            }
-          });
-
-      screen_capture->Start();
-
-#elif __linux__
-      screen_capture = new ScreenCaptureX11();
-
-      RECORD_DESKTOP_RECT rect;
-      rect.left = 0;
-      rect.top = 0;
-      rect.right = 0;
-      rect.bottom = 0;
-
-      last_frame_time_ = std::chrono::high_resolution_clock::now();
-      screen_capture->Init(
-          rect, 60,
-          [](unsigned char *data, int size, int width, int height) -> void {
-            auto now_time = std::chrono::high_resolution_clock::now();
-            std::chrono::duration<double> duration =
-                now_time - last_frame_time_;
-            auto tc = duration.count() * 1000;
-
-            if (tc >= 0) {
-              SendData(peer_server, DATA_TYPE::VIDEO, (const char *)data,
-                       NV12_BUFFER_SIZE);
-              last_frame_time_ = now_time;
-            }
-          });
-      screen_capture->Start();
-#endif
-    }
-  });
-
  // Setup SDL
  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER |
               SDL_INIT_GAMECONTROLLER) != 0) {
@@ -936,6 +552,104 @@ int main() {
  bool show_another_window = false;
  ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

+  std::string mac_addr_str = GetMac();
+
+  std::thread rtc_thread(
+      [](int screen_width, int screen_height) {
+        std::string default_cfg_path = "../../../../config/config.ini";
+        std::ifstream f(default_cfg_path.c_str());
+
+        std::string mac_addr_str = GetMac();
+
+        Params server_params;
+        server_params.cfg_path =
+            f.good() ? "../../../../config/config.ini" : "config.ini";
+        server_params.on_receive_video_buffer = ServerReceiveVideoBuffer;
+        server_params.on_receive_audio_buffer = ServerReceiveAudioBuffer;
+        server_params.on_receive_data_buffer = ServerReceiveDataBuffer;
+        server_params.on_signal_status = ServerSignalStatus;
+        server_params.on_connection_status = ServerConnectionStatus;
+
+        Params client_params;
+        client_params.cfg_path =
+            f.good() ? "../../../../config/config.ini" : "config.ini";
+        client_params.on_receive_video_buffer = ClientReceiveVideoBuffer;
+        client_params.on_receive_audio_buffer = ClientReceiveAudioBuffer;
+        client_params.on_receive_data_buffer = ClientReceiveDataBuffer;
+        client_params.on_signal_status = ClientSignalStatus;
+        client_params.on_connection_status = ClientConnectionStatus;
+
+        std::string transmission_id = "000001";
+
+        peer_server = CreatePeer(&server_params);
+        LOG_INFO("Create peer_server");
+        std::string server_user_id = "S-" + mac_addr_str;
+        Init(peer_server, server_user_id.c_str());
+        LOG_INFO("peer_server init finish");
+
+        peer_client = CreatePeer(&client_params);
+        LOG_INFO("Create peer_client");
+        std::string client_user_id = "C-" + mac_addr_str;
+        Init(peer_client, client_user_id.c_str());
+        LOG_INFO("peer_client init finish");
+
+        {
+          while (SignalStatus::SignalConnected != server_signal_status &&
+                 !done) {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+          }
+
+          if (done) {
+            return;
+          }
+
+          std::string user_id = "S-" + mac_addr_str;
+          is_create_connection =
+              CreateConnection(peer_server, mac_addr_str.c_str(),
+                               input_password)
+                  ? false
+                  : true;
+
+          nv12_buffer = new char[NV12_BUFFER_SIZE];
+
+          // Screen capture
+          screen_capturer_factory = new ScreenCapturerFactory();
+          screen_capturer = (ScreenCapturer *)screen_capturer_factory->Create();
+
+          last_frame_time_ = std::chrono::high_resolution_clock::now();
+          ScreenCapturer::RECORD_DESKTOP_RECT rect;
+          rect.left = 0;
+          rect.top = 0;
+          rect.right = screen_w;
+          rect.bottom = screen_h;
+
+          screen_capturer->Init(
+              rect, 60,
+              [](unsigned char *data, int size, int width, int height) -> void {
+                auto now_time = std::chrono::high_resolution_clock::now();
+                std::chrono::duration<double> duration =
+                    now_time - last_frame_time_;
+                auto tc = duration.count() * 1000;
+
+                if (tc >= 0) {
+                  SendData(peer_server, DATA_TYPE::VIDEO, (const char *)data,
+                           NV12_BUFFER_SIZE);
+                  last_frame_time_ = now_time;
+                }
+              });
+
+          screen_capturer->Start();
+
+          // Mouse control
+          device_controller_factory = new DeviceControllerFactory();
+          mouse_controller =
+              (MouseController *)device_controller_factory->Create(
+                  DeviceControllerFactory::Device::Mouse);
+          mouse_controller->Init(screen_w, screen_h);
+        }
+      },
+      screen_w, screen_h);
+
  // Main loop
  while (!done) {
    // Start the Dear ImGui frame
@@ -943,6 +657,10 @@ int main() {
    ImGui_ImplSDL2_NewFrame();
    ImGui::NewFrame();

+    if (joined && !menu_hovered) {
+      ImGui::SetMouseCursor(ImGuiMouseCursor_None);
+    }
+
    {
      static float f = 0.0f;
      static int counter = 0;
@@ -954,11 +672,14 @@ int main() {
      ImGui::Begin("Menu", nullptr, ImGuiWindowFlags_NoResize);

      {
+        menu_hovered = ImGui::IsWindowHovered();
        ImGui::Text(" LOCAL ID:");
        ImGui::SameLine();
        ImGui::SetNextItemWidth(95);
-        ImGui::InputText("##local_id", mac_addr, IM_ARRAYSIZE(mac_addr),
-                         ImGuiInputTextFlags_CharsUppercase);
+        ImGui::InputText(
+            "##local_id", (char *)mac_addr_str.c_str(),
+            mac_addr_str.length() + 1,
+            ImGuiInputTextFlags_CharsUppercase | ImGuiInputTextFlags_ReadOnly);

        ImGui::Text(" PASSWORD:");
        ImGui::SameLine();
@@ -980,7 +701,7 @@ int main() {
            fclose(cd_cache_file);
          }
          LeaveConnection(peer_server);
-          CreateConnection(peer_server, mac_addr, input_password);
+          CreateConnection(peer_server, mac_addr_str.c_str(), input_password);
        }

        ImGui::Spacing();
@@ -991,15 +712,13 @@ int main() {
        {
          {
            static char remote_id[20] = "";
-            if (strcmp(remote_id, "") == 0) {
-              strcpy(remote_id, GetMac(mac_addr).c_str());
-            }
            ImGui::Text("REMOTE ID:");
            ImGui::SameLine();
            ImGui::SetNextItemWidth(95);
-            ImGui::InputTextWithHint("##remote_id", mac_addr, remote_id,
-                                     IM_ARRAYSIZE(remote_id),
-                                     ImGuiInputTextFlags_AllowTabInput);
+            ImGui::InputTextWithHint("##remote_id", mac_addr_str.c_str(),
+                                     remote_id, IM_ARRAYSIZE(remote_id),
+                                     ImGuiInputTextFlags_CharsUppercase |
+                                         ImGuiInputTextFlags_CharsNoBlank);

            ImGui::Spacing();

@@ -1014,12 +733,12 @@ int main() {

            if (ImGui::Button(connect_label)) {
              int ret = -1;
-              if ("ClientSignalConnected" == client_signal_status) {
+              if ("ClientSignalConnected" == client_signal_status_str) {
                if (strcmp(connect_label, "Connect") == 0 && !joined) {
-                  std::string user_id = "C-" + std::string(GetMac(mac_addr));
+                  std::string user_id = "C-" + mac_addr_str;
                  ret = JoinConnection(peer_client, remote_id, client_password);
                  if (0 == ret) {
-                    joined = true;
+                    // joined = true;
                  }
                } else if (strcmp(connect_label, "Disconnect") == 0 && joined) {
                  ret = LeaveConnection(peer_client);
@@ -1113,9 +832,10 @@ int main() {
      fps = frame_count / (elapsed_time / 1000);
      frame_count = 0;
      window_title = "Remote Desk Client FPS [" + std::to_string(fps) +
-                     "] status [" + server_signal_status + "|" +
-                     client_signal_status + "|" + server_connection_status +
-                     "|" + client_connection_status + "]";
+                     "] status [" + server_signal_status_str + "|" +
+                     client_signal_status_str + "|" +
+                     server_connection_status_str + "|" +
+                     client_connection_status_str + "]";
      // For MacOS, UI frameworks can only be called from the main thread
      SDL_SetWindowTitle(window, window_title.c_str());
      start_time = end_time;
@@ -1136,6 +856,8 @@ int main() {
  SDL_CloseAudioDevice(output_dev);
  SDL_CloseAudioDevice(input_dev);

+  mouse_controller->Destroy();
+
  ImGui_ImplSDLRenderer2_Shutdown();
  ImGui_ImplSDL2_Shutdown();
  ImGui::DestroyContext();
--- a/src/screen_capture/macosx/screen_capture_wgc.cpp
+++ b/src/screen_capture/macosx/screen_capture_wgc.cpp
@@ -1,26 +0,0 @@
-#include "screen_capture_wgc.h"
-
-#include <iostream>
-
-ScreenCaptureWgc::ScreenCaptureWgc() {}
-
-ScreenCaptureWgc::~ScreenCaptureWgc() {}
-
-bool ScreenCaptureWgc::IsWgcSupported() { return false; }
-
-int ScreenCaptureWgc::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
-                           cb_desktop_data cb) {
-  return 0;
-}
-
-int ScreenCaptureWgc::Start() { return 0; }
-
-int ScreenCaptureWgc::Pause() { return 0; }
-
-int ScreenCaptureWgc::Resume() { return 0; }
-
-int ScreenCaptureWgc::Stop() { return 0; }
-
-void ScreenCaptureWgc::OnFrame() {}
-
-void ScreenCaptureWgc::CleanUp() {}
--- a/src/screen_capture/macosx/screen_capture_wgc.h
+++ b/src/screen_capture/macosx/screen_capture_wgc.h
@@ -1,56 +0,0 @@
-#ifndef _SCREEN_CAPTURE_WGC_H_
-#define _SCREEN_CAPTURE_WGC_H_
-
-#include <atomic>
-#include <functional>
-#include <string>
-#include <thread>
-
-typedef struct {
-  int left;
-  int top;
-  int right;
-  int bottom;
-} RECORD_DESKTOP_RECT;
-
-typedef std::function<void(unsigned char *, int, int, int)> cb_desktop_data;
-typedef std::function<void(int)> cb_desktop_error;
-
-class ScreenCaptureWgc {
- public:
-  ScreenCaptureWgc();
-  ~ScreenCaptureWgc();
-
- public:
-  bool IsWgcSupported();
-
-  int Init(const RECORD_DESKTOP_RECT &rect, const int fps, cb_desktop_data cb);
-
-  int Start();
-  int Pause();
-  int Resume();
-  int Stop();
-
-  void OnFrame();
-
- protected:
-  void CleanUp();
-
- private:
-  std::atomic_bool _running;
-  std::atomic_bool _paused;
-  std::atomic_bool _inited;
-
-  std::thread _thread;
-
-  std::string _device_name;
-
-  RECORD_DESKTOP_RECT _rect;
-
-  int _fps;
-
-  cb_desktop_data _on_data;
-  cb_desktop_error _on_error;
-};
-
-#endif
--- a/src/screen_capturer/linux/screen_capturer_x11.cpp
+++ b/src/screen_capturer/linux/screen_capturer_x11.cpp
@@ -1,4 +1,4 @@
-#include "screen_capture_x11.h"
+#include "screen_capturer_x11.h"

 #include <iostream>

@@ -7,20 +7,20 @@
 #define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
 unsigned char nv12_buffer_[NV12_BUFFER_SIZE];

-ScreenCaptureX11::ScreenCaptureX11() {}
+ScreenCapturerX11::ScreenCapturerX11() {}

-ScreenCaptureX11::~ScreenCaptureX11() {
-  if (capture_thread_->joinable()) {
-    capture_thread_->join();
-  }
-}
+ScreenCapturerX11::~ScreenCapturerX11() {}

-int ScreenCaptureX11::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
-                           cb_desktop_data cb) {
+int ScreenCapturerX11::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                            cb_desktop_data cb) {
  if (cb) {
    _on_data = cb;
  }

+  fps_ = fps;
+
+  av_log_set_level(AV_LOG_QUIET);
+
  pFormatCtx_ = avformat_alloc_context();

  avdevice_register_all();
@@ -31,9 +31,10 @@ int ScreenCaptureX11::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
  // av_dict_set(&options_, "follow_mouse", "centered", 0);
  // Video frame size. The default is to capture the full screen
  // av_dict_set(&options_, "video_size", "1280x720", 0);
-  ifmt_ = (AVInputFormat *)av_find_input_format("x11grab");
+  std::string capture_method = "x11grab";
+  ifmt_ = (AVInputFormat *)av_find_input_format(capture_method.c_str());
  if (!ifmt_) {
-    printf("Couldn't find_input_format\n");
+    LOG_ERROR("Couldn't find_input_format [{}]", capture_method.c_str());
  }

  // Grab at position 10,20
@@ -93,7 +94,15 @@ int ScreenCaptureX11::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
  return 0;
 }

-int ScreenCaptureX11::Start() {
+int ScreenCapturerX11::Destroy() {
+  if (capture_thread_->joinable()) {
+    capture_thread_->join();
+  }
+
+  return 0;
+}
+
+int ScreenCapturerX11::Start() {
  capture_thread_.reset(new std::thread([this]() {
    while (1) {
      if (av_read_frame(pFormatCtx_, packet_) >= 0) {
@@ -123,12 +132,12 @@ int ScreenCaptureX11::Start() {
  return 0;
 }

-int ScreenCaptureX11::Pause() { return 0; }
+int ScreenCapturerX11::Pause() { return 0; }

-int ScreenCaptureX11::Resume() { return 0; }
+int ScreenCapturerX11::Resume() { return 0; }

-int ScreenCaptureX11::Stop() { return 0; }
+int ScreenCapturerX11::Stop() { return 0; }

-void ScreenCaptureX11::OnFrame() {}
+void ScreenCapturerX11::OnFrame() {}

-void ScreenCaptureX11::CleanUp() {}
+void ScreenCapturerX11::CleanUp() {}
--- a/src/screen_capturer/linux/screen_capturer_x11.h
+++ b/src/screen_capturer/linux/screen_capturer_x11.h
@@ -1,11 +1,12 @@
-#ifndef _SCREEN_CAPTURE_X11_H_
-#define _SCREEN_CAPTURE_X11_H_
+#ifndef _SCREEN_CAPTURER_X11_H_
+#define _SCREEN_CAPTURER_X11_H_

 #include <atomic>
 #include <functional>
 #include <string>
 #include <thread>

+#include "screen_capturer.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -18,25 +19,19 @@ extern "C" {
 };
 #endif

-typedef struct {
-  int left;
-  int top;
-  int right;
-  int bottom;
-} RECORD_DESKTOP_RECT;
-
-typedef std::function<void(unsigned char *, int, int, int)> cb_desktop_data;
-typedef std::function<void(int)> cb_desktop_error;
-
-class ScreenCaptureX11 {
+class ScreenCapturerX11 : public ScreenCapturer {
 public:
-  ScreenCaptureX11();
-  ~ScreenCaptureX11();
+  ScreenCapturerX11();
+  ~ScreenCapturerX11();

 public:
-  int Init(const RECORD_DESKTOP_RECT &rect, const int fps, cb_desktop_data cb);
+  virtual int Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                   cb_desktop_data cb);
+
+  virtual int Destroy();
+
+  virtual int Start();

-  int Start();
  int Pause();
  int Resume();
  int Stop();
@@ -60,12 +55,12 @@ class ScreenCaptureX11 {
  int _fps;

  cb_desktop_data _on_data;
-  cb_desktop_error _on_error;

 private:
  int i_ = 0;
  int videoindex_ = 0;
  int got_picture_ = 0;
+  int fps_ = 0;
  // ffmpeg
  AVFormatContext *pFormatCtx_ = nullptr;
  AVCodecContext *pCodecCtx_ = nullptr;
--- a/src/screen_capturer/linux/x11_session.h
+++ b/src/screen_capturer/linux/x11_session.h
--- a/src/screen_capturer/linux/x11_session_impl.cpp
+++ b/src/screen_capturer/linux/x11_session_impl.cpp
--- a/src/screen_capturer/linux/x11_session_impl.h
+++ b/src/screen_capturer/linux/x11_session_impl.h
--- a/src/screen_capturer/macosx/screen_capturer_avf.cpp
+++ b/src/screen_capturer/macosx/screen_capturer_avf.cpp
@@ -0,0 +1,144 @@
+#include "screen_capturer_avf.h"
+
+#include <iostream>
+
+#include "log.h"
+
+#define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
+unsigned char nv12_buffer_[NV12_BUFFER_SIZE];
+
+ScreenCapturerAvf::ScreenCapturerAvf() {}
+
+ScreenCapturerAvf::~ScreenCapturerAvf() {}
+
+int ScreenCapturerAvf::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                            cb_desktop_data cb) {
+  if (cb) {
+    _on_data = cb;
+  }
+
+  av_log_set_level(AV_LOG_QUIET);
+
+  pFormatCtx_ = avformat_alloc_context();
+
+  avdevice_register_all();
+
+  // grabbing frame rate
+  av_dict_set(&options_, "framerate", "60", 0);
+  av_dict_set(&options_, "pixel_format", "nv12", 0);
+  // show remote cursor
+  av_dict_set(&options_, "capture_cursor", "1", 0);
+  // Make the grabbed area follow the mouse
+  // av_dict_set(&options_, "follow_mouse", "centered", 0);
+  // Video frame size. The default is to capture the full screen
+  // av_dict_set(&options_, "video_size", "1280x720", 0);
+  ifmt_ = (AVInputFormat *)av_find_input_format("avfoundation");
+  if (!ifmt_) {
+    printf("Couldn't find_input_format\n");
+  }
+
+  // Grab at position 10,20
+  if (avformat_open_input(&pFormatCtx_, "Capture screen 0", ifmt_, &options_) !=
+      0) {
+    printf("Couldn't open input stream.\n");
+    return -1;
+  }
+
+  if (avformat_find_stream_info(pFormatCtx_, NULL) < 0) {
+    printf("Couldn't find stream information.\n");
+    return -1;
+  }
+
+  videoindex_ = -1;
+  for (i_ = 0; i_ < pFormatCtx_->nb_streams; i_++)
+    if (pFormatCtx_->streams[i_]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+      videoindex_ = i_;
+      break;
+    }
+  if (videoindex_ == -1) {
+    printf("Didn't find a video stream.\n");
+    return -1;
+  }
+
+  pCodecParam_ = pFormatCtx_->streams[videoindex_]->codecpar;
+
+  pCodecCtx_ = avcodec_alloc_context3(NULL);
+  avcodec_parameters_to_context(pCodecCtx_, pCodecParam_);
+
+  pCodec_ = const_cast<AVCodec *>(avcodec_find_decoder(pCodecCtx_->codec_id));
+  if (pCodec_ == NULL) {
+    printf("Codec not found.\n");
+    return -1;
+  }
+  if (avcodec_open2(pCodecCtx_, pCodec_, NULL) < 0) {
+    printf("Could not open codec.\n");
+    return -1;
+  }
+
+  const int screen_w = pFormatCtx_->streams[videoindex_]->codecpar->width;
+  const int screen_h = pFormatCtx_->streams[videoindex_]->codecpar->height;
+
+  pFrame_ = av_frame_alloc();
+  pFrameNv12_ = av_frame_alloc();
+
+  pFrame_->width = screen_w;
+  pFrame_->height = screen_h;
+  pFrameNv12_->width = 1280;
+  pFrameNv12_->height = 720;
+
+  packet_ = (AVPacket *)av_malloc(sizeof(AVPacket));
+
+  img_convert_ctx_ = sws_getContext(
+      pFrame_->width, pFrame_->height, pCodecCtx_->pix_fmt, pFrameNv12_->width,
+      pFrameNv12_->height, AV_PIX_FMT_NV12, SWS_BICUBIC, NULL, NULL, NULL);
+
+  return 0;
+}
+
+int ScreenCapturerAvf::Destroy() {
+  if (capture_thread_->joinable()) {
+    capture_thread_->join();
+  }
+
+  return 0;
+}
+
+int ScreenCapturerAvf::Start() {
+  capture_thread_.reset(new std::thread([this]() {
+    while (1) {
+      if (av_read_frame(pFormatCtx_, packet_) >= 0) {
+        if (packet_->stream_index == videoindex_) {
+          avcodec_send_packet(pCodecCtx_, packet_);
+          av_packet_unref(packet_);
+          got_picture_ = avcodec_receive_frame(pCodecCtx_, pFrame_);
+
+          if (!got_picture_) {
+            av_image_fill_arrays(pFrameNv12_->data, pFrameNv12_->linesize,
+                                 nv12_buffer_, AV_PIX_FMT_NV12,
+                                 pFrameNv12_->width, pFrameNv12_->height, 1);
+
+            sws_scale(img_convert_ctx_, pFrame_->data, pFrame_->linesize, 0,
+                      pFrame_->height, pFrameNv12_->data,
+                      pFrameNv12_->linesize);
+
+            _on_data((unsigned char *)nv12_buffer_,
+                     pFrameNv12_->width * pFrameNv12_->height * 3 / 2,
+                     pFrameNv12_->width, pFrameNv12_->height);
+          }
+        }
+      }
+    }
+  }));
+
+  return 0;
+}
+
+int ScreenCapturerAvf::Pause() { return 0; }
+
+int ScreenCapturerAvf::Resume() { return 0; }
+
+int ScreenCapturerAvf::Stop() { return 0; }
+
+void ScreenCapturerAvf::OnFrame() {}
+
+void ScreenCapturerAvf::CleanUp() {}
--- a/src/screen_capturer/macosx/screen_capturer_avf.h
+++ b/src/screen_capturer/macosx/screen_capturer_avf.h
@@ -0,0 +1,85 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-01
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SCREEN_CAPTURER_AVF_H_
+#define _SCREEN_CAPTURER_AVF_H_
+
+#include <atomic>
+#include <functional>
+#include <string>
+#include <thread>
+
+#include "screen_capturer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <libavcodec/avcodec.h>
+#include <libavdevice/avdevice.h>
+#include <libavformat/avformat.h>
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+#ifdef __cplusplus
+};
+#endif
+
+class ScreenCapturerAvf : public ScreenCapturer {
+ public:
+  ScreenCapturerAvf();
+  ~ScreenCapturerAvf();
+
+ public:
+  virtual int Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                   cb_desktop_data cb);
+  virtual int Destroy();
+
+  virtual int Start();
+
+  int Pause();
+  int Resume();
+  int Stop();
+
+  void OnFrame();
+
+ protected:
+  void CleanUp();
+
+ private:
+  std::atomic_bool _running;
+  std::atomic_bool _paused;
+  std::atomic_bool _inited;
+
+  std::thread _thread;
+
+  std::string _device_name;
+
+  RECORD_DESKTOP_RECT _rect;
+
+  int _fps;
+
+  cb_desktop_data _on_data;
+
+ private:
+  int i_ = 0;
+  int videoindex_ = 0;
+  int got_picture_ = 0;
+  // ffmpeg
+  AVFormatContext *pFormatCtx_ = nullptr;
+  AVCodecContext *pCodecCtx_ = nullptr;
+  AVCodec *pCodec_ = nullptr;
+  AVCodecParameters *pCodecParam_ = nullptr;
+  AVDictionary *options_ = nullptr;
+  AVInputFormat *ifmt_ = nullptr;
+  AVFrame *pFrame_ = nullptr;
+  AVFrame *pFrameNv12_ = nullptr;
+  AVPacket *packet_ = nullptr;
+  struct SwsContext *img_convert_ctx_ = nullptr;
+
+  // thread
+  std::unique_ptr<std::thread> capture_thread_ = nullptr;
+};
+
+#endif
--- a/src/screen_capturer/screen_capturer.h
+++ b/src/screen_capturer/screen_capturer.h
@@ -0,0 +1,33 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-15
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SCREEN_CAPTURER_H_
+#define _SCREEN_CAPTURER_H_
+
+#include <functional>
+
+class ScreenCapturer {
+ public:
+  typedef struct {
+    int left;
+    int top;
+    int right;
+    int bottom;
+  } RECORD_DESKTOP_RECT;
+  typedef std::function<void(unsigned char *, int, int, int)> cb_desktop_data;
+
+ public:
+  virtual ~ScreenCapturer() {}
+
+ public:
+  virtual int Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                   cb_desktop_data cb) = 0;
+  virtual int Destroy() = 0;
+
+  virtual int Start() = 0;
+};
+
+#endif
--- a/src/screen_capturer/screen_capturer_factory.h
+++ b/src/screen_capturer/screen_capturer_factory.h
@@ -0,0 +1,37 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-15
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SCREEN_CAPTURER_FACTORY_H_
+#define _SCREEN_CAPTURER_FACTORY_H_
+
+#ifdef _WIN32
+
+#include "screen_capturer_wgc.h"
+#elif __linux__
+#include "screen_capturer_x11.h"
+#elif __APPLE__
+#include "screen_capturer_avf.h"
+#endif
+
+class ScreenCapturerFactory {
+ public:
+  virtual ~ScreenCapturerFactory() {}
+
+ public:
+  ScreenCapturer* Create() {
+#ifdef _WIN32
+    return new ScreenCapturerWgc();
+#elif __linux__
+    return new ScreenCapturerX11();
+#elif __APPLE__
+    return new ScreenCapturerAvf();
+#else
+    return nullptr;
+#endif
+  }
+};
+
+#endif
--- a/src/screen_capturer/windows/screen_capturer_wgc.cpp
+++ b/src/screen_capturer/windows/screen_capturer_wgc.cpp
@@ -1,12 +1,41 @@
-#include "screen_capture_wgc.h"
+#include "screen_capturer_wgc.h"

 #include <Windows.h>
 #include <d3d11_4.h>
 #include <winrt/Windows.Foundation.Metadata.h>
 #include <winrt/Windows.Graphics.Capture.h>

+extern "C" {
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+};
+
 #include <iostream>

+int BGRAToNV12FFmpeg(unsigned char *src_buffer, int width, int height,
+                     unsigned char *dst_buffer) {
+  AVFrame *Input_pFrame = av_frame_alloc();
+  AVFrame *Output_pFrame = av_frame_alloc();
+  struct SwsContext *img_convert_ctx =
+      sws_getContext(width, height, AV_PIX_FMT_BGRA, 1280, 720, AV_PIX_FMT_NV12,
+                     SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
+
+  av_image_fill_arrays(Input_pFrame->data, Input_pFrame->linesize, src_buffer,
+                       AV_PIX_FMT_BGRA, width, height, 1);
+  av_image_fill_arrays(Output_pFrame->data, Output_pFrame->linesize, dst_buffer,
+                       AV_PIX_FMT_NV12, 1280, 720, 1);
+
+  sws_scale(img_convert_ctx, (uint8_t const **)Input_pFrame->data,
+            Input_pFrame->linesize, 0, height, Output_pFrame->data,
+            Output_pFrame->linesize);
+
+  if (Input_pFrame) av_free(Input_pFrame);
+  if (Output_pFrame) av_free(Output_pFrame);
+  if (img_convert_ctx) sws_freeContext(img_convert_ctx);
+
+  return 0;
+}
+
 BOOL WINAPI EnumMonitorProc(HMONITOR hmonitor, HDC hdc, LPRECT lprc,
                            LPARAM data) {
  MONITORINFOEX info_ex;
@@ -31,14 +60,11 @@ HMONITOR GetPrimaryMonitor() {
  return hmonitor;
 }

-ScreenCaptureWgc::ScreenCaptureWgc() {}
+ScreenCapturerWgc::ScreenCapturerWgc() {}

-ScreenCaptureWgc::~ScreenCaptureWgc() {
-  Stop();
-  CleanUp();
-}
+ScreenCapturerWgc::~ScreenCapturerWgc() {}

-bool ScreenCaptureWgc::IsWgcSupported() {
+bool ScreenCapturerWgc::IsWgcSupported() {
  try {
    /* no contract for IGraphicsCaptureItemInterop, verify 10.0.18362.0 */
    return winrt::Windows::Foundation::Metadata::ApiInformation::
@@ -50,11 +76,13 @@ bool ScreenCaptureWgc::IsWgcSupported() {
  }
 }

-int ScreenCaptureWgc::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
-                           cb_desktop_data cb) {
+int ScreenCapturerWgc::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                            cb_desktop_data cb) {
  int error = 0;
  if (_inited == true) return error;

+  nv12_frame_ = new unsigned char[rect.right * rect.bottom * 4];
+
  _fps = fps;

  _on_data = cb;
@@ -86,7 +114,19 @@ int ScreenCaptureWgc::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
  return error;
 }

-int ScreenCaptureWgc::Start() {
+int ScreenCapturerWgc::Destroy() {
+  if (nv12_frame_) {
+    delete nv12_frame_;
+    nv12_frame_ = nullptr;
+  }
+
+  Stop();
+  CleanUp();
+
+  return 0;
+}
+
+int ScreenCapturerWgc::Start() {
  if (_running == true) {
    std::cout << "record desktop duplication is already running" << std::endl;
    return 0;
@@ -103,19 +143,19 @@ int ScreenCaptureWgc::Start() {
  return 0;
 }

-int ScreenCaptureWgc::Pause() {
+int ScreenCapturerWgc::Pause() {
  _paused = true;
  if (session_) session_->Pause();
  return 0;
 }

-int ScreenCaptureWgc::Resume() {
+int ScreenCapturerWgc::Resume() {
  _paused = false;
  if (session_) session_->Resume();
  return 0;
 }

-int ScreenCaptureWgc::Stop() {
+int ScreenCapturerWgc::Stop() {
  _running = false;

  if (session_) session_->Stop();
@@ -123,13 +163,15 @@ int ScreenCaptureWgc::Stop() {
  return 0;
 }

-void ScreenCaptureWgc::OnFrame(const WgcSession::wgc_session_frame &frame) {
+void ScreenCapturerWgc::OnFrame(const WgcSession::wgc_session_frame &frame) {
  if (_on_data)
-    _on_data((unsigned char *)frame.data, frame.width * frame.height * 4,
-             frame.width, frame.height);
+    BGRAToNV12FFmpeg((unsigned char *)frame.data, frame.width, frame.height,
+                     nv12_frame_);
+  _on_data(nv12_frame_, frame.width * frame.height * 4, frame.width,
+           frame.height);
 }

-void ScreenCaptureWgc::CleanUp() {
+void ScreenCapturerWgc::CleanUp() {
  _inited = false;

  if (session_) session_->Release();
--- a/src/screen_capturer/windows/screen_capturer_wgc.h
+++ b/src/screen_capturer/windows/screen_capturer_wgc.h
@@ -1,35 +1,30 @@
-#ifndef _SCREEN_CAPTURE_WGC_H_
-#define _SCREEN_CAPTURE_WGC_H_
+#ifndef _SCREEN_CAPTURER_WGC_H_
+#define _SCREEN_CAPTURER_WGC_H_

 #include <atomic>
 #include <functional>
 #include <string>
 #include <thread>

+#include "screen_capturer.h"
 #include "wgc_session.h"
 #include "wgc_session_impl.h"

-typedef struct {
-  int left;
-  int top;
-  int right;
-  int bottom;
-} RECORD_DESKTOP_RECT;
-
-typedef std::function<void(unsigned char *, int, int, int)> cb_desktop_data;
-typedef std::function<void(int)> cb_desktop_error;
-
-class ScreenCaptureWgc : public WgcSession::wgc_session_observer {
+class ScreenCapturerWgc : public ScreenCapturer,
+                          public WgcSession::wgc_session_observer {
 public:
-  ScreenCaptureWgc();
-  ~ScreenCaptureWgc();
+  ScreenCapturerWgc();
+  ~ScreenCapturerWgc();

 public:
  bool IsWgcSupported();

-  int Init(const RECORD_DESKTOP_RECT &rect, const int fps, cb_desktop_data cb);
+  virtual int Init(const RECORD_DESKTOP_RECT &rect, const int fps,
+                   cb_desktop_data cb);
+  virtual int Destroy();
+
+  virtual int Start();

-  int Start();
  int Pause();
  int Resume();
  int Stop();
@@ -55,7 +50,8 @@ class ScreenCaptureWgc : public WgcSession::wgc_session_observer {
  int _fps;

  cb_desktop_data _on_data;
-  cb_desktop_error _on_error;
+
+  unsigned char *nv12_frame_ = nullptr;
 };

 #endif
--- a/src/screen_capturer/windows/wgc_session.h
+++ b/src/screen_capturer/windows/wgc_session.h
--- a/src/screen_capturer/windows/wgc_session_impl.cpp
+++ b/src/screen_capturer/windows/wgc_session_impl.cpp
--- a/src/screen_capturer/windows/wgc_session_impl.h
+++ b/src/screen_capturer/windows/wgc_session_impl.h
--- a/test/linux_mouse_control/mouse_control.cpp
+++ b/test/linux_mouse_control/mouse_control.cpp
@@ -0,0 +1,150 @@
+#include <X11/Xlib.h>
+#include <fcntl.h>
+#include <linux/uinput.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <iostream>
+#include <sstream>
+
+using namespace std;
+
+int fd;
+Display *dpy;
+
+void initMouse();
+void destroyMouse();
+void mouseLeftClick();
+void mouseRightClick();
+void mouseGetPosition(int &x, int &y);
+void mouseMove(int xdelta, int ydelta);
+
+void initMouse() {
+  fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
+  ioctl(fd, UI_SET_EVBIT, EV_KEY);
+  ioctl(fd, UI_SET_KEYBIT, BTN_RIGHT);
+  ioctl(fd, UI_SET_KEYBIT, BTN_LEFT);
+  ioctl(fd, UI_SET_EVBIT, EV_ABS);
+  ioctl(fd, UI_SET_ABSBIT, ABS_X);
+  ioctl(fd, UI_SET_ABSBIT, ABS_Y);
+  ioctl(fd, UI_SET_EVBIT, EV_REL);
+
+  struct uinput_user_dev uidev;
+  memset(&uidev, 0, sizeof(uidev));
+  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "VirtualMouse");
+  uidev.id.bustype = BUS_USB;
+  uidev.id.version = 1;
+  uidev.id.vendor = 0x1;
+  uidev.id.product = 0x1;
+  uidev.absmin[ABS_X] = 0;
+  uidev.absmax[ABS_X] = 3200;
+  uidev.absmin[ABS_Y] = 0;
+  uidev.absmax[ABS_Y] = 900;
+
+  write(fd, &uidev, sizeof(uidev));
+  ioctl(fd, UI_DEV_CREATE);
+
+  sleep(2);
+}
+
+void mouseLeftClick() {
+  struct input_event ev_click, ev_sync;
+  memset(&ev_click, 0, sizeof(ev_click));
+  memset(&ev_sync, 0, sizeof(ev_sync));
+
+  ev_click.type = EV_KEY;
+  ev_click.code = BTN_LEFT;
+  ev_click.value = 1;
+
+  // write left click event
+  write(fd, &ev_click, sizeof(ev_click));
+
+  // sync left click event
+  ev_sync.type = EV_SYN;
+  write(fd, &ev_sync, sizeof(ev_sync));
+}
+
+void mouseRightClick() {
+  struct input_event ev_click, ev_sync;
+  memset(&ev_click, 0, sizeof(ev_click));
+  memset(&ev_sync, 0, sizeof(ev_sync));
+
+  ev_click.type = EV_KEY;
+  ev_click.code = BTN_RIGHT;
+  ev_click.value = 1;
+
+  // write right click event
+  write(fd, &ev_click, sizeof(ev_click));
+
+  // sync right click event
+  ev_sync.type = EV_SYN;
+  write(fd, &ev_sync, sizeof(ev_sync));
+}
+
+void mouseSetPosition(int x, int y) {
+  struct input_event ev[2], ev_sync;
+  memset(ev, 0, sizeof(ev));
+  memset(&ev_sync, 0, sizeof(ev_sync));
+
+  ev[0].type = EV_ABS;
+  ev[0].code = ABS_X;
+  ev[0].value = x;
+  ev[1].type = EV_ABS;
+  ev[1].code = ABS_Y;
+  ev[1].value = y;
+
+  int res_w = write(fd, ev, sizeof(ev));
+
+  std::cout << "res w : " << res_w << "\n";
+
+  ev_sync.type = EV_SYN;
+  ev_sync.value = 0;
+  ev_sync.code = 0;
+  int res_ev_sync = write(fd, &ev_sync, sizeof(ev_sync));
+
+  std::cout << "res syn : " << res_ev_sync << "\n";
+}
+
+void initDisplay() { dpy = XOpenDisplay(NULL); }
+
+void destroyMouse() { ioctl(fd, UI_DEV_DESTROY); }
+
+void mouseMove(int xdelta, int ydelta) {
+  int xx, yy;
+  mouseGetPosition(xx, yy);
+
+  mouseSetPosition(xx + xdelta, yy + ydelta);
+}
+
+void mouseGetPosition(int &x, int &y) {
+  Window root, child;
+  int rootX, rootY, winX, winY;
+  unsigned int mask;
+
+  XQueryPointer(dpy, DefaultRootWindow(dpy), &root, &child, &rootX, &rootY,
+                &winX, &winY, &mask);
+
+  std::cout << "root x : " << rootX << "\n";
+  std::cout << "root y : " << rootY << "\n";
+
+  x = rootX;
+  y = rootY;
+}
+
+int main() {
+  initMouse();
+  initDisplay();
+
+  int tempx, tempy;
+
+  for (int i = 0; i < 5; ++i) {
+    mouseMove(100, 100);
+    sleep(1);
+    std::cout << "i : " << i << "\n";
+  }
+
+  destroyMouse();
+  return 0;
+}
--- a/test/screen_capture/mac_capture.cpp
+++ b/test/screen_capture/mac_capture.cpp
@@ -0,0 +1,286 @@
+#include <stdio.h>
+
+#define __STDC_CONSTANT_MACROS
+
+#ifdef _WIN32
+// Windows
+extern "C" {
+#include "SDL/SDL.h"
+#include "libavcodec/avcodec.h"
+#include "libavdevice/avdevice.h"
+#include "libavformat/avformat.h"
+#include "libswscale/swscale.h"
+};
+#else
+// Linux...
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <SDL2/SDL.h>
+#include <libavcodec/avcodec.h>
+#include <libavdevice/avdevice.h>
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+#ifdef __cplusplus
+};
+#endif
+#endif
+
+// Output YUV420P
+#define OUTPUT_YUV420P 0
+//'1' Use Dshow
+//'0' Use GDIgrab
+#define USE_DSHOW 0
+
+// Refresh Event
+#define SFM_REFRESH_EVENT (SDL_USEREVENT + 1)
+
+#define SFM_BREAK_EVENT (SDL_USEREVENT + 2)
+
+int thread_exit = 0;
+
+int sfp_refresh_thread(void *opaque) {
+  thread_exit = 0;
+  while (!thread_exit) {
+    SDL_Event event;
+    event.type = SFM_REFRESH_EVENT;
+    SDL_PushEvent(&event);
+    SDL_Delay(40);
+  }
+  thread_exit = 0;
+  // Break
+  SDL_Event event;
+  event.type = SFM_BREAK_EVENT;
+  SDL_PushEvent(&event);
+
+  return 0;
+}
+
+// Show AVFoundation Device
+void show_avfoundation_device() {
+  AVFormatContext *pFormatCtx = avformat_alloc_context();
+  AVDictionary *options = NULL;
+  av_dict_set(&options, "list_devices", "true", 0);
+  AVInputFormat *iformat =
+      (AVInputFormat *)av_find_input_format("avfoundation");
+  printf("==AVFoundation Device Info===\n");
+  avformat_open_input(&pFormatCtx, "", iformat, &options);
+  printf("=============================\n");
+}
+
+int main(int argc, char *argv[]) {
+  AVFormatContext *pFormatCtx;
+  int i, videoindex;
+  AVCodecContext *pCodecCtx;
+  AVCodec *pCodec;
+
+  avformat_network_init();
+  pFormatCtx = avformat_alloc_context();
+
+  // Open File
+  // char filepath[]="src01_480x272_22.h265";
+  // avformat_open_input(&pFormatCtx,filepath,NULL,NULL)
+
+  // Register Device
+  avdevice_register_all();
+  // Windows
+#ifdef _WIN32
+#if USE_DSHOW
+  // Use dshow
+  //
+  // Need to Install screen-capture-recorder
+  // screen-capture-recorder
+  // Website: http://sourceforge.net/projects/screencapturer/
+  //
+  AVInputFormat *ifmt = av_find_input_format("dshow");
+  if (avformat_open_input(&pFormatCtx, "video=screen-capture-recorder", ifmt,
+                          NULL) != 0) {
+    printf("Couldn't open input stream.\n");
+    return -1;
+  }
+#else
+  // Use gdigrab
+  AVDictionary *options = NULL;
+  // Set some options
+  // grabbing frame rate
+  // av_dict_set(&options,"framerate","5",0);
+  // The distance from the left edge of the screen or desktop
+  // av_dict_set(&options,"offset_x","20",0);
+  // The distance from the top edge of the screen or desktop
+  // av_dict_set(&options,"offset_y","40",0);
+  // Video frame size. The default is to capture the full screen
+  // av_dict_set(&options,"video_size","640x480",0);
+  AVInputFormat *ifmt = av_find_input_format("gdigrab");
+  if (avformat_open_input(&pFormatCtx, "desktop", ifmt, &options) != 0) {
+    printf("Couldn't open input stream.\n");
+    return -1;
+  }
+
+#endif
+#elif defined linux
+  // Linux
+  AVDictionary *options = NULL;
+  // Set some options
+  // grabbing frame rate
+  // av_dict_set(&options,"framerate","5",0);
+  // Make the grabbed area follow the mouse
+  // av_dict_set(&options,"follow_mouse","centered",0);
+  // Video frame size. The default is to capture the full screen
+  // av_dict_set(&options,"video_size","640x480",0);
+  AVInputFormat *ifmt = av_find_input_format("x11grab");
+  // Grab at position 10,20
+  if (avformat_open_input(&pFormatCtx, ":0.0+10,20", ifmt, &options) != 0) {
+    printf("Couldn't open input stream.\n");
+    return -1;
+  }
+#else
+  show_avfoundation_device();
+  // Mac
+  AVInputFormat *ifmt = (AVInputFormat *)av_find_input_format("avfoundation");
+  // Avfoundation
+  //[video]:[audio]
+  if (avformat_open_input(&pFormatCtx, "1", ifmt, NULL) != 0) {
+    printf("Couldn't open input stream.\n");
+    return -1;
+  }
+#endif
+
+  if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
+    printf("Couldn't find stream information.\n");
+    return -1;
+  }
+  videoindex = -1;
+  for (i = 0; i < pFormatCtx->nb_streams; i++)
+    if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+      videoindex = i;
+      break;
+    }
+  if (videoindex == -1) {
+    printf("Didn't find a video stream.\n");
+    return -1;
+  }
+  pCodecCtx = pFormatCtx->streams[videoindex]->codec;
+  pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
+  if (pCodec == NULL) {
+    printf("Codec not found.\n");
+    return -1;
+  }
+  if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
+    printf("Could not open codec.\n");
+    return -1;
+  }
+  AVFrame *pFrame, *pFrameYUV;
+  pFrame = av_frame_alloc();
+  pFrameYUV = av_frame_alloc();
+  // unsigned char *out_buffer=(unsigned char
+  // *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width,
+  // pCodecCtx->height)); avpicture_fill((AVPicture *)pFrameYUV, out_buffer,
+  // AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
+  // SDL----------------------------
+  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
+    printf("Could not initialize SDL - %s\n", SDL_GetError());
+    return -1;
+  }
+  int screen_w = 640, screen_h = 360;
+  const SDL_VideoInfo *vi = SDL_GetVideoInfo();
+  // Half of the Desktop's width and height.
+  screen_w = vi->current_w / 2;
+  screen_h = vi->current_h / 2;
+  SDL_Surface *screen;
+  screen = SDL_SetVideoMode(screen_w, screen_h, 0, 0);
+
+  if (!screen) {
+    printf("SDL: could not set video mode - exiting:%s\n", SDL_GetError());
+    return -1;
+  }
+  SDL_Overlay *bmp;
+  bmp = SDL_CreateYUVOverlay(pCodecCtx->width, pCodecCtx->height,
+                             SDL_YV12_OVERLAY, screen);
+  SDL_Rect rect;
+  rect.x = 0;
+  rect.y = 0;
+  rect.w = screen_w;
+  rect.h = screen_h;
+  // SDL End------------------------
+  int ret, got_picture;
+
+  AVPacket *packet = (AVPacket *)av_malloc(sizeof(AVPacket));
+
+#if OUTPUT_YUV420P
+  FILE *fp_yuv = fopen("output.yuv", "wb+");
+#endif
+
+  struct SwsContext *img_convert_ctx;
+  img_convert_ctx = sws_getContext(
+      pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width,
+      pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
+  //------------------------------
+  SDL_Thread *video_tid = SDL_CreateThread(sfp_refresh_thread, NULL);
+  //
+  SDL_WM_SetCaption("Simplest FFmpeg Grab Desktop", NULL);
+  // Event Loop
+  SDL_Event event;
+
+  for (;;) {
+    // Wait
+    SDL_WaitEvent(&event);
+    if (event.type == SFM_REFRESH_EVENT) {
+      //------------------------------
+      if (av_read_frame(pFormatCtx, packet) >= 0) {
+        if (packet->stream_index == videoindex) {
+          ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
+          if (ret < 0) {
+            printf("Decode Error.\n");
+            return -1;
+          }
+          if (got_picture) {
+            SDL_LockYUVOverlay(bmp);
+            pFrameYUV->data[0] = bmp->pixels[0];
+            pFrameYUV->data[1] = bmp->pixels[2];
+            pFrameYUV->data[2] = bmp->pixels[1];
+            pFrameYUV->linesize[0] = bmp->pitches[0];
+            pFrameYUV->linesize[1] = bmp->pitches[2];
+            pFrameYUV->linesize[2] = bmp->pitches[1];
+            sws_scale(img_convert_ctx,
+                      (const unsigned char *const *)pFrame->data,
+                      pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data,
+                      pFrameYUV->linesize);
+
+#if OUTPUT_YUV420P
+            int y_size = pCodecCtx->width * pCodecCtx->height;
+            fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv);      // Y
+            fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv);  // U
+            fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv);  // V
+#endif
+            SDL_UnlockYUVOverlay(bmp);
+
+            SDL_DisplayYUVOverlay(bmp, &rect);
+          }
+        }
+        av_free_packet(packet);
+      } else {
+        // Exit Thread
+        thread_exit = 1;
+      }
+    } else if (event.type == SDL_QUIT) {
+      thread_exit = 1;
+    } else if (event.type == SFM_BREAK_EVENT) {
+      break;
+    }
+  }
+
+  sws_freeContext(img_convert_ctx);
+
+#if OUTPUT_YUV420P
+  fclose(fp_yuv);
+#endif
+
+  SDL_Quit();
+
+  // av_free(out_buffer);
+  av_free(pFrameYUV);
+  avcodec_close(pCodecCtx);
+  avformat_close_input(&pFormatCtx);
+
+  return 0;
+}
--- a/thirdparty/ffmpeg/xmake.lua
+++ b/thirdparty/ffmpeg/xmake.lua
@@ -43,9 +43,10 @@ package("ffmpeg")
        add_configs("hardcoded-tables", {description = "Enable hardcoded tables.", default = true, type = "boolean"})
        add_configs("asm",              {description = "Enable asm", default = false, type = "boolean"})
        add_configs("libopenh264",      {description = "Enable libopenh264", default = false, type = "boolean"})
+        add_configs("libxcb",           {description = "Enable libxcb", default = true, type = "boolean"})
    end

-    add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil")
+    add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil", "postproc")
    if is_plat("macosx") then
        add_frameworks("CoreFoundation", "Foundation", "CoreVideo", "CoreMedia", "AudioToolbox", "VideoToolbox", "Security")
    elseif is_plat("linux") then
--- a/thirdparty/projectx
+++ b/thirdparty/projectx
--- a/thirdparty/sdl2/xmake.lua
+++ b/thirdparty/sdl2/xmake.lua
@@ -2,7 +2,6 @@ package("sdl2")
    add_urls("https://github.com/libsdl-org/SDL/archive/refs/tags/release-2.28.3.tar.gz", {alias = "github"})
    add_versions("github:2.28.3", "c17455d6e0c484bfe634b8de6af4c608e86ee449c28e40af04064aa6643fe382")

-    add_deps("cmake")
    on_install(function (package)
        local configs = {}
        table.insert(configs, "-DSDL_SHARED_ENABLED_BY_DEFAULT=OFF -DSDL_TEST_ENABLED_BY_DEFAULT=OFF")
--- a/thirdparty/xmake.lua
+++ b/thirdparty/xmake.lua
@@ -2,4 +2,6 @@ includes("sdl2", "projectx")
 if is_plat("windows") then
 elseif is_plat("linux") then
    includes("ffmpeg")
+elseif is_plat("macosx") then
+    includes("ffmpeg")
 end
--- a/xmake.lua
+++ b/xmake.lua
@@ -5,6 +5,9 @@ set_license("LGPL-3.0")
 add_rules("mode.release", "mode.debug")
 set_languages("c++17")

+-- set_policy("build.warning", true)
+-- set_warnings("all", "extra")
+
 add_defines("UNICODE")
 if is_mode("debug") then
    add_defines("REMOTE_DESK_DEBUG")
@@ -23,18 +26,21 @@ if is_os("windows") then
 elseif is_os("linux") then
    add_requires("ffmpeg 5.1.2", {system = false})
    add_packages("ffmpeg")
-    add_links("SDL2")
    add_syslinks("pthread", "dl")
-    add_links("SDL2")
+    add_linkdirs("thirdparty/projectx/thirdparty/nvcodec/Lib/x64")
+    add_links("SDL2", "cuda", "nvidia-encode", "nvcuvid")
    add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
        "-lswscale", "-lavutil", "-lswresample",
        "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
-        "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-ldl", "-lpthread", 
+        "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-ldl", "-lpthread",
        {force = true})
 elseif is_os("macosx") then
    add_requires("ffmpeg 5.1.2", {system = false})
-    add_packages("ffmpeg")
-    add_links("SDL2")
+    add_requires("libxcb", {system = false})
+    add_packages("ffmpeg", "libxcb")
+    add_links("SDL2", "SDL2main")
+    add_ldflags("-Wl,-ld_classic")
+    add_frameworks("OpenGL")
 end

 add_packages("spdlog", "sdl2", "imgui")
@@ -47,23 +53,45 @@ target("log")
    add_headerfiles("src/log/log.h")
    add_includedirs("src/log", {public = true})

-target("screen_capture")
+target("common")
    set_kind("object")
    add_deps("log")
+    add_files("src/common/*.cpp")
+    add_includedirs("src/common", {public = true})
+
+target("screen_capturer")
+    set_kind("object")
+    add_deps("log")
+    add_includedirs("src/screen_capturer", {public = true})
    if is_os("windows") then
-        add_files("src/screen_capture/windows/*.cpp")
-        add_includedirs("src/screen_capture/windows", {public = true})
+        add_files("src/screen_capturer/windows/*.cpp")
+        add_includedirs("src/screen_capturer/windows", {public = true})
    elseif is_os("macosx") then
-         add_files("src/screen_capture/macosx/*.cpp")
-         add_includedirs("ssrc/creen_capture/macosx", {public = true})
+         add_files("src/screen_capturer/macosx/*.cpp")
+         add_includedirs("src/screen_capturer/macosx", {public = true})
    elseif is_os("linux") then
-         add_files("src/screen_capture/linux/*.cpp")
-         add_includedirs("src/screen_capture/linux", {public = true})
+         add_files("src/screen_capturer/linux/*.cpp")
+         add_includedirs("src/screen_capturer/linux", {public = true})
+    end
+
+target("device_controller")
+    set_kind("object")
+    add_deps("log")
+    add_includedirs("src/device_controller", {public = true})
+    if is_os("windows") then
+        add_files("src/device_controller/mouse/windows/*.cpp")
+        add_includedirs("src/device_controller/mouse/windows", {public = true})
+    elseif is_os("macosx") then
+        add_files("src/device_controller/mouse/mac/*.cpp")
+        add_includedirs("src/device_controller/mouse/mac", {public = true})
+    elseif is_os("linux") then
+         add_files("src/device_controller/mouse/linux/*.cpp")
+         add_includedirs("src/device_controller/mouse/linux", {public = true})
    end

 target("remote_desk")
    set_kind("binary")
-    add_deps("log", "screen_capture", "projectx")
+    add_deps("log", "common", "screen_capturer", "device_controller", "projectx")
    add_files("src/gui/main.cpp")

    -- after_install(function (target)
@@ -74,39 +102,49 @@ target("remote_desk")
    --     os.rm("$(projectdir)/out/lib")
    -- end)

-- target("screen_capture")
+-- target("screen_capturer")
 --     set_kind("binary")
 --     add_packages("sdl2", "imgui",  "ffmpeg", "openh264")
--     add_files("test/screen_capture/linux_capture.cpp")
+--     add_files("test/screen_capturer/linux_capture.cpp")
 --     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
 --     "-lswscale", "-lavutil", "-lswresample",
 --     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
 --     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
 --     "-ldl", {force = true})

-target("audio_capture")
-    set_kind("binary")
-    add_packages("ffmpeg")
-    add_files("test/audio_capture/sdl2_audio_capture.cpp")
-    add_includedirs("test/audio_capture")
-    add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
-    "-lswscale", "-lavutil", "-lswresample",
-    "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
-    "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
-    "-ldl", {force = true})
-    add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid")
+-- target("screen_capturer")
+--     set_kind("binary")
+--     add_packages("sdl2", "imgui",  "ffmpeg", "openh264")
+--     add_files("test/screen_capturer/mac_capture.cpp")
+--     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
+--     "-lswscale", "-lavutil", "-lswresample",
+--     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
+--     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
+--     "-ldl", {force = true})

-target("play_audio")
-    set_kind("binary")
-    add_packages("ffmpeg")
-    add_files("test/audio_capture/play_loopback.cpp")
-    add_includedirs("test/audio_capture")
-    add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
-    "-lswscale", "-lavutil", "-lswresample",
-    "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
-    "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
-    "-ldl", {force = true})
-    add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid")
+-- target("audio_capture")
+--     set_kind("binary")
+--     add_packages("ffmpeg")
+--     add_files("test/audio_capture/sdl2_audio_capture.cpp")
+--     add_includedirs("test/audio_capture")
+--     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
+--     "-lswscale", "-lavutil", "-lswresample",
+--     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
+--     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
+--     "-ldl", {force = true})
+--     add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid")
+
+-- target("play_audio")
+--     set_kind("binary")
+--     add_packages("ffmpeg")
+--     add_files("test/audio_capture/play_loopback.cpp")
+--     add_includedirs("test/audio_capture")
+--     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
+--     "-lswscale", "-lavutil", "-lswresample",
+--     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
+--     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
+--     "-ldl", {force = true})
+--     add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid")

 -- target("audio_capture")
 --     set_kind("binary")
@@ -117,4 +155,9 @@ target("play_audio")
 --     "-lswscale", "-lavutil", "-lswresample",
 --     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
 --     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
--     "-ldl", {force = true})
+--     "-ldl", {force = true})
+
+target("mouse_control")
+    set_kind("binary")
+    add_files("test/linux_mouse_control/mouse_control.cpp")
+    add_includedirs("test/linux_mouse_control")
Author	SHA1	Message	Date
dijunkun	fa05bbc8f8	Update README.md	2023-12-20 13:00:39 +08:00
Di Junkun	927f1a6d49	Update README.md	2023-12-20 09:34:43 +08:00
dijunkun	1d87f61d9f	Update README.md	2023-12-19 17:33:16 +08:00
dijunkun	ce546b77f5	Hide cursor when remote peer connected	2023-12-18 16:52:49 +08:00
dijunkun	b9e69cde51	Remove unused variables	2023-12-18 16:17:55 +08:00
dijunkun	e3987b4a42	Fix remote action type undefined error	2023-12-18 16:06:53 +08:00
dijunkun	0034359431	Update submodule	2023-12-18 15:27:11 +08:00
dijunkun	cec275bbe0	Add 1 second time interval for retry join transmission	2023-12-18 15:10:41 +08:00
dijunkun	fe68464cd2	Fix remote id hint error	2023-12-18 13:43:08 +08:00
dijunkun	181c473625	Use SDL to get screen resolution	2023-12-18 11:15:55 +08:00
dijunkun	2fc89923ae	Use factory method to create screen capturer	2023-12-15 17:29:17 +08:00
dijunkun	9276d5bfec	Fix compile error	2023-12-14 17:14:52 +08:00
dijunkun	95ef8fe8b9	Use factory method to create mouse controller on MacOS	2023-12-14 17:02:43 +08:00
dijunkun	3ab0e0136e	Use factory method to create mouse controller on Windows	2023-12-14 16:40:10 +08:00
dijunkun	daecc0d1e9	Use factory method to create mouse controller on Linux	2023-12-14 16:27:13 +08:00
dijunkun	bfecf47226	Fix cross platform compile error	2023-12-13 17:32:02 +08:00
dijunkun	09c42dd7ed	1.Add linux mouse control test;2.Fix unused variables warnning	2023-12-13 17:26:08 +08:00
dijunkun	a8a3b88514	Use uinput to control mouse and keyboard on Linux	2023-12-07 19:00:34 -08:00
dijunkun	2d6cfb5c76	Support cursor control on MacOS	2023-12-06 15:24:01 +08:00
dijunkun	ed8b536ac0	Add signal connection status 'NoSuchTransmissionId'	2023-12-04 14:04:36 +08:00
dijunkun	5e2d27e9d2	Fix ffmpeg link error on MacOS	2023-12-04 11:20:30 +08:00
dijunkun	47a2dc85f9	Fix screen capture on MacOS	2023-12-01 17:16:38 +08:00
dijunkun	5febe99bc2	Support screen capture on MacOS	2023-12-01 16:54:17 +08:00