Use imgui

application/remote_desk/remote_desk_gui/main.cpp

@@ -0,0 +1,207 @@
+// Dear ImGui: standalone example application for SDL2 + SDL_Renderer
+// (SDL is a cross-platform general purpose library for handling windows,
+// inputs, OpenGL/Vulkan/Metal graphics context creation, etc.)
+
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/
+// folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// Important to understand: SDL_Renderer is an _optional_ component of SDL2.
+// For a multi-platform app consider using e.g. SDL+DirectX on Windows and
+// SDL+OpenGL on Linux/OSX.
+
+#include <SDL.h>
+#include <stdio.h>
+
+#include "imgui.h"
+#include "imgui_impl_sdl2.h"
+#include "imgui_impl_sdlrenderer2.h"
+
+#if !SDL_VERSION_ATLEAST(2, 0, 17)
+#error This backend requires SDL 2.0.17+ because of SDL_RenderGeometry() function
+#endif
+
+// Main code
+int main(int, char**) {
+  // Setup SDL
+  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) !=
+      0) {
+    printf("Error: %s\n", SDL_GetError());
+    return -1;
+  }
+
+  // From 2.0.18: Enable native IME.
+#ifdef SDL_HINT_IME_SHOW_UI
+  SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
+#endif
+
+  // Create window with SDL_Renderer graphics context
+  SDL_WindowFlags window_flags =
+      (SDL_WindowFlags)(SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+  SDL_Window* window = SDL_CreateWindow(
+      "Dear ImGui SDL2+SDL_Renderer example", SDL_WINDOWPOS_CENTERED,
+      SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+  SDL_Renderer* renderer = SDL_CreateRenderer(
+      window, -1, SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED);
+  if (renderer == nullptr) {
+    SDL_Log("Error creating SDL_Renderer!");
+    return 0;
+  }
+  // SDL_RendererInfo info;
+  // SDL_GetRendererInfo(renderer, &info);
+  // SDL_Log("Current SDL_Renderer: %s", info.name);
+
+  // Setup Dear ImGui context
+  IMGUI_CHECKVERSION();
+  ImGui::CreateContext();
+  ImGuiIO& io = ImGui::GetIO();
+  (void)io;
+  io.ConfigFlags |=
+      ImGuiConfigFlags_NavEnableKeyboard;  // Enable Keyboard Controls
+  io.ConfigFlags |=
+      ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls
+
+  // Setup Dear ImGui style
+  ImGui::StyleColorsDark();
+  // ImGui::StyleColorsLight();
+
+  // Setup Platform/Renderer backends
+  ImGui_ImplSDL2_InitForSDLRenderer(window, renderer);
+  ImGui_ImplSDLRenderer2_Init(renderer);
+
+  // Load Fonts
+  // - If no fonts are loaded, dear imgui will use the default font. You can
+  // also load multiple fonts and use ImGui::PushFont()/PopFont() to select
+  // them.
+  // - AddFontFromFileTTF() will return the ImFont* so you can store it if you
+  // need to select the font among multiple.
+  // - If the file cannot be loaded, the function will return a nullptr. Please
+  // handle those errors in your application (e.g. use an assertion, or display
+  // an error and quit).
+  // - The fonts will be rasterized at a given size (w/ oversampling) and stored
+  // into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which
+  // ImGui_ImplXXXX_NewFrame below will call.
+  // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype
+  // for higher quality font rendering.
+  // - Read 'docs/FONTS.md' for more instructions and details.
+  // - Remember that in C/C++ if you want to include a backslash \ in a string
+  // literal you need to write a double backslash \\ !
+  // io.Fonts->AddFontDefault();
+  // io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
+  // io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
+  // io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
+  // io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
+  // ImFont* font =
+  // io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f,
+  // nullptr, io.Fonts->GetGlyphRangesJapanese()); IM_ASSERT(font != nullptr);
+
+  // Our state
+  bool show_demo_window = true;
+  bool show_another_window = false;
+  ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+
+  // Main loop
+  bool done = false;
+  while (!done) {
+    // Poll and handle events (inputs, window resize, etc.)
+    // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to
+    // tell if dear imgui wants to use your inputs.
+    // - When io.WantCaptureMouse is true, do not dispatch mouse input data to
+    // your main application, or clear/overwrite your copy of the mouse data.
+    // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input
+    // data to your main application, or clear/overwrite your copy of the
+    // keyboard data. Generally you may always pass all inputs to dear imgui,
+    // and hide them from your application based on those two flags.
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+      ImGui_ImplSDL2_ProcessEvent(&event);
+      if (event.type == SDL_QUIT) done = true;
+      if (event.type == SDL_WINDOWEVENT &&
+          event.window.event == SDL_WINDOWEVENT_CLOSE &&
+          event.window.windowID == SDL_GetWindowID(window))
+        done = true;
+    }
+
+    // Start the Dear ImGui frame
+    ImGui_ImplSDLRenderer2_NewFrame();
+    ImGui_ImplSDL2_NewFrame();
+    ImGui::NewFrame();
+
+    // 1. Show the big demo window (Most of the sample code is in
+    // ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear
+    // ImGui!).
+    if (show_demo_window) ImGui::ShowDemoWindow(&show_demo_window);
+
+    // 2. Show a simple window that we create ourselves. We use a Begin/End pair
+    // to create a named window.
+    {
+      static float f = 0.0f;
+      static int counter = 0;
+
+      ImGui::Begin("Hello, world!");  // Create a window called "Hello, world!"
+                                      // and append into it.
+
+      ImGui::Text("This is some useful text.");  // Display some text (you can
+                                                 // use a format strings too)
+      ImGui::Checkbox(
+          "Demo Window",
+          &show_demo_window);  // Edit bools storing our window open/close state
+      ImGui::Checkbox("Another Window", &show_another_window);
+
+      ImGui::SliderFloat(
+          "float", &f, 0.0f,
+          1.0f);  // Edit 1 float using a slider from 0.0f to 1.0f
+      ImGui::ColorEdit3(
+          "clear color",
+          (float*)&clear_color);  // Edit 3 floats representing a color
+
+      if (ImGui::Button(
+              "Button"))  // Buttons return true when clicked (most widgets
+                          // return true when edited/activated)
+        counter++;
+      ImGui::SameLine();
+      ImGui::Text("counter = %d", counter);
+
+      ImGui::Text("Application average %.3f ms/frame (%.1f FPS)",
+                  1000.0f / io.Framerate, io.Framerate);
+      ImGui::End();
+    }
+
+    // 3. Show another simple window.
+    if (show_another_window) {
+      ImGui::Begin(
+          "Another Window",
+          &show_another_window);  // Pass a pointer to our bool variable (the
+                                  // window will have a closing button that will
+                                  // clear the bool when clicked)
+      ImGui::Text("Hello from another window!");
+      if (ImGui::Button("Close Me")) show_another_window = false;
+      ImGui::End();
+    }
+
+    // Rendering
+    ImGui::Render();
+    SDL_RenderSetScale(renderer, io.DisplayFramebufferScale.x,
+                       io.DisplayFramebufferScale.y);
+    SDL_SetRenderDrawColor(
+        renderer, (Uint8)(clear_color.x * 255), (Uint8)(clear_color.y * 255),
+        (Uint8)(clear_color.z * 255), (Uint8)(clear_color.w * 255));
+    SDL_RenderClear(renderer);
+    ImGui_ImplSDLRenderer2_RenderDrawData(ImGui::GetDrawData());
+    SDL_RenderPresent(renderer);
+  }
+
+  // Cleanup
+  ImGui_ImplSDLRenderer2_Shutdown();
+  ImGui_ImplSDL2_Shutdown();
+  ImGui::DestroyContext();
+
+  SDL_DestroyRenderer(renderer);
+  SDL_DestroyWindow(window);
+  SDL_Quit();
+
+  return 0;
+}

