musix 0.3.5

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

#pragma once

#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>

namespace musix {

using MetaVar = std::variant<std::string, double, uint32_t>;

class player_exception : public std::exception
{
public:
    explicit player_exception(const std::string& msg = "") : msg(msg) {}
    const char* what() const noexcept override { return msg.c_str(); }

private:
    std::string msg;
};

class ChipPlayer
{
public:
    using Callback =
        std::function<void(const std::vector<std::string>& meta)>;

    virtual ~ChipPlayer() = default;
    virtual int getSamples(int16_t* target, int size) = 0;

    virtual int getHZ() { return 44100; }

    virtual bool setParameter(const std::string& /*name*/, int32_t /*value*/)
    {
        return false;
    }
    virtual bool setParameter(const std::string& /*name*/,
                              const std::string& /*value*/)
    {
        return false;
    }

    MetaVar const& meta(std::string const& what) { return metaData[what]; }

    void setMeta()
    {
        if (!changedMeta.empty()) {
            for (const auto& cb : callbacks) {
                cb(changedMeta);
            }
            for(auto&& cm : changedMeta) {
                lastMeta.insert(cm);
            }
            changedMeta.clear();
        }
    }

    std::optional<std::string> getChangedMeta()
    {
        if (lastMeta.empty()) { return std::nullopt; }
        auto res = *lastMeta.begin();
        lastMeta.erase(res);
        return res;
    }

    template <typename T, typename... A,
              typename = typename std::enable_if<std::is_integral_v<T>>::type>
    void setMeta(const std::string& what, T value, const A&... args)
    {
        metaData[what] = static_cast<uint32_t>(value);
        changedMeta.push_back(what);
        setMeta(args...);
    }

    template <typename... A>
    void setMeta(const std::string& what, double value, const A&... args)
    {
        metaData[what] = value;
        changedMeta.push_back(what);
        setMeta(args...);
    }

    template <typename... A>
    void setMeta(const std::string& what, const MetaVar& value,
                 const A&... args)
    {
        metaData[what] = value;
        changedMeta.push_back(what);
        setMeta(args...);
    }

    template <typename... A>
    void setMeta(const std::string& what, const std::string& value,
                 const A&... args)
    {
        metaData[what] = value;
        changedMeta.push_back(what);
        setMeta(args...);
    }

    template <typename... A>
    void setMeta(const std::string& what, const char* value, const A&... args)
    {
        metaData[what] = std::string(value);
        changedMeta.push_back(what);
        setMeta(args...);
    }

    virtual bool seekTo(int  /*song*/, int  /*seconds*/ = -1) { return false; }

    void onMeta(const Callback& callback)
    {
        callbacks.push_back(callback);
        std::vector<std::string> meta;
        meta.reserve(metaData.size());
        for (auto& md : metaData) {
            meta.push_back(md.first);
        }
        callback(meta);
    }

protected:
    std::unordered_map<std::string, MetaVar> metaData;
    std::vector<Callback> callbacks;
    std::vector<std::string> changedMeta;
    std::unordered_set<std::string> lastMeta;
};

} // namespace musix