maixcam2 support USB hid and display support fb

components/basic/port/linux/maix_sys_linux.cpp

@@ -1,6 +1,7 @@
 #include "maix_util.hpp"
 #include "maix_app.hpp"
 #include "signal.h"
+#include "maix_sys.hpp"
 
 namespace maix::sys
 {

components/peripheral/port/maixcam2/maix_hid.cpp

@@ -14,43 +14,57 @@
 #include <linux/i2c-dev.h>
 #include <linux/i2c.h>
 #include <sys/ioctl.h>
+#include "maix_app.hpp"
 
 #define DEV_PATH "/dev/hidg%d"
 
 namespace maix::peripheral::hid
 {
+
+    #define KEYBOARD_PATH "/etc/configfs/usb_gadget/g1/functions/hid.GS0/dev"
+    #define MOUSE_PATH "/etc/configfs/usb_gadget/g1/functions/hid.GS1/dev"
+    #define TOUCHPAD_PATH "/etc/configfs/usb_gadget/g1/functions/hid.GS2/dev"
+
+    static int _read_hid_dev_idx(const std::string &path)
+    {
+        FILE* fp = fopen(path.c_str(), "r");
+        if (!fp) return -1;
+        int left, right;
+        while (fscanf(fp, "%d:%d", &left, &right) == 2) {
+        }
+        fclose(fp);
+        return right;
+    }
+
     static int get_hid_device_idx(hid::DeviceType device_type)
     {
-        int find_mouse = fs::exists("/boot/usb.mouse") ? 1 : 0;
-        int find_touchpad = fs::exists("/boot/usb.touchpad") ? 1 : 0;
-        int find_keyboard = fs::exists("/boot/usb.keyboard") ? 1 : 0;
+        int enabled_keyboard = app::get_sys_config_kv("usb", "hid_keyboard") == "1" ? 1 : 0;
+        int enabled_mouse = app::get_sys_config_kv("usb", "hid_mouse") == "1"  ? 1 : 0;
+        int enabled_touchpad = app::get_sys_config_kv("usb", "hid_touchpad") == "1"  ? 1 : 0;
         int id = -1;
 
         switch (device_type) {
         case DEVICE_KEYBOARD:
         {
-            if (find_keyboard) {
-                id = 0;
+            if(enabled_keyboard)
+            {
+                id = _read_hid_dev_idx(KEYBOARD_PATH);
             }
             break;
         }
         case DEVICE_MOUSE:
         {
-            if (find_keyboard && find_mouse) {
-                id = 1;
-            } else if (!find_keyboard && find_mouse) {
-                id = 0;
+            if(enabled_mouse)
+            {
+                id = _read_hid_dev_idx(MOUSE_PATH);
             }
             break;
         }
         case DEVICE_TOUCHPAD:
         {
-            if ((find_keyboard + find_mouse == 2) && find_touchpad) {
-                id = 2;
-            } else if ((find_keyboard + find_mouse == 1) && find_touchpad) {
-                id = 1;
-            } else if (!(find_keyboard + find_mouse) && find_touchpad) {
-                id = 0;
+            if(enabled_touchpad)
+            {
+                id = _read_hid_dev_idx(TOUCHPAD_PATH);
             }
             break;
         }

components/vision/port/linux_common/maix_display_fb.hpp

@@ -74,6 +74,55 @@ namespace maix::display
         return 0;
     }
 
+    static int invert_bgr888_to_rgb565(unsigned char *src, int srcw, int srch, unsigned char *dst)
+    {
+        if (!src || !dst)
+            return -1;
+
+        uint16_t *out = (uint16_t *)dst;
+
+#if __riscv_vector
+        for (int y = 0; y < srch; ++y) {
+            unsigned char *src_row = src + y * srcw * 3;
+            uint16_t *out_row = out + y * srcw;
+
+            int x = 0;
+            size_t vl;
+            for (; (vl = vsetvl_e8m1(srcw - x)) > 0; x += vl) {
+                vuint8m1_t vecR = vlse8_v_u8m1(src_row + x * 3 + 2, 3, vl);
+                vuint8m1_t vecG = vlse8_v_u8m1(src_row + x * 3 + 1, 3, vl);
+                vuint8m1_t vecB = vlse8_v_u8m1(src_row + x * 3 + 0, 3, vl);
+
+                vuint16m2_t vecR5 = vsrl_vx_u16m2(vwcvtu_x_x_v_u16m2(vecR, vl), 3, vl);
+                vuint16m2_t vecG6 = vsrl_vx_u16m2(vwcvtu_x_x_v_u16m2(vecG, vl), 2, vl);
+                vuint16m2_t vecB5 = vsrl_vx_u16m2(vwcvtu_x_x_v_u16m2(vecB, vl), 3, vl);
+
+                vuint16m2_t pixel = vor_vv_u16m2(vor_vv_u16m2(vsll_vx_u16m2(vecR5, 11, vl), vsll_vx_u16m2(vecG6, 5, vl), vl), vecB5, vl);
+
+                vse16_v_u16m2(out_row + x, pixel, vl);
+            }
+        }
+#else
+        for (int y = 0; y < srch; ++y) {
+            unsigned char *src_row = src + y * srcw * 3;
+            uint16_t *out_row = out + y * srcw;
+
+            for (int x = 0; x < srcw; ++x) {
+                unsigned char R = src_row[x * 3 + 2];
+                unsigned char G = src_row[x * 3 + 1];
+                unsigned char B = src_row[x * 3 + 0];
+
+                uint16_t pixel = ((R >> 3) << 11) |
+                                 ((G >> 2) << 5)  |
+                                 (B >> 3);
+
+                out_row[x] = pixel;
+            }
+        }
+#endif
+        return 0;
+    }
+
     static int invert_yvu420sp_to_rgb565(unsigned char *src, int srcw, int srch, unsigned char *dst)
     {
         if (!src || !dst)
@@ -236,31 +285,34 @@ namespace maix::display
                 return err::ERR_NONE;
             }
 
-            struct fb_var_screeninfo vinfo;
-            struct fb_fix_screeninfo finfo;
             _fbfd = ::open(_device.c_str(), O_RDWR);
             if (_fbfd == -1) {
                 log::error("Error opening %s", _device.c_str());
                 return err::ERR_RUNTIME;
             }
-            if (ioctl(_fbfd, FBIOGET_FSCREENINFO, &finfo) == -1) {
+            if (ioctl(_fbfd, FBIOGET_FSCREENINFO, &_finfo) == -1) {
                 log::error("Error reading fixed information from %s", _device.c_str());
                 ::close(_fbfd);
                 return err::ERR_IO;
             }
-            if (ioctl(_fbfd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
+            if (ioctl(_fbfd, FBIOGET_VSCREENINFO, &_vinfo) == -1) {
                 log::error("Error reading variable information from %s", _device.c_str());
                 ::close(_fbfd);
                 return err::ERR_IO;
             }
 
-            _width = vinfo.xres;
-            _height = vinfo.yres;
-            _xres_virtual = vinfo.xres_virtual;
-            _yres_virtual = vinfo.yres_virtual;
-            _bpp = vinfo.bits_per_pixel;
-            _line_length = finfo.line_length;
-            _screensize = vinfo.yres_virtual * finfo.line_length;
+            _width = _vinfo.xres;
+            _height = _vinfo.yres;
+            _xres_virtual = _vinfo.xres_virtual;
+            _yres_virtual = _vinfo.yres_virtual;
+            _bpp = _vinfo.bits_per_pixel;
+            _line_length = _finfo.line_length;
+            _screensize = _vinfo.yres * _finfo.line_length;
+            _buff_size = _vinfo.yres_virtual * _finfo.line_length;
+            _buff_num = _vinfo.yres_virtual / _vinfo.yres;
+            _curr_buff_idx = 0;
+
+            log::info("buff num: %d, yres_virtual: %d, yres: %d", _buff_num, _vinfo.yres_virtual, _vinfo.yres);
 
             if (_bpp != 16 && _bpp != 18 && _bpp != 24 && _bpp != 32) {
                 log::error("Not support bpp: %d", _bpp);
@@ -268,13 +320,23 @@ namespace maix::display
                 return err::ERR_ARGS;
             }
 
-            _fbp = (unsigned char *)mmap(0, _screensize, PROT_READ | PROT_WRITE, MAP_SHARED, _fbfd, 0);
+            _fbp = (unsigned char *)mmap(0, _buff_size, PROT_READ | PROT_WRITE, MAP_SHARED, _fbfd, 0);
             if (_fbp == MAP_FAILED) {
                 log::error("Error mapping framebuffer to memory");
                 ::close(_fbfd);
                 return err::ERR_NO_MEM;
             }
 
+            if (_vinfo.yoffset != 0)
+            {
+                _vinfo.yoffset = 0;
+                if (ioctl(_fbfd, FBIOPAN_DISPLAY, &_vinfo) == -1) {
+                    log::error("Error write var information to %s", _device.c_str());
+                    ::close(_fbfd);
+                    return err::ERR_IO;
+                }
+            }
+
             _opened = true;
             return err::ERR_NONE;
         }
@@ -284,8 +346,10 @@ namespace maix::display
             if (!this->_opened)
                 return err::ERR_NONE;
 
-            memset(_fbp, 0, _screensize);
-            munmap(_fbp, _screensize);
+            memset(_fbp, 0, _buff_size);
+            munmap(_fbp, _buff_size);
+            _vinfo.yoffset = 0;
+            ioctl(_fbfd, FBIOPAN_DISPLAY, &_vinfo);
             ::close(_fbfd);
             _opened = false;
             return err::ERR_NONE;
@@ -321,33 +385,49 @@ namespace maix::display
                 img_ptr = fit_img_ptr;
             }
 
-            if (format == image::FMT_BGRA8888)
+            int next_buff_idx = (_curr_buff_idx + 1) % _buff_num;
+            int offset = _screensize * next_buff_idx;
+            if (format == image::FMT_BGRA8888 || format == image::FMT_RGBA8888)
             {
                 if (_bpp == 16 || _bpp == 18) {
                     image::Image *bgra8888_img = nullptr;
                     bgra8888_img = img_ptr->to_format(image::Format::FMT_RGB888);
-                    invert_rgb888_to_rgb565((uint8_t *)bgra8888_img->data(), bgra8888_img->width(), bgra8888_img->height(), _fbp);
+                    invert_rgb888_to_rgb565((uint8_t *)bgra8888_img->data(), bgra8888_img->width(), bgra8888_img->height(), _fbp + offset);
                     delete bgra8888_img;
                 } else if (_bpp == 24) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGR888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGR888, _fbp + offset, _screensize, false);
                     img->draw_image(0, 0, *img_ptr);
                     delete img;
                 } else if (_bpp == 32) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGRA8888, _fbp, _screensize, false);
-                    img->draw_image(0, 0, *img_ptr);
-                    delete img;
+                    if(format == image::FMT_RGBA8888)
+                    {
+                        image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGRA8888, _fbp + offset, _screensize, false);
+                        img->draw_image(0, 0, *img_ptr);
+                        delete img;
+                    }
+                    else
+                    {
+                        memcpy(_fbp + offset, img_ptr->data(), _screensize);
+                    }
                 }
             }
-            else if (format == image::FMT_RGB888)
+            else if (format == image::FMT_RGB888 || format == image::FMT_BGR888)
             {
                 if (_bpp == 16 || _bpp == 18) {
-                    invert_rgb888_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp);
+                    if(format == image::FMT_BGR888)
+                    {
+                        invert_bgr888_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp + offset);
+                    }
+                    else
+                    {
+                        invert_rgb888_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp + offset);
+                    }
                 } else if (_bpp == 24) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGR888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGR888, _fbp + offset, _screensize, false);
                     img->draw_image(0, 0, *img_ptr);
                     delete img;
                 } else if (_bpp == 32) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGRA8888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGRA8888, _fbp + offset, _screensize, false);
                     img->draw_image(0, 0, *img_ptr);
                     delete img;
                 }
