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
136
137
138
139
140
141
142
143
144
145


#include "HTPlugin.h"

#include "ht/misc.h"

#include "../../chipplayer.h"
#include <psf/PSFFile.h>

#include <coreutils/utils.h>
#include <set>
#include <unordered_map>

namespace musix {

class HTPlayer : public ChipPlayer
{
public:
    explicit HTPlayer(const std::string& fileName)
    {
        PSFFile psf{fileName};
        if (psf.valid()) {
            auto& tags = psf.tags();

            auto lib = tags["_lib"];

            uint32_t seconds = psf.songLength();
            if (seconds > 10000) { seconds = 0; }

            setMeta("composer", tags["artist"], "sub_title", tags["title"],
                    "game", tags["game"],
                    // "format", "Dreamcast",
                    "length", seconds);
        }

        int version = 0;

        sdsf_loader_state lstate;
        memset(&lstate, 0, sizeof(lstate));

        auto* sdsfinfo =
            static_cast<sdsf_loader_state*>(malloc(sizeof(sdsf_loader_state)));

        int init_result = sega_init();

        // const char *filename = env->GetStringUTFChars(fname, NULL);

        char temp[1024];
        strcpy(temp, fileName.c_str());

        version = psf_load(temp, &psf_file_system, 0, nullptr, nullptr, nullptr,
                           nullptr, 0);

        int load_result = psf_load(temp, &psf_file_system, version, sdsf_loader,
                                   &lstate, nullptr, nullptr, 0);
        if (load_result < 0) { throw player_exception(); }

        void* sega_state = malloc(sega_get_state_size(version - 0x10));

        sega_clear_state(sega_state, version - 0x10);

        sega_enable_dry(sega_state, 1);
        sega_enable_dsp(sega_state, 1);

        int dynarec = 1;

        sega_enable_dsp_dynarec(sega_state, 1);

        void* yam = 0;
        if (dynarec != 0) {

            if (version == 0x12) {
                void* dcsound = sega_get_dcsound_state(sega_state);
                yam = dcsound_get_yam_state(dcsound);
            } else {
                void* satsound = sega_get_satsound_state(sega_state);
                yam = satsound_get_yam_state(satsound);
            }
            if (yam != nullptr) { yam_prepare_dynacode(yam); }
        }

        uint32_t start = *reinterpret_cast<uint32_t*>(lstate.data);
        uint32_t length = lstate.data_size;
        const uint32_t max_length = (version == 0x12) ? 0x800000 : 0x80000;
        if ((start + (length - 4)) > max_length) {
            length = max_length - start + 4;
        }

        sega_upload_program(sega_state, lstate.data, length);
        free(lstate.data);

        sdsfinfo->emu = sega_state;
        sdsfinfo->yam = yam;
        sdsfinfo->version = version;

        this->state = sdsfinfo;
    }

    ~HTPlayer() override
    {
        if (state->yam != nullptr) { yam_unprepare_dynacode(state->yam); }

        free(state->emu);
    }

    int getSamples(int16_t* target, int noSamples) override
    {

        int ret = 0;

        uint32_t samples_cnt =
            noSamples /
            2; // samples_cnt in frames, 1 frame == 2 samples == 4 bytes

        ret = sega_execute(state->emu, 0x7fffffff, target, &samples_cnt);

        if (samples_cnt < (noSamples / 2)) { noSamples = samples_cnt * 2; }

        return noSamples;
    }

private:
    sdsf_loader_state* state;
};

static const std::set<std::string> supported_ext{"ssf", "dsf", "minissf",
                                                 "minidsf"};

bool HTPlugin::canHandle(const std::string& name)
{
    auto ext = utils::path_extension(name);
    return supported_ext.count(utils::path_extension(name)) > 0;
}

ChipPlayer* HTPlugin::fromFile(const std::string& fileName)
{
    return new HTPlayer{fileName};
};

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