application/remote_desk/thirdparty/xmake.lua

@@ -0,0 +1 @@
+includes("sdl2")

application/remote_desk/xmake.lua

@@ -6,6 +6,7 @@ add_rules("mode.release", "mode.debug")
 set_languages("c++17")
 
 add_requires("spdlog 1.11.0", {system = false})
+add_requires("imgui 1.89.9", {system = false}, {configs = {sdl2 = true}})
 add_defines("UNICODE")
 
 add_requires("sdl2", {system = false})
@@ -24,13 +25,13 @@ end
 
 add_packages("spdlog")
 
-includes("../../thirdparty")
+includes("thirdparty")
 
 target("log")
     set_kind("headeronly")
     add_packages("spdlog")
-    add_headerfiles("../../src/log/log.h")
-    add_includedirs("../../src/log", {public = true})
+    add_headerfiles("../utils/log/log.h")
+    add_includedirs("../utils/log", {public = true})
 
 target("screen_capture")
     set_kind("static")
@@ -74,16 +75,16 @@ target("remote_desk_client")
     end
     
 
--- target("remote_desk")
---     set_kind("binary")
---     add_deps("projectx")
---     add_packages("log")
---     add_packages("ffmpeg")
---     add_packages("vcpkg::sdl2")
---     add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil")
---     add_files("**.cpp")
---     add_includedirs("../../src/interface")
---     add_links("SDL2-static", "SDL2main", "Shell32", "gdi32", "winmm", 
---         "setupapi", "version", "WindowsApp", "Imm32", "avutil")
-
-
+target("remote_desk_gui")
+    set_kind("binary")
+    add_deps("projectx")
+    add_packages("log", "imgui", "sdl2")
+    add_files("remote_desk_gui/*.cpp")
+    if is_os("windows") then
+        add_links("SDL2-static", "SDL2main", "gdi32", "winmm", 
+        "setupapi", "version", "Imm32", "iphlpapi")
+    elseif is_os("macosx") then
+        add_links("SDL2")
+    elseif is_os("linux") then
+        add_links("SDL2")
+    end

application/utils/log/log.h

@@ -0,0 +1,127 @@
+#ifndef _LOG_H_
+#define _LOG_H_
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "spdlog/common.h"
+#include "spdlog/logger.h"
+#include "spdlog/sinks/base_sink.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+#include "spdlog/spdlog.h"
+
+using namespace std::chrono;
+
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+
+// SPDLOG_TRACE(...)
+// SPDLOG_DEBUG(...)
+// SPDLOG_INFO(...)
+// SPDLOG_WARN(...)
+// SPDLOG_ERROR(...)
+// SPDLOG_CRITICAL(...)
+
+#ifdef SIGNAL_LOGGER
+constexpr auto LOGGER_NAME = "siganl";
+#else
+constexpr auto LOGGER_NAME = "rtc";
+#endif
+
+#define LOG_INFO(...)                                                         \
+  if (nullptr == spdlog::get(LOGGER_NAME)) {                                  \
+    auto now = std::chrono::system_clock::now() + std::chrono::hours(8);      \
+    auto timet = std::chrono::system_clock::to_time_t(now);                   \
+    auto localTime = *std::gmtime(&timet);                                    \
+    std::stringstream ss;                                                     \
+    std::string filename;                                                     \
+    ss << LOGGER_NAME;                                                        \
+    ss << std::put_time(&localTime, "-%Y%m%d-%H%M%S.log");                    \
+    ss >> filename;                                                           \
+    std::string path = "logs/" + filename;                                    \
+    std::vector<spdlog::sink_ptr> sinks;                                      \
+    sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>()); \
+    sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(   \
+        path, 1048576 * 5, 3));                                               \
+    auto combined_logger = std::make_shared<spdlog::logger>(                  \
+        LOGGER_NAME, begin(sinks), end(sinks));                               \
+    combined_logger->flush_on(spdlog::level::info);                           \
+    spdlog::register_logger(combined_logger);                                 \
+    SPDLOG_LOGGER_INFO(combined_logger, __VA_ARGS__);                         \
+  } else {                                                                    \
+    SPDLOG_LOGGER_INFO(spdlog::get(LOGGER_NAME), __VA_ARGS__);                \
+  }
+
+#define LOG_WARN(...)                                                         \
+  if (nullptr == spdlog::get(LOGGER_NAME)) {                                  \
+    auto now = std::chrono::system_clock::now() + std::chrono::hours(8);      \
+    auto timet = std::chrono::system_clock::to_time_t(now);                   \
+    auto localTime = *std::gmtime(&timet);                                    \
+    std::stringstream ss;                                                     \
+    std::string filename;                                                     \
+    ss << LOGGER_NAME;                                                        \
+    ss << std::put_time(&localTime, "-%Y%m%d-%H%M%S.log");                    \
+    ss >> filename;                                                           \
+    std::string path = "logs/" + filename;                                    \
+    std::vector<spdlog::sink_ptr> sinks;                                      \
+    sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>()); \
+    sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(   \
+        path, 1048576 * 5, 3));                                               \
+    auto combined_logger = std::make_shared<spdlog::logger>(                  \
+        LOGGER_NAME, begin(sinks), end(sinks));                               \
+    spdlog::register_logger(combined_logger);                                 \
+    SPDLOG_LOGGER_WARN(combined_logger, __VA_ARGS__);                         \
+  } else {                                                                    \
+    SPDLOG_LOGGER_WARN(spdlog::get(LOGGER_NAME), __VA_ARGS__);                \
+  }
+
+#define LOG_ERROR(...)                                                        \
+  if (nullptr == spdlog::get(LOGGER_NAME)) {                                  \
+    auto now = std::chrono::system_clock::now() + std::chrono::hours(8);      \
+    auto timet = std::chrono::system_clock::to_time_t(now);                   \
+    auto localTime = *std::gmtime(&timet);                                    \
+    std::stringstream ss;                                                     \
+    std::string filename;                                                     \
+    ss << LOGGER_NAME;                                                        \
+    ss << std::put_time(&localTime, "-%Y%m%d-%H%M%S.log");                    \
+    ss >> filename;                                                           \
+    std::string path = "logs/" + filename;                                    \
+    std::vector<spdlog::sink_ptr> sinks;                                      \
+    sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>()); \
+    sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(   \
+        path, 1048576 * 5, 3));                                               \
+    auto combined_logger = std::make_shared<spdlog::logger>(                  \
+        LOGGER_NAME, begin(sinks), end(sinks));                               \
+    spdlog::register_logger(combined_logger);                                 \
+    SPDLOG_LOGGER_ERROR(combined_logger, __VA_ARGS__);                        \
+  } else {                                                                    \
+    SPDLOG_LOGGER_ERROR(spdlog::get(LOGGER_NAME), __VA_ARGS__);               \
+  }
+
+#define LOG_FATAL(...)                                                        \
+  if (nullptr == spdlog::get(LOGGER_NAME)) {                                  \
+    auto now = std::chrono::system_clock::now() + std::chrono::hours(8);      \
+    auto timet = std::chrono::system_clock::to_time_t(now);                   \
+    auto localTime = *std::gmtime(&timet);                                    \
+    std::stringstream ss;                                                     \
+    std::string filename;                                                     \
+    ss << LOGGER_NAME;                                                        \
+    ss << std::put_time(&localTime, "-%Y%m%d-%H%M%S.log");                    \
+    ss >> filename;                                                           \
+    std::string path = "logs/" + filename;                                    \
+    std::vector<spdlog::sink_ptr> sinks;                                      \
+    sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>()); \
+    sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(   \
+        path, 1048576 * 5, 3));                                               \
+    auto combined_logger = std::make_shared<spdlog::logger>(                  \
+        LOGGER_NAME, begin(sinks), end(sinks));                               \
+    spdlog::register_logger(combined_logger);                                 \
+    SPDLOG_LOGGER_CRITICAL(combined_logger, __VA_ARGS__);                     \
+  } else {                                                                    \
+    SPDLOG_LOGGER_CRITICAL(spdlog::get(LOGGER_NAME), __VA_ARGS__);            \
+  }
+
+#endif