@@ -355,13 +435,13 @@ namespace maix::display
             else if (format == image::FMT_GRAYSCALE)
             {
                 if (_bpp == 16 || _bpp == 18) {
-                    invert_gray_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp);
+                    invert_gray_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp + offset);
                 } else if (_bpp == 24) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGR888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGR888, _fbp + offset, _screensize, false);
                     img->draw_image(0, 0, *img_ptr);
                     delete img;
                 } else if (_bpp == 32) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGRA8888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGRA8888, _fbp + offset, _screensize, false);
                     img->draw_image(0, 0, *img_ptr);
                     delete img;
                 }
@@ -369,9 +449,9 @@ namespace maix::display
             else if (format == image::FMT_YVU420SP)
             {
                 if (_bpp == 16 || _bpp == 18) {
-                    invert_yvu420sp_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp);
+                    invert_yvu420sp_to_rgb565((uint8_t *)img_ptr->data(), img_ptr->width(), img_ptr->height(), _fbp + offset);
                 } else if (_bpp == 24) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGR888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGR888, _fbp + offset, _screensize, false);
                     cv::Mat cv_yvu_img(img_ptr->height() + img_ptr->height() / 2, img_ptr->width(), CV_8UC1, img_ptr->data());
                     cv::Mat cv_rgb_img;
                     cv::cvtColor(cv_yvu_img, cv_rgb_img, cv::COLOR_YUV2RGB_NV21);
