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


#include "AdPlugin.h"

#include "../../chipplayer.h"
#include "adplug/adplug.h"
#include "adplug/emuopl.h"
#include "libbinio/binfile.h"
#include "libbinio/binio.h"

#include <math.h>

#include "opl/dbemuopl.h"

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

#include <cmath>
#include <cstdio>
#include <set>
#include <string>
#include <unordered_map>

#ifdef min
#    undef min
#endif

namespace musix {

class AdPlugPlayer : public ChipPlayer
{

    Copl* emu;
    CPlayer* m_player = nullptr;
    /* STATIC! */ CAdPlugDatabase* g_database = nullptr;

public:
    AdPlugPlayer(const std::string& fileName, const std::string& configDir)
    {

        if (g_database == nullptr) {
            binistream* fp = new binifstream(configDir + "/" + "adplug.db");
            fp->setFlag(binio::BigEndian, false);
            fp->setFlag(binio::FloatIEEE);

            g_database = new CAdPlugDatabase();
            g_database->load(*fp);
            delete fp;
            CAdPlug::set_database(g_database);
        }

        emu = new CEmuopl(44100, true, true);

        m_player = CAdPlug::factory(fileName, emu, CAdPlug::players);

        if (m_player == nullptr) { throw player_exception(); }

        setMeta("title", m_player->gettitle(), "composer",
                m_player->getauthor(), "length", m_player->songlength() / 1000,
                "songs", m_player->getsubsongs(), "format",
                m_player->gettype());
    }

    ~AdPlugPlayer() override
    {
        delete m_player;
        delete emu;
        emu = nullptr;
        m_player = nullptr;
    }

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

        int freq = 44100; // 49716;

        static long minicnt = 0;
        long i = 0;
        long towrite = noSamples / 2;
        auto* pos = target;

        while (towrite > 0) {
            while (minicnt < 0) {
                minicnt += freq;
                auto playing = m_player->update();
                if (!playing) { return -1; }
            }
            i = std::min(towrite,
                         (long)(minicnt / m_player->getrefresh() + 4) & ~3);
            emu->update(pos, i);
            pos += i * 2;
            towrite -= i;
            minicnt -= (long)(m_player->getrefresh() * i);
        }

        return noSamples;
    }
};

static const std::set<std::string> supported_ext{
    "a2m",  "adl", "amd", "bam",   "cff", "cmf", "d00", "dfm", "dmo",
    "dro",  "dtm", "hcs", "hsp",   "imf", "ksm", "laa", "lds", "m",
    "mad",  "mid", "mkj", "msc",   "mtk", "rad", "raw", "rix", "rol",
    "as3m", "sa2", "sat", "sci",   "agd", "sdb", "xad", "xms", "xsm",
    "hsc",  "edl", "mtr", "adlib", "sqx"};

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

ChipPlayer* AdPlugin::fromFile(const std::string& fileName)
{
    return new AdPlugPlayer{fileName, configDir};
};

} // namespace musix

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