mediaduration.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <iterator>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/framenumber.h>
#include <promeki/framecount.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class MediaDuration {
        public:
                PROMEKI_DATATYPE(MediaDuration, DataTypeMediaDuration, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<MediaDuration> readFromStream(DataStream &s);
 
                struct FrameRange {
                                FrameNumber start; 
                                FrameNumber end;   
 
                                class Iterator {
                                        public:
                                                using iterator_category = std::forward_iterator_tag;
                                                using value_type = FrameNumber;
                                                using difference_type = std::ptrdiff_t;
                                                using pointer = const FrameNumber *;
                                                using reference = const FrameNumber &;
 
                                                Iterator() = default;
                                                explicit Iterator(const FrameNumber &v) : _cur(v) {}
 
                                                reference operator*() const { return _cur; }
                                                pointer   operator->() const { return &_cur; }
                                                Iterator &operator++() {
                                                        ++_cur;
                                                        return *this;
                                                }
                                                Iterator operator++(int) {
                                                        Iterator o = *this;
                                                        ++_cur;
                                                        return o;
                                                }
                                                bool operator==(const Iterator &other) const {
                                                        return _cur == other._cur;
                                                }
                                                bool operator!=(const Iterator &other) const {
                                                        return _cur != other._cur;
                                                }
 
                                        private:
                                                FrameNumber _cur;
                                };
 
                                FrameRange() = default;
 
                                FrameRange(const FrameNumber &s, const FrameNumber &e) : start(s), end(e) {}
 
                                bool isValid() const {
                                        return start.isValid() && end.isValid() && end.value() >= start.value();
                                }
 
                                FrameCount count() const {
                                        if (!isValid()) return FrameCount::unknown();
                                        return FrameCount(end.value() - start.value() + 1);
                                }
 
                                bool contains(const FrameNumber &frame) const {
                                        if (!isValid() || !frame.isValid()) return false;
                                        return frame.value() >= start.value() && frame.value() <= end.value();
                                }
 
                                bool operator==(const FrameRange &other) const {
                                        return start == other.start && end == other.end;
                                }
                                bool operator!=(const FrameRange &other) const { return !(*this == other); }
 
                                FrameRange &shift(int64_t n) {
                                        start += n;
                                        end += n;
                                        return *this;
                                }
 
                                FrameRange &operator+=(int64_t n) { return shift(n); }
                                FrameRange &operator-=(int64_t n) { return shift(-n); }
 
                                friend FrameRange operator+(FrameRange r, int64_t n) {
                                        r.shift(n);
                                        return r;
                                }
                                friend FrameRange operator-(FrameRange r, int64_t n) {
                                        r.shift(-n);
                                        return r;
                                }
 
                                friend Iterator begin(const FrameRange &r) { return Iterator(r.start); }
 
                                friend Iterator end(const FrameRange &r) {
                                        if (!r.isValid()) return Iterator(r.start);
                                        return Iterator(FrameNumber(r.end.value() + 1));
                                }
                };
 
                static Result<MediaDuration> fromString(const String &str);
 
                static MediaDuration fromFrameRange(const FrameRange &range) {
                        return MediaDuration(range.start, range.count());
                }
 
                MediaDuration() = default;
 
                MediaDuration(const FrameNumber &start, const FrameCount &length) : _start(start), _length(length) {}
 
                bool isValid() const { return _start.isValid() && _length.isValid(); }
 
                bool isUnknown() const { return _start.isUnknown() || _length.isUnknown(); }
 
                bool isInfinite() const { return _length.isInfinite(); }
 
                bool isEmpty() const { return _length.isEmpty(); }
 
                const FrameNumber &start() const { return _start; }
 
                const FrameCount &length() const { return _length; }
 
                void setStart(const FrameNumber &s) { _start = s; }
 
                void setLength(const FrameCount &c) { _length = c; }
 
                void setEnd(const FrameNumber &e);
 
                FrameNumber end() const;
 
                bool contains(const FrameNumber &frame) const;
 
                void addToStart(int64_t n) { _start += n; }
 
                void addToEnd(int64_t n) { _length += n; }
 
                MediaDuration &operator+=(const FrameCount &c) {
                        _length += c;
                        return *this;
                }
                MediaDuration &operator-=(const FrameCount &c) {
                        _length -= c;
                        return *this;
                }
 
                Result<FrameRange> toFrameRange() const;
 
                bool operator==(const MediaDuration &other) const {
                        return _start == other._start && _length == other._length;
                }
                bool operator!=(const MediaDuration &other) const { return !(*this == other); }
 
                bool operator<(const MediaDuration &other) const {
                        if (isUnknown() || other.isUnknown()) return false;
                        if (_start != other._start) return _start < other._start;
                        return _length < other._length;
                }
                bool operator<=(const MediaDuration &other) const {
                        if (isUnknown() || other.isUnknown()) return false;
                        return *this == other || *this < other;
                }
                bool operator>(const MediaDuration &other) const { return other < *this; }
                bool operator>=(const MediaDuration &other) const {
                        if (isUnknown() || other.isUnknown()) return false;
                        return *this == other || other < *this;
                }
 
                bool contains(const MediaDuration &other) const;
 
                bool overlaps(const MediaDuration &other) const;
 
                MediaDuration intersect(const MediaDuration &other) const;
 
                bool canAppend(const MediaDuration &other) const;
 
                Error append(const MediaDuration &other);
 
                bool canPrepend(const MediaDuration &other) const;
 
                Error prepend(const MediaDuration &other);
 
                String toString() const;
 
                operator String() const { return toString(); }
 
        private:
                FrameNumber _start;
                FrameCount  _length;
};
 
inline MediaDuration operator+(MediaDuration d, const FrameCount &c) {
        d += c;
        return d;
}
inline MediaDuration operator-(MediaDuration d, const FrameCount &c) {
        d -= c;
        return d;
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::MediaDuration);
 
template <> struct std::hash<promeki::MediaDuration> {
                size_t operator()(const promeki::MediaDuration &v) const noexcept {
                        size_t h = std::hash<promeki::FrameNumber>()(v.start());
                        size_t k = std::hash<promeki::FrameCount>()(v.length());
                        // Standard boost::hash_combine mix.
                        return h ^ (k + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2));
                }
};
 
template <> struct std::hash<promeki::MediaDuration::FrameRange> {
                size_t operator()(const promeki::MediaDuration::FrameRange &v) const noexcept {
                        size_t h = std::hash<promeki::FrameNumber>()(v.start);
                        size_t k = std::hash<promeki::FrameNumber>()(v.end);
                        return h ^ (k + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2));
                }
};
 
#endif // PROMEKI_ENABLE_CORE