@@ -380,7 +460,7 @@ namespace maix::display
                     delete img;
                     delete rgb_img;
                 } else if (_bpp == 32) {
-                    image::Image *img = new image::Image(_line_length / (_bpp / 8), _yres_virtual, image::Format::FMT_BGRA8888, _fbp, _screensize, false);
+                    image::Image *img = new image::Image(_width, _height, image::Format::FMT_BGRA8888, _fbp + offset, _screensize, false);
                     cv::Mat cv_yvu_img(img_ptr->height() + img_ptr->height() / 2, img_ptr->width(), CV_8UC1, img_ptr->data());
                     cv::Mat cv_rgb_img;
                     cv::cvtColor(cv_yvu_img, cv_rgb_img, cv::COLOR_YUV2RGB_NV21);
@@ -396,6 +476,20 @@ namespace maix::display
                 return err::ERR_ARGS;
             }
 
+            if(_buff_num > 1)
+            {
+                _vinfo.yoffset = next_buff_idx * _vinfo.yres;
+                if (ioctl(_fbfd, FBIOPAN_DISPLAY, &_vinfo) == -1) {
+                    log::error("Error write var information to %s", _device.c_str());
+                    ::close(_fbfd);
+                    if (fit_img_ptr != nullptr) {
+                        delete fit_img_ptr;
+                        fit_img_ptr = nullptr;
+                    }
+                    return err::ERR_IO;
+                }
+            }
+
             if (fit_img_ptr != nullptr) {
                 delete fit_img_ptr;
                 fit_img_ptr = nullptr;
@@ -468,7 +562,12 @@ namespace maix::display
         unsigned int _yres_virtual;
         unsigned int _line_length;
         long int _screensize = 0;
+        long int _buff_size = 0;
         int _bpp;
+        int _buff_num;
+        int _curr_buff_idx;
+        struct fb_var_screeninfo _vinfo;
+        struct fb_fix_screeninfo _finfo;
 #ifdef PLATFORM_MAIXCAM
         pwm::PWM *_bl_pwm;
 #endif

components/vision/src/maix_image.cpp

@@ -431,7 +431,8 @@ namespace maix::image
             else if ((bg.format == image::FMT_RGB888 || bg.format == image::FMT_BGR888 || bg.format == image::FMT_RGBA8888 || bg.format == image::FMT_BGRA8888) &
                 (_format == image::FMT_RGBA8888 || _format == image::FMT_BGRA8888))
             {
-                if(bg.r == bg.g && bg.g == bg.b && bg.alpha == 1)
+                uint8_t alpha = (uint8_t)(bg.alpha * 255);
+                if(bg.r == bg.g && bg.g == bg.b && bg.b == alpha)
                 {
                     memset(_data, bg.r, _data_size);
                 }
@@ -444,7 +445,7 @@ namespace maix::image
                         p[i * 4] = bg.r;
                         p[i * 4 + 1] = bg.g;
                         p[i * 4 + 2] = bg.b;
-                        p[i * 4 + 3] = bg.alpha;
+                        p[i * 4 + 3] = alpha;
                     }
                 }
             }
