ACMXVK/app/playlist.cpp

Go to the documentation of this file.

#include "playlist.hpp"
 
#include "../input_validation.hpp"
 
#include <algorithm>
#include <cctype>
#include <fstream>
#include <ostream>
#include <stdexcept>
#include <string_view>
#include <utility>
 
namespace acmxvk {
    namespace {
        [[nodiscard]] std::string trim_text(std::string text) {
            const auto first = std::find_if_not(
                text.begin(), text.end(),
                [](unsigned char character) { return std::isspace(character); });
            const auto last = std::find_if_not(
                                  text.rbegin(), text.rend(),
                                  [](unsigned char character) { return std::isspace(character); })
                                  .base();
            if (first >= last) {
                return {};
            }
            return std::string(first, last);
        }
    } // namespace
 
    fs::path find_shader_path(
        const std::vector<fs::path> &available_shaders,
        const fs::path &library_directory, std::string name) {
        name = trim_text(std::move(name));
        if (name.empty()) {
            return {};
        }
 
        fs::path requested(name);
        if (requested.extension() != ".spv") {
            requested += ".spv";
        }
        const auto match = std::find_if(
            available_shaders.begin(), available_shaders.end(),
            [&](const fs::path &shader) {
                return shader.filename() == requested.filename() ||
                       (!library_directory.empty() &&
                        shader.lexically_relative(library_directory) ==
                            requested);
            });
        return match == available_shaders.end() ? fs::path{} : *match;
    }
 
    std::vector<PlaylistNode>
    load_playlist(const fs::path &playlist_path,
                  const std::vector<fs::path> &available_shaders,
                  const fs::path &library_directory,
                  std::ostream &warning_output) {
        input::validate_file_size(playlist_path, "shader playlist");
        std::ifstream playlist_input(playlist_path);
        if (!playlist_input) {
            throw std::runtime_error("unable to open playlist: " +
                                     playlist_path.string());
        }
 
        std::vector<PlaylistNode> playlist;
        PlaylistNode *current_node = nullptr;
        std::vector<fs::path> default_entries;
        std::string line;
        std::size_t line_number = 1;
        std::size_t entry_count = 0;
        while (input::read_bounded_line(playlist_input, line,
                                        "shader playlist", line_number++)) {
            line = trim_text(std::move(line));
            if (line.empty() || line.front() == '#') {
                continue;
            }
            if (line.size() >= 2 && line.front() == '[' &&
                line.back() == ']') {
                if (playlist.size() >= input::MAX_PLAYLIST_NODES) {
                    throw std::runtime_error(
                        "shader playlist contains too many nodes");
                }
                std::string node_name =
                    trim_text(line.substr(1, line.size() - 2));
                input::validate_string(node_name,
                                       input::StringKind::DisplayText,
                                       "shader playlist node");
                playlist.push_back({std::move(node_name), {}});
                current_node = &playlist.back();
                continue;
            }
            if (line.front() == '[' || line.back() == ']') {
                throw std::runtime_error(
                    "malformed shader playlist node at line " +
                    std::to_string(line_number - 1));
            }
            if (++entry_count > input::MAX_PLAYLIST_ENTRIES) {
                throw std::runtime_error(
                    "shader playlist contains too many entries");
            }
            input::validate_string(line, input::StringKind::Path,
                                   "shader playlist entry");
 
            const fs::path shader = find_shader_path(
                available_shaders, library_directory, line);
            if (shader.empty()) {
                warning_output << "acmxvk: playlist shader not found: " << line
                               << '\n';
                continue;
            }
            if (current_node != nullptr) {
                current_node->shaders.push_back(shader);
            } else {
                default_entries.push_back(shader);
            }
        }
 
        playlist.erase(std::remove_if(playlist.begin(), playlist.end(),
                                      [](const PlaylistNode &node) {
                                          return node.shaders.empty();
                                      }),
                       playlist.end());
        if (!default_entries.empty()) {
            playlist.insert(playlist.begin(),
                            {"Default", std::move(default_entries)});
        }
        if (playlist.empty()) {
            throw std::runtime_error(
                "playlist contains no shaders available in the SPIR-V library");
        }
        return playlist;
    }
 
    std::size_t
    playlist_shader_count(const std::vector<PlaylistNode> &playlist) noexcept {
        std::size_t count = 0;
        for (const PlaylistNode &node : playlist) {
            count += node.shaders.size();
        }
        return count;
    }
} // namespace acmxvk