PostProcessor.hh

Go to the documentation of this file.

#ifndef POSTPROCESSOR_HH
#define POSTPROCESSOR_HH
 
#include "VideoLayer.hh"
#include "Schedulable.hh"
#include "EmuTime.hh"
#include <array>
#include <memory>
 
namespace openmsx {
 
class AviRecorder;
class CliComm;
class Deflicker;
class DeinterlacedFrame;
class Display;
class DoubledFrame;
class EventDistributor;
class FrameSource;
class RawFrame;
class RenderSettings;
class SuperImposedFrame;
 
class PostProcessor : public VideoLayer, private Schedulable
{
public:
        ~PostProcessor() override;
 
        [[nodiscard]] 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_; }
 
        [[nodiscard]] bool isRecording() const { return recorder != nullptr; }
 
        [[nodiscard]] unsigned getBpp() const;
 
        [[nodiscard]] FrameSource* getPaintFrame() const { return paintFrame; }
 
        // VideoLayer
        void takeRawScreenShot(unsigned height, const std::string& filename) override;
 
        [[nodiscard]] CliComm& getCliComm();
 
protected:
        [[nodiscard]] 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);
 
protected:
        RenderSettings& renderSettings;
 
        OutputSurface& screen;
 
        std::array<std::unique_ptr<RawFrame>, 4> lastFrames;
 
        std::unique_ptr<DeinterlacedFrame> deinterlacedFrame;
 
        std::unique_ptr<DoubledFrame> interlacedFrame;
 
        std::unique_ptr<Deflicker> deflicker;
 
        std::unique_ptr<SuperImposedFrame> superImposedFrame;
 
        FrameSource* paintFrame = nullptr;
 
        AviRecorder* recorder = nullptr;
 
        const RawFrame* superImposeVideoFrame = nullptr;
        const FrameSource* superImposeVdpFrame = nullptr;
 
        int interleaveCount = 0; // for interleave-black-frame
        int lastFramesCount = 0; // How many items in lastFrames[] are up-to-date
        unsigned maxWidth; // we lazily create RawFrame objects in lastFrames[]
        unsigned height;   // these two vars remember how big those should be
 
private:
        // Schedulable
        void executeUntil(EmuTime::param time) override;
 
private:
        Display& display;
 
        const bool canDoInterlace;
 
        EmuTime lastRotate;
        EventDistributor& eventDistributor;
};
 
} // namespace openmsx
 
#endif // POSTPROCESSOR_HH