1/*
2 * Copyright (c) 2021-2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#ifndef HISTREAMER_PLUGIN_COMMON_CAPS_H
17#define HISTREAMER_PLUGIN_COMMON_CAPS_H
18
19#include <utility>
20#include <vector> // NOLINT: used it
21#include "plugin_tags.h"
22
23namespace OHOS {
24namespace Media {
25namespace Plugin {
26/// Indicates that the available capability type is an fixed value.
27template <typename T> using FixedCapability = T;
28
29/// Indicates that the available capability type is an interval value.
30template <typename T> using IntervalCapability  = std::pair<T, T>;
31
32/// Indicates that the available capability types are discrete values.
33template <typename T> using DiscreteCapability = std::vector<T>;
34
35/**
36 * @brief The Capability describes the input and output capabilities of the plugin.
37 *
38 * It is basically a set of tags attached to the mime-type in order to
39 * describe the mime-type more closely.
40 *
41 * @since 1.0
42 * @version 1.0
43 */
44struct Capability {
45    /**
46     * @enum Capability ID is used to describe plugin capabilities or support capability matching.
47     * All Capability ID must come from Tag.
48     *
49     * For details about the definition and usage, to see enum Tag in file plugin_tags.h.
50     *
51     * @since 1.0
52     * @version 1.0
53     */
54    enum struct Key : uint32_t {
55        MEDIA_BITRATE = static_cast<uint32_t>(Tag::MEDIA_BITRATE),
56        AUDIO_SAMPLE_RATE = static_cast<uint32_t>(Tag::AUDIO_SAMPLE_RATE),
57        AUDIO_CHANNELS = static_cast<uint32_t>(Tag::AUDIO_CHANNELS),
58        AUDIO_CHANNEL_LAYOUT = static_cast<uint32_t>(Tag::AUDIO_CHANNEL_LAYOUT),
59        AUDIO_SAMPLE_FORMAT = static_cast<uint32_t>(Tag::AUDIO_SAMPLE_FORMAT),
60        AUDIO_MPEG_VERSION = static_cast<uint32_t>(Tag::AUDIO_MPEG_VERSION),
61        AUDIO_MPEG_LAYER = static_cast<uint32_t>(Tag::AUDIO_MPEG_LAYER),
62        AUDIO_AAC_PROFILE = static_cast<uint32_t>(Tag::AUDIO_AAC_PROFILE),
63        AUDIO_AAC_LEVEL = static_cast<uint32_t>(Tag::AUDIO_AAC_LEVEL),
64        AUDIO_AAC_STREAM_FORMAT = static_cast<uint32_t>(Tag::AUDIO_AAC_STREAM_FORMAT),
65        VIDEO_PIXEL_FORMAT = static_cast<uint32_t>(Tag::VIDEO_PIXEL_FORMAT),
66        VIDEO_BIT_STREAM_FORMAT = static_cast<uint32_t>(Tag::VIDEO_BIT_STREAM_FORMAT),
67    };
68
69    /// Used to store the capability in the key-value format.
70    using KeyMap = std::map<Key, ValueType>;
71
72    /// default constructor
73    Capability() = default;
74
75    /**
76     * @brief constructor one capability with mime of m
77     *
78     * @param m mime string
79     */
80    explicit Capability(std::string  m):mime(std::move(m)){}
81
82    /**
83     * @brief Append one fix key into KeyMap
84     *
85     * @tparam T type of value
86     * @param key Capability::Key
87     * @param val value
88     * @return reference of object
89     */
90    template<typename T>
91    Capability& AppendFixedKey(Key key, const T& val)
92    {
93        keys[key] = val;
94        return *this;
95    }
96
97    /**
98     * @brief Append one interval key i.e. [rangeStart, rangeEnd] into KeyMap
99     *
100     * @tparam T type of value
101     * @param key Capability::Key
102     * @param rangeStart range start
103     * @param rangeEnd rang end
104     * @return reference of object
105     */
106    template<typename T>
107    Capability& AppendIntervalKey(Key key, const T& rangeStart, const T& rangeEnd)
108    {
109        keys[key] = std::make_pair(rangeStart, rangeEnd);
110        return *this;
111    }
112
113    /**
114     * @brief Append one discrete key i.e. {val1, val2, ....} into KeyMap
115     *
116     * @tparam T type of value
117     * @param key Capability::Key
118     * @param discreteValues values
119     * @return reference of object
120     */
121    template<typename T>
122    Capability& AppendDiscreteKeys(Key key, DiscreteCapability<T> discreteValues)
123    {
124        keys[key] = std::move(discreteValues);
125        return *this;
126    }
127
128    /**
129     * @brief set mime of this capability
130     *
131     * @param val mime value
132     * @return reference of object
133     */
134    Capability& SetMime(std::string val)
135    {
136        mime = std::move(val);
137        return *this;
138    }
139
140    /// mime of capability. For details, see {@link constants.h}
141    std::string mime;
142
143    /// Store the parameters(Capability::Key, value pairs), which should be negotiated
144    KeyMap keys;
145};
146
147/// A collection of multiple capabilities
148using CapabilitySet = std::vector<Capability>;
149} // namespace Plugin
150} // namespace Media
151} // namespace OHOS
152#endif // HISTREAMER_PLUGIN_COMMON_CAPS_H
153