FrameSource.hh

Go to the documentation of this file.

#ifndef FRAMESOURCE_HH
#define FRAMESOURCE_HH

#include "noncopyable.hh"
#include <algorithm>
#include <vector>
#include <cassert>

struct SDL_PixelFormat;

namespace openmsx {

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

        virtual ~FrameSource();

        void init(FieldType fieldType);

        FieldType getField() const {
                return fieldType;
        }

        unsigned getHeight() const {
                return height;
        }

        virtual unsigned getLineWidth(unsigned line) const = 0;

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

        template <typename Pixel>
        inline const Pixel* getLinePtr(unsigned line) const {
                unsigned dummy;
                return reinterpret_cast<const Pixel*>(getLineInfo(line, dummy));
        }

        template <typename Pixel>
        inline const Pixel* getLinePtr(int line, unsigned width) const
        {
                line = std::min<unsigned>(std::max(0, line), getHeight() - 1);
                unsigned internalWidth;
                auto internalData = reinterpret_cast<const Pixel*>(
                        getLineInfo(line, internalWidth));
                if (internalWidth == width) {
                        return internalData;
                } else {
                        // slow path, non-inlined
                        return scaleLine(internalData, internalWidth, width);
                }
        }

        template <typename Pixel>
        inline const Pixel* getMultiLinePtr(
                int line, unsigned numLines, unsigned& actualLines,
                unsigned width) const
        {
                actualLines = 1;
                int height = getHeight();
                if ((line < 0) || (height <= line)) {
                        return getLinePtr<Pixel>(line, width);
                }
                unsigned internalWidth;
                auto internalData = reinterpret_cast<const Pixel*>(
                        getLineInfo(line, internalWidth));
                if (internalWidth != width) {
                        return scaleLine(internalData, internalWidth, width);
                }
                if (!hasContiguousStorage()) {
                        return internalData;
                }
                while (--numLines) {
                        ++line;
                        if ((line == height) || (getLineWidth(line) != width)) {
                                break;
                        }
                        ++actualLines;
                }
                return internalData;
        }

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

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

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

        virtual unsigned getRowLength() const {
                return 0;
        }

        void freeLineBuffers() const;

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

        // Used by SuperImposedFrame.
        // TODO refactor
        void* getTempBuffer() const;

protected:
        explicit FrameSource(const SDL_PixelFormat& format);

        void setHeight(unsigned height);

        virtual const void* getLineInfo(unsigned line, unsigned& width) const = 0;

        virtual bool hasContiguousStorage() const {
                return false;
        }

        // TODO: I don't understand why I need to declare a subclass as friend
        //       to give it access to a protected method, but without this
        //       GCC 3.3.5-pre will not compile it.
        friend class DeinterlacedFrame;
        friend class DoubledFrame;

private:
        template <typename Pixel> const Pixel* scaleLine(
                const Pixel* in, unsigned inWidth, unsigned outWidth) const;
        template <typename Pixel> const Pixel* blendLines(
                const Pixel* line1, const Pixel* line2, unsigned width) const;

        const SDL_PixelFormat& pixelFormat;

        unsigned height;

        FieldType fieldType;
        mutable std::vector<void*> tempBuffers;
        mutable unsigned tempCounter;
};

} // namespace openmsx

#endif // FRAMESOURCE_HH