framerate.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/duration.h>
#include <promeki/list.h>
#include <promeki/rational.h>
#include <promeki/result.h>
#include <promeki/string.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
#define PROMEKI_WELL_KNOWN_FRAME_RATES                                                                                 \
        X(FPS_Invalid, "INV", 0, 1)                                                                                    \
        X(FPS_120, "120", 120, 1)                                                                                      \
        X(FPS_119_88, "119.88", 120000, 1001)                                                                          \
        X(FPS_100, "100", 100, 1)                                                                                      \
        X(FPS_96, "96", 96, 1)                                                                                         \
        X(FPS_95_90, "95.90", 96000, 1001)                                                                             \
        X(FPS_60, "60", 60, 1)                                                                                         \
        X(FPS_59_94, "59.94", 60000, 1001)                                                                             \
        X(FPS_50, "50", 50, 1)                                                                                         \
        X(FPS_48, "48", 48, 1)                                                                                         \
        X(FPS_47_95, "47.95", 48000, 1001)                                                                             \
        X(FPS_30, "30", 30, 1)                                                                                         \
        X(FPS_29_97, "29.97", 30000, 1001)                                                                             \
        X(FPS_25, "25", 25, 1)                                                                                         \
        X(FPS_24, "24", 24, 1)                                                                                         \
        X(FPS_23_98, "23.98", 24000, 1001)
 
class FrameRate {
        public:
                PROMEKI_DATATYPE(FrameRate, DataTypeFrameRate, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<FrameRate> readFromStream(DataStream &s);
 
                using RationalType = Rational<unsigned int>;
 
#define X(type, string, num, den) type,
                enum WellKnownRate {
                        FPS_NotWellKnown = 0, 
                        PROMEKI_WELL_KNOWN_FRAME_RATES
                };
#undef X
 
                struct WellKnown; 
 
                static List<WellKnown> wellKnownRates();
 
                FrameRate() = default;
 
                FrameRate(WellKnownRate rate);
 
                FrameRate(const RationalType &r);
 
                bool isValid() const { return _fps.numerator() > 0; }
 
                unsigned int numerator() const { return _fps.numerator(); }
 
                unsigned int denominator() const { return _fps.denominator(); }
 
                double toDouble() const { return _fps.toDouble(); }
 
                static Result<FrameRate> fromDouble(double val);
 
                Duration frameDuration() const {
                        if (!isValid()) return Duration();
                        // Period in ns = denom * 1e9 / num.  Use 64-bit
                        // math so 1001 * 1e9 doesn't overflow.
                        int64_t num = static_cast<int64_t>(_fps.numerator());
                        int64_t den = static_cast<int64_t>(_fps.denominator());
                        int64_t ns = (den * INT64_C(1'000'000'000) + num / 2) / num;
                        return Duration::fromNanoseconds(ns);
                }
 
                int64_t cumulativeTicks(int64_t tickRate, int64_t frameIndex) const {
                        if (!isValid() || tickRate <= 0 || frameIndex < 0) return 0;
                        const int64_t num = static_cast<int64_t>(_fps.numerator());
                        const int64_t den = static_cast<int64_t>(_fps.denominator());
                        return (frameIndex * tickRate * den) / num;
                }
 
                size_t samplesPerFrame(int64_t sampleRate, int64_t frameIndex) const {
                        if (!isValid() || sampleRate <= 0 || frameIndex < 0) return 0;
                        const int64_t cumNow = cumulativeTicks(sampleRate, frameIndex);
                        const int64_t cumNext = cumulativeTicks(sampleRate, frameIndex + 1);
                        return static_cast<size_t>(cumNext - cumNow);
                }
 
                String toString() const { return _fps.toString(); }
 
                bool isWellKnownRate() const { return wellKnownRate() != FPS_NotWellKnown; }
 
                WellKnownRate wellKnownRate() const;
 
                const RationalType &rational() const { return _fps; }
 
                static Result<FrameRate> fromString(const String &str);
 
                bool operator==(const FrameRate &other) const { return _fps == other._fps; }
 
                bool operator!=(const FrameRate &other) const { return _fps != other._fps; }
 
        private:
                RationalType _fps;
};
 
struct FrameRate::WellKnown {
                String    label;
                FrameRate rate;
};
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::FrameRate);
 
#endif // PROMEKI_ENABLE_CORE