@@ -615,7 +616,7 @@ namespace maix::image
     {
         void *data = _data;
         std::vector<int> shape;
-        int channels = 1;
+        size_t channels = 1;
 
         if (_format == image::FMT_GRAYSCALE)
         {
@@ -625,7 +626,7 @@ namespace maix::image
         }
         else if (_format < image::FMT_YUV422SP)
         {
-            channels = (int)image::fmt_size[_format];
+            channels = (size_t)image::fmt_size[_format];
             shape = chw ? std::vector<int>{channels, _height, _width}
                         : std::vector<int>{_height, _width, channels};
         }

examples/camera_display/main/src/main.cpp

@@ -99,7 +99,9 @@ int _main(int argc, char* argv[])
 
     camera::Camera cam = camera::Camera(cam_w, cam_h, cam_fmt, "", cam_fps, cam_buffer_num, true, raw);
     camera::Camera *cam2 = NULL;
-    display::Display disp = display::Display();
+    // display::Display disp = display::Display();
+    // int width = -1, int height = -1, image::Format format = image::FMT_RGB888, const std::string &device = "", bool open = true);
+    display::Display disp = display::Display(-1, -1, image::FMT_BGRA8888, "/dev/fb0", true);
     display::Display *disp2 = NULL;
     log::info("camera and display open success");
     log::info("camera size: %dx%d", cam.width(), cam.height());

examples/vision_display_fb/.gitignore

@@ -0,0 +1,9 @@
+
+
+build
+dist
+.config.mk
+.flash.conf.json
+data
+
+/CMakeLists.txt

examples/vision_display_fb/main/CMakeLists.txt

@@ -0,0 +1,74 @@
+############### Add include ###################
+list(APPEND ADD_INCLUDE "include"
+    )
+list(APPEND ADD_PRIVATE_INCLUDE "")
+###############################################
+
+############ Add source files #################
+# list(APPEND ADD_SRCS  "src/main.c"
+#                       "src/test.c"
+#     )
+append_srcs_dir(ADD_SRCS "src")       # append source file in src dir to var ADD_SRCS
+# list(REMOVE_ITEM COMPONENT_SRCS "src/test2.c")
+# FILE(GLOB_RECURSE EXTRA_SRC  "src/*.c")
+# FILE(GLOB EXTRA_SRC  "src/*.c")
+# list(APPEND ADD_SRCS  ${EXTRA_SRC})
+# aux_source_directory(src ADD_SRCS)  # collect all source file in src dir, will set var ADD_SRCS
+# append_srcs_dir(ADD_SRCS "src")     # append source file in src dir to var ADD_SRCS
+# list(REMOVE_ITEM COMPONENT_SRCS "src/test.c")
+# set(ADD_ASM_SRCS "src/asm.S")
+# list(APPEND ADD_SRCS ${ADD_ASM_SRCS})
+# SET_PROPERTY(SOURCE ${ADD_ASM_SRCS} PROPERTY LANGUAGE C) # set .S  ASM file as C language
+# SET_SOURCE_FILES_PROPERTIES(${ADD_ASM_SRCS} PROPERTIES COMPILE_FLAGS "-x assembler-with-cpp -D BBBBB")
+###############################################
+
+###### Add required/dependent components ######
+list(APPEND ADD_REQUIREMENTS vision ext_dev)
+###############################################
+
+###### Add link search path for requirements/libs ######
+# list(APPEND ADD_LINK_SEARCH_PATH "${CONFIG_TOOLCHAIN_PATH}/lib")
+# list(APPEND ADD_REQUIREMENTS pthread m)  # add system libs, pthread and math lib for example here
+# set (OpenCV_DIR opencv/lib/cmake/opencv4)
+# find_package(OpenCV REQUIRED)
+###############################################
+
+############ Add static libs ##################
+# list(APPEND ADD_STATIC_LIB "lib/libtest.a")
+###############################################
+
+#### Add compile option for this component ####
+#### Just for this component, won't affect other 
+#### modules, including component that depend 
+#### on this component
+# list(APPEND ADD_DEFINITIONS_PRIVATE -DAAAAA=1)
+
+#### Add compile option for this component
+#### and components depend on this component
+# list(APPEND ADD_DEFINITIONS -DAAAAA222=1
+#                             -DAAAAA333=1)
+###############################################
+
+############ Add static libs ##################
+#### Update parent's variables like CMAKE_C_LINK_FLAGS
+# set(CMAKE_C_LINK_FLAGS "${CMAKE_C_LINK_FLAGS} -Wl,--start-group libmaix/libtest.a -ltest2 -Wl,--end-group" PARENT_SCOPE)
+###############################################
+
+######### Add files need to download #########
+# list(APPEND ADD_FILE_DOWNLOADS "{
+# 'url': 'https://*****/abcde.tar.xz',
+# 'urls': [],  # backup urls, if url failed, will try urls
+# 'sites': [], # download site, user can manually download file and put it into dl_path
+# 'sha256sum': '',
+# 'filename': 'abcde.tar.xz',
+# 'path': 'toolchains/xxxxx',
+# 'check_files': []
+# }"
+# )
+#
+# then extracted file in ${DL_EXTRACTED_PATH}/toolchains/xxxxx,
+# you can directly use then, for example use it in add_custom_command
+##############################################
+
+# register component, DYNAMIC or SHARED flags will make component compiled to dynamic(shared) lib
+register_component()

examples/vision_display_fb/main/include/main.h

@@ -0,0 +1,2 @@
+#pragma once
+

examples/vision_display_fb/main/src/main.cpp

@@ -0,0 +1,40 @@
+
+
+#include "maix_basic.hpp"
+#include "maix_display.hpp"
+#include "main.h"
+
+
+using namespace maix;
+
+int _main(int argc, char* argv[])
+{
+    std::string fb_dev = "/dev/fb0";
+    if(argc > 1)
+    {
+        fb_dev = argv[1];
+    }
+    log::info("fb dev: %s", fb_dev.c_str());
+    auto disp = display::Display();
+    auto disp_fb = display::Display(-1, -1, image::Format::FMT_BGRA8888, fb_dev);
+    int y = 0;
+    while(!app::need_exit())
+    {
+        image::Image img = image::Image(disp_fb.width(), disp_fb.height(), image::Format::FMT_BGRA8888, image::COLOR_BLACK);
+        img.draw_string(0, y, "hello", image::COLOR_WHITE, 2, 2);
+        disp_fb.show(img);
+        y = (y + 1) % img.height();
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    // Catch signal and process
+    sys::register_default_signal_handle();
+
+    // Use CATCH_EXCEPTION_RUN_RETURN to catch exception,
+    // if we don't catch exception, when program throw exception, the objects will not be destructed.
+    // So we catch exception here to let resources be released(call objects' destructor) before exit.
+    CATCH_EXCEPTION_RUN_RETURN(_main, -1, argc, argv);
+}
+