FrameSource.hh

Go to the documentation of this file.

#ifndef FRAMESOURCE_HH
#define FRAMESOURCE_HH

#include "aligned.hh"
#include <algorithm>
#include <cassert>

struct SDL_PixelFormat;

namespace openmsx {

class FrameSource
{
public:
        enum FieldType {
                FIELD_NONINTERLACED,
                FIELD_EVEN,
                FIELD_ODD
        };

        void init(FieldType fieldType_) { fieldType = fieldType_; }

        FieldType getField() const {
                return fieldType;
        }

        unsigned getHeight() const {
                return height;
        }

        virtual unsigned getLineWidth(unsigned line) const = 0;

        unsigned getWidth() const {
                assert(height > 0);
                unsigned result = getLineWidth(0);
                for (unsigned line = 1; line < height; ++line) {
                        assert(result == getLineWidth(line));
                }
                return result;
        }

        template <typename Pixel>
        inline Pixel getLineColor(unsigned line) const {
                SSE_ALIGNED(Pixel buf[1280]); // large enough for widest line
                unsigned width; // not used
                return reinterpret_cast<const Pixel*>(
                        getLineInfo(line, width, buf, 1280))[0];
        }

        template <typename Pixel>
        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 <typename Pixel>
        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;
        }

        virtual const void* getLineInfo(
                unsigned line, unsigned& lineWidth,
                void* buf, unsigned bufWidth) const = 0;

        template <typename Pixel>
        const Pixel* getLinePtr320_240(unsigned line, Pixel* buf) const;

        template <typename Pixel>
        const Pixel* getLinePtr640_480(unsigned line, Pixel* buf) const;

        template <typename Pixel>
        const Pixel* getLinePtr960_720(unsigned line, Pixel* buf) const;

        virtual unsigned getRowLength() const {
                return 0;
        }

        const SDL_PixelFormat& getSDLPixelFormat() const {
                return pixelFormat;
        }

protected:
        explicit FrameSource(const SDL_PixelFormat& format);
        ~FrameSource() = default;

        void setHeight(unsigned height_) { height = height_; }

        virtual bool hasContiguousStorage() const {
                return false;
        }

        template <typename Pixel> void scaleLine(
                const Pixel* in, Pixel* out,
                unsigned inWidth, unsigned outWidth) const;

private:
        const SDL_PixelFormat& pixelFormat;

        unsigned height;

        FieldType fieldType;
};

} // namespace openmsx

#endif // FRAMESOURCE_HH