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.

 */

/*

 * DXX Rebirth "jukebox" code

 * MD 2211 <md2211@users.sourceforge.net>, 2007

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "hudmsg.h"

#include "songs.h"

#include "jukebox.h"

#include "dxxerror.h"

#include "console.h"

#include "config.h"

#include "strutil.h"

#include "u_mem.h"

#include "physfs_list.h"

#include "digi.h"

#include "partial_range.h"

#include <memory>

namespace dcx {

extern bool isDirectory(const char *fname); // Pierre-Marie Baty -- work around PHYSFS_isDirectory() deprecation

#define MUSIC_HUDMSG_MAXLEN 40

#define JUKEBOX_HUDMSG_PLAYING "Now playing:"

#define JUKEBOX_HUDMSG_STOPPED "Jukebox stopped"

namespace {

struct m3u_bytes

{

        using range_type = partial_range_t<char *>;

        using ptr_range_type = partial_range_t<char **>;

        using alloc_type = std::unique_ptr<char *[]>;

        range_type range = {nullptr, nullptr};

        ptr_range_type ptr_range = {nullptr, nullptr};

        alloc_type alloc;

        m3u_bytes() = default;

        m3u_bytes(m3u_bytes &&) = default;

        m3u_bytes(range_type &&r, ptr_range_type &&p, alloc_type &&b) :

                range(std::move(r)),

                ptr_range(std::move(p)),

                alloc(std::move(b))

        {

        }

};

class FILE_deleter

{

public:

        void operator()(FILE *const p) const

        {

                fclose(p);

        }

};

class list_deleter : PHYSFS_list_deleter

{

public:

        /* When `list_pointers` is a PHYSFS allocation, `buf` is nullptr.

         * When `list_pointers` is a new[char *[]] allocation, `buf`

         * points to the same location as `list_pointers`.

         */

        std::unique_ptr<char *[]> buf;

        void operator()(char **list)

        {

                if (buf)

                {

                        assert(buf.get() == list);

                        buf.reset();

                }

                else

                        this->PHYSFS_list_deleter::operator()(list);

        }

};

class list_pointers : public PHYSFSX_uncounted_list_template<list_deleter>

{

        typedef PHYSFSX_uncounted_list_template<list_deleter> base_ptr;

public:

        using base_ptr::reset;

        void set_combined(std::unique_ptr<char *[]> &&buf)

                noexcept(

                        noexcept(std::declval<base_ptr>().reset(buf.get())) &&

                        noexcept(std::declval<list_deleter>().buf = std::move(buf))

                )

        {

                this->base_ptr::reset(buf.get());

                get_deleter().buf = std::move(buf);

        }

        void reset(PHYSFSX_uncounted_list list)

                noexcept(noexcept(std::declval<base_ptr>().reset(list.release())))

        {

                this->base_ptr::reset(list.release());

        }

};

class jukebox_songs

{

public:

        void unload();

        list_pointers list;     // the actual list

        unsigned num_songs;     // number of jukebox songs

        static const std::size_t max_songs = 1024;      // maximum number of pointers that 'list' can hold, i.e. size of list / size of one pointer

};

}

static jukebox_songs JukeboxSongs;

void jukebox_songs::unload()

{

        num_songs = 0;

        list.reset();

}

void jukebox_unload()

{

        JukeboxSongs.unload();

}

const std::array<file_extension_t, 5> jukebox_exts{{

        SONG_EXT_HMP,

        SONG_EXT_MID,

        SONG_EXT_OGG,

        SONG_EXT_FLAC,

        SONG_EXT_MP3

}};

/* Open an m3u using fopen, not PHYSFS.  If the path seems to be under

 * PHYSFS, that will be preferred over a raw filesystem path.

 */

static std::unique_ptr<FILE, FILE_deleter> open_m3u_from_disk(const char *const cfgpath)

{

        std::array<char, PATH_MAX> absbuf;

        return std::unique_ptr<FILE, FILE_deleter>(fopen(

        // it's a child of Sharepath, build full path

                (PHYSFSX_exists(cfgpath, 0)

                        ? (PHYSFSX_getRealPath(cfgpath, absbuf), absbuf.data())

                        : cfgpath), "rb")

        );

}

static m3u_bytes read_m3u_bytes_from_disk(const char *const cfgpath)

