audiochannelmap.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/list.h>
#include <promeki/pair.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/error.h>
#include <promeki/datastream.h>
#include <promeki/enums_audio.h>
#include <promeki/audiostreamdesc.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioChannelMap {
                PROMEKI_SHARED_FINAL(AudioChannelMap)
        public:
                PROMEKI_DATATYPE(AudioChannelMap, DataTypeAudioChannelMap, 1)
 
                
                using Entry = Pair<AudioStreamDesc, ChannelRole>;
 
                using EntryList = ::promeki::List<Entry>;
 
                using List = ::promeki::List<AudioChannelMap>;
 
                using Ptr = SharedPtr<AudioChannelMap>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                using ChannelRoleList = ::promeki::List<ChannelRole>;
 
                struct WellKnownLayout {
                                String          name;
                                ChannelRoleList roles;
                };
 
                using WellKnownLayoutList = ::promeki::List<WellKnownLayout>;
 
                static WellKnownLayoutList wellKnownLayouts();
 
                static Result<AudioChannelMap> fromString(const String &str);
 
                static AudioChannelMap defaultForChannels(size_t channels);
 
                static AudioChannelMap defaultForChannels(size_t channels, const AudioStreamDesc &stream);
 
                AudioChannelMap() = default;
 
                explicit AudioChannelMap(ChannelRoleList roles) {
                        _entries.reserve(roles.size());
                        for (const ChannelRole &r : roles) _entries.pushToBack(Entry(AudioStreamDesc(), r));
                }
 
                AudioChannelMap(std::initializer_list<ChannelRole> roles) {
                        _entries.reserve(roles.size());
                        for (const ChannelRole &r : roles) _entries.pushToBack(Entry(AudioStreamDesc(), r));
                }
 
                AudioChannelMap(const AudioStreamDesc &stream, ChannelRoleList roles) {
                        _entries.reserve(roles.size());
                        for (const ChannelRole &r : roles) _entries.pushToBack(Entry(stream, r));
                }
 
                AudioChannelMap(const AudioStreamDesc &stream, std::initializer_list<ChannelRole> roles) {
                        _entries.reserve(roles.size());
                        for (const ChannelRole &r : roles) _entries.pushToBack(Entry(stream, r));
                }
 
                explicit AudioChannelMap(EntryList entries) : _entries(std::move(entries)) {}
 
                AudioChannelMap(std::initializer_list<Entry> entries) : _entries(entries) {}
 
                bool isValid() const { return !_entries.isEmpty(); }
 
                size_t channels() const { return _entries.size(); }
 
                const EntryList &entries() const { return _entries; }
 
                ChannelRole role(size_t index) const {
                        if (index >= _entries.size()) return ChannelRole::Unused;
                        return _entries[index].second();
                }
 
                AudioStreamDesc stream(size_t index) const {
                        if (index >= _entries.size()) return AudioStreamDesc();
                        return _entries[index].first();
                }
 
                Entry entry(size_t index) const {
                        if (index >= _entries.size()) return Entry(AudioStreamDesc(), ChannelRole::Unused);
                        return _entries[index];
                }
 
                void setRole(size_t index, const ChannelRole &role);
 
                void setStream(size_t index, const AudioStreamDesc &stream);
 
                void setEntry(size_t index, const AudioStreamDesc &stream, const ChannelRole &role);
 
                int indexOf(const ChannelRole &role) const;
 
                int indexOf(const AudioStreamDesc &stream, const ChannelRole &role) const;
 
                bool contains(const ChannelRole &role) const { return indexOf(role) >= 0; }
 
                bool isSingleStream() const;
 
                AudioStreamDesc commonStream() const;
 
                String wellKnownName() const;
 
                bool isWellKnown() const { return !wellKnownName().isEmpty(); }
 
                String toString() const;
 
                String toSt2110ChannelOrder() const;
 
                static Result<AudioChannelMap> fromSt2110ChannelOrder(const String &value);
 
                bool operator==(const AudioChannelMap &o) const { return _entries == o._entries; }
                bool operator!=(const AudioChannelMap &o) const { return !(*this == o); }
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<AudioChannelMap> readFromStream(DataStream &s);
 
        private:
                EntryList _entries;
};
 
inline Error AudioChannelMap::writeToStream(DataStream &s) const {
        s << static_cast<uint32_t>(channels());
        for (const auto &entry : entries()) {
                s << entry.first().name();
                s << static_cast<int32_t>(entry.second().value());
        }
        return s.status() == DataStream::Ok ? Error::Ok : s.toError();
}
 
template <>
inline Result<AudioChannelMap> AudioChannelMap::readFromStream<1>(DataStream &s) {
        uint32_t count = 0;
        s >> count;
        if (s.status() != DataStream::Ok) return makeError<AudioChannelMap>(s.toError());
        AudioChannelMap::EntryList entries;
        entries.reserve(count);
        for (uint32_t i = 0; i < count; ++i) {
                String  streamName;
                int32_t roleValue = 0;
                s >> streamName >> roleValue;
                AudioStreamDesc stream = (streamName.isEmpty() || streamName == "Undefined")
                                                 ? AudioStreamDesc()
                                                 : AudioStreamDesc(streamName);
                entries.pushToBack(AudioChannelMap::Entry(stream, ChannelRole(roleValue)));
        }
        if (s.status() != DataStream::Ok) return makeError<AudioChannelMap>(s.toError());
        return makeResult(AudioChannelMap(std::move(entries)));
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::AudioChannelMap);
 
template <> struct std::hash<promeki::AudioChannelMap> {
                size_t operator()(const promeki::AudioChannelMap &v) const noexcept {
                        size_t h = 0;
                        for (const auto &entry : v.entries()) {
                                size_t s = std::hash<promeki::AudioStreamDesc>()(entry.first());
                                size_t r = std::hash<promeki::ChannelRole>()(entry.second());
                                size_t combined = s ^ (r + 0x9e3779b97f4a7c15ULL + (s << 6) + (s >> 2));
                                h = h ^ (combined + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2));
                        }
                        return h;
                }
};
 
#endif // PROMEKI_ENABLE_PROAV