audiomarker.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <functional>
#include <promeki/namespace.h>
#include <promeki/datastream.h>
#include <promeki/enums.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/result.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioMarker {
        public:
                AudioMarker() = default;
 
                AudioMarker(int64_t offset, int64_t length, AudioMarkerType type)
                    : _offset(offset), _length(length), _type(type) {}
 
                int64_t        offset() const { return _offset; }
 
                void           setOffset(int64_t v) { _offset = v; }
 
                int64_t        length() const { return _length; }
 
                void           setLength(int64_t v) { _length = v; }
 
                AudioMarkerType type() const { return _type; }
 
                void            setType(AudioMarkerType v) { _type = v; }
 
                bool operator==(const AudioMarker &o) const {
                        return _offset == o._offset && _length == o._length && _type == o._type;
                }
                bool operator!=(const AudioMarker &o) const { return !(*this == o); }
 
                String toString() const {
                        if (_length == 0) {
                                return _type.valueName() + "@" + String::number(_offset);
                        }
                        return _type.valueName() + "@" + String::number(_offset) + "+" + String::number(_length);
                }
 
                static Result<AudioMarker> fromString(const String &str) {
                        size_t at = str.find('@');
                        if (at == String::npos) return makeError<AudioMarker>(Error::Invalid);
                        String typeName = str.substr(0, at);
                        String tail     = str.substr(at + 1);
                        size_t plus     = tail.find('+');
                        String offsetStr;
                        String lengthStr;
                        if (plus == String::npos) {
                                offsetStr = tail;
                                lengthStr = String("0");
                        } else {
                                offsetStr = tail.substr(0, plus);
                                lengthStr = tail.substr(plus + 1);
                        }
                        Error   ce;
                        int64_t offset = offsetStr.to<int64_t>(&ce);
                        if (ce.isError()) return makeError<AudioMarker>(Error::Invalid);
                        int64_t length = lengthStr.to<int64_t>(&ce);
                        if (ce.isError()) return makeError<AudioMarker>(Error::Invalid);
                        AudioMarkerType t(typeName);
                        if (!t.hasListedValue()) return makeError<AudioMarker>(Error::Invalid);
                        return makeResult(AudioMarker(offset, length, t));
                }
 
        private:
                int64_t         _offset = 0;
                int64_t         _length = 0;
                AudioMarkerType _type;
};
 
class AudioMarkerList {
                PROMEKI_SHARED_FINAL(AudioMarkerList)
        public:
                PROMEKI_DATATYPE(AudioMarkerList, DataTypeAudioMarkerList, 1)
 
                
                using Entry = AudioMarker;
 
                using EntryList = ::promeki::List<Entry>;
 
                using List = ::promeki::List<AudioMarkerList>;
 
                using Ptr = SharedPtr<AudioMarkerList>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                AudioMarkerList() = default;
 
                explicit AudioMarkerList(EntryList entries) : _entries(std::move(entries)) {}
 
                AudioMarkerList(std::initializer_list<Entry> il) : _entries(il) {}
 
                const EntryList &entries() const { return _entries; }
 
                void             setEntries(EntryList entries) { _entries = std::move(entries); }
 
                void             append(const Entry &e) { _entries.pushToBack(e); }
 
                void             append(int64_t offset, int64_t length, AudioMarkerType type) {
                        _entries.pushToBack(Entry(offset, length, type));
                }
 
                size_t           size() const { return _entries.size(); }
 
                bool             isEmpty() const { return _entries.isEmpty(); }
 
                void             clear() { _entries.clear(); }
 
                int64_t          totalLengthFor(AudioMarkerType type) const {
                        int64_t sum = 0;
                        for (const auto &e : _entries) {
                                if (e.type() == type) sum += e.length();
                        }
                        return sum;
                }
 
                size_t           countFor(AudioMarkerType type) const {
                        size_t n = 0;
                        for (const auto &e : _entries) {
                                if (e.type() == type) ++n;
                        }
                        return n;
                }
 
                String toString() const {
                        if (_entries.isEmpty()) return String();
                        String out;
                        bool   first = true;
                        for (const auto &e : _entries) {
                                if (!first) out += ", ";
                                out += e.toString();
                                first = false;
                        }
                        return out;
                }
 
                static Result<AudioMarkerList> fromString(const String &str) {
                        String trimmed = str.trim();
                        if (trimmed.isEmpty()) return makeResult(AudioMarkerList());
                        EntryList   entries;
                        StringList  parts = trimmed.split(",");
                        for (const auto &p : parts) {
                                String item = p.trim();
                                if (item.isEmpty()) continue;
                                auto r = AudioMarker::fromString(item);
                                if (error(r).isError()) return makeError<AudioMarkerList>(Error::Invalid);
                                entries.pushToBack(value(r));
                        }
                        return makeResult(AudioMarkerList(std::move(entries)));
                }
 
                bool operator==(const AudioMarkerList &o) const { return _entries == o._entries; }
                bool operator!=(const AudioMarkerList &o) const { return !(*this == o); }
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<AudioMarkerList> readFromStream(DataStream &s);
 
        private:
                EntryList _entries;
};
 
inline Error AudioMarkerList::writeToStream(DataStream &s) const {
        s << static_cast<uint32_t>(size());
        for (const auto &e : entries()) {
                s << static_cast<int64_t>(e.offset());
                s << static_cast<int64_t>(e.length());
                s << static_cast<int32_t>(e.type().value());
        }
        return s.status() == DataStream::Ok ? Error::Ok : s.toError();
}
 
template <>
inline Result<AudioMarkerList> AudioMarkerList::readFromStream<1>(DataStream &s) {
        uint32_t count = 0;
        s >> count;
        if (s.status() != DataStream::Ok) return makeError<AudioMarkerList>(s.toError());
        AudioMarkerList::EntryList entries;
        entries.reserve(count);
        for (uint32_t i = 0; i < count && s.status() == DataStream::Ok; ++i) {
                int64_t offset    = 0;
                int64_t length    = 0;
                int32_t typeValue = 0;
                s >> offset >> length >> typeValue;
                entries.pushToBack(AudioMarker(offset, length, AudioMarkerType(typeValue)));
        }
        if (s.status() != DataStream::Ok) return makeError<AudioMarkerList>(s.toError());
        return makeResult(AudioMarkerList(std::move(entries)));
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::AudioMarker);
PROMEKI_FORMAT_VIA_TOSTRING(promeki::AudioMarkerList);
 
template <> struct std::hash<promeki::AudioMarker> {
                size_t operator()(const promeki::AudioMarker &m) const noexcept {
                        size_t h = std::hash<int64_t>()(m.offset());
                        size_t l = std::hash<int64_t>()(m.length());
                        size_t t = std::hash<int32_t>()(m.type().value());
                        size_t combined = l ^ (t + 0x9e3779b97f4a7c15ULL + (l << 6) + (l >> 2));
                        return h ^ (combined + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2));
                }
};
 
template <> struct std::hash<promeki::AudioMarkerList> {
                size_t operator()(const promeki::AudioMarkerList &v) const noexcept {
                        size_t h = 0;
                        for (const auto &e : v.entries()) {
                                size_t s = std::hash<promeki::AudioMarker>()(e);
                                h        = h ^ (s + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2));
                        }
                        return h;
                }
};
 
#endif // PROMEKI_ENABLE_PROAV