FrameSource.hh

Go to the documentation of this file.

#ifndef FRAMESOURCE_HH
#define FRAMESOURCE_HH
 
#include "aligned.hh"
#include "xrange.hh"
#include <algorithm>
#include <cassert>
#include <concepts>
 
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 Pixel buf[1280]; // large enough for widest line
                unsigned width; // not used
                return reinterpret_cast<const Pixel*>(
                        getLineInfo(line, width, buf, 1280))[0];
        }
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] inline const Pixel* getLinePtr(int line, unsigned width, Pixel* buf) const
        {
                line = std::min<unsigned>(std::max(0, line), getHeight() - 1);
                unsigned internalWidth;
                auto* internalData = reinterpret_cast<const Pixel*>(
                        getLineInfo(line, internalWidth, buf, width));
                if (internalWidth == width) {
                        return internalData;
                } else {
                        // slow path, non-inlined
                        // internalData might be equal to buf
                        scaleLine(internalData, buf, internalWidth, width);
                        return buf;
                }
        }
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] inline const Pixel* getMultiLinePtr(
                int line, unsigned numLines, unsigned& actualLines,
                unsigned width, Pixel* buf) const
        {
                actualLines = 1;
                if ((line < 0) || (int(height) <= line)) {
                        return getLinePtr(line, width, buf);
                }
                unsigned internalWidth;
                auto* internalData = reinterpret_cast<const Pixel*>(
                        getLineInfo(line, internalWidth, buf, width));
                if (internalWidth != width) {
                        scaleLine(internalData, buf, internalWidth, width);
                        return buf;
                }
                if (!hasContiguousStorage()) {
                        return internalData;
                }
                while (--numLines) {
                        ++line;
                        if ((line == int(height)) || (getLineWidth(line) != width)) {
                                break;
                        }
                        ++actualLines;
                }
                return internalData;
        }
 
        [[nodiscard]] virtual const void* getLineInfo(
                unsigned line, unsigned& lineWidth,
                void* buf, unsigned bufWidth) const = 0;
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] const Pixel* getLinePtr320_240(unsigned line, Pixel* buf) const;
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] const Pixel* getLinePtr640_480(unsigned line, Pixel* buf) const;
 
        template<std::unsigned_integral Pixel>
        [[nodiscard]] const Pixel* getLinePtr960_720(unsigned line, Pixel* buf) const;
 
        [[nodiscard]] virtual unsigned getRowLength() const {
                return 0;
        }
 
        [[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(
                const Pixel* in, Pixel* out,
                unsigned inWidth, unsigned outWidth) const;
 
private:
        const PixelFormat& pixelFormat;
 
        unsigned height;
 
        FieldType fieldType;
};
 
} // namespace openmsx
 
#endif // FRAMESOURCE_HH