thirdparty/ffmpeg/xmake.lua

@@ -1,197 +0,0 @@
-package("ffmpegxx")
-    set_homepage("https://www.ffmpeg.org")
-    set_description("A collection of libraries to process multimedia content such as audio, video, subtitles and related metadata.")
-    set_license("GPL-3.0")
-
-    if is_plat("windows", "mingw") then
-        -- use vcpkg static lib
-        -- add_urls("https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-$(version)-full_build-shared.7z")
-        -- add_versions("5.1.2", "d9eb97b72d7cfdae4d0f7eaea59ccffb8c364d67d88018ea715d5e2e193f00e9")
-
-        -- add_configs("shared", {description = "Download shared binaries.", default = true, type = "boolean", readonly = true})
-        -- add_configs("vs_runtime", {description = "Set vs compiler runtime.", default = "MD", readonly = true})
-    else
-        add_urls("https://ffmpeg.org/releases/ffmpeg-$(version).tar.bz2", {alias = "home"})
-        add_urls("https://github.com/FFmpeg/FFmpeg/archive/n$(version).zip", {alias = "github"})
-        add_urls("https://git.ffmpeg.org/ffmpeg.git", "https://github.com/FFmpeg/FFmpeg.git", {alias = "git"})
-        add_versions("home:5.1.2", "39a0bcc8d98549f16c570624678246a6ac736c066cebdb409f9502e915b22f2b")
-        add_versions("github:5.1.2", "0c99f3609160f40946e2531804175eea16416320c4b6365ad075e390600539db")
-        add_versions("git:5.1.2", "n5.1.2")
-
-        add_configs("asm",              {description = "Disable asm", default = false, type = "boolean"})
-        add_configs("pic",              {description = "Enable force Position Independent Code", default = true, type = "boolean"})
-        add_configs("gpl",              {description = "Enable GPL code", default = true, type = "boolean"})
-        add_configs("ffprobe",          {description = "Enable ffprobe program.", default = false, type = "boolean"})
-        add_configs("ffmpeg",           {description = "Enable ffmpeg program.", default = true, type = "boolean"})
-        add_configs("ffplay",           {description = "Enable ffplay program.", default = false, type = "boolean"})
-        add_configs("zlib",             {description = "Enable zlib compression library.", default = false, type = "boolean"})
-        add_configs("lzma",             {description = "Enable liblzma compression library.", default = false, type = "boolean"})
-        add_configs("bzlib",            {description = "Enable bzlib compression library.", default = false, type = "boolean"})
-        add_configs("libx264",          {description = "Enable libx264 decoder.", default = false, type = "boolean"})
-        add_configs("libx265",          {description = "Enable libx265 decoder.", default = false, type = "boolean"})
-        add_configs("iconv",            {description = "Enable libiconv library.", default = false, type = "boolean"})
-        add_configs("hardcoded-tables", {description = "Enable hardcoded tables.", default = true, type = "boolean"})
-    end
-
-    -- add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil")
-    if is_plat("macosx") then
-        add_frameworks("CoreFoundation", "Foundation", "CoreVideo", "CoreMedia", "AudioToolbox", "VideoToolbox", "Security")
-    elseif is_plat("linux") then
-        add_syslinks("pthread")
-    end
-
-    if is_plat("linux", "macosx") then
-        add_deps("yasm")
-    end
-
-    if on_fetch then
-        on_fetch("mingw", "linux", "macosx", function (package, opt)
-            import("lib.detect.find_tool")
-            if opt.system then
-                local result
-                for _, name in ipairs({"libavcodec", "libavdevice", "libavfilter", "libavformat", "libavutil", "libpostproc", "libswresample", "libswscale"}) do
-                    local pkginfo = package:find_package("pkgconfig::" .. name, opt)
-                    if pkginfo then
-                        pkginfo.version = nil
-                        if not result then
-                            result = pkginfo
-                        else
-                            result = result .. pkginfo
-                        end
-                    else
-                        return
-                    end
-                end
-                local ffmpeg = find_tool("ffmpeg", {check = "-help", version = true, command = "-version", parse = "%d+%.?%d+%.?%d+", force = true})
-                if ffmpeg then
-                    result.version = ffmpeg.version
-                end
-                return result
-            end
-        end)
-    end
-
-    on_load("linux", "macos", "android", function (package)
-        local configdeps = {zlib    = "zlib",
-                            bzlib   = "bzip2",
-                            lzma    = "xz",
-                            libx264 = "x264",
-                            libx265 = "x265",
-                            iconv   = "libiconv"}
-        for name, dep in pairs(configdeps) do
-            if package:config(name) then
-                package:add("deps", dep)
-            end
-        end
-        -- https://www.ffmpeg.org/platform.html#toc-Advanced-linking-configuration
-        if package:config("pic") ~= false then
-            package:add("shflags", "-Wl,-Bsymbolic")
-            package:add("ldflags", "-Wl,-Bsymbolic")
-        end
-        if not package:config("gpl") then
-            package:set("license", "LGPL-3.0")
-        end
-    end)
-
-    on_install("windows|x64", "mingw|x86_64", function (package)
-        os.mv("bin", package:installdir())
-        os.mv("include", package:installdir())
-        os.mv("lib", package:installdir())
-        package:addenv("PATH", "bin")
-    end)
-
-    on_install("linux", "macosx", "android@linux,macosx", function (package)
-        local configs = {"--enable-version3",
-                         "--disable-doc"}
-        if package:config("gpl") then
-            table.insert(configs, "--enable-gpl")
-        end
-        if is_plat("macosx") and macos.version():ge("10.8") then
-            table.insert(configs, "--enable-videotoolbox")
-        end
-        for name, enabled in pairs(package:configs()) do
-            if not package:extraconf("configs", name, "builtin") then
-                if enabled then
-                    table.insert(configs, "--enable-" .. name)
-                else
-                    table.insert(configs, "--disable-" .. name)
-                end
-            end
-        end
-        if package:config("shared") then
-            table.insert(configs, "--enable-shared")
-            table.insert(configs, "--disable-static")
-        else
-            table.insert(configs, "--enable-static")
-            table.insert(configs, "--disable-shared")
-        end
-        if package:debug() then
-            table.insert(configs, "--enable-debug")
-        else
-            table.insert(configs, "--disable-debug")
-        end
-        if package:config("pic") ~= false then
-            table.insert(configs, "--enable-pic")
-        end
-        if package:is_plat("android") then
-            import("core.base.option")
-            import("core.tool.toolchain")
-            local ndk = toolchain.load("ndk", {plat = package:plat(), arch = package:arch()})
-            local bin = ndk:bindir()
-            local ndk_sdkver = ndk:config("ndk_sdkver")
-            local arch, cpu, triple, cross_prefix
-            if package:is_arch("arm64-v8a") then
-                arch = "arm64"
-                cpu = "armv8-a"
-                triple = "aarch64-linux-android"
-                cross_prefix = path.join(bin, "aarch64-linux-android-")
-            elseif package:arch():startswith("arm") then
-                arch = "arm"
-                cpu = "armv7-a"
-                triple = "armv7a-linux-androideabi"
-                cross_prefix = path.join(bin, "arm-linux-androideabi-")
-            else
-                raise("unknown arch(%s) for android!", package:arch())
-            end
-            local sysroot  = path.join(path.directory(bin), "sysroot")
-            local cflags   = table.join(table.wrap(package:config("cxflags")), table.wrap(package:config("cflags")), table.wrap(get_config("cxflags")), get_config("cflags"))
-            local cxxflags = table.join(table.wrap(package:config("cxflags")), table.wrap(package:config("cxxflags")), table.wrap(get_config("cxflags")), get_config("cxxflags"))
-            assert(os.isdir(sysroot), "we do not support old version ndk!")
-            if package:is_arch("arm64-v8a") then
-                table.insert(cflags, "-mfpu=neon")
-                table.insert(cflags, "-mfloat-abi=soft")
-            else
-                table.insert(cflags, "-mfpu=neon")
-                table.insert(cflags, "-mfloat-abi=soft")
-            end
-            table.insert(configs, "--enable-neon")
-            table.insert(configs, "--enable-asm")
-            table.insert(configs, "--enable-jni")
-            table.insert(configs, "--target-os=android")
-            table.insert(configs, "--enable-cross-compile")
-            table.insert(configs, "--disable-avdevice")
-            table.insert(configs, "--arch=" .. arch)
-            table.insert(configs, "--cpu=" .. cpu)
-            table.insert(configs, "--cc=" .. path.join(bin, triple .. ndk_sdkver .. "-clang"))
-            table.insert(configs, "--cxx=" .. path.join(bin, triple .. ndk_sdkver .. "-clang++"))
-            table.insert(configs, "--extra-cflags=" .. table.concat(cflags, ' '))
-            table.insert(configs, "--extra-cxxflags=" .. table.concat(cxxflags, ' '))
-            table.insert(configs, "--sysroot=" .. sysroot)
-            table.insert(configs, "--cross-prefix=" .. cross_prefix)
-            table.insert(configs, "--prefix=" .. package:installdir())
-            os.vrunv("./configure", configs)
-            local argv = {"-j4"}
-            if option.get("verbose") then
-                table.insert(argv, "V=1")
-            end
-            os.vrunv("make", argv)
-            os.vrun("make install")
-        else
-            import("package.tools.autoconf").install(package, configs)
-        end
-        package:addenv("PATH", "bin")
-    end)
-
-    on_test(function (package)
-        assert(package:has_cfuncs("avformat_open_input", {includes = "libavformat/avformat.h"}))
-    end)

thirdparty/xmake.lua

@@ -1 +1 @@
-includes("libjuice", "sdl2")
+includes("libjuice")