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

#include "RSNPlugin.h"

#include <archive/archive.h>
#include <coreutils/log.h>

#include <memory>
#include <set>

namespace musix {

class RSNPlayer : public ChipPlayer
{
public:
    RSNPlayer(const std::vector<std::string>& l,
              const std::shared_ptr<ChipPlugin>& plugin)
        : songs(l), plugin(plugin)
    {
        LOGD("Playing with {}", plugin->name());
        player = std::shared_ptr<ChipPlayer>(plugin->fromFile(l[0]));
        if (player == nullptr) { throw player_exception(); }
        setMeta("title", player->meta("title"), "sub_title",
                player->meta("sub_title"), "game", player->meta("game"),
                "composer", player->meta("composer"), "length",
                player->meta("length"), "format", player->meta("format"),
                "songs", l.size());
    }

    int getSamples(int16_t* target, int noSamples) override
    {
        if (player) { return player->getSamples(target, noSamples); }
        return 0;
    }

    bool seekTo(int song, int seconds) override
    {
        player = nullptr;
        player = std::shared_ptr<ChipPlayer>(plugin->fromFile(songs[song]));
        if (player) {
            setMeta("sub_title", player->meta("sub_title"), "length",
                    player->meta("length"), "song", song);
            if (seconds > 0) { player->seekTo(-1, seconds); }
            return true;
        }
        return false;
    }

private:
    std::vector<std::string> songs;
    std::shared_ptr<ChipPlayer> player;
    std::shared_ptr<ChipPlugin> plugin;
};

ChipPlayer* RSNPlugin::fromFile(const std::string& fileName)
{

    static const std::set<std::string> song_formats{
        "spc", "psf",     "minipsf", "psf2",    "minipsf2", "miniusf",
        "dsf", "minidsf", "mini2sf", "minigsf", "mdx",      "s98"};

    std::vector<std::string> l;
    auto rsnDir = utils::get_cache_dir("chipmusic") / ".rsn";
    fs::create_directory(rsnDir);
    for (auto const& f : utils::listFiles(rsnDir, false, true)) {
        fs::remove(f);
    }

    if (!fs::exists(fileName)) { return nullptr; }

    try {
        auto* a = utils::Archive::open(fileName, rsnDir.string(),
                                       utils::Archive::TYPE_RAR);
        a->extractAll(rsnDir.string());
        for (auto const& f : utils::listFiles(rsnDir, false, true)) {
            if (song_formats.count(utils::path_extension(f.string())) > 0) {
                LOGD("Found {}", f.string());
                l.push_back(f.string());
            }
        };
        delete a;
    } catch (utils::archive_exception& e) {
        LOGW("Archive fail");
        return nullptr;
    }

    sort(l.begin(), l.end());

    if (!l.empty()) {
        for (auto name : l) {
            utils::makeLower(name);
            for (auto const& plugin : ChipPlugin::getPlugins()) {
                if (plugin->name() != "UADE" && plugin->name() != "RSNPlugin" &&
                    plugin->canHandle(name)) {
                    try {
                        return new RSNPlayer(l, plugin);
                    } catch (player_exception& e) {
                        LOGD("FAILED");
                    }
                }
            }
        }
    }
    return nullptr;
};

bool RSNPlugin::canHandle(const std::string& name)
{
    static const std::set<std::string> supported_ext{"rsn", "rps", "rdc",
                                                     "rds", "rgs", "r64"};
    return supported_ext.count(utils::path_extension(name)) > 0;
}

} // namespace musix

extern "C" void rsnplugin_register()
{
    musix::ChipPlugin::addPluginConstructor([](std::string const& config) {
        return std::make_shared<musix::RSNPlugin>();
    });
}