FrameSource.hh

Go to the documentation of this file.

#ifndef FRAMESOURCE_HH
#define FRAMESOURCE_HH
 
#include "aligned.hh"
#include "narrow.hh"
#include "xrange.hh"
#include <algorithm>
#include <array>
#include <cassert>
#include <concepts>
#include <span>
 
namespace openmsx {
 
class PixelFormat;
 
class FrameSource
{
public:
        enum FieldType {
                FIELD_NONINTERLACED,
                FIELD_EVEN,
                FIELD_ODD
        };
 
        void init(FieldType fieldType_) { fieldType = fieldType_; }
 
        [[nodiscard]] FieldType getField() const {
                return fieldType;
        }
 
        [[nodiscard]] unsigned getHeight() const {
                return height;
        }
 
        [[nodiscard]] virtual unsigned getLineWidth(unsigned line) const = 0;
 
        [[nodiscard]] unsigned getWidth() const {
                assert(height > 0);
                unsigned result = getLineWidth(0);
                for (auto line : xrange(1u, height)) {
                        assert(result == getLineWidth(line)); (void)line;
                }
                return result;
        }
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] inline Pixel getLineColor(unsigned line) const {
                ALIGNAS_SSE std::array<Pixel, 1280> buf; // large enough for widest line
                unsigned width; // not used
                return reinterpret_cast<const Pixel*>(
                        getLineInfo(line, width, buf.data(), 1280))[0];
        }
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] inline std::span<const Pixel> getLine(int line, std::span<Pixel> buf) const
        {
                line = std::clamp(line, 0, narrow<int>(getHeight() - 1));
                unsigned internalWidth;
                auto* internalData = reinterpret_cast<const Pixel*>(
                        getLineInfo(line, internalWidth, buf.data(), narrow<unsigned>(buf.size())));
                if (internalWidth == narrow<unsigned>(buf.size())) {
                        return std::span{internalData, buf.size()};
                } else {
                        // slow path, non-inlined
                        // internalData might be equal to buf
                        scaleLine(std::span{internalData, internalWidth}, buf);
                        return buf;
                }
        }
 
        [[nodiscard]] virtual const void* getLineInfo(
                unsigned line, unsigned& lineWidth,
                void* buf, unsigned bufWidth) const = 0;
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] std::span<const Pixel, 320> getLinePtr320_240(unsigned line, std::span<Pixel, 320> buf) const;
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] std::span<const Pixel, 640> getLinePtr640_480(unsigned line, std::span<Pixel, 640> buf) const;
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] std::span<const Pixel, 960> getLinePtr960_720(unsigned line, std::span<Pixel, 960> buf) const;
 
        [[nodiscard]] const PixelFormat& getPixelFormat() const {
                return pixelFormat;
        }
 
protected:
        explicit FrameSource(const PixelFormat& format);
        ~FrameSource() = default;
 
        void setHeight(unsigned height_) { height = height_; }
 
        [[nodiscard]] virtual bool hasContiguousStorage() const {
                return false;
        }
 
        template<std::unsigned_integral Pixel> void scaleLine(
                std::span<const Pixel> in, std::span<Pixel> out) const;
 
private:
        const PixelFormat& pixelFormat;
 
        unsigned height;
 
        FieldType fieldType;
};
 
} // namespace openmsx
 
#endif // FRAMESOURCE_HH