From 83d5ba42f8a98fc0df177efef4333f74a0481f61 Mon Sep 17 00:00:00 2001 From: pants Date: Mon, 21 Sep 2026 14:18:06 -0700 Subject: init --- src/application.cpp | 281 +++++++++++++++++++++++ src/canvas.cpp | 64 ++++++ src/canvas/chafa.cpp | 104 +++++++++ src/canvas/chafa.hpp | 52 +++++ src/canvas/iterm2/chunk.cpp | 56 +++++ src/canvas/iterm2/chunk.hpp | 45 ++++ src/canvas/iterm2/iterm2.cpp | 108 +++++++++ src/canvas/iterm2/iterm2.hpp | 51 +++++ src/canvas/kitty/chunk.cpp | 52 +++++ src/canvas/kitty/chunk.hpp | 42 ++++ src/canvas/kitty/kitty.cpp | 106 +++++++++ src/canvas/kitty/kitty.hpp | 48 ++++ src/canvas/sixel.cpp | 96 ++++++++ src/canvas/sixel.hpp | 57 +++++ src/canvas/stdout.hpp | 64 ++++++ src/canvas/wayland/config.cpp | 43 ++++ src/canvas/wayland/config.hpp | 45 ++++ src/canvas/wayland/config/dummy.cpp | 29 +++ src/canvas/wayland/config/dummy.hpp | 35 +++ src/canvas/wayland/config/hyprland.cpp | 151 +++++++++++++ src/canvas/wayland/config/hyprland.hpp | 53 +++++ src/canvas/wayland/config/sway.cpp | 183 +++++++++++++++ src/canvas/wayland/config/sway.hpp | 62 +++++ src/canvas/wayland/config/wayfire.cpp | 73 ++++++ src/canvas/wayland/config/wayfire.hpp | 44 ++++ src/canvas/wayland/wayland.cpp | 222 ++++++++++++++++++ src/canvas/wayland/wayland.hpp | 84 +++++++ src/canvas/wayland/window/shm.cpp | 75 +++++++ src/canvas/wayland/window/shm.hpp | 47 ++++ src/canvas/wayland/window/waylandegl.cpp | 235 +++++++++++++++++++ src/canvas/wayland/window/waylandegl.hpp | 88 ++++++++ src/canvas/wayland/window/waylandshm.cpp | 186 +++++++++++++++ src/canvas/wayland/window/waylandshm.hpp | 77 +++++++ src/canvas/wayland/window/waylandwindow.hpp | 46 ++++ src/canvas/x11/window/x11.cpp | 119 ++++++++++ src/canvas/x11/window/x11.hpp | 60 +++++ src/canvas/x11/window/x11egl.cpp | 138 ++++++++++++ src/canvas/x11/window/x11egl.hpp | 68 ++++++ src/canvas/x11/x11.cpp | 257 +++++++++++++++++++++ src/canvas/x11/x11.hpp | 93 ++++++++ src/dimensions.cpp | 62 +++++ src/flags.cpp | 52 +++++ src/image.cpp | 185 +++++++++++++++ src/image/libvips.cpp | 216 ++++++++++++++++++ src/image/libvips.hpp | 71 ++++++ src/image/opencv.cpp | 249 +++++++++++++++++++++ src/image/opencv.hpp | 68 ++++++ src/main.cpp | 151 +++++++++++++ src/os.cpp | 126 +++++++++++ src/process/apple.cpp | 43 ++++ src/process/linux.cpp | 39 ++++ src/terminal.cpp | 335 ++++++++++++++++++++++++++++ src/tmux.cpp | 142 ++++++++++++ src/util/dbus.cpp | 15 ++ src/util/egl.cpp | 228 +++++++++++++++++++ src/util/socket.cpp | 169 ++++++++++++++ src/util/util.cpp | 262 ++++++++++++++++++++++ src/util/x11.cpp | 171 ++++++++++++++ 58 files changed, 6323 insertions(+) create mode 100644 src/application.cpp create mode 100644 src/canvas.cpp create mode 100644 src/canvas/chafa.cpp create mode 100644 src/canvas/chafa.hpp create mode 100644 src/canvas/iterm2/chunk.cpp create mode 100644 src/canvas/iterm2/chunk.hpp create mode 100644 src/canvas/iterm2/iterm2.cpp create mode 100644 src/canvas/iterm2/iterm2.hpp create mode 100644 src/canvas/kitty/chunk.cpp create mode 100644 src/canvas/kitty/chunk.hpp create mode 100644 src/canvas/kitty/kitty.cpp create mode 100644 src/canvas/kitty/kitty.hpp create mode 100644 src/canvas/sixel.cpp create mode 100644 src/canvas/sixel.hpp create mode 100644 src/canvas/stdout.hpp create mode 100644 src/canvas/wayland/config.cpp create mode 100644 src/canvas/wayland/config.hpp create mode 100644 src/canvas/wayland/config/dummy.cpp create mode 100644 src/canvas/wayland/config/dummy.hpp create mode 100644 src/canvas/wayland/config/hyprland.cpp create mode 100644 src/canvas/wayland/config/hyprland.hpp create mode 100644 src/canvas/wayland/config/sway.cpp create mode 100644 src/canvas/wayland/config/sway.hpp create mode 100644 src/canvas/wayland/config/wayfire.cpp create mode 100644 src/canvas/wayland/config/wayfire.hpp create mode 100644 src/canvas/wayland/wayland.cpp create mode 100644 src/canvas/wayland/wayland.hpp create mode 100644 src/canvas/wayland/window/shm.cpp create mode 100644 src/canvas/wayland/window/shm.hpp create mode 100644 src/canvas/wayland/window/waylandegl.cpp create mode 100644 src/canvas/wayland/window/waylandegl.hpp create mode 100644 src/canvas/wayland/window/waylandshm.cpp create mode 100644 src/canvas/wayland/window/waylandshm.hpp create mode 100644 src/canvas/wayland/window/waylandwindow.hpp create mode 100644 src/canvas/x11/window/x11.cpp create mode 100644 src/canvas/x11/window/x11.hpp create mode 100644 src/canvas/x11/window/x11egl.cpp create mode 100644 src/canvas/x11/window/x11egl.hpp create mode 100644 src/canvas/x11/x11.cpp create mode 100644 src/canvas/x11/x11.hpp create mode 100644 src/dimensions.cpp create mode 100644 src/flags.cpp create mode 100644 src/image.cpp create mode 100644 src/image/libvips.cpp create mode 100644 src/image/libvips.hpp create mode 100644 src/image/opencv.cpp create mode 100644 src/image/opencv.hpp create mode 100644 src/main.cpp create mode 100644 src/os.cpp create mode 100644 src/process/apple.cpp create mode 100644 src/process/linux.cpp create mode 100644 src/terminal.cpp create mode 100644 src/tmux.cpp create mode 100644 src/util/dbus.cpp create mode 100644 src/util/egl.cpp create mode 100644 src/util/socket.cpp create mode 100644 src/util/util.cpp create mode 100644 src/util/x11.cpp (limited to 'src') diff --git a/src/application.cpp b/src/application.cpp new file mode 100644 index 0000000..2aa06f5 --- /dev/null +++ b/src/application.cpp @@ -0,0 +1,281 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "application.hpp" +#include "image.hpp" +#include "tmux.hpp" +#include "util.hpp" +#include "util/socket.hpp" +#include "version.hpp" + +#include +#include +#include +#include + +#include +#include +#include +#include + +using njson = nlohmann::json; +namespace fs = std::filesystem; + +Application::Application(const char *executable) +{ + flags = Flags::instance(); + print_header(); + setup_logger(); + set_silent(); + terminal = std::make_unique(); + if (flags->no_stdin) { + daemonize(); + } + canvas = Canvas::create(); + const auto cache_path = util::get_cache_path(); + if (!fs::exists(cache_path) && !flags->no_cache) { + fs::create_directories(cache_path); + } + tmux::register_hooks(); + socket_thread = std::thread([this] { + const auto sock_path = util::get_socket_path(); + logger->info("Listening for commands on socket {}", sock_path); + socket_loop(); + }); + if (flags->no_cache) { + logger->info("Image caching is disabled"); + } + if (VIPS_INIT(executable)) { + vips_error_exit(nullptr); + } + vips_cache_set_max(1); +} + +Application::~Application() +{ + if (socket_thread.joinable()) { + socket_thread.join(); + } + logger->info("Exiting ueberzugpp"); + canvas.reset(); + vips_shutdown(); + tmux::unregister_hooks(); + fs::remove(util::get_socket_path()); +} + +void Application::execute(const std::string_view cmd) +{ + if (!canvas) { + return; + } + njson json; + try { + json = njson::parse(cmd); + } catch (const njson::parse_error &e) { + logger->error("Command received is not valid json"); + return; + } + const auto json_str = json.dump(); + logger->info("Command received: {}", json_str); + + const std::string &action = json.at("action"); + if (action == "tmux") { + const std::string &hook = json.at("hook"); + handle_tmux_hook(hook); + return; + } + + const std::string &identifier = json.at("identifier"); + if (action == "add") { + if (!json.at("path").is_string()) { + logger->error("Path received is not valid"); + return; + } + auto image = Image::load(json, terminal.get()); + if (!image) { + logger->error("Unable to load image file"); + return; + } + canvas->add_image(identifier, std::move(image)); + } else if (action == "remove") { + canvas->remove_image(identifier); + } else { + logger->warn("Command not supported"); + } +} + +void Application::handle_tmux_hook(const std::string_view hook) +{ + const std::unordered_map> hook_fns{ + {"client-session-changed", + [this] { + if (tmux::is_window_focused()) { + canvas->show(); + } else { + canvas->hide(); + } + }}, + {"session-window-changed", + [this] { + if (tmux::is_window_focused()) { + canvas->show(); + } else { + canvas->hide(); + } + }}, + {"client-detached", [this] { canvas->hide(); }}, + {"window-layout-changed", + [this] { + if (tmux::is_window_focused()) { + canvas->hide(); + } + }}, + }; + + try { + hook_fns.at(hook)(); + } catch (const std::out_of_range &oor) { + logger->warn("TMUX hook not recognized"); + } +} + +void Application::setup_logger() +{ + const auto log_tmp = util::get_log_filename(); + const auto log_path = util::temp_directory_path() / log_tmp; + try { + spdlog::flush_on(spdlog::level::debug); + const auto sink = std::make_shared(log_path); + + const auto main_logger = std::make_shared("main", sink); + const auto terminal_logger = std::make_shared("terminal", sink); + const auto cv_logger = std::make_shared("opencv", sink); + const auto vips_logger = std::make_shared("vips", sink); + const auto x11_logger = std::make_shared("X11", sink); + const auto sixel_logger = std::make_shared("sixel", sink); + const auto kitty_logger = std::make_shared("kitty", sink); + const auto iterm2_logger = std::make_shared("iterm2", sink); + const auto chafa_logger = std::make_shared("chafa", sink); + const auto wayland_logger = std::make_shared("wayland", sink); + const auto opengl_logger = std::make_shared("opengl", sink); + + spdlog::initialize_logger(main_logger); + spdlog::initialize_logger(terminal_logger); + spdlog::initialize_logger(cv_logger); + spdlog::initialize_logger(vips_logger); + spdlog::initialize_logger(x11_logger); + spdlog::initialize_logger(sixel_logger); + spdlog::initialize_logger(kitty_logger); + spdlog::initialize_logger(iterm2_logger); + spdlog::initialize_logger(chafa_logger); + spdlog::initialize_logger(wayland_logger); + spdlog::initialize_logger(opengl_logger); + + logger = spdlog::get("main"); + } catch (const spdlog::spdlog_ex &ex) { + std::cout << "Log init failed: " << ex.what() << '\n'; + } +} + +void Application::command_loop() +{ + if (flags->no_stdin) { + return; + } + while (!stop_flag) { + try { + const auto in_event = os::wait_for_data_on_stdin(100); + if (!in_event) { + continue; + } + const auto cmd = os::read_data_from_stdin(); + execute(cmd); + } catch (const std::system_error &err) { + stop_flag = true; + break; + } + } +} + +void Application::socket_loop() +{ + UnixSocket socket; + socket.bind_to_endpoint(util::get_socket_path()); + + const int waitms = 100; + int conn = -1; + while (!stop_flag) { + try { + conn = socket.wait_for_connections(waitms); + } catch (const std::system_error &err) { + stop_flag = true; + break; + } + + if (conn == -1) { + continue; + } + + const auto data = socket.read_data_from_connection(conn); + for (const auto &cmd : data) { + if (cmd == "EXIT") { + stop_flag = true; + return; + } + execute(cmd); + } + } +} + +void Application::print_header() +{ + const auto log_tmp = util::get_log_filename(); + const auto log_path = util::temp_directory_path() / log_tmp; + const auto art = fmt::format(R"( + _ _ _ +| | | | | | _ _ +| | | | ___| |__ ___ _ __ _____ _ __ _ _| |_ _| |_ +| | | |/ _ \ '_ \ / _ \ '__|_ / | | |/ _` |_ _|_ _| +| |_| | __/ |_) | __/ | / /| |_| | (_| | |_| |_| + \___/ \___|_.__/ \___|_| /___|\__,_|\__, | + __/ | + |___/ v{}.{}.{})", + ueberzugpp_VERSION_MAJOR, ueberzugpp_VERSION_MINOR, ueberzugpp_VERSION_PATCH); + std::ofstream ofs(log_path, std::ios::out | std::ios::app); + ofs << art << '\n' << std::flush; +} + +void Application::set_silent() +{ + if (!flags->silent) { + return; + } + f_stderr.reset(std::freopen("/dev/null", "w", stderr)); +} + +void Application::print_version() +{ + const auto ver_str = fmt::format("ueberzugpp {}.{}.{}", ueberzugpp_VERSION_MAJOR, ueberzugpp_VERSION_MINOR, + ueberzugpp_VERSION_PATCH); + std::cout << ver_str << '\n'; +} + +void Application::daemonize() +{ + os::daemonize(); + std::ofstream ofs(flags->pid_file); + ofs << os::get_pid() << std::flush; +} diff --git a/src/canvas.cpp b/src/canvas.cpp new file mode 100644 index 0000000..08fd0a3 --- /dev/null +++ b/src/canvas.cpp @@ -0,0 +1,64 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "canvas/chafa.hpp" +#include "canvas/iterm2/iterm2.hpp" +#include "canvas/kitty/kitty.hpp" +#include "canvas/sixel.hpp" +#include "canvas/stdout.hpp" +#ifdef ENABLE_X11 +# include "canvas/x11/x11.hpp" +#endif +#ifdef ENABLE_WAYLAND +# include "canvas/wayland/wayland.hpp" +#endif +#include "flags.hpp" +#include + +auto Canvas::create() -> std::unique_ptr +{ + const auto flags = Flags::instance(); + const auto logger = spdlog::get("main"); + +#ifdef ENABLE_WAYLAND + if (flags->output == "wayland") { + return std::make_unique(); + } +#else + logger->debug("Wayland support not compiled in the binary"); +#endif +#ifdef ENABLE_X11 + if (flags->output == "x11") { + return std::make_unique(); + } +#else + logger->debug("X11 support not compiled in the binary"); +#endif + + if (flags->output == "kitty") { + return std::make_unique>(flags->output); + } + if (flags->output == "iterm2") { + return std::make_unique>(flags->output); + } + if (flags->output == "sixel") { + return std::make_unique>(flags->output); + } + if (flags->output == "chafa") { + return std::make_unique>(flags->output); + } + throw std::runtime_error(fmt::format("output backend not supported (backend is {})", flags->output)); +} diff --git a/src/canvas/chafa.cpp b/src/canvas/chafa.cpp new file mode 100644 index 0000000..dc3ece5 --- /dev/null +++ b/src/canvas/chafa.cpp @@ -0,0 +1,104 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "chafa.hpp" +#include "dimensions.hpp" +#include "terminal.hpp" +#include "util.hpp" +#include "util/ptr.hpp" + +#include +#include +#include + +#include +#include + +void gstring_delete(GString *str) +{ + g_string_free(str, true); +} + +Chafa::Chafa(std::unique_ptr new_image, std::mutex *stdout_mutex) + : symbol_map(chafa_symbol_map_new()), + config(chafa_canvas_config_new()), + image(std::move(new_image)), + stdout_mutex(stdout_mutex) +{ + const auto envp = c_unique_ptr{g_get_environ()}; + term_info = chafa_term_db_detect(chafa_term_db_get_default(), envp.get()); + + const auto dims = image->dimensions(); + x = dims.x + 1; + y = dims.y + 1; + horizontal_cells = std::ceil(static_cast(image->width()) / dims.terminal->font_width); + vertical_cells = std::ceil(static_cast(image->height()) / dims.terminal->font_height); + + chafa_symbol_map_add_by_tags(symbol_map, CHAFA_SYMBOL_TAG_BLOCK); + chafa_symbol_map_add_by_tags(symbol_map, CHAFA_SYMBOL_TAG_BORDER); + chafa_symbol_map_add_by_tags(symbol_map, CHAFA_SYMBOL_TAG_SPACE); + chafa_symbol_map_remove_by_tags(symbol_map, CHAFA_SYMBOL_TAG_WIDE); + chafa_canvas_config_set_symbol_map(config, symbol_map); + chafa_canvas_config_set_pixel_mode(config, CHAFA_PIXEL_MODE_SYMBOLS); + chafa_canvas_config_set_geometry(config, horizontal_cells, vertical_cells); +} + +Chafa::~Chafa() +{ + chafa_canvas_unref(canvas); + chafa_canvas_config_unref(config); + chafa_symbol_map_unref(symbol_map); + chafa_term_info_unref(term_info); + + const std::scoped_lock lock{*stdout_mutex}; + util::clear_terminal_area(x, y, horizontal_cells, vertical_cells); +} + +void Chafa::draw() +{ + canvas = chafa_canvas_new(config); + chafa_canvas_draw_all_pixels(canvas, CHAFA_PIXEL_BGRA8_UNASSOCIATED, image->data(), image->width(), image->height(), + image->width() * 4); + +#ifdef CHAFA_VERSION_1_14 + GString **lines = nullptr; + gint lines_length = 0; + + chafa_canvas_print_rows(canvas, term_info, &lines, &lines_length); + auto ycoord = y; + const std::scoped_lock lock{*stdout_mutex}; + util::save_cursor_position(); + for (int i = 0; i < lines_length; ++i) { + const auto line = c_unique_ptr{lines[i]}; + util::move_cursor(ycoord++, x); + std::cout << line->str; + } + g_free(lines); +#else + const auto result = c_unique_ptr{chafa_canvas_print(canvas, term_info)}; + auto ycoord = y; + const auto lines = util::str_split(result->str, "\n"); + + const std::scoped_lock lock{*stdout_mutex}; + util::save_cursor_position(); + ranges::for_each(lines, [this, &ycoord](const std::string &line) { + util::move_cursor(ycoord++, x); + std::cout << line; + }); +#endif + std::cout << std::flush; + util::restore_cursor_position(); +} diff --git a/src/canvas/chafa.hpp b/src/canvas/chafa.hpp new file mode 100644 index 0000000..608aa13 --- /dev/null +++ b/src/canvas/chafa.hpp @@ -0,0 +1,52 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef CHAFA_WINDOW_H +#define CHAFA_WINDOW_H + +#include "image.hpp" +#include "window.hpp" + +#include +#include + +#include + +class Chafa : public Window +{ + public: + Chafa(std::unique_ptr new_image, std::mutex *stdout_mutex); + ~Chafa() override; + + void draw() override; + void generate_frame() override{}; + + private: + ChafaTermInfo *term_info = nullptr; + ChafaSymbolMap *symbol_map = nullptr; + ChafaCanvasConfig *config = nullptr; + ChafaCanvas *canvas = nullptr; + + std::unique_ptr image; + std::mutex *stdout_mutex; + + int x; + int y; + int horizontal_cells = 0; + int vertical_cells = 0; +}; + +#endif diff --git a/src/canvas/iterm2/chunk.cpp b/src/canvas/iterm2/chunk.cpp new file mode 100644 index 0000000..950606f --- /dev/null +++ b/src/canvas/iterm2/chunk.cpp @@ -0,0 +1,56 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "chunk.hpp" +#include "util.hpp" + +Iterm2Chunk::Iterm2Chunk(uint64_t size) +{ + auto bufsize = 4*((size+2)/3); + buffer.resize(size, 0); + result.resize(bufsize + 1, 0); +} + +void Iterm2Chunk::set_size(uint64_t size) +{ + this->size = size; +} + +auto Iterm2Chunk::get_size() const -> uint64_t +{ + return size; +} + +auto Iterm2Chunk::get_buffer() -> char* +{ + return buffer.data(); +} + +auto Iterm2Chunk::get_result() -> char* +{ + return result.data(); +} + +void Iterm2Chunk::process_chunk(std::unique_ptr& chunk) +{ + util::base64_encode_v2(reinterpret_cast(chunk->get_buffer()), + chunk->get_size(), reinterpret_cast(chunk->get_result())); +} + +void Iterm2Chunk::operator()(std::unique_ptr& chunk) const +{ + process_chunk(chunk); +} diff --git a/src/canvas/iterm2/chunk.hpp b/src/canvas/iterm2/chunk.hpp new file mode 100644 index 0000000..4abcb21 --- /dev/null +++ b/src/canvas/iterm2/chunk.hpp @@ -0,0 +1,45 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef ITERM2_CHUNK_H +#define ITERM2_CHUNK_H + +#include +#include +#include + +class Iterm2Chunk +{ +public: + Iterm2Chunk() = default; + explicit Iterm2Chunk(uint64_t size); + + void operator()(std::unique_ptr& chunk) const; + void static process_chunk(std::unique_ptr& chunk); + + [[nodiscard]] auto get_size() const -> uint64_t; + void set_size(uint64_t size); + auto get_buffer() -> char*; + auto get_result() -> char*; + +private: + uint64_t size; + std::vector buffer; + std::vector result; + +}; + +#endif diff --git a/src/canvas/iterm2/iterm2.cpp b/src/canvas/iterm2/iterm2.cpp new file mode 100644 index 0000000..2818aab --- /dev/null +++ b/src/canvas/iterm2/iterm2.cpp @@ -0,0 +1,108 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "iterm2.hpp" +#include "chunk.hpp" +#include "dimensions.hpp" +#include "image.hpp" +#include "terminal.hpp" +#include "util.hpp" + +#include +#include +#include +#include + +#include +#include + +#ifdef HAVE_STD_EXECUTION_H +# include +#else +# include +#endif + +#include + +namespace fs = std::filesystem; + +Iterm2::Iterm2(std::unique_ptr new_image, std::mutex *stdout_mutex) + : image(std::move(new_image)), + stdout_mutex(stdout_mutex) +{ + const auto dims = image->dimensions(); + x = dims.x + 1; + y = dims.y + 1; + horizontal_cells = std::ceil(static_cast(image->width()) / dims.terminal->font_width); + vertical_cells = std::ceil(static_cast(image->height()) / dims.terminal->font_height); +} + +Iterm2::~Iterm2() +{ + const std::scoped_lock lock{*stdout_mutex}; + util::clear_terminal_area(x, y, horizontal_cells, vertical_cells); +} + +void Iterm2::draw() +{ + str.append("\033]1337;File=inline=1;"); + const auto filename = image->filename(); + const auto num_bytes = fs::file_size(filename); + const auto encoded_filename = + util::base64_encode(reinterpret_cast(filename.c_str()), filename.size()); + str.append(fmt::format("size={};name={};width={}px;height={}px:", num_bytes, encoded_filename, image->width(), + image->height())); + + const int chunk_size = 1023; + const auto chunks = process_chunks(filename, chunk_size, num_bytes); + const int num_chunks = std::ceil(static_cast(num_bytes) / chunk_size); + const uint64_t bytes_per_chunk = 4 * ((chunk_size + 2) / 3) + 100; + str.reserve((num_chunks + 2) * bytes_per_chunk); + + ranges::for_each(chunks, [this](const std::unique_ptr &chunk) { str.append(chunk->get_result()); }); + str.append("\a"); + + const std::scoped_lock lock{*stdout_mutex}; + util::save_cursor_position(); + util::move_cursor(y, x); + std::cout << str << std::flush; + util::restore_cursor_position(); + str.clear(); +} + +auto Iterm2::process_chunks(const std::string &filename, int chunk_size, size_t num_bytes) + -> std::vector> +{ + const int num_chunks = std::ceil(static_cast(num_bytes) / chunk_size); + std::vector> chunks; + chunks.reserve(num_chunks + 2); + + std::ifstream ifs(filename); + while (ifs.good()) { + auto chunk = std::make_unique(chunk_size); + ifs.read(chunk->get_buffer(), chunk_size); + chunk->set_size(ifs.gcount()); + chunks.push_back(std::move(chunk)); + } + +#ifdef HAVE_STD_EXECUTION_H + std::for_each(std::execution::par_unseq, chunks.begin(), chunks.end(), Iterm2Chunk::process_chunk); +#else + oneapi::tbb::parallel_for_each(chunks.begin(), chunks.end(), Iterm2Chunk()); +#endif + + return chunks; +} diff --git a/src/canvas/iterm2/iterm2.hpp b/src/canvas/iterm2/iterm2.hpp new file mode 100644 index 0000000..0912809 --- /dev/null +++ b/src/canvas/iterm2/iterm2.hpp @@ -0,0 +1,51 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef ITERM2_CANVAS_H +#define ITERM2_CANVAS_H + +#include "chunk.hpp" +#include "image.hpp" +#include "window.hpp" + +#include +#include +#include + +class Iterm2 : public Window +{ + public: + Iterm2(std::unique_ptr new_image, std::mutex *stdout_mutex); + ~Iterm2() override; + + void draw() override; + void generate_frame() override{}; + + private: + std::unique_ptr image; + std::mutex *stdout_mutex; + std::string str; + + int x; + int y; + int horizontal_cells = 0; + int vertical_cells = 0; + + static auto process_chunks(const std::string &filename, int chunk_size, size_t num_bytes) + -> std::vector>; +}; + +#endif diff --git a/src/canvas/kitty/chunk.cpp b/src/canvas/kitty/chunk.cpp new file mode 100644 index 0000000..a54dc94 --- /dev/null +++ b/src/canvas/kitty/chunk.cpp @@ -0,0 +1,52 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "chunk.hpp" +#include "util.hpp" + +KittyChunk::KittyChunk(const unsigned char* ptr, uint64_t size): +ptr(ptr), +size(size) +{ + uint64_t bufsize = 4*((size+2)/3); + result.resize(bufsize + 1, 0); +} + +void KittyChunk::process_chunk(KittyChunk& chunk) +{ + util::base64_encode_v2(chunk.get_ptr(), chunk.get_size(), + reinterpret_cast(chunk.get_result())); +} + +void KittyChunk::operator()(KittyChunk& chunk) const +{ + process_chunk(chunk); +} + +auto KittyChunk::get_result() -> char* +{ + return result.data(); +} + +auto KittyChunk::get_ptr() const -> const unsigned char* +{ + return ptr; +} + +auto KittyChunk::get_size() const -> uint64_t +{ + return size; +} diff --git a/src/canvas/kitty/chunk.hpp b/src/canvas/kitty/chunk.hpp new file mode 100644 index 0000000..ac611e8 --- /dev/null +++ b/src/canvas/kitty/chunk.hpp @@ -0,0 +1,42 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef KITTY_CHUNK_H +#define KITTY_CHUNK_H + +#include +#include + +class KittyChunk +{ +public: + KittyChunk() = default; + KittyChunk(const unsigned char* ptr, uint64_t size); + + void operator()(KittyChunk& chunk) const; + + auto get_result() -> char*; + [[nodiscard]] auto get_ptr() const -> const unsigned char*; + [[nodiscard]] auto get_size() const -> uint64_t; + + static void process_chunk(KittyChunk& chunk); +private: + const unsigned char* ptr; + uint64_t size; + std::vector result; +}; + +#endif diff --git a/src/canvas/kitty/kitty.cpp b/src/canvas/kitty/kitty.cpp new file mode 100644 index 0000000..ed89948 --- /dev/null +++ b/src/canvas/kitty/kitty.cpp @@ -0,0 +1,106 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "kitty.hpp" +#include "dimensions.hpp" +#include "util.hpp" + +#include + +#include + +#ifdef HAVE_STD_EXECUTION_H +# include +#else +# include +#endif + +Kitty::Kitty(std::unique_ptr new_image, std::mutex *stdout_mutex) + : image(std::move(new_image)), + stdout_mutex(stdout_mutex), + id(util::generate_random_number(1)) +{ + const auto dims = image->dimensions(); + x = dims.x + 1; + y = dims.y + 1; +} + +Kitty::~Kitty() +{ + const std::scoped_lock lock{*stdout_mutex}; + std::cout << fmt::format("\033_Ga=d,d=i,i={}\033\\", id) << std::flush; +} + +void Kitty::draw() +{ + generate_frame(); +} + +void Kitty::generate_frame() +{ + const int bits_per_channel = 8; + auto chunks = process_chunks(); + str.append(fmt::format("\033_Ga=T,m=1,i={},q=2,f={},s={},v={};{}\033\\", id, image->channels() * bits_per_channel, + image->width(), image->height(), chunks.front().get_result())); + + for (auto chunk = std::next(std::begin(chunks)); chunk != std::prev(std::end(chunks)); std::advance(chunk, 1)) { + str.append("\033_Gm=1,q=2;"); + str.append(chunk->get_result()); + str.append("\033\\"); + } + + str.append("\033_Gm=0,q=2;"); + str.append(chunks.back().get_result()); + str.append("\033\\"); + + const std::scoped_lock lock{*stdout_mutex}; + util::save_cursor_position(); + util::move_cursor(y, x); + std::cout << str << std::flush; + util::restore_cursor_position(); + str.clear(); +} + +auto Kitty::process_chunks() -> std::vector +{ + const uint64_t chunk_size = 3068; + uint64_t num_chunks = image->size() / chunk_size; + uint64_t last_chunk_size = image->size() % chunk_size; + if (last_chunk_size == 0) { + last_chunk_size = chunk_size; + num_chunks--; + } + const uint64_t bytes_per_chunk = 4 * ((chunk_size + 2) / 3) + 100; + str.reserve((num_chunks + 2) * bytes_per_chunk); + + std::vector chunks; + chunks.reserve(num_chunks + 2); + const auto *ptr = image->data(); + + uint64_t idx = 0; + for (; idx < num_chunks; idx++) { + chunks.emplace_back(ptr + idx * chunk_size, chunk_size); + } + chunks.emplace_back(ptr + idx * chunk_size, last_chunk_size); + +#ifdef HAVE_STD_EXECUTION_H + std::for_each(std::execution::par_unseq, std::begin(chunks), std::end(chunks), KittyChunk::process_chunk); +#else + oneapi::tbb::parallel_for_each(std::begin(chunks), std::end(chunks), KittyChunk()); +#endif + + return chunks; +} diff --git a/src/canvas/kitty/kitty.hpp b/src/canvas/kitty/kitty.hpp new file mode 100644 index 0000000..9889434 --- /dev/null +++ b/src/canvas/kitty/kitty.hpp @@ -0,0 +1,48 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef KITTY_WINDOW_H +#define KITTY_WINDOW_H + +#include "chunk.hpp" +#include "image.hpp" +#include "window.hpp" + +#include +#include +#include + +class Kitty : public Window +{ + public: + Kitty(std::unique_ptr new_image, std::mutex *stdout_mutex); + ~Kitty() override; + + void draw() override; + void generate_frame() override; + + private: + std::string str; + std::unique_ptr image; + std::mutex *stdout_mutex; + uint32_t id; + int x; + int y; + + auto process_chunks() -> std::vector; +}; + +#endif diff --git a/src/canvas/sixel.cpp b/src/canvas/sixel.cpp new file mode 100644 index 0000000..17bf1d4 --- /dev/null +++ b/src/canvas/sixel.cpp @@ -0,0 +1,96 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "sixel.hpp" +#include "dimensions.hpp" +#include "terminal.hpp" +#include "util.hpp" + +#include +#include + +namespace fs = std::filesystem; + +Sixel::Sixel(std::unique_ptr new_image, std::mutex *stdout_mutex) + : image(std::move(new_image)), + stdout_mutex(stdout_mutex) +{ + const auto dims = image->dimensions(); + x = dims.x + 1; + y = dims.y + 1; + horizontal_cells = std::ceil(static_cast(image->width()) / dims.terminal->font_width); + vertical_cells = std::ceil(static_cast(image->height()) / dims.terminal->font_height); + + const auto draw_callback = [](char *data, int size, void *priv) -> int { + auto *str = static_cast(priv); + str->append(data, size); + return size; + }; + sixel_output_new(&output, draw_callback, &str, nullptr); + + const auto file_size = fs::file_size(image->filename()); + constexpr auto reserve_ratio = 50; + str.reserve(file_size * reserve_ratio); + + // create dither and palette from image + sixel_dither_new(&dither, -1, nullptr); + sixel_dither_initialize(dither, const_cast(image->data()), image->width(), image->height(), + SIXEL_PIXELFORMAT_RGB888, SIXEL_LARGE_LUM, SIXEL_REP_CENTER_BOX, SIXEL_QUALITY_HIGH); +} + +Sixel::~Sixel() +{ + can_draw.store(false); + if (draw_thread.joinable()) { + draw_thread.join(); + } + sixel_dither_destroy(dither); + sixel_output_destroy(output); + + const std::scoped_lock lock{*stdout_mutex}; + util::clear_terminal_area(x, y, horizontal_cells, vertical_cells); +} + +void Sixel::draw() +{ + if (!image->is_animated()) { + generate_frame(); + return; + } + + // start drawing loop + draw_thread = std::thread([this] { + while (can_draw.load()) { + generate_frame(); + image->next_frame(); + std::this_thread::sleep_for(std::chrono::milliseconds(image->frame_delay())); + } + }); +} + +void Sixel::generate_frame() +{ + // output sixel content to stream + sixel_encode(const_cast(image->data()), image->width(), image->height(), 3 /*unused*/, dither, + output); + + const std::scoped_lock lock{*stdout_mutex}; + util::save_cursor_position(); + util::move_cursor(y, x); + std::cout << str << std::flush; + util::restore_cursor_position(); + str.clear(); +} diff --git a/src/canvas/sixel.hpp b/src/canvas/sixel.hpp new file mode 100644 index 0000000..a675f91 --- /dev/null +++ b/src/canvas/sixel.hpp @@ -0,0 +1,57 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef SIXEL_WINDOW_H +#define SIXEL_WINDOW_H + +#include "image.hpp" +#include "window.hpp" + +#include +#include +#include +#include +#include + +#include + +class Sixel : public Window +{ + public: + Sixel(std::unique_ptr new_image, std::mutex *stdout_mutex); + ~Sixel() override; + + void draw() override; + void generate_frame() override; + + private: + std::unique_ptr image; + std::mutex *stdout_mutex; + + std::string str; + std::thread draw_thread; + std::atomic can_draw{true}; + + int x; + int y; + int horizontal_cells = 0; + int vertical_cells = 0; + + sixel_dither_t *dither = nullptr; + sixel_output_t *output = nullptr; +}; + +#endif diff --git a/src/canvas/stdout.hpp b/src/canvas/stdout.hpp new file mode 100644 index 0000000..11a8ebb --- /dev/null +++ b/src/canvas/stdout.hpp @@ -0,0 +1,64 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef STDOUT_CANVAS_H +#define STDOUT_CANVAS_H + +#include "canvas.hpp" +#include "image.hpp" +#include "window.hpp" + +#include + +#include +#include +#include +#include + +template +class StdoutCanvas : public Canvas +{ + public: + explicit StdoutCanvas(const std::string &output) + { + logger = spdlog::get(output); + logger->info("Canvas created"); + } + + ~StdoutCanvas() override = default; + + void add_image(const std::string &identifier, std::unique_ptr new_image) override + { + logger->info("Displaying image with id {}", identifier); + images.erase(identifier); + const auto [entry, success] = + images.emplace(identifier, std::make_unique(std::move(new_image), &stdout_mutex)); + entry->second->draw(); + } + + void remove_image(const std::string &identifier) override + { + logger->info("Removing image with id {}", identifier); + images.erase(identifier); + } + + private: + std::mutex stdout_mutex; + std::shared_ptr logger; + std::unordered_map> images; +}; + +#endif diff --git a/src/canvas/wayland/config.cpp b/src/canvas/wayland/config.cpp new file mode 100644 index 0000000..4cd19e9 --- /dev/null +++ b/src/canvas/wayland/config.cpp @@ -0,0 +1,43 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "config.hpp" +#include "os.hpp" +#include "config/sway.hpp" +#include "config/hyprland.hpp" +#include "config/wayfire.hpp" +#include "config/dummy.hpp" + +auto WaylandConfig::get() -> std::unique_ptr +{ + const auto sway_sock = os::getenv("SWAYSOCK"); + if (sway_sock.has_value()) { + return std::make_unique(sway_sock.value()); + } + + const auto hypr_sig = os::getenv("HYPRLAND_INSTANCE_SIGNATURE"); + if (hypr_sig.has_value()) { + return std::make_unique(hypr_sig.value()); + } + + const auto wayfire_sock = os::getenv("WAYFIRE_SOCKET"); + if (wayfire_sock.has_value()) { + return std::make_unique(wayfire_sock.value()); + } + + return std::make_unique(); +} + diff --git a/src/canvas/wayland/config.hpp b/src/canvas/wayland/config.hpp new file mode 100644 index 0000000..c84e669 --- /dev/null +++ b/src/canvas/wayland/config.hpp @@ -0,0 +1,45 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYLAND_CONFIG_H +#define WAYLAND_CONFIG_H + +#include +#include +#include + +struct WaylandWindowGeometry { + int width; + int height; + int x; + int y; +}; + +class WaylandConfig +{ + public: + static auto get() -> std::unique_ptr; + + virtual ~WaylandConfig() = default; + + virtual auto get_focused_output_name() -> std::string = 0; + virtual auto get_window_info() -> struct WaylandWindowGeometry = 0; + virtual auto is_dummy() -> bool { return false; } + virtual void initial_setup(std::string_view appid) = 0; + virtual void move_window(std::string_view appid, int xcoord, int ycoord) = 0; +}; + +#endif diff --git a/src/canvas/wayland/config/dummy.cpp b/src/canvas/wayland/config/dummy.cpp new file mode 100644 index 0000000..d4b4297 --- /dev/null +++ b/src/canvas/wayland/config/dummy.cpp @@ -0,0 +1,29 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "dummy.hpp" + +auto DummyWaylandConfig::get_window_info() -> struct WaylandWindowGeometry +{ + return {}; +} + +void DummyWaylandConfig::initial_setup([[maybe_unused]] std::string_view appid) +{} + +void DummyWaylandConfig::move_window([[maybe_unused]] std::string_view appid, + [[maybe_unused]] int xcoord, [[maybe_unused]] int ycoord) +{} diff --git a/src/canvas/wayland/config/dummy.hpp b/src/canvas/wayland/config/dummy.hpp new file mode 100644 index 0000000..60b35c1 --- /dev/null +++ b/src/canvas/wayland/config/dummy.hpp @@ -0,0 +1,35 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef DUMMY_WAYLAND_CONFIG_H +#define DUMMY_WAYLAND_CONFIG_H + +#include "../config.hpp" + +class DummyWaylandConfig : public WaylandConfig +{ + public: + DummyWaylandConfig() = default; + ~DummyWaylandConfig() override = default; + + auto get_focused_output_name() -> std::string override { return {}; }; + auto get_window_info() -> struct WaylandWindowGeometry override; + auto is_dummy() -> bool override { return true; } + void initial_setup(std::string_view appid) override; + void move_window(std::string_view appid, int xcoord, int ycoord) override; +}; + +#endif diff --git a/src/canvas/wayland/config/hyprland.cpp b/src/canvas/wayland/config/hyprland.cpp new file mode 100644 index 0000000..42387fb --- /dev/null +++ b/src/canvas/wayland/config/hyprland.cpp @@ -0,0 +1,151 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "hyprland.hpp" +#include "os.hpp" +#include "tmux.hpp" +#include "util/socket.hpp" + +#include +#include +#include +#include + +using njson = nlohmann::json; +namespace fs = std::filesystem; + +HyprlandSocket::HyprlandSocket(const std::string_view signature) + : logger(spdlog::get("wayland")) +{ + const auto socket_base_dir = os::getenv("XDG_RUNTIME_DIR").value_or("/tmp"); + const auto socket_rel_path = fmt::format("hypr/{}/.socket.sock", signature); + socket_path = fmt::format("{}/{}", socket_base_dir, socket_rel_path); + // XDG_RUNTIME_DIR set but hyprland < 0.40 + if (!fs::exists(socket_path)) { + socket_path = fmt::format("/tmp/{}", socket_rel_path); + } + + logger->info("Using hyprland socket {}", socket_path); + const auto active = request_result("j/activewindow"); + address = active.at("address"); + set_active_monitor(); +} + +void HyprlandSocket::set_active_monitor() +{ + const auto monitors = request_result("j/monitors"); + for (const auto &monitor : monitors) { + bool focused = monitor.at("focused"); + if (focused) { + output_name = monitor.at("name"); + output_scale = monitor.at("scale"); + break; + } + } +} + +auto HyprlandSocket::get_focused_output_name() -> std::string +{ + return output_name; +} + +auto HyprlandSocket::request_result(const std::string_view payload) -> nlohmann::json +{ + const UnixSocket socket{socket_path}; + socket.write(payload.data(), payload.size()); + const std::string result = socket.read_until_empty(); + return njson::parse(result); +} + +void HyprlandSocket::request(const std::string_view payload) +{ + const UnixSocket socket{socket_path}; + logger->debug("Running socket command {}", payload); + socket.write(payload.data(), payload.length()); +} + +auto HyprlandSocket::get_active_window() -> nlohmann::json +{ + // recalculate address in case it changed + if (tmux::is_used()) { + const auto active = request_result("j/activewindow"); + address = active.at("address"); + } + const auto clients = request_result("j/clients"); + const auto client = ranges::find_if(clients, [this](const njson &json) { return json.at("address") == address; }); + if (client == clients.end()) { + throw std::runtime_error("Active window not found"); + } + return *client; +} + +auto HyprlandSocket::get_window_info() -> struct WaylandWindowGeometry { + const auto terminal = get_active_window(); + const auto &sizes = terminal.at("size"); + const auto &coords = terminal.at("at"); + + return { + .width = sizes.at(0), + .height = sizes.at(1), + .x = coords.at(0), + .y = coords.at(1), + }; +} + +void HyprlandSocket::initial_setup(const std::string_view appid) +{ + disable_focus(appid); + enable_floating(appid); + remove_borders(appid); + remove_rounding(appid); +} + +void HyprlandSocket::remove_rounding(const std::string_view appid) +{ + const auto payload = fmt::format("/keyword windowrulev2 rounding 0,title:{}", appid); + request(payload); +} + +void HyprlandSocket::disable_focus(const std::string_view appid) +{ + const auto payload = fmt::format("/keyword windowrulev2 nofocus,title:{}", appid); + request(payload); +} + +void HyprlandSocket::enable_floating(const std::string_view appid) +{ + const auto payload = fmt::format("/keyword windowrulev2 float,title:{}", appid); + request(payload); +} + +void HyprlandSocket::remove_borders(const std::string_view appid) +{ + const auto payload = fmt::format("/keyword windowrulev2 noborder,title:{}", appid); + request(payload); +} + +void HyprlandSocket::move_window(const std::string_view appid, int xcoord, int ycoord) +{ + int res_x = xcoord; + int res_y = ycoord; + if (output_scale > 1.0F) { + const int offset = 10; + res_x = res_x / 2 + offset; + res_y = res_y / 2 + offset; + } + const auto payload = fmt::format("/dispatch movewindowpixel exact {} {},title:{}", res_x, res_y, appid); + request(payload); +} diff --git a/src/canvas/wayland/config/hyprland.hpp b/src/canvas/wayland/config/hyprland.hpp new file mode 100644 index 0000000..4353d98 --- /dev/null +++ b/src/canvas/wayland/config/hyprland.hpp @@ -0,0 +1,53 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef HYPRLAND_SOCKET_H +#define HYPRLAND_SOCKET_H + +#include "../config.hpp" + +#include +#include + +class HyprlandSocket : public WaylandConfig +{ + public: + explicit HyprlandSocket(std::string_view signature); + ~HyprlandSocket() override = default; + + auto get_window_info() -> struct WaylandWindowGeometry override; + auto get_focused_output_name() -> std::string override; + void initial_setup(std::string_view appid) override; + void move_window(std::string_view appid, int xcoord, int ycoord) override; + + private: + void disable_focus(std::string_view appid); + void enable_floating(std::string_view appid); + void remove_borders(std::string_view appid); + void remove_rounding(std::string_view appid); + void request(std::string_view payload); + auto request_result(std::string_view payload) -> nlohmann::json; + auto get_active_window() -> nlohmann::json; + void set_active_monitor(); + + std::shared_ptr logger; + std::string socket_path; + std::string address; + std::string output_name; + float output_scale = 1.0F; +}; + +#endif diff --git a/src/canvas/wayland/config/sway.cpp b/src/canvas/wayland/config/sway.cpp new file mode 100644 index 0000000..85bff0c --- /dev/null +++ b/src/canvas/wayland/config/sway.cpp @@ -0,0 +1,183 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "sway.hpp" +#include "application.hpp" +#include "os.hpp" +#include "tmux.hpp" +#include "util.hpp" + +#include +#include +#include +#include + +#include +#include + +using njson = nlohmann::json; + +constexpr auto ipc_magic = std::string_view{"i3-ipc"}; +constexpr auto ipc_header_size = ipc_magic.size() + 8; + +SwaySocket::SwaySocket(const std::string_view endpoint) + : socket(endpoint), + logger(spdlog::get("wayland")) +{ + logger->info("Using sway socket {}", endpoint); + set_active_output_info(); +} + +struct __attribute__((packed)) ipc_header { + std::array magic; + uint32_t len; + uint32_t type; +}; + +auto SwaySocket::get_window_info() -> struct WaylandWindowGeometry { + const auto nodes = get_nodes(); + const auto window = get_active_window(nodes); + const auto &rect = window.at("rect"); + return {.width = rect.at("width"), + .height = rect.at("height"), + .x = rect.at("x").get() - output_info.x, + .y = rect.at("y").get() - output_info.y}; +} + +auto SwaySocket::get_active_window(const std::vector& nodes) -> nlohmann::json +{ + const auto pids = tmux::get_client_pids().value_or(std::vector{Application::parent_pid}); + + for (const auto pid : pids) { + const auto tree = util::get_process_tree(pid); + const auto found = ranges::find_if(nodes, [&tree](const njson &json) -> bool { + try { + return ranges::find(tree, json.at("pid").get()) != tree.end(); + } catch (const njson::out_of_range &err) { + return false; + } + }); + if (found != nodes.end()) { + return *found; + } + } + return nullptr; +} + +auto SwaySocket::get_focused_output_name() -> std::string +{ + return output_info.name; +}; + +void SwaySocket::set_active_output_info() +{ + const auto outputs = ipc_message(IPC_GET_OUTPUTS); + for (const auto &node : outputs) { + bool focused = node.at("focused"); + if (focused) { + const auto &rect = node.at("rect"); + output_info = { + .x = rect.at("x"), + .y = rect.at("y"), + .scale = node.at("scale"), + .name = node.at("name"), + }; + break; + } + } +} + +void SwaySocket::initial_setup(const std::string_view appid) +{ + disable_focus(appid); + enable_floating(appid); +} + +void SwaySocket::disable_focus(const std::string_view appid) +{ + const auto payload = fmt::format(R"(no_focus [app_id="{}"])", appid); + ipc_command(payload); +} + +void SwaySocket::enable_floating(const std::string_view appid) +{ + ipc_command(appid, "floating enable"); +} + +void SwaySocket::move_window(const std::string_view appid, int xcoord, int ycoord) +{ + int res_x = xcoord; + int res_y = ycoord; + if (output_info.scale > 1.0F) { + res_x = res_x / 2; + res_y = res_y / 2; + } + const auto payload = fmt::format(R"([app_id="{}"] move position {} {})", appid, res_x, res_y); + ipc_command(payload); +} + +auto SwaySocket::ipc_message(ipc_message_type type, const std::string_view payload) const -> nlohmann::json +{ + struct ipc_header header; + header.len = payload.size(); + header.type = type; + ipc_magic.copy(header.magic.data(), ipc_magic.size()); + + if (!payload.empty()) { + logger->debug("Running socket command {}", payload); + } + socket.write(&header, ipc_header_size); + socket.write(payload.data(), payload.size()); + + socket.read(&header, ipc_header_size); + std::string buff(header.len, 0); + socket.read(buff.data(), buff.size()); + return njson::parse(buff); +} + +auto SwaySocket::get_nodes() const -> std::vector +{ + logger->debug("Obtaining sway tree"); + const auto tree = ipc_message(IPC_GET_TREE); + std::stack nodes_st; + std::vector nodes_vec; + + nodes_st.push(tree); + + while (!nodes_st.empty()) { + const auto top = nodes_st.top(); + nodes_st.pop(); + nodes_vec.push_back(top); + for (const auto &node : top.at("nodes")) { + nodes_st.push(node); + } + for (const auto &node : top.at("floating_nodes")) { + nodes_st.push(node); + } + } + return nodes_vec; +} + +void SwaySocket::ipc_command(const std::string_view appid, const std::string_view command) const +{ + const auto payload = fmt::format(R"(for_window [app_id="{}"] {})", appid, command); + ipc_command(payload); +} + +void SwaySocket::ipc_command(const std::string_view payload) const +{ + std::ignore = ipc_message(IPC_COMMAND, payload); +} diff --git a/src/canvas/wayland/config/sway.hpp b/src/canvas/wayland/config/sway.hpp new file mode 100644 index 0000000..9ac4d69 --- /dev/null +++ b/src/canvas/wayland/config/sway.hpp @@ -0,0 +1,62 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef SWAY_SOCKET_H +#define SWAY_SOCKET_H + +#include "../config.hpp" +#include "util/socket.hpp" + +#include +#include + +enum ipc_message_type { IPC_COMMAND = 0, IPC_GET_WORKSPACES = 1, IPC_GET_OUTPUTS = 3, IPC_GET_TREE = 4 }; + +struct SwayOutputInfo { + int x; + int y; + float scale; + std::string name; +}; + +class SwaySocket : public WaylandConfig +{ + public: + explicit SwaySocket(std::string_view endpoint); + ~SwaySocket() override = default; + + auto get_focused_output_name() -> std::string override; + auto get_window_info() -> struct WaylandWindowGeometry override; + void initial_setup(std::string_view appid) override; + void move_window(std::string_view appid, int xcoord, int ycoord) override; + static auto get_active_window(const std::vector &nodes) -> nlohmann::json; + + private: + void disable_focus(std::string_view appid); + void enable_floating(std::string_view appid); + void ipc_command(std::string_view appid, std::string_view command) const; + void ipc_command(std::string_view payload) const; + void set_active_output_info(); + + [[nodiscard]] auto get_nodes() const -> std::vector; + [[nodiscard]] auto ipc_message(ipc_message_type type, std::string_view payload = "") const -> nlohmann::json; + + UnixSocket socket; + std::shared_ptr logger; + struct SwayOutputInfo output_info; +}; + +#endif diff --git a/src/canvas/wayland/config/wayfire.cpp b/src/canvas/wayland/config/wayfire.cpp new file mode 100644 index 0000000..efde546 --- /dev/null +++ b/src/canvas/wayland/config/wayfire.cpp @@ -0,0 +1,73 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "wayfire.hpp" + +using njson = nlohmann::json; + +WayfireSocket::WayfireSocket(const std::string_view endpoint): +socket(endpoint), +logger(spdlog::get("wayland")) +{ + logger->info("Using wayfire socket {}", endpoint); +} + +auto WayfireSocket::get_window_info() -> struct WaylandWindowGeometry +{ + const auto response = request("window-rules/get-focused-view"); + const auto& info = response.at("info"); + const auto& geometry = info.at("geometry"); + const int decoration_height = 25; + return { + .width = geometry.at("width"), + .height = geometry.at("height").get() - decoration_height, + .x = 0, + .y = 0 + }; +} + +void WayfireSocket::initial_setup([[maybe_unused]] const std::string_view appid) +{ + // all is handled by the ueberzug plugin +} + +void WayfireSocket::move_window(const std::string_view appid, int xcoord, int ycoord) +{ + const njson payload_data = { + {"app-id", appid}, + {"x", xcoord}, + {"y", ycoord} + }; + std::ignore = request("ueberzugpp/set_offset", payload_data); +} + +auto WayfireSocket::request(const std::string_view method, const njson& data) const -> njson +{ + const njson json = { + {"method", method}, + {"data", data} + }; + const auto payload = json.dump(); + const uint32_t payload_size = payload.length(); + socket.write(&payload_size, sizeof(uint32_t)); + socket.write(payload.c_str(), payload_size); + + uint32_t response_size = 0; + socket.read(&response_size, sizeof(uint32_t)); + std::string buffer (response_size, 0); + socket.read(buffer.data(), response_size); + return njson::parse(buffer); +} diff --git a/src/canvas/wayland/config/wayfire.hpp b/src/canvas/wayland/config/wayfire.hpp new file mode 100644 index 0000000..e1e83eb --- /dev/null +++ b/src/canvas/wayland/config/wayfire.hpp @@ -0,0 +1,44 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYFIRE_SOCKET_H +#define WAYFIRE_SOCKET_H + +#include "../config.hpp" +#include "util/socket.hpp" + +#include +#include + +class WayfireSocket : public WaylandConfig +{ + public: + explicit WayfireSocket(std::string_view endpoint); + ~WayfireSocket() override = default; + + auto get_window_info() -> struct WaylandWindowGeometry override; + auto get_focused_output_name() -> std::string override { return {}; }; + void initial_setup(std::string_view appid) override; + void move_window(std::string_view appid, int xcoord, int ycoord) override; + + private: + [[nodiscard]] auto request(std::string_view method, const nlohmann::json &data = {}) const -> nlohmann::json; + + UnixSocket socket; + std::shared_ptr logger; +}; + +#endif diff --git a/src/canvas/wayland/wayland.cpp b/src/canvas/wayland/wayland.cpp new file mode 100644 index 0000000..9e2a642 --- /dev/null +++ b/src/canvas/wayland/wayland.cpp @@ -0,0 +1,222 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "wayland.hpp" +#include "application.hpp" +#include "image.hpp" +#include "os.hpp" +#include "util.hpp" + +#ifdef ENABLE_OPENGL +# include "window/waylandegl.hpp" +# include +#endif +#include "window/waylandshm.hpp" + +constexpr struct wl_registry_listener registry_listener = {.global = WaylandCanvas::registry_handle_global, + .global_remove = [](auto...) { /*unused*/ }}; + +constexpr struct xdg_wm_base_listener xdg_wm_base_listener = {.ping = WaylandCanvas::xdg_wm_base_ping}; + +constexpr struct wl_output_listener wl_output_listener = {.geometry = [](auto...) { /*unused*/ }, + .mode = [](auto...) { /*unused*/ }, + .done = WaylandCanvas::output_done, + .scale = WaylandCanvas::output_scale, + .name = WaylandCanvas::output_name, + .description = [](auto...) { /*unused*/ }}; + +void WaylandCanvas::registry_handle_global(void *data, wl_registry *registry, uint32_t name, const char *interface, + [[maybe_unused]] uint32_t version) +{ + const std::string_view interface_str{interface}; +#ifdef WSL + const uint32_t compositor_ver = 4; + const uint32_t shm_ver = 1; + const uint32_t xdg_base_ver = 1; + const uint32_t output_ver = 3; +#else + const uint32_t compositor_ver = 5; + const uint32_t shm_ver = 1; + const uint32_t xdg_base_ver = 2; + const uint32_t output_ver = 4; +#endif + + auto *canvas = static_cast(data); + if (interface_str == wl_compositor_interface.name) { + canvas->compositor = static_cast( + wl_registry_bind(registry, name, &wl_compositor_interface, compositor_ver)); + } else if (interface_str == wl_shm_interface.name) { + canvas->wl_shm = static_cast(wl_registry_bind(registry, name, &wl_shm_interface, shm_ver)); + } else if (interface_str == xdg_wm_base_interface.name) { + canvas->xdg_base = + static_cast(wl_registry_bind(registry, name, &xdg_wm_base_interface, xdg_base_ver)); + xdg_wm_base_add_listener(canvas->xdg_base, &xdg_wm_base_listener, canvas); + } else if (interface_str == wl_output_interface.name) { + auto *output = + static_cast(wl_registry_bind(registry, name, &wl_output_interface, output_ver)); + wl_output_add_listener(output, &wl_output_listener, canvas); + } +} + +void WaylandCanvas::xdg_wm_base_ping([[maybe_unused]] void *data, struct xdg_wm_base *xdg_wm_base, uint32_t serial) +{ + xdg_wm_base_pong(xdg_wm_base, serial); +} + +void WaylandCanvas::output_name(void *data, [[maybe_unused]] struct wl_output *output, const char *name) +{ + auto *canvas = static_cast(data); + canvas->output_pair.first = name; +} + +void WaylandCanvas::output_scale(void *data, [[maybe_unused]] struct wl_output *output, int32_t scale) +{ + auto *canvas = static_cast(data); + canvas->output_pair.second = scale; +} + +void WaylandCanvas::output_done(void *data, [[maybe_unused]] struct wl_output *output) +{ + auto *canvas = static_cast(data); + const auto active_output = canvas->config->get_focused_output_name(); + if (active_output == canvas->output_pair.first) { + canvas->flags->scale_factor = canvas->output_pair.second; + canvas->flags->needs_scaling = canvas->output_pair.second > 1; + } + canvas->output_info.insert(canvas->output_pair); +} + +WaylandCanvas::WaylandCanvas() + : display(wl_display_connect(nullptr)) +{ + if (display == nullptr) { + throw std::runtime_error("Failed to connect to wayland display."); + } + logger = spdlog::get("wayland"); + flags = Flags::instance(); + config = WaylandConfig::get(); + registry = wl_display_get_registry(display); + wl_registry_add_listener(registry, ®istry_listener, this); + wl_display_roundtrip(display); + event_handler = std::thread(&WaylandCanvas::handle_events, this); + +#ifdef ENABLE_OPENGL + if (flags->use_opengl) { + try { + egl = std::make_unique>(EGL_PLATFORM_WAYLAND_EXT, display); + } catch (const std::runtime_error &) { + egl_available = false; + } + } else { + egl_available = false; + } +#endif + + logger->info("Canvas created"); +} + +void WaylandCanvas::show() +{ + for (const auto &[key, value] : windows) { + value->show(); + } +} + +void WaylandCanvas::hide() +{ + for (const auto &[key, value] : windows) { + value->hide(); + } +} + +WaylandCanvas::~WaylandCanvas() +{ + windows.clear(); + if (event_handler.joinable()) { + event_handler.join(); + } + +#ifdef ENABLE_OPENGL + egl.reset(); +#endif + + if (wl_shm != nullptr) { + wl_shm_destroy(wl_shm); + } + if (compositor != nullptr) { + wl_compositor_destroy(compositor); + } + if (registry != nullptr) { + wl_registry_destroy(registry); + } + wl_display_disconnect(display); +} + +void WaylandCanvas::add_image(const std::string &identifier, std::unique_ptr new_image) +{ + std::shared_ptr window; +#ifdef ENABLE_OPENGL + if (egl_available) { + try { + window = std::make_shared(compositor, xdg_base, egl.get(), std::move(new_image), + config.get(), &xdg_agg); + } catch (const std::runtime_error &err) { + return; + } + } +#endif + if (window == nullptr) { + window = std::make_shared(this, std::move(new_image), &xdg_agg, config.get()); + } + + window->finish_init(); + windows.insert_or_assign(identifier, std::move(window)); +} + +void WaylandCanvas::handle_events() +{ + const auto wl_fd = wl_display_get_fd(display); + bool in_event = false; + + while (!Application::stop_flag) { + // prepare to read wayland events + while (wl_display_prepare_read(display) != 0) { + wl_display_dispatch_pending(display); + } + wl_display_flush(display); + + try { + constexpr int waitms = 100; + in_event = os::wait_for_data_on_fd(wl_fd, waitms); + } catch (const std::system_error &err) { + Application::stop_flag = true; + break; + } + + if (in_event) { + wl_display_read_events(display); + wl_display_dispatch_pending(display); + } else { + wl_display_cancel_read(display); + } + } +} + +void WaylandCanvas::remove_image(const std::string &identifier) +{ + windows.erase(identifier); + wl_display_flush(display); +} diff --git a/src/canvas/wayland/wayland.hpp b/src/canvas/wayland/wayland.hpp new file mode 100644 index 0000000..e2016df --- /dev/null +++ b/src/canvas/wayland/wayland.hpp @@ -0,0 +1,84 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYLAND_CANVAS_H +#define WAYLAND_CANVAS_H + +#include "canvas.hpp" +#include "config.hpp" +#include "flags.hpp" +#include "wayland-xdg-shell-client-protocol.h" +#include "window/waylandwindow.hpp" + +#include +#include +#include + +#include +#include + +#ifdef ENABLE_OPENGL +# include "util/egl.hpp" +# include +#endif + +class WaylandCanvas : public Canvas +{ + public: + explicit WaylandCanvas(); + ~WaylandCanvas() override; + + static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, + uint32_t version); + static void xdg_wm_base_ping(void *data, struct xdg_wm_base *xdg_wm_base, uint32_t serial); + + static void output_scale(void *data, struct wl_output *output, int32_t scale); + static void output_name(void *data, struct wl_output *output, const char *name); + static void output_done(void *data, struct wl_output *output); + + void add_image(const std::string &identifier, std::unique_ptr new_image) override; + void remove_image(const std::string &identifier) override; + void show() override; + void hide() override; + + struct wl_compositor *compositor = nullptr; + struct wl_shm *wl_shm = nullptr; + struct xdg_wm_base *xdg_base = nullptr; + + std::pair output_pair; + std::unordered_map output_info; + + private: + struct wl_display *display = nullptr; + struct wl_registry *registry = nullptr; + std::thread event_handler; + + std::shared_ptr logger; + std::unique_ptr config; + std::shared_ptr flags; + std::unordered_map> windows; + +#ifdef ENABLE_OPENGL + std::unique_ptr> egl; + bool egl_available = true; +#endif + + struct XdgStructAgg xdg_agg; + + void handle_events(); +}; + +#endif diff --git a/src/canvas/wayland/window/shm.cpp b/src/canvas/wayland/window/shm.cpp new file mode 100644 index 0000000..461267d --- /dev/null +++ b/src/canvas/wayland/window/shm.cpp @@ -0,0 +1,75 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "shm.hpp" +#include "util.hpp" +#include "util/ptr.hpp" + +#include +#include +#include +#include + +#include + +#include +#include + +WaylandShm::WaylandShm(int width, int height, int scale_factor, struct wl_shm *shm) + : shm(shm), + width(width), + height(height), + stride(width * 4), + pool_size(height * stride * scale_factor) +{ + const int path_size = 32; + shm_path = fmt::format("/{}", util::generate_random_string(path_size)); + create_shm_file(); + allocate_pool_buffers(); +} + +void WaylandShm::create_shm_file() +{ + fd = memfd_create("ueberzugpp-shm", 0); + if (fd == -1) { + throw std::system_error(errno, std::system_category()); + } + int res = ftruncate(fd, pool_size); + if (res == -1) { + throw std::system_error(errno, std::system_category()); + } + auto *pool_ptr = mmap(nullptr, pool_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (pool_ptr == MAP_FAILED) { + throw std::system_error(errno, std::system_category()); + } + pool_data = static_cast(pool_ptr); +} + +void WaylandShm::allocate_pool_buffers() +{ + const auto pool = c_unique_ptr{wl_shm_create_pool(shm, fd, pool_size)}; + buffer = wl_shm_pool_create_buffer(pool.get(), 0, width, height, stride, WL_SHM_FORMAT_ARGB8888); +} + +WaylandShm::~WaylandShm() +{ + shm_unlink(shm_path.c_str()); + close(fd); + munmap(pool_data, pool_size); + if (buffer != nullptr) { + wl_buffer_destroy(buffer); + } +} diff --git a/src/canvas/wayland/window/shm.hpp b/src/canvas/wayland/window/shm.hpp new file mode 100644 index 0000000..fca1f88 --- /dev/null +++ b/src/canvas/wayland/window/shm.hpp @@ -0,0 +1,47 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYLAND_SHM_H +#define WAYLAND_SHM_H + +#include +#include + +class WaylandShm +{ + public: + WaylandShm(int width, int height, int scale_factor, struct wl_shm *shm); + ~WaylandShm(); + + struct wl_buffer *buffer = nullptr; + uint8_t *pool_data; + + private: + void create_shm_file(); + void allocate_pool_buffers(); + + struct wl_shm *shm = nullptr; + + int fd = 0; + std::string shm_path; + + int width = 0; + int height = 0; + int stride = 0; + int pool_size = 0; +}; + +#endif diff --git a/src/canvas/wayland/window/waylandegl.cpp b/src/canvas/wayland/window/waylandegl.cpp new file mode 100644 index 0000000..3545d20 --- /dev/null +++ b/src/canvas/wayland/window/waylandegl.cpp @@ -0,0 +1,235 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "waylandegl.hpp" +#include "dimensions.hpp" +#include "util.hpp" + +#include +#include + +constexpr int id_len = 10; + +constexpr struct xdg_surface_listener xdg_surface_listener_egl = { + .configure = WaylandEglWindow::xdg_surface_configure, +}; + +constexpr struct wl_callback_listener frame_listener_egl = {.done = WaylandEglWindow::wl_surface_frame_done}; + +WaylandEglWindow::WaylandEglWindow(struct wl_compositor *compositor, struct xdg_wm_base *xdg_base, + const EGLUtil *egl, + std::unique_ptr new_image, WaylandConfig *new_config, + struct XdgStructAgg *xdg_agg) + : compositor(compositor), + xdg_base(xdg_base), + surface(wl_compositor_create_surface(compositor)), + xdg_surface(xdg_wm_base_get_xdg_surface(xdg_base, surface)), + xdg_toplevel(xdg_surface_get_toplevel(xdg_surface)), + image(std::move(new_image)), + config(new_config), + egl_window(wl_egl_window_create(surface, image->width(), image->height())), + egl(egl), + appid(fmt::format("ueberzugpp_{}", util::generate_random_string(id_len))), + xdg_agg(xdg_agg) +{ + config->initial_setup(appid); + opengl_setup(); + xdg_setup(); +} + +WaylandEglWindow::~WaylandEglWindow() +{ + opengl_cleanup(); + delete_xdg_structs(); + delete_wayland_structs(); +} + +void WaylandEglWindow::opengl_cleanup() +{ + egl->run_contained(egl_context, egl_surface, [this] { + glDeleteTextures(1, &texture); + glDeleteFramebuffers(1, &fbo); + }); + eglDestroySurface(egl->display, egl_surface); + eglDestroyContext(egl->display, egl_context); +} + +void WaylandEglWindow::finish_init() +{ + auto xdg = std::make_unique(); + xdg->ptr = weak_from_this(); + this_ptr = xdg.get(); + xdg_agg->ptrs.push_back(std::move(xdg)); + setup_listeners(); + visible = true; +} + +void WaylandEglWindow::opengl_setup() +{ + egl_surface = egl->create_surface(egl_window); + if (egl_surface == EGL_NO_SURFACE) { + throw std::runtime_error(""); + } + + egl_context = egl->create_context(egl_surface); + if (egl_context == EGL_NO_CONTEXT) { + throw std::runtime_error(""); + } + + egl->run_contained(egl_surface, egl_context, [this] { + eglSwapInterval(egl->display, 0); + glGenFramebuffers(1, &fbo); + glGenTextures(1, &texture); + }); +} + +void WaylandEglWindow::setup_listeners() +{ + xdg_surface_add_listener(xdg_surface, &xdg_surface_listener_egl, this_ptr); + wl_surface_commit(surface); + + if (image->is_animated()) { + callback = wl_surface_frame(surface); + wl_callback_add_listener(callback, &frame_listener_egl, this_ptr); + } +} + +void WaylandEglWindow::xdg_setup() +{ + xdg_toplevel_set_app_id(xdg_toplevel, appid.c_str()); + xdg_toplevel_set_title(xdg_toplevel, appid.c_str()); +} + +void WaylandEglWindow::delete_xdg_structs() +{ + if (xdg_toplevel != nullptr) { + xdg_toplevel_destroy(xdg_toplevel); + xdg_toplevel = nullptr; + } + if (xdg_surface != nullptr) { + xdg_surface_destroy(xdg_surface); + xdg_surface = nullptr; + } +} + +void WaylandEglWindow::delete_wayland_structs() +{ + if (egl_window != nullptr) { + wl_egl_window_destroy(egl_window); + egl_window = nullptr; + } + if (surface != nullptr) { + wl_surface_destroy(surface); + surface = nullptr; + } +} + +void WaylandEglWindow::draw() +{ + load_framebuffer(); + + wl_surface_commit(surface); + move_window(); +} + +void WaylandEglWindow::load_framebuffer() +{ + std::scoped_lock lock{egl_mutex}; + egl->run_contained(egl_surface, egl_context, [this] { + egl->get_texture_from_image(*image, texture); + glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo); + glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); + glBlitFramebuffer(0, 0, image->width(), image->height(), 0, 0, image->width(), image->height(), + GL_COLOR_BUFFER_BIT, GL_NEAREST); + + eglSwapBuffers(egl->display, egl_surface); + }); +} + +void WaylandEglWindow::move_window() +{ + const auto dims = image->dimensions(); + const auto cur_window = config->get_window_info(); + const int wayland_x = dims.xpixels() + dims.padding_horizontal; + const int wayland_y = dims.ypixels() + dims.padding_vertical; + const int xcoord = cur_window.x + wayland_x; + const int ycoord = cur_window.y + wayland_y; + config->move_window(appid, xcoord, ycoord); +} + +void WaylandEglWindow::generate_frame() +{ + std::this_thread::sleep_for(std::chrono::milliseconds(image->frame_delay())); + callback = wl_surface_frame(surface); + wl_callback_add_listener(callback, &frame_listener_egl, this_ptr); + + image->next_frame(); + load_framebuffer(); + + wl_surface_commit(surface); +} + +void WaylandEglWindow::show() +{ + if (visible) { + return; + } + visible = true; + xdg_surface = xdg_wm_base_get_xdg_surface(xdg_base, surface); + xdg_toplevel = xdg_surface_get_toplevel(xdg_surface); + xdg_setup(); + setup_listeners(); +} + +void WaylandEglWindow::hide() +{ + if (!visible) { + return; + } + visible = false; + const std::scoped_lock lock{draw_mutex}; + delete_xdg_structs(); + wl_surface_attach(surface, nullptr, 0, 0); + wl_surface_commit(surface); +} + +void WaylandEglWindow::xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) +{ + xdg_surface_ack_configure(xdg_surface, serial); + const auto *tmp = static_cast(data); + const auto window = tmp->ptr.lock(); + if (!window) { + return; + } + auto *egl_window = dynamic_cast(window.get()); + egl_window->draw(); +} + +void WaylandEglWindow::wl_surface_frame_done(void *data, struct wl_callback *callback, [[maybe_unused]] uint32_t time) +{ + wl_callback_destroy(callback); + const auto *tmp = static_cast(data); + const auto window = tmp->ptr.lock(); + if (!window) { + return; + } + auto *egl_window = dynamic_cast(window.get()); + const std::scoped_lock lock{egl_window->draw_mutex}; + if (!egl_window->visible) { + return; + } + egl_window->generate_frame(); +} diff --git a/src/canvas/wayland/window/waylandegl.hpp b/src/canvas/wayland/window/waylandegl.hpp new file mode 100644 index 0000000..768e57f --- /dev/null +++ b/src/canvas/wayland/window/waylandegl.hpp @@ -0,0 +1,88 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYLAND_EGL_WINDOW_H +#define WAYLAND_EGL_WINDOW_H + +#include "../config.hpp" +#include "image.hpp" +#include "util/egl.hpp" +#include "wayland-xdg-shell-client-protocol.h" +#include "waylandwindow.hpp" + +#include +#include + +#include +#include + +class WaylandEglWindow : public WaylandWindow +{ + public: + WaylandEglWindow(struct wl_compositor *compositor, struct xdg_wm_base *xdg_base, + const EGLUtil *egl, std::unique_ptr new_image, + WaylandConfig *new_config, struct XdgStructAgg *xdg_agg); + ~WaylandEglWindow() override; + static void xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial); + static void wl_surface_frame_done(void *data, struct wl_callback *callback, uint32_t time); + + void draw() override; + void generate_frame() override; + void show() override; + void hide() override; + + void finish_init() override; + + private: + struct wl_compositor *compositor; + struct xdg_wm_base *xdg_base; + + struct wl_surface *surface = nullptr; + struct xdg_surface *xdg_surface = nullptr; + struct xdg_toplevel *xdg_toplevel = nullptr; + struct wl_callback *callback; + + std::unique_ptr image; + WaylandConfig *config; + + EGLSurface egl_surface; + EGLContext egl_context; + + struct wl_egl_window *egl_window = nullptr; + const EGLUtil *egl; + + GLuint texture; + GLuint fbo; + + std::mutex draw_mutex; + std::mutex egl_mutex; + + std::string appid; + void *this_ptr; + struct XdgStructAgg *xdg_agg; + bool visible = false; + + void move_window(); + void delete_wayland_structs(); + void delete_xdg_structs(); + + void opengl_cleanup(); + void xdg_setup(); + void setup_listeners(); + void opengl_setup(); + void load_framebuffer(); +}; +#endif diff --git a/src/canvas/wayland/window/waylandshm.cpp b/src/canvas/wayland/window/waylandshm.cpp new file mode 100644 index 0000000..1ee5994 --- /dev/null +++ b/src/canvas/wayland/window/waylandshm.cpp @@ -0,0 +1,186 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "waylandshm.hpp" +#include "dimensions.hpp" +#include "shm.hpp" +#include "util.hpp" + +#include + +constexpr int id_len = 10; + +constexpr struct xdg_surface_listener xdg_surface_listener = { + .configure = WaylandShmWindow::xdg_surface_configure, +}; + +constexpr struct wl_callback_listener frame_listener = {.done = WaylandShmWindow::wl_surface_frame_done}; + +void WaylandShmWindow::xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) +{ + xdg_surface_ack_configure(xdg_surface, serial); + const auto *tmp = static_cast(data); + const auto window = tmp->ptr.lock(); + if (!window) { + return; + } + auto *shm_window = dynamic_cast(window.get()); + shm_window->wl_draw(shm_window->output_scale); +} + +void WaylandShmWindow::wl_surface_frame_done(void *data, struct wl_callback *callback, [[maybe_unused]] uint32_t time) +{ + wl_callback_destroy(callback); + const auto *tmp = static_cast(data); + const auto window = tmp->ptr.lock(); + if (!window) { + return; + } + auto *shm_window = dynamic_cast(window.get()); + const std::scoped_lock lock{shm_window->draw_mutex}; + if (!shm_window->visible) { + return; + } + shm_window->generate_frame(); +} + +WaylandShmWindow::WaylandShmWindow(WaylandCanvas *canvas, std::unique_ptr new_image, + struct XdgStructAgg *xdg_agg, WaylandConfig *config) + : config(config), + xdg_base(canvas->xdg_base), + surface(wl_compositor_create_surface(canvas->compositor)), + xdg_surface(xdg_wm_base_get_xdg_surface(xdg_base, surface)), + xdg_toplevel(xdg_surface_get_toplevel(xdg_surface)), + image(std::move(new_image)), + appid(fmt::format("ueberzugpp_{}", util::generate_random_string(id_len))), + xdg_agg(xdg_agg) +{ + config->initial_setup(appid); + xdg_setup(); + output_scale = canvas->output_info.at(config->get_focused_output_name()); + shm = std::make_unique(image->width(), image->height(), output_scale, canvas->wl_shm); +} + +void WaylandShmWindow::finish_init() +{ + auto xdg = std::make_unique(); + xdg->ptr = weak_from_this(); + this_ptr = xdg.get(); + xdg_agg->ptrs.push_back(std::move(xdg)); + + setup_listeners(); + visible = true; +} + +void WaylandShmWindow::setup_listeners() +{ + xdg_surface_add_listener(xdg_surface, &xdg_surface_listener, this_ptr); + wl_surface_commit(surface); + + if (image->is_animated()) { + callback = wl_surface_frame(surface); + wl_callback_add_listener(callback, &frame_listener, this_ptr); + } +} + +void WaylandShmWindow::xdg_setup() +{ + xdg_toplevel_set_app_id(xdg_toplevel, appid.c_str()); + xdg_toplevel_set_title(xdg_toplevel, appid.c_str()); +} + +WaylandShmWindow::~WaylandShmWindow() +{ + delete_xdg_structs(); + delete_wayland_structs(); +} + +void WaylandShmWindow::wl_draw(int32_t scale_factor) +{ + std::memcpy(shm->pool_data, image->data(), image->size()); + wl_surface_attach(surface, shm->buffer, 0, 0); + wl_surface_set_buffer_scale(surface, scale_factor); + wl_surface_commit(surface); + move_window(); +} + +void WaylandShmWindow::show() +{ + if (visible) { + return; + } + visible = true; + xdg_surface = xdg_wm_base_get_xdg_surface(xdg_base, surface); + xdg_toplevel = xdg_surface_get_toplevel(xdg_surface); + xdg_setup(); + setup_listeners(); +} + +void WaylandShmWindow::hide() +{ + if (!visible) { + return; + } + visible = false; + const std::scoped_lock lock{draw_mutex}; + delete_xdg_structs(); + wl_surface_attach(surface, nullptr, 0, 0); + wl_surface_commit(surface); +} + +void WaylandShmWindow::delete_xdg_structs() +{ + if (xdg_toplevel != nullptr) { + xdg_toplevel_destroy(xdg_toplevel); + xdg_toplevel = nullptr; + } + if (xdg_surface != nullptr) { + xdg_surface_destroy(xdg_surface); + xdg_surface = nullptr; + } +} + +void WaylandShmWindow::delete_wayland_structs() +{ + if (surface != nullptr) { + wl_surface_destroy(surface); + surface = nullptr; + } +} + +void WaylandShmWindow::move_window() +{ + const auto dims = image->dimensions(); + const auto cur_window = config->get_window_info(); + const int wayland_x = dims.xpixels() + dims.padding_horizontal; + const int wayland_y = dims.ypixels() + dims.padding_vertical; + const int xcoord = cur_window.x + wayland_x; + const int ycoord = cur_window.y + wayland_y; + config->move_window(appid, xcoord, ycoord); +} + +void WaylandShmWindow::generate_frame() +{ + std::this_thread::sleep_for(std::chrono::milliseconds(image->frame_delay())); + callback = wl_surface_frame(surface); + wl_callback_add_listener(callback, &frame_listener, this_ptr); + + image->next_frame(); + std::memcpy(shm->pool_data, image->data(), image->size()); + wl_surface_attach(surface, shm->buffer, 0, 0); + wl_surface_damage_buffer(surface, 0, 0, image->width(), image->height()); + wl_surface_commit(surface); +} diff --git a/src/canvas/wayland/window/waylandshm.hpp b/src/canvas/wayland/window/waylandshm.hpp new file mode 100644 index 0000000..f275c4c --- /dev/null +++ b/src/canvas/wayland/window/waylandshm.hpp @@ -0,0 +1,77 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYLAND_SHM_WINDOW_H +#define WAYLAND_SHM_WINDOW_H + +#include "../wayland.hpp" +#include "image.hpp" +#include "shm.hpp" +#include "wayland-xdg-shell-client-protocol.h" +#include "waylandwindow.hpp" + +#include +#include +#include +#include +#include + +class WaylandShmWindow : public WaylandWindow +{ + public: + WaylandShmWindow(WaylandCanvas *canvas, std::unique_ptr new_image, struct XdgStructAgg *xdg_agg, + WaylandConfig *config); + ~WaylandShmWindow() override; + static void xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial); + static void wl_surface_frame_done(void *data, struct wl_callback *callback, uint32_t time); + + void draw() override {} + void wl_draw(int32_t scale_factor) override; + void generate_frame() override; + void show() override; + void hide() override; + + void finish_init() override; + + std::mutex draw_mutex; + std::atomic visible{false}; + std::unique_ptr shm; + int32_t output_scale; + + private: + WaylandConfig *config; + + struct xdg_wm_base *xdg_base = nullptr; + struct wl_surface *surface = nullptr; + struct xdg_surface *xdg_surface = nullptr; + struct xdg_toplevel *xdg_toplevel = nullptr; + struct wl_callback *callback; + + std::unique_ptr image; + std::string appid; + + struct XdgStructAgg *xdg_agg; + void *this_ptr; + + void move_window(); + void xdg_setup(); + + void setup_listeners(); + void delete_wayland_structs(); + void delete_xdg_structs(); +}; + +#endif diff --git a/src/canvas/wayland/window/waylandwindow.hpp b/src/canvas/wayland/window/waylandwindow.hpp new file mode 100644 index 0000000..0a1a1e8 --- /dev/null +++ b/src/canvas/wayland/window/waylandwindow.hpp @@ -0,0 +1,46 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef WAYLAND_WINDOW_H +#define WAYLAND_WINDOW_H + +#include "window.hpp" + +#include +#include + +class WaylandWindow: + public Window, + public std::enable_shared_from_this +{ +public: + ~WaylandWindow() override = default; + + virtual void wl_draw([[maybe_unused]] int32_t scale_factor) {}; + virtual void finish_init() = 0; +}; + +struct XdgStruct +{ + std::weak_ptr ptr; +}; + +struct XdgStructAgg +{ + std::vector> ptrs; +}; + +#endif diff --git a/src/canvas/x11/window/x11.cpp b/src/canvas/x11/window/x11.cpp new file mode 100644 index 0000000..c32c715 --- /dev/null +++ b/src/canvas/x11/window/x11.cpp @@ -0,0 +1,119 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "x11.hpp" +#include "dimensions.hpp" + +#include + +#include + +constexpr std::string_view win_name = "ueberzugpp"; + +X11Window::X11Window(xcb_connection_t *connection, xcb_screen_t *screen, xcb_window_t window, xcb_window_t parent, + std::shared_ptr image) + : connection(connection), + screen(screen), + window(window), + parent(parent), + gc(xcb_generate_id(connection)), + image(std::move(image)) +{ + logger = spdlog::get("X11"); + create(); + change_title(); +} + +void X11Window::create() +{ + const uint32_t value_mask = XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP; + struct xcb_create_window_value_list_t value_list; + value_list.background_pixel = screen->black_pixel; + value_list.border_pixel = screen->black_pixel; + value_list.event_mask = XCB_EVENT_MASK_EXPOSURE; + value_list.colormap = screen->default_colormap; + + const auto dimensions = image->dimensions(); + const auto xcoord = static_cast(dimensions.xpixels() + dimensions.padding_horizontal); + const auto ycoord = static_cast(dimensions.ypixels() + dimensions.padding_vertical); + xcb_create_window_aux(connection, screen->root_depth, window, this->parent, xcoord, ycoord, image->width(), + image->height(), 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, value_mask, + &value_list); + + xcb_create_gc(connection, gc, window, 0, nullptr); + logger->debug("Created child window {} at ({},{}) with parent {}", window, xcoord, ycoord, parent); +} + +void X11Window::change_title() +{ + const int bits_in_char = 8; + xcb_change_property(connection, XCB_PROP_MODE_REPLACE, window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, bits_in_char, + win_name.size(), win_name.data()); +} + +void X11Window::show() +{ + if (visible) { + return; + } + visible = true; + xcb_map_window(connection, window); + xcb_flush(connection); +} + +void X11Window::hide() +{ + if (!visible) { + return; + } + visible = false; + xcb_unmap_window(connection, window); + xcb_flush(connection); +} + +void X11Window::draw() +{ + if (!xcb_image) { + return; + } + xcb_image_put(connection, window, gc, xcb_image.get(), 0, 0, 0); +} + +void X11Window::generate_frame() +{ + xcb_image.reset(xcb_image_create_native(connection, image->width(), image->height(), XCB_IMAGE_FORMAT_Z_PIXMAP, + screen->root_depth, nullptr, 0, nullptr)); + xcb_image->data = const_cast(image->data()); + send_expose_event(); +} + +X11Window::~X11Window() +{ + xcb_destroy_window(connection, window); + xcb_free_gc(connection, gc); + xcb_flush(connection); +} + +void X11Window::send_expose_event() +{ + const int event_size = 32; + std::array buffer; + auto *event = reinterpret_cast(buffer.data()); + event->response_type = XCB_EXPOSE; + event->window = window; + xcb_send_event(connection, 0, window, XCB_EVENT_MASK_EXPOSURE, reinterpret_cast(event)); + xcb_flush(connection); +} diff --git a/src/canvas/x11/window/x11.hpp b/src/canvas/x11/window/x11.hpp new file mode 100644 index 0000000..5230b1d --- /dev/null +++ b/src/canvas/x11/window/x11.hpp @@ -0,0 +1,60 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef X11_WINDOW_H +#define X11_WINDOW_H + +#include "image.hpp" +#include "util/ptr.hpp" +#include "window.hpp" + +#include +#include + +class Dimensions; + +class X11Window : public Window +{ +public: + X11Window(xcb_connection_t* connection, xcb_screen_t *screen, + xcb_window_t window, xcb_window_t parent, std::shared_ptr image); + ~X11Window() override; + + void draw() override; + void generate_frame() override; + void show() override; + void hide() override; + +private: + xcb_connection_t *connection; + xcb_screen_t *screen; + + xcb_window_t window; + xcb_window_t parent; + xcb_gcontext_t gc; + + c_unique_ptr xcb_image; + std::shared_ptr logger; + std::shared_ptr image; + + bool visible = false; + + void send_expose_event(); + void create(); + void change_title(); +}; + +#endif diff --git a/src/canvas/x11/window/x11egl.cpp b/src/canvas/x11/window/x11egl.cpp new file mode 100644 index 0000000..c494957 --- /dev/null +++ b/src/canvas/x11/window/x11egl.cpp @@ -0,0 +1,138 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "x11egl.hpp" +#include "dimensions.hpp" +#include "image.hpp" +#include "util.hpp" + +#include + +X11EGLWindow::X11EGLWindow(xcb_connection_t *connection, xcb_screen_t *screen, xcb_window_t windowid, + xcb_window_t parentid, const EGLUtil *egl, + std::shared_ptr new_image) + : connection(connection), + screen(screen), + windowid(windowid), + parentid(parentid), + image(std::move(new_image)), + egl(egl) +{ + logger = spdlog::get("x11"); + create(); + opengl_setup(); +} + +X11EGLWindow::~X11EGLWindow() +{ + egl->run_contained(egl_surface, egl_context, [this] { + glDeleteTextures(1, &texture); + glDeleteFramebuffers(1, &fbo); + }); + eglDestroySurface(egl->display, egl_surface); + eglDestroyContext(egl->display, egl_context); + + xcb_destroy_window(connection, windowid); + xcb_flush(connection); +} + +void X11EGLWindow::create() +{ + const uint32_t value_mask = XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP; + struct xcb_create_window_value_list_t value_list; + value_list.background_pixel = screen->black_pixel; + value_list.border_pixel = screen->black_pixel; + value_list.event_mask = XCB_EVENT_MASK_EXPOSURE; + value_list.colormap = screen->default_colormap; + + const auto dimensions = image->dimensions(); + const auto xcoord = static_cast(dimensions.xpixels() + dimensions.padding_horizontal); + const auto ycoord = static_cast(dimensions.ypixels() + dimensions.padding_vertical); + xcb_create_window_aux(connection, screen->root_depth, windowid, parentid, xcoord, ycoord, image->width(), + image->height(), 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, value_mask, + &value_list); +} + +void X11EGLWindow::opengl_setup() +{ + egl_surface = egl->create_surface(&windowid); + if (egl_surface == EGL_NO_SURFACE) { + throw std::runtime_error(""); + } + + egl_context = egl->create_context(egl_surface); + if (egl_context == EGL_NO_CONTEXT) { + throw std::runtime_error(""); + } + + egl->run_contained(egl_surface, egl_context, [this] { + glGenFramebuffers(1, &fbo); + glGenTextures(1, &texture); + }); +} + +void X11EGLWindow::draw() +{ + const std::scoped_lock lock{egl_mutex}; + egl->run_contained(egl_surface, egl_context, [this] { + glBlitFramebuffer(0, 0, image->width(), image->height(), 0, 0, image->width(), image->height(), + GL_COLOR_BUFFER_BIT, GL_NEAREST); + eglSwapBuffers(egl->display, egl_surface); + }); +} + +void X11EGLWindow::generate_frame() +{ + const std::scoped_lock lock{egl_mutex}; + egl->run_contained(egl_surface, egl_context, [this] { + egl->get_texture_from_image(*image, texture); + glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo); + glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); + }); + + send_expose_event(); +} + +void X11EGLWindow::show() +{ + if (visible) { + return; + } + visible = true; + xcb_map_window(connection, windowid); + xcb_flush(connection); +} + +void X11EGLWindow::hide() +{ + if (!visible) { + return; + } + visible = false; + xcb_unmap_window(connection, windowid); + xcb_flush(connection); +} + +void X11EGLWindow::send_expose_event() +{ + const int event_size = 32; + std::array buffer; + auto *event = reinterpret_cast(buffer.data()); + event->response_type = XCB_EXPOSE; + event->window = windowid; + xcb_send_event(connection, 0, windowid, XCB_EVENT_MASK_EXPOSURE, reinterpret_cast(event)); + xcb_flush(connection); +} diff --git a/src/canvas/x11/window/x11egl.hpp b/src/canvas/x11/window/x11egl.hpp new file mode 100644 index 0000000..09fdf82 --- /dev/null +++ b/src/canvas/x11/window/x11egl.hpp @@ -0,0 +1,68 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef X11_EGL_WINDOW_H +#define X11_EGL_WINDOW_H + +#include "window.hpp" +#include "util/egl.hpp" + +#include +#include + +#include +#include + +class Image; + +class X11EGLWindow : public Window +{ +public: + X11EGLWindow(xcb_connection_t* connection, xcb_screen_t* screen, + xcb_window_t windowid, xcb_window_t parentid, const EGLUtil* egl, + std::shared_ptr new_image); + ~X11EGLWindow() override; + + void draw() override; + void generate_frame() override; + void show() override; + void hide() override; + +private: + xcb_connection_t* connection; + xcb_screen_t* screen; + xcb_window_t windowid; + xcb_window_t parentid; + std::shared_ptr image; + const EGLUtil* egl; + + GLuint texture; + GLuint fbo; + EGLContext egl_context; + EGLSurface egl_surface; + + std::mutex egl_mutex; + std::shared_ptr logger; + + bool visible = false; + + void send_expose_event(); + void create(); + void change_title(); + void opengl_setup(); +}; + +#endif diff --git a/src/canvas/x11/x11.cpp b/src/canvas/x11/x11.cpp new file mode 100644 index 0000000..5f1a04c --- /dev/null +++ b/src/canvas/x11/x11.cpp @@ -0,0 +1,257 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "x11.hpp" +#include "application.hpp" +#include "flags.hpp" +#include "os.hpp" +#include "tmux.hpp" +#include "util.hpp" + +#include + +#include + +#ifdef ENABLE_OPENGL +# include "window/x11egl.hpp" +# include +#endif +#include "window/x11.hpp" + +X11Canvas::X11Canvas() + : connection(xcb_connect(nullptr, nullptr)) +{ + if (xcb_connection_has_error(connection) > 0) { + throw std::runtime_error("Can't connect to X11 server"); + } + screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data; + +#ifdef ENABLE_XCB_ERRORS + xcb_errors_context_new(connection, &err_ctx); +#endif + + flags = Flags::instance(); + +#ifdef ENABLE_OPENGL + if (flags->use_opengl) { + try { + egl = std::make_unique>(EGL_PLATFORM_XCB_EXT, connection); + } catch (const std::runtime_error &err) { + egl_available = false; + } + } else { + egl_available = false; + } +#endif + + xutil = std::make_unique(connection); + logger = spdlog::get("X11"); + event_handler = std::thread(&X11Canvas::handle_events, this); + logger->info("Canvas created"); +} + +X11Canvas::~X11Canvas() +{ + draw_threads.clear(); + windows.clear(); + image_windows.clear(); + + if (event_handler.joinable()) { + event_handler.join(); + } + +#ifdef ENABLE_XCB_ERRORS + xcb_errors_context_free(err_ctx); +#endif + + xcb_disconnect(connection); +} + +void X11Canvas::draw(const std::string &identifier) +{ + if (!images.at(identifier)->is_animated()) { + for (const auto &[wid, window] : image_windows.at(identifier)) { + window->generate_frame(); + } + return; + } + + draw_threads.insert_or_assign(identifier, std::jthread([this, identifier](const std::stop_token &stoken) { + const auto image = images.at(identifier); + const auto wins = image_windows.at(identifier); + while (!stoken.stop_requested()) { + for (const auto &[wid, window] : wins) { + window->generate_frame(); + } + image->next_frame(); + std::this_thread::sleep_for(std::chrono::milliseconds(image->frame_delay())); + } + })); +} + +void X11Canvas::show() +{ + const std::scoped_lock lock{windows_mutex}; + for (const auto &[wid, window] : windows) { + window->show(); + } +} + +void X11Canvas::hide() +{ + const std::scoped_lock lock{windows_mutex}; + for (const auto &[wid, window] : windows) { + window->hide(); + } +} + +void X11Canvas::handle_events() +{ + const int event_mask = 0x80; + const int waitms = 100; + const int connfd = xcb_get_file_descriptor(connection); + bool status = false; + + while (!Application::stop_flag) { + try { + status = os::wait_for_data_on_fd(connfd, waitms); + } catch (const std::system_error &err) { + Application::stop_flag = true; + break; + } + + if (!status) { + continue; + } + + const std::scoped_lock lock{windows_mutex}; + auto event = unique_C_ptr{xcb_poll_for_event(connection)}; + while (event) { + const int real_event = event->response_type & ~event_mask; + switch (real_event) { + case 0: { + const auto *err = reinterpret_cast(event.get()); + print_xcb_error(err); + break; + } + case XCB_EXPOSE: { + const auto *expose = reinterpret_cast(event.get()); + try { + logger->debug("Received expose event for window {}", expose->window); + const auto window = windows.at(expose->window); + window->draw(); + } catch (const std::out_of_range &oor) { + logger->debug("Discarding expose event for window {}", expose->window); + } + break; + } + default: { + logger->debug("Received unknown event {}", real_event); + break; + } + } + event.reset(xcb_poll_for_event(connection)); + } + } +} + +void X11Canvas::add_image(const std::string &identifier, std::unique_ptr new_image) +{ + remove_image(identifier); + + logger->debug("Initializing canvas"); + images.insert({identifier, std::move(new_image)}); + image_windows.insert({identifier, {}}); + + const auto image = images.at(identifier); + const auto dims = image->dimensions(); + std::unordered_set parent_ids{dims.terminal->x11_wid}; + get_tmux_window_ids(parent_ids); + + ranges::for_each(parent_ids, [this, &identifier, &image](xcb_window_t parent) { + const auto window_id = xcb_generate_id(connection); + std::shared_ptr window; +#ifdef ENABLE_OPENGL + if (egl_available) { + try { + window = std::make_shared(connection, screen, window_id, parent, egl.get(), image); + } catch (const std::runtime_error &err) { + return; + } + } +#endif + if (window == nullptr) { + window = std::make_shared(connection, screen, window_id, parent, image); + } + windows.insert({window_id, window}); + image_windows.at(identifier).insert({window_id, window}); + window->show(); + }); + + draw(identifier); +} + +void X11Canvas::get_tmux_window_ids(std::unordered_set &windows) +{ + const auto pids = tmux::get_client_pids(); + if (!pids.has_value()) { + return; + } + const auto pid_window_map = xutil->get_pid_window_map(); + for (const auto pid : pids.value()) { + const auto ppids = util::get_process_tree(pid); + for (const auto ppid : ppids) { + const auto win = pid_window_map.find(ppid); + if (win == pid_window_map.end()) { + continue; + } + windows.insert(win->second); + break; // prevent multiple windows being created + } + } +} + +void X11Canvas::print_xcb_error(const xcb_generic_error_t *err) +{ +#ifdef ENABLE_XCB_ERRORS + const char *extension = nullptr; + const char *major = xcb_errors_get_name_for_major_code(err_ctx, err->major_code); + const char *minor = xcb_errors_get_name_for_minor_code(err_ctx, err->major_code, err->minor_code); + const char *error = xcb_errors_get_name_for_error(err_ctx, err->error_code, &extension); + + const std::string_view ext_str = extension != nullptr ? extension : "no_extension"; + const std::string_view minor_str = minor != nullptr ? minor : "no_minor"; + logger->error("XCB: {}:{}, {}:{}, resource {} sequence {}", error, ext_str, major, minor_str, err->resource_id, + err->sequence); +#else + logger->error("XCB: resource {} sequence {}", err->resource_id, err->sequence); +#endif +} + +void X11Canvas::remove_image(const std::string &identifier) +{ + draw_threads.erase(identifier); + images.erase(identifier); + + const std::scoped_lock lock{windows_mutex}; + const auto old_windows = image_windows.extract(identifier); + if (old_windows.empty()) { + return; + } + for (const auto &[key, value] : old_windows.mapped()) { + windows.erase(key); + } +} diff --git a/src/canvas/x11/x11.hpp b/src/canvas/x11/x11.hpp new file mode 100644 index 0000000..09d99a3 --- /dev/null +++ b/src/canvas/x11/x11.hpp @@ -0,0 +1,93 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef X11_CANVAS_H +#define X11_CANVAS_H + +#include "canvas.hpp" +#include "image.hpp" +#include "window.hpp" +#include "dimensions.hpp" +#include "util/x11.hpp" + +#include +#include +#include +#include +#include + +#include +#include + +#ifdef ENABLE_XCB_ERRORS +# include +#endif + +#ifdef ENABLE_OPENGL +# include "util/egl.hpp" +#endif + +class Flags; + +class X11Canvas : public Canvas +{ +public: + explicit X11Canvas(); + ~X11Canvas() override; + + void add_image(const std::string& identifier, std::unique_ptr new_image) override; + void remove_image(const std::string& identifier) override; + void hide() override; + void show() override; + +private: + xcb_connection_t *connection; + xcb_screen_t *screen; + +#ifdef ENABLE_XCB_ERRORS + xcb_errors_context_t *err_ctx; +#endif + + std::unique_ptr xutil; + + // map for event handler + std::unordered_map> windows; + + // windows per image + std::unordered_map>> image_windows; + + std::unordered_map> images; + std::unordered_map draw_threads; + + std::thread event_handler; + std::mutex windows_mutex; + + std::shared_ptr logger; + std::shared_ptr flags; + +#ifdef ENABLE_OPENGL + std::unique_ptr> egl; + bool egl_available = true; +#endif + + void draw(const std::string& identifier); + void handle_events(); + void get_tmux_window_ids(std::unordered_set& windows); + void print_xcb_error(const xcb_generic_error_t* err); +}; + +#endif diff --git a/src/dimensions.cpp b/src/dimensions.cpp new file mode 100644 index 0000000..ecbe851 --- /dev/null +++ b/src/dimensions.cpp @@ -0,0 +1,62 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "dimensions.hpp" +#include "tmux.hpp" +#include "terminal.hpp" + +#include + +Dimensions::Dimensions(const Terminal* terminal, uint16_t xcoord, + uint16_t ycoord, int max_w, int max_h, std::string scaler): +max_w(max_w), +max_h(max_h), +padding_horizontal(terminal->padding_horizontal), +padding_vertical(terminal->padding_vertical), +scaler(std::move(scaler)), +terminal(terminal), +orig_x(xcoord), +orig_y(ycoord) +{ + read_offsets(); +} + +void Dimensions::read_offsets() +{ + const auto [offset_x, offset_y] = tmux::get_offset(); + x = orig_x + offset_x; + y = orig_y + offset_y; +} + +auto Dimensions::xpixels() const -> int +{ + return x * terminal->font_width; +} + +auto Dimensions::ypixels() const -> int +{ + return y * terminal->font_height; +} + +auto Dimensions::max_wpixels() const -> int +{ + return max_w * terminal->font_width; +} + +auto Dimensions::max_hpixels() const -> int +{ + return max_h * terminal->font_height; +} diff --git a/src/flags.cpp b/src/flags.cpp new file mode 100644 index 0000000..4369794 --- /dev/null +++ b/src/flags.cpp @@ -0,0 +1,52 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "flags.hpp" +#include "os.hpp" +#include "util.hpp" + +#include +#include +#include + +namespace fs = std::filesystem; +using json = nlohmann::json; + +// read configuration file +Flags::Flags() +{ + const auto home = os::getenv("HOME").value_or(util::temp_directory_path()); + const auto config_home = os::getenv("XDG_CONFIG_HOME").value_or(fmt::format("{}/.config", home)); + config_file = fmt::format("{}/ueberzugpp/config.json", config_home); + if (fs::exists(config_file)) { + read_config_file(); + } +} + +void Flags::read_config_file() +{ + std::ifstream ifs(config_file); + const auto data = json::parse(ifs); + if (!data.contains("layer")) { + return; + } + const auto &layer = data.at("layer"); + silent = layer.value("silent", false); + output = layer.value("output", ""); + no_cache = layer.value("no-cache", false); + no_opencv = layer.value("no-opencv", false); + use_opengl = layer.value("opengl", false); +} diff --git a/src/image.cpp b/src/image.cpp new file mode 100644 index 0000000..fae3ef6 --- /dev/null +++ b/src/image.cpp @@ -0,0 +1,185 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "image.hpp" +#ifdef ENABLE_OPENCV +# include "image/opencv.hpp" +#endif +#include "dimensions.hpp" +#include "flags.hpp" +#include "image/libvips.hpp" +#include "util.hpp" + +#ifdef ENABLE_OPENCV +# include +#endif +#include +#include + +namespace fs = std::filesystem; +using njson = nlohmann::json; + +auto Image::load(const njson &command, const Terminal *terminal) -> std::unique_ptr +{ + const fs::path &filename = command.at("path"); + if (!fs::exists(filename)) { + return nullptr; + } + const auto flags = Flags::instance(); + const auto logger = spdlog::get("main"); + std::shared_ptr dimensions; + try { + dimensions = get_dimensions(command, terminal); + } catch (const std::exception &) { + logger->error("Could not parse dimensions from command"); + return nullptr; + } + std::string image_path = filename; + bool in_cache = false; + if (!flags->no_cache) { + image_path = check_cache(*dimensions, filename); + in_cache = image_path != filename; + } + +#ifdef ENABLE_OPENCV + if (cv::haveImageReader(image_path) && !flags->no_opencv) { + try { + return std::make_unique(dimensions, image_path, in_cache); + } catch (const std::runtime_error &) { + return nullptr; + } + } +#endif + const auto *vips_loader = vips_foreign_find_load(image_path.c_str()); + if (vips_loader != nullptr) { + try { + return std::make_unique(dimensions, image_path, in_cache); + } catch (const vips::VError &) { + return nullptr; + } + } + return nullptr; +} + +auto Image::check_cache(const Dimensions &dimensions, const fs::path &orig_path) -> std::string +{ + const fs::path cache_path = util::get_cache_file_save_location(orig_path); + if (!fs::exists(cache_path)) { + return orig_path; + } + + vips::VImage cache_img; + try { + cache_img = vips::VImage::new_from_file(cache_path.c_str()); + } catch (const vips::VError &) { + return orig_path; + } + const uint32_t img_width = cache_img.width(); + const uint32_t img_height = cache_img.height(); + const uint32_t dim_width = dimensions.max_wpixels(); + const uint32_t dim_height = dimensions.max_hpixels(); + const int delta = 10; + + if ((dim_width >= img_width && dim_height >= img_height) && + ((dim_width - img_width) <= delta || (dim_height - img_height) <= delta)) { + return cache_path; + } + return orig_path; +} + +auto Image::get_new_sizes(double max_width, double max_height, std::string_view scaler, int scale_factor) const + -> std::pair +{ + int img_width = width(); + int img_height = height(); + int new_width = img_width; + int new_height = img_height; + double new_scale = 0; + double width_scale = 0; + double height_scale = 0; + double min_scale = 0; + double max_scale = 0; + + if (scaler == "fit_contain" || scaler == "forced_cover") { + // I believe these should work the same + new_scale = max_height / img_height; + if (img_width >= img_height) { + new_scale = max_width / img_width; + } + new_width = static_cast(img_width * new_scale); + new_height = static_cast(img_height * new_scale); + new_scale = 1; + } + + if (new_height > max_height) { + if (new_width > max_width) { + width_scale = max_width / new_width; + height_scale = max_height / new_height; + min_scale = std::min(width_scale, height_scale); + max_scale = std::max(width_scale, height_scale); + if (new_width * max_scale <= max_width && new_height * max_scale <= max_height) { + new_scale = max_scale; + } else { + new_scale = min_scale; + } + } else { + new_scale = max_height / new_height; + } + } else if (new_width > max_width) { + new_scale = max_width / new_width; + } + if (new_scale != 1) { + new_width = static_cast(new_width * new_scale); + new_height = static_cast(new_height * new_scale); + } + + return std::make_pair(util::round_up(new_width, scale_factor), util::round_up(new_height, scale_factor)); +} + +auto Image::get_dimensions(const njson &json, const Terminal *terminal) -> std::shared_ptr +{ + using std::string; + int xcoord = 0; + int ycoord = 0; + int max_width = 0; + int max_height = 0; + string width_key = "max_width"; + string height_key = "max_height"; + const string scaler = json.value("scaler", "contain"); + if (json.contains("width")) { + width_key = "width"; + height_key = "height"; + } + if (json.at(width_key).is_string()) { + const string &width = json.at(width_key); + const string &height = json.at(height_key); + max_width = std::stoi(width); + max_height = std::stoi(height); + } else { + max_width = json.at(width_key); + max_height = json.at(height_key); + } + if (json.at("x").is_string()) { + const string &xcoords = json.at("x"); + const string &ycoords = json.at("y"); + xcoord = std::stoi(xcoords); + ycoord = std::stoi(ycoords); + } else { + xcoord = json.at("x"); + ycoord = json.at("y"); + } + return std::make_shared(terminal, xcoord, ycoord, max_width, max_height, scaler); +} diff --git a/src/image/libvips.cpp b/src/image/libvips.cpp new file mode 100644 index 0000000..c7ecffc --- /dev/null +++ b/src/image/libvips.cpp @@ -0,0 +1,216 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "libvips.hpp" +#include "dimensions.hpp" +#include "flags.hpp" +#include "terminal.hpp" +#include "util.hpp" + +#include +#include + +#ifdef ENABLE_OPENCV +# include +#endif + +using vips::VError; +using vips::VImage; + +LibvipsImage::LibvipsImage(std::shared_ptr new_dims, const std::string &filename, bool in_cache) + : path(filename), + dims(std::move(new_dims)), + max_width(dims->max_wpixels()), + max_height(dims->max_hpixels()), + in_cache(in_cache) +{ + image = VImage::new_from_file(path.c_str()).colourspace(VIPS_INTERPRETATION_sRGB); + flags = Flags::instance(); + logger = spdlog::get("vips"); + logger->info("loading file {}", filename); + + try { + // animated images should have both n-pages and delay + npages = image.get_int("n-pages"); + std::ignore = image.get_array_int("delay"); + is_anim = true; + logger->info("file is an animated image"); + auto *opts = VImage::option()->set("n", -1); + backup = VImage::new_from_file(filename.c_str(), opts).colourspace(VIPS_INTERPRETATION_sRGB); + orig_height = backup.height() / npages; + image = backup.crop(0, 0, backup.width(), orig_height); + } catch (const VError &err) { + logger->debug("Failed to process image animation"); + } + + if (!is_anim) { + image = image.autorot(); + } + process_image(); +} + +auto LibvipsImage::dimensions() const -> const Dimensions & +{ + return *dims; +} + +auto LibvipsImage::filename() const -> std::string +{ + return path.string(); +} + +auto LibvipsImage::width() const -> int +{ + return image.width(); +} + +auto LibvipsImage::height() const -> int +{ + return image.height(); +} + +auto LibvipsImage::size() const -> size_t +{ + return _size; +} + +auto LibvipsImage::data() const -> const unsigned char * +{ + return _data.get(); +} + +auto LibvipsImage::channels() const -> int +{ + return image.bands(); +} + +auto LibvipsImage::is_animated() const -> bool +{ + return is_anim; +} + +auto LibvipsImage::next_frame() -> void +{ + if (!is_anim) { + return; + } + top += orig_height; + if (top == backup.height()) { + top = 0; + } + image = backup.crop(0, top, backup.width(), orig_height); + process_image(); +} + +auto LibvipsImage::frame_delay() const -> int +{ + if (!is_anim) { + return -1; + } + try { + const auto delays = backup.get_array_int("delay"); + const int ms_per_sec = 1000; + if (delays.at(0) == 0) { +#ifdef ENABLE_OPENCV + const cv::VideoCapture video(path); + if (video.isOpened()) { + return static_cast((1.0 / video.get(cv::CAP_PROP_FPS)) * ms_per_sec); + } +#endif + return static_cast((1.0 / npages) * ms_per_sec); + } + return delays.at(0); + } catch (const VError &err) { + return -1; + } +} + +auto LibvipsImage::resize_image() -> void +{ + if (in_cache) { + return; + } + const auto [new_width, new_height] = get_new_sizes(max_width, max_height, dims->scaler, flags->scale_factor); + if (new_width <= 0 && new_height <= 0) { + // ensure width and height are pair + if (flags->needs_scaling) { + const auto curw = width(); + const auto curh = height(); + if ((curw % 2) != 0 || (curh % 2) != 0) { + auto *opts = VImage::option() + ->set("height", util::round_up(curh, flags->scale_factor)) + ->set("size", VIPS_SIZE_FORCE); + image = image.thumbnail_image(util::round_up(curw, flags->scale_factor), opts); + } + } + return; + } + + logger->debug("Resizing image"); + + auto *opts = VImage::option()->set("height", new_height)->set("size", VIPS_SIZE_FORCE); + image = image.thumbnail_image(new_width, opts); + + if (is_anim || flags->no_cache) { + return; + } + + const auto save_location = util::get_cache_file_save_location(path); + try { + image.write_to_file(save_location.c_str()); + logger->debug("Saved resized image"); + } catch (const VError &err) { + logger->debug("Could not save resized image"); + } +} + +auto LibvipsImage::process_image() -> void +{ + resize_image(); + if (flags->origin_center) { + const double img_width = static_cast(width()) / dims->terminal->font_width; + const double img_height = static_cast(height()) / dims->terminal->font_height; + dims->x -= std::floor(img_width / 2); + dims->y -= std::floor(img_height / 2); + } + + const std::unordered_set bgra_trifecta = {"x11", "chafa", "wayland"}; + +#ifdef ENABLE_OPENGL + if (flags->use_opengl) { + image = image.flipver(); + } +#endif + + if (bgra_trifecta.contains(flags->output)) { + // alpha channel required + if (!image.has_alpha()) { + const int alpha_value = 255; + image = image.bandjoin(alpha_value); + } + // convert from RGB to BGR + auto bands = image.bandsplit(); + std::swap(bands[0], bands[2]); + image = VImage::bandjoin(bands); + } else if (flags->output == "sixel") { + // sixel expects RGB888 + if (image.has_alpha()) { + image = image.flatten(); + } + } + _size = VIPS_IMAGE_SIZEOF_IMAGE(image.get_image()); + _data.reset(static_cast(image.write_to_memory(&_size))); +} diff --git a/src/image/libvips.hpp b/src/image/libvips.hpp new file mode 100644 index 0000000..76cc731 --- /dev/null +++ b/src/image/libvips.hpp @@ -0,0 +1,71 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef LIBVIPS_IMAGE_H +#define LIBVIPS_IMAGE_H + +#include "image.hpp" +#include "util/ptr.hpp" + +#include +#include +#include +#include + +class LibvipsImage : public Image +{ + public: + LibvipsImage(std::shared_ptr new_dims, const std::string &filename, bool in_cache); + + [[nodiscard]] auto dimensions() const -> const Dimensions & override; + [[nodiscard]] auto width() const -> int override; + [[nodiscard]] auto height() const -> int override; + [[nodiscard]] auto size() const -> size_t override; + [[nodiscard]] auto data() const -> const unsigned char * override; + [[nodiscard]] auto channels() const -> int override; + + void next_frame() override; + [[nodiscard]] auto frame_delay() const -> int override; + [[nodiscard]] auto is_animated() const -> bool override; + [[nodiscard]] auto filename() const -> std::string override; + + private: + vips::VImage image; + vips::VImage backup; + + c_unique_ptr _data; + std::filesystem::path path; + std::shared_ptr dims; + + std::shared_ptr flags; + std::shared_ptr logger; + + uint32_t max_width; + uint32_t max_height; + size_t _size = 0; + + // for animated pictures + int top = 0; + int orig_height; + int npages = 0; + bool is_anim = false; + bool in_cache; + + void process_image(); + void resize_image(); +}; + +#endif diff --git a/src/image/opencv.cpp b/src/image/opencv.cpp new file mode 100644 index 0000000..60c2425 --- /dev/null +++ b/src/image/opencv.cpp @@ -0,0 +1,249 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "opencv.hpp" +#include "dimensions.hpp" +#include "flags.hpp" +#include "terminal.hpp" +#include "util.hpp" + +#include +#include + +#include +#include +#include + +enum { + EXIF_ORIENTATION_2 = 2, + EXIF_ORIENTATION_3, + EXIF_ORIENTATION_4, + EXIF_ORIENTATION_5, + EXIF_ORIENTATION_6, + EXIF_ORIENTATION_7, + EXIF_ORIENTATION_8, +}; + +OpencvImage::OpencvImage(std::shared_ptr new_dims, const std::string &filename, bool in_cache) + : path(filename), + dims(std::move(new_dims)), + max_width(dims->max_wpixels()), + max_height(dims->max_hpixels()), + in_cache(in_cache) +{ + logger = spdlog::get("opencv"); + image = cv::imread(filename, cv::IMREAD_UNCHANGED); + + if (image.empty()) { + logger->warn("unable to read image"); + throw std::runtime_error(""); + } + logger->info("loading file {}", filename); + flags = Flags::instance(); + + rotate_image(); + process_image(); +} + +auto OpencvImage::filename() const -> std::string +{ + return path.string(); +} + +auto OpencvImage::dimensions() const -> const Dimensions & +{ + return *dims; +} + +auto OpencvImage::width() const -> int +{ + return image.cols; +} + +auto OpencvImage::height() const -> int +{ + return image.rows; +} + +auto OpencvImage::size() const -> size_t +{ + return _size; +} + +auto OpencvImage::data() const -> const unsigned char * +{ + return image.data; +} + +auto OpencvImage::channels() const -> int +{ + return image.channels(); +} + +void OpencvImage::wayland_processing() +{ + if (flags->output != "wayland") { + return; + } +} + +void OpencvImage::rotate_image() +{ + const auto rotation = util::read_exif_rotation(path); + if (!rotation.has_value()) { + return; + } + const auto value = rotation.value(); + + // kudos https://jdhao.github.io/2019/07/31/image_rotation_exif_info/ + switch (value) { + case EXIF_ORIENTATION_2: + cv::flip(image, image, 1); + break; + case EXIF_ORIENTATION_3: + cv::flip(image, image, -1); + break; + case EXIF_ORIENTATION_4: + cv::flip(image, image, 0); + break; + case EXIF_ORIENTATION_5: + cv::rotate(image, image, cv::ROTATE_90_CLOCKWISE); + cv::flip(image, image, 1); + break; + case EXIF_ORIENTATION_6: + cv::rotate(image, image, cv::ROTATE_90_CLOCKWISE); + break; + case EXIF_ORIENTATION_7: + cv::rotate(image, image, cv::ROTATE_90_COUNTERCLOCKWISE); + cv::flip(image, image, 1); + break; + case EXIF_ORIENTATION_8: + cv::rotate(image, image, cv::ROTATE_90_COUNTERCLOCKWISE); + break; + default: + break; + } +} + +// only use opencl if required +auto OpencvImage::resize_image() -> void +{ + if (in_cache) { + return; + } + const auto [new_width, new_height] = get_new_sizes(max_width, max_height, dims->scaler, flags->scale_factor); + if (new_width <= 0 && new_height <= 0) { + // ensure width and height are pair + if (flags->needs_scaling) { + const auto curw = width(); + const auto curh = height(); + if ((curw % 2) != 0 || (curh % 2) != 0) { + resize_image_helper(image, util::round_up(curw, flags->scale_factor), + util::round_up(curh, flags->scale_factor)); + } + } + return; + } + + const auto opencl_ctx = cv::ocl::Context::getDefault(); + opencl_available = opencl_ctx.ptr() != nullptr; + + if (opencl_available) { + logger->debug("OpenCL is available"); + image.copyTo(uimage); + resize_image_helper(uimage, new_width, new_height); + uimage.copyTo(image); + } else { + resize_image_helper(image, new_width, new_height); + } +} + +void OpencvImage::resize_image_helper(cv::InputOutputArray &mat, int new_width, int new_height) +{ + logger->debug("Resizing image"); + cv::resize(mat, mat, cv::Size(new_width, new_height), 0, 0, cv::INTER_AREA); + + if (flags->no_cache) { + logger->debug("Caching is disabled"); + return; + } + + const auto save_location = util::get_cache_file_save_location(path); + try { + cv::imwrite(save_location, mat); + logger->debug("Saved resized image"); + } catch (const cv::Exception &ex) { + logger->error("Could not save image"); + } +} + +void OpencvImage::process_image() +{ + resize_image(); + if (flags->origin_center) { + const double img_width = static_cast(width()) / dims->terminal->font_width; + const double img_height = static_cast(height()) / dims->terminal->font_height; + dims->x -= std::floor(img_width / 2); + dims->y -= std::floor(img_height / 2); + } + + const std::unordered_set bgra_trifecta = {"x11", "chafa", "wayland"}; + + if (image.depth() == CV_16U) { + const float alpha = 0.00390625; // 1 / 256 + image.convertTo(image, CV_8U, alpha); + } + + if (image.channels() == 4) { + // premultiply alpha + image.forEach([](cv::Vec4b &pix, const int *) { + const uint8_t alpha = pix[3]; + const uint8_t div = 255; + pix[0] = (pix[0] * alpha) / div; + pix[1] = (pix[1] * alpha) / div; + pix[2] = (pix[2] * alpha) / div; + }); + } + +#ifdef ENABLE_OPENGL + if (flags->use_opengl) { + cv::flip(image, image, 0); + } +#endif + + if (image.channels() == 1) { + cv::cvtColor(image, image, cv::COLOR_GRAY2BGRA); + } + + if (bgra_trifecta.contains(flags->output)) { + if (image.channels() == 3) { + cv::cvtColor(image, image, cv::COLOR_BGR2BGRA); + } + } else if (flags->output == "kitty") { + if (image.channels() == 4) { + cv::cvtColor(image, image, cv::COLOR_BGRA2RGBA); + } else { + cv::cvtColor(image, image, cv::COLOR_BGR2RGB); + } + } else if (flags->output == "sixel") { + if (image.channels() == 4) { + cv::cvtColor(image, image, cv::COLOR_BGRA2RGB); + } else { + cv::cvtColor(image, image, cv::COLOR_BGR2RGB); + } + } + _size = image.total() * image.elemSize(); +} diff --git a/src/image/opencv.hpp b/src/image/opencv.hpp new file mode 100644 index 0000000..6214abc --- /dev/null +++ b/src/image/opencv.hpp @@ -0,0 +1,68 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef OPENCV_IMAGE_H +#define OPENCV_IMAGE_H + +#include "image.hpp" + +#include +#include +#include +#include + +namespace fs = std::filesystem; + +class OpencvImage : public Image +{ + public: + OpencvImage(std::shared_ptr new_dims, const std::string &filename, bool in_cache); + ~OpencvImage() override = default; + + [[nodiscard]] auto dimensions() const -> const Dimensions & override; + [[nodiscard]] auto width() const -> int override; + [[nodiscard]] auto height() const -> int override; + [[nodiscard]] auto size() const -> size_t override; + [[nodiscard]] auto data() const -> const unsigned char * override; + [[nodiscard]] auto channels() const -> int override; + + [[nodiscard]] auto filename() const -> std::string override; + + private: + cv::Mat image; + cv::UMat uimage; + + fs::path path; + std::shared_ptr dims; + + uint64_t _size = 0; + uint32_t max_width; + uint32_t max_height; + bool in_cache; + bool opencl_available = false; + + std::shared_ptr logger; + std::shared_ptr flags; + + void process_image(); + void resize_image(); + void resize_image_helper(cv::InputOutputArray &mat, int new_width, int new_height); + + void rotate_image(); + void wayland_processing(); +}; + +#endif diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..dbc83a8 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,151 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include + +#include +#include +#include +#include +#include + +#include +#if (CLI11_VERSION_MAJOR >= 3) || (CLI11_VERSION_MAJOR == 2 && CLI11_VERSION_MINOR >= 6) +// CLI11 2.6.0 and beyond requires this header file for the CLI::IsMember validator. +# include +#endif + +#include "application.hpp" +#include "flags.hpp" +#include "tmux.hpp" +#include "util.hpp" + +void signal_handler(const int signal) +{ + Application::stop_flag = true; + + const auto logger = spdlog::get("main"); + if (!logger) { + return; + } + switch (signal) { + case SIGINT: + logger->error("SIGINT received, exiting..."); + break; + case SIGTERM: + logger->error("SIGTERM received, exiting..."); + break; + case SIGHUP: + logger->error("SIGHUP received, exiting..."); + break; + default: + logger->error("UNKNOWN({}) signal received, exiting...", signal); + break; + } +} + +auto main(int argc, char *argv[]) -> int +{ + // handle signals + struct sigaction sga; + sga.sa_handler = signal_handler; + sigemptyset(&sga.sa_mask); + sga.sa_flags = 0; + sigaction(SIGINT, &sga, nullptr); + sigaction(SIGTERM, &sga, nullptr); + sigaction(SIGHUP, &sga, nullptr); + sigaction(SIGCHLD, nullptr, nullptr); + + spdlog::cfg::load_env_levels(); + + std::shared_ptr flags; + try { + flags = Flags::instance(); + } catch (const std::exception &e) { + std::cerr << "Could not parse config file: " << e.what() << std::endl; + return 1; + } + + CLI::App program("Display images in the terminal", "ueberzug"); + program.add_flag("-V,--version", flags->print_version, "Print version information."); + + auto *layer_command = program.add_subcommand("layer", "Display images on the terminal."); + layer_command->add_flag("-s,--silent", flags->silent, "Print stderr to /dev/null."); + layer_command + ->add_flag("--use-escape-codes", flags->use_escape_codes, "Use escape codes to get terminal capabilities.") + ->default_val(false); + layer_command->add_option("--pid-file", flags->pid_file, "Output file where to write the daemon PID."); + layer_command->add_flag("--no-stdin", flags->no_stdin, "Do not listen on stdin for commands.")->needs("--pid-file"); + layer_command->add_flag("--no-cache", flags->no_cache, "Disable caching of resized images."); + layer_command->add_flag("--no-opencv", flags->no_opencv, "Do not use OpenCV, use Libvips instead."); + layer_command->add_option("-o,--output", flags->output, "Image output method") + ->check(CLI::IsMember({"x11", "wayland", "sixel", "kitty", "iterm2", "chafa"})); + layer_command->add_flag("--origin-center", flags->origin_center, "Location of the origin wrt the image"); + layer_command->add_option("-p,--parser", nullptr, "**UNUSED**, only present for backwards compatibility."); + layer_command->add_option("-l,--loader", nullptr, "**UNUSED**, only present for backwards compatibility."); + + auto *cmd_comand = program.add_subcommand("cmd", "Send a command to a running ueberzugpp instance."); + cmd_comand->add_option("-s,--socket", flags->cmd_socket, "UNIX socket of running instance"); + cmd_comand->add_option("-i,--identifier", flags->cmd_id, "Preview identifier"); + cmd_comand->add_option("-a,--action", flags->cmd_action, "Action to send"); + cmd_comand->add_option("-f,--file", flags->cmd_file_path, "Path of image file"); + cmd_comand->add_option("-x,--xpos", flags->cmd_x, "X position of preview"); + cmd_comand->add_option("-y,--ypos", flags->cmd_y, "Y position of preview"); + cmd_comand->add_option("--max-width", flags->cmd_max_width, "Max width of preview"); + cmd_comand->add_option("--max-height", flags->cmd_max_height, "Max height of preview"); + + auto *tmux_command = program.add_subcommand("tmux", "Handle tmux hooks. Used internaly."); + tmux_command->allow_extras(); + + auto *query_win_command = + program.add_subcommand("query_windows", "**UNUSED**, only present for backwards compatibility."); + query_win_command->allow_extras(); + + CLI11_PARSE(program, argc, argv); + + if (query_win_command->parsed()) { + return 0; + } + + if (flags->print_version) { + Application::print_version(); + return 0; + } + + if (!layer_command->parsed() && !tmux_command->parsed() && !cmd_comand->parsed()) { + program.exit(CLI::CallForHelp()); + return 1; + } + + if (layer_command->parsed()) { + Application application(argv[0]); + application.command_loop(); + } + + if (tmux_command->parsed()) { + try { + const auto positionals = tmux_command->remaining(); + tmux::handle_hook(positionals.at(0), std::stoi(positionals.at(1))); + } catch (const std::out_of_range &oor) { + } + } + + if (cmd_comand->parsed()) { + util::send_command(*flags); + } + + return 0; +} diff --git a/src/os.cpp b/src/os.cpp new file mode 100644 index 0000000..af37a0e --- /dev/null +++ b/src/os.cpp @@ -0,0 +1,126 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "os.hpp" +#include "util/ptr.hpp" + +#include +#include +#include + +#include +#include +#include +#include + +auto os::exec(const std::string &cmd) -> std::string +{ + const int bufsize = 128; + std::array buffer{}; + std::string result; + const c_unique_ptr pipe{popen(cmd.c_str(), "r")}; + if (!pipe) { + throw std::system_error(errno, std::generic_category()); + } + while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) { + result.append(buffer.data()); + } + if (!result.empty()) { + result.erase(result.length() - 1); + } + return result; +} + +auto os::read_data_from_fd(int filde, char sep) -> std::string +{ + using std::errc; + std::string response; + char readch = 0; + + while (true) { + const auto status = read(filde, &readch, 1); + if (status == -1) { + throw std::system_error(errno, std::system_category()); + } + if (status == 0 || readch == sep) { + if (response.empty()) { + throw std::system_error(EIO, std::system_category()); + } + break; + } + response.push_back(readch); + } + return response; +} + +auto os::read_data_from_stdin(char sep) -> std::string +{ + return read_data_from_fd(STDIN_FILENO, sep); +} + +auto os::wait_for_data_on_fd(int filde, int waitms) -> bool +{ + struct pollfd fds; + fds.fd = filde; + fds.events = POLLIN; + + poll(&fds, 1, waitms); + + if ((fds.revents & (POLLERR | POLLNVAL | POLLHUP)) != 0) { + throw std::system_error(EIO, std::generic_category()); + } + + return (fds.revents & POLLIN) != 0; +} + +auto os::wait_for_data_on_stdin(int waitms) -> bool +{ + return wait_for_data_on_fd(STDIN_FILENO, waitms); +} + +auto os::getenv(const std::string &var) -> std::optional +{ + const char *env_p = std::getenv(var.c_str()); // NOLINT + if (env_p == nullptr) { + return {}; + } + return env_p; +} + +auto os::get_pid() -> int +{ + return getpid(); +} + +auto os::get_ppid() -> int +{ + return getppid(); +} + +void os::daemonize() +{ + const int pid = fork(); + if (pid < 0) { + std::exit(EXIT_FAILURE); // NOLINT + } + if (pid > 0) { + std::exit(EXIT_SUCCESS); // NOLINT + } + const int status = setsid(); + if (status < 0) { + std::exit(EXIT_FAILURE); // NOLINT + } +} diff --git a/src/process/apple.cpp b/src/process/apple.cpp new file mode 100644 index 0000000..bf9f831 --- /dev/null +++ b/src/process/apple.cpp @@ -0,0 +1,43 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "os.hpp" +#include "process.hpp" +#include "tmux.hpp" +#include "util.hpp" + +#include +#include +#include + +Process::Process(int pid) + : pid(pid) +{ + struct proc_bsdshortinfo sproc; + struct proc_bsdinfo proc; + + int status = proc_pidinfo(pid, PROC_PIDT_SHORTBSDINFO, 0, &sproc, PROC_PIDT_SHORTBSDINFO_SIZE); + if (status == PROC_PIDT_SHORTBSDINFO_SIZE) { + ppid = static_cast(sproc.pbsi_ppid); + } + + status = proc_pidinfo(pid, PROC_PIDTBSDINFO, 0, &proc, PROC_PIDTBSDINFO_SIZE); + if (status == PROC_PIDTBSDINFO_SIZE) { + tty_nr = static_cast(proc.e_tdev); + minor_dev = minor(tty_nr); + pty_path = fmt::format("/dev/ttys{:0>3}", minor_dev); + } +} diff --git a/src/process/linux.cpp b/src/process/linux.cpp new file mode 100644 index 0000000..9dbe05c --- /dev/null +++ b/src/process/linux.cpp @@ -0,0 +1,39 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "process.hpp" + +#include +#include +#include +#if defined(__FreeBSD__) || defined(__NetBSD__) +# include +#else +# include +#endif + +constexpr auto max_size = std::numeric_limits::max(); + +Process::Process(int pid) + : pid(pid) +{ + const auto stat = fmt::format("/proc/{}/stat", pid); + std::ifstream ifs(stat); + ifs.ignore(max_size, ')'); // skip pid and executable name + ifs >> state >> ppid >> process_group_id >> session_id >> tty_nr; + minor_dev = minor(tty_nr); // NOLINT + pty_path = fmt::format("/dev/pts/{}", minor_dev); +} diff --git a/src/terminal.cpp b/src/terminal.cpp new file mode 100644 index 0000000..e093238 --- /dev/null +++ b/src/terminal.cpp @@ -0,0 +1,335 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "terminal.hpp" +#include "flags.hpp" +#include "os.hpp" +#include "process.hpp" +#include "tmux.hpp" +#include "util.hpp" +#ifdef ENABLE_X11 +# include "util/x11.hpp" +#endif +#ifdef ENABLE_WAYLAND +# include "canvas/wayland/config.hpp" +#endif + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +Terminal::Terminal() + : terminal_pid(pid) +{ + flags = Flags::instance(); + logger = spdlog::get("terminal"); + term = os::getenv("TERM").value_or("xterm-256color"); + term_program = os::getenv("TERM_PROGRAM").value_or(""); + logger->info("TERM = {}", term); + if (!term_program.empty()) { + logger->info("TERM_PROGRAM = {}", term_program); + } + open_first_pty(); + get_terminal_size(); + set_detected_output(); +} + +Terminal::~Terminal() +{ + if (pty_fd > 0) { + close(pty_fd); + } +} + +void Terminal::get_terminal_size() +{ + struct winsize size; + ioctl(pty_fd, TIOCGWINSZ, &size); + cols = size.ws_col; + rows = size.ws_row; + xpixel = size.ws_xpixel; + ypixel = size.ws_ypixel; + logger->debug("ioctl sizes: COLS={} ROWS={} XPIXEL={} YPIXEL={}", cols, rows, xpixel, ypixel); + + check_iterm2_support(); + if (flags->use_escape_codes) { + init_termios(); + if (xpixel == 0 || ypixel == 0) { + get_terminal_size_escape_code(); + } + if (xpixel == 0 || ypixel == 0) { + get_terminal_size_xtsm(); + } + check_sixel_support(); + check_kitty_support(); + reset_termios(); + } + + get_fallback_x11_terminal_sizes(); + get_fallback_wayland_terminal_sizes(); + + if (xpixel == 0 || ypixel == 0) { + xpixel = fallback_xpixel; + ypixel = fallback_ypixel; + } + if (xpixel == 0 || ypixel == 0) { + throw std::runtime_error("Unable to calculate terminal sizes"); + } + + const double padding_horiz = guess_padding(cols, xpixel); + const double padding_vert = guess_padding(rows, ypixel); + + padding_horizontal = static_cast(std::max(padding_horiz, padding_vert)); + padding_vertical = padding_horizontal; + font_width = static_cast( + std::floor(guess_font_size(cols, static_cast(xpixel), static_cast(padding_horizontal)))); + font_height = static_cast( + std::floor(guess_font_size(rows, static_cast(ypixel), static_cast(padding_vertical)))); + + if (xpixel < fallback_xpixel && ypixel < fallback_ypixel) { + padding_horizontal = static_cast((fallback_xpixel - xpixel) / 2); + padding_vertical = static_cast((fallback_ypixel - ypixel) / 2); + font_width = static_cast(xpixel / cols); + font_height = static_cast(ypixel / rows); + } + + logger->debug("padding_horiz={} padding_vert={}", padding_horizontal, padding_vertical); + logger->debug("font_width={} font_height={}", font_width, font_height); +} + +void Terminal::set_detected_output() +{ + if (supports_sixel) { + detected_output = "sixel"; + } + if (supports_kitty) { + detected_output = "kitty"; + } + if (supports_iterm2) { + detected_output = "iterm2"; + } + if (supports_x11) { + detected_output = "x11"; + } + if (supports_wayland) { + detected_output = "wayland"; + } + if (flags->output.empty()) { + if (detected_output.empty()) { + flags->output = "chafa"; + } else { + flags->output = detected_output; + } + } +} + +auto Terminal::guess_padding(uint16_t chars, double pixels) -> double +{ + const double font_size = std::floor(pixels / chars); + return (pixels - font_size * chars) / 2; +} + +auto Terminal::guess_font_size(uint16_t chars, float pixels, float padding) -> float +{ + return (pixels - 2 * padding) / static_cast(chars); +} + +void Terminal::get_terminal_size_escape_code() +{ + const auto resp = read_raw_str("\033[14t").erase(0, 4); + if (resp.empty()) { + return; + } + const auto sizes = util::str_split(resp, ";"); + try { + ypixel = std::stoi(sizes[0]); + xpixel = std::stoi(sizes[1]); + } catch (const std::invalid_argument &) { + logger->debug("Got unexpected values in get_terminal_size_escape_code"); + } + // some old vte terminals respond to these values in a different order + // assume everything older than 7000 is broken + const auto vte_ver_str = os::getenv("VTE_VERSION").value_or(""); + if (!vte_ver_str.empty()) { + const auto vte_ver = std::stoi(vte_ver_str); + const auto working_ver = 7000; + if (vte_ver <= working_ver) { + std::swap(ypixel, xpixel); + } + } + logger->debug("ESC sizes XPIXEL={} YPIXEL={}", xpixel, ypixel); +} + +void Terminal::get_terminal_size_xtsm() +{ + const auto resp = read_raw_str("\033[?2;1;0S").erase(0, 3); + if (resp.empty()) { + return; + } + const auto sizes = util::str_split(resp, ";"); + if (sizes.size() != 4) { + return; + } + try { + ypixel = std::stoi(sizes[3]); + xpixel = std::stoi(sizes[2]); + } catch (const std::invalid_argument &) { + logger->debug("Got unexpected values in get_terminal_size_xtsm"); + } + logger->debug("XTSM sizes XPIXEL={} YPIXEL={}", xpixel, ypixel); +} + +void Terminal::check_sixel_support() +{ + // some terminals support sixel but don't respond to escape sequences + const auto supported_terms = std::unordered_set{"yaft-256color", "iTerm.app"}; + const auto resp = read_raw_str("\033[?1;1;0S").erase(0, 3); + const auto vals = util::str_split(resp, ";"); + if (vals.size() > 2 || supported_terms.contains(term) || supported_terms.contains(term_program)) { + supports_sixel = true; + logger->debug("sixel is supported"); + } else { + logger->debug("sixel is not supported"); + } +} + +void Terminal::check_kitty_support() +{ + const auto resp = read_raw_str("\033_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\033\\\033[c"); + if (resp.find("OK") != std::string::npos) { + supports_kitty = true; + logger->debug("kitty is supported"); + } else { + logger->debug("kitty is not supported"); + } +} + +void Terminal::check_iterm2_support() +{ + const auto supported_terms = std::unordered_set{"WezTerm", "iTerm.app"}; + if (supported_terms.contains(term_program)) { + supports_iterm2 = true; + logger->debug("iterm2 is supported"); + } else { + logger->debug("iterm2 is not supported"); + } +} + +auto Terminal::read_raw_str(const std::string_view esc) -> std::string +{ + const auto waitms = 100; + std::cout << esc << std::flush; + try { + const auto in_event = os::wait_for_data_on_stdin(waitms); + if (!in_event) { + return ""; + } + return os::read_data_from_stdin(esc.back()); + } catch (const std::system_error &) { + return ""; + } +} + +void Terminal::init_termios() +{ + tcgetattr(0, &old_term); /* grab old terminal i/o settings */ + new_term = old_term; /* make new settings same as old settings */ + new_term.c_lflag &= ~ICANON; /* disable buffered i/o */ + new_term.c_lflag &= ~ECHO; /* set echo mode */ + tcsetattr(0, TCSANOW, &new_term); /* use these new terminal i/o settings now */ +} + +void Terminal::reset_termios() const +{ + tcsetattr(0, TCSANOW, &old_term); +} + +void Terminal::get_fallback_x11_terminal_sizes() +{ +#ifdef ENABLE_X11 + const auto xutil = X11Util(); + if (xutil.connected) { + supports_x11 = true; + logger->debug("X11 is supported"); + } else { + logger->debug("x11 is not supported"); + return; + } + x11_wid = xutil.get_parent_window(terminal_pid); + logger->debug("Using fallback X11 window id {}", x11_wid); + const auto [xpix, ypix] = xutil.get_window_dimensions(x11_wid); + fallback_xpixel = xpix; + fallback_ypixel = ypix; + logger->debug("X11 sizes: XPIXEL={} YPIXEL={}", fallback_xpixel, fallback_ypixel); +#endif +} + +void Terminal::get_fallback_wayland_terminal_sizes() +{ +#ifdef ENABLE_WAYLAND + const auto config = WaylandConfig::get(); + if (!config->is_dummy()) { + supports_wayland = true; + logger->debug("Wayland is supported."); + } else { + logger->debug("Wayland is not supported"); + return; + } + const auto window = config->get_window_info(); + fallback_xpixel = static_cast(window.width); + fallback_ypixel = static_cast(window.height); +#endif +} + +void Terminal::open_first_pty() +{ + const auto pids = tmux::get_client_pids().value_or(std::vector{pid}); + + struct stat stat_info; + for (const auto spid : pids) { + auto tree = util::get_process_tree_v2(spid); + ranges::reverse(tree); + for (const auto &proc : tree) { + const int stat_res = stat(proc.pty_path.c_str(), &stat_info); + if (stat_res == -1) { + const auto err = std::error_code(errno, std::generic_category()); + logger->debug("stat failed ({}) for pty {}, pid {}, ignoring", err.message(), proc.pty_path, proc.pid); + continue; + } + if (proc.tty_nr == static_cast(stat_info.st_rdev)) { + pty_fd = open(proc.pty_path.c_str(), O_RDONLY | O_NOCTTY); + if (pty_fd == -1) { + const auto err = std::error_code(errno, std::generic_category()); + logger->debug("could not open pty {}, {}, ignoring", proc.pty_path, err.message()); + continue; + } + terminal_pid = proc.pid; + logger->info("PTY = {}", proc.pty_path); + return; + } + } + } + logger->warn("Could not open pty, using stdout as fallback"); + pty_fd = STDOUT_FILENO; +} diff --git a/src/tmux.cpp b/src/tmux.cpp new file mode 100644 index 0000000..b919d7d --- /dev/null +++ b/src/tmux.cpp @@ -0,0 +1,142 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "tmux.hpp" +#include "os.hpp" +#include "util.hpp" + +#include +#include +#include +#include + +constexpr auto session_hooks = std::to_array( + {"session-window-changed", "client-detached", "window-layout-changed"}); + +constexpr auto global_hooks = std::to_array( + {"client-session-changed"}); + +auto tmux::get_session_id() -> std::string +{ + const auto cmd = fmt::format("tmux display -p -F '#{{session_id}}' -t {}", tmux::get_pane()); + return os::exec(cmd); +} + +auto tmux::is_used() -> bool +{ + return !tmux::get_pane().empty(); +} + +auto tmux::is_window_focused() -> bool +{ + const auto cmd = fmt::format("tmux display -p -F '#{{session_attached}},#{{window_active}},#{{pane_in_mode}}' -t {}", tmux::get_pane()); + return os::exec(cmd) == "1,1,0"; +} + +auto tmux::get_pane() -> std::string +{ + return os::getenv("TMUX_PANE").value_or(""); +} + +auto tmux::get_client_pids() -> std::optional> +{ + if (!tmux::is_used()) { + return {}; + } + if (!tmux::is_window_focused()) { + return {}; + } + + std::vector pids; + const auto cmd = fmt::format("tmux list-clients -F '#{{client_pid}}' -t {}", tmux::get_pane()); + const auto output = os::exec(cmd); + + for (const auto &line : util::str_split(output, "\n")) { + pids.push_back(std::stoi(line)); + } + + return pids; +} + +auto tmux::get_offset() -> std::pair +{ + if (!tmux::is_used()) { + return std::make_pair(0, 0); + } + const auto [p_x, p_y] = tmux::get_pane_offset(); + const auto s_y = tmux::get_statusbar_offset(); + return std::make_pair(p_x, p_y + s_y); +} + +auto tmux::get_pane_offset() -> std::pair +{ + const auto cmd = fmt::format(R"(tmux display -p -F '#{{pane_top}},#{{pane_left}}, + #{{pane_bottom}},#{{pane_right}}, + #{{window_height}},#{{window_width}}' -t {})", + tmux::get_pane()); + const auto output = util::str_split(os::exec(cmd), ","); + return std::make_pair(std::stoi(output.at(1)), std::stoi(output.at(0))); +} + +auto tmux::get_statusbar_offset() -> int +{ + const std::string cmd = "tmux display -p '#{status},#{status-position}'"; + const auto output = util::str_split(os::exec(cmd), ","); + if (output.at(1) != "top" || output.at(0) == "off") { + return 0; + } + if (output.at(0) == "on") { + return 1; + } + return std::stoi(output.at(0)); +} + +void tmux::handle_hook(const std::string_view hook, int pid) +{ + const auto msg = fmt::format(R"({{"action":"tmux","hook":"{}"}})", hook); + const auto endpoint = util::get_socket_path(pid); + util::send_socket_message(msg, endpoint); +} + +void tmux::register_hooks() +{ + if (!tmux::is_used()) { + return; + } + for (const auto &hook : session_hooks) { + std::string cmd = fmt::format(R"(tmux set-hook -t {0} {1} "run-shell 'ueberzugpp tmux {1} {2}'")", tmux::get_pane(), hook, os::get_pid()); + os::exec(cmd); + } + for (const auto &hook : global_hooks) { + std::string cmd = fmt::format(R"(tmux set-hook -g {0} "run-shell 'ueberzugpp tmux {0} {1}'")", hook, os::get_pid()); + os::exec(cmd); + } +} + +void tmux::unregister_hooks() +{ + if (!tmux::is_used()) { + return; + } + for (const auto &hook : session_hooks) { + const auto cmd = fmt::format("tmux set-hook -u -t {} {}", tmux::get_pane(), hook); + os::exec(cmd); + } + for (const auto &hook : global_hooks) { + const auto cmd = fmt::format("tmux set-hook -gu {}", hook); + os::exec(cmd); + } +} diff --git a/src/util/dbus.cpp b/src/util/dbus.cpp new file mode 100644 index 0000000..1cc78e5 --- /dev/null +++ b/src/util/dbus.cpp @@ -0,0 +1,15 @@ +#include "util/dbus.hpp" +#include + +DbusUtil::DbusUtil(const std::string &address) + : connection(dbus_connection_open(address.c_str(), nullptr)) +{ + if (connection == nullptr) { + throw std::invalid_argument("Could not connect to dbus address"); + } +} + +DbusUtil::~DbusUtil() +{ + dbus_connection_unref(connection); +} diff --git a/src/util/egl.cpp b/src/util/egl.cpp new file mode 100644 index 0000000..5b64459 --- /dev/null +++ b/src/util/egl.cpp @@ -0,0 +1,228 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "util/egl.hpp" +#include "image.hpp" + +#include +#include + +#include +#include + +constexpr EGLint egl_major_version = 1; +constexpr EGLint egl_minor_version = 5; +constexpr EGLint opengl_major_version = 4; +constexpr EGLint opengl_minor_version = 6; + +constexpr auto config_attrs = std::to_array({EGL_SURFACE_TYPE, + EGL_WINDOW_BIT, + EGL_CONFORMANT, + EGL_OPENGL_BIT, + EGL_RENDERABLE_TYPE, + EGL_OPENGL_BIT, + EGL_COLOR_BUFFER_TYPE, + EGL_RGB_BUFFER, + + EGL_RED_SIZE, + 8, + EGL_GREEN_SIZE, + 8, + EGL_BLUE_SIZE, + 8, + EGL_ALPHA_SIZE, + 8, + + EGL_DEPTH_SIZE, + 24, + EGL_STENCIL_SIZE, + 8, + + EGL_NONE}); + +const auto context_attrs = std::to_array( + {EGL_CONTEXT_MAJOR_VERSION, opengl_major_version, EGL_CONTEXT_MINOR_VERSION, opengl_minor_version, +#ifdef DEBUG + EGL_CONTEXT_OPENGL_DEBUG, EGL_TRUE, +#endif + EGL_CONTEXT_OPENGL_ROBUST_ACCESS, EGL_TRUE, EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, + EGL_NONE}); + +void GLAPIENTRY debug_callback([[maybe_unused]] GLenum source, [[maybe_unused]] GLenum type, + [[maybe_unused]] GLuint gl_id, GLenum severity, [[maybe_unused]] GLsizei length, + const GLchar *message, [[maybe_unused]] const void *user) +{ + if (type != GL_DEBUG_TYPE_ERROR) { + return; + } + const auto logger = spdlog::get("opengl"); + logger->error("Type: {:#X}, Severity: {:#X}, Message: {}", type, severity, message); +} + +template +EGLUtil::EGLUtil(EGLenum platform, T *native_display, const EGLAttrib *attrib) + : display(eglGetPlatformDisplay(platform, native_display, attrib)) +{ + logger = spdlog::get("opengl"); + + if (display == EGL_NO_DISPLAY) { + const auto err = error_to_string(); + logger->error("Could not obtain display, error {}", err); + throw std::runtime_error(""); + } + + EGLint egl_major = 0; + EGLint egl_minor = 0; + EGLBoolean eglres = eglInitialize(display, &egl_major, &egl_minor); + if (eglres != EGL_TRUE) { + const auto err = error_to_string(); + logger->error("Could not initialize display, error {}", err); + throw std::runtime_error(""); + } + if (egl_major != egl_major_version && egl_minor != egl_minor_version) { + logger->error("EGL {}.{} is not available", egl_major_version, egl_minor_version); + throw std::runtime_error(""); + } + + eglres = eglBindAPI(EGL_OPENGL_API); + if (eglres != EGL_TRUE) { + const auto err = error_to_string(); + logger->error("Could not bind to OpenGL API, error {}", err); + throw std::runtime_error(""); + } + + int num_config = 0; + eglres = eglChooseConfig(display, config_attrs.data(), &config, 1, &num_config); + if (eglres != EGL_TRUE || num_config != 1) { + const auto err = error_to_string(); + logger->error("Could not create config, error {}", err); + throw std::runtime_error(""); + } + + logger->info("Using EGL {}.{} and OpenGL {}.{}", egl_major_version, egl_minor_version, opengl_major_version, + opengl_minor_version); +} + +template +EGLUtil::~EGLUtil() +{ + eglTerminate(display); +} + +template +auto EGLUtil::error_to_string() const -> std::string +{ + using pair_type = std::pair; + constexpr auto error_codes = std::to_array({ + {EGL_SUCCESS, "EGL_SUCCESS"}, + {EGL_BAD_ACCESS, "EGL_BAD_ACCESS"}, + {EGL_BAD_ALLOC, "EGL_BAD_ALLOC"}, + {EGL_BAD_ATTRIBUTE, "EGL_BAD_ATTRIBUTE"}, + {EGL_BAD_CONFIG, "EGL_BAD_CONFIG"}, + {EGL_BAD_CONTEXT, "EGL_BAD_CONTEXT"}, + {EGL_BAD_CURRENT_SURFACE, "EGL_BAD_CURRENT_SURFACE"}, + {EGL_BAD_DISPLAY, "EGL_BAD_DISPLAY"}, + {EGL_BAD_MATCH, "EGL_BAD_MATCH"}, + {EGL_BAD_NATIVE_PIXMAP, "EGL_BAD_NATIVE_PIXMAP"}, + {EGL_BAD_NATIVE_WINDOW, "EGL_BAD_NATIVE_WINDOW"}, + {EGL_BAD_PARAMETER, "EGL_BAD_PARAMETER"}, + {EGL_BAD_SURFACE, "EGL_BAD_SURFACE"}, + }); + + const auto current_error = eglGetError(); + + const auto found = + ranges::find_if(error_codes, [current_error](const pair_type &pair) { return pair.first == current_error; }); + + if (found == error_codes.end()) { + return "EGL_UNKNOWN_ERROR"; + } + + return std::string(found->second); +} + +template +auto EGLUtil::create_context(EGLSurface surface) const -> EGLContext +{ + EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attrs.data()); + if (context == EGL_NO_CONTEXT) { + const auto err = error_to_string(); + logger->error("Could not create context, error {}", err); + return context; + } + +#ifdef DEBUG + run_contained(surface, context, [] { + glDebugMessageCallback(debug_callback, nullptr); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + }); +#endif + + return context; +} + +template +auto EGLUtil::create_surface(V *native_window) const -> EGLSurface +{ + EGLSurface surface = eglCreatePlatformWindowSurface(display, config, native_window, nullptr); + if (surface == EGL_NO_SURFACE) { + const auto err = error_to_string(); + logger->error("Could not create surface, error {}", err); + } + return surface; +} + +template +void EGLUtil::make_current(EGLSurface surface, EGLContext context) const +{ + eglMakeCurrent(display, surface, surface, context); +} + +template +void EGLUtil::restore() const +{ + eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); +} + +template +void EGLUtil::run_contained(EGLSurface surface, EGLContext context, const std::function &func) const +{ + make_current(surface, context); + func(); + restore(); +} + +template +void EGLUtil::get_texture_from_image(const Image &image, GLuint texture) const +{ + glBindTexture(GL_TEXTURE_2D, texture); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.width(), image.height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, image.data()); +} + +#ifdef ENABLE_X11 +# include +template class EGLUtil; +#endif + +#ifdef ENABLE_WAYLAND +# include +# include +template class EGLUtil; +#endif diff --git a/src/util/socket.cpp b/src/util/socket.cpp new file mode 100644 index 0000000..d770270 --- /dev/null +++ b/src/util/socket.cpp @@ -0,0 +1,169 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "util/socket.hpp" + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "os.hpp" +#include "util.hpp" + +namespace fs = std::filesystem; + +UnixSocket::UnixSocket(const std::string_view endpoint) + : fd(socket(AF_UNIX, SOCK_STREAM, 0)) +{ + if (fd == -1) { + throw std::system_error(errno, std::generic_category()); + } + connect_to_endpoint(endpoint); +} + +UnixSocket::UnixSocket() + : fd(socket(AF_UNIX, SOCK_STREAM, 0)) +{ + if (fd == -1) { + throw std::system_error(errno, std::generic_category()); + } + const int bufsize = 8192; + buffer.reserve(bufsize); +} + +void UnixSocket::connect_to_endpoint(const std::string_view endpoint) +{ + if (!fs::exists(endpoint)) { + connected = false; + return; + } + struct sockaddr_un sock; + std::memset(&sock, 0, sizeof(sockaddr_un)); + sock.sun_family = AF_UNIX; + endpoint.copy(sock.sun_path, endpoint.size()); + + int res = connect(fd, reinterpret_cast(&sock), sizeof(struct sockaddr_un)); + if (res == -1) { + throw std::system_error(errno, std::generic_category()); + } +} + +void UnixSocket::bind_to_endpoint(const std::string_view endpoint) const +{ + struct sockaddr_un sock; + std::memset(&sock, 0, sizeof(sockaddr_un)); + sock.sun_family = AF_UNIX; + endpoint.copy(sock.sun_path, endpoint.size()); + + int res = bind(fd, reinterpret_cast(&sock), sizeof(struct sockaddr_un)); + if (res == -1) { + throw std::system_error(errno, std::generic_category()); + } + res = listen(fd, SOMAXCONN); + if (res == -1) { + throw std::system_error(errno, std::generic_category()); + } +} + +auto UnixSocket::wait_for_connections(int waitms) const -> int +{ + const auto in_event = os::wait_for_data_on_fd(fd, waitms); + if (in_event) { + return accept(fd, nullptr, nullptr); + } + return -1; +} + +auto UnixSocket::read_data_from_connection(int filde) -> std::vector +{ + // a single connection could send multiples commands at once + // each command should end with a '\n' character + const int read_buffer_size = 4096; + std::array read_buffer; + while (true) { + const auto status = recv(filde, read_buffer.data(), read_buffer_size, 0); + if (status <= 0) { + break; + } + buffer.append(read_buffer.data(), status); + } + auto cmds = util::str_split(buffer, "\n"); + buffer.clear(); + close(filde); + return cmds; +} + +void UnixSocket::write(const void *data, std::size_t len) const +{ + if (!connected) { + return; + } + const auto *runner = static_cast(data); + while (len != 0) { + const auto status = send(fd, runner, len, MSG_NOSIGNAL); + if (status == -1) { + throw std::system_error(errno, std::generic_category()); + } + len -= status; + runner += status; + } +} + +void UnixSocket::read(void *data, std::size_t len) const +{ + if (!connected) { + return; + } + auto *runner = static_cast(data); + while (len != 0) { + const auto status = recv(fd, runner, len, 0); + if (status == 0) { + return; // no data + } + if (status == -1) { + throw std::system_error(errno, std::generic_category()); + } + len -= status; + runner += status; + } +} + +auto UnixSocket::read_until_empty() const -> std::string +{ + std::string result; + const int read_buffer_size = 4096; + std::array read_buffer; + result.reserve(read_buffer_size); + while (true) { + const auto status = recv(fd, read_buffer.data(), read_buffer_size, 0); + if (status <= 0) { + break; + } + result.append(read_buffer.data(), status); + } + return result; +} + +UnixSocket::~UnixSocket() +{ + close(fd); +} diff --git a/src/util/util.cpp b/src/util/util.cpp new file mode 100644 index 0000000..2d3e99f --- /dev/null +++ b/src/util/util.cpp @@ -0,0 +1,262 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "util.hpp" +#include "flags.hpp" +#include "os.hpp" +#include "process.hpp" +#include "util/ptr.hpp" +#include "util/socket.hpp" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#if OPENSSL_VERSION_NUMBER < 0x10100000L +# define EVP_MD_CTX_new EVP_MD_CTX_create +# define EVP_MD_CTX_free EVP_MD_CTX_destroy +#endif +#ifdef ENABLE_TURBOBASE64 +# ifdef WITH_SYSTEM_TURBOBASE64 +# include +# else +# include "turbob64.h" +# endif +#endif +#include + +#include + +namespace fs = std::filesystem; +using njson = nlohmann::json; + +auto util::str_split(std::string_view str, std::string_view delim) -> std::vector +{ + std::vector result; + for (const auto word : ranges::views::split(str, delim)) { + result.emplace_back(ranges::to(word)); + } + return result; +} + +auto util::get_process_tree(int pid) -> std::vector +{ + std::vector res; + Process runner(pid); + while (runner.pid > 1) { + res.push_back(runner.pid); + runner = Process(runner.ppid); + } + return res; +} + +auto util::get_process_tree_v2(int pid) -> std::vector +{ + std::vector tree; + Process runner(pid); + while (runner.pid > 1) { + tree.push_back(runner); + runner = Process(runner.ppid); + } + return tree; +} + +auto util::get_cache_path() -> std::string +{ + const auto home = os::getenv("HOME").value_or(util::temp_directory_path()); + const auto cache_home = os::getenv("XDG_CACHE_HOME").value_or(fmt::format("{}/.cache", home)); + return fmt::format("{}/ueberzugpp/", cache_home); +} + +auto util::get_log_filename() -> std::string +{ + const auto user = os::getenv("USER").value_or("NOUSER"); + return fmt::format("ueberzugpp-{}.log", user); +} + +auto util::get_socket_path(int pid) -> std::string +{ + return fmt::format("{}/ueberzugpp-{}.socket", util::temp_directory_path().string(), pid); +} + +void util::send_socket_message(const std::string_view msg, const std::string_view endpoint) +{ + try { + UnixSocket socket; + socket.connect_to_endpoint(endpoint); + socket.write(msg.data(), msg.size()); + } catch (const std::system_error &err) { + return; + } +} + +auto util::base64_encode(const unsigned char *input, size_t length) -> std::string +{ + const size_t bufsize = 4 * ((length + 2) / 3) + 1; + std::vector res(bufsize, 0); + base64_encode_v2(input, length, reinterpret_cast(res.data())); + return {res.data()}; +} + +void util::base64_encode_v2(const unsigned char *input, size_t length, unsigned char *out) +{ +#ifdef ENABLE_TURBOBASE64 + tb64enc(input, length, out); +#else + EVP_EncodeBlock(out, input, static_cast(length)); +#endif +} + +auto util::get_b2_hash_ssl(const std::string_view str) -> std::string +{ + std::stringstream sstream; + const auto mdctx = c_unique_ptr{EVP_MD_CTX_new()}; +#ifdef LIBRESSL_VERSION_NUMBER + const auto *evp = EVP_sha256(); +#else + const auto *evp = EVP_blake2b512(); +#endif + auto digest = std::array(); + + EVP_DigestInit_ex(mdctx.get(), evp, nullptr); + EVP_DigestUpdate(mdctx.get(), str.data(), str.size()); + unsigned int digest_len = 0; + EVP_DigestFinal_ex(mdctx.get(), digest.data(), &digest_len); + + sstream << std::hex << std::setw(2) << std::setfill('0'); + for (unsigned int i = 0; i < digest_len; ++i) { + sstream << static_cast(digest[i]); + } + return sstream.str(); +} + +void util::move_cursor(int row, int col) +{ + std::cout << "\033[" << row << ";" << col << "f" << std::flush; +} + +void util::save_cursor_position() +{ + std::cout << "\0337" << std::flush; +} + +void util::restore_cursor_position() +{ + std::cout << "\0338" << std::flush; +} + +auto util::get_cache_file_save_location(const fs::path &path) -> std::string +{ + return fmt::format("{}{}{}", get_cache_path(), get_b2_hash_ssl(path.string()), path.extension().string()); +} + +void util::benchmark(const std::function &func) +{ + using std::chrono::duration; + using std::chrono::duration_cast; + using std::chrono::high_resolution_clock; + using std::chrono::milliseconds; + + const auto ti1 = high_resolution_clock::now(); + func(); + const auto ti2 = high_resolution_clock::now(); + const duration ms_double = ti2 - ti1; + + std::cout << ms_double.count() << "ms\n"; +} + +void util::send_command(const Flags &flags) +{ + if (flags.cmd_action == "exit") { + util::send_socket_message("EXIT", flags.cmd_socket); + return; + } + + if (flags.cmd_action == "remove") { + const njson json = {{"action", "remove"}, {"identifier", flags.cmd_id}}; + util::send_socket_message(json.dump(), flags.cmd_socket); + return; + } + + const njson json = {{"action", flags.cmd_action}, + {"identifier", flags.cmd_id}, + {"max_width", std::stoi(flags.cmd_max_width)}, + {"max_height", std::stoi(flags.cmd_max_height)}, + {"x", std::stoi(flags.cmd_x)}, + {"y", std::stoi(flags.cmd_y)}, + {"path", flags.cmd_file_path}}; + util::send_socket_message(json.dump(), flags.cmd_socket); +} + +void util::clear_terminal_area(int xcoord, int ycoord, int width, int height) +{ + save_cursor_position(); + const auto line_clear = std::string(width, ' '); + for (int i = ycoord; i <= height + 2; ++i) { + util::move_cursor(i, xcoord); + std::cout << line_clear; + } + std::cout << std::flush; + restore_cursor_position(); +} + +auto util::generate_random_string(size_t length) -> std::string +{ + constexpr auto chars = + std::to_array({'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', + 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}); + auto rng_dev = std::random_device(); + auto rng = std::mt19937(rng_dev()); + auto dist = std::uniform_int_distribution{{}, chars.size() - 1}; + std::string result(length, 0); + std::generate_n(std::begin(result), length, [&chars, &dist, &rng] { return chars[dist(rng)]; }); + return result; +} + +auto util::read_exif_rotation(const fs::path &path) -> std::optional +{ + try { + auto image = vips::VImage::new_from_file(path.c_str()); + return image.get_int("orientation"); + } catch (const vips::VError &) { + return {}; + } +} + +auto util::round_up(int num_to_round, int multiple) -> int +{ + if (multiple == 0) { + return num_to_round; + } + + int remainder = num_to_round % multiple; + if (remainder == 0) { + return num_to_round; + } + + return num_to_round + multiple - remainder; +} + +auto util::temp_directory_path() -> fs::path +{ + return os::getenv("UEBERZUGPP_TMPDIR").value_or(fs::temp_directory_path()); +} diff --git a/src/util/x11.cpp b/src/util/x11.cpp new file mode 100644 index 0000000..5250997 --- /dev/null +++ b/src/util/x11.cpp @@ -0,0 +1,171 @@ +// Display images inside a terminal +// Copyright (C) 2023 JustKidding +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "util/x11.hpp" +#include "flags.hpp" +#include "os.hpp" +#include "util.hpp" +#include "util/ptr.hpp" + +#include +#include +#include + +#include +#include +#include +#include + +X11Util::X11Util() + : connection(xcb_connect(nullptr, nullptr)) +{ + const auto flags = Flags::instance(); + const auto xdg_session = os::getenv("XDG_SESSION_TYPE").value_or(""); + if (xcb_connection_has_error(connection) == 0) { + screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data; + if (xdg_session != "wayland" || flags->output == "x11") { + connected = true; + } + } +} + +X11Util::X11Util(xcb_connection_t *connection) + : connection(connection), + screen(xcb_setup_roots_iterator(xcb_get_setup(connection)).data), + owns_connection(false) +{ +} + +X11Util::~X11Util() +{ + if (owns_connection) { + xcb_disconnect(connection); + } +} + +auto X11Util::get_server_window_ids() const -> std::vector +{ + const int num_clients = 256; + std::vector windows; + std::stack cookies_st; + windows.reserve(num_clients); + + cookies_st.push(xcb_query_tree_unchecked(connection, screen->root)); + + while (!cookies_st.empty()) { + const auto cookie = cookies_st.top(); + cookies_st.pop(); + + const auto reply = unique_C_ptr{xcb_query_tree_reply(connection, cookie, nullptr)}; + if (!reply) { + continue; + } + + const auto num_children = xcb_query_tree_children_length(reply.get()); + if (num_children == 0) { + continue; + } + const auto *children = xcb_query_tree_children(reply.get()); + for (int i = 0; i < num_children; ++i) { + const auto child = children[i]; + const bool is_complete_window = window_has_properties(child, {XCB_ATOM_WM_CLASS, XCB_ATOM_WM_NAME}); + if (is_complete_window) { + windows.push_back(child); + } + cookies_st.push(xcb_query_tree_unchecked(connection, child)); + } + } + return windows; +} + +auto X11Util::get_pid_window_map() const -> std::unordered_map +{ + const auto windows = get_server_window_ids(); + std::unordered_map res; + std::vector cookies; + res.reserve(windows.size()); + cookies.reserve(windows.size()); + + struct xcb_res_client_id_spec_t spec; + spec.mask = XCB_RES_CLIENT_ID_MASK_LOCAL_CLIENT_PID; + + // bulk request pids + for (const auto window : windows) { + spec.client = window; + cookies.push_back(xcb_res_query_client_ids_unchecked(connection, 1, &spec)); + } + + // process replies + auto win_iter = windows.cbegin(); + for (const auto cookie : cookies) { + const auto reply = + unique_C_ptr{xcb_res_query_client_ids_reply(connection, cookie, nullptr)}; + if (!reply) { + continue; + } + const auto iter = xcb_res_query_client_ids_ids_iterator(reply.get()); + const auto pid = *xcb_res_client_id_value_value(iter.data); + res.insert_or_assign(pid, *win_iter); + std::advance(win_iter, 1); + } + return res; +} + +auto X11Util::window_has_properties(xcb_window_t window, std::initializer_list properties) const -> bool +{ + std::vector cookies; + cookies.reserve(properties.size()); + for (const auto prop : properties) { + cookies.push_back(xcb_get_property_unchecked(connection, 0, window, prop, XCB_ATOM_ANY, 0, 4)); + } + return ranges::any_of(cookies, [this](xcb_get_property_cookie_t cookie) -> bool { + const auto reply = unique_C_ptr{xcb_get_property_reply(connection, cookie, nullptr)}; + return reply && xcb_get_property_value_length(reply.get()) != 0; + }); +} + +auto X11Util::get_window_dimensions(xcb_window_t window) const -> std::pair +{ + const auto cookie = xcb_get_geometry_unchecked(connection, window); + const auto reply = unique_C_ptr{xcb_get_geometry_reply(connection, cookie, nullptr)}; + if (!reply) { + return std::make_pair(0, 0); + } + return std::make_pair(reply->width, reply->height); +} + +auto X11Util::get_parent_window(int pid) const -> xcb_window_t +{ + const auto wid = os::getenv("WINDOWID"); + if (wid.has_value()) { + try { + return std::stoi(wid.value()); + } catch (const std::out_of_range &oor) { + return 0; + } + } + + const auto pid_window_map = get_pid_window_map(); + const auto tree = util::get_process_tree(pid); + for (const auto spid : tree) { + const auto win = pid_window_map.find(spid); + if (win != pid_window_map.end()) { + return win->second; + } + } + + return 0; +} -- cgit v1.2.3