Subversion Repositories Games.Descent

/*

 * This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.

 * It is copyright by its individual contributors, as recorded in the

 * project's Git history.  See COPYING.txt at the top level for license

 * terms and a link to the Git history.

 */

/*

 * This is an alternate backend for the music system.

 * It uses SDL_mixer to provide a more reliable playback,

 * and allow processing of multiple audio formats.

 *

 *  -- MD2211 (2006-04-24)

 */

#include <SDL.h>

#include <SDL_mixer.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h> // Pierre-Marie Baty -- for getuid()

#include <pwd.h> // Pierre-Marie Baty -- for getpwuid()

#include "args.h"

#include "hmp.h"

#include "adlmidi_dynamic.h"

#include "digi_mixer_music.h"

#include "strutil.h"

#include "u_mem.h"

#include "config.h"

#include "console.h"

#include "physfsrwops.h"

namespace dcx {

namespace {

#if SDL_MIXER_MAJOR_VERSION == 2

#define DXX_SDL_MIXER_MANAGES_RWOPS     1

#else

#define DXX_SDL_MIXER_MANAGES_RWOPS     0

#endif

#if DXX_SDL_MIXER_MANAGES_RWOPS

#define DXX_SDL_MIXER_Mix_LoadMUS_MANAGE_RWOPS  , SDL_TRUE

#define DXX_SDL_MIXER_Mix_LoadMUS_PASS_RWOPS(rw)

#else

#define DXX_SDL_MIXER_Mix_LoadMUS_MANAGE_RWOPS

#define DXX_SDL_MIXER_Mix_LoadMUS_PASS_RWOPS(rw)        , rw

#endif

struct Music_delete

{

        void operator()(Mix_Music *m) const

        {

                Mix_FreeMusic(m);

        }

};

class current_music_t : std::unique_ptr<Mix_Music, Music_delete>

{

#if !DXX_SDL_MIXER_MANAGES_RWOPS

        using rwops_pointer = std::unique_ptr<SDL_RWops, RWops_delete>;

        rwops_pointer m_ops;

#endif

        using music_pointer = std::unique_ptr<Mix_Music, Music_delete>;

public:

#if DXX_SDL_MIXER_MANAGES_RWOPS

        using music_pointer::reset;

#else

        void reset(

                Mix_Music *const music = nullptr

                , SDL_RWops *const rwops = nullptr

                ) noexcept

        {

                /* Clear music first in case it needs the old ops

                 * Clear old ops

                 * If no new music, clear new ops immediately.  This only

                 * happens if the new music fails to load.

                 */

                this->music_pointer::reset(music);

                m_ops.reset(rwops);

                if (!music)

                        m_ops.reset();

        }

#endif

        using music_pointer::operator bool;

        using music_pointer::get;

};

}

static current_music_t current_music;

static std::vector<uint8_t> current_music_hndlbuf;

#if DXX_USE_ADLMIDI

static ADL_MIDIPlayer_t current_adlmidi;

static ADL_MIDIPlayer *get_adlmidi()

{

        if (!CGameCfg.ADLMIDI_enabled)

                return nullptr;

        ADL_MIDIPlayer *adlmidi = current_adlmidi.get();

        if (!adlmidi)

        {

                int sample_rate;

                Mix_QuerySpec(&sample_rate, nullptr, nullptr);

                adlmidi = adl_init(sample_rate);

                if (adlmidi)

                {

                        adl_switchEmulator(adlmidi, ADLMIDI_EMU_DOSBOX);

                        adl_setNumChips(adlmidi, CGameCfg.ADLMIDI_num_chips);

                        adl_setBank(adlmidi, CGameCfg.ADLMIDI_bank);

                        adl_setSoftPanEnabled(adlmidi, 1);

                        current_adlmidi.reset(adlmidi);

                }

        }

        return adlmidi;

}

static void mix_adlmidi(void *udata, Uint8 *stream, int len);

#endif

enum class CurrentMusicType

{

        None,

#if DXX_USE_ADLMIDI

        ADLMIDI,

#endif

