diff --git a/README.md b/README.md
index ac4f6417..21b18b12 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # GoPro Controller
 
 Tool for control multiple GoPro Cameras, The design is for above 100 cameras connection.
-
+ 
 [Documentation](https://github.com/Elly2018/GoPro_Controller/wiki)
 
 ## Application Requirement
diff --git a/src/master/GoProMaster.cpp b/src/master/GoProMaster.cpp
index 96e82ad8..5fcb0de2 100644
--- a/src/master/GoProMaster.cpp
+++ b/src/master/GoProMaster.cpp
@@ -25,7 +25,7 @@ GoProMaster::~GoProMaster() {
         t1.join();
     }
     for (auto& s : servers) {
-        s->client.close();
+        s->client->close();
         std::lock_guard<std::mutex> lock(camera_mtx);
         cleanCameraFromServer(s->ip);
     }
@@ -40,9 +40,10 @@ std::string GoProMaster::addServer(const std::string& ip) {
     }
 
     auto conn = std::make_shared<ServerConnection>();
+    conn->client = std::make_shared<hv::WebSocketClient>();
     conn->ip = ip;
     
-    conn->client.onopen = [conn, this]() {
+    conn->client->onopen = [conn, this]() {
         std::cout << "Connected to server: " << conn->ip << std::endl;
         conn->connected = true;
         {
@@ -52,12 +53,12 @@ std::string GoProMaster::addServer(const std::string& ip) {
             ImGui::InsertNotification(toast);
         }
     };
-    conn->client.onmessage = [conn, this](const std::string& msg) {
+    conn->client->onmessage = [conn, this](const std::string& msg) {
         std::thread([=]() {
             processMessage(conn->ip, msg);
         }).detach();
     };
-    conn->client.onclose = [conn, this]() {
+    conn->client->onclose = [conn, this]() {
         if(conn->connected){
             std::cout << "Disconnected from server: " << conn->ip << std::endl;
             conn->connected = false;
@@ -85,7 +86,7 @@ void GoProMaster::reconnectAll() {
             std::cout << "Connecting to " << s->ip << "..." << std::endl;
             // Assuming ws://ip:9090 based on server implementation
             std::string url = "ws://" + s->ip + ":9090";
-            s->client.open(url.c_str());
+            s->client->open(url.c_str());
         }
     }
 }
@@ -94,7 +95,7 @@ void GoProMaster::disconnectAll(){
     for (auto& s : servers) {
         if (s->connected) {
             std::cout << "Disconnect to " << s->ip << "..." << std::endl;
-            s->client.close();
+            s->client->close();
         }
     }
 }
@@ -114,7 +115,7 @@ void GoProMaster::reconnect(const std::string& ip){
         if(s->ip == ip && !s->connected){
             std::cout << "Connecting to " << s->ip << "..." << std::endl;
             std::string url = "ws://" + s->ip + ":9090";
-            s->client.open(url.c_str());
+            s->client->open(url.c_str());
             break;
         }
     }
@@ -124,7 +125,7 @@ void GoProMaster::disconnect(const std::string& ip){
     for(auto& s : servers){
         if(s->ip == ip && s->connected){
             std::cout << "Disconnecting to " << s->ip << "..." << std::endl;
-            s->client.close();
+            s->client->close();
             break;
         }
     }
@@ -149,7 +150,7 @@ void GoProMaster::command_only(const std::string command, std::string target){
 
     for(auto s : servers){
         if(s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
         }
     }
 }
@@ -163,7 +164,7 @@ void GoProMaster::command_only(const std::string server, const std::string comma
 
     for(auto s : servers){
         if(s->ip == server && s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
             break;
         }
     }
@@ -179,7 +180,7 @@ void GoProMaster::command_with_value(const std::string command, std::string targ
 
     for(auto s : servers){
         if(s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
         }
     }
 }
@@ -193,7 +194,7 @@ void GoProMaster::query_only(const std::string command, std::string target){
 
     for(auto s : servers){
         if(s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
         }
     }
 }
@@ -207,7 +208,7 @@ void GoProMaster::query_only(const std::string server, const std::string command
 
     for(auto s : servers){
         if(s->ip == server && s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
             break;
         }
     }
@@ -222,7 +223,7 @@ void GoProMaster::webcam_only(const std::string command, std::string target){
 
     for(auto s : servers){
         if(s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
         }
     }
 }
@@ -236,7 +237,7 @@ void GoProMaster::webcam_only(const std::string server, const std::string comman
 
     for(auto s : servers){
         if(s->ip == server && s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
             break;
         }
     }
@@ -255,7 +256,7 @@ void GoProMaster::preview_start(std::string server, std::string target){
 
     for(auto s : servers){
         if(s->ip == server && s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
             break;
         }
     }
@@ -270,7 +271,7 @@ void GoProMaster::preview_end(std::string server, std::string target){
 
     for(auto s : servers){
         if((s->ip == server || server.size() == 0) && s->connected){
-            s->client.send(data.dump());
+            s->client->send(data.dump());
             break;
         }
     }
@@ -293,26 +294,33 @@ void GoProMaster::download_last_media(const std::string ip, const DownloadMediaP
         for(auto& s : cameras){
             if(!s->connected) continue;
             if(ip.size() > 0 && s->ip != ip) continue;
-            std::string filename = s->name + fs::path(s->last_media).extension().string();
+            std::string ext = fs::path(s->last_media).extension().string();
+            std::string filename = s->name;
             if(filename.size() == 0 || s->name.size() == 0) {
                 std::cerr << "[download_last_media] filename size is 0, we just skip..." << std::endl;
                 continue;
             }
             size_t filename_size = filename.size();
+            std::cout << "[download_last_media] \ttype: " << params.type << std::endl;
+            std::cout << "[download_last_media] \tfilename: " << filename.c_str() << std::endl;
             if(params.c_count > 0){
                 std::string ccc = "";
-                if(params.type == 1){
-                    filename.reserve();
-                }
                 for(int32_t i = 0; i < params.c_count && i < filename_size; i++){
-                    ccc += filename.at(filename.size() - 1);
-                    filename.pop_back();
+                    if(params.type == 1){
+                        ccc += filename.at(0);
+                        filename.erase(filename.begin());
+                    }
+                    if(params.type == 2){
+                        ccc += filename.at(filename.size() - 1);
+                        filename.erase(filename.begin() + filename.size() - 1);
+                    }
                 }
                 if(params.type == 2){
                     ccc.reserve();
                 }
                 filename = ccc;
             }
+            filename += ext;
             bool islocal = s->server == "127.0.0.1";
 
             json data = json::object();
@@ -327,7 +335,7 @@ void GoProMaster::download_last_media(const std::string ip, const DownloadMediaP
 
             for(auto ss : servers){
                 if(s->server == ss->ip && ss->connected){
-                    ss->client.send(data.dump());
+                    ss->client->send(data.dump());
                     downloading_last_media_total++;
                     break;
                 }
@@ -350,7 +358,7 @@ void GoProMaster::presetSwitch(const std::string server, const std::string targe
             get_status["value"]["name"] = "load";
             get_status["value"]["mode"] = mode;
             get_status["value"]["target"] = target;
-            s->client.send(get_status.dump());
+            s->client->send(get_status.dump());
         }
     }).detach();
 }
@@ -384,7 +392,7 @@ void GoProMaster::apply(const std::string& ip, const std::string& target, const
             get_status["value"]["target"] = target;
             get_status["value"]["id"] = id;
             get_status["value"]["value"] =  std::to_string(value);
-            s->client.send(get_status.dump());
+            s->client->send(get_status.dump());
         }
     }).detach();
 }
@@ -399,24 +407,24 @@ void GoProMaster::applyAll(const std::string& ip, const json& res){
             get_status["value"]["source"] = ip;
             get_status["value"]["name"] = "setall";
             get_status["value"]["value"] = res;
-            s->client.send(get_status.dump());
+            s->client->send(get_status.dump());
         }
     }).detach();
 }
 
-void GoProMaster::quickApplyAll(const std::shared_ptr<CameraInfo>& target){
-    int32_t model = InspectorWindow::_get_current_model(target->hw);
+void GoProMaster::quickApplyAll(const CameraInfo& target){
+    int32_t model = InspectorWindow::_get_current_model(target.hw);
     json root = json::object();
     json _set = json::object();
     json _status = json::object();
-    if(getSettingsFromCamera(*target, _set) && getStatusFromCamera(*target, _status)){
+    if(getSettingsFromCamera(target, _set) && getStatusFromCamera(target, _status)){
         // Execute the apply logic here
         int32_t p = _status[std::to_string(PRESET_ID)].get<int32_t>();
         root["model"] = model; // Added a model field for mark it's supported
         root["preset"] = p;
         root["setting"] = _set;
         std::cout << "trying apply all, preset: " << p << std::endl;
-        applyAll(target->ip, root);
+        applyAll(target.ip, root);
     }
 }
 
@@ -507,6 +515,7 @@ bool GoProMaster::remove_preset(const std::string name){
     }
     return false;
 }
+
 std::vector<std::string> GoProMaster::get_preset_names(){
     if(!(*preset_ptr)["data"].is_array()) {
         (*preset_ptr)["data"] = json::array();
@@ -531,16 +540,67 @@ const std::vector<CameraInfo> GoProMaster::getCameras_Clone() {
     {
         std::lock_guard<std::mutex> lock(camera_mtx);
         for(auto& i : getCameras()){
-            buffer.push_back(*i.get());
+            CameraInfo sc = CameraInfo();
+            sc.hw = json::parse(i->hw.dump());
+            sc.state = json::parse(i->state.dump());
+            sc.ip = i->ip;
+            sc.last_media = i->last_media;
+            sc.name = i->name;
+            sc.serial = i->serial;
+            sc.connected = i->connected;
+            sc.server = i->server;
+            buffer.push_back(sc);
         }
     }
     return buffer;
 }
 
+const CameraInfo GoProMaster::getCamera_Clone(int32_t index) {
+    if(index < 0 || index >= cameras.size()) return CameraInfo();
+    CameraInfo sc = CameraInfo();
+    auto i = getCameras().at(index).get();
+    sc.hw = i->hw;
+    sc.ip = i->ip;
+    sc.last_media = i->last_media;
+    sc.name = i->name;
+    sc.serial = i->serial;
+    sc.connected = i->connected;
+    sc.state = i->state;
+    sc.server = i->server;
+    return sc;
+}
+
 const std::vector<std::shared_ptr<ServerConnection>>& GoProMaster::getServers() const {
     return servers;
 }
 
+const std::vector<ServerConnection> GoProMaster::getServers_Clone() {
+    std::vector<ServerConnection> buffer = std::vector<ServerConnection>();
+    {
+        std::lock_guard<std::mutex> lock(server_mtx);
+        for(auto& i : getServers()){
+            ServerConnection sc = ServerConnection();
+            sc.ip = i->ip;
+            sc.connected = i->connected;
+            sc.last_message = i->last_message;
+            sc.client = i->client;
+            buffer.push_back(sc);
+        }
+    }
+    return buffer;
+}
+
+const ServerConnection GoProMaster::getServer_Clone(int32_t index) {
+    if(index < 0 || index >= servers.size()) return ServerConnection();
+    ServerConnection sc = ServerConnection();
+    auto i = getServers().at(index).get();
+    sc.ip = i->ip;
+    sc.connected = i->connected;
+    sc.last_message = i->last_message;
+    sc.client = i->client;
+    return sc;
+}
+
 void GoProMaster::update(){
     while (!done) {
         for (auto& s : servers) {
@@ -551,7 +611,7 @@ void GoProMaster::update(){
             get_status["value"] = json::object();
             get_status["value"]["name"] = "ip";
             ipQueryFinish.insert_or_assign(s->ip, true);
-            s->client.send(get_status.dump());
+            s->client->send(get_status.dump());
         }
 
         for (auto& s : servers) {
@@ -562,7 +622,7 @@ void GoProMaster::update(){
             get_status["value"] = json::object();
             get_status["value"]["name"] = "getall";
             stateQueryFinish.insert_or_assign(s->ip, true);
-            s->client.send(get_status.dump());
+            s->client->send(get_status.dump());
         }
 
         for (auto& s : servers) {
@@ -573,7 +633,7 @@ void GoProMaster::update(){
             get_status["value"] = json::object();
             get_status["value"]["name"] = "lastmedia";
             mediaQueryFinish.insert_or_assign(s->ip, true);
-            s->client.send(get_status.dump());
+            s->client->send(get_status.dump());
         }
 
         std::lock_guard<std::mutex> lock(locate_mtx);
@@ -849,7 +909,7 @@ void GoProMaster::processMessage(const std::string& server, const std::string& m
 void GoProMaster::sendToAll(const std::string& msg) {
     for (auto& s : servers) {
         if (s->connected) {
-            s->client.send(msg);
+            s->client->send(msg);
         }
     }
 }
@@ -962,9 +1022,13 @@ bool GoProMaster::getStatusFromCamera(CameraInfo target, json& res){
 }
 
 std::string GoProMaster::getBarInfo(const std::shared_ptr<CameraInfo> &c){
-    json obj = c->state;
+    return getBarInfo(*c);
+}
+
+std::string GoProMaster::getBarInfo(const CameraInfo &c){
+    json obj = c.state;
     bool find = false;
-    std::string result = c->name + "  " + c->serial + "  " + c->ip + "  ";
+    std::string result = c.name + "  " + c.serial + "  " + c.ip + "  ";
     if(obj["settings"].is_object()){
         if(obj["settings"]["2"].is_number()){
             int32_t vr = obj["settings"]["2"].get<int32_t>();
@@ -989,7 +1053,7 @@ std::string GoProMaster::getBarInfo(const std::shared_ptr<CameraInfo> &c){
             find = true;
         }
     }
-    if(!find) return c->ip + "  ...";
+    if(!find) return c.ip + "  ...";
     return result;
 }
 
@@ -1010,6 +1074,7 @@ int32_t GoProMaster::findServer(const std::string ip){
 
 int32_t GoProMaster::findCamera(const std::string server, const std::string ip){
     int32_t index = 0;
+    //std::lock_guard<std::mutex> lock(camera_mtx);
     for(const auto& c : cameras){
         if(c->server == server && c->ip == ip){
             return index;
@@ -1017,4 +1082,4 @@ int32_t GoProMaster::findCamera(const std::string server, const std::string ip){
         ++index;
     }
     return -1;
-}
\ No newline at end of file
+}
diff --git a/src/master/GoProMaster.h b/src/master/GoProMaster.h
index 12009739..bb14297a 100644
--- a/src/master/GoProMaster.h
+++ b/src/master/GoProMaster.h
@@ -102,7 +102,7 @@ class GoProMaster {
     int32_t haslocate(const std::string server, const std::string target);
     void apply(const std::string& ip, const std::string& target, const int32_t id, const int32_t value);
     void applyAll(const std::string& ip, const json& res);
-    void quickApplyAll(const std::shared_ptr<CameraInfo>& target);
+    void quickApplyAll(const CameraInfo& target);
 
     bool directoryExists(const std::string& path);
 
@@ -132,6 +132,7 @@ class GoProMaster {
      */
     std::mutex camera_mtx;
     std::mutex locate_mtx;
+    std::mutex server_mtx;
 
     // ----------------------------------------------------------
     //
@@ -146,10 +147,13 @@ class GoProMaster {
      * Get current camera record (Clone, For thread optimization)
      */
     const std::vector<CameraInfo> getCameras_Clone();
+    const CameraInfo getCamera_Clone(int32_t index);
     /**
      * Get current websocket server record
      */
     const std::vector<std::shared_ptr<ServerConnection>>& getServers() const;
+    const std::vector<ServerConnection> getServers_Clone();
+    const ServerConnection getServer_Clone(int32_t index);
 private:
     /** 
      * All cameras record for master
@@ -225,6 +229,7 @@ class GoProMaster {
     bool getSettingsFromCamera(CameraInfo target, json& res);
     bool getStatusFromCamera(CameraInfo target, json& res);
     std::string getBarInfo(const std::shared_ptr<CameraInfo> &c);
+    std::string getBarInfo(const CameraInfo &c);
 
     size_t getServerCount();
     int32_t findServer(const std::string ip);
diff --git a/src/master/data/camera_info.h b/src/master/data/camera_info.h
index 558ae38f..abf12384 100644
--- a/src/master/data/camera_info.h
+++ b/src/master/data/camera_info.h
@@ -29,6 +29,6 @@ struct CameraInfo {
     /**
      * The json states
      */
-    json state;
-    json hw;
+    json state = json::object();
+    json hw = json::object();
 };
\ No newline at end of file
diff --git a/src/master/data/server_connection.h b/src/master/data/server_connection.h
index 997d35e9..ad423e97 100644
--- a/src/master/data/server_connection.h
+++ b/src/master/data/server_connection.h
@@ -19,7 +19,7 @@ struct ServerConnection {
     /**
      * The libhv websocket client
      */
-    hv::WebSocketClient client;
+    std::shared_ptr<hv::WebSocketClient> client;
     /**
      * Current connection state
      */
diff --git a/src/master/popup/preview/decode.cpp b/src/master/popup/preview/decode.cpp
index 38098657..71e64f28 100644
--- a/src/master/popup/preview/decode.cpp
+++ b/src/master/popup/preview/decode.cpp
@@ -16,7 +16,6 @@ void PreviewPopup::update_decoder(){
     }
 
     {
-        std::lock_guard<std::mutex> lock(master->camera_mtx);
         s = master->findCamera(state->preview_server, state->preview_ip);
 
         if(s == -1){
@@ -24,10 +23,10 @@ void PreviewPopup::update_decoder(){
             trying = false;
             return;
         }
-        const std::shared_ptr<CameraInfo>& c = master->getCameras().at(s);
-        model = _get_current_model(c->hw);
+        const CameraInfo c = master->getCamera_Clone(s);
+        model = _get_current_model(c.hw);
         json buffer_setting = json::object();
-        master->getSettingsFromCamera(*c, buffer_setting);
+        master->getSettingsFromCamera(c, buffer_setting);
     }
 
     if(gl_texture != 0){
diff --git a/src/master/popup/preview/preview_popwin.cpp b/src/master/popup/preview/preview_popwin.cpp
index 3991b7f5..67294ec2 100644
--- a/src/master/popup/preview/preview_popwin.cpp
+++ b/src/master/popup/preview/preview_popwin.cpp
@@ -48,11 +48,11 @@ void PreviewPopup::set_window_data(json data){
     }
 }
 
-void PreviewPopup::register_setting_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c)> caller){
+void PreviewPopup::register_setting_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c)> caller){
     setting_drawer = caller;
 }
 
-void PreviewPopup::register_protune_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c)> caller){
+void PreviewPopup::register_protune_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c)> caller){
     protune_drawer = caller;
 }
 
@@ -162,10 +162,9 @@ void PreviewPopup::_draw_bottom_button(){
 void PreviewPopup::_draw_setting(){
     if(setting_drawer != NULL){
         int32_t s = -1;
-        std::lock_guard<std::mutex> lock(master->camera_mtx);
         s = master->findCamera(state->preview_server, state->preview_ip);
         if(s != -1){
-            const std::shared_ptr<CameraInfo>& c = master->getCameras().at(s);
+            const CameraInfo c = master->getCamera_Clone(s);
             if(ImGui::Button("Quick Apply All##Preview_Popwin_Action")){
                 state->applying_all = true;
                 master->quickApplyAll(c);
diff --git a/src/master/popup/preview_popwin.h b/src/master/popup/preview_popwin.h
index a06d929f..efa37819 100644
--- a/src/master/popup/preview_popwin.h
+++ b/src/master/popup/preview_popwin.h
@@ -53,8 +53,8 @@ class PreviewPopup : public BasePopWindow {
     json get_window_data() override;
     void set_window_data(json data) override;
 
-    void register_setting_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c)> caller);
-    void register_protune_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c)> caller);
+    void register_setting_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c)> caller);
+    void register_protune_drawer(std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c)> caller);
 
     virtual void trigger(bool value) override;
     virtual void update_decoder();
@@ -70,8 +70,8 @@ class PreviewPopup : public BasePopWindow {
     void _draw_setting();
 
 private:
-    std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c)> setting_drawer;
-    std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c)> protune_drawer;
+    std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c)> setting_drawer;
+    std::function<void(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c)> protune_drawer;
     cv::VideoCapture cap;
     std::string pipeline;
     std::queue<cv::Mat> frame_queue;
diff --git a/src/master/windows/camera_list.h b/src/master/windows/camera_list.h
index 591df14a..b2fe580e 100644
--- a/src/master/windows/camera_list.h
+++ b/src/master/windows/camera_list.h
@@ -45,15 +45,15 @@ class CameraListWindow : public BaseWindow {
     void set_window_data(json data) override;
     virtual void render() override;
 
-    virtual void draw_line(const std::shared_ptr<CameraInfo>& c);
-    virtual void draw_group_state(const std::shared_ptr<CameraInfo>& c);
-    virtual void draw_group_header(const std::shared_ptr<CameraInfo>& c);
-    virtual void item_event(const std::shared_ptr<CameraInfo>& c);
-    void onClick(const std::shared_ptr<CameraInfo>& c);
+    virtual void draw_line(const CameraInfo& c);
+    virtual void draw_group_state(const CameraInfo& c);
+    virtual void draw_group_header(const CameraInfo& c);
+    virtual void item_event(const CameraInfo& c);
+    void onClick(const CameraInfo& c);
 
 private:
     ImVec2 get_rect_size();
-    std::vector<std::shared_ptr<CameraInfo>> get_filtering_result();
+    std::vector<CameraInfo> get_filtering_result();
     std::string get_filter_string(FilterType type);
     std::string get_sort_string(SortType type);
     std::string toTimeCode(int32_t timer);
diff --git a/src/master/windows/camera_list/camera_list.cpp b/src/master/windows/camera_list/camera_list.cpp
index a13cc159..7b502ac9 100644
--- a/src/master/windows/camera_list/camera_list.cpp
+++ b/src/master/windows/camera_list/camera_list.cpp
@@ -60,7 +60,6 @@ void CameraListWindow::render(){
     ImGui::Begin(title.c_str(), &enable, w_flag);
     {
         ImVec2 window_size = ImGui::GetWindowSize();
-        std::lock_guard<std::mutex> lock(master->camera_mtx);
 
         changed = ImGui::SliderInt("Item Size##Camera_List_Size", &size, 0, 15);
         changed = changed || ImGui::InputText("Search", &search);
@@ -110,10 +109,10 @@ void CameraListWindow::render(){
         float width = ImGui::GetWindowSize().x; // Total space size
         int32_t limit = static_cast<int32_t>((width / rect_size.x) - 0.5f);
         int32_t counter = 0;
-        std::vector<std::shared_ptr<CameraInfo>> ciss = get_filtering_result();
+        std::vector<CameraInfo> ciss = get_filtering_result();
         ImGui::Text("Cal: %f/%f, Total: %d, Line: %d", width, rect_size.x, size, limit);
         for(const auto& c : ciss){
-            if(c){
+            if(c.ip.size() > 0){
                 try{
                     if(size == 0) draw_line(c);
                     else {
@@ -141,10 +140,10 @@ void CameraListWindow::render(){
     }
 }
 
-void CameraListWindow::draw_line(const std::shared_ptr<CameraInfo>& c){
-    bool selected = c->ip == state->current_camera_item && c->server == state->current_camera_server;
+void CameraListWindow::draw_line(const CameraInfo& c){
+    bool selected = c.ip == state->current_camera_item && c.server == state->current_camera_server;
     std::string plusStatus = master->getBarInfo(c);
-    std::string plusID = plusStatus + "##CameraList_" + c->ip;
+    std::string plusID = plusStatus + "##CameraList_" + c.ip;
     if(ImGui::Selectable(plusID.c_str(), selected)){
         // User select interaction
         onClick(c);
@@ -152,60 +151,60 @@ void CameraListWindow::draw_line(const std::shared_ptr<CameraInfo>& c){
     item_event(c);
 }
 
-void CameraListWindow::item_event(const std::shared_ptr<CameraInfo>& c){
+void CameraListWindow::item_event(const CameraInfo& c){
     if(ImGui::IsItemClicked(ImGuiMouseButton_Left) && ImGui::IsItemHovered()){
         onClick(c);
     }
     if(ImGui::IsItemClicked(ImGuiMouseButton_Right) && ImGui::IsItemHovered()){
         ImGui::OpenPopupOnItemClick();
     }
-    if(ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) && ImGui::IsItemHovered() && c->connected){
-        master->preview_start(c->server, c->ip);
-        state->preview_ip = c->ip;
-        state->preview_server = c->server;
+    if(ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) && ImGui::IsItemHovered() && c.connected){
+        master->preview_start(c.server, c.ip);
+        state->preview_ip = c.ip;
+        state->preview_server = c.server;
         state->command_sender("preview_start");
     }
 
-    if(ImGui::BeginPopupContextItem((title + "##Popup_Menu" + c->ip).c_str())){
-        ImGui::BeginDisabled(!c->connected);
+    if(ImGui::BeginPopupContextItem((title + "##Popup_Menu" + c.ip).c_str())){
+        ImGui::BeginDisabled(!c.connected);
         if (ImGui::Selectable("Connect")){
-            master->command_only(c->server, "usb_on", c->ip);
+            master->command_only(c.server, "usb_on", c.ip);
         }
         if (ImGui::Selectable("Disconnect")){
-            master->command_only(c->server, "usb_off", c->ip);
+            master->command_only(c.server, "usb_off", c.ip);
         }
         ImGui::Separator();
         if (ImGui::Selectable("Reboot"))
         {
-            master->command_only(c->server, "reboot", c->ip);
+            master->command_only(c.server, "reboot", c.ip);
         }
         if (ImGui::Selectable("Shutdown"))
         {
-            master->command_only(c->server, "shutdown", c->ip);
+            master->command_only(c.server, "shutdown", c.ip);
         }
         if (ImGui::Selectable("Preview"))
         {
-            master->preview_start(c->server, c->ip);
-            state->preview_ip = c->ip;
-            state->preview_server = c->server;
+            master->preview_start(c.server, c.ip);
+            state->preview_ip = c.ip;
+            state->preview_server = c.server;
             state->command_sender("preview_start");
         }
         ImGui::EndDisabled();
         if (ImGui::Selectable("Delete"))
         {
-            master->command_only(c->server, "delete", c->ip);
+            master->command_only(c.server, "delete", c.ip);
         }
         ImGui::EndPopup();
     }
 }
 
-void CameraListWindow::onClick(const std::shared_ptr<CameraInfo>& c){
+void CameraListWindow::onClick(const CameraInfo& c){
     state->current_setting_items_bind = false;
-    state->current_camera_item = c->ip;
-    state->current_camera_server = c->server;
-    state->current_camera_name = c->name;
-    std::cout << "Select camera: " << c->server << "  " << c->ip << std::endl;
-    master->query_only(c->server, "get", c->ip);
+    state->current_camera_item = c.ip;
+    state->current_camera_server = c.server;
+    state->current_camera_name = c.name;
+    std::cout << "Select camera: " << c.server << "  " << c.ip << std::endl;
+    master->query_only(c.server, "get", c.ip);
     //current_setting_items_bind = master.getSettingsFromCamera(*c, current_setting_items);
 }
 
@@ -213,24 +212,24 @@ ImVec2 CameraListWindow::get_rect_size(){
     return ImVec2(10 * (size + 10) + 20, 10 * (size + 10) + 20);
 }
 
-std::vector<std::shared_ptr<CameraInfo>> CameraListWindow::get_filtering_result(){
-    auto buffer = master->getCameras();
-    auto filtered = std::vector<std::shared_ptr<CameraInfo>>();
+std::vector<CameraInfo> CameraListWindow::get_filtering_result(){
+    auto buffer = master->getCameras_Clone();
+    auto filtered = std::vector<CameraInfo>();
 
     for(auto& c : buffer){
         if(search.size() > 0){
-            bool ip_contain = c->ip.find(search) != std::string::npos;
-            bool name_contain = c->name.find(search) != std::string::npos;
-            bool serial_contain = c->serial.find(search) != std::string::npos;
+            bool ip_contain = c.ip.find(search) != std::string::npos;
+            bool name_contain = c.name.find(search) != std::string::npos;
+            bool serial_contain = c.serial.find(search) != std::string::npos;
             if(!ip_contain && !name_contain && !serial_contain) continue;
         }
 
         if(filter == FilterType::Connect){
-            if(c->connected == filter_connect){
+            if(c.connected == filter_connect){
                 filtered.push_back(c);
             }
         }else if(filter == FilterType::Server){
-            if(c->server == filter_ip){
+            if(c.server == filter_ip){
                 filtered.push_back(c);
             }
         }else {
@@ -239,12 +238,12 @@ std::vector<std::shared_ptr<CameraInfo>> CameraListWindow::get_filtering_result(
     }
 
     if (sort == SortType::Name){
-        std::sort(filtered.begin(), filtered.end(), [](const std::shared_ptr<CameraInfo>& a, const std::shared_ptr<CameraInfo>& b){
-            return a->name < b->name;
+        std::sort(filtered.begin(), filtered.end(), [](const CameraInfo& a, const CameraInfo& b){
+            return a.name < b.name;
         });
     }else if (sort == SortType::IP){
-        std::sort(filtered.begin(), filtered.end(), [](const std::shared_ptr<CameraInfo>& a, const std::shared_ptr<CameraInfo>& b){
-            return a->ip < b->ip;
+        std::sort(filtered.begin(), filtered.end(), [](const CameraInfo& a, const CameraInfo& b){
+            return a.ip < b.ip;
         });
     }
     
diff --git a/src/master/windows/camera_list/display_header.cpp b/src/master/windows/camera_list/display_header.cpp
index 9f2c0d00..e32d96e3 100644
--- a/src/master/windows/camera_list/display_header.cpp
+++ b/src/master/windows/camera_list/display_header.cpp
@@ -1,17 +1,17 @@
 #include "../camera_list.h"
 
-void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
+void CameraListWindow::draw_group_header(const CameraInfo& c){
     json status = json::object();
     json setting = json::object();
     int preset = 0;
-    master->getStatusFromCamera(*c, status);
-    master->getSettingsFromCamera(*c, setting);
+    master->getStatusFromCamera(c, status);
+    master->getSettingsFromCamera(c, setting);
 
     ImGui::BeginGroup();
     ImGuiStyle& style = ImGui::GetStyle();
     float fontsize = ImGui::GetFontSize();
-    std::string id = c->ip + "##Grid_Item_ID";
-    std::string pid = c->ip + "##Grid_Popup_Item_ID";
+    std::string id = c.ip + "##Grid_Item_ID";
+    std::string pid = c.ip + "##Grid_Popup_Item_ID";
     ImGui::PushID(id.c_str());
 
     ImDrawList* draw_list = ImGui::GetWindowDrawList();
@@ -37,11 +37,11 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
     // Drawing outline
     {
         uint32_t col = col_red;
-        if(c->connected) col = col_greed;
+        if(c.connected) col = col_greed;
         draw_list->AddRect(image_pos + ImVec2(5, 5), image_pos_max - ImVec2(5, 5), col, 2.0F, 0, 2.0F);
     }
     // Drawing Battery
-    if(c->connected){
+    if(c.connected){
         bool batteryHave = false;
         bool batteryCharging = false;
         int precentage = 0;
@@ -108,7 +108,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
         }
     }
     // Drawing SD card
-    if(c->connected){
+    if(c.connected){
         bool sdHave = false;
         int64_t remaining = 0;
         uint32_t col_inner_color;
@@ -157,7 +157,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
     // Center text
     {
         std::string shutter_speed;
-        std::string camera_title = c->name;
+        std::string camera_title = c.name;
         std::string iso_setting;
         std::string white_balance_setting;
         float spacing = 0.75F;
@@ -174,7 +174,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
             center.y + ( camera_title_size.y / -2.0F ) + (rect_size_unit.y * (spacing * -3.0F))
         );
         draw_list->AddText(camera_title_min, col_white, camera_title.c_str());
-        if(c->connected) {
+        if(c.connected) {
             int32_t SHUTTER_SPEED_ID = SHUTTER_SPEED_PHOTO_ID;
             int32_t ISO_MIN_ID = ISO_MIN_PHOTO_ID;
             int32_t ISO_MAX_ID = ISO_MAX_PHOTO_ID;
@@ -231,7 +231,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
         }
     }
     // Record Time
-    if(c->connected){
+    if(c.connected){
         ImVec2 frame_padding = ImVec2(10, 10);
         ImVec2 center = ImVec2(
             image_pos.x + (rect_size.x / 2.0F),
@@ -253,7 +253,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
         draw_list->AddText(record_time_min, col_white, record_time.c_str());
     }
     // Preset mode
-    if(c->connected){
+    if(c.connected){
         int32_t preset;
         std::string preset_text;
         if(status[std::to_string(PRESET_ID)].is_number_integer()){
@@ -279,7 +279,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
         ), col_white, preset_text.c_str());
     }
     // Setting
-    if(c->connected){
+    if(c.connected){
         float spacing = 0.75F;
         float word_spacing = 10;
         std::string res;
@@ -335,7 +335,7 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
     
     ImGui::PopID();
     ImGui::Dummy(rect_size);
-    bool is_select = state->current_camera_item == c->ip && state->current_camera_server == c->server;
+    bool is_select = state->current_camera_item == c.ip && state->current_camera_server == c.server;
     if(ImGui::IsItemHovered()){
         std::string displayText = "";
         displayText += "name: ";
@@ -343,28 +343,28 @@ void CameraListWindow::draw_group_header(const std::shared_ptr<CameraInfo>& c){
         displayText += "\n";
 
         displayText += "server: ";
-        displayText += c->server;
+        displayText += c.server;
         displayText += "\n";
 
         displayText += "ip: ";
-        displayText += c->ip;
+        displayText += c.ip;
         displayText += "\n";
 
         displayText += "serial: ";
-        if(c->hw["serial_number"].is_string()){
-            displayText += c->hw["serial_number"].get<std::string>();
+        if(c.hw.is_object() && c.hw["serial_number"].is_string()){
+            displayText += c.hw["serial_number"].get<std::string>();
         }
         displayText += "\n";
 
         displayText += "model: ";
-        if(c->hw["model_name"].is_string()){
-            displayText += c->hw["model_name"].get<std::string>();
+        if(c.hw.is_object() && c.hw["model_name"].is_string()){
+            displayText += c.hw["model_name"].get<std::string>();
         }
         displayText += "\n";
 
         displayText += "firmware: ";
-        if(c->hw["firmware_version"].is_string()){
-            displayText += c->hw["firmware_version"].get<std::string>();
+        if(c.hw.is_object() && c.hw["firmware_version"].is_string()){
+            displayText += c.hw["firmware_version"].get<std::string>();
         }
         displayText += "\n";
         ImGui::SetItemTooltip("%s", displayText.c_str());
diff --git a/src/master/windows/camera_list/display_state.cpp b/src/master/windows/camera_list/display_state.cpp
index c7d6608b..1447ad29 100644
--- a/src/master/windows/camera_list/display_state.cpp
+++ b/src/master/windows/camera_list/display_state.cpp
@@ -1,426 +1,428 @@
 #include "../camera_list.h"
 
-void CameraListWindow::draw_group_state(const std::shared_ptr<CameraInfo>& c){
+void CameraListWindow::draw_group_state(const CameraInfo& c){
     json status = json::object();
     json setting = json::object();
     int32_t preset = 0;
-    master->getStatusFromCamera(*c, status);
-    master->getSettingsFromCamera(*c, setting);
+    master->getStatusFromCamera(c, status);
+    master->getSettingsFromCamera(c, setting);
 
     ImGui::BeginGroup();
-    ImGuiStyle& style = ImGui::GetStyle();
-    float fontsize = ImGui::GetFontSize();
-    std::string id = c->ip + "##Grid_Item_ID";
-    std::string pid = c->ip + "##Grid_Popup_Item_ID";
-    ImGui::PushID(id.c_str());
-
-    ImDrawList* draw_list = ImGui::GetWindowDrawList();
-    ImVec2 image_pos = ImGui::GetCursorScreenPos();
-    ImVec2 rect_size = get_rect_size();
-    ImVec2 rect_size_unit = ImVec2(rect_size.x / 12.0F, rect_size.y / 12.0F);
-
-    ImVec2 image_pos_max = image_pos + rect_size;
-    uint32_t col_white = IM_COL32(255, 255, 255, 255);
-    uint32_t col_grey = IM_COL32(210, 210, 210, 255);
-    uint32_t col_grey_light = IM_COL32(210, 210, 210, 50);
-    uint32_t col_red = IM_COL32(230, 10, 10, 255);
-    uint32_t col_orange = IM_COL32(230, 230, 10, 255);
-    uint32_t col_orange_dark = IM_COL32(80, 80, 10, 255);
-    uint32_t col_greed = IM_COL32(10, 230, 10, 255);
-
-    // Get preset
-    {
-        if(status[std::to_string(PRESET_ID)].is_number_integer()){
-            preset = status[std::to_string(PRESET_ID)].get<int32_t>();
+    {    
+        ImGuiStyle& style = ImGui::GetStyle();
+        float fontsize = ImGui::GetFontSize();
+        std::string id = c.ip + "##Grid_Item_ID";
+        std::string pid = c.ip + "##Grid_Popup_Item_ID";
+        ImGui::PushID(id.c_str());
+
+        ImDrawList* draw_list = ImGui::GetWindowDrawList();
+        ImVec2 image_pos = ImGui::GetCursorScreenPos();
+        ImVec2 rect_size = get_rect_size();
+        ImVec2 rect_size_unit = ImVec2(rect_size.x / 12.0F, rect_size.y / 12.0F);
+
+        ImVec2 image_pos_max = image_pos + rect_size;
+        uint32_t col_white = IM_COL32(255, 255, 255, 255);
+        uint32_t col_grey = IM_COL32(210, 210, 210, 255);
+        uint32_t col_grey_light = IM_COL32(210, 210, 210, 50);
+        uint32_t col_red = IM_COL32(230, 10, 10, 255);
+        uint32_t col_orange = IM_COL32(230, 230, 10, 255);
+        uint32_t col_orange_dark = IM_COL32(80, 80, 10, 255);
+        uint32_t col_greed = IM_COL32(10, 230, 10, 255);
+
+        // Get preset
+        {
+            if(status[std::to_string(PRESET_ID)].is_number_integer()){
+                preset = status[std::to_string(PRESET_ID)].get<int32_t>();
+            }
         }
-    }
 
-    // Drawing outline
-    {
-        uint32_t col = col_red;
-        if(c->connected) col = col_greed;
-        draw_list->AddRect(image_pos + ImVec2(5, 5), image_pos_max - ImVec2(5, 5), col, 2.0F, 0, 2.0F);
-    }
-    // Drawing Battery
-    if(c->connected){
-        bool batteryHave = false;
-        bool batteryCharging = false;
-        int precentage = 0;
-        uint32_t col_inner_color;
-        if(status[std::to_string(BATTERY_PRESENT_ID)].is_number()){
-            batteryHave = status[std::to_string(BATTERY_PRESENT_ID)].get<int32_t>() == 1;
-        }
-        if(status[std::to_string(INTERNAL_BATTERY_PERCENTAGE_ID)].is_number()){
-            precentage = status[std::to_string(INTERNAL_BATTERY_PERCENTAGE_ID)].get<int32_t>();
-        }
-        if(status[std::to_string(INTERNAL_BATTERY_BARS_ID)].is_number()){
-            batteryCharging = status[std::to_string(INTERNAL_BATTERY_BARS_ID)].get<int32_t>() == 4;
+        // Drawing outline
+        {
+            uint32_t col = col_red;
+            if(c.connected) col = col_greed;
+            draw_list->AddRect(image_pos + ImVec2(5, 5), image_pos_max - ImVec2(5, 5), col, 2.0F, 0, 2.0F);
         }
-        ImVec2 battery_text_size;
-        std::string battery_text;
-        if(batteryHave){
-            if(precentage <= 25){
-                col_inner_color = col_orange;
+        // Drawing Battery
+        if(c.connected){
+            bool batteryHave = false;
+            bool batteryCharging = false;
+            int precentage = 0;
+            uint32_t col_inner_color;
+            if(status[std::to_string(BATTERY_PRESENT_ID)].is_number()){
+                batteryHave = status[std::to_string(BATTERY_PRESENT_ID)].get<int32_t>() == 1;
+            }
+            if(status[std::to_string(INTERNAL_BATTERY_PERCENTAGE_ID)].is_number()){
+                precentage = status[std::to_string(INTERNAL_BATTERY_PERCENTAGE_ID)].get<int32_t>();
+            }
+            if(status[std::to_string(INTERNAL_BATTERY_BARS_ID)].is_number()){
+                batteryCharging = status[std::to_string(INTERNAL_BATTERY_BARS_ID)].get<int32_t>() == 4;
+            }
+            ImVec2 battery_text_size;
+            std::string battery_text;
+            if(batteryHave){
+                if(precentage <= 25){
+                    col_inner_color = col_orange;
+                }else{
+                    col_inner_color = col_greed;
+                }
+                battery_text = std::to_string(precentage) + "%";
             }else{
-                col_inner_color = col_greed;
+                col_inner_color = col_red;
+                battery_text = "X";
+            }
+            battery_text_size = ImGui::CalcTextSize(battery_text.c_str());
+            ImVec2 bettery_size = ImVec2(rect_size_unit.x * 2.2, rect_size_unit.y * 1.2F);
+            ImVec2 frame_padding = ImVec2(10, 10);
+            ImVec2 inner_padding = ImVec2(2, 2);
+            int32_t spacing = 15;
+
+            // Drawing Battery outline
+            ImVec2 outter_min = image_pos + ImVec2(rect_size.x - (frame_padding.x + bettery_size.x), frame_padding.y);
+            ImVec2 outter_max = image_pos + ImVec2(rect_size.x - frame_padding.x, frame_padding.y + bettery_size.y);
+            draw_list->AddRectFilled(
+                outter_min, 
+                outter_max, 
+                col_grey);
+                
+            // Drawing Battery inline
+            ImVec2 inner_min = outter_min + inner_padding;
+            ImVec2 inner_max = outter_max - inner_padding;
+            float w = inner_max.y - inner_min.y;
+            float wc = w * (precentage / 100.0F);
+            float wr = w - wc;
+            inner_max.x -= wr;
+            draw_list->AddRectFilled(
+                inner_min, 
+                inner_max, 
+                col_inner_color);
+
+            // Drawing Battery text
+            ImVec2 text_pos = ImVec2(outter_max.x - battery_text_size.x, outter_max.y);
+            draw_list->AddText(text_pos, col_white, battery_text.c_str());
+
+            if(batteryCharging){
+                std::string charging_text = "C=>";
+                ImVec2 charging_text_size = ImGui::CalcTextSize(charging_text.c_str());
+                ImVec2 charging_text_pos = ImVec2(inner_min.x, 
+                    ((inner_max.y + inner_min.y) / 2.0F) - (charging_text_size.y / 2.0F)
+                );
+                draw_list->AddText(charging_text_pos, col_orange_dark, charging_text.c_str());
             }
-            battery_text = std::to_string(precentage) + "%";
-        }else{
-            col_inner_color = col_red;
-            battery_text = "X";
-        }
-        battery_text_size = ImGui::CalcTextSize(battery_text.c_str());
-        ImVec2 bettery_size = ImVec2(rect_size_unit.x * 2.2, rect_size_unit.y * 1.2F);
-        ImVec2 frame_padding = ImVec2(10, 10);
-        ImVec2 inner_padding = ImVec2(2, 2);
-        int32_t spacing = 15;
-
-        // Drawing Battery outline
-        ImVec2 outter_min = image_pos + ImVec2(rect_size.x - (frame_padding.x + bettery_size.x), frame_padding.y);
-        ImVec2 outter_max = image_pos + ImVec2(rect_size.x - frame_padding.x, frame_padding.y + bettery_size.y);
-        draw_list->AddRectFilled(
-            outter_min, 
-            outter_max, 
-            col_grey);
-            
-        // Drawing Battery inline
-        ImVec2 inner_min = outter_min + inner_padding;
-        ImVec2 inner_max = outter_max - inner_padding;
-        float w = inner_max.y - inner_min.y;
-        float wc = w * (precentage / 100.0F);
-        float wr = w - wc;
-        inner_max.x -= wr;
-        draw_list->AddRectFilled(
-            inner_min, 
-            inner_max, 
-            col_inner_color);
-
-        // Drawing Battery text
-        ImVec2 text_pos = ImVec2(outter_max.x - battery_text_size.x, outter_max.y);
-        draw_list->AddText(text_pos, col_white, battery_text.c_str());
-
-        if(batteryCharging){
-            std::string charging_text = "C=>";
-            ImVec2 charging_text_size = ImGui::CalcTextSize(charging_text.c_str());
-            ImVec2 charging_text_pos = ImVec2(inner_min.x, 
-                ((inner_max.y + inner_min.y) / 2.0F) - (charging_text_size.y / 2.0F)
-            );
-            draw_list->AddText(charging_text_pos, col_orange_dark, charging_text.c_str());
-        }
-    }
-    // Drawing SD card
-    if(c->connected){
-        bool sdHave = false;
-        int64_t remaining = 0;
-        uint32_t col_inner_color;
-        if(status[std::to_string(PRIMARY_STORAGE_ID)].is_number()){
-            int b = status[std::to_string(PRIMARY_STORAGE_ID)].get<int32_t>() == 1;
-            if(b == 1) sdHave = true;
-        }
-        if(status[std::to_string(SD_CARD_REMAINING_ID)].is_number()){
-            remaining = status[std::to_string(SD_CARD_REMAINING_ID)].get<int64_t>();
-        }
-        ImVec2 sd_text_size;
-        std::string sd_text;
-        if(sdHave){
-            col_inner_color = col_greed;
-            sd_text = bytesToGbString(remaining);
-        }else{
-            col_inner_color = col_red;
-            sd_text = "X";
         }
-        sd_text_size = ImGui::CalcTextSize(sd_text.c_str());
-        ImVec2 sd_size = ImVec2(rect_size_unit.x * 2.2, rect_size_unit.y * 1.2F);
-        ImVec2 frame_padding = ImVec2(10, 10);
-        ImVec2 inner_padding = ImVec2(2, 2);
-        int32_t spacing = 15;
-
-        // Drawing SD outline
-        ImVec2 outter_min = image_pos + frame_padding;
-        ImVec2 outter_max = image_pos + frame_padding + sd_size;
-        draw_list->AddRectFilled(
-            outter_min, 
-            outter_max, 
-            col_grey);
-            
-        // Drawing SD inline
-        ImVec2 inner_min = outter_min + inner_padding;
-        ImVec2 inner_max = outter_max - inner_padding;
-        draw_list->AddRectFilled(
-            inner_min, 
-            inner_max, 
-            col_inner_color);
-
-        // Drawing SD text
-        ImVec2 text_pos = ImVec2(outter_min.x, outter_max.y);
-        draw_list->AddText(text_pos, col_white, sd_text.c_str());
-    }
-    // Center text
-    {
-        std::string shutter_speed;
-        std::string ev_setting;
-        std::string camera_title = c->name;
-        std::string iso_setting;
-        std::string white_balance_setting;
-        std::string sharpness_setting;
-        std::string color_setting;
-        float spacing = 0.75F;
-
-        ImVec2 camera_title_size = ImGui::CalcTextSize(camera_title.c_str());
-
-        // Draw Title in center
-        ImVec2 center = ImVec2(
-            image_pos.x + (rect_size.x / 2.0F),
-            image_pos.y + (rect_size.y / 2.0F)
-        );
-        ImVec2 camera_title_min = ImVec2(
-            center.x + ( camera_title_size.x / -2.0F ),
-            center.y + ( camera_title_size.y / -2.0F ) + (rect_size_unit.y * (spacing * -3.0F))
-        );
-        draw_list->AddText(camera_title_min, col_white, camera_title.c_str());
-        if(c->connected) {
-            int32_t SHUTTER_SPEED_ID = 0;
-            int32_t ISO_MIN_ID = 0;
-            int32_t ISO_MAX_ID = 0;
-            if(preset == 65538){ // Burst
-                SHUTTER_SPEED_ID = SHUTTER_SPEED_PHOTO_ID;
-                ISO_MIN_ID = ISO_MIN_BURST_ID;
-                ISO_MAX_ID = ISO_MAX_BURST_ID;
+        // Drawing SD card
+        if(c.connected){
+            bool sdHave = false;
+            int64_t remaining = 0;
+            uint32_t col_inner_color;
+            if(status[std::to_string(PRIMARY_STORAGE_ID)].is_number()){
+                int b = status[std::to_string(PRIMARY_STORAGE_ID)].get<int32_t>() == 1;
+                if(b == 1) sdHave = true;
             }
-            else if(preset == 65536){ // photo
-                SHUTTER_SPEED_ID = SHUTTER_SPEED_PHOTO_ID;
-                ISO_MIN_ID = ISO_MIN_PHOTO_ID;
-                ISO_MAX_ID = ISO_MAX_PHOTO_ID;
+            if(status[std::to_string(SD_CARD_REMAINING_ID)].is_number()){
+                remaining = status[std::to_string(SD_CARD_REMAINING_ID)].get<int64_t>();
             }
-            else if(preset == 0){ // video
-                SHUTTER_SPEED_ID = SHUTTER_SPEED_VIDEO_ID;
-                ISO_MIN_ID = ISO_MIN_VIDEO_ID;
-                ISO_MAX_ID = ISO_MAX_VIDEO_ID;
+            ImVec2 sd_text_size;
+            std::string sd_text;
+            if(sdHave){
+                col_inner_color = col_greed;
+                sd_text = bytesToGbString(remaining);
+            }else{
+                col_inner_color = col_red;
+                sd_text = "X";
             }
-            else{ // Timelapse
+            sd_text_size = ImGui::CalcTextSize(sd_text.c_str());
+            ImVec2 sd_size = ImVec2(rect_size_unit.x * 2.2, rect_size_unit.y * 1.2F);
+            ImVec2 frame_padding = ImVec2(10, 10);
+            ImVec2 inner_padding = ImVec2(2, 2);
+            int32_t spacing = 15;
+
+            // Drawing SD outline
+            ImVec2 outter_min = image_pos + frame_padding;
+            ImVec2 outter_max = image_pos + frame_padding + sd_size;
+            draw_list->AddRectFilled(
+                outter_min, 
+                outter_max, 
+                col_grey);
                 
-            }
+            // Drawing SD inline
+            ImVec2 inner_min = outter_min + inner_padding;
+            ImVec2 inner_max = outter_max - inner_padding;
+            draw_list->AddRectFilled(
+                inner_min, 
+                inner_max, 
+                col_inner_color);
+
+            // Drawing SD text
+            ImVec2 text_pos = ImVec2(outter_min.x, outter_max.y);
+            draw_list->AddText(text_pos, col_white, sd_text.c_str());
+        }
+        // Center text
+        {
+            std::string shutter_speed;
+            std::string ev_setting;
+            std::string camera_title = c.name;
+            std::string iso_setting;
+            std::string white_balance_setting;
+            std::string sharpness_setting;
+            std::string color_setting;
+            float spacing = 0.75F;
+
+            ImVec2 camera_title_size = ImGui::CalcTextSize(camera_title.c_str());
+
+            // Draw Title in center
+            ImVec2 center = ImVec2(
+                image_pos.x + (rect_size.x / 2.0F),
+                image_pos.y + (rect_size.y / 2.0F)
+            );
+            ImVec2 camera_title_min = ImVec2(
+                center.x + ( camera_title_size.x / -2.0F ),
+                center.y + ( camera_title_size.y / -2.0F ) + (rect_size_unit.y * (spacing * -3.0F))
+            );
+            draw_list->AddText(camera_title_min, col_white, camera_title.c_str());
+            if(c.connected) {
+                int32_t SHUTTER_SPEED_ID = 0;
+                int32_t ISO_MIN_ID = 0;
+                int32_t ISO_MAX_ID = 0;
+                if(preset == 65538){ // Burst
+                    SHUTTER_SPEED_ID = SHUTTER_SPEED_PHOTO_ID;
+                    ISO_MIN_ID = ISO_MIN_BURST_ID;
+                    ISO_MAX_ID = ISO_MAX_BURST_ID;
+                }
+                else if(preset == 65536){ // photo
+                    SHUTTER_SPEED_ID = SHUTTER_SPEED_PHOTO_ID;
+                    ISO_MIN_ID = ISO_MIN_PHOTO_ID;
+                    ISO_MAX_ID = ISO_MAX_PHOTO_ID;
+                }
+                else if(preset == 0){ // video
+                    SHUTTER_SPEED_ID = SHUTTER_SPEED_VIDEO_ID;
+                    ISO_MIN_ID = ISO_MIN_VIDEO_ID;
+                    ISO_MAX_ID = ISO_MAX_VIDEO_ID;
+                }
+                else{ // Timelapse
+                    
+                }
 
-            if(setting[std::to_string(EXPOSURE_ID)].is_number_integer()){
-                int32_t re = setting[std::to_string(EXPOSURE_ID)].get<int32_t>();
-                ev_setting = EXPOSURE_STRING[re];
-            }
-            if(setting[std::to_string(SHUTTER_SPEED_ID)].is_number_integer()){
-                int32_t re = setting[std::to_string(SHUTTER_SPEED_ID)].get<int32_t>();
-                if(preset == 0){ // Video
-                    shutter_speed = SHUTTER_SPEED_VIDEO_STRING[re];
-                }else {
-                    shutter_speed = SHUTTER_SPEED_PHOTO_STRING[re];
+                if(setting[std::to_string(EXPOSURE_ID)].is_number_integer()){
+                    int32_t re = setting[std::to_string(EXPOSURE_ID)].get<int32_t>();
+                    ev_setting = EXPOSURE_STRING[re];
                 }
-                if(shutter_speed == "Auto"){
-                    shutter_speed = "S: " + shutter_speed + ", " + ev_setting;
-                }else{
-                    shutter_speed = "S: " + shutter_speed;
+                if(setting[std::to_string(SHUTTER_SPEED_ID)].is_number_integer()){
+                    int32_t re = setting[std::to_string(SHUTTER_SPEED_ID)].get<int32_t>();
+                    if(preset == 0){ // Video
+                        shutter_speed = SHUTTER_SPEED_VIDEO_STRING[re];
+                    }else {
+                        shutter_speed = SHUTTER_SPEED_PHOTO_STRING[re];
+                    }
+                    if(shutter_speed == "Auto"){
+                        shutter_speed = "S: " + shutter_speed + ", " + ev_setting;
+                    }else{
+                        shutter_speed = "S: " + shutter_speed;
+                    }
                 }
-            }
-            if(setting[std::to_string(ISO_MIN_ID)].is_number() && setting[std::to_string(ISO_MAX_ID)].is_number()){
-                int32_t iso_min = setting[std::to_string(ISO_MIN_ID)].get<int32_t>();
-                int32_t iso_max = setting[std::to_string(ISO_MAX_ID)].get<int32_t>();
-                std::string iso_min_text = "ISO MIN";
-                std::string iso_max_text = "ISO MAX";
-                if(preset == 0){
-                    iso_min_text = ISO_MIN_VIDEO_STRING[iso_min];
-                    iso_max_text = ISO_MAX_VIDEO_STRING[iso_max];
-                }else{
-                    iso_min_text = ISO_MIN_PHOTO_STRING[iso_min];
-                    iso_max_text = ISO_MAX_PHOTO_STRING[iso_max];
+                if(setting[std::to_string(ISO_MIN_ID)].is_number() && setting[std::to_string(ISO_MAX_ID)].is_number()){
+                    int32_t iso_min = setting[std::to_string(ISO_MIN_ID)].get<int32_t>();
+                    int32_t iso_max = setting[std::to_string(ISO_MAX_ID)].get<int32_t>();
+                    std::string iso_min_text = "ISO MIN";
+                    std::string iso_max_text = "ISO MAX";
+                    if(preset == 0){
+                        iso_min_text = ISO_MIN_VIDEO_STRING[iso_min];
+                        iso_max_text = ISO_MAX_VIDEO_STRING[iso_max];
+                    }else{
+                        iso_min_text = ISO_MIN_PHOTO_STRING[iso_min];
+                        iso_max_text = ISO_MAX_PHOTO_STRING[iso_max];
+                    }
+                    iso_setting = "I: " + iso_min_text + " " + iso_max_text;
+                }
+                if(setting[std::to_string(SHARPNESS_ID)].is_number()){
+                    int32_t sharpness_bal = setting[std::to_string(SHARPNESS_ID)].get<int32_t>();
+                    sharpness_setting = SHARPNESS_STRING[sharpness_bal];
+                }
+                if(setting[std::to_string(COLOR_ID)].is_number()){
+                    int32_t color_bal = setting[std::to_string(COLOR_ID)].get<int32_t>();
+                    color_setting = COLOR_STRING[color_bal];
                 }
-                iso_setting = "I: " + iso_min_text + " " + iso_max_text;
+                if(setting[std::to_string(WHITE_BALANCE_ID)].is_number()){
+                    int32_t white_bal = setting[std::to_string(WHITE_BALANCE_ID)].get<int32_t>();
+                    white_balance_setting = WHITE_BALANCE_STRING[white_bal];
+                    white_balance_setting += ", " + sharpness_setting + ", " + color_setting;
+                }
+
+                ImVec2 shutter_speed_size = ImGui::CalcTextSize(shutter_speed.c_str());
+                ImVec2 shutter_speed_min = ImVec2(
+                    center.x + ( shutter_speed_size.x / -2.0F ),
+                    center.y + ( shutter_speed_size.y / -2.0F ) + (rect_size_unit.y * (spacing * -1.0F))
+                );
+                draw_list->AddText(shutter_speed_min, col_white, shutter_speed.c_str());
+
+                ImVec2 iso_setting_size = ImGui::CalcTextSize(iso_setting.c_str());
+                ImVec2 iso_setting_min = ImVec2(
+                    center.x + ( iso_setting_size.x / -2.0F ),
+                    center.y + ( iso_setting_size.y / -2.0F ) + (rect_size_unit.y * (spacing * 1.0F))
+                );
+                draw_list->AddText(iso_setting_min, col_white, iso_setting.c_str());
+
+                ImVec2 white_balance_setting_size = ImGui::CalcTextSize(white_balance_setting.c_str());
+                ImVec2 white_balance_setting_min = ImVec2(
+                    center.x + ( white_balance_setting_size.x / -2.0F ),
+                    center.y + ( white_balance_setting_size.y / -2.0F ) + (rect_size_unit.y * (spacing * 3.0F))
+                );
+                draw_list->AddText(white_balance_setting_min, col_white, white_balance_setting.c_str());
+            }
+        }
+        // Record Time
+        if(c.connected){
+            ImVec2 frame_padding = ImVec2(10, 10);
+            ImVec2 center = ImVec2(
+                image_pos.x + (rect_size.x / 2.0F),
+                image_pos.y + (rect_size.y / 2.0F)
+            );
+
+            std::string record_time;
+
+            if(status[std::to_string(VIDEO_ENCODING_DURATION_ID)].is_number_integer()){
+                int32_t re = status[std::to_string(VIDEO_ENCODING_DURATION_ID)].get<int32_t>();
+                record_time = toTimeCode(re);
+            }
+
+            ImVec2 record_time_size = ImGui::CalcTextSize(record_time.c_str());
+            ImVec2 record_time_min = ImVec2(
+                center.x + ( record_time_size.x / -2.0F ),
+                image_pos.y + frame_padding.y
+            );
+            draw_list->AddText(record_time_min, col_white, record_time.c_str());
+        }
+        // Preset mode
+        if(c.connected){
+            int32_t preset;
+            std::string preset_text;
+            if(status[std::to_string(PRESET_ID)].is_number_integer()){
+                preset = status[std::to_string(PRESET_ID)].get<int32_t>();
             }
-            if(setting[std::to_string(SHARPNESS_ID)].is_number()){
-                int32_t sharpness_bal = setting[std::to_string(SHARPNESS_ID)].get<int32_t>();
-                sharpness_setting = SHARPNESS_STRING[sharpness_bal];
+
+            if(preset == GOPRO_MODE_VALUE[0]) preset_text = "V";
+            else if(preset == GOPRO_MODE_VALUE[1]) preset_text = "PB";
+            else if(preset == GOPRO_MODE_VALUE[2]) preset_text = "PS";
+            else if(preset == GOPRO_MODE_VALUE[3]) preset_text = "T";
+            else if(preset == GOPRO_MODE_VALUE[4]) preset_text = "TT";
+            else if(preset == GOPRO_MODE_VALUE[5]) preset_text = "TLP";
+            else if(preset == GOPRO_MODE_VALUE[6]) preset_text = "TLT";
+            else if(preset == GOPRO_MODE_VALUE[7]) preset_text = "TV";
+            else if(preset == GOPRO_MODE_VALUE[8]) preset_text = "TNV";
+            else preset_text = std::to_string(preset);
+
+            ImVec2 frame_padding = ImVec2(10, 10);
+            ImVec2 preset_text_size = ImGui::CalcTextSize(preset_text.c_str());
+            draw_list->AddText(ImVec2(
+                image_pos.x + frame_padding.x,
+                (image_pos.y + rect_size.y) - (frame_padding.y + preset_text_size.y)
+            ), col_white, preset_text.c_str());
+        }
+        // Setting
+        if(c.connected){
+            float spacing = 0.75F;
+            float word_spacing = 10;
+            std::string res;
+            std::string fps;
+            std::string profile;
+            std::string videolen;
+
+            if(setting[std::to_string(VIDEO_RESOLUTION_ID)].is_number_integer()){
+                int32_t re = setting[std::to_string(VIDEO_RESOLUTION_ID)].get<int32_t>();
+                res = VIDEO_RESOLUTION_STRING[re];
             }
-            if(setting[std::to_string(COLOR_ID)].is_number()){
-                int32_t color_bal = setting[std::to_string(COLOR_ID)].get<int32_t>();
-                color_setting = COLOR_STRING[color_bal];
+            if(setting[std::to_string(FRAMES_PER_SECOND_ID)].is_number_integer()){
+                int32_t re = setting[std::to_string(FRAMES_PER_SECOND_ID)].get<int32_t>();
+                fps = FRAMES_PER_SECOND_STRING[re];
             }
-            if(setting[std::to_string(WHITE_BALANCE_ID)].is_number()){
-                int32_t white_bal = setting[std::to_string(WHITE_BALANCE_ID)].get<int32_t>();
-                white_balance_setting = WHITE_BALANCE_STRING[white_bal];
-                white_balance_setting += ", " + sharpness_setting + ", " + color_setting;
+            if(setting[std::to_string(PROFILES_ID)].is_number_integer()){
+                int32_t re = setting[std::to_string(PROFILES_ID)].get<int32_t>();
+                profile = PROFILES_STRING[re];
+            }
+            if(preset == 0){
+                if(setting[std::to_string(VIDEO_LENS_ID)].is_number_integer()){
+                    int32_t re = setting[std::to_string(VIDEO_LENS_ID)].get<int32_t>();
+                    videolen = VIDEO_LENS_STRING[re];
+                    while(videolen.size() > 1){
+                        videolen.pop_back();
+                    }
+                }
+            }else{
+                if(setting[std::to_string(PHOTO_LENS_ID)].is_number_integer()){
+                    int32_t re = setting[std::to_string(PHOTO_LENS_ID)].get<int32_t>();
+                    videolen = PHOTO_LENS_STRING[re];
+                    while(videolen.size() > 1){
+                        videolen.pop_back();
+                    }
+                }
             }
 
-            ImVec2 shutter_speed_size = ImGui::CalcTextSize(shutter_speed.c_str());
-            ImVec2 shutter_speed_min = ImVec2(
-                center.x + ( shutter_speed_size.x / -2.0F ),
-                center.y + ( shutter_speed_size.y / -2.0F ) + (rect_size_unit.y * (spacing * -1.0F))
-            );
-            draw_list->AddText(shutter_speed_min, col_white, shutter_speed.c_str());
+            ImVec2 res_text_size = ImGui::CalcTextSize(res.c_str());
+            ImVec2 fps_text_size = ImGui::CalcTextSize(fps.c_str());
+            ImVec2 profile_text_size = ImGui::CalcTextSize(profile.c_str());
+            ImVec2 videolen_text_size = ImGui::CalcTextSize(videolen.c_str());
+            ImVec2 frame_padding = ImVec2(5, 5);
 
-            ImVec2 iso_setting_size = ImGui::CalcTextSize(iso_setting.c_str());
-            ImVec2 iso_setting_min = ImVec2(
-                center.x + ( iso_setting_size.x / -2.0F ),
-                center.y + ( iso_setting_size.y / -2.0F ) + (rect_size_unit.y * (spacing * 1.0F))
+            ImVec2 corner = image_pos + rect_size;
+            ImVec2 profile_pos = ImVec2(
+                corner.x - (frame_padding.x + profile_text_size.x),
+                corner.y - (frame_padding.y + profile_text_size.y + ((rect_size_unit.y * 2.0F) * spacing))
             );
-            draw_list->AddText(iso_setting_min, col_white, iso_setting.c_str());
+            draw_list->AddText(profile_pos, col_white, profile.c_str());
 
-            ImVec2 white_balance_setting_size = ImGui::CalcTextSize(white_balance_setting.c_str());
-            ImVec2 white_balance_setting_min = ImVec2(
-                center.x + ( white_balance_setting_size.x / -2.0F ),
-                center.y + ( white_balance_setting_size.y / -2.0F ) + (rect_size_unit.y * (spacing * 3.0F))
+            ImVec2 framing_pos = ImVec2(
+                corner.x - (frame_padding.x + videolen_text_size.x),
+                corner.y - (frame_padding.y + videolen_text_size.y)
             );
-            draw_list->AddText(white_balance_setting_min, col_white, white_balance_setting.c_str());
-        }
-    }
-    // Record Time
-    if(c->connected){
-        ImVec2 frame_padding = ImVec2(10, 10);
-        ImVec2 center = ImVec2(
-            image_pos.x + (rect_size.x / 2.0F),
-            image_pos.y + (rect_size.y / 2.0F)
-        );
-
-        std::string record_time;
-
-        if(status[std::to_string(VIDEO_ENCODING_DURATION_ID)].is_number_integer()){
-            int32_t re = status[std::to_string(VIDEO_ENCODING_DURATION_ID)].get<int32_t>();
-            record_time = toTimeCode(re);
-        }
+            draw_list->AddText(framing_pos, col_white, videolen.c_str());
 
-        ImVec2 record_time_size = ImGui::CalcTextSize(record_time.c_str());
-        ImVec2 record_time_min = ImVec2(
-            center.x + ( record_time_size.x / -2.0F ),
-            image_pos.y + frame_padding.y
-        );
-        draw_list->AddText(record_time_min, col_white, record_time.c_str());
-    }
-    // Preset mode
-    if(c->connected){
-        int32_t preset;
-        std::string preset_text;
-        if(status[std::to_string(PRESET_ID)].is_number_integer()){
-            preset = status[std::to_string(PRESET_ID)].get<int32_t>();
-        }
+            ImVec2 fps_pos = framing_pos - ImVec2(word_spacing + fps_text_size.x, 0);
+            draw_list->AddText(fps_pos, col_white, fps.c_str());
 
-        if(preset == GOPRO_MODE_VALUE[0]) preset_text = "V";
-        else if(preset == GOPRO_MODE_VALUE[1]) preset_text = "PB";
-        else if(preset == GOPRO_MODE_VALUE[2]) preset_text = "PS";
-        else if(preset == GOPRO_MODE_VALUE[3]) preset_text = "T";
-        else if(preset == GOPRO_MODE_VALUE[4]) preset_text = "TT";
-        else if(preset == GOPRO_MODE_VALUE[5]) preset_text = "TLP";
-        else if(preset == GOPRO_MODE_VALUE[6]) preset_text = "TLT";
-        else if(preset == GOPRO_MODE_VALUE[7]) preset_text = "TV";
-        else if(preset == GOPRO_MODE_VALUE[8]) preset_text = "TNV";
-        else preset_text = std::to_string(preset);
-
-        ImVec2 frame_padding = ImVec2(10, 10);
-        ImVec2 preset_text_size = ImGui::CalcTextSize(preset_text.c_str());
-        draw_list->AddText(ImVec2(
-            image_pos.x + frame_padding.x,
-            (image_pos.y + rect_size.y) - (frame_padding.y + preset_text_size.y)
-        ), col_white, preset_text.c_str());
-    }
-    // Setting
-    if(c->connected){
-        float spacing = 0.75F;
-        float word_spacing = 10;
-        std::string res;
-        std::string fps;
-        std::string profile;
-        std::string videolen;
-
-        if(setting[std::to_string(VIDEO_RESOLUTION_ID)].is_number_integer()){
-            int32_t re = setting[std::to_string(VIDEO_RESOLUTION_ID)].get<int32_t>();
-            res = VIDEO_RESOLUTION_STRING[re];
-        }
-        if(setting[std::to_string(FRAMES_PER_SECOND_ID)].is_number_integer()){
-            int32_t re = setting[std::to_string(FRAMES_PER_SECOND_ID)].get<int32_t>();
-            fps = FRAMES_PER_SECOND_STRING[re];
+            ImVec2 res_pos = fps_pos - ImVec2(word_spacing + res_text_size.x, 0);
+            draw_list->AddText(res_pos, col_white, res.c_str());
         }
-        if(setting[std::to_string(PROFILES_ID)].is_number_integer()){
-            int32_t re = setting[std::to_string(PROFILES_ID)].get<int32_t>();
-            profile = PROFILES_STRING[re];
-        }
-        if(preset == 0){
-            if(setting[std::to_string(VIDEO_LENS_ID)].is_number_integer()){
-                int32_t re = setting[std::to_string(VIDEO_LENS_ID)].get<int32_t>();
-                videolen = VIDEO_LENS_STRING[re];
-                while(videolen.size() > 1){
-                    videolen.pop_back();
-                }
+        
+        ImGui::PopID();
+        ImGui::Dummy(rect_size);
+        bool is_select = state->current_camera_item == c.ip && state->current_camera_server == c.server;
+        if(ImGui::IsItemHovered()){
+            std::string displayText = "";
+            displayText += "name: ";
+            displayText += state->current_camera_name;
+            displayText += "\n";
+
+            displayText += "server: ";
+            displayText += c.server;
+            displayText += "\n";
+
+            displayText += "ip: ";
+            displayText += c.ip;
+            displayText += "\n";
+
+            displayText += "serial: ";
+            if(c.hw.is_object() && c.hw.contains("serial_number") && c.hw["serial_number"].is_string()){
+                displayText += c.hw["serial_number"].get<std::string>();
             }
-        }else{
-            if(setting[std::to_string(PHOTO_LENS_ID)].is_number_integer()){
-                int32_t re = setting[std::to_string(PHOTO_LENS_ID)].get<int32_t>();
-                videolen = PHOTO_LENS_STRING[re];
-                while(videolen.size() > 1){
-                    videolen.pop_back();
-                }
-            }
-        }
+            displayText += "\n";
 
-        ImVec2 res_text_size = ImGui::CalcTextSize(res.c_str());
-        ImVec2 fps_text_size = ImGui::CalcTextSize(fps.c_str());
-        ImVec2 profile_text_size = ImGui::CalcTextSize(profile.c_str());
-        ImVec2 videolen_text_size = ImGui::CalcTextSize(videolen.c_str());
-        ImVec2 frame_padding = ImVec2(5, 5);
-
-        ImVec2 corner = image_pos + rect_size;
-        ImVec2 profile_pos = ImVec2(
-            corner.x - (frame_padding.x + profile_text_size.x),
-            corner.y - (frame_padding.y + profile_text_size.y + ((rect_size_unit.y * 2.0F) * spacing))
-        );
-        draw_list->AddText(profile_pos, col_white, profile.c_str());
-
-        ImVec2 framing_pos = ImVec2(
-            corner.x - (frame_padding.x + videolen_text_size.x),
-            corner.y - (frame_padding.y + videolen_text_size.y)
-        );
-        draw_list->AddText(framing_pos, col_white, videolen.c_str());
-
-        ImVec2 fps_pos = framing_pos - ImVec2(word_spacing + fps_text_size.x, 0);
-        draw_list->AddText(fps_pos, col_white, fps.c_str());
-
-        ImVec2 res_pos = fps_pos - ImVec2(word_spacing + res_text_size.x, 0);
-        draw_list->AddText(res_pos, col_white, res.c_str());
-    }
-    
-    ImGui::PopID();
-    ImGui::Dummy(rect_size);
-    bool is_select = state->current_camera_item == c->ip && state->current_camera_server == c->server;
-    if(ImGui::IsItemHovered()){
-        std::string displayText = "";
-        displayText += "name: ";
-        displayText += state->current_camera_name;
-        displayText += "\n";
-
-        displayText += "server: ";
-        displayText += c->server;
-        displayText += "\n";
-
-        displayText += "ip: ";
-        displayText += c->ip;
-        displayText += "\n";
-
-        displayText += "serial: ";
-        if(c->hw["serial_number"].is_string()){
-            displayText += c->hw["serial_number"].get<std::string>();
-        }
-        displayText += "\n";
+            displayText += "model: ";
+            if(c.hw.is_object() && c.hw.contains("model_name") && c.hw["model_name"].is_string()){
+                displayText += c.hw["model_name"].get<std::string>();
+            }
+            displayText += "\n";
 
-        displayText += "model: ";
-        if(c->hw["model_name"].is_string()){
-            displayText += c->hw["model_name"].get<std::string>();
+            displayText += "firmware: ";
+            if(c.hw.is_object() && c.hw.contains("firmware_version") && c.hw["firmware_version"].is_string()){
+                displayText += c.hw["firmware_version"].get<std::string>();
+            }
+            displayText += "\n";
+            ImGui::SetItemTooltip("%s", displayText.c_str());
+            draw_list->AddRect(image_pos, image_pos_max, col_grey, 2.0F, 0, 5.0F);
         }
-        displayText += "\n";
-
-        displayText += "firmware: ";
-        if(c->hw["firmware_version"].is_string()){
-            displayText += c->hw["firmware_version"].get<std::string>();
+        else if(is_select){
+            draw_list->AddRect(image_pos, image_pos_max, col_grey_light, 2.0F, 0, 5.0F);
         }
-        displayText += "\n";
-        ImGui::SetItemTooltip("%s", displayText.c_str());
-        draw_list->AddRect(image_pos, image_pos_max, col_grey, 2.0F, 0, 5.0F);
-    }
-    else if(is_select){
-        draw_list->AddRect(image_pos, image_pos_max, col_grey_light, 2.0F, 0, 5.0F);
+        item_event(c);
     }
-    item_event( c);
     ImGui::EndGroup();
 }
diff --git a/src/master/windows/inspector.h b/src/master/windows/inspector.h
index 09c0cc2d..03ec0a13 100644
--- a/src/master/windows/inspector.h
+++ b/src/master/windows/inspector.h
@@ -23,8 +23,8 @@ class InspectorWindow : public BaseWindow {
     virtual void draw_system();
     virtual void draw_setting();
     virtual void draw_protune();
-    static void global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c);
-    static void global_draw_protune(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c);
+    static void global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c);
+    static void global_draw_protune(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c);
     virtual void draw_status();
     virtual void draw_hardware();
     virtual void draw_network();
@@ -41,8 +41,8 @@ class InspectorWindow : public BaseWindow {
 protected:
     virtual void _draw_setting(std::vector<int32_t>& ordered);
     virtual void _draw_status(std::vector<int32_t>& ordered);
-    static void _global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c, std::vector<int32_t>& ordered);
-    static bool _global_draw_setting_item(int32_t i, std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c, std::vector<int32_t>& ordered);
+    static void _global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c, std::vector<int32_t>& ordered);
+    static bool _global_draw_setting_item(int32_t i, std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c, std::vector<int32_t>& ordered);
     static bool conditional_filter(const std::shared_ptr<GlobalState>& state, int32_t mymodel, int32_t setting_id);
     static bool conditional_filter_option(const std::shared_ptr<GlobalState>& state, int32_t mymodel, int32_t setting_id, int32_t value_index);
 
diff --git a/src/master/windows/inspector/command.cpp b/src/master/windows/inspector/command.cpp
index b08a84e2..49c1b4e0 100644
--- a/src/master/windows/inspector/command.cpp
+++ b/src/master/windows/inspector/command.cpp
@@ -16,7 +16,7 @@ void InspectorWindow::draw_command_local(){
     ImVec2 full_button_size = ImVec2(size.x - style.ItemSpacing.x, 0);
 
     if(current_camera != -1) {
-        CameraInfo info = *(master->getCameras().at(current_camera));
+        CameraInfo info = master->getCamera_Clone(current_camera);
 
         if(ImGui::Button("Record", button_2size)) master->command_only(info.server, "shutter_on", info.ip); ImGui::SameLine();
         if(ImGui::Button("Stop", button_2size)) master->command_only(info.server, "shutter_off", info.ip);
diff --git a/src/master/windows/inspector/inspector.cpp b/src/master/windows/inspector/inspector.cpp
index 95c85eb2..b04c5624 100644
--- a/src/master/windows/inspector/inspector.cpp
+++ b/src/master/windows/inspector/inspector.cpp
@@ -109,11 +109,10 @@ void InspectorWindow::set_window_data(json data) {
 void InspectorWindow::render(){
     ImGui::Begin("Inspector", &enable, w_flag);
     {
-        std::lock_guard<std::mutex> lock(master->camera_mtx);
         int32_t s = master->findCamera(state->current_camera_server, state->current_camera_item);
         if(s != -1){
-            auto& c = master->getCameras().at(s);
-            should_disabled = !c->connected || state->current_camera_item.size() < 10 || s == -1 || !state->current_setting_items_bind;
+            CameraInfo c = master->getCamera_Clone(s);
+            should_disabled = !c.connected || state->current_camera_item.size() < 10 || s == -1 || !state->current_setting_items_bind;
         }
         draw_header();
 
@@ -152,7 +151,7 @@ void InspectorWindow::render(){
                 ImGui::BeginDisabled(should_disabled || state->applying_all);
                 if(ImGui::Button("Quick Apply All##Inspector_Bar_Item")){
                     if(s != -1){
-                        const std::shared_ptr<CameraInfo>& c = master->getCameras().at(s);
+                        const CameraInfo c = master->getCamera_Clone(s);
                         master->quickApplyAll(c);
                         state->applying_all = true;
                     }
diff --git a/src/master/windows/inspector/setting.cpp b/src/master/windows/inspector/setting.cpp
index 48c18d91..48453671 100644
--- a/src/master/windows/inspector/setting.cpp
+++ b/src/master/windows/inspector/setting.cpp
@@ -35,9 +35,9 @@ void InspectorWindow::draw_protune(){
     }
 }
 
-void InspectorWindow::global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c){
+void InspectorWindow::global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c){
     json status = json::object();
-    master->getStatusFromCamera(*c, status);
+    master->getStatusFromCamera(c, status);
     if (status[std::to_string(PRESET_ID)].is_number()) {
         int32_t preset = status[std::to_string(PRESET_ID)].get<int32_t>();
         if(preset == 0){
@@ -48,9 +48,9 @@ void InspectorWindow::global_draw_setting(std::shared_ptr<GlobalState>& state, s
     }
 }
 
-void InspectorWindow::global_draw_protune(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c){
+void InspectorWindow::global_draw_protune(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c){
     json status = json::object();
-    master->getStatusFromCamera(*c, status);
+    master->getStatusFromCamera(c, status);
     if (status[std::to_string(PRESET_ID)].is_number()) {
         int32_t preset = status[std::to_string(PRESET_ID)].get<int32_t>();
         if(preset == 0){
@@ -64,7 +64,7 @@ void InspectorWindow::global_draw_protune(std::shared_ptr<GlobalState>& state, s
 void InspectorWindow::_draw_setting(std::vector<int32_t>& ordered){
     int32_t current = master->findCamera(state->current_camera_server, state->current_camera_item);
     if(current < 0) return;
-    auto& c = master->getCameras().at(current);
+    const CameraInfo c = master->getCamera_Clone(current);
     int32_t move_from = -1, move_to = -1;
     for(int32_t i = 0; i < ordered.size(); i++){
         int32_t id = ordered[i];
@@ -105,23 +105,23 @@ void InspectorWindow::_draw_setting(std::vector<int32_t>& ordered){
     }
 }
 
-void InspectorWindow::_global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c, std::vector<int32_t>& ordered){
+void InspectorWindow::_global_draw_setting(std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c, std::vector<int32_t>& ordered){
     for(int32_t i = 0; i < ordered.size(); i++){
         _global_draw_setting_item(i, state, master, c, ordered);
     }
 }
 
-bool InspectorWindow::_global_draw_setting_item(int32_t i, std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const std::shared_ptr<CameraInfo>& c, std::vector<int32_t>& ordered){
+bool InspectorWindow::_global_draw_setting_item(int32_t i, std::shared_ptr<GlobalState>& state, std::shared_ptr<GoProMaster>& master, const CameraInfo& c, std::vector<int32_t>& ordered){
     int32_t id = ordered[i];
     std::string name = GET_SETTING_NAME_BY_ID(id);
     size_t size = GET_SETTING_SIZE_BY_ID(id);
     int32_t ava = GET_SETTING_AVA_BY_ID(id);
-    int32_t model_enum = _get_current_model(c->hw);
+    int32_t model_enum = _get_current_model(c.hw);
 
     json setting = json::object();
     json status = json::object();
-    master->getSettingsFromCamera(*c, setting);
-    master->getStatusFromCamera(*c, status);
+    master->getSettingsFromCamera(c, setting);
+    master->getStatusFromCamera(c, status);
 
     if((model_enum&ava) == 0){
         return false;
@@ -170,7 +170,7 @@ bool InspectorWindow::_global_draw_setting_item(int32_t i, std::shared_ptr<Globa
             if (ImGui::Selectable(option.c_str(), is_selected))
             {
                 setting[std::to_string(id)] = n; // Change index
-                master->apply("", c->ip, id, values_id[n]);
+                master->apply("", c.ip, id, values_id[n]);
             }
             if (is_selected)
                 ImGui::SetItemDefaultFocus();   // You may set the initial focus when opening the combo (scrolling + for keyboard navigation support)
diff --git a/src/master/windows/websocket_server.cpp b/src/master/windows/websocket_server.cpp
index 19ccfd53..bd1af7d4 100644
--- a/src/master/windows/websocket_server.cpp
+++ b/src/master/windows/websocket_server.cpp
@@ -86,17 +86,17 @@ void WebsocketWindow::render(){
             ImGui::TableSetupColumn("Last Message");
             ImGui::TableHeadersRow();
 
-            for (const auto& s : master->getServers()) {
+            for (const auto& s : master->getServers_Clone()) {
                 ImGui::TableNextRow();
                 ImGui::TableSetColumnIndex(0);
-                ImGui::Text("%s", s->ip.c_str());
+                ImGui::Text("%s", s.ip.c_str());
                 ImGui::TableSetColumnIndex(1);
-                if (s->connected) 
+                if (s.connected) 
                     ImGui::TextColored(ImVec4(0,1,0,1), "Connected");
                 else 
                     ImGui::TextColored(ImVec4(1,0,0,1), "Disconnected");
                 ImGui::TableSetColumnIndex(2);
-                ImGui::Text("%s", s->last_message.c_str());
+                ImGui::Text("%s", s.last_message.c_str());
             }
             ImGui::EndTable();
         }