videotestpattern.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/color.h>
#include <promeki/imagedesc.h>
#include <promeki/mediaioallocator.h>
#include <promeki/uncompressedvideopayload.h>
#include <promeki/timecode.h>
#include <promeki/enums_tpg.h>
// PaintEngine is needed for the cached _cachedBgPixel member regardless of
// FreeType; fastfont.h used to pull it in transitively, so include it
// directly now that the FastFont include is feature-gated.
#include <promeki/paintengine.h>
#if PROMEKI_ENABLE_FREETYPE
#include <promeki/fastfont.h>
#endif
#include <promeki/motionband.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class UncompressedVideoPayload;
 
class VideoTestPattern {
        public:
                using Pattern = VideoPattern;
 
                VideoTestPattern();
 
                ~VideoTestPattern();
 
                VideoTestPattern(const VideoTestPattern &) = delete;
                VideoTestPattern &operator=(const VideoTestPattern &) = delete;
 
                Pattern pattern() const { return _pattern; }
 
                void setPattern(Pattern pattern);
 
                const Color &solidColor() const { return _solidColor; }
 
                void setSolidColor(const Color &color);
 
                // ---- Burn-in configuration ----
 
                bool burnEnabled() const { return _burnEnabled; }
 
                void setBurnEnabled(bool val) { _burnEnabled = val; }
 
                const String &burnFontFilename() const { return _burnFontFilename; }
 
                void setBurnFontFilename(const String &path);
 
                int burnFontSize() const { return _burnFontSize; }
 
                void setBurnFontSize(int px);
 
                const Color &burnTextColor() const { return _burnTextColor; }
 
                void setBurnTextColor(const Color &c);
 
                const Color &burnBackgroundColor() const { return _burnBackgroundColor; }
 
                void setBurnBackgroundColor(const Color &c);
 
                bool burnDrawBackground() const { return _burnDrawBackground; }
 
                void setBurnDrawBackground(bool val) { _burnDrawBackground = val; }
 
                BurnPosition burnPosition() const { return _burnPosition; }
 
                void setBurnPosition(BurnPosition pos) { _burnPosition = pos; }
 
                int burnTopReserved() const { return _burnTopReserved; }
 
                void setBurnTopReserved(int lines) { _burnTopReserved = (lines > 0) ? lines : 0; }
 
                SharedPtr<UncompressedVideoPayload, true, UncompressedVideoPayload>
                createPayload(const ImageDesc &desc, double motionOffset = 0.0,
                              const Timecode &currentTimecode = Timecode()) const;
 
                Error applyBurn(UncompressedVideoPayload &inout, const String &burnText) const;
 
                void render(UncompressedVideoPayload &img, double motionOffset = 0.0) const;
 
                void setAllocator(MediaIOAllocator::Ptr allocator);
 
                MediaIOAllocator::Ptr allocator() const { return _allocator; }
 
                // ---- Motion band ----
 
                MotionBand &motionBand() { return _motionBand; }
 
                const MotionBand &motionBand() const { return _motionBand; }
 
                Error applyMotionBand(UncompressedVideoPayload &inout, uint64_t frameCount) const {
                        return _motionBand.apply(inout, frameCount);
                }
 
        private:
                // Background pattern state
                VideoPattern _pattern = VideoPattern::ColorBars;
                Color        _solidColor;
 
                // Burn-in config
                bool   _burnEnabled = false;
                String _burnFontFilename;
                int    _burnFontSize = 36;
                // Effective font size actually passed to FastFont.
                // Equals _burnFontSize when that is > 0; when
                // _burnFontSize is 0 (auto) it is computed from the
                // rendered image height at renderBurn() time.  Tracked
                // separately so image-size changes can trigger a font
                // reconfigure via _burnFontConfigDirty.
                mutable int  _burnEffectiveFontSize = 36;
                Color        _burnTextColor = Color::White;
                Color        _burnBackgroundColor = Color::Black;
                bool         _burnDrawBackground = true;
                BurnPosition _burnPosition = BurnPosition::BottomCenter;
                int          _burnTopReserved = 0;
 
                // Generic image cache: a small fixed array of slots
                // shared by all patterns.  Slot meanings are local to
                // each pattern's branch in create() — for example
                // AvSync uses slot 0 for "white marker" and slot 1 for
                // "black non-marker", while a static pattern uses slot
                // 0 for its pre-rendered background.  Patterns are
                // mutually exclusive at any given time, so reusing the
                // same slot index across patterns is fine.
                //
                // Any change to _pattern, _solidColor, or the
                // requested ImageDesc dumps the entire cache; the next
                // create() call rebuilds whatever it needs.  Two
                // renderSolid() calls (the most expensive thing the
                // current patterns can do on a rebuild) are essentially
                // free, so a simpler dump-on-change policy is the right
                // tradeoff over per-key invalidation.
                static constexpr int CacheSlotCount = 2;
                mutable SharedPtr<UncompressedVideoPayload, true, UncompressedVideoPayload>
                               _cachedPayloads[CacheSlotCount];
                mutable size_t _cacheW = 0;
                mutable size_t _cacheH = 0;
                mutable int    _cachePixelFormatId = 0;
 
