PostProcessor.hh

Go to the documentation of this file.

#ifndef POSTPROCESSOR_HH
#define POSTPROCESSOR_HH

#include "FrameSource.hh"
#include "VideoLayer.hh"
#include "Schedulable.hh"
#include "EmuTime.hh"
#include <memory>
#include <vector>

namespace openmsx {

class Display;
class RenderSettings;
class RawFrame;
class DeinterlacedFrame;
class DoubledFrame;
class Deflicker;
class SuperImposedFrame;
class AviRecorder;
class CliComm;
class EventDistributor;

class PostProcessor : public VideoLayer, private Schedulable
{
public:
        ~PostProcessor() override;

        virtual std::unique_ptr<RawFrame> rotateFrames(
                std::unique_ptr<RawFrame> finishedFrame, EmuTime::param time);

        void setSuperimposeVideoFrame(const RawFrame* videoSource) {
                superImposeVideoFrame = videoSource;
        }

        void setSuperimposeVdpFrame(const FrameSource* vdpSource) {
                superImposeVdpFrame = vdpSource;
        }

        void setRecorder(AviRecorder* recorder_) { recorder = recorder_; }

        bool isRecording() const { return recorder != nullptr; }

        unsigned getBpp() const;

        FrameSource* getPaintFrame() const { return paintFrame; }

        // VideoLayer
        void takeRawScreenShot(unsigned height, const std::string& filename) override;


        CliComm& getCliComm();

protected:
        static unsigned getLineWidth(FrameSource* frame, unsigned y, unsigned step);

        PostProcessor(
                MSXMotherBoard& motherBoard, Display& display,
                OutputSurface& screen, const std::string& videoSource,
                unsigned maxWidth, unsigned height, bool canDoInterlace);

        RenderSettings& renderSettings;

        OutputSurface& screen;

        std::unique_ptr<RawFrame> lastFrames[4];

        std::unique_ptr<DeinterlacedFrame> deinterlacedFrame;

        std::unique_ptr<DoubledFrame> interlacedFrame;

        std::unique_ptr<Deflicker> deflicker;

        std::unique_ptr<SuperImposedFrame> superImposedFrame;

        FrameSource* paintFrame;

        AviRecorder* recorder;

        const RawFrame* superImposeVideoFrame;
        const FrameSource* superImposeVdpFrame;

        int interleaveCount; // for interleave-black-frame
        int lastFramesCount; // How many items in lastFrames[] are up-to-date
        int maxWidth; // we lazily create RawFrame objects in lastFrames[]
        int height;   // these two vars remember how big those should be

private:
        // Schedulable
        void executeUntil(EmuTime::param time) override;

        Display& display;

        const bool canDoInterlace;

        EmuTime lastRotate;
        EventDistributor& eventDistributor;
};

} // namespace openmsx

#endif // POSTPROCESSOR_HH