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 "Schedulable.hh"
#include "Filename.hh"
#include "EmuTime.hh"
#include "serialize_meta.hh"
#include <string>
#include <memory>

namespace openmsx {

class CassetteImage;
class HardwareConfig;
class MSXMotherBoard;
class Wav8Writer;
class LoadingIndicator;
class BooleanSetting;
class TapeCommand;

class CassettePlayer : public CassetteDevice, public ResampledSoundDevice
                     , private EventListener, private Schedulable
{
public:
        explicit CassettePlayer(const HardwareConfig& hwConf);
        virtual ~CassettePlayer();

        // CassetteDevice
        virtual void setMotor(bool status, EmuTime::param time);
        virtual short readSample(EmuTime::param time);
        virtual void setSignal(bool output, EmuTime::param time);

        // Pluggable
        virtual const std::string& getName() const;
        virtual string_ref getDescription() const;
        virtual void plugHelper(Connector& connector, EmuTime::param time);
        virtual void unplugHelper(EmuTime::param time);

        // SoundDevice
        virtual void generateChannels(int** bufs, unsigned num);

        template<typename Archive>
        void serialize(Archive& ar, unsigned version);

        enum State { PLAY, RECORD, STOP }; // public for serialization

private:
        State getState() const;
        std::string getStateString() const;
        void setState(State newState, const Filename& newImage,
                      EmuTime::param time);
        void setImageName(const Filename& newImage);
        const Filename& getImageName() const;
        void checkInvariants() const;

        void playTape(const Filename& filename, EmuTime::param time);
        void insertTape(const Filename& filename);

        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
        virtual int signalEvent(const std::shared_ptr<const Event>& event);

        // Schedulable
        virtual void executeUntil(EmuTime::param time, int userData);

        static const size_t BUF_SIZE = 1024;
        unsigned char buf[BUF_SIZE];

        double lastX; // last unfiltered output
        double lastY; // last filtered output
        double partialOut;
        double partialInterval;

        EmuTime tapePos;

        EmuTime prevSyncTime;

        // SoundDevice
        unsigned audioPos;
        Filename casImage;

        MSXMotherBoard& motherBoard;
        const std::unique_ptr<TapeCommand> tapeCommand;
        const std::unique_ptr<LoadingIndicator> loadingIndicator;
        const std::unique_ptr<BooleanSetting> autoRunSetting;
        std::unique_ptr<Wav8Writer> recordImage;
        std::unique_ptr<CassetteImage> playImage;

        size_t sampcnt;
        State state;
        bool lastOutput;
        bool motor, motorControl;
        bool syncScheduled;

        friend class TapeCommand;
};
SERIALIZE_CLASS_VERSION(CassettePlayer, 2);

} // namespace openmsx

#endif