                // Optional allocator override.  Null = use
                // MediaIOAllocator::defaultAllocator() so freshly-
                // constructed VideoTestPatterns behave exactly as
                // before the allocator framework existed.
                MediaIOAllocator::Ptr _allocator;
 
                // Embedded motion band — parallel to burn-in.  Owns
                // its own pre-rendered cache of N band frames in the
                // target pixel format and stamps the appropriate one
                // into the frame from applyMotionBand().
                MotionBand _motionBand;
 
                // Burn font — lazily constructed the first time burn
                // actually runs, because FastFont needs a PaintEngine
                // (and thus a pixel format) at construction time.  Only
                // present when FreeType is compiled in; without it
                // @ref applyBurn returns @c Error::FontUnavailable.
#if PROMEKI_ENABLE_FREETYPE
                mutable FastFont::UPtr _burnFont;
#endif
                mutable bool           _burnFontConfigDirty = true;
 
                // Cached @ref PaintEngine::Pixel for @ref _burnBackgroundColor.
                // applyBurn() runs a single fillRect per frame; building
                // that pixel via @c PaintEngine::createPixel(Color) goes
                // through a Color::convert into the target colour model
                // (sRGB→Rec.709 YCbCr Limited on NV12 / YUV outputs),
                // which is non-trivial.  We cache it and invalidate
                // whenever the configured bg colour changes (see
                // @ref setBurnBackgroundColor) or the target pixel format
                // changes (detected via @ref _cachedBgPixelFormat).
                mutable PaintEngine::Pixel _cachedBgPixel;
                mutable PixelFormat        _cachedBgPixelFormat;
 
                bool isStaticPattern() const;
 
                template <typename Builder>
                SharedPtr<UncompressedVideoPayload, true, UncompressedVideoPayload>
                cachedPayload(int slotIndex, const ImageDesc &desc, Builder &&build) const {
                        if (_cacheW != desc.width() || _cacheH != desc.height() ||
                            _cachePixelFormatId != static_cast<int>(desc.pixelFormat().id())) {
                                invalidatePayloadCache();
                                _cacheW = desc.width();
                                _cacheH = desc.height();
                                _cachePixelFormatId = static_cast<int>(desc.pixelFormat().id());
                        }
                        auto &slot = _cachedPayloads[slotIndex];
                        if (!slot.isValid()) {
                                // Route allocation through the
                                // installed allocator (typically
                                // SystemCow when wired by TpgMediaIO).
                                // Null _allocator falls back to the
                                // process-wide default — no behaviour
                                // change for callers that never wire
                                // one up.
                                slot = _allocator.isValid() ? _allocator->allocateVideoPayload(desc)
                                                            : UncompressedVideoPayload::allocate(desc);
                                if (slot.isValid()) {
                                        build(slot);
                                        // Seal the cached payload so
                                        // subsequent ensureExclusive()
                                        // detaches a SystemCow-backed
                                        // buffer cheaply (MAP_PRIVATE
                                        // clone, not full-frame memcpy).
                                        // Default backends no-op.
                                        (void)slot->data().seal();
                                }
                        }
                        return slot;
                }
 
                void invalidatePayloadCache() const;
 
                void applyBurnFontConfig() const;
                void computeBurnPosition(int frameW, int frameH, int textW, int totalH, int ascender, int &x,
                                         int &y) const;
 
                ImageDesc rgbScratchDesc(const ImageDesc &target) const;
 
                void renderColorBars(UncompressedVideoPayload &img, double offset, bool full) const;
                void renderRamp(UncompressedVideoPayload &img, double offset) const;
                void renderGrid(UncompressedVideoPayload &img, double offset) const;
                void renderCrosshatch(UncompressedVideoPayload &img, double offset) const;
                void renderCheckerboard(UncompressedVideoPayload &img, double offset) const;
                void renderZonePlate(UncompressedVideoPayload &img, double phase) const;
                void renderNoise(UncompressedVideoPayload &img) const;
                void renderSolid(UncompressedVideoPayload &img, const Color &color) const;
                void renderColorChecker(UncompressedVideoPayload &img) const;
                void renderSMPTE219(UncompressedVideoPayload &img) const;
                void renderMultiBurst(UncompressedVideoPayload &img) const;
                void renderLimitRange(UncompressedVideoPayload &img) const;
                void renderCircularZone(UncompressedVideoPayload &img, double phase) const;
                void renderAlignment(UncompressedVideoPayload &img) const;
                void renderSDIPathological(UncompressedVideoPayload &img, bool isEQ) const;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV