CassettePlayer.hh

Go to the documentation of this file.

#ifndef CASSETTEPLAYER_HH
#define CASSETTEPLAYER_HH
 
#include "EventListener.hh"
#include "CassetteDevice.hh"
#include "ResampledSoundDevice.hh"
#include "MSXMotherBoard.hh"
#include "RecordedCommand.hh"
#include "Schedulable.hh"
#include "ThrottleManager.hh"
#include "Filename.hh"
#include "EmuTime.hh"
#include "BooleanSetting.hh"
#include "outer.hh"
#include "serialize_meta.hh"
#include <array>
#include <cstdint>
#include <memory>
#include <string>
 
namespace openmsx {
 
class CassetteImage;
class HardwareConfig;
class Wav8Writer;
 
class CassettePlayer final : public CassetteDevice, public ResampledSoundDevice
                           , public MediaInfoProvider
                           , private EventListener
{
public:
        explicit CassettePlayer(const HardwareConfig& hwConf);
        ~CassettePlayer() override;
 
        // CassetteDevice
        void setMotor(bool status, EmuTime::param time) override;
        int16_t readSample(EmuTime::param time) override;
        void setSignal(bool output, EmuTime::param time) override;
 
        // Pluggable
        std::string_view getName() const override;
        std::string_view getDescription() const override;
        void plugHelper(Connector& connector, EmuTime::param time) override;
        void unplugHelper(EmuTime::param time) override;
 
        // SoundDevice
        void generateChannels(std::span<float*> buffers, unsigned num) override;
        float getAmplificationFactorImpl() const override;
 
        // MediaInfoProvider
        void getMediaInfo(TclObject& result) override;
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
        enum State { PLAY, RECORD, STOP }; // public for serialization
 
private:
        [[nodiscard]] State getState() const { return state; }
        [[nodiscard]] std::string getStateString() const;
        void setState(State newState, const Filename& newImage,
                      EmuTime::param time);
        void setImageName(const Filename& newImage);
        const Filename& getImageName() const { return casImage; }
        void checkInvariants() const;
 
        void playTape(const Filename& filename, EmuTime::param time);
        void insertTape(const Filename& filename, EmuTime::param time);
 
        void removeTape(EmuTime::param time);
 
        void recordTape(const Filename& filename, EmuTime::param time);
 
        void rewind(EmuTime::param time);
 
        void setMotorControl(bool status, EmuTime::param time);
 
        bool isRolling() const;
 
        void updateLoadingState(EmuTime::param time);
 
        double getTapePos(EmuTime::param time);
 
        double getTapeLength(EmuTime::param time);
 
        void sync(EmuTime::param time);
        void updateTapePosition(EmuDuration::param duration, EmuTime::param time);
        void generateRecordOutput(EmuDuration::param duration);
 
        void fillBuf(size_t length, double x);
        void flushOutput();
        void autoRun();
 
        // EventListener
        int signalEvent(const Event& event) override;
 
        // Schedulable
        struct SyncEndOfTape final : Schedulable {
                friend class CassettePlayer;
                explicit SyncEndOfTape(Scheduler& s) : Schedulable(s) {}
                void executeUntil(EmuTime::param time) override {
                        auto& cp = OUTER(CassettePlayer, syncEndOfTape);
                        cp.execEndOfTape(time);
                }
        } syncEndOfTape;
        struct SyncAudioEmu final : Schedulable {
                friend class CassettePlayer;
                explicit SyncAudioEmu(Scheduler& s) : Schedulable(s) {}
                void executeUntil(EmuTime::param time) override {
                        auto& cp = OUTER(CassettePlayer, syncAudioEmu);
                        cp.execSyncAudioEmu(time);
                }
        } syncAudioEmu;
 
        void execEndOfTape(EmuTime::param time);
        void execSyncAudioEmu(EmuTime::param time);
        EmuTime::param getCurrentTime() const { return syncEndOfTape.getCurrentTime(); }
 
        std::array<uint8_t, 1024> buf;
 
        double lastX; // last unfiltered output
        double lastY; // last filtered output
        double partialOut;
        double partialInterval;
 
        EmuTime tapePos = EmuTime::zero();
 
        EmuTime prevSyncTime = EmuTime::zero();
 
        // SoundDevice
        unsigned audioPos = 0;
        Filename casImage;
 
        MSXMotherBoard& motherBoard;
 
        struct TapeCommand final : RecordedCommand {
                TapeCommand(CommandController& commandController,
                            StateChangeDistributor& stateChangeDistributor,
                            Scheduler& scheduler);
                void execute(std::span<const TclObject> tokens, TclObject& result,
                             EmuTime::param time) override;
                [[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;
                void tabCompletion(std::vector<std::string>& tokens) const override;
                [[nodiscard]] bool needRecord(std::span<const TclObject> tokens) const override;
        } tapeCommand;
 
        LoadingIndicator loadingIndicator;
        BooleanSetting autoRunSetting;
        std::unique_ptr<Wav8Writer> recordImage;
        std::unique_ptr<CassetteImage> playImage;
 
        size_t sampCnt = 0;
        State state = STOP;
        bool lastOutput = false;
        bool motor = false, motorControl = true;
        bool syncScheduled = false;
};
SERIALIZE_CLASS_VERSION(CassettePlayer, 2);
 
} // namespace openmsx
 
#endif