{

        const auto &&f = open_m3u_from_disk(cfgpath);

        if (!f)

                return {};

        const auto fp = f.get();

        fseek(fp, -1, SEEK_END);

        const std::size_t length = ftell(fp) + 1;

        const auto juke_max_songs = JukeboxSongs.max_songs;

        if (length >= PATH_MAX * juke_max_songs)

                return {};

        fseek(fp, 0, SEEK_SET);

        /* A file consisting only of single character records and newline

         * separators, with no junk newlines, comments, or final terminator,

         * will need one pointer per two bytes of file, rounded up.  Any

         * file that uses longer records, which most will use, will need

         * fewer pointers.  This expression usually overestimates, sometimes

         * substantially.  However, it is still more conservative than the

         * previous expression, which was to allocate exactly

         * `JukeboxSongs.max_songs` pointers without regard to the file size

         * or contents.

         */

        const auto required_alloc_size = 1 + (length / 2);

        const auto max_songs = std::min(required_alloc_size, juke_max_songs);

        /* Use T=`char*[]` to ensure alignment.  Place pointers before file

         * contents to keep the pointer array aligned.

         */

        auto &&list_buf = std::make_unique<char*[]>(max_songs + 1 + (length / sizeof(char *)));

        const auto p = reinterpret_cast<char *>(list_buf.get() + max_songs);

        p[length] = '\0';       // make sure the last string is terminated

        return fread(p, length, 1, fp)

                ? m3u_bytes(

                        unchecked_partial_range(p, length),

                        unchecked_partial_range(list_buf.get(), max_songs),

                        std::move(list_buf)

                )

                : m3u_bytes();

}

static int read_m3u(void)

{

        auto &&m3u = read_m3u_bytes_from_disk(CGameCfg.CMLevelMusicPath.data());

        auto &list_buf = m3u.alloc;

        if (!list_buf)

                return 0;

        // The growing string list is allocated last, hopefully reducing memory fragmentation when it grows

        const auto eol = [](char c) {

                return c == '\n' || c == '\r' || !c;

        };

        JukeboxSongs.list.set_combined(std::move(list_buf));

        const auto &range = m3u.range;

        auto pp = m3u.ptr_range.begin();

        for (auto buf = range.begin(); buf != range.end(); ++buf)

        {

                for (; buf != range.end() && eol(*buf);)        // find new line - support DOS, Unix and Mac line endings

                        buf++;

                if (buf == range.end())

                        break;

                if (*buf != '#')        // ignore comments / extra info

                {

                        *pp++ = buf;

                        if (pp == m3u.ptr_range.end())

                                break;

                }

                for (; buf != range.end(); ++buf)       // find end of line

                        if (eol(*buf))

                        {

                                *buf = 0;

                                break;

                        }

                if (buf == range.end())

                        break;

        }

        JukeboxSongs.num_songs = std::distance(m3u.ptr_range.begin(), pp);

        return 1;

}

/* Loads music file names from a given directory or M3U playlist */

void jukebox_load()

{

        jukebox_unload();

        // Check if it's an M3U file

        auto &cfgpath = CGameCfg.CMLevelMusicPath;

        size_t musiclen = strlen(cfgpath.data());

        if (musiclen > 4 && !d_stricmp(&cfgpath[musiclen - 4], ".m3u"))

                read_m3u();

        else    // a directory

        {

                class PHYSFS_path_deleter

                {

                public:

                        void operator()(const char *const p) const noexcept

                        {

                                PHYSFS_unmount(p); // Pierre-Marie Baty -- work around PHYSFS_removeFromSearchPath() deprecation

                        }

                };

                std::unique_ptr<const char, PHYSFS_path_deleter> new_path;

                const char *sep = PHYSFS_getDirSeparator();

                size_t seplen = strlen(sep);

                // stick a separator on the end if necessary.

                if (musiclen >= seplen)

                {

                        auto p = &cfgpath[musiclen - seplen];

                        if (strcmp(p, sep))

                                cfgpath.copy_if(musiclen, sep, seplen);

                }

                const auto p = cfgpath.data();

                // Read directory using PhysicsFS

                if (/*PHYSFS_*/isDirectory(p))  // find files in relative directory // Pierre-Marie Baty -- work around PHYSFS_isDirectory() deprecation

                        JukeboxSongs.list.reset(PHYSFSX_findFiles(p, jukebox_exts));

                else

                {

                        if (PHYSFSX_isNewPath(p))

                                new_path.reset(p);

                        PHYSFS_mount(p, NULL, 0); // Pierre-Marie Baty -- work around PHYSFS_addToSearchPath() deprecation

                        // as mountpoints are no option (yet), make sure only files originating from GameCfg.CMLevelMusicPath are aded to the list.

                        JukeboxSongs.list.reset(PHYSFSX_findabsoluteFiles("", p, jukebox_exts));

                }

                if (!JukeboxSongs.list)

                {

                        return;

                }

                JukeboxSongs.num_songs = std::distance(JukeboxSongs.list.begin(), JukeboxSongs.list.end());

        }

        if (JukeboxSongs.num_songs)

        {

                con_printf(CON_DEBUG,"Jukebox: %d music file(s) found in %s", JukeboxSongs.num_songs, cfgpath.data());

                if (CGameCfg.CMLevelMusicTrack[1] != JukeboxSongs.num_songs)

                {

                        CGameCfg.CMLevelMusicTrack[1] = JukeboxSongs.num_songs;

                        CGameCfg.CMLevelMusicTrack[0] = 0; // number of songs changed so start from beginning.

                }

        }

        else

        {

                CGameCfg.CMLevelMusicTrack[0] = -1;

                CGameCfg.CMLevelMusicTrack[1] = -1;

                con_puts(CON_DEBUG,"Jukebox music could not be found!");

        }

}

