musix 0.3.3

Music player library for esoteric audio formats (music from C64,Amiga etc)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#pragma once

#include <atomic>
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>

class STIL
{
public:
#pragma pack(push, 1)
    struct LengthEntry
    {
        uint64_t hash;
        uint16_t length;
        uint16_t stil;

        LengthEntry() = default;
        LengthEntry(uint64_t h, uint16_t l, uint16_t st)
            : hash(h), length(l), stil(st)
        {
        }
        bool operator<(const LengthEntry& other) const
        {
            return hash < other.hash;
        }
        bool operator<(uint64_t other) const { return hash < other; }
    }; //__attribute__((packed));
#pragma pack(pop)

    std::vector<LengthEntry> mainHash;
    std::vector<uint16_t> extraLengths;

    struct STILInfo
    {
        int subSong;
        int seconds;
        std::string title;
        std::string name;
        std::string artist;
        std::string author;
        std::string comment;
    };

    struct STILSong
    {
        STILSong() = default;
        STILSong(const std::vector<STILInfo>& _songs,
                 const std::string& _comment)
            : songs(_songs), comment(_comment)
        {
        }
        std::string title;
        std::string composer;
        std::string copyright;

        std::vector<STILInfo> songs;
        std::string comment;
        std::vector<uint16_t> lengths;
    };

    explicit STIL(std::filesystem::path const& data_dir);
    ~STIL();

    std::vector<uint16_t> getLengths(LengthEntry const& entry);
    std::atomic<bool> ready{false};

private:
    std::unordered_map<std::string, STILSong> stilSongs;
    std::vector<STILSong> stilArray;

    std::thread initThread;
    std::filesystem::path dataDir;
    bool stopInitThread{};

    static constexpr uint16_t a2h(char c)
    {
        return c <= '9' ? c - '0' : (tolower(c) - 'a' + 10);
    }

    template <typename T> static constexpr T from_hex(const std::string& s)
    {
        T t = 0;
        const auto* ptr = s.c_str();
        while (*ptr) {
            t = (t << 4U) | a2h(*ptr++);
        }
        return t;
    }

public:
    static uint64_t calculateMD5(const std::string& fileName);

    void readSTIL();
    void readLengths();

    std::optional<STILSong> findSTIL(std::string const& fileName);
    STILSong getInfo(std::vector<uint8_t> const& data);
    std::vector<uint16_t> findLengths(uint64_t key);
    std::vector<uint16_t> findLengths(std::vector<uint8_t> const& data);
};