motionband.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/array.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/color.h>
#include <promeki/imagedesc.h>
#include <promeki/mediaioallocator.h>
#include <promeki/uncompressedvideopayload.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MotionBand {
        public:
                enum Position {
                        Bottom = 0, 
                        Top    = 1  
                };
 
                static constexpr int DefaultHeight = 16;
 
                MotionBand();
 
                ~MotionBand();
 
                MotionBand(const MotionBand &) = delete;
                MotionBand &operator=(const MotionBand &) = delete;
 
                bool enabled() const { return _enabled; }
 
                void setEnabled(bool val);
 
                int height() const { return _height; }
 
                void setHeight(int lines);
 
                int sequenceLength() const { return _sequenceLength; }
 
                void setSequenceLength(int frames);
 
                int offset() const { return _offset; }
 
                void setOffset(int frames);
 
                Position position() const { return _position; }
 
                void setPosition(Position p);
 
                int borderWidth() const { return _borderWidth; }
 
                void setBorderWidth(int pixels);
 
                const Color &backgroundColor() const { return _backgroundColor; }
 
                void setBackgroundColor(const Color &c);
 
                const Color &markerColor() const { return _markerColor; }
 
                void setMarkerColor(const Color &c);
 
                const Color &borderColor() const { return _borderColor; }
 
                void setBorderColor(const Color &c);
 
                int reservedLines() const { return _enabled ? _height : 0; }
 
                Error apply(UncompressedVideoPayload &inout, uint64_t frameCount) const;
 
                void setAllocator(MediaIOAllocator::Ptr allocator);
 
                MediaIOAllocator::Ptr allocator() const { return _allocator; }
 
                void invalidateCache() const;
 
        private:
                bool     _enabled = false;
                int      _height = DefaultHeight;
                int      _sequenceLength = 0;
                int      _offset = 0;
                Position _position = Position::Bottom;
                int      _borderWidth = 4;
                Color    _backgroundColor;
                Color    _markerColor;
                Color    _borderColor;
 
                MediaIOAllocator::Ptr _allocator;
 
                // Cache: one slot per cycle frame, lazily filled on
                // first request.  All slots are sized to the same
                // (imageWidth x effectiveHeight) and rendered in the
                // descriptor's pixel format so apply() is just a
                // plane-by-plane memcpy.
                mutable List<UncompressedVideoPayload::Ptr> _cache;
                mutable size_t                              _cacheImgWidth = 0;
                mutable size_t                              _cacheImgHeight = 0;
                mutable int                                 _cachePixelFormatId = 0;
                mutable int                                 _cacheEffectiveHeight = 0;
 
                int effectiveBandHeight(const ImageDesc &target) const;
 
                UncompressedVideoPayload::Ptr cachedFrame(int frameInCycle, const ImageDesc &target) const;
 
                void renderFrame(UncompressedVideoPayload &out, int frameInCycle) const;
 
                ImageDesc rgbScratchDesc(const ImageDesc &target, int bandHeight) const;
 
                ImageDesc bandDesc(const ImageDesc &target, int bandHeight) const;
 
                int bandTopY(const ImageDesc &target, int bandHeight) const;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV