update CHANGELOG.md

feat: add HTTPS support
feat: enable direct H.264 streaming over HTTP
style: optimize menu bar and settings styling

.gitignore

@@ -16,4 +16,16 @@ web/web
 .idea
 .vscode
 
-NanoKVM-Server
+NanoKVM-Server
+
+support/sg2002/kvm_system/build
+support/sg2002/kvm_system/dist
+support/sg2002/kvm_system/CMakeLists.txt
+
+support/sg2002/kvm_vision_test/build
+support/sg2002/kvm_vision_test/dist
+support/sg2002/kvm_vision_test/CMakeLists.txt
+
+support/sg2002/additional/original
+kvmapp/server/dl_lib
+kvmapp/kvm_system/kvm_system

CHANGELOG.md

@@ -1,3 +1,77 @@
+## 2.2.7 [e18ec22](https://github.com/sipeed/NanoKVM/commit/e18ec2219d22886529575d1fdaad5c320e05f5b2) (2025-05-08)
+
+* feat: add HTTPS support
+* feat: support direct H.264 streaming over HTTP
+* Localization
+  * update Russian translation (thanks to [polyzium](https://github.com/polyzium))
+  * update Dutch translation (thanks to [LeonStraathof](https://github.com/LeonStraathof))
+  * update Ukrainian translation (thanks to [click0](https://github.com/click0))
+  * update German translation (thanks to [3limin4tor](https://github.com/3limin4tor))
+
+## 2.2.6 [c83dc55](https://github.com/sipeed/NanoKVM/commit/c83dc5565c9dbed22336661a8832edbd93a06d11) (2025-04-17)
+
+* feat: add mouse jiggler to prevent system sleep
+* feat: add support for swap memory
+* feat: add support for customizing the device hostname
+* feat: add support for customizing the web page title
+* feat: add support for assigning custom names to Wake-on-LAN MAC addresses
+* feat: add confirmation prompts for power operations
+* feat: add logo to the login page (thanks to [S33G](https://github.com/S33G))
+* fix: fix possible privacy issues with MIC drivers. [Repair Record](https://github.com/sipeed/NanoKVM/commit/f9244b36df090a05cd59ba11ea4fd01e9b638995)
+* fix: fix iptables rule that could interfere with SSH connections (thanks to [scpcom](https://github.com/scpcom))
+* fix: fix the static IP gateway configuration might not apply correctly (thanks to [xitation](https://github.com/xitation))
+* perf: optimized OLED display handling and sleep logic
+* perf: improve H.264 streaming reliability by adding a heartbeat mechanism
+* perf: set the minimum screen size to 640x480
+* perf: add display of both wired and wireless IPv4 addresses in the settings page
+* perf: update the Thai language translations (thanks to [ChokunPlayZ](https://github.com/ChokunPlayZ))
+* chore: bump axios to 1.8.4
+* chore: bump golang.org/x/net to v0.39.0
+* chore: bump github.com/golang-jwt/jwt/v5 to to v5.2.2
+
+## 2.2.5 [3286cc2](https://github.com/sipeed/NanoKVM/commit/3286cc2f85a14133d65935cb476c833dcf151459) (2025-03-26)
+
+* fix: server crash caused by MJPEG frame detection error
+* feat: add HID-Only mode
+* feat: support preview updates
+* perf: improve image reading performance by optimizing screen parameters
+
+## 2.2.4 [1bf986d](https://github.com/sipeed/NanoKVM/commit/1bf986d41b34d568c1ffee5df90ce61b6b08456b) (2025-03-21)
+
+* fix: resolve USB initialization issue
+* fix: correct abnormal updates in certain models
+* perf: add version restrictions for production testing
+
+## 2.2.3 [6ef83cb](https://github.com/sipeed/NanoKVM/commit/6ef83cb22fcd77f721d32c97c85d12f2bfc3035a) (2025-03-21)
+
+* feat: add support for setting H.264 GOP
+* fix: resolve deadlock caused by HDMI resolution errors
+* perf: merge H.264 SPS and PPS into I-frame
+* perf: refactor MJPEG frame detection
+* perf: added more configuration options to the serial port terminal (thanks to [@mekaris](https://github.com/mekaris))
+* perf: improve the `update-nanokvm.py` script (thanks to [@reishoku](https://github.com/reishoku))
+* perf: disable mDNS by default in new products
+* perf: update log timestamp to millisecond precision
+* chore: bump Go to 1.23
+* chore: bump `golang.org/x/net` to v0.37.0
+
+## 2.2.2 [58d5ab2](https://github.com/sipeed/NanoKVM/commit/58d5ab2d37244b1e1a68b925a5c23c324c489ad3) (2025-03-11)
+
+* feat: add watchdog for NanoKVM-Server
+* feat: add support for UE chip
+* feat: support system reboot
+* feat: support enable/disable mDNS
+* fix: resolve UE chip cannot start server
+* perf: refactor automatic resolution detection
+* perf: add output prompt for unsupported resolutions
+* perf: add lock to kvmv_read_img
+* perf: configurable VENC automatic recycling feature
+* perf: add maximum limit for vi
+* perf: add tooltips to menu bar (thanks to [@S33G](https://github.com/S33G))
+* perf: menu bar is now draggable (thanks to [@forumi0721](https://github.com/forumi0721))
+* perf: image list support auto-refresh (thanks to [@forumi0721](https://github.com/forumi0721))
+* perf: update translations
+
 ## 2.2.1 [b5e48a0](https://github.com/sipeed/NanoKVM/commit/b5e48a07e82df3aedd60442342ae50b95684a697) (2025-02-21)
 
 * fix: mounted image were not being detected correctly
@@ -30,9 +104,9 @@ NanoKVM [Image v1.4.0](https://github.com/sipeed/NanoKVM/releases/tag/v1.4.0) ha
 * perf: download Tailscale installation package from the official source
 * perf: automatic enable/disable GOMEMLIMIT on tailscale start/stop
 * perf: add JWT configuration
-    * secretKey: customize secret key. If empty, generated a random 64-byte secret key by default
-    * refreshTokenDuration: customize token expiration time
-    * revokeTokensOnLogout: invalidate all JWT tokens on logout
+  * secretKey: customize secret key. If empty, generated a random 64-byte secret key by default
+  * refreshTokenDuration: customize token expiration time
+  * revokeTokensOnLogout: invalidate all JWT tokens on logout
 * perf: implement secure password storage using bcrypt hashing
 * perf: implement integrity checks for online updates
 * refactor: refactor HDMI module and remove the dependency `libmaixcam_lib.so`

README.md

@@ -18,56 +18,69 @@ English | [中文](./README_ZH.md) | [日本語](./README_JA.md)
 > Your NanoKVM is powered by [RISC-V](https://en.wikipedia.org/wiki/RISC-V)!
 > If you have any issues or suggestions, creating issue here, or tell us with [MaixHub Discussion](https://maixhub.com/discussion/nanokvm).
 
-## Opensource & Contribution 
-
-### Update 2025.02.19
-All components of NanoKVM were open-sourced, including the [front-end](https://github.com/sipeed/NanoKVM/tree/main/web), [back-end](https://github.com/sipeed/NanoKVM/tree/main/server), [kvm_vision](https://github.com/sipeed/NanoKVM/tree/main/vision/components/kvm), [kvm_mmf](https://github.com/sipeed/NanoKVM/tree/main/vision/components/kvm_mmf), [kvm_system](https://github.com/sipeed/NanoKVM/tree/main/support), the [kvmapp update package](https://github.com/sipeed/NanoKVM-System/tree/main/kvmapp), [system sdk](https://github.com/sipeed/LicheeRV-Nano-Build/tree/NanoKVM), and [packaging methods](https://github.com/sipeed/LicheeRV-Nano-Build/blob/NanoKVM/kvm/NanoKVM_img.sh).
-
-### Update 2025.02.14
-Newest APP v2.1.6 add most security enhancements&bug fix, recommend regular users upgrade to this version or newer.
-
-### Update 2025.02.05
-For users concerned about security, you can read this issue: https://github.com/sipeed/NanoKVM/issues/301 , you will find explanations addressing all security concerns.
-GitHub, as an open and transparent platform, provides a space for discussing so-called "backdoor" concerns. Open-source makes products more secure!
-
-### Update 2024.10.18
-
-We have open-sourced the backend code in 10.8, and thank you for civil PR it immediately, we will give you newest NanoKVM-PCIe as a reward！   
-The mid-Oct batch is starting testing and packaging, most orders before 10.1 will ship out next and next next week.   
-The aliexpress shipping date is change to Dec since 10.1, it is a conservative delivery time. the order in Oct. should send out during 11.15~12.15.   
-
 ## Introduction
 
 Lichee NanoKVM is an IP-KVM product based on LicheeRV Nano, inheriting the extreme size and powerful features of LicheeRV Nano.
-The Lichee NanoKVM is available in two versions:
-NanoKVM Lite is a basic configuration that is suitable for individual users with certain DIY capabilities and enterprise users with bulk requirements.
-The NanoKVM Full is a full version with a sophisticated case and complete accessories, as well as a built-in system mirror card that is ready to use at boot, and is recommended for individual users.
 
-![NanoKVM Disassembled](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_1.jpg)
+The Lichee NanoKVM is now available in three versions:
+
+* NanoKVM-Cube Lite is a basic configuration that is suitable for individual users with certain DIY capabilities and enterprise users with bulk requirements.
+
+* NanoKVM-Cube Full is a full version with a sophisticated case and complete accessories, as well as a built-in system mirror card that is ready to use at boot, and is recommended for individual users.
+
+* NanoKVM-PCle is a new form with a built-in PCle baffle that can be fixed inside the chassis. NanoKVM-PCle adds optional WiFi and PoE functions based on NanoKVM-Cube; it has its own PCle slot and can draw power from the motherboard PCle slot; in addition, the wired connection (ETH) is also more stable, meeting more professional needs.
+
+<div align="center">
+
+![NanoKVM-Cube](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_1.jpg)
+
+![NanoKVM-PCIe](https://wiki.sipeed.com/hardware/assets/NanoKVM/introduce/NanoKVM-PCIe.png)
+
+</div>
+
+> For users concerned about security, you can read this issue: [#301](https://github.com/sipeed/NanoKVM/issues/301). You will find explanations addressing all security concerns.
+> GitHub, as an open and transparent platform, provides a space for discussing so-called "backdoor" concerns. Open-source makes products more secure!
+
+## Project Structure
+
+``` shell
+├── kvmapp          # APP update package
+│   ├── jpg_stream  # Compatible for direct updates from very old versions
+│   ├── kvm_new_app # Triggers necessary components for kvm_system update
+│   ├── kvm_system  # kvm_system application
+│   ├── server      # NanoKVM front-end and back-end applications
+│   └── system      # Necessary system components
+├── web             # NanoKVM front-end
+├── server          # NanoKVM back-end
+├── support         # Auxiliary functions (image subsystem, system status, system updates, screen, keys, etc.)
+│   ├── sg2002      # NanoKVM-Lite/Full/PCIe
+│   └── h618        # NanoKVM-Pro
+├── ...
+```
 
 ## Tech Specs
 
-| Products          	| NanoKVM (Lite)                       	| NanoKVM (Full)                   	| PiKVM V4                          	|
-|-------------------	|--------------------------------------	|----------------------------------	|-----------------------------------	|
-| Compute Units     	| LicheeRV Nano(RISCV)                 	| LicheeRV Nano(RISCV)             	| CM4 (ARM)                         	|
-| Resolution        	| 1080P @ 60fps                        	| 1080P @ 60fps                    	| 1080P @ 60fps                     	|
-| Video encoding    	| MJPEG, H264                          	| MJPEG, H264                      	| MJPEG, H264                       	|
-| Video delay       	| 90～230ms                            	| 90～230ms                        	| 100～230ms                        	|
-| UEFI/BIOS         	| ✓                                    	| ✓                                	| ✓                                 	|
-| Virtual HID       	| ✓                                    	| ✓                                	| ✓                                 	|
-| Virtual CD-ROM    	| ✓                                    	| ✓                                	| ✓                                 	|
-| IPMI              	| ✓                                    	| ✓                                	| ✓                                 	|
-| Wake-on-LAN       	| ✓                                    	| ✓                                	| ✓                                 	|
-| ETH               	| 100M/10M                             	| 100M/10M                         	| 1000M/100M/10M                    	|
-| ATX power control 	| None，Users can connect by their own 	| USB interface IO control board   	| RJ-45 interface IO control board  	|
-| OLED              	| None，Users can connect by their own 	| 128x64 0.96" white               	| 128x32 0.91" white                	|
-| UART              	| 2                                    	| 2                                	| 1                                 	|
-| TF Card           	| None                                 	| ✓                                	| ✓                                 	|
-| Expansion         	| None                                 	| PoE                              	| WiFi/LTE                          	|
-| Power consumption 	| 0.2A@5V                              	| 0.2A@5V                          	| Peak 2.6A@5V                      	|
-| Power input       	| PC USB can be powered                	| PC USB or auxiliary power supply 	| DC 5V 3A power supply is required 	|
-| Cooling           	| Silent fanless                       	| Silent fanless                   	| Fan cooling                       	|
-| Size              	| 23x37x15mm   ～1/30 PiKVM V4 size    	| 40x36x36mm   ～1/7 PiKVM V4 size 	| 120x68x44mm                       	|
+| Products           | NanoKVM (Lite)                        | NanoKVM (Full)                    | PiKVM V4                           |
+|------------------- |-------------------------------------- |---------------------------------- |----------------------------------- |
+| Compute Units      | LicheeRV Nano(RISCV)                  | LicheeRV Nano(RISCV)              | CM4 (ARM)                          |
+| Resolution         | 1080P @ 60fps                         | 1080P @ 60fps                     | 1080P @ 60fps                      |
+| Video encoding     | MJPEG, H264                           | MJPEG, H264                       | MJPEG, H264                        |
+| Video delay        | 90～230ms                             | 90～230ms                         | 100～230ms                         |
+| UEFI/BIOS          | ✓                                     | ✓                                 | ✓                                  |
+| Virtual HID        | ✓                                     | ✓                                 | ✓                                  |
+| Virtual CD-ROM     | ✓                                     | ✓                                 | ✓                                  |
+| IPMI               | ✓                                     | ✓                                 | ✓                                  |
+| Wake-on-LAN        | ✓                                     | ✓                                 | ✓                                  |
+| ETH                | 100M/10M                              | 100M/10M                          | 1000M/100M/10M                     |
+| ATX power control  | None，Users can connect by their own  | USB interface IO control board    | RJ-45 interface IO control board   |
+| OLED               | None，Users can connect by their own  | 128x64 0.96" white                | 128x32 0.91" white                 |
+| UART               | 2                                     | 2                                 | 1                                  |
+| TF Card            | None                                  | ✓                                 | ✓                                  |
+| Expansion          | None                                  | PoE                               | WiFi/LTE                           |
+| Power consumption  | 0.2A@5V                               | 0.2A@5V                           | Peak 2.6A@5V                       |
+| Power input        | PC USB can be powered                 | PC USB or auxiliary power supply  | DC 5V 3A power supply is required  |
+| Cooling            | Silent fanless                        | Silent fanless                    | Fan cooling                        |
+| Size               | 23x37x15mm   ～1/30 PiKVM V4 size     | 40x36x36mm   ～1/7 PiKVM V4 size  | 120x68x44mm                        |
 
 ![NanoKVM PCB Pinout](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_2.jpg)
 
@@ -81,38 +94,50 @@ The NanoKVM image is built on LicheeRV Nano SDK and MaixCDK, and is compatible w
 
 Note: Out of the 256MB memory in SG2002, 158MB is currently allocated for the multimedia subsystem, which NanoKVM will use for video image acquisition and processing.
 
-+ [NanoKVM-A Schematic](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_RV_Nano_KVM_A_30111.pdf)
-+ [NanoKVM-B Schematic](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_HDMI_MIPI_31011.pdf)
-+ [NanoKVM img](https://github.com/sipeed/NanoKVM/releases/tag/NanoKVM)
+* [NanoKVM-A Schematic](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_RV_Nano_KVM_A_30111.pdf)
+* [NanoKVM-B Schematic](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_RV_Nano_KVM_B_30131.pdf)
+* [NanoKVM img](https://github.com/sipeed/NanoKVM/releases/tag/NanoKVM)
 
 ## Roadmap
 
-### Q1 2025
-
 **Enhancements:**
 
-- [x] Refactor the HDMI module and remove the libmaixcam_lib.so dependency
-- [x] Disable SSH by default and add an enable/disable toggle in the web UI
-- [x] Disable Tailscale by default and add an enable/disable toggle in the web UI
-- [x] Add JWT configuration options to the configuration file
-- [x] Secure password storage with bcrypt
+* [x] Refactor the HDMI module and remove the libmaixcam_lib.so dependency
+* [x] Disable SSH by default and add an enable/disable toggle in the web UI
+* [x] Disable Tailscale by default and add an enable/disable toggle in the web UI
+* [x] Add JWT configuration options to the configuration file
+* [x] Secure password storage with bcrypt
 
 **Distribution:**
 
-- [x] Distribute applications via GitHub
-- [x] Implement integrity checks for online updates
-- [ ] Support offline updates
+* [x] Distribute applications via GitHub
+* [x] Implement integrity checks for online updates
+* [ ] Support offline updates
 
 **Bug Fixes:**
 
-- [x] Fix the DNS issue
-- [x] Fix the CSRF vulnerability
+* [x] Fix the DNS issue
+* [x] Fix the CSRF vulnerability
 
 **Features**
 
-- [ ] [79](https://github.com/sipeed/NanoKVM/issues/79) Support Zerotier
-- [ ] [99](https://github.com/sipeed/NanoKVM/issues/99) Support WireGuard
-- [ ] [249](https://github.com/sipeed/NanoKVM/issues/249) Add Mouse Jiggler
+* [ ] [79](https://github.com/sipeed/NanoKVM/issues/79) Support Zerotier
+* [ ] [99](https://github.com/sipeed/NanoKVM/issues/99) Support WireGuard
+* [ ] [249](https://github.com/sipeed/NanoKVM/issues/249) Add Mouse Jiggler
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+Thanks for your interest in contributing to NanoKVM!
+
+Please keep your pull requests small and focused. This will make it easier to review and merge.
+
+> Developers who have contributed high-quality Pull Requests will receive a NanoKVM Cube, PCIe, or Pro as a token of our appreciation.
 
 ## Where to buy
 
@@ -124,3 +149,7 @@ Note: Out of the 256MB memory in SG2002, 158MB is currently allocated for the mu
 
 * [MaixHub Discussion](https://maixhub.com/discussion/nanokvm)
 * QQ group: 703230713
+
+## License
+
+This project is licensed under the GPL-3.0 License - see the LICENSE file for details.

README_JA.md

@@ -1,11 +1,13 @@
-# NanoKVM
+NanoKVM
+======
 
 <div align="center">
 
 ![](https://wiki.sipeed.com/hardware/assets/NanoKVM/introduce/NanoKVM_3.png)
 
 <h3>
-    <a href="https://wiki.sipeed.com/hardware/zh/lichee/RV_Nano/1_intro.html"> クイックスタート </a> |
+    <a href="https://wiki.sipeed.com/hardware/en/kvm/NanoKVM/introduction.html"> クイックスタート </a>
+    |
     <a href="https://cn.dl.sipeed.com/shareURL/KVM/nanoKVM"> ハードウェア </a>
 </h3>
 
@@ -13,18 +15,29 @@
 
 </div>
 
-> Your NanoKVM Power by RISC-V !
+> NanoKVM は [RISC-V](https://en.wikipedia.org/wiki/RISC-V) を搭載しています！
 > 使用中に問題や提案がある場合は、ここで issue を提出するか、[MaixHub Discussion](https://maixhub.com/discussion/nanokvm) でお知らせください。
 
-## オープンソース & 貢献 & 出荷
+## オープンソース & コントリビューション
 
-スターが2Kに近づいています！10月中旬にバックエンドのソースコードを整理してオープンソース化します！（また、10.1前のすべての予約注文が出荷される時期でもあります）
+### 2025.02.19 更新
 
-### 10.18 更新
+NanoKVM のすべてのコンポーネントはオープンソース化されており、[front-end](https://github.com/sipeed/NanoKVM/tree/main/web)、[back-end](https://github.com/sipeed/NanoKVM/tree/main/server)、[kvm_vision](https://github.com/sipeed/NanoKVM/tree/main/vision/components/kvm)、[kvm_mmf](https://github.com/sipeed/NanoKVM/tree/main/vision/components/kvm_mmf)、[kvm_system](https://github.com/sipeed/NanoKVM/tree/main/support)、[kvmapp update package](https://github.com/sipeed/NanoKVM-System/tree/main/kvmapp)、[system sdk](https://github.com/sipeed/LicheeRV-Nano-Build/tree/NanoKVM)、[packaging methods](https://github.com/sipeed/LicheeRV-Nano-Build/blob/NanoKVM/kvm/NanoKVM_img.sh)が含まれます。
 
-10.8にバックエンドコードをオープンソース化しました。すぐにPRを提出してくれたCivilに感謝します。最新のNanoKVM-PCIeを報酬として提供します！
-10月中旬のバッチはテストとパッケージングを開始しており、10.1前のほとんどの注文は次週と次々週に出荷されます。
-10.1以降、アリエクスプレスの出荷日は12月に変更されました。これは保守的な納期です。10月の注文は11.15〜12.15の間に発送される予定です。
+### 2025.02.14 更新
+
+最新のアプリケーションバージョン v2.1.6 には、多くのセキュリティ強化とバグ修正が追加されているため、一般のユーザーはこのバージョン以降へのアップグレードをお勧めします。
+
+### 2025.02.05 更新
+
+セキュリティを懸念しているユーザーは、この issue をお読みください: <https://github.com/sipeed/NanoKVM/issues/301>、セキュリティに関するすべての懸念事項について説明されています。
+GitHub は、オープンで透明性のあるプラットフォームとして、いわゆる「バックドア」の懸念事項を議論する場を提供しています。オープンソースであることにより、製品のセキュリティがさらに強化されます！
+
+### 2024.10.18 更新
+
+10/08にバックエンドコードをオープンソース化しました。すぐにPRを提出してくれたCivilに感謝します。最新のNanoKVM-PCIeを報酬として提供します！
+10月中旬のバッチはテストとパッケージングを開始しており、10/01以前のほとんどの注文は次週と次々週に出荷されます。
+10/01以降、アリエクスプレスの出荷日は12月に変更されました。これは保守的な納期です。10月の注文は11/15〜12/15の間に発送される予定です。
 
 ## 紹介
 
@@ -33,35 +46,35 @@ Lichee NanoKVMは2つのバージョンがあります：
 NanoKVM Liteは基本構成で、一定のDIY能力を持つ個人ユーザーや大量のニーズを持つ企業ユーザーに適しています。
 NanoKVM Fullは完全版で、洗練されたケースと完全なアクセサリーを備え、起動時にすぐに使用できるシステムミラーカードが内蔵されており、個人ユーザーに推奨されます。
 
-![](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_1.jpg)
+![NanoKVM 分解画像](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_1.jpg)
 
 ## 技術仕様
 
-| 製品 | NanoKVM (Lite) | NanoKVM (Full) | PiKVM V4 |
-| --- | --- | --- | --- |
-| 計算ユニット | LicheeRV Nano(RISCV) | LicheeRV Nano(RISCV) | CM4 (ARM) |
-| 解像度 | 1080P @ 60fps | 1080P @ 60fps | 1080P @ 60fps |
-| ビデオエンコーディング | MJPEG, H264 | MJPEG, H264 | MJPEG, H264 |
-| ビデオ遅延 | 90～230ms | 90～230ms | 100～230ms |
-| UEFI/BIOS | ✓ | ✓ | ✓ |
-| 仮想HID | ✓ | ✓ | ✓ |
-| 仮想CD-ROM | ✓ | ✓ | ✓ |
-| IPMI | ✓ | ✓ | ✓ |
-| Wake-on-LAN | ✓ | ✓ | ✓ |
-| ETH | 100M/10M | 100M/10M | 1000M/100M/10M |
-| ATX電源制御 | なし、ユーザーが自分で接続 | USBインターフェースIO制御ボード | RJ-45インターフェースIO制御ボード |
-| OLED | なし、ユーザーが自分で接続 | 128x64 0.96" 白 | 128x32 0.91" 白 |
-| UART | 2 | 2 | 1 |
-| TFカード | なし | ✓ | ✓ |
-| 拡張 | なし | PoE | WiFi/LTE |
-| 消費電力 | 0.2A@5V | 0.2A@5V | ピーク2.6A@5V |
-| 電源入力 | PC USBで給電可能 | PC USBまたは補助電源 | DC 5V 3A電源が必要 |
-| 冷却 | 静音ファンレス | 静音ファンレス | ファン冷却 |
-| サイズ | 23x37x15mm <br> ～1/30 PiKVM V4サイズ | 40x36x36mm <br/> ～1/7 PiKVM V4サイズ | 120x68x44mm |
+| 製品                   | NanoKVM (Lite)                        | NanoKVM (Full)                    | PiKVM V4                           |
+|----------------------- |-------------------------------------- |---------------------------------- |----------------------------------- |
+| 計算ユニット           | LicheeRV Nano(RISCV)                  | LicheeRV Nano(RISCV)              | CM4 (ARM)                          |
+| 解像度                 | 1080P @ 60fps                         | 1080P @ 60fps                     | 1080P @ 60fps                      |
+| ビデオエンコーディング | MJPEG, H264                           | MJPEG, H264                       | MJPEG, H264                        |
+| ビデオ遅延             | 90～230ms                             | 90～230ms                         | 100～230ms                         |
+| UEFI/BIOS              | ✓                                    | ✓                                | ✓                                 |
+| 仮想HID                | ✓                                    | ✓                                | ✓                                 |
+| 仮想CD-ROM             | ✓                                    | ✓                                | ✓                                 |
+| IPMI                   | ✓                                    | ✓                                | ✓                                 |
+| Wake-on-LAN            | ✓                                    | ✓                                | ✓                                 |
+| ETH                    | 100M/10M                              | 100M/10M                          | 1000M/100M/10M                     |
+| ATX電源制御            | なし、ユーザーが自分で接続            | USBインターフェースIO制御ボード   | RJ-45インターフェースIO制御ボード  |
+| OLED                   | なし、ユーザーが自分で接続            | 128x64 0.96" 白                   | 128x32 0.91" 白                    |
+| UART                   | 2                                     | 2                                 | 1                                  |
+| TFカード               | なし                                  | ✓                                | ✓                                 |
+| 拡張                   | なし                                  | PoE                               | WiFi/LTE                           |
+| 消費電力               | 0.2A@5V                               | 0.2A@5V                           | ピーク時 2.6A@5V                   |
+| 電源入力               | PC USBで給電可能                      | PC USBまたは補助電源              | DC 5V 3A電源が必要                 |
+| 冷却                   | 静音ファンレス                        | 静音ファンレス                    | ファン冷却                         |
+| サイズ                 | 23x37x15mm   ～1/30 PiKVM V4サイズ    | 40x36x36mm   ～1/7 PiKVM V4サイズ | 120x68x44mm                        |
 
-![](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_2.jpg)
+![NanoKVM PCB ピン配置](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_2.jpg)
 
-## ハードウェアプラットフォーム NanoKVM
+## NanoKVM ハードウェアプラットフォーム
 
 NanoKVMはSipeed [LicheeRV Nano](https://wiki.sipeed.com/hardware/zh/lichee/RV_Nano/1_intro.html)に基づいており、仕様、回路図、寸法図は[こちら](http://cn.dl.sipeed.com/shareURL/LICHEE/LicheeRV_Nano)で確認できます。
 
@@ -69,12 +82,41 @@ NanoKVM LiteはLicheeRV NanoとHDMItoCSIボードで構成され、NanoKVM FULL
 
 NanoKVMイメージはLicheeRV Nano SDKおよびMaixCDKに基づいて構築されており、LicheeRV Nanoを使用する資料と互換性があります。逆に、KVMソフトウェアはLicheeRV Nanoや他のSG2002製品では使用できません。LicheeRV NanoやMaixCamでHDMI入力アプリケーションを構築したい場合は、技術サポートを受けるためにお問い合わせください。
 
-注：SG2002の256MBメモリのうち、現在105MBがマルチメディアサブシステムに割り当てられており、NanoKVMはビデオ画像の取得と処理にこのメモリを使用します。
+注：SG2002の256MBメモリのうち、現在158MBがマルチメディアサブシステムに割り当てられており、NanoKVMはビデオ画像の取得と処理にこのメモリを使用します。
 
 + [NanoKVM-A 回路図](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_RV_Nano_KVM_A_30111.pdf)
 + [NanoKVM-B 回路図](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_HDMI_MIPI_31011.pdf)
 + [NanoKVM イメージダウンロード](https://github.com/sipeed/NanoKVM/releases/tag/NanoKVM)
 
+## ロードマップ
+
+### Q1 2025
+
+**改善:**
+
+- [x] HDMI モジュールをリファクタリングし、libmaixcam_lib.so の依存関係を削除
+- [x] SSH をデフォルトで無効にし、Web UI に有効/無効の切り替えを追加
+- [x] Tailscale をデフォルトで無効にし、Web UI に有効/無効の切り替えを追加
+- [x] 設定ファイルに JWT 設定オプションを追加
+- [x] bcrypt を利用したパスワードストレージのセキュリティ保護
+
+**配布:**
+
+- [x] GitHub 経由でのアプリケーション配布
+- [x] オンラインでの更新の際に整合性チェックを実施
+- [ ] オフラインでの更新をサポート
+
+**バグ修正:**
+
+- [x] DNS の問題を修正
+- [x] CSRF の脆弱性を修正
+
+**機能**
+
+- [ ] [79](https://github.com/sipeed/NanoKVM/issues/79) Zerotier をサポート
+- [ ] [99](https://github.com/sipeed/NanoKVM/issues/99) WireGuard をサポート
+- [ ] [249](https://github.com/sipeed/NanoKVM/issues/249) Mouse Jiggler を追加
+
 ## 購入方法
 
 * [Aliexpress(グローバル、米国とロシアを除く)](https://www.aliexpress.com/item/1005007369816019.html)

README_ZH.md

@@ -6,8 +6,9 @@ NanoKVM
 ![](https://wiki.sipeed.com/hardware/assets/NanoKVM/introduce/NanoKVM_3.png)
 
 <h3>
-    <a href="https://wiki.sipeed.com/hardware/zh/lichee/RV_Nano/1_intro.html"> 快速开始 </a> |
-    <a href="https://cn.dl.sipeed.com/shareURL/KVM/nanoKVM"> 硬件资料 </a>
+    <a href="https://wiki.sipeed.com/hardware/en/kvm/NanoKVM/introduction.html"> Quick Start </a>
+    |
+    <a href="https://cn.dl.sipeed.com/shareURL/KVM/nanoKVM"> Hardware </a>
 </h3>
 
 [English](./README.md) | 中文 | [日本語](./README_JA.md)
@@ -17,15 +18,46 @@ NanoKVM
 > Your NanoKVM Power by RISC-V !
 > 如果您在使用过程中有任何问题或建议，请在这里提交 issue， 或在 [MaixHub Discussion](https://maixhub.com/discussion/nanokvm)告诉我们.
 
-
 ## 简介
 
 Lichee NanoKVM 是基于 LicheeRV Nano 的 IP-KVM 产品，继承了 LicheeRV Nano的极致体积 和 强大功能。
-Lichee NanoKVM分为两个版本：
-NanoKVM Lite 为基础版配置，适合 具有一定DIY能力的个人用户 和 有批量需求的企业用户。
-NanoKVM Full 为完整版配置，带精致外壳和完整配件，内置开机即用的系统镜像卡，推荐个人用户购买。
 
-![](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_1.jpg)
+Lichee NanoKVM 目前有三个版本：
+
+* NanoKVM-Cube Lite 为基础版配置，适合 具有一定DIY能力的个人用户 和 有批量需求的企业用户。
+* NanoKVM-Cube Full 为完整版配置，带精致外壳和完整配件，内置开机即用的系统镜像卡，推荐个人用户购买。
+* NanoKVM-PCle 为全新形态，内置 PCle 挡板，可固定在机箱内部。NanoKVM-PCle 在 NanoKVM-Cube 基础上增加了可选的 WiFi 和 PoE 功能；拥有自家的 PCle 插槽，可从主板 PCle 插槽取电；另外有线连接（ETH）也更加稳定，满足更多专业需求。
+
+<div align="center">
+
+![NanoKVM-Cube](https://wiki.sipeed.com/hardware/zh/kvm/assets/NanoKVM/1_intro/NanoKVM_1.jpg)
+
+![NanoKVM-PCIe](https://wiki.sipeed.com/hardware/assets/NanoKVM/introduce/NanoKVM-PCIe.png)
+
+</div>
+
+> 对于关注安全的用户，可以阅读此问题 [#301](https://github.com/sipeed/NanoKVM/issues/301)，您会找到有关所有安全问题的解释。GitHub 作为一个开放和透明的平台，为讨论所谓的“后门”担忧提供了空间。开源使产品更加安全！
+
+## 项目结构
+
+``` shell
+├── kvmapp          # APP更新包
+│   ├── jpg_stream  # 兼容从非常老的版本中直接更新
+│   ├── kvm_new_app # 触发 kvm_system 更新必要组件
+│   ├── kvm_system  # kvm_system 应用
+│   ├── server      # NanoKVM 前后端应用
+│   └── system      # 必要系统组件
+├── server          # NanoKVM 后端
+├── support         # 辅助功能(图像子系统、系统状态、系统更新、屏幕、按键……)
+│   ├── sg2002      # NanoKVM-Lite/Full/PCIe
+│   └── h618        # NanoKVM-Pro
+├── web             # NanoKVM 前端
+├── LICENSE
+├── README_JA.md
+├── README.md
+├── README_ZH.md
+└── CHANGELOG.md
+```
 
 ## 参数
 
@@ -63,10 +95,9 @@ NanoKVM 镜像在LicheeRV Nano SDK 和 MaixCDK 基础上构建，可以兼容使
 
 注: SG2002的256MB内存中, 目前划分105MB用于多媒体子系统, NanoKVM会在视频图像采集和处理中使用这部分内存.
 
-+ [NanoKVM-A 原理图](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_RV_Nano_KVM_A_30111.pdf)
-+ [NanoKVM-B 原理图](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_HDMI_MIPI_31011.pdf)
-+ [NanoKVM 镜像下载](https://github.com/sipeed/NanoKVM/releases/tag/NanoKVM)
-
+* [NanoKVM-A 原理图](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_RV_Nano_KVM_A_30111.pdf)
+* [NanoKVM-B 原理图](https://cn.dl.sipeed.com/fileList/KVM/nanoKVM/HDK/02_Schematic/SCH_HDMI_MIPI_31011.pdf)
+* [NanoKVM 镜像下载](https://github.com/sipeed/NanoKVM/releases/tag/NanoKVM)
 
 ## 购买渠道
 

kvmapp/jpg_stream/S95nanokvm

@@ -0,0 +1,91 @@
+#!/bin/sh
+# nanokvm Rev2.1
+
+case "$1" in
+  start)
+    echo -n kvm > /boot/hostname.prefix
+    cp /mnt/data/sensor_cfg.ini.LT /mnt/data/sensor_cfg.ini
+
+    str_value=$(cat /sys/class/cvi-base/base_uid | awk '{print $2}')
+    first_uint=$(echo $str_value | cut -d'_' -f1)
+    second_uint=$(echo $str_value | cut -d'_' -f2)
+    result="$first_uint$second_uint"
+    echo $result > /device_key
+
+    # if [ ! -e /etc/kvm/hw ]
+    # then
+
+    # fi
+
+    # echo 504 > /sys/class/gpio/export   # pwr led
+    # echo 505 > /sys/class/gpio/export   # hdd led
+    # echo 503 > /sys/class/gpio/export   # pwr key
+    # echo 507 > /sys/class/gpio/export   # rst key
+
+    # echo in > /sys/class/gpio/gpio504/direction     # pwr led
+    # echo in > /sys/class/gpio/gpio505/direction     # hdd led
+    # echo out > /sys/class/gpio/gpio503/direction    # pwr key
+    # echo out > /sys/class/gpio/gpio507/direction    # rst key
+
+    iptables -A INPUT -i eth0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
+    iptables -A OUTPUT -o eth0 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
+    iptables -A OUTPUT -o eth0 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
+    iptables -A INPUT -i eth0 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
+    iptables -A OUTPUT -o eth0 -p tcp --sport 8000 -m state --state ESTABLISHED -j DROP
+
+    cp -r /kvmapp/kvm_system /tmp/
+    /tmp/kvm_system/kvm_system &
+
+    # if [ -e /kvmapp/kvm_stream ]
+    # then
+    #   cp -r /kvmapp/kvm_stream /tmp/
+    #   /tmp/kvm_stream/kvm_stream &
+    # fi
+    
+    cp -r /kvmapp/server /tmp/
+    /tmp/server/NanoKVM-Server &
+  ;;
+  stop)
+    killall kvm_system
+    # killall kvm_stream
+    killall NanoKVM-Server
+    rm -r /tmp/kvm_system
+    # rm -r /tmp/kvm_stream
+    rm -r /tmp/server
+    echo "OK"
+  ;;
+  # restart_stream)
+  #   killall kvm_stream
+  #   rm -r /tmp/kvm_stream
+  #   if [ -e /kvmapp/kvm_stream ]
+  #   then
+  #     cp -r /kvmapp/kvm_stream /tmp/
+  #     /tmp/kvm_stream/kvm_stream &
+  #     echo "OK"
+  #   fi
+  # ;;
+  restart)
+    killall kvm_system
+    # killall kvm_stream
+    killall NanoKVM-Server
+    rm -r /tmp/kvm_system
+    # rm -r /tmp/kvm_stream
+    rm -r /tmp/server
+    
+    cp -r /kvmapp/kvm_system /tmp/
+    /tmp/kvm_system/kvm_system &
+
+    # if [ -e /kvmapp/kvm_stream ]
+    # then
+    #   cp -r /kvmapp/kvm_stream /tmp/
+    #   /tmp/kvm_stream/kvm_stream &
+    # fi
+    
+    cp -r /kvmapp/server /tmp/
+    /tmp/server/NanoKVM-Server &
+
+    sync
+
+    echo "OK"
+  ;;
+esac

kvmapp/jpg_stream/jpg_stream

@@ -0,0 +1,5 @@
+rm /etc/init.d/S95webkvm
+cp /kvmapp/jpg_stream/S95nanokvm /etc/init.d/
+cp /kvmapp/jpg_stream/dl_lib/libmaixcam_lib.so /kvmapp/kvm_system/dl_lib
+rm -r /kvmapp/jpg_stream
+/etc/init.d/S95nanokvm restart

kvmapp/system/init.d/S00kmod

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+if [ "$1" = "start" ]
+then
+	. /etc/profile
+	printf "load kernel module: "
+	cd /mnt/system/ko/
+	insmod soph_sys.ko
+	insmod soph_base.ko
+	insmod soph_rtos_cmdqu.ko
+	insmod soph_fast_image.ko
+	insmod soph_mipi_rx.ko
+	insmod soph_snsr_i2c.ko
+	insmod soph_vi.ko
+	insmod soph_vpss.ko
+	insmod soph_dwa.ko
+	insmod soph_vo.ko
+	insmod soph_rgn.ko
+	insmod soph_wdt.ko
+	insmod soph_clock_cooling.ko
+	insmod soph_tpu.ko
+	insmod soph_vcodec.ko
+	insmod soph_jpeg.ko
+	insmod soph_vc_driver.ko MaxVencChnNum=9 MaxVdecChnNum=9
+	insmod soph_rtc.ko
+	insmod soph_ive.ko
+	insmod soph_mon.ko
+	insmod soph_pwm.ko
+	insmod soph_wiegand.ko
+	echo "OK"
+	exit 0
+fi

kvmapp/system/init.d/S01fs

@@ -0,0 +1,42 @@
+#!/bin/sh
+
+if [ "$1" = "start" ]
+then
+                # use all sdcard free space for data
+                parted -s /dev/mmcblk0 "resizepart 2 -0"
+                echo "yes
+                8192MB
+                " | parted ---pretend-input-tty /dev/mmcblk0 "resizepart 2 8192MB"
+                # resize data filesystem
+                (resize2fs /dev/mmcblk0p2) &
+
+
+        . /etc/profile
+        printf "mounting filesystem : "
+        mkdir -p /boot
+        mount -t vfat /dev/mmcblk0p1 /boot
+        mount -t configfs configfs /sys/kernel/config
+        mount -t debugfs debugfs /sys/kernel/debug
+
+        if [ -e /boot/usb.disk0 ]
+        then
+                if [ ! -e /etc/kvm.disk0 ]
+                then
+                        touch /etc/kvm.disk0
+                        # use all sdcard free space for data
+                        parted -s /dev/mmcblk0 "mkpart primary 8193MB 100%"
+                        sleep 1
+                        # resize data filesystem
+                        (mkfs.exfat /dev/mmcblk0p3) &
+                        sleep 1
+                fi
+        fi
+
+        if [ -e /dev/mmcblk0p3 ]
+        then
+                mkdir -p /data
+                mount /dev/mmcblk0p3 /data
+        fi
+
+        echo "OK"
+fi

kvmapp/system/init.d/S03usbdev

@@ -0,0 +1,139 @@
+#!/bin/sh
+# kvmhwd Rev2.1
+
+start_usb_dev(){
+    . /etc/profile
+    echo "usb mode: device"
+    cd /sys/kernel/config/usb_gadget
+
+    mkdir g0
+    cd g0
+
+    echo 0x3346 > idVendor
+    echo 0x1009 > idProduct
+    mkdir strings/0x409
+    echo '0123456789ABCDEF' > strings/0x409/serialnumber
+    echo 'sipeed' > strings/0x409/manufacturer
+    echo 'NanoKVM' > strings/0x409/product
+
+    mkdir configs/c.1
+    echo 0xE0 > configs/c.1/bmAttributes
+    echo 120 > configs/c.1/MaxPower
+    mkdir configs/c.1/strings/0x409
+    echo "NanoKVM" >  configs/c.1/strings/0x409/configuration
+
+    if [ -e /boot/usb.ncm ]
+    then
+        mkdir functions/ncm.usb0
+        ln -s functions/ncm.usb0 configs/c.1/
+    else
+        if [ -e /boot/usb.rndis0 ]
+        then
+                mkdir functions/rndis.usb0
+                ln -s functions/rndis.usb0 configs/c.1/
+        fi
+    fi
+
+    if [ ! -e /boot/disable_hid ]
+    then
+        # keyboard
+        mkdir functions/hid.GS0
+        if [ -e /boot/BIOS ]
+        then
+            echo 1 > functions/hid.GS0/subclass
+        fi
+        if [ ! -e /boot/usb.notwakeup ]
+        then
+            echo 1 > functions/hid.GS0/wakeup_on_write
+        fi
+        echo 1 > functions/hid.GS0/protocol
+        echo 8 > functions/hid.GS0/report_length
+        echo -ne \\x05\\x01\\x09\\x06\\xa1\\x01\\x05\\x07\\x19\\xe0\\x29\\xe7\\x15\\x00\\x25\\x01\\x75\\x01\\x95\\x08\\x81\\x02\\x95\\x01\\x75\\x08\\x81\\x03\\x95\\x05\\x75\\x01\\x05\\x08\\x19\\x01\\x29\\x05\\x91\\x02\\x95\\x01\\x75\\x03\\x91\\x03\\x95\\x06\\x75\\x08\\x15\\x00\\x25\\x65\\x05\\x07\\x19\\x00\\x29\\x65\\x81\\x00\\xc0 > functions/hid.GS0/report_desc
+        ln -s functions/hid.GS0 configs/c.1
+
+        # mouse
+        mkdir functions/hid.GS1
+        if [ -e /boot/BIOS ]
+        then
+            echo 1 > functions/hid.GS1/subclass
+        fi
+        if [ ! -e /boot/usb.notwakeup ]
+        then
+            echo 1 > functions/hid.GS1/wakeup_on_write
+        fi
+        echo 2 > functions/hid.GS1/protocol
+        echo 4 > functions/hid.GS1/report_length
+        echo -ne \\x5\\x1\\x9\\x2\\xa1\\x1\\x9\\x1\\xa1\\x0\\x5\\x9\\x19\\x1\\x29\\x3\\x15\\x0\\x25\\x1\\x95\\x3\\x75\\x1\\x81\\x2\\x95\\x1\\x75\\x5\\x81\\x3\\x5\\x1\\x9\\x30\\x9\\x31\\x9\\x38\\x15\\x81\\x25\\x7f\\x75\\x8\\x95\\x3\\x81\\x6\\xc0\\xc0 > functions/hid.GS1/report_desc        
+        ln -s functions/hid.GS1 configs/c.1
+
+        # touchpad
+        mkdir functions/hid.GS2
+        if [ -e /boot/BIOS ]
+        then
+            echo 1 > functions/hid.GS2/subclass
+        fi
+        if [ ! -e /boot/usb.notwakeup ]
+        then
+            echo 1 > functions/hid.GS2/wakeup_on_write
+        fi
+        echo 2 > functions/hid.GS2/protocol
+        echo 6 > functions/hid.GS2/report_length
+        echo -ne \\x05\\x01\\x09\\x02\\xa1\\x01\\x09\\x01\\xa1\\x00\\x05\\x09\\x19\\x01\\x29\\x03\\x15\\x00\\x25\\x01\\x95\\x03\\x75\\x01\\x81\\x02\\x95\\x01\\x75\\x05\\x81\\x01\\x05\\x01\\x09\\x30\\x09\\x31\\x15\\x00\\x26\\xff\\x7f\\x35\\x00\\x46\\xff\\x7f\\x75\\x10\\x95\\x02\\x81\\x02\\x05\\x01\\x09\\x38\\x15\\x81\\x25\\x7f\\x35\\x00\\x45\\x00\\x75\\x08\\x95\\x01\\x81\\x06\\xc0\\xc0 > functions/hid.GS2/report_desc
+        ln -s functions/hid.GS2 configs/c.1
+    fi
+
+    if [ -e /boot/usb.disk0 ]
+    then
+            mkdir functions/mass_storage.disk0
+            ln -s functions/mass_storage.disk0 configs/c.1/
+            echo 1 > functions/mass_storage.disk0/lun.0/removable
+            if [ -e /boot/usb.disk0.ro ]
+            then
+                    echo 1 > functions/mass_storage.disk0/lun.0/ro
+                    echo 0 > functions/mass_storage.disk0/lun.0/cdrom
+            fi
+            disk=$(cat /boot/usb.disk0)
+            if [ -z "${disk}" ]
+            then
+                    # if [ ! -e /mnt/usbdisk.img ]
+                    # then
+                    #         fallocate -l 8G /mnt/usbdisk.img
+                    #         mkfs.vfat /mnt/usbdisk.img
+                    # fi
+                    echo /dev/mmcblk0p3 > functions/mass_storage.disk0/lun.0/file
+            else
+                    cat /boot/usb.disk0 > functions/mass_storage.disk0/lun.0/file
+            fi
+    fi
+
+    ls /sys/class/udc/ | cat > UDC
+    echo device > /proc/cviusb/otg_role
+}
+
+start_usb_host(){
+    echo '' > /sys/kernel/config/usb_gadget/g0/UDC
+    echo host > /proc/cviusb/otg_role
+}
+
+restart_usb_dev(){
+    echo > /sys/kernel/config/usb_gadget/g0/UDC
+    sleep 1
+    ls /sys/class/udc/ | cat > /sys/kernel/config/usb_gadget/g0/UDC
+    echo "USB Restart OK!"
+}
+
+case "$1" in
+  start)
+    start_usb_dev
+  ;;
+  restart)
+    restart_usb_dev
+  ;;
+  stop)
+    start_usb_host
+  ;;
+  stop_start)
+    start_usb_host
+    start_usb_dev
+  ;;
+esac

kvmapp/system/init.d/S03usbhid

@@ -0,0 +1,93 @@
+#!/bin/sh
+# kvmhwd hid only
+
+start_usb_dev(){
+    . /etc/profile
+    echo "usb mode: device"
+    cd /sys/kernel/config/usb_gadget
+
+    mkdir g0
+    cd g0
+
+    echo 0x0101 > bcdUSB
+    echo 0x0623 > bcdDevice
+    echo 0x3346 > idVendor
+    echo 0x1009 > idProduct
+    mkdir strings/0x409
+    # echo '0' > strings/0x409/serialnumber
+    echo 'sipeed' > strings/0x409/manufacturer
+    echo 'NanoKVM' > strings/0x409/product
+
+    mkdir configs/c.1
+    echo 0xA0 > configs/c.1/bmAttributes
+    echo 200 > configs/c.1/MaxPower
+    mkdir configs/c.1/strings/0x409
+    echo "NanoKVM" >  configs/c.1/strings/0x409/configuration
+
+    # keyboard
+    mkdir functions/hid.GS0
+    echo 1 > functions/hid.GS0/subclass
+    if [ ! -e /boot/usb.notwakeup ]
+    then
+        echo 1 > functions/hid.GS0/wakeup_on_write
+    fi
+    echo 1 > functions/hid.GS0/protocol
+    echo 8 > functions/hid.GS0/report_length
+    echo -ne \\x05\\x01\\x09\\x06\\xa1\\x01\\x05\\x07\\x19\\xe0\\x29\\xe7\\x15\\x00\\x25\\x01\\x75\\x01\\x95\\x08\\x81\\x02\\x95\\x01\\x75\\x08\\x81\\x03\\x95\\x05\\x75\\x01\\x05\\x08\\x19\\x01\\x29\\x05\\x91\\x02\\x95\\x01\\x75\\x03\\x91\\x03\\x95\\x06\\x75\\x08\\x15\\x00\\x25\\x65\\x05\\x07\\x19\\x00\\x29\\x65\\x81\\x00\\xc0 > functions/hid.GS0/report_desc
+    ln -s functions/hid.GS0 configs/c.1
+
+    # mouse
+    mkdir functions/hid.GS1
+    echo 1 > functions/hid.GS1/subclass
+    if [ ! -e /boot/usb.notwakeup ]
+    then
+        echo 1 > functions/hid.GS1/wakeup_on_write
+    fi
+    echo 2 > functions/hid.GS1/protocol
+    echo 4 > functions/hid.GS1/report_length
+    echo -ne \\x5\\x1\\x9\\x2\\xa1\\x1\\x9\\x1\\xa1\\x0\\x5\\x9\\x19\\x1\\x29\\x3\\x15\\x0\\x25\\x1\\x95\\x3\\x75\\x1\\x81\\x2\\x95\\x1\\x75\\x5\\x81\\x3\\x5\\x1\\x9\\x30\\x9\\x31\\x9\\x38\\x15\\x81\\x25\\x7f\\x75\\x8\\x95\\x3\\x81\\x6\\xc0\\xc0 > functions/hid.GS1/report_desc        
+    ln -s functions/hid.GS1 configs/c.1
+
+    # touchpad
+    mkdir functions/hid.GS2
+    echo 1 > functions/hid.GS2/subclass
+    if [ ! -e /boot/usb.notwakeup ]
+    then
+        echo 1 > functions/hid.GS2/wakeup_on_write
+    fi
+    echo 2 > functions/hid.GS2/protocol
+    echo 6 > functions/hid.GS2/report_length
+    echo -ne \\x05\\x01\\x09\\x02\\xa1\\x01\\x09\\x01\\xa1\\x00\\x05\\x09\\x19\\x01\\x29\\x03\\x15\\x00\\x25\\x01\\x95\\x03\\x75\\x01\\x81\\x02\\x95\\x01\\x75\\x05\\x81\\x01\\x05\\x01\\x09\\x30\\x09\\x31\\x15\\x00\\x26\\xff\\x7f\\x35\\x00\\x46\\xff\\x7f\\x75\\x10\\x95\\x02\\x81\\x02\\x05\\x01\\x09\\x38\\x15\\x81\\x25\\x7f\\x35\\x00\\x45\\x00\\x75\\x08\\x95\\x01\\x81\\x06\\xc0\\xc0 > functions/hid.GS2/report_desc
+    ln -s functions/hid.GS2 configs/c.1
+
+    ls /sys/class/udc/ | cat > UDC
+    echo device > /proc/cviusb/otg_role
+}
+
+start_usb_host(){
+    echo '' > /sys/kernel/config/usb_gadget/g0/UDC
+    echo host > /proc/cviusb/otg_role
+}
+
+restart_usb_dev(){
+    echo > /sys/kernel/config/usb_gadget/g0/UDC
+    sleep 1
+    ls /sys/class/udc/ | cat > /sys/kernel/config/usb_gadget/g0/UDC
+    echo "USB Restart OK!"
+}
+
+case "$1" in
+  start)
+    start_usb_dev
+  ;;
+  restart)
+    restart_usb_dev
+  ;;
+  stop)
+    start_usb_host
+  ;;
+  stop_start)
+    start_usb_host
+    start_usb_dev
+  ;;
+esac

kvmapp/system/init.d/S15kvmhwd

@@ -0,0 +1,234 @@
+#!/bin/sh
+# kvmhwd Rev2.4
+
+Alpha_OLED_RST_Pin=371
+Beta_OLED_RST_Pin=502
+Beta_OLED_SCL=595
+Beta_OLED_SDA=507
+WiFi_EN_Pin=506
+Alpha_PWR_LED_Pin=504
+Alpha_HDD_LED_Pin=505
+Alpha_PWR_KEY_Pin=503
+Alpha_RST_KEY_Pin=507
+Beta_PWR_LED_Pin=504
+Beta_PWR_KEY_Pin=503
+Beta_RST_KEY_Pin=505
+PCIe_HDMI_RST_Pin=451
+
+init_alpha_hw(){
+  devmem 0x030010D0 32 0x2  # I2C1_SCL
+  devmem 0x030010DC 32 0x2  # I2C1_SDA
+  devmem 0x030010D4 32 0x3  # OLED_RST
+  devmem 0x0300103C 32 0x3  # GPIOA15
+  devmem 0x03001050 32 0x3  # GPIOA22
+  devmem 0x0300105C 32 0x3  # GPIOA23
+  devmem 0x03001060 32 0x3  # GPIOA24
+  devmem 0x03001054 32 0x3  # GPIOA25
+  devmem 0x03001058 32 0x3  # GPIOA27
+  
+	devmem 0x03001068 32 0x6  # GPIOA 18 UART1 RX
+	devmem 0x03001064 32 0x6  # GPIOA 19 UART1 TX
+	devmem 0x03001070 32 0x2  # GPIOA 28 UART2 TX
+	devmem 0x03001074 32 0x2  # GPIOA 29 UART2 RX
+
+  echo ${Alpha_OLED_RST_Pin} > /sys/class/gpio/export  # OLED_RST
+  echo out > /sys/class/gpio/gpio${Alpha_OLED_RST_Pin}/direction
+  echo 1 > /sys/class/gpio/gpio${Alpha_OLED_RST_Pin}/value
+
+  echo ${Alpha_PWR_LED_Pin} > /sys/class/gpio/export   # pwr led
+  echo ${Alpha_HDD_LED_Pin} > /sys/class/gpio/export   # hdd led
+  echo ${Alpha_PWR_KEY_Pin} > /sys/class/gpio/export   # pwr key
+  echo ${Alpha_RST_KEY_Pin} > /sys/class/gpio/export   # rst key
+
+  echo in > /sys/class/gpio/gpio${Alpha_PWR_LED_Pin}/direction     # pwr led
+  echo in > /sys/class/gpio/gpio${Alpha_HDD_LED_Pin}/direction     # hdd led
+  echo out > /sys/class/gpio/gpio${Alpha_PWR_KEY_Pin}/direction    # pwr key
+  echo out > /sys/class/gpio/gpio${Alpha_RST_KEY_Pin}/direction    # rst key
+
+  rmmod /mnt/system/ko/i2c-gpio.ko
+  rmmod /mnt/system/ko/i2c-algo-bit.ko
+
+  # rm /etc/init.d/S25wifimod
+  # rm /etc/init.d/S30wifi
+}
+
+init_beta_pcie_hw(){
+  devmem 0x0300103C 32 0x3  # GPIOA15
+  devmem 0x03001050 32 0x3  # GPIOA22
+  devmem 0x0300105C 32 0x3  # GPIOA23
+  devmem 0x03001060 32 0x3  # GPIOA24
+  devmem 0x03001054 32 0x3  # GPIOA25
+  devmem 0x03001058 32 0x3  # GPIOA27
+
+  devmem 0x030010E4 32 0x0  # SDIO CLK
+  devmem 0x030010E0 32 0x0  # SDIO CMD
+  devmem 0x030010DC 32 0x0  # SDIO D0
+  devmem 0x030010D8 32 0x0  # SDIO D1
+  devmem 0x030010D4 32 0x0  # SDIO D2
+  devmem 0x030010D0 32 0x0  # SDIO D3
+
+	devmem 0x03001068 32 0x6  # GPIOA 18 UART1 RX
+	devmem 0x03001064 32 0x6  # GPIOA 19 UART1 TX
+	devmem 0x03001070 32 0x2  # GPIOA 28 UART2 TX
+	devmem 0x03001074 32 0x2  # GPIOA 29 UART2 RX
+
+  echo ${Beta_OLED_RST_Pin} > /sys/class/gpio/export  # Beta OLED_RST
+  echo out > /sys/class/gpio/gpio${Beta_OLED_RST_Pin}/direction
+  echo 1 > /sys/class/gpio/gpio${Beta_OLED_RST_Pin}/value
+
+  echo ${Beta_PWR_LED_Pin} > /sys/class/gpio/export   # pwr led
+  echo ${Beta_PWR_KEY_Pin} > /sys/class/gpio/export   # pwr key
+  echo ${Beta_RST_KEY_Pin} > /sys/class/gpio/export   # rst key
+  echo ${PCIe_HDMI_RST_Pin} > /sys/class/gpio/export   # hdmi rst key
+
+  echo in > /sys/class/gpio/gpio${Beta_PWR_LED_Pin}/direction     # pwr led
+  echo out > /sys/class/gpio/gpio${Beta_PWR_KEY_Pin}/direction    # pwr key
+  echo out > /sys/class/gpio/gpio${Beta_RST_KEY_Pin}/direction    # rst key
+  echo out > /sys/class/gpio/gpio${PCIe_HDMI_RST_Pin}/direction    # rst key
+
+  echo 1 > /sys/class/gpio/gpio${PCIe_HDMI_RST_Pin}/value    # rst key
+
+  rmmod /mnt/system/ko/i2c-gpio.ko
+  rmmod /mnt/system/ko/i2c-algo-bit.ko
+  insmod /mnt/system/ko/i2c-algo-bit.ko
+  insmod /mnt/system/ko/i2c-gpio.ko
+}
+
+kvm_hw_detect(){
+  if [ ! -e /etc/kvm/hdmi_version ]
+  then
+    rm /etc/kvm/hw
+  fi
+  if [ -e /etc/kvm/hw ]
+  then
+    echo "/etc/kvm/hw exist"
+  else
+    echo "/etc/kvm/hw not exist"
+    if [ -d "/etc/kvm/" ]
+    then
+      echo "/etc/kvm/ exist"
+    else
+      mkdir /etc/kvm/
+    fi
+    devmem 0x0300104C 32 0x3  # GPIOA26 / WiFi_EN
+    echo ${WiFi_EN_Pin} > /sys/class/gpio/export  # WiFi_EN
+    echo out > /sys/class/gpio/gpio${WiFi_EN_Pin}/direction
+    echo 0 > /sys/class/gpio/gpio${WiFi_EN_Pin}/value
+
+    devmem 0x0300103C 32 0x3  # GPIOA15
+    devmem 0x03001050 32 0x3  # GPIOA22
+    devmem 0x0300105C 32 0x3  # GPIOA23
+    devmem 0x03001060 32 0x3  # GPIOA24
+    devmem 0x03001054 32 0x3  # GPIOA25
+    devmem 0x03001058 32 0x3  # GPIOA27
+
+    devmem 0x030010D0 32 0x2  # I2C1_SCL
+    devmem 0x030010DC 32 0x2  # I2C1_SDA
+    devmem 0x030010D4 32 0x3  # OLED_RST
+    echo ${Alpha_OLED_RST_Pin} > /sys/class/gpio/export  # OLED_RST
+    echo out > /sys/class/gpio/gpio${Alpha_OLED_RST_Pin}/direction
+    echo 1 > /sys/class/gpio/gpio${Alpha_OLED_RST_Pin}/value
+
+    kvm_tmp=$(i2cdetect -ry 1 0x3d 0x3d | grep 3d)
+    if [ -n "$kvm_tmp" ]
+    then
+      # alpha hw
+      echo "alpha" > /etc/kvm/hw
+    else
+      # beta/pcie hw
+      echo ${Alpha_OLED_RST_Pin} > /sys/class/gpio/unexport  # OLED_RST
+      echo ${Beta_OLED_RST_Pin} > /sys/class/gpio/export  # Beta_OLED_RST_Pin
+      echo out > /sys/class/gpio/gpio${Beta_OLED_RST_Pin}/direction
+      echo 1 > /sys/class/gpio/gpio${Beta_OLED_RST_Pin}/value
+
+      rmmod /mnt/system/ko/i2c-gpio.ko
+      rmmod /mnt/system/ko/i2c-algo-bit.ko
+      insmod /mnt/system/ko/i2c-algo-bit.ko
+      insmod /mnt/system/ko/i2c-gpio.ko
+
+      kvm_tmp=$(i2cdetect -ry 4 0x2c 0x2c | grep 2c)
+      if [ -n "$kvm_tmp" ]
+      then
+        echo "c" > /etc/kvm/hdmi_version
+      else
+        kvm_tmp1=$(i2cdetect -ry 4 0x2b 0x2b | grep 2b)
+        if [ -n "$kvm_tmp1" ]
+        then
+          echo "ux" > /etc/kvm/hdmi_version
+        else
+          echo "ue" > /etc/kvm/hdmi_version
+        fi
+      fi
+
+      kvm_tmp=$(i2cdetect -ry 5 0x3c 0x3c | grep 3c)
+      if [ -n "$kvm_tmp" ]
+      then
+        echo "pcie" > /etc/kvm/hw
+        sync
+        reboot
+      else
+        echo "beta" > /etc/kvm/hw
+        # rm /etc/init.d/S25wifimod
+        # rm /etc/init.d/S30wifi
+        sync
+      fi
+
+      echo 1 > /sys/class/gpio/gpio${WiFi_EN_Pin}/value
+      echo ${WiFi_EN_Pin} > /sys/class/gpio/unexport  # WiFi_EN
+    fi
+  fi
+  sync
+}
+
+kvm_hw_init(){
+    FIND_FILE="/etc/kvm/hw"
+    if [ `grep -c "alpha" $FIND_FILE` -ne '0' ]
+    then
+        echo "hw = alpha!"
+        init_alpha_hw
+    fi
+    if [ `grep -c "beta" $FIND_FILE` -ne '0' ]
+    then
+        echo "hw = beta!"
+        init_beta_pcie_hw
+    fi
+    if [ `grep -c "pcie" $FIND_FILE` -ne '0' ]
+    then
+        echo "hw = pcie!"
+        init_beta_pcie_hw
+    fi
+}
+
+kvm_hdmi_version_detect(){
+  hdmi_tmp=$(i2cdetect -ry 4 0x2c 0x2c | grep 2c)
+  if [ -n "$hdmi_tmp" ]
+  then
+    echo "c" > /etc/kvm/hdmi_version
+  else
+    hdmi_tmp1=$(i2cdetect -ry 4 0x2b 0x2b | grep 2b)
+    if [ -n "$hdmi_tmp1" ]
+    then
+      echo "ux" > /etc/kvm/hdmi_version
+    else
+      echo "ue" > /etc/kvm/hdmi_version
+    fi
+  fi
+}
+
+case "$1" in
+  start)
+    kvm_hw_detect
+    kvm_hw_init
+  ;;
+  re-detect)
+    rm /etc/kvm/hw
+    kvm_hw_detect
+    kvm_hw_init
+  ;;
+  re-init)
+    kvm_hw_init
+  ;;
+  get_hdmi_version)
+    kvm_hdmi_version_detect
+  ;;
+esac

kvmapp/system/init.d/S30eth

@@ -0,0 +1,119 @@
+#!/bin/sh
+
+. /etc/profile
+
+# /boot/eth.nodhcp for example
+# ipaddr/net        gw[optional]
+# 192.168.0.101/24 192.168.0.1
+# 192.168.3.116/22  
+
+RESERVE_INET="192.168.0.1/24"
+
+start() {
+    printf "start ethernet: "
+    if [ -e /boot/eth.nodhcp ] 
+    then
+        [ -e /boot/eth.nodhcp ] &&
+            cat /boot/eth.nodhcp | while read inet gw
+            do
+                addr=${inet%/*}
+                netid=${inet#*/}
+                [ -z $gw ] &&
+                gw=$( echo $addr| ( IFS='.' read a b c d; echo $((
+                    (((((($a<<8)+$b)<<8)+$c)<<8)+$d)
+                        & (((1<<$netid)-1)<<(32-$netid))
+                    ))
+                )) &&
+                gw=$(($gw>>24&0xff)).$(($gw>>16&0xff)).$(($gw>>8&0xff)).$((1+( $gw>>0&0xff )))
+
+                arping -Dqc2 -Ieth0 $addr || continue
+                ip a add $inet brd + dev eth0
+                ip r add default via $gw dev eth0
+                cp -f /etc/resolv.conf /etc/resolv.conf.old
+                cat > /etc/resolv.conf << EOF
+nameserver $gw
+nameserver 8.8.4.4
+nameserver 8.8.8.8
+nameserver 114.114.114.114
+nameserver 119.29.29.29
+nameserver 223.5.5.5
+EOF
+                break
+            done &&
+            ip a show dev eth0|grep inet || (
+                udhcpc -i eth0 -t 3 -T 1 -A 5 -b -p /run/udhcpc.eth0.pid &>/dev/null
+                ip a show dev eth0|grep inet
+            ) || (
+                # failed to apply dynamic addr, need a available static addr to visit the LAN 
+                inet=$RESERVE_INET
+                addr=${inet%/*}
+                ip a add $inet brd + dev eth0
+            ) || exit 1
+    else
+        (udhcpc -i eth0 -t 10 -T 1 -A 5 -b -p /run/udhcpc.eth0.pid) &
+    fi
+
+    echo "OK"
+}
+stop() {
+    [[ ! -e "/run/udhcpc.eth0.pid" ]] && echo "udhcpc is not running..." && exit 1
+    kill `cat /run/udhcpc.eth0.pid`
+    rm /run/udhcpc.eth0.pid
+}
+
+case "$1" in
+        start)
+                start
+                ;;
+        stop)
+                stop
+                ;;
+        restart|reload)
+                $0 stop
+                $0 start
+                ;;
+        doc)
+                cat <<EOF
+If you want to set your own static ip address
+    rather then fetch it by dhcp.
+Then you need to create a file \`/boot/eth.nodhcp\`,
+    and edit it following the format below:
+    \`addr/netid        gw[optional]\` in one line
+    for example (support muti definations, checks with arp):
+    1. 192.168.0.101/24 192.168.0.1
+    2. 192.168.3.116/22
+Delete this file if you change to use dhcp default.
+ATTENTION: If all the STATIC address you set in the file is
+    already in use on this LAN checked with arp, then none
+    of them will be yours. And it will trigger dhcp, try to 
+    fetch DYNAMIC one. If it's also failed, your address will 
+    be the REVERSE one, 192.168.0.1/24. Just to be sure that
+    you can visit your NanoKVM device through eth to fix some
+    problems by ssh, unless you must disassemble it and modify
+    or rewrite the TFCard once again.
+EOF
+                echo ""
+                cat <<EOF
+如果您想自行设置静态 ip 地址而不是使用 dhcp 来获取它。
+
+那么您需要新建一个文件 \`/boot/eth.nodhcp\`，然后按照以下格式编辑它：
+    \`addr/netid        gw[optional]\` 在一行内
+示例（支持多个预设，会通过 arp 检查是否占用）：
+    1. 192.168.0.101/24 192.168.0.1
+    2. 192.168.3.116/22
+
+如果您想改回默认 dhcp 获取 ip 地址的方式，删除该文件后即可恢复。
+
+注意：如果您预设的所有静态 ip 地址都被 arp 检测到已占用，则不会成功设置。
+    此时会触发 dhcp 尝试获取 ip 地址，如果仍失败，那么最终会强制设置成
+    192.168.90.1/24。这是为了保证您的 NanoKVM 设备总是能有一个可用的
+    ip 地址，方便您通过局域网 ssh 连接设备进行一些修复，否则您可能需要
+    拆开外壳以手动修改 TF 卡或重新烧卡。
+
+
+EOF
+                ;;
+        *)
+                echo "Usage: $0 {start|stop|restart}"
+                exit 1
+esac

kvmapp/system/init.d/S30wifi

@@ -0,0 +1,175 @@
+#!/bin/sh
+
+. /etc/profile
+
+gen_hostapd_conf() {
+	ssid="${1}"
+	pass="${2}"
+	echo "ctrl_interface=/var/run/hostapd"
+	echo "ctrl_interface_group=0"
+	echo "ssid=${ssid}"
+	echo "hw_mode=g"
+	echo "channel=1"
+	echo "beacon_int=100"
+	echo "dtim_period=2"
+	echo "max_num_sta=255"
+	echo "rts_threshold=-1"
+	echo "fragm_threshold=-1"
+	echo "macaddr_acl=0"
+	echo "auth_algs=3"
+	echo "wpa=2"
+	echo "wpa_passphrase=${pass}"
+	echo "ieee80211n=1"
+}
+
+gen_udhcpd_conf() {
+    interface=${1}
+    ipv4_prefix=${2}
+    echo "start ${ipv4_prefix}.100"
+    echo "end ${ipv4_prefix}.200"
+    echo "interface ${interface}"
+    echo "pidfile /var/run/udhcpd.${interface}.pid"
+    echo "lease_file /var/lib/misc/udhcpd.${interface}.leases"
+    echo "option subnet 255.255.255.0"
+    echo "option lease 864000"
+}
+
+gen_dnsmasq_conf() {
+    ipv4_prefix=${1}
+    echo "bind-interfaces"
+    echo "interface=wlan0"
+    echo "address=/config.kvm/${ipv4_prefix}.1"
+    echo "no-hosts"
+    echo "dhcp-range=${ipv4_prefix}.2,${ipv4_prefix}.254"
+    echo "dhcp-option=6,${ipv4_prefix}.1"
+    echo "dhcp-option=3,${ipv4_prefix}.1"
+    echo "dhcp-authoritative"
+}
+
+start() {
+    echo "wifi mode: sta"
+    ssid=""
+    pass=""
+    if [ -e /boot/wifi.ssid ] && [ -e /boot/wifi.pass ]; then
+        echo "Updating WiFi credentials from /boot to /etc/kvm/"
+
+        rm -f /etc/kvm/wifi.ssid /etc/kvm/wifi.pass
+
+        mv /boot/wifi.ssid /etc/kvm/wifi.ssid
+        mv /boot/wifi.pass /etc/kvm/wifi.pass
+
+        chown root:root /etc/kvm/wifi.ssid /etc/kvm/wifi.pass
+        chmod 644 /etc/kvm/wifi.ssid /etc/kvm/wifi.pass
+    fi
+    if [ -e /etc/kvm/wifi.ssid ]
+    then
+        ssid=`cat /etc/kvm/wifi.ssid`
+    fi
+    if [ -e /etc/kvm/wifi.pass ]
+    then
+        pass=`cat /etc/kvm/wifi.pass`
+    fi
+    echo "ctrl_interface=/var/run/wpa_supplicant" > /etc/wpa_supplicant.conf
+    wpa_passphrase "$ssid" "$pass" >> /etc/wpa_supplicant.conf
+    wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant.conf
+    if [ ! -e /boot/wifi.nodhcp ]
+    then
+        (udhcpc -i wlan0 -t 10 -T 1 -A 5 -b -p /run/udhcpc.wlan0.pid) &
+    fi
+}
+
+ap_start() {
+    echo "wifi mode: ap"
+    id2=$(printf "%d" 0x$(sha512sum /sys/class/cvi-base/base_uid | head -c 2))
+    id3=$(printf "%d" 0x$(sha512sum /sys/class/cvi-base/base_uid | head -c 4 | tail -c 2))
+    if [ "$id2" = "$id3" ]
+    then
+        id2=$((id2 + 1))
+    fi
+    if [ "$id2" -ge 255 ]
+    then
+        id2=253
+    fi
+    if [ "$id3" -ge 255 ]
+    then
+        id3=254
+    fi
+    ssid=""
+    pass=""
+    if [ -e /kvmapp/kvm/ap.ssid ]
+    then
+        ssid=`cat /kvmapp/kvm/ap.ssid`
+    fi
+    if [ -e /kvmapp/kvm/ap.pass ]
+    then
+        pass=`cat /kvmapp/kvm/ap.pass`
+    fi
+    gen_hostapd_conf "$ssid" "$pass" > /etc/hostapd.conf
+    ipv4_prefix=10.$id3.$id2
+    if [ ! -e /etc/udhcpd.wlan0.conf ]
+    then
+        gen_udhcpd_conf wlan0 "${ipv4_prefix}"  > /etc/udhcpd.wlan0.conf
+    fi
+    # gen_dnsmasq_conf "${ipv4_prefix}"  > /etc/dnsmasq.conf
+
+    # iptables --policy INPUT ACCEPT
+    # iptables --policy FORWARD ACCEPT
+    # iptables --policy OUTPUT ACCEPT
+    # iptables -F
+    # iptables -t nat -F
+    # iptables -t nat -A PREROUTING -i wlan0 -p udp --dport 53 -j DNAT --to ${ipv4_prefix}.1
+
+    ifconfig wlan0 up
+    ip route del default || true
+    ip add flush dev wlan0
+    ip addr add $ipv4_prefix.1/24 dev wlan0
+    # dnsmasq --pid-file=/tmp/dnsmasq.run -C /etc/dnsmasq.conf
+    hostapd -B -i wlan0 /etc/hostapd.conf
+    udhcpd -S /etc/udhcpd.wlan0.conf
+}
+
+stop() {
+	ps -ef|grep hostapd|grep -v grep|awk '{print $1}'|xargs kill -2 || true
+	ps -ef|grep "udhcpd -S /etc/udhcpd.wlan0.conf" |grep -v grep|awk '{print $1}'|xargs kill -2 || true
+	killall wpa_supplicant || true
+	if [ -e /run/udhcpc.wlan0.pid ]
+	then
+		kill `cat /run/udhcpc.wlan0.pid` || true
+		rm -f /run/udhcpc.wlan0.pid
+	fi
+	if [ -e /var/run/udhcpd.wlan0.pid ]
+	then
+		kill `cat /var/run/udhcpd.wlan0.pid`  || true
+		rm -f /var/run/udhcpd.wlan0.pid
+	fi
+	if [ -e /tmp/dnsmasq.run ]
+	then
+		kill `cat /tmp/dnsmasq.run`  || true
+		rm -f /tmp/dnsmasq.run
+	fi
+	# if [ -e /etc/wpa_supplicant.conf]
+	# then
+	# 	echo > /etc/wpa_supplicant.conf
+	# fi
+	airmon-ng stop wlan0mon || true
+}
+
+restart() {
+	stop
+	start
+}
+
+if [ "${1}" = "start" ]
+then
+	start
+elif [ "${1}" = "stop" ]
+then
+	stop
+elif [ "${1}" = "ap" ]
+then
+    stop
+	ap_start
+elif [ "${1}" = "restart" ]
+then
+	restart
+fi

kvmapp/system/init.d/S50avahi-daemon

@@ -0,0 +1,20 @@
+#!/bin/sh
+#
+# avahi-daemon init script
+
+DAEMON=/usr/sbin/avahi-daemon
+case "$1" in
+    start)
+	$DAEMON -c || $DAEMON -D
+	;;
+    stop)
+	$DAEMON -c && $DAEMON -k
+	;;
+    reload)
+	$DAEMON -c && $DAEMON -r
+	;;
+    *)
+	echo "Usage: S50avahi-daemon {start|stop|reload}" >&2
+	exit 1
+	;;
+esac

kvmapp/system/init.d/S50ssdpd

@@ -0,0 +1,49 @@
+#!/bin/sh
+
+DAEMON=ssdpd
+PIDFILE=/var/run/$DAEMON.pid
+CFGFILE=/etc/default/$DAEMON
+
+DAEMON_ARGS=""
+
+# Read configuration variable file if it is present
+# shellcheck source=/dev/null
+[ -r "$CFGFILE" ] && . "$CFGFILE"
+
+# shellcheck disable=SC2086
+start() {
+        printf 'Starting %s: ' "$DAEMON"
+        if start-stop-daemon -S -q -p "$PIDFILE" -x "$DAEMON" -- $DAEMON_ARGS; then
+                echo "OK"
+        else
+                echo "FAIL"
+        fi
+}
+
+stop() {
+        printf 'Stopping %s: ' "$DAEMON"
+        if start-stop-daemon -K -q -p "$PIDFILE" -x "$DAEMON"; then
+                echo "OK"
+        else
+                echo "FAIL"
+        fi
+}
+
+restart() {
+        stop
+        start
+}
+
+case "$1" in
+        start|stop|restart)
+                "$1"
+                ;;
+        reload)
+                restart
+                ;;
+        *)
+                echo "Usage: $0 {start|stop|restart|reload}"
+                exit 1
+esac
+
+exit $?

kvmapp/system/init.d/S50sshd

@@ -0,0 +1,73 @@
+#!/bin/sh
+#
+# sshd        Starts sshd.
+#
+
+# Ensure required binaries exist
+[ -x /usr/bin/ssh-keygen ] || exit 0
+[ -x /usr/sbin/sshd ] || exit 1
+
+PIDFILE="/var/run/sshd.pid"
+
+umask 077
+
+startssh() {
+    # Generate SSH keys if they do not exist
+    [ ! -f /etc/ssh/ssh_host_rsa_key ] && /usr/bin/ssh-keygen -A
+
+        printf "Starting sshd: "
+        /usr/sbin/sshd
+        touch /var/lock/sshd
+        echo "OK"
+}
+
+start() {
+    if [ -e /etc/kvm/ssh_stop ]; then
+        if [ -e /boot/start_ssh_once ]; then
+            rm -f /boot/start_ssh_once
+            startssh
+        else
+            echo "SSH does not start"
+            exit 0
+        fi
+    else
+        startssh
+    fi
+}
+
+stop() {
+        printf "Stopping sshd: "
+        killall sshd 2>/dev/null
+        rm -f /var/lock/sshd
+        echo "OK"
+}
+
+restart() {
+        stop
+        start
+}
+
+case "$1" in
+    start)
+        start
+        ;;
+    stop)
+        stop
+        ;;
+    restart|reload)
+        restart
+        ;;
+    permanent_on)
+        rm -f /etc/kvm/ssh_stop
+        start
+        ;;
+    permanent_off)
+        touch /etc/kvm/ssh_stop
+        stop
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|restart|permanent_on|permanent_off}"
+        exit 1
+esac
+
+exit 0

kvmapp/system/init.d/S80dnsmasq

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+DAEMON="dnsmasq"
+PIDFILE="/var/run/$DAEMON.pid"
+
+[ -f /etc/dnsmasq.conf ] || exit 0
+
+case "$1" in
+	start)
+		printf "Starting dnsmasq: "
+		start-stop-daemon -S -p "$PIDFILE" -x "/usr/sbin/$DAEMON" -- \
+			--pid-file="$PIDFILE"
+		[ $? = 0 ] && echo "OK" || echo "FAIL"
+		;;
+	stop)
+		printf "Stopping dnsmasq: "
+		start-stop-daemon -K -q -p "$PIDFILE" -x "/usr/sbin/$DAEMON"
+		[ $? = 0 ] && echo "OK" || echo "FAIL"
+		;;
+	restart|reload)
+		$0 stop
+		$0 start
+		;;
+	*)
+		echo "Usage: $0 {start|stop|restart}"
+		exit 1
+esac
+
+exit 0

kvmapp/system/init.d/S95nanokvm

@@ -0,0 +1,69 @@
+#!/bin/sh
+# nanokvm Rev3.1
+
+case "$1" in
+  start)
+    echo -n kvm > /boot/hostname.prefix
+
+    # Copy sensor config if the file exists
+    [ -f /mnt/data/sensor_cfg.ini.LT ] && cp /mnt/data/sensor_cfg.ini.LT /mnt/data/sensor_cfg.ini
+
+    # Generate unique device key
+    if [ -f /sys/class/cvi-base/base_uid ]; then
+        str_value=$(awk '{print $2}' /sys/class/cvi-base/base_uid)
+        first_uint=$(echo "$str_value" | cut -d'_' -f1)
+        second_uint=$(echo "$str_value" | cut -d'_' -f2)
+        echo "$first_uint$second_uint" > /device_key
+    fi
+
+    # Set iptables rules (skip if already present)
+    iptables -C INPUT -i eth0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT 2>/dev/null || \
+    iptables -A INPUT -i eth0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
+
+    iptables -C OUTPUT -o eth0 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT 2>/dev/null || \
+    iptables -A OUTPUT -o eth0 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
+
+    iptables -C INPUT -i eth0 -p tcp --sport 22 -m state --state NEW,ESTABLISHED -j ACCEPT 2>/dev/null || \
+    iptables -A INPUT -i eth0 -p tcp --sport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
+
+    iptables -C OUTPUT -o eth0 -p tcp --dport 22 -m state --state ESTABLISHED -j ACCEPT 2>/dev/null || \
+    iptables -A OUTPUT -o eth0 -p tcp --dport 22 -m state --state ESTABLISHED -j ACCEPT
+
+    iptables -C OUTPUT -o eth0 -p tcp --sport 8000 -m state --state ESTABLISHED -j DROP 2>/dev/null || \
+    iptables -A OUTPUT -o eth0 -p tcp --sport 8000 -m state --state ESTABLISHED -j DROP
+
+    # Start services
+    cp -r /kvmapp/kvm_system /tmp/
+    /tmp/kvm_system/kvm_system &
+
+    cp -r /kvmapp/server /tmp/
+    /tmp/server/NanoKVM-Server &
+   ;;
+
+  stop)
+    killall kvm_system
+    killall NanoKVM-Server
+    rm -r /tmp/kvm_system /tmp/server
+    echo "OK"
+   ;;
+
+  restart)
+    killall kvm_system
+    killall NanoKVM-Server
+    rm -r /tmp/kvm_system /tmp/server
+
+    cp -r /kvmapp/kvm_system /tmp/
+    /tmp/kvm_system/kvm_system &
+
+    cp -r /kvmapp/server /tmp/
+    /tmp/server/NanoKVM-Server &
+
+    sync
+    echo "OK"
+   ;;
+    
+  *)
+    echo "Usage: $0 {start|stop|restart}"
+    exit 1
+  ;;
+esac

kvmapp/system/init.d/S98tailscaled

@@ -0,0 +1,114 @@
+#!/bin/sh
+
+DAEMON="tailscaled"
+PIDFILE="/var/run/$DAEMON.pid"
+
+# Set the port to listen on for incoming VPN packets.
+# Remote nodes will automatically be informed about the new port number,
+# but you might want to configure this in order to set external firewall
+# settings.
+PORT="41641"
+
+# Extra flags you might want to pass to tailscaled.
+FLAGS=""
+
+# You need tailscaled at /usr/sbin to server, and tailscale at /usr/bin to operate
+# STATIC version needed. Download page at https://pkgs.tailscale.com/stable/#static
+PKG_URL_LATEST="https://pkgs.tailscale.com/stable/tailscale_latest_riscv64.tgz"
+[ ! -x /usr/sbin/$DAEMON ] &&
+    echo "/usr/sbin/$DAEMON not found, please download it from $PKG_URL_LATEST" &&
+    echo "Then unpack it, copy $DAEMON to /usr/sbin and copy tailscale to /usr/bin" &&
+    exit 1
+VERSION=$(/usr/sbin/$DAEMON --version|sed -n '1p'|xargs echo -n)
+
+[ -x /usr/bin/tailscale ] || echo "/usr/bin/tailscale not found, your installation of tailscale may be broken"
+
+# just for those need forwarding
+[ ! -f /etc/sysctl.d/99-tailscale.conf ] &&
+    mkdir -p /etc/sysctl.d/ &&
+    echo "missing /etc/sysctl.d/99-tailscale.conf, try make it below:" &&
+    (tee /etc/sysctl.d/99-tailscale.conf <<EOF
+net.ipv4.ip_forward = 1
+net.ipv6.conf.all.forwarding = 1
+EOF
+    ) &&
+    echo "if this message repeats showing, please look at $0 if you need forwarding"
+
+case "$1" in
+        start)
+                tailscale set --accept-dns=false
+                if [ -f /etc/kvm/GOMEMLIMIT ]; then
+                     value=$(cat /etc/kvm/GOMEMLIMIT)
+                     export GOMEMLIMIT="${value}MiB"
+                else
+                     export GOMEMLIMIT=1024MiB
+                fi
+                
+                echo "GOMEMLIMIT set to ${GOMEMLIMIT}"
+                printf "Starting $DAEMON[$VERSION]: "
+                start-stop-daemon -S -bmq -p "$PIDFILE" -x "/usr/sbin/$DAEMON" -- \
+                    --state=/var/lib/tailscale/tailscaled.state \
+                    --socket=/var/run/tailscale/tailscaled.sock \
+                    --port=${PORT} \
+                    $FLAGS
+                [ $? = 0 ] && echo "OK" || echo "FAIL"
+                ;;
+        stop)
+                printf "Stopping $DAEMON: "
+                start-stop-daemon -K -p "$PIDFILE"
+                [ $? = 0 ]  && (echo "OK"; rm -f "$PIDFILE") || echo "FAIL"
+                printf "cleaning tailscaled: "
+                /usr/sbin/$DAEMON --cleanup &>/dev/null
+                [ $? = 0 ] && echo "OK" || echo "FAIL"
+                ;;
+        restart|reload)
+                $0 stop
+                $0 start
+                ;;
+        doc)
+                cat <<EOF
+To use tailscale, you need to meet these conditions below:
+  1. Both tailscale and tailscaled were installed.
+  2. At least one tailscale's account were registered.
+     (https://login.tailscale.com/start)
+  3. Your NanoKVM device must keep online.
+
+Then, follow the steps below:
+  1. Login in https://login.tailscale.com on your PC
+     to enter into yout admin console.
+  2. Run 'tailscale login' on your device, and copy the link showed
+     to open on your PC, and confirm the auth.
+  3. Congratulations, your NanoKVM device is now on the tailnet, try to
+     visit it from all your device which on the same tailnet.
+  4. run 'tailscale set --webclient' and manage your device
+     on the web interface from localnet and tailenet.
+
+Added: no more action to be repeat after your device reboot.
+EOF
+                echo ""
+                cat <<EOF
+为了正常使用 tailscale, 你需要满足以下几个条件：
+  1. tailscale 和 tailscaled 这两个静态链接的二进制程序
+     都已经正确安装在系统上。
+  2. 至少注册一个 tailscale 的帐号才能使用其服务。
+     (https://login.tailscale.com/start)
+  3. 你的 NanoKVM 设备必须保持在线。
+
+然后，跟着以下步骤操作：
+  1. 在你的电脑上登录 https://login.tailscale.com 以进入控制台。
+  2. 在你的 NanoKVM ssh 终端上执行 'tailscale login', 然后复制
+     出现的链接到浏览器上，登录并通过验证。
+  3. 祝贺，你的 NanoKVM 现在已经加入了 tailnet 然后你可以从任意
+     同样已加入同一 tailnet 的设备去访问你的 NanoKVM。
+  4. 执行 'tailscale set --webclient' 然后你就可以从 '局域网' 和
+     'tailnet' 来访问特定网页，用来管理你的设备。
+
+补充: 不需要重复上面的操作，哪怕你的设备重启过。
+EOF
+                ;;
+        *)
+                echo "Usage: $0 {start|stop|restart}"
+                exit 1
+esac
+
+exit 0

kvmapp/system/update-nanokvm.py

@@ -0,0 +1,96 @@
+import os
+import shutil
+import time
+import zipfile
+import pathlib
+import requests
+
+temporary: str = "/root/.kvm-cache/"
+
+
+def mkdir() -> None:
+    if pathlib.Path(temporary).exists():
+        shutil.rmtree(temporary)
+    pathlib.Path(temporary).mkdir()
+    print(f"Created temporary directory {temporary}")
+
+
+def read(file: str) -> str:
+    return pathlib.Path(file).read_text().replace("\n", "")
+
+
+def download_firmware() -> None:
+    print("Downloading firmware...")
+
+    now = int(time.time())
+    url = f"https://cdn.sipeed.com/nanokvm/latest.zip?n={now}"
+    print(f"Downloading firmware from {url}")
+
+    response = requests.get(url)
+
+    if response.status_code != 200:
+        raise Exception(f"Failed to download firmware, status: {response.status_code}")
+
+    content_type = response.headers.get("content-type")
+    if content_type != "application/zip":
+        raise Exception(f"Failed to download firmware, content_type: {content_type}")
+
+    zip_file = f"{temporary}/latest.zip"
+    with open(zip_file, "wb") as f:
+        for chunk in response.iter_content(chunk_size=1024):
+            f.write(chunk)
+
+    with zipfile.ZipFile(zip_file, "r") as f:
+        f.extractall(temporary)
+
+    print("Completed downloading firmware.")
+
+
+def update() -> None:
+    backup_dir   = pathlib.Path("/root/old")
+    firmware_dir = pathlib.Path("/kvmapp")
+
+    if backup_dir.exists():
+      shutil.rmtree(backup_dir)
+
+    if firmware_dir.exists():
+      firmware_dir.rename(backup_dir)
+
+    pathlib.Path(f"{temporary}/latest").rename(firmware_dir)
+
+
+def change_permissions() -> None:
+    for root, dirs, files in os.walk("/kvmapp"):
+        os.chmod(root, 0o755)
+
+        for file in files:
+            file_path = os.path.join(root, file)
+            os.chmod(file_path, 0o755)
+
+    print("change permissions done")
+
+
+def main() -> None:
+    try:
+        print("Stopping nanokvm service...")
+        os.system("/etc/init.d/S95nanokvm stop")
+
+        print("Staring update...")
+
+        mkdir()
+        download_firmware()
+        update()
+        change_permissions()
+
+        version = read("/kvmapp/version")
+        print(f"Successfully updated to version: {version}")
+        print("restart service\nthe nanokvm will reboot")
+    except Exception as e:
+        print(f"update failed\n{e}")
+    finally:
+        shutil.rmtree(temporary)
+        os.system("/etc/init.d/S95nanokvm restart")
+
+
+if __name__ == "__main__":
+    main()

server/README.md

@@ -13,7 +13,7 @@ server
 ├── dl_lib       // Shared object libraries
 ├── include      // Header files for shared objects
 ├── logger       // Logging system
-├── middleware   // Server middleware components 
+├── middleware   // Server middleware components
 ├── proto        // API request/response definitions
 ├── router       // API route handlers
 ├── service      // Core service implementations
@@ -39,7 +39,7 @@ cert:
 logger:
     level: info
     file: stdout
-    
+
 # Authentication setting (enable/disable)
 # Note: Only disable authentication in development environment
 authentication: enable
@@ -53,16 +53,16 @@ jwt:
    revokeTokensOnLogout: true
 
 # Address for custom STUN server
+# Note: You can disable the STUN service by setting it to 'disable' (e.g., in a LAN environment)
 stun: stun.l.google.com:19302
 
 # Address and authentication for custom TURN server
 turn:
-    turnAddr: turn.cloudflare.com:3478
+    turnAddr: example_addr
     turnUser: example_user
     turnCred: example_cred
 ```
 
-
 ## Compile & Deploy
 
 Note: Use Linux operating system (x86-64). This build process is not compatible with ARM, Windows or macOS.
@@ -75,8 +75,9 @@ Note: Use Linux operating system (x86-64). This build process is not compatible
 2. Compile the Project
     1. Run `cd server` from the project root directory.
     2. Run `go mod tidy` to install Go dependencies.
-    3. Run `CGO_ENABLED=1 GOOS=linux GOARCH=riscv64 CC=riscv64-unknown-linux-musl-gcc CGO_CFLAGS="-mcpu=c906fdv -march=rv64imafdcv0p7xthead -mcmodel=medany -mabi=lp64d" go build` to compile the project.
-    4. After compilation, an executable file named `NanoKVM-Server` will be generated.
+    3. (Optional) If you compiled `libkvm.so` yourself, you need to modify its RPATH by `patchelf --add-rpath \$ORIGIN ./dl_lib/libkvm.so`.
+    4. Run `CGO_ENABLED=1 GOOS=linux GOARCH=riscv64 CC=riscv64-unknown-linux-musl-gcc CGO_CFLAGS="-mcpu=c906fdv -march=rv64imafdcv0p7xthead -mcmodel=medany -mabi=lp64d" go build` to compile the project.
+    5. After compilation, an executable file named `NanoKVM-Server` will be generated.
 
 3. Modify RPATH
     1. Run `sudo apt install patchelf` or `pip install patchelf` to install patchelf.

server/README_JA.md

@@ -16,7 +16,7 @@ server
 ├── middleware   // サーバーミドルウェアコンポーネント
 ├── proto        // API リクエスト/レスポンス定義
 ├── router       // API ルートハンドラ
-├── service      // コアサービスの実<EFBFBD><EFBFBD>
+├── service      // コアサービスの実装
 ├── utils        // ユーティリティ関数
 └── main.go
 ```
@@ -39,17 +39,23 @@ cert:
 logger:
     level: info
     file: stdout
-    
+
 # 認証設定 (enable/disable)
 # 注意: 認証を無効にするのは開発環境でのみ行ってください
 authentication: enable
 
-# JWT 秘密鍵の設定
-# 空のままにすると、サーバー起動時にランダムな鍵が生成されます
-secretKey: ""
+jwt:
+   # JWT 秘密鍵の設定。 空のままにすると、サーバー起動時にランダムな 64 バイトの鍵が自動的に生成されます。
+   secretKey: ""
+   # JWT トークンの有効期限（秒単位）。 デフォルト: 2678400 (31 日)
+   refreshTokenDuration: 2678400
+   # ユーザーがログアウトすると、すべての JWT トークンが無効になります。 デフォルト: true
+   revokeTokensOnLogout: true
 
+# カスタム STUN サーバーのアドレス
 stun: stun.l.google.com:19302
 
+# カスタム TURN サーバーのアドレスと認証情報
 turn:
     turnAddr: turn.cloudflare.com:3478
     turnUser: example_user
@@ -80,3 +86,12 @@ turn:
     1. デプロイ前に、ブラウザでアプリケーションを最新バージョンに更新します。手順は[こちら](https://wiki.sipeed.com/hardware/en/kvm/NanoKVM/system/updating.html)を参照してください。
     2. コンパイルして生成された `NanoKVM-Server` ファイルを使用して、NanoKVM の `/kvmapp/server/` ディレクトリ内の元のファイルを置き換えます。
     3. NanoKVM で `/etc/init.d/S95nanokvm restart` を実行してサービスを再起動します。
+
+## 手動更新
+
+> ファイルのアップロードには SSH が必要です。Web 設定で有効にしてください: `設定 > SSH`
+
+1. [GitHub](https://github.com/sipeed/NanoKVM/releases) から最新のアプリケーションをダウンロードします。
+2. ダウンロードしたファイルを解凍し、解凍したフォルダーの名前を `kvmapp` に変更します。
+3. NanoKVM 上の既存の `/kvmapp` ディレクトリをバックアップし、新しい `kvmapp` フォルダーに置き換えます。
+4. NanoKVM で `/etc/init.d/S95nanokvm restart` を実行してサービスを再起動します。

server/README_ZH.md

@@ -31,13 +31,13 @@ port:
 cert:
     crt: server.crt
     key: server.key
-    
+
 # 日志级别（debug/info/warn/error）
 # 注意：在生产环境中使用 info 或 error。debug 模式仅在开发环境中使用。
 logger:
     level: info
     file: stdout
-    
+
 # 鉴权设置（enable/disable）
 # 注意：生产环境中请勿使用 disable。
 authentication: enable
@@ -50,10 +50,12 @@ jwt:
    # 在帐号登出时是否使所有 jwt token 失效。默认为 true
    revokeTokensOnLogout: true
 
+# 自定义 STUN 服务器的地址
+# 注意：可以设置为“disable”来禁用 STUN 服务（例如在局域网环境中使用时）
 stun: stun.l.google.com:19302
 
 turn:
-    turnAddr: turn.cloudflare.com:3478
+    turnAddr: example_addr
     turnUser: example_user
     turnCred: example_cred
 ```
@@ -70,8 +72,9 @@ turn:
 2. 编译
    1. 在项目根目录下执行 `cd server` 进入 server 目录；
    2. 执行 `go mod tidy` 安装 Go 依赖包；
-   3. 执行 `CGO_ENABLED=1 GOOS=linux GOARCH=riscv64 CC=riscv64-unknown-linux-musl-gcc CGO_CFLAGS="-mcpu=c906fdv -march=rv64imafdcv0p7xthead -mcmodel=medany -mabi=lp64d" go build` 进行编译；
-   4. 编译完成后，会生成可执行文件 `NanoKVM-Server`。
+   3. （可选）如果您手动编译了 `libkvm.so`，则需要通过 `patchelf --add-rpath \$ORIGIN ./dl_lib/libkvm.so` 修改其 RPATH 属性。
+   4. 执行 `CGO_ENABLED=1 GOOS=linux GOARCH=riscv64 CC=riscv64-unknown-linux-musl-gcc CGO_CFLAGS="-mcpu=c906fdv -march=rv64imafdcv0p7xthead -mcmodel=medany -mabi=lp64d" go build` 进行编译；
+   5. 编译完成后，会生成可执行文件 `NanoKVM-Server`。
 
 3. 修改 RPATH
    1. 执行 `sudo apt install patchelf` 或 `pip install patchelf` 安装 patchelf；
@@ -79,8 +82,8 @@ turn:
    3. 执行 `patchelf --add-rpath \$ORIGIN/dl_lib NanoKVM-Server` 修改可执行文件的 RPATH 属性。
 
 4. 部署
-   1. 上传文件需要启用 SSH 功能。请在 Web `设置 - SSH` 中检查 SSH 是否已经启用； 
-   2. 使用编译生成的 `NanoKVM-Server` 文件，替换 NanoKVM 中 `/kvmapp/server/` 目录下的原始文件； 
+   1. 上传文件需要启用 SSH 功能。请在 Web `设置 - SSH` 中检查 SSH 是否已经启用；
+   2. 使用编译生成的 `NanoKVM-Server` 文件，替换 NanoKVM 中 `/kvmapp/server/` 目录下的原始文件；
    3. 在 NanoKVM 中执行 `/etc/init.d/S95nanokvm restart` 重启服务。
 
 ## 手动更新
@@ -90,4 +93,4 @@ turn:
 1. 从 [GitHub](https://github.com/sipeed/NanoKVM/releases) 下载最新的应用安装包；
 2. 解压缩下载的安装包，并将解压后的文件夹重命名为 `kvmapp`；
 3. 备份 NanoKVM 系统中的 `/kvmapp` 目录，然后用解压后的 `kvmapp` 文件夹替换现有目录。
-4. 在 NanoKVM 中执行 `/etc/init.d/S95nanokvm restart` 重启服务。
+4. 在 NanoKVM 中执行 `/etc/init.d/S95nanokvm restart` 重启服务。

server/common/cgo.go

@@ -20,9 +20,7 @@ var (
 	kvmVisionOnce sync.Once
 )
 
-type KvmVision struct {
-	mutex sync.Mutex
-}
+type KvmVision struct{}
 
 func GetKvmVision() *KvmVision {
 	kvmVisionOnce.Do(func() {
@@ -44,9 +42,6 @@ func GetKvmVision() *KvmVision {
 }
 
 func (k *KvmVision) ReadMjpeg(width uint16, height uint16, quality uint16) (data []byte, result int) {
-	k.mutex.Lock()
-	defer k.mutex.Unlock()
-
 	var (
 		kvmData  *C.uint8_t
 		dataSize C.uint32_t
@@ -72,10 +67,7 @@ func (k *KvmVision) ReadMjpeg(width uint16, height uint16, quality uint16) (data
 	return
 }
 
-func (k *KvmVision) ReadH264(width uint16, height uint16, bitRate uint16) (data []byte, sps []byte, pps []byte, result int) {
-	k.mutex.Lock()
-	defer k.mutex.Unlock()
-
+func (k *KvmVision) ReadH264(width uint16, height uint16, bitRate uint16) (data []byte, result int) {
 	var (
 		kvmData  *C.uint8_t
 		dataSize C.uint32_t
@@ -97,48 +89,10 @@ func (k *KvmVision) ReadH264(width uint16, height uint16, bitRate uint16) (data
 
 	data = C.GoBytes(unsafe.Pointer(kvmData), C.int(dataSize))
 
-	if result == 3 {
-		sps, _ = k.ReadH264SPS()
-		pps, _ = k.ReadH264PPS()
-	}
-
 	log.Debugf("read kvm image: %v", result)
 	return
 }
 
-func (k *KvmVision) ReadH264SPS() ([]byte, int) {
-	var (
-		kvmData  *C.uint8_t
-		dataSize C.uint32_t
-	)
-
-	result := int(C.kvmv_get_sps_frame(&kvmData, &dataSize))
-	if result < 0 {
-		log.Errorf("failed to read sps: %v", result)
-		return nil, result
-	}
-
-	data := C.GoBytes(unsafe.Pointer(kvmData), C.int(dataSize))
-
-	return data, result
-}
-
-func (k *KvmVision) ReadH264PPS() ([]byte, int) {
-	var (
-		kvmData  *C.uint8_t
-		dataSize C.uint32_t
-	)
-
-	result := int(C.kvmv_get_pps_frame(&kvmData, &dataSize))
-	if result < 0 {
-		log.Errorf("failed to read pps: %v", result)
-		return nil, result
-	}
-
-	data := C.GoBytes(unsafe.Pointer(kvmData), C.int(dataSize))
-	return data, result
-}
-
 func (k *KvmVision) SetHDMI(enable bool) int {
 	hdmiEnable := C.uint8_t(0)
 	if enable {
@@ -154,10 +108,17 @@ func (k *KvmVision) SetHDMI(enable bool) int {
 	return result
 }
 
-func (k *KvmVision) Close() {
-	k.mutex.Lock()
-	defer k.mutex.Unlock()
+func (k *KvmVision) SetGop(gop uint8) {
+	_gop := C.uint8_t(gop)
+	C.set_h264_gop(_gop)
+}
 
+func (k *KvmVision) SetFrameDetect(frame uint8) {
+	_frame := C.uint8_t(frame)
+	C.set_frame_detact(_frame)
+}
+
+func (k *KvmVision) Close() {
 	C.kvmv_deinit()
 	log.Debugf("stop kvm vision...")
 }

server/common/screen.go

@@ -8,6 +8,7 @@ type Screen struct {
 	FPS     int
 	Quality uint16
 	BitRate uint16
+	GOP     uint8
 }
 
 var (
@@ -46,6 +47,7 @@ func GetScreen() *Screen {
 			Quality: 80,
 			FPS:     30,
 			BitRate: 3000,
+			GOP:     30,
 		}
 	})
 
@@ -70,6 +72,24 @@ func SetScreen(key string, value int) {
 
 	case "fps":
 		screen.FPS = validateFPS(value)
+
+	case "gop":
+		screen.GOP = uint8(value)
+	}
+}
+
+func CheckScreen() {
+	if _, ok := ResolutionMap[screen.Height]; !ok {
+		screen.Width = 1920
+		screen.Height = 1080
+	}
+
+	if _, ok := QualityMap[screen.Quality]; !ok {
+		screen.Quality = 80
+	}
+
+	if _, ok := BitRateMap[screen.BitRate]; !ok {
+		screen.BitRate = 3000
 	}
 }
 

server/config/default.go

@@ -21,7 +21,7 @@ var defaultConfig = &Config{
 	},
 	Stun: "stun.l.google.com:19302",
 	Turn: Turn{
-		TurnAddr: "turn.cloudflare.com:3478",
+		TurnAddr: "",
 		TurnUser: "",
 		TurnCred: "",
 	},

server/config/file.go

@@ -0,0 +1,45 @@
+package config
+
+import (
+	"os"
+
+	log "github.com/sirupsen/logrus"
+	"gopkg.in/yaml.v3"
+)
+
+const ConfigurationFile = "/etc/kvm/server.yaml"
+
+func Read() (*Config, error) {
+	data, err := os.ReadFile(ConfigurationFile)
+	if err != nil {
+		log.Errorf("failed to read config: %v", err)
+		return nil, err
+	}
+
+	var conf Config
+
+	if err := yaml.Unmarshal(data, &conf); err != nil {
+		log.Fatalf("failed to unmarshal config: %v", err)
+		return nil, err
+	}
+
+	log.Debugf("read %s successfully", ConfigurationFile)
+	return &conf, nil
+}
+
+func Write(conf *Config) error {
+	data, err := yaml.Marshal(&conf)
+	if err != nil {
+		log.Errorf("failed to marshal config: %v", err)
+		return err
+	}
+
+	err = os.WriteFile(ConfigurationFile, data, 0644)
+	if err != nil {
+		log.Errorf("failed to write config: %v", err)
+		return err
+	}
+
+	log.Debugf("write to %s successfully", ConfigurationFile)
+	return nil
+}

server/go.mod

@@ -1,13 +1,15 @@
 module NanoKVM-Server
 
-go 1.22.1
+go 1.23.0
+
+toolchain go1.23.2
 
 require (
 	github.com/creack/pty v1.1.24
 	github.com/gin-gonic/contrib v0.0.0-20240508051311-c1c6bf0061b0
 	github.com/gin-gonic/gin v1.10.0
 	github.com/go-playground/validator/v10 v10.20.0
-	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/gorilla/websocket v1.5.3
 	github.com/mervick/aes-everywhere/go/aes256 v0.0.0-20240803013625-6759956693c0
 	github.com/pion/webrtc/v4 v4.0.1
@@ -15,7 +17,7 @@ require (
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/viper v1.19.0
 	github.com/unrolled/secure v1.15.0
-	golang.org/x/crypto v0.31.0
+	golang.org/x/crypto v0.37.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -71,9 +73,9 @@ require (
 	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/arch v0.8.0 // indirect
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
-	golang.org/x/net v0.33.0 // indirect
-	golang.org/x/sys v0.28.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/net v0.39.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
+	golang.org/x/text v0.24.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )

server/go.sum

@@ -36,6 +36,8 @@ github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
 github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
+github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -160,17 +162,33 @@ golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
 golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
 golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
+golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
 golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
+golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
 google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
 google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

server/include/kvm_vision.h

@@ -13,6 +13,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdlib.h>
 #include <pthread.h>
+#include <time.h>
 
 #define IMG_BUFFER_FULL			-3
 #define IMG_VENC_ERROR			-2
@@ -23,7 +24,14 @@ extern "C" {
 #define IMG_H264_TYPE_IF		3
 #define IMG_H264_TYPE_PF		4
 
+#define NORMAL_RES                      0
+#define NEW_RES                         1
+#define UNSUPPORT_RES                   2
+#define UNKNOWN_RES                     3
+#define ERROR_RES                       4
+
 void kvmv_init(uint8_t _debug_info_en);
+void set_venc_auto_recyc(uint8_t _enable);
 /**********************************************************************************
  * @name    kvmv_read_img
  * @author  Sipeed BuGu
@@ -37,22 +45,25 @@ void kvmv_init(uint8_t _debug_info_en);
  * @param	_pp_kvm_data		@output: 	Encode data
  * @param	_p_kvmv_data_size	@output: 	Encode data size
  * @return
+        -7: HDMI INPUT RES ERROR
+        -6: Unsupported resolution, please modify it in the host settings.
+        -5: Retrieving image, please wait
         -4: Modifying image resolution, please wait
         -3: img buffer full
         -2: VENC Error
         -1: No images were acquired
          0: Acquire MJPEG encoded images
-         1: Acquire H264 encoded images(SPS)
-         2: Acquire H264 encoded images(PPS)
+         1: Acquire H264 encoded images(SPS)[Deprecated]
+         2: Acquire H264 encoded images(PPS)[Deprecated]
          3: Acquire H264 encoded images(I)
          4: Acquire H264 encoded images(P)
+         5: IMG not changed
  **********************************************************************************/
 int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _qlty, uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size);
-int kvmv_get_sps_frame(uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size);
-int kvmv_get_pps_frame(uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size);
 int free_kvmv_data(uint8_t ** _pp_kvm_data);
 void free_all_kvmv_data();
 void set_h264_gop(uint8_t _gop);
+void set_frame_detact(uint8_t _frame_detact);
 void kvmv_deinit();
 uint8_t kvmv_hdmi_control(uint8_t _en);
 
@@ -60,4 +71,4 @@ uint8_t kvmv_hdmi_control(uint8_t _en);
 }
 #endif
 
-#endif // KVM_VISION_H_
+#endif // KVM_VISION_H_

server/logger/formatter.go

@@ -22,7 +22,7 @@ func (f *formatter) Format(entry *logrus.Entry) ([]byte, error) {
 		buffer = &bytes.Buffer{}
 	}
 
-	now := entry.Time.Format("2006-01-02 15:04:05")
+	now := entry.Time.Format("2006-01-02 15:04:05.000")
 
 	if entry.HasCaller() {
 		fileName := filepath.Base(entry.Caller.File)

server/main.go

@@ -1,18 +1,21 @@
 package main
 
 import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
 	"NanoKVM-Server/common"
 	"NanoKVM-Server/config"
 	"NanoKVM-Server/logger"
 	"NanoKVM-Server/middleware"
 	"NanoKVM-Server/router"
-	"NanoKVM-Server/utils"
-	"fmt"
-	"log"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
+	"NanoKVM-Server/service/vm/jiggler"
 
 	"github.com/gin-gonic/gin"
 	cors "github.com/rs/cors/wrapper/gin"
@@ -37,7 +40,8 @@ func initialize() {
 	time.Sleep(10 * time.Millisecond)
 	vision.SetHDMI(true)
 
-	utils.InitGoMemLimit()
+	// run mouse jiggler
+	jiggler.GetJiggler().Run()
 
 	sigChan := make(chan os.Signal, 1)
 	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
@@ -56,7 +60,6 @@ func run() {
 	gin.SetMode(gin.ReleaseMode)
 	r := gin.New()
 	r.Use(gin.Recovery())
-
 	if conf.Authentication == "disable" {
 		r.Use(cors.AllowAll())
 	}
@@ -65,20 +68,17 @@ func run() {
 
 	httpAddr := fmt.Sprintf(":%d", conf.Port.Http)
 	httpsAddr := fmt.Sprintf(":%d", conf.Port.Https)
-	log.Printf("proto: %s, port: %d %d\n", conf.Proto, conf.Port.Http, conf.Port.Https)
 
 	if conf.Proto == "https" {
-		r.Use(middleware.Tls())
-
 		go func() {
-			if err := r.Run(httpAddr); err != nil {
-				panic("start http server failed")
+			r.Use(middleware.Tls())
+			err := r.RunTLS(httpsAddr, conf.Cert.Crt, conf.Cert.Key)
+			if err != nil {
+				panic("start https server failed")
 			}
 		}()
 
-		if err := r.RunTLS(httpsAddr, conf.Cert.Crt, conf.Cert.Key); err != nil {
-			panic("start https server failed")
-		}
+		runRedirect(httpAddr, httpsAddr)
 	} else {
 		if err := r.Run(httpAddr); err != nil {
 			panic("start http server failed")
@@ -86,6 +86,26 @@ func run() {
 	}
 }
 
+func runRedirect(httpPort string, httpsPort string) {
+	err := http.ListenAndServe(httpPort, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		host := req.Host
+		if strings.Contains(host, httpPort) {
+			host = strings.Split(host, httpPort)[0]
+		}
+
+		targetURL := "https://" + host + req.URL.String()
+		if httpsPort != ":443" {
+			targetURL = "https://" + host + httpsPort + req.URL.String()
+		}
+
+		http.Redirect(w, req, targetURL, http.StatusTemporaryRedirect)
+	}))
+
+	if err != nil {
+		panic("start http server failed")
+	}
+}
+
 func dispose() {
 	common.GetKvmVision().Close()
 }

server/proto/application.go

@@ -4,3 +4,11 @@ type GetVersionRsp struct {
 	Current string `json:"current"`
 	Latest  string `json:"latest"`
 }
+
+type GetPreviewRsp struct {
+	Enabled bool `json:"enabled"`
+}
+
+type SetPreviewReq struct {
+	Enable bool `validate:"omitempty"`
+}

server/proto/hid.go

@@ -0,0 +1,9 @@
+package proto
+
+type GetHidModeRsp struct {
+	Mode string `json:"mode"` // normal or hid-only
+}
+
+type SetHidModeReq struct {
+	Mode string `validate:"required"` // normal or hid-only
+}

server/proto/network.go

@@ -12,6 +12,11 @@ type DeleteMacReq struct {
 	Mac string `form:"mac" validate:"required"`
 }
 
+type SetMacNameReq struct {
+	Mac  string `form:"mac" validate:"required"`
+	Name string `form:"name" validate:"required"`
+}
+
 type TailscaleState string
 
 const (

server/proto/stream.go

@@ -1,9 +1,9 @@
 package proto
 
-type GetFrameDetectRsp struct {
-	Enabled bool `json:"enabled"`
+type UpdateFrameDetectReq struct {
+	Enabled bool `validate:"omitempty"`
 }
 
-type UpdateFrameDetectRsp struct {
-	Enabled bool `json:"enabled"`
+type StopFrameDetectReq struct {
+	Duration int `validate:"omitempty"`
 }

server/proto/vm.go

@@ -1,7 +1,14 @@
 package proto
 
+type IP struct {
+	Name    string `json:"name"`
+	Addr    string `json:"addr"`
+	Version string `json:"version"`
+	Type    string `json:"type"`
+}
+
 type GetInfoRsp struct {
-	Ip          string `json:"ip"`
+	IPs         []IP   `json:"ips"`
 	Mdns        string `json:"mdns"`
 	Image       string `json:"image"`
 	Application string `json:"application"`
@@ -62,8 +69,8 @@ type UpdateVirtualDeviceRsp struct {
 }
 
 type SetMemoryLimitReq struct {
-	Enabled bool  `json:"enabled"`
-	Limit   int64 `json:"limit"`
+	Enabled bool  `validate:"omitempty"`
+	Limit   int64 `validate:"omitempty"`
 }
 
 type GetMemoryLimitRsp struct {
@@ -72,7 +79,7 @@ type GetMemoryLimitRsp struct {
 }
 
 type SetOledReq struct {
-	Sleep int `json:"sleep"`
+	Sleep int `validate:"omitempty"`
 }
 
 type GetOLEDRsp struct {
@@ -83,3 +90,45 @@ type GetOLEDRsp struct {
 type GetSSHStateRsp struct {
 	Enabled bool `json:"enabled"`
 }
+
+type GetSwapRsp struct {
+	Size int64 `json:"size"` // unit: MB
+}
+
+type SetSwapReq struct {
+	Size int64 `validate:"omitempty"` // unit: MB
+}
+
+type GetMouseJigglerRsp struct {
+	Enabled bool   `json:"enabled"`
+	Mode    string `json:"mode"`
+}
+
+type SetMouseJigglerReq struct {
+	Enabled bool   `validate:"omitempty"`
+	Mode    string `validate:"omitempty"`
+}
+
+type GetMdnsStateRsp struct {
+	Enabled bool `json:"enabled"`
+}
+
+type SetHostnameReq struct {
+	Hostname string `validate:"required"`
+}
+
+type GetHostnameRsp struct {
+	Hostname string `json:"hostname"`
+}
+
+type SetWebTitleReq struct {
+	Title string `validate:"omitempty"`
+}
+
+type GetWebTitleRsp struct {
+	Title string `json:"title"`
+}
+
+type SetTlsReq struct {
+	Enabled bool `validate:"omitempty"`
+}

server/router/application.go

@@ -13,4 +13,7 @@ func applicationRouter(r *gin.Engine) {
 
 	api.GET("/application/version", service.GetVersion) // get application version
 	api.POST("/application/update", service.Update)     // update application
+
+	api.GET("/application/preview", service.GetPreview)  // get preview updates state
+	api.POST("/application/preview", service.SetPreview) // set preview updates state
 }

server/router/hid.go

@@ -13,4 +13,7 @@ func hidRouter(r *gin.Engine) {
 
 	api.POST("/hid/reset", service.Reset) // reset hid
 	api.POST("/hid/paste", service.Paste) // paste
+
+	api.GET("/hid/mode", service.GetHidMode)  // get hid mode
+	api.POST("/hid/mode", service.SetHidMode) // set hid mode
 }

server/router/network.go

@@ -14,9 +14,9 @@ func networkRouter(r *gin.Engine) {
 
 	api := r.Group("/api").Use(middleware.CheckToken())
 
-	api.POST("/network/wol", service.WakeOnLAN)       // wake on lan
-	api.GET("/network/wol/mac", service.GetMac)       // get mac list
-	api.DELETE("/network/wol/mac", service.DeleteMac) // delete mac
-
-	api.GET("/network/wifi", service.GetWifi) // get Wi-Fi information
+	api.POST("/network/wol", service.WakeOnLAN)           // wake on lan
+	api.GET("/network/wol/mac", service.GetMac)           // get mac list
+	api.DELETE("/network/wol/mac", service.DeleteMac)     // delete mac
+	api.POST("/network/wol/mac/name", service.SetMacName) // set mac name
+	api.GET("/network/wifi", service.GetWifi)             // get Wi-Fi information
 }

server/router/stream.go

@@ -2,6 +2,7 @@ package router
 
 import (
 	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/stream/direct"
 	"NanoKVM-Server/service/stream/h264"
 	"NanoKVM-Server/service/stream/mjpeg"
 
@@ -12,9 +13,9 @@ func streamRouter(r *gin.Engine) {
 	api := r.Group("/api").Use(middleware.CheckToken())
 
 	api.GET("/stream/mjpeg", mjpeg.Connect)                      // mjpeg stream
-	api.GET("/stream/mjpeg/detect", mjpeg.GetFrameDetect)        // get frame detect state
-	api.POST("/stream/mjpeg/detect", mjpeg.UpdateFrameDetect)    // update frame detect state
+	api.POST("/stream/mjpeg/detect", mjpeg.UpdateFrameDetect)    // update frame detect
 	api.POST("/stream/mjpeg/detect/stop", mjpeg.StopFrameDetect) // temporary stop frame detect
 
-	api.GET("/stream/h264", h264.Connect) // h264 stream
+	api.GET("/stream/h264", h264.Connect)          // h264 stream (webrtc)
+	api.GET("/stream/h264/direct", direct.Connect) // h264 stream (http)
 }

server/router/vm.go

@@ -9,6 +9,7 @@ import (
 
 func vmRouter(r *gin.Engine) {
 	service := vm.NewService()
+
 	api := r.Group("/api").Use(middleware.CheckToken())
 
 	api.GET("/vm/info", service.GetInfo)         // get device information
@@ -39,4 +40,24 @@ func vmRouter(r *gin.Engine) {
 	api.GET("/vm/ssh", service.GetSSHState)         // get SSH state
 	api.POST("/vm/ssh/enable", service.EnableSSH)   // enable SSH
 	api.POST("/vm/ssh/disable", service.DisableSSH) // disable SSH
+
+	api.GET("/vm/swap", service.GetSwap)  // get swap file size
+	api.POST("/vm/swap", service.SetSwap) // set swap file size
+
+	api.GET("/vm/mouse-jiggler", service.GetMouseJiggler)   // get mouse jiggler
+	api.POST("/vm/mouse-jiggler/", service.SetMouseJiggler) // set mouse jiggler
+
+	api.GET("/vm/hostname", service.GetHostname)  // Get Hostname
+	api.POST("/vm/hostname", service.SetHostname) // Set Hostname
+
+	api.GET("/vm/web-title", service.GetWebTitle)  // Get web title
+	api.POST("/vm/web-title", service.SetWebTitle) // Set web title
+
+	api.GET("/vm/mdns", service.GetMdnsState)         // get mDNS state
+	api.POST("/vm/mdns/enable", service.EnableMdns)   // enable mDNS
+	api.POST("/vm/mdns/disable", service.DisableMdns) // disable mDNS
+
+	api.POST("/vm/tls", service.SetTls) // enable/disable TLS
+
+	api.POST("/vm/system/reboot", service.Reboot) // reboot system
 }

server/service/application/preview.go

@@ -0,0 +1,60 @@
+package application
+
+import (
+	"NanoKVM-Server/proto"
+	"os"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	PreviewUpdatesFlag = "/etc/kvm/preview_updates"
+)
+
+func (s *Service) GetPreview(c *gin.Context) {
+	var rsp proto.Response
+
+	isEnabled := isPreviewEnabled()
+
+	rsp.OkRspWithData(c, &proto.GetPreviewRsp{
+		Enabled: isEnabled,
+	})
+}
+
+func (s *Service) SetPreview(c *gin.Context) {
+	var req proto.SetPreviewReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	if req.Enable == isPreviewEnabled() {
+		rsp.OkRsp(c)
+		return
+	}
+
+	if req.Enable {
+		if err := os.WriteFile(PreviewUpdatesFlag, []byte("1"), 0o644); err != nil {
+			log.Errorf("failed to write %s: %s", PreviewUpdatesFlag, err)
+			rsp.ErrRsp(c, -2, "enable failed")
+			return
+		}
+	} else {
+		if err := os.Remove(PreviewUpdatesFlag); err != nil {
+			log.Errorf("failed to remove %s: %s", PreviewUpdatesFlag, err)
+			rsp.ErrRsp(c, -3, "disable failed")
+			return
+		}
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("set preview updates state: %t", req.Enable)
+}
+
+func isPreviewEnabled() bool {
+	_, err := os.Stat(PreviewUpdatesFlag)
+	return err == nil
+}

server/service/application/service.go

@@ -1,7 +1,8 @@
 package application
 
 const (
-	BaseURL = "https://cdn.sipeed.com/nanokvm"
+	StableURL  = "https://cdn.sipeed.com/nanokvm"
+	PreviewURL = "https://cdn.sipeed.com/nanokvm/preview"
 
 	AppDir    = "/kvmapp"
 	BackupDir = "/root/old"

server/service/application/update.go

@@ -3,13 +3,11 @@ package application
 import (
 	"crypto/sha512"
 	"encoding/base64"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"os/exec"
-	"strings"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -23,39 +21,6 @@ const (
 	maxTries = 3
 )
 
-type Latest struct {
-	Version string `json:"version"`
-	Name    string `json:"name"`
-	Sha512  string `json:"sha512"`
-	Size    uint   `json:"size"`
-}
-
-func (s *Service) GetVersion(c *gin.Context) {
-	var rsp proto.Response
-
-	// current version
-	currentVersion := "1.0.0"
-
-	versionFile := fmt.Sprintf("%s/version", AppDir)
-	if version, err := os.ReadFile(versionFile); err == nil {
-		currentVersion = strings.ReplaceAll(string(version), "\n", "")
-	}
-
-	log.Debugf("current version: %s", currentVersion)
-
-	// latest version
-	latest, err := getLatest()
-	if err != nil {
-		rsp.ErrRsp(c, -1, "get latest version failed")
-		return
-	}
-
-	rsp.OkRspWithData(c, &proto.GetVersionRsp{
-		Current: currentVersion,
-		Latest:  latest.Version,
-	})
-}
-
 func (s *Service) Update(c *gin.Context) {
 	var rsp proto.Response
 
@@ -87,10 +52,9 @@ func update() error {
 	}
 
 	// download
-	url := fmt.Sprintf("%s/%s", BaseURL, latest.Name)
 	target := fmt.Sprintf("%s/%s", CacheDir, latest.Name)
 
-	if err := download(url, target); err != nil {
+	if err := download(latest.Url, target); err != nil {
 		log.Errorf("download app failed: %s", err)
 		return err
 	}
@@ -135,39 +99,6 @@ func update() error {
 	return nil
 }
 
-func getLatest() (*Latest, error) {
-	url := fmt.Sprintf("%s/latest.json?now=%d", BaseURL, time.Now().Unix())
-
-	resp, err := http.Get(url)
-	if err != nil {
-		log.Debugf("failed to request version: %v", err)
-		return nil, err
-	}
-	defer func() {
-		_ = resp.Body.Close()
-	}()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Errorf("failed to read response: %v", err)
-		return nil, err
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		log.Errorf("server responded with status code: %d", resp.StatusCode)
-		return nil, err
-	}
-
-	var latest Latest
-	if err := json.Unmarshal(body, &latest); err != nil {
-		log.Errorf("failed to unmarshal response: %s", err)
-		return nil, err
-	}
-
-	log.Debugf("get application latest version: %s", latest.Version)
-	return &latest, nil
-}
-
 func download(url string, target string) (err error) {
 	for i := range maxTries {
 		log.Debugf("attempt #%d/%d", i+1, maxTries)

server/service/application/version.go

@@ -0,0 +1,89 @@
+package application
+
+import (
+	"NanoKVM-Server/proto"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+type Latest struct {
+	Version string `json:"version"`
+	Name    string `json:"name"`
+	Sha512  string `json:"sha512"`
+	Size    uint   `json:"size"`
+	Url     string `json:"url"`
+}
+
+func (s *Service) GetVersion(c *gin.Context) {
+	var rsp proto.Response
+
+	// current version
+	currentVersion := "1.0.0"
+
+	versionFile := fmt.Sprintf("%s/version", AppDir)
+	if version, err := os.ReadFile(versionFile); err == nil {
+		currentVersion = strings.ReplaceAll(string(version), "\n", "")
+	}
+
+	log.Debugf("current version: %s", currentVersion)
+
+	// latest version
+	latest, err := getLatest()
+	if err != nil {
+		rsp.ErrRsp(c, -1, "get latest version failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetVersionRsp{
+		Current: currentVersion,
+		Latest:  latest.Version,
+	})
+}
+
+func getLatest() (*Latest, error) {
+	baseURL := StableURL
+	if isPreviewEnabled() {
+		baseURL = PreviewURL
+	}
+
+	url := fmt.Sprintf("%s/latest.json?now=%d", baseURL, time.Now().Unix())
+
+	resp, err := http.Get(url)
+	if err != nil {
+		log.Debugf("failed to request version: %v", err)
+		return nil, err
+	}
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Errorf("failed to read response: %v", err)
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		log.Errorf("server responded with status code: %d", resp.StatusCode)
+		return nil, fmt.Errorf("status code %d", resp.StatusCode)
+	}
+
+	var latest Latest
+	if err := json.Unmarshal(body, &latest); err != nil {
+		log.Errorf("failed to unmarshal response: %s", err)
+		return nil, err
+	}
+
+	latest.Url = fmt.Sprintf("%s/%s", baseURL, latest.Name)
+
+	log.Debugf("get application latest version: %s", latest.Version)
+	return &latest, nil
+}

server/service/extensions/tailscale/service.go

@@ -16,6 +16,8 @@ const (
 	TailscalePath  = "/usr/bin/tailscale"
 	TailscaledPath = "/usr/sbin/tailscaled"
 	ConfigPath     = "etc/sysctl.d/99-tailscale.conf"
+
+	GoMemLimit int64 = 75
 )
 
 var StateMap = map[string]proto.TailscaleState{
@@ -69,7 +71,7 @@ func (s *Service) Start(c *gin.Context) {
 	}
 
 	if !utils.IsGoMemLimitExist() {
-		_ = utils.SetGoMemLimit(50)
+		_ = utils.SetGoMemLimit(GoMemLimit)
 	}
 
 	rsp.OkRsp(c)
@@ -165,7 +167,7 @@ func (s *Service) Login(c *gin.Context) {
 	}
 
 	if !utils.IsGoMemLimitExist() {
-		_ = utils.SetGoMemLimit(50)
+		_ = utils.SetGoMemLimit(GoMemLimit)
 	}
 
 	rsp.OkRspWithData(c, &proto.LoginTailscaleRsp{

server/service/hid/mode.go

@@ -0,0 +1,158 @@
+package hid
+
+import (
+	"NanoKVM-Server/proto"
+	"errors"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	ModeNormal  = "normal"
+	ModeHidOnly = "hid-only"
+
+	ModeFlag          = "/sys/kernel/config/usb_gadget/g0/bcdDevice"
+	NormalModeScript  = "/kvmapp/system/init.d/S03usbdev"
+	HidOnlyModeScript = "/kvmapp/system/init.d/S03usbhid"
+	TargetModeScript  = "/etc/init.d/S03usbdev"
+)
+
+var modeMap = map[string]string{
+	"0x0510": ModeNormal,
+	"0x0623": ModeHidOnly,
+}
+
+func (s *Service) GetHidMode(c *gin.Context) {
+	var rsp proto.Response
+
+	mode, err := getHidMode()
+	if err != nil {
+		rsp.ErrRsp(c, -1, "get HID mode failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetHidModeRsp{
+		Mode: mode,
+	})
+	log.Debugf("get hid mode: %s", mode)
+}
+
+func (s *Service) SetHidMode(c *gin.Context) {
+	var req proto.SetHidModeReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+	if req.Mode != ModeNormal && req.Mode != ModeHidOnly {
+		rsp.ErrRsp(c, -2, "invalid arguments")
+		return
+	}
+
+	if mode, _ := getHidMode(); req.Mode == mode {
+		rsp.OkRsp(c)
+		return
+	}
+
+	srcScript := NormalModeScript
+	if req.Mode == ModeHidOnly {
+		srcScript = HidOnlyModeScript
+	}
+
+	if err := copyModeFile(srcScript); err != nil {
+		rsp.ErrRsp(c, -3, "operation failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+
+	log.Println("reboot system...")
+	time.Sleep(500 * time.Millisecond)
+	_ = exec.Command("reboot").Run()
+}
+
+func copyModeFile(srcScript string) error {
+	// open the source file
+	srcFile, err := os.Open(srcScript)
+	if err != nil {
+		log.Errorf("failed to open %s: %s", srcScript, err)
+		return err
+	}
+	defer func() {
+		_ = srcFile.Close()
+	}()
+
+	srcInfo, err := srcFile.Stat()
+	if err != nil {
+		log.Errorf("failed to get %s info: %s", srcScript, err)
+		return err
+	}
+
+	// create and copy to temporary file
+	tmpFile, err := os.CreateTemp("/etc/init.d/", ".S03usbdev-")
+	if err != nil {
+		log.Errorf("failed to create temp %s: %s", TargetModeScript, err)
+		return err
+	}
+	tmpPath := tmpFile.Name()
+	defer func() {
+		_ = os.Remove(tmpPath)
+	}()
+	log.Debugf("create temporary file: %s", tmpPath)
+
+	if err := tmpFile.Chmod(srcInfo.Mode()); err != nil {
+		_ = tmpFile.Close()
+		log.Errorf("failed to set %s mode: %s", tmpPath, err)
+		return err
+	}
+
+	if _, err := io.Copy(tmpFile, srcFile); err != nil {
+		_ = tmpFile.Close()
+		log.Errorf("failed to copy %s: %s", srcScript, err)
+		return err
+	}
+
+	if err := tmpFile.Sync(); err != nil {
+		_ = tmpFile.Close()
+		log.Errorf("failed to sync %s: %s", tmpPath, err)
+		return err
+	}
+
+	if err := tmpFile.Close(); err != nil {
+		log.Errorf("failed to close %s: %s", tmpPath, err)
+		return err
+	}
+
+	// replace the target file with the temporary file
+	if err := os.Rename(tmpPath, TargetModeScript); err != nil {
+		log.Errorf("failed to rename %s: %s", tmpPath, err)
+		return err
+	}
+
+	log.Debugf("copy %s to %s successful", srcScript, TargetModeScript)
+	return nil
+}
+
+func getHidMode() (string, error) {
+	data, err := os.ReadFile(ModeFlag)
+	if err != nil {
+		log.Errorf("failed to read %s: %s", ModeFlag, err)
+		return "", err
+	}
+
+	key := strings.TrimSpace(string(data))
+	mode, ok := modeMap[key]
+	if !ok {
+		log.Errorf("invalid mode flag: %s", key)
+		return "", errors.New("invalid mode flag")
+	}
+
+	return mode, nil
+}

server/service/network/wol.go

@@ -33,7 +33,7 @@ func (s *Service) WakeOnLAN(c *gin.Context) {
 		return
 	}
 
-	command := fmt.Sprintf("ether-wake %s", mac)
+	command := fmt.Sprintf("ether-wake -b %s", mac)
 	cmd := exec.Command("sh", "-c", command)
 
 	output, err := cmd.CombinedOutput()
@@ -65,6 +65,54 @@ func (s *Service) GetMac(c *gin.Context) {
 	rsp.OkRspWithData(c, data)
 }
 
+func (s *Service) SetMacName(c *gin.Context) {
+	var req proto.SetMacNameReq // Mac:string Name:string
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	content, err := os.ReadFile(WolMacFile)
+	if err != nil {
+		log.Errorf("failed to open %s: %s", WolMacFile, err)
+		rsp.ErrRsp(c, -2, "read failed")
+		return
+	}
+
+	macs := strings.Split(string(content), "\n")
+	var newLines []string
+	macFound := false
+
+	for _, line := range macs {
+		parts := strings.Split(line, " ")
+		if req.Mac != parts[0] {
+			newLines = append(newLines, line)
+			continue
+		}
+		newLines = append(newLines, parts[0]+" "+req.Name)
+		macFound = true
+	}
+
+	if !macFound {
+		log.Errorf("failed to found mac %s: %s", req.Mac, err)
+		rsp.ErrRsp(c, -3, "write failed")
+		return
+	}
+
+	data := strings.Join(newLines, "\n")
+	err = os.WriteFile(WolMacFile, []byte(data), 0o644)
+	if err != nil {
+		log.Errorf("failed to write %s: %s", WolMacFile, err)
+		rsp.ErrRsp(c, -3, "write failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("set wol mac name: %s %s", req.Mac, req.Name)
+}
+
 func (s *Service) DeleteMac(c *gin.Context) {
 	var req proto.DeleteMacReq
 	var rsp proto.Response
@@ -85,7 +133,8 @@ func (s *Service) DeleteMac(c *gin.Context) {
 	var newMacs []string
 
 	for _, mac := range macs {
-		if req.Mac != mac {
+		parts := strings.Split(mac, " ")
+		if req.Mac != parts[0] {
 			newMacs = append(newMacs, mac)
 		}
 	}
@@ -164,7 +213,8 @@ func isMacExist(mac string) bool {
 
 	macs := strings.Split(string(content), "\n")
 	for _, item := range macs {
-		if mac == item {
+		parts := strings.Split(item, " ")
+		if mac == parts[0] {
 			return true
 		}
 	}

server/service/stream/direct/h264.go

@@ -0,0 +1,104 @@
+package direct
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	log "github.com/sirupsen/logrus"
+
+	"NanoKVM-Server/common"
+)
+
+type Frame struct {
+	IsKeyFrame bool   `json:"isKeyFrame"`
+	Data       string `json:"data"`
+	Timestamp  int64  `json:"timestamp"`
+}
+
+var (
+	mutex    = sync.Mutex{}
+	wsMap    = make(map[*websocket.Conn]bool)
+	upgrader = websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool {
+			return true
+		},
+	}
+)
+
+func Connect(c *gin.Context) {
+	ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		log.Errorf("failed to create websocket: %s", err)
+		return
+	}
+
+	defer func() {
+		_ = ws.Close()
+		log.Debugf("h264 websocket disconnected")
+	}()
+
+	var zeroTime time.Time
+	_ = ws.SetReadDeadline(zeroTime)
+
+	mutex.Lock()
+	wsMap[ws] = true
+	if len(wsMap) == 1 {
+		go send()
+	}
+	mutex.Unlock()
+
+	_, _, err = ws.ReadMessage()
+	if err != nil {
+		mutex.Lock()
+		delete(wsMap, ws)
+		mutex.Unlock()
+		log.Debugf("failed to read message: %s", err)
+	}
+}
+
+func send() {
+	screen := common.GetScreen()
+	common.CheckScreen()
+
+	fps := screen.FPS
+	duration := time.Second / time.Duration(fps)
+
+	ticker := time.NewTicker(duration)
+	defer ticker.Stop()
+
+	vision := common.GetKvmVision()
+	startTime := time.Now()
+
+	for range ticker.C {
+		if len(wsMap) == 0 {
+			return
+		}
+
+		data, result := vision.ReadH264(screen.Width, screen.Height, screen.BitRate)
+		if result < 0 {
+			continue
+		}
+
+		frameMsg := Frame{
+			IsKeyFrame: result == 3,
+			Data:       base64.StdEncoding.EncodeToString(data),
+			Timestamp:  time.Since(startTime).Microseconds(),
+		}
+
+		frameJSON, err := json.Marshal(frameMsg)
+		if err != nil {
+			continue
+		}
+
+		for ws := range wsMap {
+			if err := ws.WriteMessage(websocket.TextMessage, frameJSON); err != nil {
+				log.Debugf("failed to write message: %s", err)
+			}
+		}
+	}
+}

server/service/stream/h264/client.go

@@ -2,6 +2,7 @@ package h264
 
 import (
 	"encoding/json"
+	"sync"
 
 	"github.com/gorilla/websocket"
 	"github.com/pion/webrtc/v4"
@@ -9,8 +10,9 @@ import (
 )
 
 type Client struct {
-	ws *websocket.Conn
-	pc *webrtc.PeerConnection
+	ws    *websocket.Conn
+	pc    *webrtc.PeerConnection
+	mutex sync.Mutex
 }
 
 type Message struct {
@@ -36,9 +38,7 @@ func (c *Client) addTrack() {
 		return
 	}
 
-	mutex.Lock()
 	trackMap[c.ws] = videoTrack
-	mutex.Unlock()
 }
 
 // register callback events
@@ -61,13 +61,9 @@ func (c *Client) register() {
 	// ICE connection state has changed
 	c.pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
 		if state == webrtc.ICEConnectionStateConnected && !isSending {
-			mutex.Lock()
-			if !isSending {
-				// start sending h264 data
-				go send()
-				isSending = true
-			}
-			mutex.Unlock()
+			// start sending h264 data
+			go send()
+			isSending = true
 		}
 
 		log.Debugf("ice connection state has changed to %s", state.String())
@@ -81,13 +77,11 @@ func (c *Client) readMessage() {
 	for {
 		_, raw, err := c.ws.ReadMessage()
 		if err != nil {
-			mutex.Lock()
 			delete(trackMap, c.ws)
-			if len(trackMap) == 0 && isSending {
+			if isSending && len(trackMap) == 0 {
 				// stop sending when all websocket connections are closed
-				exitSig <- true
+				isSending = false
 			}
-			mutex.Unlock()
 
 			log.Debugf("failed to read message: %s", err)
 			return
@@ -155,8 +149,8 @@ func (c *Client) readMessage() {
 
 // send websocket message
 func (c *Client) sendMessage(event string, data string) error {
-	mutex.RLock()
-	defer mutex.RUnlock()
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
 
 	message := &Message{
 		Event: event,

server/service/stream/h264/h264.go

@@ -4,6 +4,7 @@ import (
 	"NanoKVM-Server/config"
 	"net/http"
 	"sync"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/websocket"
@@ -18,9 +19,7 @@ var (
 		},
 	}
 	trackMap  = make(map[*websocket.Conn]*webrtc.TrackLocalStaticSample)
-	mutex     = sync.RWMutex{}
 	isSending = false
-	exitSig   = make(chan bool, 1)
 )
 
 func Connect(c *gin.Context) {
@@ -35,11 +34,14 @@ func Connect(c *gin.Context) {
 		log.Debugf("h264 websocket disconnected")
 	}()
 
+	var zeroTime time.Time
+	_ = wsConn.SetReadDeadline(zeroTime)
+
 	conf := config.GetInstance()
 
 	var iceServers []webrtc.ICEServer
 
-	if conf.Stun != "" {
+	if conf.Stun != "" && conf.Stun != "disable" {
 		iceServers = append(iceServers, webrtc.ICEServer{
 			URLs: []string{"stun:" + conf.Stun},
 		})
@@ -53,11 +55,9 @@ func Connect(c *gin.Context) {
 		})
 	}
 
-	rtc_config := webrtc.Configuration{
+	peerConn, err := webrtc.NewPeerConnection(webrtc.Configuration{
 		ICEServers: iceServers,
-	}
-
-	peerConn, err := webrtc.NewPeerConnection(rtc_config)
+	})
 	if err != nil {
 		log.Errorf("failed to create PeerConnection: %s", err)
 		return
@@ -69,8 +69,9 @@ func Connect(c *gin.Context) {
 	}()
 
 	client := &Client{
-		ws: wsConn,
-		pc: peerConn,
+		ws:    wsConn,
+		pc:    peerConn,
+		mutex: sync.Mutex{},
 	}
 
 	client.addTrack()

server/service/stream/h264/sender.go

@@ -2,7 +2,6 @@ package h264
 
 import (
 	"NanoKVM-Server/common"
-	"NanoKVM-Server/service/stream"
 	"time"
 
 	"github.com/pion/webrtc/v4/pkg/media"
@@ -11,6 +10,8 @@ import (
 
 func send() {
 	screen := common.GetScreen()
+	common.CheckScreen()
+
 	fps := screen.FPS
 	duration := time.Second / time.Duration(fps)
 
@@ -18,63 +19,33 @@ func send() {
 	defer ticker.Stop()
 
 	vision := common.GetKvmVision()
-	for {
-		select {
-		case <-ticker.C:
-			height := screen.Height
-			width, ok := common.ResolutionMap[height]
-			if !ok {
-				width = 0
-				height = 0
-			}
-
-			bitRate := screen.BitRate
-			if _, ok := common.BitRateMap[bitRate]; !ok {
-				bitRate = 3000
-			}
-
-			data, sps, pps, result := vision.ReadH264(width, height, bitRate)
-			if result < 0 {
-				continue
-			}
-
-			if result == 3 {
-				writeSample(sps, duration)
-				writeSample(pps, duration)
-			}
-			writeSample(data, duration)
-
-			stream.GetFrameRateCounter().Update()
-
-			if screen.FPS != fps {
-				fps = screen.FPS
-				duration = time.Second / time.Duration(fps)
-				ticker.Reset(duration)
-			}
-
-		case <-exitSig:
-			mutex.Lock()
-			isSending = false
-			mutex.Unlock()
+	for range ticker.C {
+		if !isSending && len(trackMap) == 0 {
 			return
 		}
-	}
-}
 
-func writeSample(data []byte, duration time.Duration) {
-	sample := media.Sample{
-		Data:     data,
-		Duration: duration,
-	}
+		data, result := vision.ReadH264(screen.Width, screen.Height, screen.BitRate)
+		if result < 0 {
+			continue
+		}
 
-	mutex.RLock()
-	defer mutex.RUnlock()
+		sample := media.Sample{
+			Data:     data,
+			Duration: duration,
+		}
 
-	for _, track := range trackMap {
-		if err := track.WriteSample(sample); err != nil {
-			log.Errorf("failed to send h264 data: %s", err)
+		for _, track := range trackMap {
+			if err := track.WriteSample(sample); err != nil {
+				log.Errorf("failed to send h264 data: %s", err)
+			}
+		}
+
+		log.Debugf("send h264 data: %d", len(data))
+
+		if screen.FPS != fps {
+			fps = screen.FPS
+			duration = time.Second / time.Duration(fps)
+			ticker.Reset(duration)
 		}
 	}
-
-	log.Debugf("send h264 data: %d", len(data))
 }

server/service/stream/mjpeg/frame-detect.go

@@ -1,132 +1,55 @@
 package mjpeg
 
 import (
-	"errors"
-	"os"
+	"NanoKVM-Server/common"
+	"NanoKVM-Server/proto"
 	"time"
 
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
-
-	"NanoKVM-Server/proto"
 )
 
-const (
-	frameDetect    = "/etc/kvm/frame_detact"
-	frameDetectTmp = "/etc/kvm/frame_detact_tmp"
-)
-
-type UpdateFrameDetectRsp struct {
-	Enabled bool `json:"enabled"`
-}
-
-func GetFrameDetect(c *gin.Context) {
-	var rsp proto.Response
-
-	isEnabled, err := isFrameDetectEnabled()
-	if err != nil {
-		rsp.ErrRsp(c, -1, "unknown frame detect status")
-		return
-	}
-
-	rsp.OkRspWithData(c, &proto.GetFrameDetectRsp{
-		Enabled: isEnabled,
-	})
-	log.Debugf("get frame detect success, enabled: %t", isEnabled)
-}
+const FrameDetectInterval uint8 = 60
 
 func UpdateFrameDetect(c *gin.Context) {
+	var req proto.UpdateFrameDetectReq
 	var rsp proto.Response
 
-	isEnabled, err := isFrameDetectEnabled()
-	if err != nil {
-		rsp.ErrRsp(c, -1, "unknown frame status")
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid parameters")
 		return
 	}
 
-	if isEnabled {
-		_ = os.Remove(frameDetect)
-		_ = os.Remove(frameDetectTmp)
-	} else {
-		file, err2 := os.OpenFile(frameDetect, os.O_CREATE|os.O_TRUNC, 0o644)
-		if err2 != nil {
-			rsp.ErrRsp(c, -3, "enable frame detect failed")
-			return
-		}
-		defer func() {
-			_ = file.Close()
-		}()
+	var frame uint8 = 0
+	if req.Enabled {
+		frame = FrameDetectInterval
 	}
 
-	isEnabled, err = isFrameDetectEnabled()
-	if err != nil {
-		rsp.ErrRsp(c, -4, "unknown frame status")
-		return
-	}
+	common.GetKvmVision().SetFrameDetect(frame)
 
-	rsp.OkRspWithData(c, &UpdateFrameDetectRsp{
-		Enabled: isEnabled,
-	})
-	log.Debugf("update frame detect success, enabled: %t", isEnabled)
+	rsp.OkRsp(c)
+	log.Debugf("update frame detect: %t", req.Enabled)
 }
 
 func StopFrameDetect(c *gin.Context) {
+	var req proto.StopFrameDetectReq
 	var rsp proto.Response
 
-	exist, err := isFileExist(frameDetect)
-	if err != nil {
-		rsp.ErrRsp(c, -1, "unknown frame status")
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid parameters")
 		return
 	}
 
-	if !exist {
-		rsp.OkRsp(c)
-		return
+	duration := 10 * time.Second
+	if req.Duration > 0 {
+		duration = time.Duration(req.Duration) * time.Second
 	}
 
-	err = os.Rename(frameDetect, frameDetectTmp)
-	if err != nil {
-		rsp.ErrRsp(c, -2, "stop operation failed")
-		return
-	}
+	vision := common.GetKvmVision()
 
-	go func() {
-		time.Sleep(20 * time.Second)
-		_ = os.Rename(frameDetectTmp, frameDetect)
-		log.Debug("frame detect started")
-	}()
+	vision.SetFrameDetect(0)
+	time.Sleep(duration)
+	vision.SetFrameDetect(FrameDetectInterval)
 
 	rsp.OkRsp(c)
-	log.Debug("frame detect stopped")
-}
-
-func isFrameDetectEnabled() (bool, error) {
-	exist, err := isFileExist(frameDetect)
-	if err != nil {
-		return false, err
-	}
-
-	if exist {
-		return true, nil
-	}
-
-	exist, err = isFileExist(frameDetectTmp)
-	if err != nil {
-		return false, err
-	}
-
-	return exist, nil
-}
-
-func isFileExist(name string) (bool, error) {
-	_, err := os.Stat(name)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return false, nil
-		}
-
-		return false, nil
-	}
-
-	return true, nil
 }

server/service/stream/mjpeg/mjpeg.go

@@ -11,8 +11,8 @@ import (
 )
 
 var (
-	chanMap = make(map[*gin.Context]chan struct{})
-	mutex   = sync.RWMutex{}
+	chanMap = make(map[*gin.Context]bool)
+	mutex   = sync.Mutex{}
 	exitSig = make(chan bool, 1)
 )
 
@@ -23,13 +23,13 @@ func Connect(c *gin.Context) {
 	c.Header("Pragma", "no-cache")
 
 	mutex.Lock()
-	chanMap[c] = make(chan struct{}, 1)
+	chanMap[c] = true
 	if len(chanMap) == 1 {
 		go send()
 	}
 	mutex.Unlock()
 
-	<-chanMap[c]
+	<-c.Request.Context().Done()
 
 	mutex.Lock()
 	delete(chanMap, c)
@@ -41,6 +41,8 @@ func Connect(c *gin.Context) {
 
 func send() {
 	screen := common.GetScreen()
+	common.CheckScreen()
+
 	fps := screen.FPS
 
 	ticker := time.NewTicker(time.Second / time.Duration(fps))
@@ -50,27 +52,14 @@ func send() {
 	for {
 		select {
 		case <-ticker.C:
-			height := screen.Height
-			width, ok := common.ResolutionMap[height]
-			if !ok {
-				width = 0
-				height = 0
-			}
-
-			quality := screen.Quality
-			if _, ok := common.QualityMap[quality]; !ok {
-				quality = 80
-			}
-
-			data, result := vision.ReadMjpeg(width, height, quality)
-			if result < 0 {
+			data, result := vision.ReadMjpeg(screen.Width, screen.Height, screen.Quality)
+			if result < 0 || result == 5 {
 				continue
 			}
 
-			for c, ch := range chanMap {
+			for c := range chanMap {
 				if err := write(c, data); err != nil {
 					log.Debugf("failed to write mjpeg data: %s", err)
-					close(ch)
 				}
 			}
 			log.Debugf("send mjpeg data: %d", len(data))

server/service/vm/gpio.go

@@ -23,12 +23,13 @@ func (s *Service) SetGpio(c *gin.Context) {
 	}
 
 	device := ""
+	conf := config.GetInstance().Hardware
 
 	switch req.Type {
 	case "power":
-		device = s.config.Hardware.GPIOPower
+		device = conf.GPIOPower
 	case "reset":
-		device = s.config.Hardware.GPIOReset
+		device = conf.GPIOReset
 	default:
 		rsp.ErrRsp(c, -2, fmt.Sprintf("invalid power event: %s", req.Type))
 		return
@@ -53,15 +54,17 @@ func (s *Service) SetGpio(c *gin.Context) {
 func (s *Service) GetGpio(c *gin.Context) {
 	var rsp proto.Response
 
-	pwr, err := readGpio(s.config.Hardware.GPIOPowerLED)
+	conf := config.GetInstance().Hardware
+
+	pwr, err := readGpio(conf.GPIOPowerLED)
 	if err != nil {
 		rsp.ErrRsp(c, -2, fmt.Sprintf("failed to read power led: %s", err))
 		return
 	}
 
 	hdd := false
-	if s.config.Hardware.Version == config.HWVersionAlpha {
-		hdd, err = readGpio(s.config.Hardware.GPIOHDDLed)
+	if conf.Version == config.HWVersionAlpha {
+		hdd, err = readGpio(conf.GPIOHDDLed)
 		if err != nil {
 			rsp.ErrRsp(c, -2, fmt.Sprintf("failed to read hdd led: %s", err))
 			return

server/service/vm/hostname.go

@@ -0,0 +1,57 @@
+package vm
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"NanoKVM-Server/proto"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	BootHostnameFile = "/boot/hostname"
+	EtcHostname      = "/etc/hostname"
+)
+
+func (s *Service) SetHostname(c *gin.Context) {
+	var req proto.SetHostnameReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	data := []byte(fmt.Sprintf("%s", req.Hostname))
+
+	if err := os.WriteFile(BootHostnameFile, data, 0o644); err != nil {
+		rsp.ErrRsp(c, -2, "failed to write data")
+		return
+	}
+
+	if err := os.WriteFile(EtcHostname, data, 0o644); err != nil {
+		rsp.ErrRsp(c, -3, "failed to write data")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("set Hostname: %s", req.Hostname)
+}
+
+func (s *Service) GetHostname(c *gin.Context) {
+	var rsp proto.Response
+
+	data, err := os.ReadFile(EtcHostname)
+	if err != nil {
+		rsp.ErrRsp(c, -1, "read Hostname failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetHostnameRsp{
+		Hostname: strings.Replace(string(data), "\n", "", -1),
+	})
+	log.Debugf("get Hostname successful")
+}

server/service/vm/info.go

@@ -3,7 +3,6 @@ package vm
 import (
 	"NanoKVM-Server/config"
 	"fmt"
-	"net"
 	"os"
 	"strings"
 
@@ -18,14 +17,15 @@ var imageVersionMap = map[string]string{
 	"2024-07-23-20-18-587710.img": "v1.1.0",
 	"2024-08-08-19-44-bef2ca.img": "v1.2.0",
 	"2024-11-13-09-59-9c961a.img": "v1.3.0",
-	"2025-02-17-16-59-3649fe.img": "v1.4.0",
+	"2025-02-17-19-08-3649fe.img": "v1.4.0",
+	"2025-04-17-14-21-98d17d.img": "v1.4.1",
 }
 
 func (s *Service) GetInfo(c *gin.Context) {
 	var rsp proto.Response
 
 	data := &proto.GetInfoRsp{
-		Ip:          getIp(),
+		IPs:         getIPs(),
 		Mdns:        getMdns(),
 		Image:       getImageVersion(),
 		Application: getApplicationVersion(),
@@ -36,23 +36,31 @@ func (s *Service) GetInfo(c *gin.Context) {
 	log.Debug("get vm information success")
 }
 
-func getIp() string {
-	addressList, err := net.InterfaceAddrs()
+func getIPs() (ips []proto.IP) {
+	interfaces, err := GetInterfaceInfos()
 	if err != nil {
-		return ""
+		return
 	}
 
-	for _, address := range addressList {
-		if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.To4() != nil {
-			ip := ipnet.IP.String()
-			return ip
+	for _, iface := range interfaces {
+		if iface.IP.To4() != nil {
+			ips = append(ips, proto.IP{
+				Name:    iface.Name,
+				Addr:    iface.IP.String(),
+				Version: "IPv4",
+				Type:    iface.Type,
+			})
 		}
 	}
 
-	return ""
+	return
 }
 
 func getMdns() string {
+	if pid := getAvahiDaemonPid(); pid == "" {
+		return ""
+	}
+
 	content, err := os.ReadFile("/etc/hostname")
 	if err != nil {
 		return ""

server/service/vm/ip.go

@@ -0,0 +1,107 @@
+package vm
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	Wired    = "Wired"
+	Wireless = "Wireless"
+	Other    = "Other"
+)
+
+type InterfaceInfo struct {
+	Name string
+	Type string
+	IP   net.IP
+}
+
+func GetInterfaceInfos() ([]*InterfaceInfo, error) {
+	var interfaceInfos []*InterfaceInfo
+
+	interfaces, err := net.Interfaces()
+	if err != nil {
+		log.Errorf("failed to get net interfaces: %s", err)
+		return nil, err
+	}
+
+	for _, iface := range interfaces {
+		info := getInterfaceInfo(iface)
+		if info != nil {
+			interfaceInfos = append(interfaceInfos, info)
+		}
+	}
+
+	if len(interfaceInfos) == 0 {
+		return nil, fmt.Errorf("no valid IP address")
+	}
+
+	return interfaceInfos, nil
+}
+
+func getInterfaceInfo(iface net.Interface) *InterfaceInfo {
+	if iface.Flags&net.FlagUp == 0 {
+		return nil
+	}
+
+	interfaceType := getInterfaceType(iface)
+	if interfaceType == Other {
+		return nil
+	}
+
+	interfaceIP := getInterfaceIP(iface)
+	if interfaceIP == nil {
+		return nil
+	}
+
+	return &InterfaceInfo{
+		Name: iface.Name,
+		Type: interfaceType,
+		IP:   interfaceIP,
+	}
+}
+
+func getInterfaceType(iface net.Interface) string {
+	if strings.HasPrefix(iface.Name, "eth") || strings.HasPrefix(iface.Name, "en") {
+		return Wired
+	}
+
+	if strings.HasPrefix(iface.Name, "wlan") || strings.HasPrefix(iface.Name, "wl") {
+		return Wireless
+	}
+
+	return Other
+}
+
+func getInterfaceIP(iface net.Interface) net.IP {
+	addrs, err := iface.Addrs()
+	if err != nil {
+		log.Errorf("failed to get interface addresses: %s", err)
+		return nil
+	}
+
+	for _, addr := range addrs {
+		var ip net.IP
+
+		switch v := addr.(type) {
+		case *net.IPNet:
+			ip = v.IP
+		case *net.IPAddr:
+			ip = v.IP
+		default:
+			continue
+		}
+
+		if ip == nil {
+			continue
+		}
+
+		return ip
+	}
+
+	return nil
+}

server/service/vm/jiggler/jiggler.go

@@ -0,0 +1,119 @@
+package jiggler
+
+import (
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	ConfigFile = "/etc/kvm/mouse-jiggler"
+	Interval   = 15 * time.Second
+)
+
+var (
+	jiggler Jiggler
+	once    sync.Once
+)
+
+type Jiggler struct {
+	mutex       sync.Mutex
+	enabled     bool
+	running     bool
+	mode        string
+	lastUpdated time.Time
+}
+
+func GetJiggler() *Jiggler {
+	once.Do(func() {
+		jiggler = Jiggler{
+			mutex:       sync.Mutex{},
+			enabled:     false,
+			running:     false,
+			mode:        "relative",
+			lastUpdated: time.Now(),
+		}
+
+		content, err := os.ReadFile(ConfigFile)
+		if err != nil {
+			return
+		}
+
+		mode := strings.ReplaceAll(string(content), "\n", "")
+		if mode != "" {
+			jiggler.mode = mode
+		}
+
+		jiggler.enabled = true
+	})
+
+	return &jiggler
+}
+
+func (j *Jiggler) Enable(mode string) error {
+	err := os.WriteFile(ConfigFile, []byte(mode), 0644)
+	if err != nil {
+		return err
+	}
+
+	j.enabled = true
+	j.mode = mode
+	j.Run()
+
+	return nil
+}
+
+func (j *Jiggler) Disable() error {
+	if err := os.Remove(ConfigFile); err != nil {
+		return err
+	}
+
+	j.enabled = false
+	j.mode = "relative"
+
+	return nil
+}
+
+func (j *Jiggler) Run() {
+	if !j.enabled || j.running {
+		return
+	}
+
+	j.mutex.Lock()
+	j.running = true
+	j.mutex.Unlock()
+
+	j.Update()
+
+	go func() {
+		ticker := time.NewTicker(Interval)
+		defer ticker.Stop()
+
+		for range ticker.C {
+			if !j.enabled {
+				j.running = false
+				return
+			}
+
+			if time.Since(j.lastUpdated) > Interval {
+				move(j.mode)
+				j.Update()
+			}
+		}
+	}()
+}
+
+func (j *Jiggler) Update() {
+	if j.running {
+		j.lastUpdated = time.Now()
+	}
+}
+
+func (j *Jiggler) IsEnabled() bool {
+	return j.enabled
+}
+
+func (j *Jiggler) GetMode() string {
+	return j.mode
+}

server/service/vm/jiggler/mouse.go

@@ -0,0 +1,55 @@
+package jiggler
+
+import (
+	"os"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+func move(mode string) {
+	var (
+		hid  string
+		data [][]byte
+	)
+
+	if mode == "absolute" {
+		hid = "/dev/hidg2"
+		data = [][]byte{
+			{0x00, 0x00, 0x3f, 0x00, 0x3f, 0x00},
+			{0x00, 0xff, 0x3f, 0xff, 0x3f, 0x00},
+		}
+	} else {
+		hid = "/dev/hidg1"
+		data = [][]byte{
+			{0x00, 0x0a, 0x0a, 0x00},
+			{0x00, 0xf6, 0xf6, 0x00},
+		}
+	}
+
+	write(hid, data)
+}
+
+func write(hid string, data [][]byte) {
+	file, err := os.OpenFile(hid, os.O_WRONLY, 0o666)
+	if err != nil {
+		log.Errorf("failed to open %s: %s", hid, err)
+		return
+	}
+	defer func() {
+		_ = file.Close()
+	}()
+
+	for _, b := range data {
+		deadline := time.Now().Add(8 * time.Millisecond)
+		if err := file.SetWriteDeadline(deadline); err != nil {
+			log.Errorf("failed to set deadline: %s", err)
+			return
+		}
+
+		if _, err := file.Write(b); err != nil {
+			log.Errorf("failed to write: %s", err)
+			return
+		}
+	}
+}

server/service/vm/mdns.go

@@ -0,0 +1,92 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	AvahiDaemonPid          = "/run/avahi-daemon/pid"
+	AvahiDaemonScript       = "/etc/init.d/S50avahi-daemon"
+	AvahiDaemonBackupScript = "/kvmapp/system/init.d/S50avahi-daemon"
+)
+
+func (s *Service) GetMdnsState(c *gin.Context) {
+	var rsp proto.Response
+
+	pid := getAvahiDaemonPid()
+
+	rsp.OkRspWithData(c, &proto.GetMdnsStateRsp{
+		Enabled: pid != "",
+	})
+}
+
+func (s *Service) EnableMdns(c *gin.Context) {
+	var rsp proto.Response
+
+	pid := getAvahiDaemonPid()
+	if pid != "" {
+		rsp.OkRsp(c)
+		return
+	}
+
+	commands := []string{
+		fmt.Sprintf("cp -f %s %s", AvahiDaemonBackupScript, AvahiDaemonScript),
+		fmt.Sprintf("%s start", AvahiDaemonScript),
+	}
+
+	command := strings.Join(commands, " && ")
+	err := exec.Command("sh", "-c", command).Run()
+	if err != nil {
+		log.Errorf("failed to start avahi-daemon: %s", err)
+		rsp.ErrRsp(c, -1, "failed to enable mdns")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("avahi-daemon started")
+}
+
+func (s *Service) DisableMdns(c *gin.Context) {
+	var rsp proto.Response
+
+	pid := getAvahiDaemonPid()
+	if pid == "" {
+		rsp.OkRsp(c)
+		return
+	}
+
+	command := fmt.Sprintf("kill -9 %s", pid)
+	err := exec.Command("sh", "-c", command).Run()
+	if err != nil {
+		log.Errorf("failed to stop avahi-daemon: %s", err)
+		rsp.ErrRsp(c, -1, "failed to disable mdns")
+		return
+	}
+
+	_ = os.Remove(AvahiDaemonPid)
+	_ = os.Remove(AvahiDaemonScript)
+
+	rsp.OkRsp(c)
+	log.Debugf("avahi-daemon stopped")
+}
+
+func getAvahiDaemonPid() string {
+	if _, err := os.Stat(AvahiDaemonPid); err != nil {
+		return ""
+	}
+
+	content, err := os.ReadFile(AvahiDaemonPid)
+	if err != nil {
+		log.Errorf("failed to read mdns pid: %s", err)
+		return ""
+	}
+
+	return strings.ReplaceAll(string(content), "\n", "")
+}

server/service/vm/mouse-jiggler.go

@@ -0,0 +1,49 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/service/vm/jiggler"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+func (s *Service) GetMouseJiggler(c *gin.Context) {
+	var rsp proto.Response
+
+	mouseJiggler := jiggler.GetJiggler()
+
+	data := &proto.GetMouseJigglerRsp{
+		Enabled: mouseJiggler.IsEnabled(),
+		Mode:    mouseJiggler.GetMode(),
+	}
+
+	rsp.OkRspWithData(c, data)
+}
+
+func (s *Service) SetMouseJiggler(c *gin.Context) {
+	var req proto.SetMouseJigglerReq
+	var rsp proto.Response
+
+	err := proto.ParseFormRequest(c, &req)
+	if err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	mouseJiggler := jiggler.GetJiggler()
+
+	if req.Enabled {
+		err = mouseJiggler.Enable(req.Mode)
+	} else {
+		err = mouseJiggler.Disable()
+	}
+
+	if err != nil {
+		rsp.ErrRsp(c, -2, "operation failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("set mouse jiggler: %t", req.Enabled)
+}

server/service/vm/screen.go

@@ -4,6 +4,7 @@ import (
 	"NanoKVM-Server/common"
 	"fmt"
 	"os"
+	"strconv"
 
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
@@ -22,30 +23,34 @@ func (s *Service) SetScreen(c *gin.Context) {
 	var req proto.SetScreenReq
 	var rsp proto.Response
 
-	if err := proto.ParseFormRequest(c, &req); err != nil {
+	err := proto.ParseFormRequest(c, &req)
+	if err != nil {
 		rsp.ErrRsp(c, -1, "invalid arguments")
 		return
 	}
 
-	file, ok := screenFileMap[req.Type]
-	if !ok {
-		rsp.ErrRsp(c, -2, "invalid arguments")
-		return
-	}
-
-	data := fmt.Sprintf("%d", req.Value)
-	if req.Type == "type" {
+	switch req.Type {
+	case "type":
+		data := "h264"
 		if req.Value == 0 {
 			data = "mjpeg"
-		} else {
-			data = "h264"
 		}
+		err = writeScreen("type", data)
+
+	case "gop":
+		gop := 30
+		if req.Value >= 1 && req.Value <= 100 {
+			gop = req.Value
+		}
+		common.GetKvmVision().SetGop(uint8(gop))
+
+	default:
+		data := strconv.Itoa(req.Value)
+		err = writeScreen(req.Type, data)
 	}
 
-	err := os.WriteFile(file, []byte(data), 0o666)
 	if err != nil {
-		log.Errorf("write kvm %s failed: %s", file, err)
-		rsp.ErrRsp(c, -3, "update screen failed")
+		rsp.ErrRsp(c, -2, "update screen failed")
 		return
 	}
 
@@ -54,3 +59,18 @@ func (s *Service) SetScreen(c *gin.Context) {
 	log.Debugf("update screen: %+v", req)
 	rsp.OkRsp(c)
 }
+
+func writeScreen(key string, value string) error {
+	file, ok := screenFileMap[key]
+	if !ok {
+		return fmt.Errorf("invalid argument %s", key)
+	}
+
+	err := os.WriteFile(file, []byte(value), 0o666)
+	if err != nil {
+		log.Errorf("write kvm %s failed: %s", file, err)
+		return err
+	}
+
+	return nil
+}

server/service/vm/service.go

@@ -1,15 +1,8 @@
 package vm
 
-import (
-	"NanoKVM-Server/config"
-)
-
 type Service struct {
-	config *config.Config
 }
 
 func NewService() *Service {
-	return &Service{
-		config: config.GetInstance(),
-	}
+	return &Service{}
 }

server/service/vm/swap.go

@@ -0,0 +1,176 @@
+package vm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"NanoKVM-Server/proto"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	SwapFile    = "/swapfile"
+	InittabPath = "/etc/inittab"
+	TempInittab = "/etc/.inittab.tmp"
+)
+
+func (s *Service) GetSwap(c *gin.Context) {
+	var rsp proto.Response
+
+	rsp.OkRspWithData(c, &proto.GetSwapRsp{
+		Size: getSwapSize(),
+	})
+}
+
+func (s *Service) SetSwap(c *gin.Context) {
+	var rsp proto.Response
+	var req proto.SetSwapReq
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	size := getSwapSize()
+	if req.Size == size {
+		rsp.OkRsp(c)
+		return
+	}
+
+	if req.Size == 0 {
+		if err := disableSwap(); err != nil {
+			rsp.ErrRsp(c, -2, "disable swap failed")
+			return
+		}
+		if err := disableInittab(); err != nil {
+			rsp.ErrRsp(c, -3, "disable inittab failed")
+			return
+		}
+	} else {
+		if err := enableSwap(req.Size); err != nil {
+			rsp.ErrRsp(c, -4, "enable swap failed")
+			return
+		}
+		if err := enableInittab(); err != nil {
+			rsp.ErrRsp(c, -5, "enable inittab failed")
+			return
+		}
+	}
+
+	rsp.OkRsp(c)
+}
+
+func getSwapSize() int64 {
+	fileInfo, err := os.Stat(SwapFile)
+	if err != nil {
+		return 0
+	}
+
+	return fileInfo.Size() / 1024 / 1024
+}
+
+func enableSwap(size int64) error {
+	if getSwapSize() > 0 {
+		if err := disableSwap(); err != nil {
+			return err
+		}
+	}
+
+	commands := []string{
+		fmt.Sprintf("fallocate -l %dM %s", size, SwapFile),
+		fmt.Sprintf("chmod 600 %s", SwapFile),
+		fmt.Sprintf("mkswap %s", SwapFile),
+		fmt.Sprintf("swapon %s", SwapFile),
+	}
+
+	for _, command := range commands {
+		err := exec.Command("sh", "-c", command).Run()
+		if err != nil {
+			log.Errorf("failed to execute %s: %s", command, err)
+			return err
+		}
+
+		time.Sleep(300 * time.Millisecond)
+	}
+
+	log.Debugf("set swap file size: %d", size)
+	return nil
+}
+
+func disableSwap() error {
+	command := "swapoff -a"
+	if err := exec.Command("sh", "-c", command).Run(); err != nil {
+		log.Errorf("failed to execute swapoff: %s", err)
+		return err
+	}
+
+	if err := os.Remove(SwapFile); err != nil {
+		log.Errorf("failed to delete %s: %s", SwapFile, err)
+		return err
+	}
+
+	return nil
+}
+
+func enableInittab() error {
+	f, err := os.OpenFile(InittabPath, os.O_APPEND|os.O_WRONLY, 0644)
+	if err != nil {
+		log.Errorf("read inittab failed: %s", err)
+		return err
+	}
+	defer func() {
+		_ = f.Close()
+	}()
+
+	content := fmt.Sprintf("\nsi11::sysinit:/sbin/swapon %s", SwapFile)
+	_, err = f.WriteString(content)
+	if err != nil {
+		log.Errorf("write inittab failed: %s", err)
+		return err
+	}
+
+	log.Debugf("write to %s: %s", InittabPath, content)
+	return nil
+}
+
+func disableInittab() error {
+	defer func() {
+		_ = os.Remove(TempInittab)
+	}()
+
+	input, err := os.ReadFile(InittabPath)
+	if err != nil {
+		log.Errorf("read fstab failed: %s", err)
+		return err
+	}
+
+	lines := strings.Split(string(input), "\n")
+	output := make([]string, 0)
+
+	for _, line := range lines {
+		if strings.HasSuffix(line, SwapFile) {
+			log.Debugf("%s delete line: %s", InittabPath, line)
+		} else {
+			output = append(output, line)
+		}
+	}
+
+	content := strings.Join(output, "\n")
+	content = strings.TrimSuffix(content, "\n")
+	if err := os.WriteFile(TempInittab, []byte(content), 0644); err != nil {
+		log.Errorf("write temp fstab failed: %s", err)
+		return err
+	}
+
+	if err := os.Rename(TempInittab, InittabPath); err != nil {
+		log.Errorf("replace fstab failed: %s", err)
+		return err
+	}
+
+	return nil
+}

server/service/vm/system.go

@@ -0,0 +1,25 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"os/exec"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+func (s *Service) Reboot(c *gin.Context) {
+	var rsp proto.Response
+
+	log.Println("reboot system...")
+
+	err := exec.Command("reboot").Run()
+	if err != nil {
+		rsp.ErrRsp(c, -1, "operation failed")
+		log.Errorf("failed to reboot: %s", err)
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debug("system rebooted")
+}

server/service/vm/tls.go

@@ -0,0 +1,76 @@
+package vm
+
+import (
+	"fmt"
+	"os/exec"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+
+	"NanoKVM-Server/config"
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/utils"
+)
+
+func (s *Service) SetTls(c *gin.Context) {
+	var req proto.SetTlsReq
+	var rsp proto.Response
+
+	err := proto.ParseFormRequest(c, &req)
+	if err != nil {
+		rsp.ErrRsp(c, -1, fmt.Sprintf("invalid arguments: %s", err))
+		return
+	}
+
+	if req.Enabled {
+		err = enableTls()
+	} else {
+		err = disableTls()
+	}
+
+	if err != nil {
+		log.Errorf("failed to set TLS: %s", err)
+		rsp.ErrRsp(c, -2, "operation failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+
+	_ = exec.Command("sh", "-c", "/etc/init.d/S95nanokvm restart").Run()
+}
+
+func enableTls() error {
+	if err := utils.GenerateCert(); err != nil {
+		return err
+	}
+
+	conf, err := config.Read()
+	if err != nil {
+		return err
+	}
+
+	conf.Proto = "https"
+	conf.Cert.Crt = "/etc/kvm/server.crt"
+	conf.Cert.Key = "/etc/kvm/server.key"
+
+	if err := config.Write(conf); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func disableTls() error {
+	conf, err := config.Read()
+	if err != nil {
+		return err
+	}
+
+	conf.Proto = "http"
+
+	if err := config.Write(conf); err != nil {
+		return err
+	}
+
+	return nil
+}

server/service/vm/web-title.go

@@ -0,0 +1,58 @@
+package vm
+
+import (
+	"os"
+	"strings"
+
+	"NanoKVM-Server/proto"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	WebTitleFile = "/etc/kvm/web-title"
+)
+
+func (s *Service) SetWebTitle(c *gin.Context) {
+	var req proto.SetWebTitleReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	if req.Title == "" || req.Title == "NanoKVM" {
+		err := os.Remove(WebTitleFile)
+		if err != nil {
+			rsp.ErrRsp(c, -2, "reset failed")
+			return
+		}
+	} else {
+		err := os.WriteFile(WebTitleFile, []byte(req.Title), 0o644)
+		if err != nil {
+			rsp.ErrRsp(c, -3, "write failed")
+			return
+		}
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("set web title: %s", req.Title)
+}
+
+func (s *Service) GetWebTitle(c *gin.Context) {
+	var rsp proto.Response
+
+	data, err := os.ReadFile(WebTitleFile)
+	if err != nil {
+		rsp.ErrRsp(c, -1, "read web title failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetWebTitleRsp{
+		Title: strings.Replace(string(data), "\n", "", -1),
+	})
+
+	log.Debugf("get web title successful")
+}

server/service/ws/ws.go

@@ -10,6 +10,7 @@ import (
 	log "github.com/sirupsen/logrus"
 
 	"NanoKVM-Server/service/hid"
+	"NanoKVM-Server/service/vm/jiggler"
 )
 
 const (
@@ -85,6 +86,9 @@ func (c *WsClient) Read() error {
 		} else if event[0] == MouseEvent {
 			c.mouse <- event[1:]
 		}
+
+		// update latest HID operation time
+		jiggler.GetJiggler().Update()
 	}
 }
 

server/utils/cert.go

@@ -0,0 +1,100 @@
+package utils
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"math/big"
+	"net"
+	"os"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+func GenerateCert() error {
+	var (
+		host      = "localhost"
+		ipAddress = []net.IP{net.ParseIP("127.0.0.1"), net.ParseIP("::1")}
+		validFor  = time.Hour * 24 * 365 * 10
+		certFile  = "/etc/kvm/server.crt"
+		keyFile   = "/etc/kvm/server.key"
+	)
+
+	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		log.Errorf("failed to generate RSA private key: %v", err)
+		return err
+	}
+	publicKey := &privateKey.PublicKey
+
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		log.Errorf("failed to generate serial number: %v", err)
+		return err
+	}
+
+	template := x509.Certificate{
+		SerialNumber: serialNumber,
+		Subject: pkix.Name{
+			CommonName: host,
+		},
+		NotBefore:             time.Now(),
+		NotAfter:              time.Now().Add(validFor),
+		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+		IsCA:                  false,
+		DNSNames:              []string{host},
+		IPAddresses:           ipAddress,
+	}
+
+	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey)
+	if err != nil {
+		log.Errorf("failed to create certificate: %v", err)
+		return err
+	}
+
+	// generate certificate
+	certOut, err := os.Create(certFile)
+	if err != nil {
+		log.Errorf("failed to create %s: %v", certFile, err)
+		return err
+	}
+
+	if err := pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
+		log.Errorf("failed to encode %s: %v", certFile, err)
+		return err
+	}
+
+	_ = certOut.Sync()
+	_ = certOut.Close()
+	log.Debugf("%s generated", certFile)
+
+	// generate private key
+	keyOut, err := os.OpenFile(keyFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) // 权限 0600
+	if err != nil {
+		log.Errorf("failed to create %s: %v", keyFile, err)
+		return err
+	}
+
+	privateBytes, err := x509.MarshalPKCS8PrivateKey(privateKey)
+	if err != nil {
+		log.Errorf("failed to marshal private key: %v", err)
+		return err
+	}
+
+	if err := pem.Encode(keyOut, &pem.Block{Type: "PRIVATE KEY", Bytes: privateBytes}); err != nil {
+		log.Errorf("failed to encode %s: %v", keyFile, err)
+		return err
+	}
+
+	_ = keyOut.Sync()
+	_ = keyOut.Close()
+	log.Debugf("%s generated", keyFile)
+
+	return nil
+}

support/README.md

@@ -1,8 +1,5 @@
-## If you want to compile kvm_system yourself, please follow the steps below: 
+# NanoKVM Support Instructions
 
-1. Clone the MaixCDK repository: `git clone https://github.com/sipeed/MaixCDK.git`
-2. Improve the Compilation Environment, refer to [here](https://github.com/sipeed/MaixCDK/tree/main/docs/doc_zh#%E5%BF%AB%E9%80%9F%E5%BC%80%E5%A7%8B)
-3. Copy `./kvm_system` to `~/MaixCDK` and open it in terminal
-4. Execute `maixcdk build` and Select `maixcam` to complete the compilation
-5. Replace `/kvmapp/kvm_system/kvm_system` in the NanoKVM system with `dist/kvm_system_release/kvm_system`
-6. Execute: `/etc/init.d/S95nanokvm restart` on NanoKVM
+`/support` contains auxiliary functions for NanoKVM, such as image subsystem, system status monitoring, system updates, screen key drivers, and a few system functions.
+
+Currently, NanoKVM is divided into two versions based on the main control chip: SG2002 (which includes NanoKVM-Lite/Full/PCIe) and H618 (including NanoKVM-Pro). Different chips have significantly different projects and compilation environments. To distinguish between them, they are stored separately in `/support/sg2002` and `/support/h618`.

support/README_ZH.md

@@ -0,0 +1,5 @@
+# NanoKVM support 说明
+
+`/support`包含NanoKVM辅助性的功能，如图像子系统、系统状态监控、系统更新、屏幕按键驱动和少部分的系统功能
+
+当前 NanoKVM 根据主控芯片的不同分为两个版本：SG2002（包含NanoKVM-Lite/Full/PCIe）和H618（包括NanoKVM-Pro），不同的芯片有差异较大的工程和编译环境，为做区分，将它们分别存放在`/support/sg2002`和`/support/h618`

support/kvm_system/main/lib/system_state/system_state.h

@@ -1,30 +0,0 @@
-#ifndef SYSTEM_STATE_H_
-#define SYSTEM_STATE_H_
-#include "config.h"
-
-enum ip_addr_t
-{
-    ETH_IP=1, WiFi_IP, Tailscale_IP, RNDIS_IP, ETH_ROUTE, WiFi_ROUTE, NULL_IP
-};
-
-// net_port
-int get_ip_addr(ip_addr_t ip_type);
-int chack_net_state(ip_addr_t use_ip_type);
-void patch_eth_wifi(void);
-int kvm_eth_cable_exist();
-int kvm_wifi_exist();
-int kvm_rndis_exist();
-int kvm_tailscale_exist();
-void kvm_update_usb_state();
-void kvm_update_hdmi_state();
-void kvm_update_stream_fps(void);
-void kvm_update_stream_type(void);
-void kvm_update_stream_qlty(void);
-void kvm_update_hdmi_res(void);
-void kvm_update_eth_state(void);
-void kvm_update_wifi_state(void);
-void kvm_update_rndis_state(void);
-void kvm_update_tailscale_state(void);
-uint8_t ion_free_space(void);
-
-#endif // SYSTEM_STATE_H_

support/sg2002/README.md

@@ -0,0 +1,26 @@
+# NanoKVM Support Instructions
+
+## Environment Preparation
+1. NanoKVM-Lite/Full/PCIe is based on the SG2002 as the main control chip. The projects in the support section are compiled under the [MaixCDK](https://github.com/sipeed/MaixCDK) framework. Before compiling, please ensure that the `MaixCDK` environment is correctly configured. For configuration instructions, click [here](https://github.com/sipeed/MaixCDK/blob/main/docs/doc_zh/README.md).
+
+## kvm_system Compilation Instructions
+
+> The `kvm_system` is responsible for monitoring the NanoKVM system status, system updates, screen key drivers, and a few system functions, compiled with MaixCDK.
+
+1. Before compiling, please ensure that the above-mentioned `MaixCDK` environment is correctly configured.
+2. Modify the paths of `MAIXCDK_PATH` and `NanoKVM_PATH` in `./build`.
+3. Execute `./build kvm_system` to compile `kvm_system`.
+4. Use `scp ./kvm_system/dist/kvm_system_release/kvm_system root@192.168.x.x:/kvmapp/kvm_system` to copy it to NanoKVM for testing.
+5. Use `./build add_to_kvmapp` to place the executable file into the `/kvmapp` installation package.
+6. Use `./build kvm_system clean` to clean the compilation of `kvm_system`.
+
+## kvm_vision Compilation Instructions
+
+> `kvm_vision` refers to the image acquisition and encoding subsystem of NanoKVM, compiled with MaixCDK to produce dynamic libraries for Go calls. Use `kvm_vision_test` to compile and test the dynamic library.
+
+1. Before compiling, please ensure that the above-mentioned `MaixCDK` environment is correctly configured.
+2. Modify the paths of `MAIXCDK_PATH` and `NanoKVM_PATH` in `./build`.
+3. Execute `./build kvm_vision` to compile `kvm_vision_test`.
+4. You can test the dynamic libraries in `kvm_vision_test/dist/kvm_vision_test_release/dl_lib/`.
+5. Use `./build add_to_kvmapp` to place the dynamic libraries into the `/kvmapp` installation package.
+6. Use `./build kvm_vision clean` to clean the compilation of `kvm_vision`.

support/sg2002/README_ZH.md

@@ -0,0 +1,26 @@
+# NanoKVM support 说明
+
+## 环境准备
+1. NanoKVM-Lite/Full/PCIe 以SG2002为主控芯片，support 部分的工程在[MaixCDK](https://github.com/sipeed/MaixCDK) 框架下编译。编译前，请保证`MaixCDK`环境已正确配置，配置教程点击[这里](https://github.com/sipeed/MaixCDK/blob/main/docs/doc_zh/README.md)
+
+## kvm_system 编译说明
+
+> `kvm_system` 负责 NanoKVM 系统状态监控、系统更新、屏幕按键驱动和少部分的系统功能，借助 MaixCDK 编译
+
+1. 编译前，请保证上述 1.`MaixCDK`环境已正确配置
+2. 修改 `./build` 中 `MAIXCDK_PATH` 和 `NanoKVM_PATH`的路径
+3. 执行 `./build kvm_system` 编译 kvm_system 
+4. 使用 `scp ./kvm_system/dist/kvm_system_release/kvm_system root@192.168.x.x:/kvmapp/kvm_system` 拷贝入 NanoKVM 测试
+5. 使用 `./build add_to_kvmapp` 可以将可执行文件放入 `/kvmapp` 安装包内
+6. 使用 `./build kvm_system clean` 可以清除 kvm_system 的编译
+
+## kvm_vision 编译说明
+
+> `kvm_vision` 是 NanoKVM 图像获取编码子系统的统称，使用MaixCDK编译出动态库供Go调用，使用 `kvm_vision_test` 编译和测试动态库
+
+1. 编译前，请保证上述 1.`MaixCDK`环境已正确配置
+2. 修改 `./build` 中 `MAIXCDK_PATH` 和 `NanoKVM_PATH`的路径
+3. 执行 `./build kvm_vision` 编译 kvm_vision_test 
+4. 可使用 `kvm_vision_test/dist/kvm_vision_test_release/dl_lib/` 中的动态库测试
+5. 使用 `./build add_to_kvmapp` 可以将动态库放入 `/kvmapp` 安装包内
+6. 使用 `./build kvm_vision clean` 可以清除 kvm_system 的编译

support/sg2002/additional/kvm/include/kvm_vision.h

@@ -19,6 +19,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdlib.h>
 #include <pthread.h>
+#include <time.h>
 
 // #include "kvm_mmf.hpp"
 
@@ -31,7 +32,14 @@ extern "C" {
 #define IMG_H264_TYPE_IF		3
 #define IMG_H264_TYPE_PF		4
 
+#define NORMAL_RES                      0
+#define NEW_RES                         1
+#define UNSUPPORT_RES                   2
+#define UNKNOWN_RES                     3
+#define ERROR_RES                       4
+
 void kvmv_init(uint8_t _debug_info_en = 0);
+void set_venc_auto_recyc(uint8_t _enable);
 /**********************************************************************************
  * @name    kvmv_read_img
  * @author  Sipeed BuGu
@@ -45,22 +53,25 @@ void kvmv_init(uint8_t _debug_info_en = 0);
  * @param	_pp_kvm_data		@output: 	Encode data
  * @param	_p_kvmv_data_size	@output: 	Encode data size
  * @return
+        -7: HDMI INPUT RES ERROR
+        -6: Unsupported resolution, please modify it in the host settings.
+        -5: Retrieving image, please wait
         -4: Modifying image resolution, please wait
         -3: img buffer full
-        -2: VENC Error
+        -2: VENC Errorl
         -1: No images were acquired
          0: Acquire MJPEG encoded images
-         1: Acquire H264 encoded images(SPS)
-         2: Acquire H264 encoded images(PPS)
+         1: Acquire H264 encoded images(SPS)[Deprecated]
+         2: Acquire H264 encoded images(PPS)[Deprecated]
          3: Acquire H264 encoded images(I)
          4: Acquire H264 encoded images(P)
+         5: IMG not changed
  **********************************************************************************/
 int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _qlty, uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size);
-int kvmv_get_sps_frame(uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size);
-int kvmv_get_pps_frame(uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size);
 int free_kvmv_data(uint8_t ** _pp_kvm_data);
 void free_all_kvmv_data();
 void set_h264_gop(uint8_t _gop);
+void set_frame_detact(uint8_t _frame_detact);
 void kvmv_deinit();
 uint8_t kvmv_hdmi_control(uint8_t _en);
 

support/sg2002/additional/kvm/src/kvm_vision.cpp

@@ -19,6 +19,10 @@
 #define KVMV_MAX_TRY_NUM	   	2
 #define vi_min_width            32
 #define vi_min_height           3
+#define vi_max_width            1920
+#define vi_max_height           1080
+
+#define Farame_sample_size      76800   // 320*240
 
 #define default_vi_width        1920
 #define default_vi_height       1080
@@ -30,16 +34,22 @@
 #define default_h264_gop        30
 
 #define kvmv_data_buffer_size   4
+#define Try_rounds_HDMI_err_res 5
 
 #define vi_width_path           "/kvmapp/kvm/width"
 #define vi_height_path          "/kvmapp/kvm/height"
 #define hdmi_mode_path          "/etc/kvm/hdmi_mode"
 #define hdmi_state_path         "/proc/lt_int"
+#define watchdog_mode_path      "/etc/kvm/watchdog"
+#define watchdog_temp_path      "/tmp/watchdog"
+#define watchdog_file           "/tmp/nanokvm_wd"
 
 #define LT6911_ADDR 	0x2B
 #define LT6911_READ 	0xFF
 #define LT6911_WRITE 	0x00
 
+pthread_mutex_t vi_mutex;
+
 static char NanoKVM_edit[] = {
 	0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x41,0x0C,0x33,0xC2,0x66,0xBA,0x00,0x00,
 	0x2B,0x1F,0x01,0x04,0xA5,0x50,0x22,0x78,0x3B,0xCC,0xE5,0xAB,0x51,0x48,0xA6,0x26,
@@ -65,7 +75,7 @@ typedef struct {
 	uint16_t qlty;
 	uint8_t cam_state = 0;
 	uint8_t stream_stop;
-	uint8_t frame_detact;
+	uint8_t frame_detact = 0;
 	uint8_t display;
     uint8_t reinit_flag = 1;
     uint8_t reopen_cam_flag = 0;
@@ -78,7 +88,11 @@ typedef struct {
     uint8_t hdmi_stop_flag = 0;
     uint8_t hdmi_reading_flag = 0;
     uint8_t hdmi_mode = 0;
+    uint8_t hdmi_res_type = 0;
+    uint8_t hdmi_res_err = 0;
+    uint8_t hdmi_try_rounds = 0;
     uint8_t vi_detect_state = 0;
+    uint8_t venc_auto_recyc = 0;
 } kvmv_cfg_t;
 
 typedef struct {
@@ -100,8 +114,6 @@ camera::Camera *cam = new camera::Camera(default_vpss_width, default_vpss_height
 kvmv_cfg_t kvmv_cfg;
 
 kvmv_data_t kvmv_data_buffer[kvmv_data_buffer_size];
-kvmv_data_t kvmv_SPS_buffer = {0};
-kvmv_data_t kvmv_PPS_buffer = {0};
 
 uint8_t kvmv_data_buffer_index = 0;
 
@@ -154,6 +166,44 @@ uint16_t hdmi_res_list[][2] = {
     {800, 600},
 };
 
+uint16_t hdmi_unsupported_res_list[][2] = {
+    {1680, 1050},
+    {1440, 1050},
+    {1400, 1050},
+    {1368, 768},
+    {1366, 768},
+    {720, 576},
+};
+
+/* return 0 : normal res;
+/* return 1 : new res;
+ * return 2 : unsupport res;
+ * return 3 : unknow res;
+ */
+uint8_t check_res(uint16_t _width, uint16_t _height)
+{
+    uint8_t i;
+    uint8_t ret;
+
+    for(i = 0; i < sizeof(hdmi_res_list)/4; i++){
+        if(_width == hdmi_res_list[i][0] && _height == hdmi_res_list[i][1]) return NORMAL_RES;
+    }
+    for(i = 0; i < sizeof(hdmi_unsupported_res_list)/4; i++){
+        if(_width == hdmi_unsupported_res_list[i][0] && _height == hdmi_unsupported_res_list[i][1]) return UNSUPPORT_RES;
+    }
+    return UNKNOWN_RES;
+}
+
+void write_res_to_file(uint16_t _width, uint16_t _height)
+{
+	char Cmd[100]={0};
+    sprintf(Cmd, "echo %d > %s", _width, vi_width_path);
+    system(Cmd);
+    sprintf(Cmd, "echo %d > %s", _height, vi_height_path);
+    system(Cmd);
+    system("sync");
+}
+
 /* return 0 : VI not init;
  * return 1 : HDMI and CSI status are normal;
  * return 2 : HDMI abnormal;
@@ -215,6 +265,19 @@ uint8_t get_vi_state()
     return ret;
 }
 
+int set_hdmi_mode(uint8_t _hdmi_mode)
+{
+    if(_hdmi_mode >= 0 && _hdmi_mode <= 2){
+        char Cmd[100]={0};
+        sprintf(Cmd, "echo %d > %s", _hdmi_mode, hdmi_mode_path);
+        system(Cmd);
+        return 1;
+    } else {
+        debug("[kvmv] Incorrect HDMI mode.\n");
+        return 0;
+    }
+}
+
 int get_hdmi_mode(void)
 {
     if(access(hdmi_mode_path, F_OK) == 0){
@@ -247,6 +310,27 @@ int get_hdmi_mode(void)
     return 0;
 }
 
+uint8_t watchdog_sf_is_open(void)
+{
+	if(access(watchdog_mode_path, F_OK) == 0) return 1;
+    else if(access(watchdog_temp_path, F_OK) == 0) return 1;
+	else return 0;
+}
+
+int vision_update_watchdog() 
+{
+    FILE *file;
+
+    file = fopen(watchdog_file, "w");
+    if (file == NULL) {
+        debug("[kvmv] watchdog open error\n");
+        return -1;
+    }
+    // fprintf(file, "%s", 'v');
+    fclose(file);
+    return 1;
+}
+
 int get_manual_resolution(void)
 {
     uint8_t RW_Data[35];
@@ -294,6 +378,19 @@ int get_manual_resolution(void)
         sprintf(Cmd, "echo %d > %s", vi_min_height, vi_height_path);
 	    system(Cmd);
     }
+    // res max limit
+    if(tmp_width > vi_max_width){
+        tmp_width = vi_max_width;
+	    char Cmd[100]={0};
+        sprintf(Cmd, "echo %d > %s", vi_max_width, vi_width_path);
+	    system(Cmd);
+    }
+    if(tmp_height > vi_max_height){
+        tmp_height = vi_max_height;
+	    char Cmd[100]={0};
+        sprintf(Cmd, "echo %d > %s", vi_max_height, vi_height_path);
+	    system(Cmd);
+    }
 
     // res change ?
     if(kvmv_cfg.vi_width != tmp_width){
@@ -309,6 +406,91 @@ int get_manual_resolution(void)
     return res;
 }
 
+uint8_t auto_try_res()
+{
+    char Cmd[100]={0};
+    uint8_t err_code;
+    uint8_t auto_trying_times = 0;
+
+    for (auto_trying_times = 0; auto_trying_times < sizeof(hdmi_res_list)/4; auto_trying_times++){
+        err_code = get_vi_state();
+        switch(err_code){
+        case 0:
+            // shouldn't be possible to run here
+            cam->restart(default_vpss_width, default_vpss_height, image::FMT_YVU420SP);
+            printf("[kvmv] VI not init\n");
+            break;
+        case 1:
+            printf("[kvmv] VI subsystem is normal\n");
+            return 1;
+            break;
+        case 2:
+            // HDMI not detected or resolution not supported; interval checks will continue
+            printf("[kvmv] Cannot obtain HDMI input\n");
+            auto_trying_times--;
+            break;
+        case 3: // width too small
+        case 4: // width too large
+        case 5: // height too small
+        case 6: // height too large
+            // CSI abnormal due to resolution error
+            // The test list is short; sequential testing can be performed
+            printf("[kvmv] Trying %d * %d res ..\n", hdmi_res_list[auto_trying_times][0], hdmi_res_list[auto_trying_times][1]);
+            sprintf(Cmd, "echo %d > %s", hdmi_res_list[auto_trying_times][0], vi_width_path);
+            system(Cmd);
+            sprintf(Cmd, "echo %d > %s", hdmi_res_list[auto_trying_times][1], vi_height_path);
+            system(Cmd);
+
+            kvmv_cfg.vi_width = hdmi_res_list[auto_trying_times][0];
+            kvmv_cfg.vi_height = hdmi_res_list[auto_trying_times][1];
+            printf("[kvmv] restart cam...\n");
+            cam->restart(default_vpss_width, default_vpss_height, image::FMT_YVU420SP);
+            time::sleep_ms(50);
+            break;
+        case 7: // Unknown reason
+            printf("[kvmv] CSI abnormal: Unknown reason\n");
+            break;
+        }
+    }
+    if (get_vi_state() == 1) return 1;
+    if (get_vi_state() == 2) return 2;
+    else return 0;
+}
+
+/* return :
+ * 0 : error
+ * 1 : out of mem
+ * 2 : normal
+*/
+uint8_t chack_ion()
+{
+    // cat /sys/kernel/debug/ion/cvi_carveout_heap_dump/summary | grep "usage rate:" | awk -F '[:%]' '{print $2}'
+	uint8_t RW_Data[10];
+    uint8_t ATOI_Data[3] = {0};
+    uint8_t ion_usage_rate;
+    char Cmd[150]={0};
+    // sprintf( Cmd, "cat /sys/kernel/debug/ion/cvi_carveout_heap_dump/summary | grep \"usage rate:\" | awk -F '[:%]' '{print $2}'");
+    sprintf( Cmd, "cat /sys/kernel/debug/ion/cvi_carveout_heap_dump/summary | grep \"usage rate:\" | awk '{print $2}'");
+    FILE* fp = popen( Cmd, "r" );
+    if ( NULL == fp )
+    {
+        pclose(fp);
+        return 0;
+    }
+    fgets((char*)RW_Data, 8, fp);
+    pclose(fp);
+    RW_Data[8] = 0;
+    if (RW_Data[6] == '&') return 1;
+    else {
+        ATOI_Data[0] = RW_Data[5];
+        ATOI_Data[1] = RW_Data[6];
+    }
+    ion_usage_rate = atoi((char*)ATOI_Data);
+
+    if(ion_usage_rate >= 95) return 1;
+    else return 2;
+}
+
 void lt6911_enable()
 {
 	uint8_t buf[2];
@@ -320,7 +502,7 @@ void lt6911_enable()
 	buf[1] = 0x01;
 	LT6911_i2c.writeto(LT6911_ADDR, buf, 2);
 
-    if(kvmv_cfg.hdmi_version == 1){
+    if(kvmv_cfg.hdmi_version != 0){
         // disable watchdog
         buf[0] = 0x10;
         buf[1] = 0x00;
@@ -494,15 +676,13 @@ void lt6911_get_hdmi_clk()
 
 uint8_t lt6911_get_csi_res(uint16_t *p_width, uint16_t *p_height)
 {
-	uint8_t ret = 0;
 	uint8_t buf[2];
 	uint8_t revbuf[4];
+    uint8_t res_type;
 	static uint16_t old_Vactive;
 	static uint16_t old_Hactive;
 	uint16_t Vactive;
 	uint16_t Hactive;
-	char Cmd[100]={0};
-
 
     if(kvmv_cfg.hdmi_version == 0){
         // LT6911C	
@@ -558,31 +738,41 @@ uint8_t lt6911_get_csi_res(uint16_t *p_width, uint16_t *p_height)
         Vactive = (revbuf[0] << 8)|revbuf[1];
         Hactive = (revbuf[2] << 8)|revbuf[3];
     } else {
-        return ret;
+        return UNKNOWN_RES;
     }
 
-	if(old_Hactive != Hactive || old_Vactive != Vactive){
-		old_Hactive = Hactive;
-		old_Vactive = Vactive;
-		// p_kvm_cfg->width = Hactive;
-		// p_kvm_cfg->height = Vactive;
-		*p_width = Hactive;
-		*p_height = Vactive;
-		ret = 1;
-	}
+    res_type = check_res(Hactive, Vactive);
+    if(res_type == NORMAL_RES)
+    {
+        if(old_Hactive != Hactive || old_Vactive != Vactive){
+            old_Hactive = Hactive;
+            old_Vactive = Vactive;
+            // p_kvm_cfg->width = Hactive;
+            // p_kvm_cfg->height = Vactive;
+            *p_width = Hactive;
+            *p_height = Vactive;
+            res_type = NEW_RES;
+        }
+    }
 
-	debug("[hdmi]CSI res: %d * %d; new res = %d\n", Hactive, Vactive, ret);
-	// setenv("KVM_CSI_HEIGHT", to_string(Hactive).c_str(), 1);
-	// setenv("KVM_CSI_WIDTH",  to_string(Vactive).c_str(), 1);
+    switch (res_type)
+    {
+    case NORMAL_RES:
+        printf("[hdmi] get res : %d * %d\n", Hactive, Vactive);
+        break;
+    case NEW_RES:
+        printf("[hdmi] get new res : %d * %d\n", Hactive, Vactive);
+        write_res_to_file(Hactive, Vactive);
+        break;
+    case UNSUPPORT_RES:
+        printf("[hdmi] get unsupport res : %d * %d\n", Hactive, Vactive);
+        break;
+    case UNKNOWN_RES:
+        printf("[hdmi] get unknown res : %d * %d\n", Hactive, Vactive);
+        break;
+    }
 
-	sprintf(Cmd, "echo %d > %s", Hactive, vi_width_path);
-	system(Cmd);
-	sprintf(Cmd, "echo %d > %s", Vactive, vi_height_path);
-	system(Cmd);
-	system("sync");
-
-
-	return ret;
+	return res_type;
 }
 
 void lt6911_write_reg(uint8_t reg, uint8_t val)
@@ -817,6 +1007,57 @@ void lt6911_read_fw(void)
 
 // ==============================================================
 
+void* watchdog_sf_feed(void * arg)
+{
+    while(true)
+    {
+        if(kvmv_cfg.try_exit_thread == 1)
+            break;
+        time::sleep_ms(500);
+        if (watchdog_sf_is_open()){
+            if (chack_ion() == 1){
+                debug("[kvmv] Ion memory is full reboot now!\n");
+                system("reboot");
+            }
+            // debug("[kvmv] watchdog_sf_feed now!\n");
+            vision_update_watchdog();
+        }
+    }
+}
+
+void get_hdmi_version()
+{
+	FILE *fp;
+	uint8_t RW_Data[2];
+    system("/kvmapp/system/init.d/S15kvmhwd get_hdmi_version");
+	if(access("/etc/kvm/hdmi_version", F_OK) == 0){
+        fp = fopen("/etc/kvm/hdmi_version", "r");
+        fread(RW_Data, sizeof(char), 2, fp);
+        fclose(fp);
+        if(RW_Data[0] == 'u'){
+            // 6911uxc
+            if(RW_Data[1] == 'e'){
+                kvmv_cfg.hdmi_version = 2;
+                debug("[hdmi]HDMI-UE exist!\n");
+                set_hdmi_mode(1);
+            } else if(RW_Data[1] == 'x') {
+                kvmv_cfg.hdmi_version = 1;
+                debug("[hdmi]HDMI-UX exist!\n");
+            } else {
+                kvmv_cfg.hdmi_version = 1;
+                debug("[hdmi]Incomplete version number, set to 'ux'\n");
+            }
+        } else {
+            // 6911c
+            kvmv_cfg.hdmi_version = 0;
+            debug("[hdmi]HDMI-C exist!\n");
+        }
+        RW_Data[0] = 0;
+    } else {
+        kvmv_cfg.hdmi_version = 0;
+    }
+}
+
 void* vi_subsystem_detection(void * arg)
 {
 	uint64_t __attribute__((unused)) int_time;
@@ -828,47 +1069,25 @@ void* vi_subsystem_detection(void * arg)
     uint8_t rising_times = 0;
     uint8_t falling_times = 0;
 	uint8_t cam_need_restart = 0;
+    uint8_t auto_change_mode = 0;
     kvmv_cfg.thread_is_running = 1;
 	if(access("/proc/lt_int", F_OK) != 0){
 		time::sleep_ms(10);
 		debug("[hdmi]/proc/lt_int not ok\n");
 	}
 
-	if(access("/etc/kvm/hdmi_version", F_OK) == 0){
-        fp = fopen("/etc/kvm/hdmi_version", "r");
-        fread(RW_Data, sizeof(char), 1, fp);
-        fclose(fp);
-        if(RW_Data[0] == 'u'){
-            // 6911uxc
-            kvmv_cfg.hdmi_version = 1;
-            debug("[hdmi]HDMI-UXC exist!\n");
-        } else {
-            // 6911c
-            kvmv_cfg.hdmi_version = 0;
-            debug("[hdmi]HDMI-C exist!\n");
-        }
-        RW_Data[0] = 0;
-    } else {
-        kvmv_cfg.hdmi_version = 0;
-    }
+    get_hdmi_version();
 
     // while(!app::need_exit())
-    uint8_t while_count_get_hdmi_mode = 0;
     uint8_t while_count_detect_res = 0;
-    uint8_t auto_trying_times = 0;
     while(true)
     {
-        uint8_t get_new_hdmi_mode = 0;
         if(kvmv_cfg.try_exit_thread == 1)
             break;
         
-        // Low-frequency detection mode change
-        if (while_count_get_hdmi_mode >= 100){
-            while_count_get_hdmi_mode = 0;
-            get_new_hdmi_mode = get_hdmi_mode();
-        } else {
-            while_count_get_hdmi_mode ++;
-        }
+        uint8_t get_new_hdmi_mode = get_hdmi_mode();
+        uint8_t try_res;
+        uint8_t err_code;
 
         switch (kvmv_cfg.hdmi_mode){
         case 0:
@@ -911,7 +1130,14 @@ void* vi_subsystem_detection(void * arg)
                                     // hdmi get res
                                     debug("[hdmi] C HDMI cable insertion!\n");
                                     kvmv_cfg.hdmi_cable_state = 1;
-                                    kvmv_cfg.reopen_cam_flag = lt6911_get_csi_res(&kvmv_cfg.vi_width, &kvmv_cfg.vi_height);
+                                    kvmv_cfg.hdmi_res_type = lt6911_get_csi_res(&kvmv_cfg.vi_width, &kvmv_cfg.vi_height);
+                                    if (kvmv_cfg.hdmi_res_type == NEW_RES) kvmv_cfg.reopen_cam_flag = 1;
+                                    else if (kvmv_cfg.hdmi_res_type == UNKNOWN_RES){
+                                        /* Move HDMI resolution modification directly 
+                                            to mode1 to solve deadlock problem */
+                                        auto_change_mode = 1;
+                                        set_hdmi_mode(1);
+                                    }
                                 } else {
                                     // HDMI res = 0*0/x*0
                                     debug("[hdmi] C HDMI cable unplugged!\n");
@@ -929,7 +1155,14 @@ void* vi_subsystem_detection(void * arg)
                                     // hdmi get res
                                     debug("[hdmi] UXC HDMI cable insertion!\n");
                                     kvmv_cfg.hdmi_cable_state = 1;
-                                    kvmv_cfg.reopen_cam_flag = lt6911_get_csi_res(&kvmv_cfg.vi_width, &kvmv_cfg.vi_height);
+                                    kvmv_cfg.hdmi_res_type = lt6911_get_csi_res(&kvmv_cfg.vi_width, &kvmv_cfg.vi_height);
+                                    if (kvmv_cfg.hdmi_res_type == NEW_RES) kvmv_cfg.reopen_cam_flag = 1;
+                                    else if (kvmv_cfg.hdmi_res_type == UNKNOWN_RES){
+                                        /* Move HDMI resolution modification directly 
+                                            to mode1 to solve deadlock problem */
+                                        auto_change_mode = 1;
+                                        set_hdmi_mode(1);
+                                    }
                                 } else {
                                     // HDMI res = 0*0/x*0
                                     debug("[hdmi] UXC HDMI cable unplugged!\n");
@@ -937,6 +1170,8 @@ void* vi_subsystem_detection(void * arg)
                                 }
                                 lt6911_disable();
                             }
+                        } else {
+                            debug("[hdmi] Chip not supported for reading \n");
                         }
                         kvmv_cfg.hdmi_reading_flag = 0;
                     }
@@ -952,62 +1187,43 @@ void* vi_subsystem_detection(void * arg)
              * 1: Preparing / Testing in progress
              * 2: Test completed: Suitable resolution found,
              */
+                    
             if(get_new_hdmi_mode == 1){
                 kvmv_cfg.vi_detect_state = 1;
-                auto_trying_times = 0;
             }
             if(kvmv_cfg.vi_detect_state == 1){
-                uint8_t err_code = get_vi_state();
-                debug("[kvmv] get_vi_state() = %d\n", err_code);
-                switch(err_code){
-                case 0:
-                    // shouldn't be possible to run here
-                    printf("[kvmv] VI not init\n");
-                    break;
-                case 1:
-                    printf("[kvmv] VI subsystem is normal\n");
+                try_res = auto_try_res();
+                if (try_res == 1) {
+                    kvmv_cfg.hdmi_res_err = NORMAL_RES;
+                    kvmv_cfg.hdmi_try_rounds = 0;
                     kvmv_cfg.vi_detect_state = 2;
-                    break;
-                case 2:
-                    // HDMI not detected or resolution not supported; interval checks will continue
-                    printf("[kvmv] Cannot obtain HDMI input\n");
-                    break;
-                case 3: // width too small
-                case 4: // width too large
-                case 5: // height too small
-                case 6: // height too large
-                    // CSI abnormal due to resolution error
-                    // The test list is short; sequential testing can be performed
-                    if(auto_trying_times < sizeof(hdmi_res_list)/4){
-                        char Cmd[100]={0};
-                        printf("[kvmv] Trying %d * %d res ..\n", hdmi_res_list[auto_trying_times][0], hdmi_res_list[auto_trying_times][1]);
-                        sprintf(Cmd, "echo %d > %s", hdmi_res_list[auto_trying_times][0], vi_width_path);
-                        system(Cmd);
-                        sprintf(Cmd, "echo %d > %s", hdmi_res_list[auto_trying_times][1], vi_height_path);
-                        system(Cmd);
-                        printf("[kvmv] restart cam...\n");
-                        cam->restart(default_vpss_width, default_vpss_height, image::FMT_YVU420SP);
-                        auto_trying_times++;
-                        time::sleep_ms(10);
-                    } else {
-                        printf("[kvmv] Suitable resolution not found, switching to manual input mode automatically\n");
+                } else if (try_res == 0) {
+                    /*  There may be a situation where the correct resolution cannot be recognized 
+                        after one round of detection. By default, Try_rounds_HDMI_err_res rounds will be detected, 
+                        and if it cannot be detected, jump to the next mode */ 
+                    kvmv_cfg.hdmi_res_err = ERROR_RES;
+                    kvmv_cfg.hdmi_try_rounds++;
+                    if(kvmv_cfg.hdmi_try_rounds >= Try_rounds_HDMI_err_res){
+                        kvmv_cfg.hdmi_try_rounds = 0;
                         kvmv_cfg.vi_detect_state = 1;
-                        char Cmd[100]={0};
-                        sprintf(Cmd, "echo 2 > %s", hdmi_mode_path);
-                        system(Cmd);
-                        while_count_get_hdmi_mode = 100;    // Take effect immediately
+                        // printf("[kvmv] Suitable resolution not found, switching to manual input mode automatically\n");
+                        if(auto_change_mode == 1){
+                            auto_change_mode = 0;
+                            set_hdmi_mode(0);
+                        } else {
+                            set_hdmi_mode(2);
+                        }
                     }
-                    break;
-                case 7: // Unknown reason
-                    printf("[kvmv] CSI abnormal: Unknown reason\n");
-                    break;
+                } else if (try_res == 2) {
+                    kvmv_cfg.hdmi_try_rounds = 0;
+                    // Cannot obtain HDMI input / No signal on HDMI
                 }
             } else if (kvmv_cfg.vi_detect_state == 2){
                 // Low-frequency detection of HDMI status, no log output
-                uint8_t err_code = get_vi_state();
+                printf("[kvmv] kvmv_cfg.vi_detect_state == 2\n");
+                err_code = get_vi_state();
                 if (err_code != 1) {
                     kvmv_cfg.vi_detect_state = 1;
-                    auto_trying_times = 0;
                 }
                 time::sleep_ms(1000); 
             } else {
@@ -1016,17 +1232,17 @@ void* vi_subsystem_detection(void * arg)
             break;
         case 2:
             // Manually initialize VI.
-            if (while_count_detect_res >= 100){
-                while_count_detect_res = 0;
+            while_count_detect_res = (while_count_detect_res + 1)%100;
+            if(while_count_detect_res == 1){
                 if (kvmv_cfg.vi_detect_state == 1){
                     // detect_res
                     if (get_manual_resolution()) {
-                        printf("[kvmv] restart cam...\n");
+                        debug("[kvmv] restart cam...\n");
                         cam->restart(default_vpss_width, default_vpss_height, image::FMT_YVU420SP);
                     }
 
                     // dbg info
-                    uint8_t err_code = get_vi_state();
+                    err_code = get_vi_state();
                     switch(err_code){
                     case 0:
                         debug("[kvmv] VI not init\n");
@@ -1056,14 +1272,11 @@ void* vi_subsystem_detection(void * arg)
                     }
                 } else if (kvmv_cfg.vi_detect_state == 2){
                     // detection of HDMI status, no log output
-                    uint8_t err_code = get_vi_state();
+                    err_code = get_vi_state();
                     if (err_code != 1) kvmv_cfg.vi_detect_state = 1;
                 } else {
                     kvmv_cfg.vi_detect_state = 1;
                 }
-
-            } else {
-                while_count_detect_res ++;
             }
             break;
         
@@ -1129,6 +1342,31 @@ int sync_vi_res()
     return res;
 }
 
+uint8_t frame_changed(image::Image *raw)
+{
+    static int raw_size = 0;
+    static uint8_t Farame_sample[Farame_sample_size] = {0};
+    uint8_t ret = 0;
+    uint8_t sample_byte;
+    if(raw->data_size() != raw_size){
+        raw_size = raw->data_size();
+        ret = 1;
+    }
+    int Detection_Pixel_Interval = raw_size/(Farame_sample_size*1.5);
+    for(int i = 0; i < Farame_sample_size; i ++){
+        // printf("[kvmv] i = %d\n", i);
+        if(i >= raw_size){
+            ret = 0;
+        }
+        sample_byte = *(uint8_t*)(raw->data()+(i*Detection_Pixel_Interval));
+        if(sample_byte != Farame_sample[i]){
+            Farame_sample[i] = sample_byte;
+            ret = 1;
+        }
+    }
+    return ret;
+}
+
 void jpg_dump(kvmv_data_t* dump_to, image::Image *raw)
 {
     dump_to->p_img_data = (uint8_t *)malloc(raw->data_size());
@@ -1173,29 +1411,17 @@ int h264_stream_dump(kvmv_data_t* dump_to, mmf_stream_t* dump_from)
     static int8_t I_Frame_index = -1;
     // debug("[kvmv]dump_from->count = %d\n", dump_from->count);
     if (dump_from->count == 3) {
-        // debug("[kvmv]dump I-Frame\r\n");
-        if(kvmv_SPS_buffer.p_img_data != NULL || kvmv_PPS_buffer.p_img_data != NULL)
-            return IMG_BUFFER_FULL;
 
-        kvmv_SPS_buffer.p_img_data  = (uint8_t *)malloc(dump_from->data_size[0]);
-        kvmv_PPS_buffer.p_img_data  = (uint8_t *)malloc(dump_from->data_size[1]);
-        dump_to->p_img_data         = (uint8_t *)malloc(dump_from->data_size[2]);
+        dump_to->p_img_data = (uint8_t *)malloc(dump_from->data_size[0]+dump_from->data_size[1]+dump_from->data_size[2]);
+        dump_to->img_data_size = dump_from->data_size[0]+dump_from->data_size[1]+dump_from->data_size[2];
+        dump_to->img_data_type = IMG_H264_TYPE_IF;
+        memcpy(dump_to->p_img_data, dump_from->data[0], dump_from->data_size[0]);
+        memcpy(dump_to->p_img_data+dump_from->data_size[0], dump_from->data[1], dump_from->data_size[1]);
+        memcpy(dump_to->p_img_data+dump_from->data_size[0]+dump_from->data_size[1], dump_from->data[2], dump_from->data_size[2]);
 
-        kvmv_SPS_buffer.img_data_size   = dump_from->data_size[0];
-        kvmv_PPS_buffer.img_data_size   = dump_from->data_size[1];
-        dump_to->img_data_size          = dump_from->data_size[2];
-
-        kvmv_SPS_buffer.img_data_type   = IMG_H264_TYPE_SPS;
-        kvmv_PPS_buffer.img_data_type   = IMG_H264_TYPE_PPS;
-        dump_to->img_data_type          = IMG_H264_TYPE_IF;
-
-        memcpy(kvmv_SPS_buffer.p_img_data,  dump_from->data[0], dump_from->data_size[0]);
-        memcpy(kvmv_PPS_buffer.p_img_data,  dump_from->data[1], dump_from->data_size[1]);
-        memcpy(dump_to->p_img_data,         dump_from->data[2], dump_from->data_size[2]);
-
-        debug("[kvmv]SPS size = %d\n", kvmv_SPS_buffer.img_data_size);
-        debug("[kvmv]PPS size = %d\n", kvmv_PPS_buffer.img_data_size);
-        debug("[kvmv]I-Frame size = %d\n", dump_to->img_data_size);
+        debug("[kvmv]SPS size = %d\n", dump_from->data_size[0]);
+        debug("[kvmv]PPS size = %d\n", dump_from->data_size[1]);
+        debug("[kvmv]I-Frame size = %d\n", dump_from->data_size[2]);
 
         return IMG_H264_TYPE_IF;
 
@@ -1216,18 +1442,17 @@ int h264_stream_dump(kvmv_data_t* dump_to, mmf_stream_t* dump_from)
 void set_h264_gop(uint8_t _gop)
 {
     kvm_venc.enc_h264_init = 0; // call
-    kvmvenc_gop = maxmin_data(100, 10, (int)_gop);
+    kvmvenc_gop = maxmin_data(100, 1, (int)_gop);
+    debug("[kvmv] set_h264_gop = %d\n", kvmvenc_gop);
 }
 
-// uint8_t get_h264_gop(void)
-// {
-//     return kvm_venc.kvm_venc_cfg.gop;
-// }
-
-// uint8_t get_hdmi_width(void)
-// {
-//     return kvm_venc.kvm_venc_cfg.gop;
-// }
+void set_frame_detact(uint8_t _frame_detact)
+{
+    uint8_t frame_detact = maxmin_data(100, 0, (int)_frame_detact);
+    kvmv_cfg.frame_detact = frame_detact;
+    debug("[kvmv] set_frame_detact = %d\n", kvmv_cfg.frame_detact);
+    kvmv_cfg.stream_stop = 0;
+}
 
 int8_t raw_to_h264(image::Image *raw, kvmv_data_t* ret_stream, uint16_t _qlty)
 {
@@ -1298,6 +1523,7 @@ int8_t raw_to_h264(image::Image *raw, kvmv_data_t* ret_stream, uint16_t _qlty)
 void kvmv_init(uint8_t _debug_info_en)
 {
     pthread_t thread;
+    pthread_mutex_init(&vi_mutex, NULL);
     if(_debug_info_en == 0) debug_en = 0;
     else                    debug_en = 1;
 
@@ -1309,8 +1535,6 @@ void kvmv_init(uint8_t _debug_info_en)
     for(int i = 0; i < kvmv_data_buffer_size; i++){
         kvmv_data_buffer[i].p_img_data = NULL;
     }
-    kvmv_SPS_buffer.p_img_data = NULL;
-    kvmv_PPS_buffer.p_img_data = NULL;
 
     kvmv_cfg.try_exit_thread = 0;
     // debug("[kvmv]kvmv_init - 2\r\n");
@@ -1319,7 +1543,12 @@ void kvmv_init(uint8_t _debug_info_en)
         debug("[kvmv]thread is running!\r\n");
     } else {
         if (0 != pthread_create(&thread, NULL, vi_subsystem_detection, NULL)) {
-            debug("[kvmv]create thread failed!\r\n");
+            debug("[kvmv]create vi_subsystem_detection thread failed!\r\n");
+            // return -1;
+        }
+
+        if (0 != pthread_create(&thread, NULL, watchdog_sf_feed, NULL)) {
+            debug("[kvmv]create watchdog_sf_feed thread failed!\r\n");
             // return -1;
         }
     }
@@ -1349,6 +1578,11 @@ uint8_t check_kvmv(uint8_t _try_num)
     return 1;
 }
 
+void set_venc_auto_recyc(uint8_t _enable)
+{
+    if(_enable) kvmv_cfg.venc_auto_recyc = 1;
+    else kvmv_cfg.venc_auto_recyc = 0;
+}
 
 /**********************************************************************************
  * @name    kvmv_read_img
@@ -1363,20 +1597,43 @@ uint8_t check_kvmv(uint8_t _try_num)
  * @param	_pp_kvm_data		@output: 	Encode data
  * @param	_p_kvmv_data_size	@output: 	Encode data size
  * @return
+        -7: HDMI INPUT RES ERROR
+        -6: Unsupported resolution, please modify it in the host settings.
+        -5: Retrieving image, please wait
         -4: Modifying image resolution, please wait
         -3: img buffer full
         -2: VENC Errorl
         -1: No images were acquired
          0: Acquire MJPEG encoded images
-         1: Acquire H264 encoded images(SPS)
-         2: Acquire H264 encoded images(PPS)
+         1: Acquire H264 encoded images(SPS)[Deprecated]
+         2: Acquire H264 encoded images(PPS)[Deprecated]
          3: Acquire H264 encoded images(I)
          4: Acquire H264 encoded images(P)
+         5: IMG not changed
  **********************************************************************************/
 int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _qlty, uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size)
 {
+    static uint8_t frame_undetact_count = 0;
 	// uint64_t __attribute__((unused)) start_time = time::time_ms();
+    debug("[kvmv]kvmv_read_img type = %d...\n", _type);
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    ts.tv_sec += 1;
+    // pthread_mutex_lock(&vi_mutex);         // Add lock
+    int mutex_res = pthread_mutex_timedlock(&vi_mutex, &ts);
+    if(mutex_res != 0){
+        return -5;
+    }
+    if (kvmv_cfg.hdmi_res_err == ERROR_RES){
+        pthread_mutex_unlock(&vi_mutex);
+        return -7;
+    }
+    if (kvmv_cfg.hdmi_res_type == UNSUPPORT_RES){
+        pthread_mutex_unlock(&vi_mutex);
+        return -6;
+    }
     if (kvmv_cfg.vi_detect_state == 1){
+        pthread_mutex_unlock(&vi_mutex);
         return -4;
     }
     uint8_t try_num = 0;
@@ -1413,7 +1670,30 @@ int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _ql
         // debug("[kvmv]befor read img: %d \r\n", (int)(time::time_ms() - start_time));
         image::Image *img = cam->read();
         // debug("[kvmv]read img: %d \r\n", (int)(time::time_ms() - start_time));
+        
         if(img != NULL){
+            // frame detect
+            if(_type == VENC_MJPEG && kvmv_cfg.frame_detact != 0){
+                if(kvmv_cfg.stream_stop == 0){
+                    frame_undetact_count++;
+                } else {
+                    frame_undetact_count = kvmv_cfg.frame_detact;
+                }
+                
+                if(frame_undetact_count == kvmv_cfg.frame_detact){
+                    frame_undetact_count = 0;
+    
+                    if(frame_changed(img) == 0){
+                        debug("[kvmv]frame not changed...\n");
+                        kvmv_cfg.stream_stop = 1;
+                        delete img;
+                        pthread_mutex_unlock(&vi_mutex);
+                        return 5;
+                    } else {
+                        kvmv_cfg.stream_stop = 0;
+                    }
+                }
+            } 
 			if(kvmv_cfg.cam_state == 0) {
 				kvmv_cfg.cam_state = 1;
                 kvmv_cfg.hdmi_cable_state = 1;
@@ -1427,15 +1707,26 @@ int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _ql
 			delete img;
             debug("[kvmv]can`t get img...\n");
             continue;
+            // pthread_mutex_unlock(&vi_mutex);
+            // return IMG_NOT_EXIST;
         }
         // debug("[kvmv]cheak img null?: %d \r\n", (int)(time::time_ms() - start_time));
 
         // img exist
         // Encode
-        if(_type == VENC_H264 && kvmv_cfg.venc_type != _type){
+        if(kvmv_cfg.venc_type == VENC_MJPEG && kvmv_cfg.venc_type != _type){
+            if(kvmv_cfg.venc_auto_recyc == 1){
+                mmf_enc_jpg_deinit(0);
+            }
             kvm_venc.enc_h264_init = 1;
-            // debug("[kvmv] change to h264\n");
         }
+        if(kvmv_cfg.venc_type == VENC_H264 && kvmv_cfg.venc_type != _type){
+            if(kvmv_cfg.venc_auto_recyc == 1){
+                mmf_del_venc_channel(kvm_venc.mmf_venc_chn);
+            }
+            kvm_venc.enc_h264_init = 0;
+        }
+
         kvmv_cfg.venc_type = _type;
 
         if(kvmv_cfg.venc_type == VENC_MJPEG){
@@ -1447,6 +1738,7 @@ int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _ql
 			    delete img;
                 debug("[kvmv]jpg buffer full\n");
                 *_pp_kvm_data = NULL;
+                pthread_mutex_unlock(&vi_mutex);
                 return IMG_BUFFER_FULL;
             } 
             jpg_dump(p_kvmv_data, jpg);
@@ -1454,6 +1746,7 @@ int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _ql
 			delete img;
             *_pp_kvm_data = p_kvmv_data->p_img_data;
             *_p_kvmv_data_size = p_kvmv_data->img_data_size;
+            pthread_mutex_unlock(&vi_mutex);
             return IMG_MJPEG_TYPE;
         } else if (kvmv_cfg.venc_type == VENC_H264){
             int ret;
@@ -1462,6 +1755,7 @@ int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _ql
                 // buffer full
 			    delete img;
                 *_pp_kvm_data = NULL;
+                pthread_mutex_unlock(&vi_mutex);
                 return IMG_BUFFER_FULL;
             } 
             // debug("[kvmv]get_save_buffer: %d \r\n", (int)(time::time_ms() - start_time));
@@ -1470,35 +1764,13 @@ int kvmv_read_img(uint16_t _width, uint16_t _height, uint8_t _type, uint16_t _ql
 			delete img;
             *_pp_kvm_data = p_kvmv_data->p_img_data;
             *_p_kvmv_data_size = p_kvmv_data->img_data_size;
+            pthread_mutex_unlock(&vi_mutex);
             return ret;
         }
     } while (check_kvmv(try_num++));
     // debug("[kvmv]return: %d \r\n", (int)(time::time_ms() - start_time));
     *_pp_kvm_data = NULL;
-    return IMG_NOT_EXIST;
-}
-
-int kvmv_get_sps_frame(uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size)
-{
-    if(kvmv_SPS_buffer.p_img_data == NULL){ 
-        return IMG_NOT_EXIST;
-    } else {
-        *_pp_kvm_data = kvmv_SPS_buffer.p_img_data;
-        *_p_kvmv_data_size = kvmv_SPS_buffer.img_data_size;
-        return IMG_H264_TYPE_SPS;
-    }
-    return IMG_NOT_EXIST;
-}
-
-int kvmv_get_pps_frame(uint8_t** _pp_kvm_data, uint32_t* _p_kvmv_data_size)
-{
-    if(kvmv_PPS_buffer.p_img_data == NULL){
-        return IMG_NOT_EXIST;
-    } else {
-        *_pp_kvm_data = kvmv_PPS_buffer.p_img_data;
-        *_p_kvmv_data_size = kvmv_PPS_buffer.img_data_size;
-        return IMG_H264_TYPE_PPS;
-    }
+    pthread_mutex_unlock(&vi_mutex);
     return IMG_NOT_EXIST;
 }
 
@@ -1514,12 +1786,6 @@ int free_kvmv_data(uint8_t ** _pp_kvm_data)
         // debug("[kvmv]free_kvmv_data - 3\r\n");
                 kvmv_data_buffer[i].p_img_data = NULL;
                 uint8_t _type = kvmv_data_buffer[i].img_data_type;
-                if(_type == IMG_H264_TYPE_IF){
-                    free(kvmv_SPS_buffer.p_img_data);
-                    free(kvmv_PPS_buffer.p_img_data);
-                    kvmv_SPS_buffer.p_img_data = NULL;
-                    kvmv_PPS_buffer.p_img_data = NULL;
-                }
                 return _type;
             } else {
                 return IMG_NOT_EXIST;
@@ -1537,14 +1803,11 @@ void free_all_kvmv_data()
             kvmv_data_buffer[i].p_img_data = NULL;
         }
     }
-    if(kvmv_SPS_buffer.p_img_data != NULL) free(kvmv_SPS_buffer.p_img_data);
-    if(kvmv_PPS_buffer.p_img_data != NULL) free(kvmv_PPS_buffer.p_img_data);
-    kvmv_SPS_buffer.p_img_data = NULL;
-    kvmv_PPS_buffer.p_img_data = NULL;
 }
 
 void kvmv_deinit()
 {
+    pthread_mutex_destroy(&vi_mutex);
     kvmv_cfg.try_exit_thread = 1;
     cam->close();
     mmf_deinit();

support/sg2002/additional/kvm_mmf/CMakeLists.txt

@@ -0,0 +1,66 @@
+
+list(APPEND ADD_REQUIREMENTS basic ini)
+list(APPEND ADD_INCLUDE "include")
+
+# sophgo-middleware
+set(middleware_src_path "${CMAKE_CURRENT_SOURCE_DIR}/../3rd_party/sophgo-middleware/sophgo-middleware")
+
+
+set(source_dir "src")
+append_srcs_dir(ADD_SRCS "${source_dir}")
+
+# middleware
+set(middleware_include_dir .
+    ${middleware_src_path}/v2/component/panel/${CONFIG_SOPHGO_MIDDLEWARE_CHIP}
+    ${middleware_src_path}/v2/include
+    ${middleware_src_path}/v2/include/isp/${CONFIG_SOPHGO_MIDDLEWARE_CHIP}
+    ${middleware_src_path}/v2/sample/common
+    ${middleware_src_path}/v2/uapi
+    ${middleware_src_path}/v2/3rdparty/inih
+    ${middleware_src_path}/v2/modules/ive/include/
+)
+list(APPEND ADD_INCLUDE ${middleware_include_dir})
+set_property(SOURCE ${middleware_include_dir} PROPERTY GENERATED 1)
+
+append_srcs_dir(middleware_src_dir  ${middleware_src_path}/v2/sample/common
+                                    ${middleware_src_path}/v2/component/isp/sensor/sg200x/lontium_lt6911
+                                    )
+list(APPEND ADD_SRCS        ${middleware_src_dir}
+                            "${source_dir}/kvm_mmf.cpp")
+set_property(SOURCE ${middleware_src_dir} PROPERTY GENERATED 1)
+
+set(middleware_static_lib_file  "")
+    list(APPEND ADD_STATIC_LIB ${middleware_static_lib_file})
+set_property(SOURCE ${middleware_static_lib_file} PROPERTY GENERATED 1)
+
+set(mmf_lib_dir ${middleware_src_path}/v2/lib)
+
+if(CONFIG_SOPHGO_MIDDLEWARE_C_LIBRARY STREQUAL "musl")
+    set(middleware_dynamic_lib_file     ${mmf_lib_dir}/libcvi_bin.so
+                                        ${mmf_lib_dir}/libae.so
+                                        ${mmf_lib_dir}/libaf.so
+                                        ${mmf_lib_dir}/libawb.so
+                                        ${mmf_lib_dir}/libcvi_bin_isp.so
+                                        ${mmf_lib_dir}/libisp_algo.so
+                                        ${mmf_lib_dir}/libisp.so
+                                        ${mmf_lib_dir}/libsys.so
+                                        ${mmf_lib_dir}/libvdec.so
+                                        ${mmf_lib_dir}/libvenc.so
+                                        ${mmf_lib_dir}/libvpu.so
+                                        ${mmf_lib_dir}/3rd/libini.so)
+elseif(CONFIG_SOPHGO_MIDDLEWARE_C_LIBRARY STREQUAL "glibc")
+    set(middleware_dynamic_lib_file     ${mmf_lib_dir}/libcvi_vb.so
+                                        ${mmf_lib_dir}/libcvi_sys.so
+                                        ${mmf_lib_dir}/libcvi_debug.so
+    )
+else()
+    message(FATAL_ERROR "No sophgo middleware c library support, please check menuoconfig to select c library")
+endif()
+list(APPEND ADD_DYNAMIC_LIB ${middleware_dynamic_lib_file})
+set_property(SOURCE ${middleware_dynamic_lib_file} PROPERTY GENERATED 1)
+
+list(APPEND ADD_DEFINITIONS_PRIVATE -DSENSOR_LONTIUM_LT6911
+                                -DSENSOR2_TYPE=LONTIUM_LT6911_2M_60FPS_8BIT)
+
+
+register_component(DYNAMIC)

support/sg2002/additional/kvm_mmf/src/kvm_mmf.cpp

@@ -663,12 +663,12 @@ static CVI_S32 _mmf_sys_init(SIZE_S stSize)
 
 	// vi
 	u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_UYVY,
-		DATA_BITWIDTH_12, enCompressMode, DEFAULT_ALIGN);
+		DATA_BITWIDTH_8, enCompressMode, DEFAULT_ALIGN);
 	u32BlkRotSize = COMMON_GetPicBufferSize(stSize.u32Height, stSize.u32Width, PIXEL_FORMAT_UYVY,
-		DATA_BITWIDTH_12, enCompressMode, DEFAULT_ALIGN);
+		DATA_BITWIDTH_8, enCompressMode, DEFAULT_ALIGN);
 	u32BlkSize = MAX(u32BlkSize, u32BlkRotSize);
 	stVbConf.astCommPool[MMF_VB_VI_ID].u32BlkSize	= u32BlkSize;
-	stVbConf.astCommPool[MMF_VB_VI_ID].u32BlkCnt	= 4;
+	stVbConf.astCommPool[MMF_VB_VI_ID].u32BlkCnt	= 3;
 	stVbConf.astCommPool[MMF_VB_VI_ID].enRemapMode	= VB_REMAP_MODE_CACHED;
 	stVbConf.u32MaxPoolCnt = 1;
 

support/sg2002/additional/peripheral/port/maixcam/maix_i2c.cpp

@@ -0,0 +1,322 @@
+/**
+ * @author neucrack@sipeed, lxowalle@sipeed
+ * @copyright Sipeed Ltd 2023-
+ * @license Apache 2.0
+ * @update 2023.9.8: Add framework, create this file.
+ */
+
+
+#include "maix_i2c.hpp"
+#include "maix_basic.hpp"
+#include "cstdio"
+#include <fcntl.h>
+#include <unistd.h>
+#include <linux/i2c-dev.h>
+#include <linux/i2c.h>
+#include <sys/ioctl.h>
+
+#define DEV_PATH "/dev/i2c-%d"
+
+namespace maix::peripheral::i2c
+{
+
+    std::vector<int> list_devices()
+    {
+        std::vector<int> data;
+        // list all files in /dev, find i2c-*
+        std::vector<std::string> *files = fs::listdir("/dev");
+        for (auto &file : *files)
+        {
+            if (file.find("i2c-") != std::string::npos)
+            {
+                try
+                {
+                    data.push_back(std::stoi(file.substr(4)));
+                }
+                catch (const std::exception &e)
+                {
+                    log::error("i2c bus id %s format error", file.c_str());
+                }
+            }
+        }
+        delete files;
+        return data;
+    }
+
+    I2C::I2C(int id, i2c::Mode mode, int freq, i2c::AddrSize addr_size)
+    {
+        char buf[32];
+
+        snprintf(buf, sizeof(buf), DEV_PATH, id);
+        if(access(buf, F_OK) == 0){
+            if (mode == i2c::SLAVE)
+            {
+                throw err::Exception(err::Err::ERR_NOT_IMPL, "i2c::SLAVE mode not implemented");
+            }
+            if (addr_size != i2c::SEVEN_BIT)
+            {
+                throw err::Exception(err::Err::ERR_NOT_IMPL, "addr_size " + std::to_string(addr_size) + " not support");
+            }
+
+            int fd = ::open(buf, O_RDWR);
+            if (fd < 0)
+            {
+                throw err::Exception(err::Err::ERR_IO, "open " + std::string(buf) + " failed");
+            }
+            _fd = fd;
+            _freq = freq;
+            _mode = mode;
+            _addr_size = addr_size;
+        } else {
+            printf("not exit i2c\r\n");
+        }
+    }
+
+    I2C::~I2C()
+    {
+        if (_fd > 0)
+        {
+            ::close(_fd);
+        }
+    }
+
+    std::vector<int> I2C::scan(int addr)
+    {
+        std::vector<int> data;
+        int addr_start = 0x08;
+        int addr_end = 0x77;
+        if(addr > 0)
+        {
+            addr_start = addr;
+            addr_end = addr;
+        }
+
+        if (_mode != i2c::Mode::MASTER)
+        {
+            log::error("Only for master mode");
+            return data;
+        }
+
+        switch (_addr_size)
+        {
+        case i2c::AddrSize::SEVEN_BIT:
+            for (int address = addr_start; address <= addr_end; ++address)
+            {
+                if (::ioctl(_fd, I2C_SLAVE, address) < 0)
+                {
+                    continue;
+                }
+
+                unsigned char buffer[1];
+                if (::read(_fd, buffer, sizeof(buffer)) >= 0)
+                {
+                    data.push_back(address);
+                }
+            }
+            break;
+        default:
+            log::error("bit %d not support", _addr_size);
+            return data;
+        }
+
+        return data;
+    }
+
+    int I2C::writeto(int addr, const uint8_t *data, int len)
+    {
+        if (_mode != i2c::Mode::MASTER)
+        {
+            log::error("Only for master mode");
+            return (int)-err::Err::ERR_NOT_PERMIT;
+        }
+
+        if (0 != ioctl(_fd, I2C_SLAVE, addr))
+        {
+            // log::error("set slave address failed");
+            return (int)-err::Err::ERR_IO;
+        }
+
+        if (len != ::write(_fd, data, len))
+        {
+            log::error("write failed");
+            return (int)-err::Err::ERR_IO;
+        }
+
+        return len;
+    }
+
+    int I2C::writeto(int addr, const std::vector<unsigned char> data)
+    {
+        return writeto(addr, data.data(), (int)data.size());
+    }
+
+    int I2C::writeto(int addr, const Bytes &data)
+    {
+        return writeto(addr, data.data, (int)data.size());
+    }
+
+    Bytes* I2C::readfrom(int addr, int len)
+    {
+        Bytes *data = new Bytes(nullptr, len);
+
+        if (_mode != i2c::Mode::MASTER)
+        {
+            log::error("Only for master mode");
+            return nullptr;
+        }
+
+        if (0 != ioctl(_fd, I2C_SLAVE, addr))
+        {
+            // log::error("set slave address failed");
+            return nullptr;
+        }
+
+        if (len != ::read(_fd, data->data, len))
+        {
+            log::error("read failed");
+            delete data;
+            return nullptr;
+        }
+        return data;
+    }
+
+    int I2C::writeto_mem(int addr, int mem_addr, const uint8_t *data, int len, int mem_addr_size, bool mem_addr_le)
+    {
+        if (_mode != i2c::Mode::MASTER)
+        {
+            log::error("Only for master mode");
+            return (int)-err::Err::ERR_NOT_PERMIT;
+        }
+        if(mem_addr_size % 8 != 0)
+        {
+            log::error("mem_addr_size must be multiple of 8");
+            return (int)-err::Err::ERR_IO;
+        }
+
+        if (0 != ioctl(_fd, I2C_SLAVE, addr))
+        {
+            // log::error("set slave address failed");
+            return (int)-err::Err::ERR_IO;
+        }
+
+        std::vector<unsigned char> data_final;
+
+        if(mem_addr_size == 8)
+        {
+            data_final.push_back((unsigned char)mem_addr);
+        }
+        else
+        {
+            if(mem_addr_le)
+            {
+                for(int i = 0; i < mem_addr_size / 8; i++)
+                {
+                    data_final.push_back((unsigned char)(mem_addr & 0xff));
+                    mem_addr >>= 8;
+                }
+            }
+            else
+            {
+                for(int i = 0; i < mem_addr_size / 8; i++)
+                {
+                    data_final.push_back((unsigned char)(mem_addr >> (8 * (mem_addr_size / 8 - i - 1))));
+                }
+            }
+        }
+        for(int i = 0; i < len; i++)
+        {
+            data_final.push_back(data[i]);
+        }
+        int write_len = ::write(_fd, data_final.data(), data_final.size());
+        if (data_final.size() != (size_t)write_len)
+        {
+            log::error("write failed, write_len: %d", write_len);
+            return (int)-err::Err::ERR_IO;
+        }
+
+        return len;
+    }
+
+    int I2C::writeto_mem(int addr, int mem_addr, const std::vector<unsigned char> data, int mem_addr_size, bool mem_addr_le)
+    {
+        return writeto_mem(addr, mem_addr, data.data(), (int)data.size(), mem_addr_size, mem_addr_le);
+    }
+
+    int I2C::writeto_mem(int addr, int mem_addr, const Bytes &data, int mem_addr_size, bool mem_addr_le)
+    {
+        return writeto_mem(addr, mem_addr, data.data, (int)data.size(), mem_addr_size, mem_addr_le);
+    }
+
+    Bytes* I2C::readfrom_mem(int addr, int mem_addr, int len, int mem_addr_size, bool mem_addr_le)
+    {
+        // write mem_addr and restart to read
+        if (_mode != i2c::Mode::MASTER)
+        {
+            log::error("Only for master mode");
+            return nullptr;
+        }
+        if(mem_addr_size % 8 != 0)
+        {
+            log::error("mem_addr_size must be multiple of 8");
+            return nullptr;
+        }
+
+        // write mem_addr first and restart to read
+        if (0 != ioctl(_fd, I2C_SLAVE, addr))
+        {
+            // log::error("set slave address failed");
+            return nullptr;
+        }
+
+        std::vector<unsigned char> data_final;
+        if(mem_addr_size == 8)
+        {
+            data_final.push_back((unsigned char)mem_addr);
+        }
+        else
+        {
+            if(mem_addr_le)
+            {
+                for(int i = 0; i < mem_addr_size / 8; i++)
+                {
+                    data_final.push_back((unsigned char)(mem_addr & 0xff));
+                    mem_addr >>= 8;
+                }
+            }
+            else
+            {
+
+                for(int i = 0; i < mem_addr_size / 8; i++)
+                {
+                    data_final.push_back((unsigned char)(mem_addr >> (8 * (mem_addr_size / 8 - i - 1))));
+                }
+            }
+        }
+        // write read with I2C_RDWR
+        struct i2c_msg msgs[2];
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = data_final.size();
+        msgs[0].buf = data_final.data();
+
+        Bytes *data = new Bytes(nullptr, len);
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = len;
+        msgs[1].buf = data->data;
+
+        struct i2c_rdwr_ioctl_data msgset;
+        msgset.msgs = msgs;
+        msgset.nmsgs = 2;
+
+        int read_len = ioctl(_fd, I2C_RDWR, &msgset);
+        if (read_len != 2)
+        {
+            log::error("read failed");
+            delete data;
+            return nullptr;
+        }
+
+        return data;
+    }
+}

support/sg2002/additional/vision/include/maix_image_def.hpp

@@ -18,7 +18,7 @@ namespace maix::image
 
     /**
      * Image formats
-     * @attention for developers, update this enum will also need to update the fmt_size in maix_image.cpp
+     * @attention for MaixPy firmware developers, update this enum will also need to update the fmt_size and fmt_names too !!!
      * @maixpy maix.image.Format
      */
     enum Format
@@ -36,6 +36,22 @@ namespace maix::image
         FMT_YVU420P,  // YYY...VVV...UUU
         FMT_YUV420P,  // YYY...UUU...VVV
         FMT_GRAYSCALE,
+        FMT_BGGR6,      // 6-bit Bayer format with a BGGR pattern.
+        FMT_GBRG6,      // 6-bit Bayer format with a GBRG pattern.
+        FMT_GRBG6,      // 6-bit Bayer format with a GRBG pattern.
+        FMT_RGGB6,      // 6-bit Bayer format with a RGGB pattern.
+        FMT_BGGR8,      // 8-bit Bayer format with a BGGR pattern.
+        FMT_GBRG8,      // 8-bit Bayer format with a GBRG pattern.
+        FMT_GRBG8,      // 8-bit Bayer format with a GRBG pattern.
+        FMT_RGGB8,      // 8-bit Bayer format with a RGGB pattern.
+        FMT_BGGR10,     // 10-bit Bayer format with a BGGR pattern.
+        FMT_GBRG10,     // 10-bit Bayer format with a GBRG pattern.
+        FMT_GRBG10,     // 10-bit Bayer format with a GRBG pattern.
+        FMT_RGGB10,     // 10-bit Bayer format with a RGGB pattern.
+        FMT_BGGR12,     // 12-bit Bayer format with a BGGR pattern.
+        FMT_GBRG12,     // 12-bit Bayer format with a GBRG pattern.
+        FMT_GRBG12,     // 12-bit Bayer format with a GRBG pattern.
+        FMT_RGGB12,     // 12-bit Bayer format with a RGGB pattern.
         FMT_UNCOMPRESSED_MAX,
 
         // compressed format below, not compressed should define upper
@@ -45,32 +61,8 @@ namespace maix::image
         FMT_COMPRESSED_MAX,
 
         FMT_INVALID = 0xFF  // format not valid
-    };
-    // enum Format
-    // {
-    //     FMT_RGB888    = 0,  // RGBRGB...RGB, R at the lowest address
-    //     FMT_BGR888    = 1,  // BGRBGR...BGR, B at the lowest address
-    //     FMT_RGBA8888  = 2,  // RGBARGBA...RGBA, R at the lowest address
-    //     FMT_BGRA8888  = 3,  // BGRABGRA...BGRA, B at the lowest address
-    //     FMT_RGB565    = 4,
-    //     FMT_BGR565    = 5,
-    //     FMT_YUV422SP  = 6,  // YYY...UVUVUV...UVUV
-    //     FMT_YUV422P   = 7,  // YYY...UUU...VVV
-    //     FMT_YVU420SP  = 8,  // YYY...VUVUVU...VUVU, NV21
-    //     FMT_YUV420SP  = 9,  // YYY...UVUVUV...UVUV, NV12
-    //     FMT_YVU420P   = 10, // YYY...VVV...UUU
-    //     FMT_YUV420P   = 11, // YYY...UUU...VVV
-    //     FMT_GRAYSCALE = 12, // YYY...
-    //     FMT_UNCOMPRESSED_MAX,
+    }; // !!!! update this section please update fmt_size and fmt_names too !!!!
 
-    //     // compressed format below, not compressed should define upper
-    //     FMT_COMPRESSED_MIN = 200,
-    //     FMT_JPEG           = 201,
-    //     FMT_PNG            = 202,
-    //     FMT_COMPRESSED_MAX,
-
-    //     FMT_INVALID = 0xFF  // format not valid
-    // };
     /**
      * Image format size in bytes
      * @attention It's a copy of this variable in MaixPy,
@@ -91,12 +83,29 @@ namespace maix::image
         1.5,
         1.5,
         1.5,
-        1,
-        0,
-        0,
-        0,
-        0,
-        0
+        1, // grayscale
+        0.75,   // 6-bit Bayer format
+        0.75,   // 6-bit Bayer format
+        0.75,   // 6-bit Bayer format
+        0.75,   // 6-bit Bayer format
+        1,      // 8-bit Bayer format
+        1,      // 8-bit Bayer format
+        1,      // 8-bit Bayer format
+        1,      // 8-bit Bayer format
+        1.25,   // 10-bit Bayer format
+        1.25,   // 10-bit Bayer format
+        1.25,   // 10-bit Bayer format
+        1.25,   // 10-bit Bayer format
+        1.5,    // 12-bit Bayer format
+        1.5,    // 12-bit Bayer format
+        1.5,    // 12-bit Bayer format
+        1.5,    // 12-bit Bayer format
+        0, // uncompereed_max
+        0, // compressed_min
+        1, // jpeg
+        1, // png
+        0, // compressed_max
+        0  // invalid
         };
 
     /**
@@ -114,10 +123,32 @@ namespace maix::image
         "YUV422P",
         "YVU420SP",
         "YUV420SP",
-        "YVU420P"
+        "YVU420P",
         "YUV420P",
         "GRAYSCALE",
-        "MAX"};
+        "BGGR6",
+        "GBRG6",
+        "GRBG6",
+        "RG6B6",
+        "BGGR8",
+        "GBRG8",
+        "GRBG8",
+        "RG6B8",
+        "BGGR10",
+        "GBRG10",
+        "GRBG10",
+        "RG6B10",
+        "BGGR12",
+        "GBRG12",
+        "GRBG12",
+        "RG6B12",
+        "UNCOMPRESSED_MAX",
+        "COMPRESSED_MIN",
+        "JPEG",
+        "PNG",
+        "COMPRESSED_MAX",
+        "INVALID"
+        };
 
     /**
      * Image size type
@@ -171,7 +202,7 @@ namespace maix::image
           * @param index 0 for width, 1 for height
           * @return int& width or height
           * @maixpy maix.image.Size.__getitem__
-          * @maixcdk maix.image.Size.[]
+          * @maixcdk maix.image.Size.operator[]
           */
         int &operator[](int index)
         {
@@ -267,4 +298,16 @@ namespace maix::image
         EDGE_CANNY,
         EDGE_SIMPLE,
     };
+
+    /**
+     * FlipDir
+     * @maixpy maix.image.FlipDir
+     */
+    enum class FlipDir
+    {
+        X,
+        Y,
+        XY
+    };
+
 }