        SDLMixer,

};

static CurrentMusicType current_music_type = CurrentMusicType::None;

static CurrentMusicType load_mus_data(const uint8_t *data, size_t size);

static CurrentMusicType load_mus_file(const char *filename);

/*

 *  Plays a music file from an absolute path or a relative path

 */

int mix_play_file(const char *filename, int loop, void (*hook_finished_track)())

{

        std::array<char, PATH_MAX> full_path;

        const char *fptr;

        unsigned int bufsize = 0;

        mix_free_music();       // stop and free what we're already playing, if anything

        fptr = strrchr(filename, '.');

        if (fptr == NULL)

                return 0;

        // It's a .hmp!

        if (!d_stricmp(fptr, ".hmp"))

        {

                hmp2mid(filename, current_music_hndlbuf);

                current_music_type = load_mus_data(current_music_hndlbuf.data(), current_music_hndlbuf.size());

        }

        // try loading music via given filename

        if (current_music_type == CurrentMusicType::None)

                current_music_type = load_mus_file(filename);

        // allow the shell convention tilde character to mean the user's home folder

        // chiefly used for default jukebox level song music referenced in 'descent.m3u' for Mac OS X

        if (current_music_type == CurrentMusicType::None && *filename == '~')

        {

                const auto sep = PHYSFS_getDirSeparator();

                const auto lensep = strlen(sep);

                snprintf(full_path.data(), PATH_MAX, "%s/%s", /*PHYSFS_getUserDir()*/getpwuid(getuid())->pw_dir, // Pierre-Marie Baty -- work around PHYSFS_getUserDir() deprecation

                                 &filename[1 + (!strncmp(&filename[1], sep, lensep)

                        ? lensep

                        : 0)]);

                current_music_type = load_mus_file(full_path.data());

                if (current_music_type != CurrentMusicType::None)

                        filename = full_path.data();    // used later for possible error reporting

        }

        // no luck. so it might be in Searchpath. So try to build absolute path

        if (current_music_type == CurrentMusicType::None)

        {

                PHYSFSX_getRealPath(filename, full_path);

                current_music_type = load_mus_file(full_path.data());

                if (current_music_type != CurrentMusicType::None)

                        filename = full_path.data();    // used later for possible error reporting

        }

        // still nothin'? Let's open via PhysFS in case it's located inside an archive

        if (current_music_type == CurrentMusicType::None)

        {

                if (RAIIPHYSFS_File filehandle{PHYSFS_openRead(filename)})

                {

                        unsigned len = PHYSFS_fileLength(filehandle);

                        current_music_hndlbuf.resize(len);

                        bufsize = PHYSFS_read(filehandle, &current_music_hndlbuf[0], sizeof(char), len);

                        current_music_type = load_mus_data(current_music_hndlbuf.data(), bufsize*sizeof(char));

                }

        }

        switch (current_music_type)

        {

#if DXX_USE_ADLMIDI

        case CurrentMusicType::ADLMIDI:

        {

                ADL_MIDIPlayer *adlmidi = get_adlmidi();

                adl_setLoopEnabled(adlmidi, loop);

                Mix_HookMusic(&mix_adlmidi, nullptr);

                Mix_HookMusicFinished(hook_finished_track ? hook_finished_track : mix_free_music);

                return 1;

        }

#endif

        case CurrentMusicType::SDLMixer:

        {

                Mix_PlayMusic(current_music.get(), (loop ? -1 : 1));

                Mix_HookMusicFinished(hook_finished_track ? hook_finished_track : mix_free_music);

                return 1;

        }

        default:

        {

                con_printf(CON_CRITICAL,"Music %s could not be loaded: %s", filename, Mix_GetError());

                mix_stop_music();

        }

        }

        return 0;

}

// What to do when stopping song playback

void mix_free_music()

{

        Mix_HaltMusic();

#if DXX_USE_ADLMIDI

        /* Only ADLMIDI can set a hook, so if ADLMIDI is compiled out, there is no

         * need to clear the hook.

         *

         * When ADLMIDI is supported, clear unconditionally, instead of checking

         * whether the music type requires it.

         */

        Mix_HookMusic(nullptr, nullptr);

#endif

        current_music.reset();

        current_music_hndlbuf.clear();

        current_music_type = CurrentMusicType::None;

}

void mix_set_music_volume(int vol)

{

        vol *= MIX_MAX_VOLUME/8;

        Mix_VolumeMusic(vol);

}

void mix_stop_music()

{

        Mix_HaltMusic();

        current_music_hndlbuf.clear();

}

void mix_pause_music()

{

        Mix_PauseMusic();

}

void mix_resume_music()

{

        Mix_ResumeMusic();

}

void mix_pause_resume_music()

{

        if (Mix_PausedMusic())

                Mix_ResumeMusic();

        else if (Mix_PlayingMusic())

                Mix_PauseMusic();

}

static CurrentMusicType load_mus_data(const uint8_t *data, size_t size)

{

        CurrentMusicType type = CurrentMusicType::None;

#if DXX_USE_ADLMIDI

        const auto adlmidi = get_adlmidi();

        if (adlmidi && adl_openData(adlmidi, data, size) == 0)

                type = CurrentMusicType::ADLMIDI;

        else

#endif

        {

                const auto rw = SDL_RWFromConstMem(data, size);

                current_music.reset(Mix_LoadMUS_RW(rw DXX_SDL_MIXER_Mix_LoadMUS_MANAGE_RWOPS) DXX_SDL_MIXER_Mix_LoadMUS_PASS_RWOPS(rw));

                if (current_music)

                        type = CurrentMusicType::SDLMixer;

        }

        return type;

}

static CurrentMusicType load_mus_file(const char *filename)

{

        CurrentMusicType type = CurrentMusicType::None;

#if DXX_USE_ADLMIDI

        const auto adlmidi = get_adlmidi();

        if (adlmidi && adl_openFile(adlmidi, filename) == 0)

                type = CurrentMusicType::ADLMIDI;

        else

#endif

        {

                current_music.reset(Mix_LoadMUS(filename));

                if (current_music)

                        type = CurrentMusicType::SDLMixer;

        }

        return type;

}

#if DXX_USE_ADLMIDI

static int16_t sat16(int32_t x)

{

        x = (x < INT16_MIN) ? INT16_MIN : x;

        x = (x > INT16_MAX) ? INT16_MAX : x;

        return x;

}

static void mix_adlmidi(void *, Uint8 *stream, int len)

{

        ADLMIDI_AudioFormat format;

        format.containerSize = sizeof(int16_t);

        format.sampleOffset = 2 * format.containerSize;

        format.type = ADLMIDI_SampleType_S16;

        ADL_MIDIPlayer *adlmidi = get_adlmidi();

        int sampleCount = len / format.containerSize;

        adl_playFormat(adlmidi, sampleCount, stream, stream + format.containerSize, &format);

        const auto samples = reinterpret_cast<int16_t *>(stream);

        const auto amplify = [](int16_t i) { return sat16(2 * i); };

        std::transform(samples, samples + sampleCount, samples, amplify);

}

#endif

}