SidTuneBase.h

/*
 * This file is part of libsidplayfp, a SID player engine.
 *
 * Copyright 2011-2021 Leandro Nini <drfiemost@users.sourceforge.net>
 * Copyright 2007-2010 Antti Lankila
 * Copyright 2000 Simon White
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
 
#ifndef SIDTUNEBASE_H
#define SIDTUNEBASE_H
 
#include <stdint.h>
#include <memory>
#include <vector>
#include <string>
 
#include "sidplayfp/SidTuneInfo.h"
#include "sidplayfp/siddefs.h"
 
#include "SmartPtr.h"
#include "SidTuneInfoImpl.h"
 
#include "sidcxx11.h"
 
namespace libsidplayfp
{
 
class sidmemory;
template <class T> class SmartPtr_sidtt;
 
class loadError
{
private:
    const char* m_msg;
public:
    loadError(const char* msg) : m_msg(msg) {}
    const char* message() const { return m_msg; }
};
 
class SidTuneBase
{
protected:
    using buffer_t = std::vector<uint8_t>;
 
protected:
    static constexpr unsigned int MAX_SONGS = 256;
 
    // Generic error messages
    static const char ERR_TRUNCATED[];
    static const char ERR_INVALID[];
 
public:  // ----------------------------------------------------------------
    virtual ~SidTuneBase() = default;
 
    using LoaderFunc = void (*)(const char* fileName, buffer_t& bufferRef);
 
    static SidTuneBase* load(const char* fileName, const char **fileNameExt, bool separatorIsSlash)
    {
        return load(nullptr, fileName, fileNameExt, separatorIsSlash);
    }
 
    static SidTuneBase* load(LoaderFunc loader, const char* fileName, const char **fileNameExt, bool separatorIsSlash);
 
    static SidTuneBase* read(const uint_least8_t* sourceBuffer, uint_least32_t bufferLen)
    {
        return getFromBuffer(sourceBuffer, bufferLen);
    }
 
    unsigned int selectSong(unsigned int songNum);
 
    const SidTuneInfo* getInfo() const { return info.get(); }
 
    const SidTuneInfo* getInfo(unsigned int songNum)
    {
        selectSong(songNum);
        return info.get();
    }
 
    virtual void placeSidTuneInC64mem(sidmemory& mem);
 
    virtual const char *createMD5(char *) { return nullptr; }
 
    virtual const char *createMD5New(char *) { return nullptr; }
 
    const uint_least8_t* c64Data() const { return &cache[fileOffset]; }
 
protected:  // -------------------------------------------------------------
 
    std::unique_ptr<SidTuneInfoImpl> info;
 
    uint_least8_t songSpeed[MAX_SONGS];
    SidTuneInfo::clock_t clockSpeed[MAX_SONGS];
 
    uint_least32_t fileOffset;
 
    buffer_t cache;
 
protected:
    SidTuneBase();
 
    static void loadFile(const char* fileName, buffer_t& bufferRef);
 
    void convertOldStyleSpeedToTables(uint_least32_t speed,
         SidTuneInfo::clock_t clock = SidTuneInfo::CLOCK_PAL);
 
    bool checkCompatibility();
 
    bool checkRelocInfo();
 
    void resolveAddrs(const uint_least8_t* c64data);
 
    virtual void acceptSidTune(const char* dataFileName, const char* infoFileName,
                        buffer_t& buf, bool isSlashedFileName);
 
    std::string petsciiToAscii(SmartPtr_sidtt<const uint8_t>& spPet);
 
private:  // ---------------------------------------------------------------
 
#if !defined(SIDTUNE_NO_STDIN_LOADER)
    static SidTuneBase* getFromStdIn();
#endif
    static SidTuneBase* getFromFiles(const char* fileName, const char **fileNameExtensions, bool separatorIsSlash)
    {
        return getFromFiles(nullptr, fileName, fileNameExtensions, separatorIsSlash);
    }
 
    static SidTuneBase* getFromFiles(LoaderFunc loader, const char* fileName, const char **fileNameExtensions, bool separatorIsSlash);
 
    static SidTuneBase* getFromBuffer(const uint_least8_t* const buffer, uint_least32_t bufferLen);
 
    static void createNewFileName(std::string& destString,
                           const char* sourceName, const char* sourceExt);
 
private:
    // prevent copying
    SidTuneBase(const SidTuneBase&) = delete;
    SidTuneBase& operator=(SidTuneBase&) = delete;
};
 
}
 
#endif  /* SIDTUNEBASE_H */