// To proceed tru our playlist. Usually used for continous play, but can loop as well.

static void jukebox_hook_next()

{

        if (!JukeboxSongs.list || CGameCfg.CMLevelMusicTrack[0] == -1)

                return;

        if (CGameCfg.CMLevelMusicPlayOrder == LevelMusicPlayOrder::Random)

                CGameCfg.CMLevelMusicTrack[0] = d_rand() % CGameCfg.CMLevelMusicTrack[1]; // simply a random selection - no check if this song has already been played. But that's how I roll!

        else

                CGameCfg.CMLevelMusicTrack[0]++;

        if (CGameCfg.CMLevelMusicTrack[0] + 1 > CGameCfg.CMLevelMusicTrack[1])

                CGameCfg.CMLevelMusicTrack[0] = 0;

        jukebox_play();

}

}

namespace dsx {

// Play tracks from Jukebox directory. Play track specified in GameCfg.CMLevelMusicTrack[0] and loop depending on CGameCfg.CMLevelMusicPlayOrder

int jukebox_play()

{

        const char *music_filename;

        uint_fast32_t size_full_filename = 0;

        if (!JukeboxSongs.list)

                return 0;

        if (CGameCfg.CMLevelMusicTrack[0] < 0 ||

                CGameCfg.CMLevelMusicTrack[0] + 1 > CGameCfg.CMLevelMusicTrack[1])

                return 0;

        music_filename = JukeboxSongs.list[CGameCfg.CMLevelMusicTrack[0]];

        if (!music_filename)

                return 0;

        size_t size_music_filename = strlen(music_filename);

        auto &cfgpath = CGameCfg.CMLevelMusicPath;

        size_t musiclen = strlen(cfgpath.data());

        size_full_filename = musiclen + size_music_filename + 1;

        RAIIdmem<char[]> full_filename;

        CALLOC(full_filename, char[], size_full_filename);

        const char *LevelMusicPath;

        if (musiclen > 4 && !d_stricmp(&cfgpath[musiclen - 4], ".m3u")) // if it's from an M3U playlist

                LevelMusicPath = "";

        else                                                                                    // if it's from a specified path

                LevelMusicPath = cfgpath.data();

        snprintf(full_filename.get(), size_full_filename, "%s%s", LevelMusicPath, music_filename);

        int played = songs_play_file(full_filename.get(), (CGameCfg.CMLevelMusicPlayOrder == LevelMusicPlayOrder::Level ? 1 : 0), (CGameCfg.CMLevelMusicPlayOrder == LevelMusicPlayOrder::Level ? nullptr : jukebox_hook_next));

        full_filename.reset();

        if (!played)

        {

                return 0;       // whoops, got an error

        }

        // Formatting a pretty message

        const char *prefix = "...";

        if (size_music_filename >= MUSIC_HUDMSG_MAXLEN) {

                music_filename += size_music_filename - MUSIC_HUDMSG_MAXLEN;

        } else {

                prefix += 3;

        }

        HUD_init_message(HM_DEFAULT, "%s %s%s", JUKEBOX_HUDMSG_PLAYING, prefix, music_filename);

        return 1;

}

}