PostProcessor.hh

Go to the documentation of this file.

#ifndef GLPOSTPROCESSOR_HH
#define GLPOSTPROCESSOR_HH
 
#include "GLUtil.hh"
#include "RenderSettings.hh"
#include "VideoLayer.hh"
 
#include "EmuTime.hh"
#include "Schedulable.hh"
 
#include <array>
#include <memory>
#include <vector>
 
namespace openmsx {
 
class AviRecorder;
class CliComm;
class Deflicker;
class DeinterlacedFrame;
class Display;
class DoubledFrame;
class EventDistributor;
class FrameSource;
class GLScaler;
class MSXMotherBoard;
class RawFrame;
class RenderSettings;
class SuperImposedFrame;
 
class PostProcessor final : public VideoLayer, private Schedulable
{
public:
        PostProcessor(
                MSXMotherBoard& motherBoard, Display& display,
                OutputSurface& screen, const std::string& videoSource,
                unsigned maxWidth, unsigned height, bool canDoInterlace);
        ~PostProcessor() override;
 
        // Layer interface:
        void paint(OutputSurface& output) override;
 
        [[nodiscard]] 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]] FrameSource* getPaintFrame() const { return paintFrame; }
 
        // VideoLayer
        void takeRawScreenShot(unsigned height, const std::string& filename) override;
 
        [[nodiscard]] CliComm& getCliComm();
 
private:
        // Observer<Setting> interface:
        void update(const Setting& setting) noexcept override;
 
        // Schedulable
        void executeUntil(EmuTime::param time) override;
 
        [[nodiscard]] static unsigned getLineWidth(FrameSource* frame, unsigned y, unsigned step);
 
        void initBuffers();
        void createRegions();
        void uploadFrame();
        void uploadBlock(unsigned srcStartY, unsigned srcEndY,
                         unsigned lineWidth);
 
        void preCalcNoise(float factor);
        void drawNoise() const;
        void drawGlow(int glow);
 
        void preCalcMonitor3D(float width);
        void drawMonitor3D() const;
 
private:
        Display& display;
        RenderSettings& renderSettings;
        EventDistributor& eventDistributor;
 
        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
 
        const bool canDoInterlace;
 
        EmuTime lastRotate;
        std::unique_ptr<GLScaler> currScaler;
 
        struct StoredFrame {
                gl::ivec2 size; // (re)allocate when window size changes
                gl::Texture tex;
                gl::FrameBufferObject fbo;
        };
        std::array<StoredFrame, 2> renderedFrames;
 
        // Noise effect:
        gl::Texture noiseTextureA{true, true}; // interpolate + wrap
        gl::Texture noiseTextureB{true, true};
        float noiseX = 0.0f, noiseY = 0.0f;
 
        struct TextureData {
                gl::ColorTexture tex;
                [[nodiscard]] unsigned width() const { return tex.getWidth(); }
        };
        std::vector<TextureData> textures;
        gl::PixelBuffer<unsigned> pbo;
 
        gl::ColorTexture superImposeTex;
 
        struct Region {
                Region(unsigned srcStartY_, unsigned srcEndY_,
                       unsigned dstStartY_, unsigned dstEndY_,
                       unsigned lineWidth_)
                        : srcStartY(srcStartY_)
                        , srcEndY(srcEndY_)
                        , dstStartY(dstStartY_)
                        , dstEndY(dstEndY_)
                        , lineWidth(lineWidth_) {}
                unsigned srcStartY;
                unsigned srcEndY;
                unsigned dstStartY;
                unsigned dstEndY;
                unsigned lineWidth;
        };
        std::vector<Region> regions;
 
        unsigned frameCounter = 0;
 
        RenderSettings::ScaleAlgorithm scaleAlgorithm = RenderSettings::ScaleAlgorithm::NO;
 
        gl::ShaderProgram monitor3DProg;
        gl::BufferObject arrayBuffer;
        gl::BufferObject elementBuffer;
        gl::BufferObject vbo;
        gl::BufferObject stretchVBO;
 
        bool storedFrame = false;
};
 
} // namespace openmsx
 
#endif // GLPOSTPROCESSOR_HH